[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 13 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;
 
         /** 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();
 
         /**
          * Returns an ID that uniquely identifies this TimedItem and doesn't change.
          * To avoid colliding with IDs generated for Date headers, at least one of the upper 32
          * bits of the long should be set.
          * @return ID that can uniquely identify the TimedItem.
          */
         public abstract long getStableId();
+
+        /** @return Whether this item is an offline page. */
+        public boolean isOfflinePage() {

[gone, 2017/02/02 20:49:55]

This class should really have no idea what an offline page is.

[shaktisahu, 2017/02/02 23:29:38]

Okay. In that case, I can move this function to DownloadItemGroup since that's
the only place where it is used.

+            return false;
+        }
     }
 
     private static class DateViewHolder extends RecyclerView.ViewHolder {
         private TextView mTextView;
 
         public DateViewHolder(View view) {
             super(view);
             if (view instanceof TextView) mTextView = (TextView) view;
         }
 
@@ skipping 26 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;
         }
 
-        /**
-         * @return The size of this group.
-         */

[gone, 2017/02/02 23:59:48]

Why'd you remove this?

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

Done. Was accidentally removed.

+        protected boolean isListHeaderOrFooter() {
+            return mIsListHeaderOrFooter;
+        }
+
+        protected Date getDate() {
+            return mDate;
+        }
+
         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_OFFLINE_HEADER = 2;

[gone, 2017/02/02 23:59:48]

automatic offline header or something

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

Done. 
TYPE_SUGGESTED_OFFLINE_PAGES_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 92 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;
         } 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 14 matching lines @@
         }
 
         int i = position;
         for (ItemGroup group : mGroups) {
             if (i >= group.size()) {
                 i -= group.size();
             } else {
                 return new Pair<>(group, i);
             }
         }
+        System.out.println(
+                ("shakti, position " + position + " groups " + mGroups.size() + " msize " + mSize));
         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--;
         }
 
+        // Somewhat inefficient if number of groups is large.

[gone, 2017/02/02 23:59:48]

Can't you recompute the size based on the item/group you just removed?  Beats
having to iterate through the entire data structure every time something is
removed.

+        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();
     }
 }