[Download Home] Displaying offline page bundle per day

chrome/android/java/src/org/chromium/chrome/browser/widget/DateDividedAdapter.java

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.chrome.browser.widget;
 
 import android.os.AsyncTask;
 import android.support.v7.widget.RecyclerView;
 import android.support.v7.widget.RecyclerView.Adapter;
 import android.support.v7.widget.RecyclerView.ViewHolder;
 import android.text.format.DateUtils;
 import android.util.Pair;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
 import android.widget.TextView;
 
 import org.chromium.chrome.R;
-import org.chromium.chrome.browser.widget.DateDividedAdapter.ItemGroup;
 
 import java.util.ArrayList;
 import java.util.Calendar;
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.Date;
 import java.util.List;
 import java.util.SortedSet;
 import java.util.TreeSet;
 import java.util.concurrent.ExecutionException;
@@ skipping 11 matching lines @@
 
     /**
      * Interface that the {@link Adapter} uses to interact with the items it manages.
      */
     public abstract static class TimedItem {
         /** Value indicating that a TimedItem is not currently being displayed. */
         public static final int INVALID_POSITION = -1;
 
         /** Position of the TimedItem in the list, or {@link #INVALID_POSITION} if not shown. */
         private int mPosition = INVALID_POSITION;
 

[Theresa, 2017/02/03 22:36:45]

It looks like you need to sync and rebase this CL. I landed a change to
DateDividedAdapter earlier this week that introduced variables for
mIsFirstInGroup and mIsLastInGroup to TimedItem. The booleans are being used to
select the background drawable for history items and it will soon be used for
downloads as well.

Since this CL changes it so that not all items in a group are visible, the
booleans should be updated to something like mIsFirstVisibleInGroup and
mIsLastVisibleInGroup, so that the last visible item in each group gets the
background drawable with a shadow on the bottom even when there are hidden items
in the group.

[shaktisahu, 2017/02/04 18:57:43]

Done.

         /** See {@link #mPosition}. */
-        private final void setPosition(int position) {
+        public final void setPosition(int position) {
             mPosition = position;
         }
 
         /** See {@link #mPosition}. */
         public final int getPosition() {
             return mPosition;
         }
 
         /** @return The timestamp for this item. */
         public abstract long getTimestamp();
@@ skipping 44 matching lines @@
 
     protected static class BasicViewHolder extends RecyclerView.ViewHolder {
         public BasicViewHolder(View itemView) {
             super(itemView);
         }
     }
 
     /**
      * A bucket of items with the same date.
      */
-    protected static class ItemGroup {
+    public static class ItemGroup {
         private final Date mDate;
-        private final List<TimedItem> mItems = new ArrayList<>();
+        protected final List<TimedItem> mItems = new ArrayList<>();
 
         /** Index of the header, relative to the full list.  Must be set only once.*/
         private int mIndex;
 
         private boolean mIsSorted;
         private boolean mIsListHeaderOrFooter;
 
         public ItemGroup(long timestamp) {
             mDate = new Date(timestamp);
             mIsSorted = true;
         }
 
         public void addItem(TimedItem item) {
             mItems.add(item);
             mIsSorted = mItems.size() == 1;
         }
 
         public void removeItem(TimedItem item) {
             mItems.remove(item);
         }
 
         /** Records the position of all the TimedItems in this group, relative to the full list. */
         public void setPosition(int index) {
             assert mIndex == 0 || mIndex == TimedItem.INVALID_POSITION;
             mIndex = index;
 
             sortIfNeeded();
+            setPositionForItems(index + 1);
+        }
+
+        protected void setPositionForItems(int startIndex) {
+            int index = startIndex;
             for (TimedItem item : mItems) {
+                item.setPosition(index);
                 index += 1;
-                item.setPosition(index);
             }
         }
 
         /** Unsets the position of all TimedItems in this group. */
         public void resetPosition() {
             mIndex = TimedItem.INVALID_POSITION;
             for (TimedItem item : mItems) item.setPosition(TimedItem.INVALID_POSITION);
         }
 
         /**
          * @return Whether the given date happens in the same day as the items in this group.
          */
         public boolean isSameDay(Date otherDate) {
             return compareDate(mDate, otherDate) == 0;
         }
 
+        protected boolean isListHeaderOrFooter() {

[Theresa, 2017/02/03 19:53:06]

Where is this called?

[shaktisahu, 2017/02/04 18:57:43]

Done. Removed. Thanks!

+            return mIsListHeaderOrFooter;
+        }
+
+        protected Date getDate() {
+            return mDate;
+        }
+
         /**
          * @return The size of this group.
          */
         public int size() {
             if (mIsListHeaderOrFooter) return 1;
 
             // Plus 1 to account for the date header.
             return mItems.size() + 1;
         }
 
         public TimedItem getItemAt(int index) {
             // 0 is allocated to the date header. The list header has no items.
             if (index == 0 || mIsListHeaderOrFooter) return null;
 
             sortIfNeeded();
             return mItems.get(index - 1);
         }
 
         /**
          * Rather than sorting the list each time a new item is added, the list is sorted when
          * something requires a correct ordering of the items.
          */
-        private void sortIfNeeded() {
+        protected void sortIfNeeded() {
             if (mIsSorted) return;
             mIsSorted = true;
 
             Collections.sort(mItems, new Comparator<TimedItem>() {
                 @Override
                 public int compare(TimedItem lhs, TimedItem rhs) {
-                    // More recent items are listed first.  Ideally we'd use Long.compare, but that
-                    // is an API level 19 call for some inexplicable reason.
-                    long timeDelta = lhs.getTimestamp() - rhs.getTimestamp();
-                    if (timeDelta > 0) {
-                        return -1;
-                    } else if (timeDelta == 0) {
-                        return 0;
-                    } else {
-                        return 1;
-                    }
+                    return compareItem(lhs, rhs);
                 }
             });
         }
+
+        protected int compareItem(TimedItem lhs, TimedItem rhs) {
+            // More recent items are listed first.  Ideally we'd use Long.compare, but that
+            // is an API level 19 call for some inexplicable reason.
+            long timeDelta = lhs.getTimestamp() - rhs.getTimestamp();
+            if (timeDelta > 0) {
+                return -1;
+            } else if (timeDelta == 0) {
+                return 0;
+            } else {
+                return 1;
+            }
+        }
+
+        public int getItemViewType(int position) {
+            return TYPE_NORMAL;
+        }
     }
 
     // Cached async tasks to get the two Calendar objects, which are used when comparing dates.
     private static final AsyncTask<Void, Void, Calendar> sCal1 = createCalendar();
     private static final AsyncTask<Void, Void, Calendar> sCal2 = createCalendar();
 
     public static final int TYPE_FOOTER = -2;
     public static final int TYPE_HEADER = -1;
     public static final int TYPE_DATE = 0;
     public static final int TYPE_NORMAL = 1;
+    public static final int TYPE_SUGGESTED_OFFLINE_PAGES_HEADER = 2;

[Theresa, 2017/02/03 19:53:06]

DateDividedAdapter shouldn't know about offline pages.


Also, would it make sense to introduce a "TYPE_SUBSECTION" concept so that the
work in this CL can be more easily leveraged for possible future expandable
subsections?

[shaktisahu, 2017/02/04 18:57:43]

Yes, I changed this to TYPE_SUBSECTION which can be used for the subclassed
adapters. DownloadHistoryAdapter will use this for offline page header.

 
     private int mSize;
     private boolean mHasListHeader;
     private boolean mHasListFooter;
 
     private SortedSet<ItemGroup> mGroups = new TreeSet<>(new Comparator<ItemGroup>() {
         @Override
         public int compare(ItemGroup lhs, ItemGroup rhs) {
             return compareDate(lhs.mDate, rhs.mDate);
         }
@@ skipping 38 matching lines @@
      * {@link #clear(boolean)} to remove previous items.
      */
     public void loadItems(List<? extends TimedItem> timedItems) {
         for (TimedItem timedItem : timedItems) {
             Date date = new Date(timedItem.getTimestamp());
             boolean found = false;
             for (ItemGroup group : mGroups) {
                 if (group.isSameDay(date)) {
                     found = true;
                     group.addItem(timedItem);
-                    mSize++;
                     break;
                 }
             }
             if (!found) {
                 // Create a new ItemGroup with the date for the new item. This increases the
                 // size by two because we add new views for the date and the item itself.
-                ItemGroup newGroup = new ItemGroup(timedItem.getTimestamp());
+                ItemGroup newGroup = createGroup(timedItem.getTimestamp());
                 newGroup.addItem(timedItem);
                 mGroups.add(newGroup);
-                mSize += 2;
             }
         }
 
+        computeItemCount();
         setGroupPositions();
         notifyDataSetChanged();
     }
 
+    protected ItemGroup createGroup(long timeStamp) {
+        ItemGroup group = new ItemGroup(timeStamp);
+        return group;
+    }
+
     /**
      * Tells each group where they start in the list.
      */
-    private void setGroupPositions() {
+    protected void setGroupPositions() {
         int startIndex = 0;
         for (ItemGroup group : mGroups) {
             group.resetPosition();
             group.setPosition(startIndex);
             startIndex += group.size();
         }
     }
 
     /**
      * Adds a header as the first group in this adapter.
@@ skipping 90 matching lines @@
     }
 
     @Override
     public final int getItemViewType(int position) {
         Pair<ItemGroup, Integer> pair = getGroupAt(position);
         if (pair.second == TYPE_HEADER) {
             return TYPE_HEADER;
         } else if (pair.second == TYPE_FOOTER) {
             return TYPE_FOOTER;
         } else if (pair.second == 0) {
             return TYPE_DATE;

[Theresa, 2017/02/03 19:53:06]

If we're moving the responsibility of knowing the view types for items into
ItemGroup, then this should probably move too. 

[shaktisahu, 2017/02/04 18:57:43]

Done.

         } else {
-            return TYPE_NORMAL;
+            ItemGroup group = pair.first;
+            return group.getItemViewType(pair.second);
         }
     }
 
     @Override
-    public final RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+    public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
         if (viewType == TYPE_DATE) {
             return new DateViewHolder(LayoutInflater.from(parent.getContext()).inflate(
                     getTimedItemViewResId(), parent, false));
         } else if (viewType == TYPE_NORMAL) {
             return createViewHolder(parent);
         } else if (viewType == TYPE_HEADER) {
             return createHeader(parent);
         } else if (viewType == TYPE_FOOTER) {
             return createFooter(parent);
         }
         assert false;
         return null;
     }
 
     @Override
-    public final void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
+    public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
         Pair<Date, TimedItem> pair = getItemAt(position);
         if (holder instanceof DateViewHolder) {
             ((DateViewHolder) holder).setDate(pair.first);
         } else if (!(holder instanceof BasicViewHolder)) {
             bindViewHolderForTimedItem(holder, pair.second);
         }
     }
 
     @Override
     public final int getItemCount() {
@@ skipping 24 matching lines @@
         assert false;
         return null;
     }
 
     /**
      * @param item The item to remove from the adapter.
      */
     protected void removeItem(TimedItem item) {
         ItemGroup group = getGroupAt(item.getPosition()).first;
         group.removeItem(item);
-        mSize--;
 
         // Remove the group if only the date header is left.
         if (group.size() == 1) {
             mGroups.remove(group);
-            mSize--;
         }
 
+        computeItemCount();
         setGroupPositions();
         notifyDataSetChanged();
     }
 
+    protected void computeItemCount() {
+        mSize = 0;
+        for (ItemGroup group : mGroups) {
+            mSize += group.size();
+        }
+    }
+
     /**
      * Creates a long ID that identifies a particular day in history.
      * @param date Date to process.
      * @return Long that has the day of the year (1-365) in the lowest 16 bits and the year in the
      *         next 16 bits over.
      */
     private static long getStableIdFromDate(Date date) {
         Pair<Calendar, Calendar> pair = getCachedCalendars();
         Calendar calendar = pair.first;
         calendar.setTime(date);
         long dayOfYear = calendar.get(Calendar.DAY_OF_YEAR);
         long year = calendar.get(Calendar.YEAR);
         return (year << 16) + dayOfYear;
     }
 
     /**
      * Compares two {@link Date}s. Note if you already have two {@link Calendar} objects, use
      * {@link #compareCalendar(Calendar, Calendar)} instead.
      * @return 0 if date1 and date2 are in the same day; 1 if date1 is before date2; -1 otherwise.
      */
-    private static int compareDate(Date date1, Date date2) {
+    protected static int compareDate(Date date1, Date date2) {
         Pair<Calendar, Calendar> pair = getCachedCalendars();
         Calendar cal1 = pair.first, cal2 = pair.second;
         cal1.setTime(date1);
         cal2.setTime(date2);
         return compareCalendar(cal1, cal2);
     }
 
     /**
      * @return 0 if cal1 and cal2 are in the same day; 1 if cal1 happens before cal2; -1 otherwise.
      */
@@ skipping 30 matching lines @@
      */
     private static AsyncTask<Void, Void, Calendar> createCalendar() {
         return new AsyncTask<Void, Void, Calendar>() {
             @Override
             protected Calendar doInBackground(Void... unused) {
                 return Calendar.getInstance();
             }
         }.execute();
     }
 }