[Download Home] Displaying offline page bundle per day

chrome/android/java/src/org/chromium/chrome/browser/download/ui/DownloadHistoryAdapter.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.download.ui;
 
 import android.content.ComponentName;
 import android.support.v7.widget.RecyclerView.ViewHolder;
 import android.text.TextUtils;
 import android.view.LayoutInflater;
@@ skipping 10 matching lines @@
 import org.chromium.chrome.browser.download.ui.DownloadHistoryItemWrapper.DownloadItemWrapper;
 import org.chromium.chrome.browser.download.ui.DownloadHistoryItemWrapper.OfflinePageItemWrapper;
 import org.chromium.chrome.browser.download.ui.DownloadManagerUi.DownloadUiObserver;
 import org.chromium.chrome.browser.offlinepages.downloads.OfflinePageDownloadBridge;
 import org.chromium.chrome.browser.offlinepages.downloads.OfflinePageDownloadItem;
 import org.chromium.chrome.browser.widget.DateDividedAdapter;
 import org.chromium.chrome.browser.widget.selection.SelectionDelegate;
 import org.chromium.content_public.browser.DownloadState;
 
 import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
 /** Bridges the user's download history and the UI used to display it. */
 public class DownloadHistoryAdapter extends DateDividedAdapter
         implements DownloadUiObserver, DownloadSharedPreferenceHelper.Observer {
 
     /** Alerted about changes to internal state. */
     static interface TestObserver {
         abstract void onDownloadItemCreated(DownloadItem item);
         abstract void onDownloadItemUpdated(DownloadItem item);
     }
 
     private class BackendItemsImpl extends BackendItems {
         @Override
         public DownloadHistoryItemWrapper removeItem(String guid) {
             DownloadHistoryItemWrapper wrapper = super.removeItem(guid);
 
             if (wrapper != null) {
                 mFilePathsToItemsMap.removeItem(wrapper);
                 if (getSelectionDelegate().isItemSelected(wrapper)) {
                     getSelectionDelegate().toggleSelectionForItem(wrapper);
                 }
             }
 
             return wrapper;
         }
     }
 
+    /** Represents the subsection header of the suggested pages for a given date. */
+    public class SubsectionHeader extends TimedItem {
+        private final Date mDate;
+        private final int mItemCount;
+        private final long mTotalFileSize;
+        private final Long mStableId;
+
+        public SubsectionHeader(Date date, int itemCount, long totalFileSize) {
+            mDate = date;
+            mItemCount = itemCount;
+            mTotalFileSize = totalFileSize;
+
+            // Generate a stable ID based on timestamp.
+            mStableId = 0xFFFFFFFF00000000L + (getTimestamp() & 0x0FFFFFFFF);
+        }
+
+        @Override
+        public long getTimestamp() {
+            return mDate.getTime();
+        }
+
+        public int getItemCount() {
+            return mItemCount;
+        }
+
+        public long getTotalFileSize() {
+            return mTotalFileSize;
+        }
+
+        @Override
+        public long getStableId() {
+            return mStableId;
+        }
+    }
+
     /**
      * Tracks externally deleted items that have been removed from downloads history.
      * Shared across instances.
      */
     private static final DeletedFileTracker sDeletedFileTracker = new DeletedFileTracker();
 
     private static final String EMPTY_QUERY = null;
 
     private final BackendItems mRegularDownloadItems = new BackendItemsImpl();
     private final BackendItems mIncognitoDownloadItems = new BackendItemsImpl();
     private final BackendItems mOfflinePageItems = new BackendItemsImpl();
 
-    private final BackendItems mFilteredItems = new BackendItemsImpl();
     private final FilePathsToDownloadItemsMap mFilePathsToItemsMap =
             new FilePathsToDownloadItemsMap();
 
+    private final Map<Date, Boolean> mSubSectionExpanded = new HashMap<>();
     private final ComponentName mParentComponent;
     private final boolean mShowOffTheRecord;
     private final LoadingStateDelegate mLoadingDelegate;
     private final ObserverList<TestObserver> mObservers = new ObserverList<>();
     private final List<DownloadItemView> mViews = new ArrayList<>();
 
     private BackendProvider mBackendProvider;
     private OfflinePageDownloadBridge.Observer mOfflinePageObserver;
     private int mFilter = DownloadFilter.FILTER_ALL;
     private String mSearchQuery = EMPTY_QUERY;
@@ skipping 115 matching lines @@
         totalSize += mOfflinePageItems.getTotalBytes();
         return totalSize;
     }
 
     @Override
     protected int getTimedItemViewResId() {
         return R.layout.date_view;
     }
 
     @Override
+    protected SubsectionHeaderViewHolder createSubsectionHeader(ViewGroup parent) {
+        OfflineGroupHeaderView offlineHeader =
+                (OfflineGroupHeaderView) LayoutInflater.from(parent.getContext())
+                        .inflate(R.layout.offline_download_header, parent, false);
+        offlineHeader.setAdapter(this);
+        return new SubsectionHeaderViewHolder(offlineHeader);
+    }
+
+    @Override
+    protected void bindViewHolderForSubsectionHeader(
+            SubsectionHeaderViewHolder holder, TimedItem timedItem) {
+        SubsectionHeader headerItem = (SubsectionHeader) timedItem;
+        Date date = new Date(headerItem.getTimestamp());
+        OfflineGroupHeaderView headerView = (OfflineGroupHeaderView) holder.getView();
+        headerView.update(date, isSubsectionExpanded(date), headerItem.getItemCount(),
+                headerItem.getTotalFileSize());
+    }
+
+    @Override
     public ViewHolder createViewHolder(ViewGroup parent) {
         DownloadItemView v = (DownloadItemView) LayoutInflater.from(parent.getContext()).inflate(
                 R.layout.download_item_view, parent, false);
         v.setSelectionDelegate(getSelectionDelegate());
         mViews.add(v);
         return new DownloadHistoryItemViewHolder(v);
     }
 
     @Override
     public void bindViewHolderForTimedItem(ViewHolder current, TimedItem timedItem) {
         final DownloadHistoryItemWrapper item = (DownloadHistoryItemWrapper) timedItem;
 
         DownloadHistoryItemViewHolder holder = (DownloadHistoryItemViewHolder) current;
         holder.getItemView().displayItem(mBackendProvider, item);
     }
 
+    @Override
+    protected ItemGroup createGroup(long timeStamp) {
+        return new DownloadItemGroup(timeStamp);
+    }
+
     /** Called when a new DownloadItem has been created by the native DownloadManager. */
     public void onDownloadItemCreated(DownloadItem item) {
         boolean isOffTheRecord = item.getDownloadInfo().isOffTheRecord();
         if (isOffTheRecord && !mShowOffTheRecord) return;
 
         BackendItems list = getDownloadItemList(isOffTheRecord);
         assert list.findItemIndex(item.getId()) == BackendItems.INVALID_INDEX;
 
         DownloadItemWrapper wrapper = createDownloadItemWrapper(item);
         boolean wasAdded = addDownloadHistoryItemWrapper(wrapper);
@@ skipping 148 matching lines @@
         return mBackendProvider.getOfflinePageBridge();
     }
 
     private SelectionDelegate<DownloadHistoryItemWrapper> getSelectionDelegate() {
         return mBackendProvider.getSelectionDelegate();
     }
 
     /** Filters the list of downloads to show only files of a specific type. */
     private void filter(int filterType) {
         mFilter = filterType;
-        mFilteredItems.clear();
-        mRegularDownloadItems.filter(mFilter, mSearchQuery, mFilteredItems);
-        mIncognitoDownloadItems.filter(mFilter, mSearchQuery, mFilteredItems);
-        mOfflinePageItems.filter(mFilter, mSearchQuery, mFilteredItems);
+
+        BackendItems filteredDownloadItems = new BackendItemsImpl();
+        mRegularDownloadItems.filter(mFilter, mSearchQuery, filteredDownloadItems);
+        mIncognitoDownloadItems.filter(mFilter, mSearchQuery, filteredDownloadItems);
+
+        List<TimedItem> filteredTimedItems = new ArrayList<>();
+        filteredTimedItems.addAll(filteredDownloadItems);
+        filteredTimedItems.addAll(filterOfflinePageItems());
+
         clear(false);
-        loadItems(mFilteredItems);
+        loadItems(filteredTimedItems);
+    }
+
+    /**
+     * Filters the offline pages based on the current filter and search text.
+     * If there are suggested pages, they are filtered based on whether or not the subsection for
+     * that date is expanded. Also a TimedItem is added to each subsection to represent the header
+     * for the suggested pages.
+     */
+    private List<TimedItem> filterOfflinePageItems() {
+        List<TimedItem> filteredTimedItems = new ArrayList<>();
+        Map<Date, Integer> suggestedPageCountMap = new HashMap<>();
+        Map<Date, Long> suggestedPageTotalSizeMap = new HashMap<>();
+
+        BackendItems filteredOfflinePageItems = new BackendItemsImpl();
+        mOfflinePageItems.filter(mFilter, mSearchQuery, filteredOfflinePageItems);
+
+        for (DownloadHistoryItemWrapper item : filteredOfflinePageItems) {
+            OfflinePageItemWrapper offlineItem = (OfflinePageItemWrapper) item;
+
+            // Add the suggested pages to the adapter only if the section is expanded for that date.
+            if (offlineItem.isSuggested()) {
+                incrementSuggestedPageCount(
+                        offlineItem, suggestedPageCountMap, suggestedPageTotalSizeMap);
+                if (!isSubsectionExpanded(getDateWithoutTime(offlineItem.getTimestamp()))) continue;
+            }
+            filteredTimedItems.add(offlineItem);
+        }
+
+        // Add a TimedItem for each subsection.
+        for (Date date : suggestedPageCountMap.keySet()) {
+            filteredTimedItems.add(new SubsectionHeader(

[Theresa, 2017/02/16 17:48:17]

Instead of constructing the SubsectionHeader each time we filter, would it make
sense to keep a map of Date -> SubsectionHeader?

Right now every time a download item or offline page item is modified or the
user selects a different filter or searches for anything, we'll end up
reconstructing all of the SubsectionHeaders. It would be more efficient to
update them when a suggested offline page is added/updated/removed.

If we store the Date -> SubsectionHeader map as an instance variable, we could
also use that in place of the mSubSectionExpanded map.

[shaktisahu, 2017/02/16 21:15:11]

I think this is okay, since they aren't that many (a few days probably), and
they really don't contain anything heavy. I wanted to keep a map of Boolean and
didn't want to maintain SubSectionHeaders to be less error prone when updating
states (add, remove, filter etc). But we could maintain these things either way
I guess.

[Theresa, 2017/02/17 23:56:34]

The backend is going to automatically remove suggested offline content after a
few days?

[shaktisahu, 2017/02/18 00:39:46]

I would think so. I will check this with the UX if it can go for months :)

+                    date, suggestedPageCountMap.get(date), suggestedPageTotalSizeMap.get(date)));
+        }
+
+        return filteredTimedItems;
+    }
+
+    // Updates the total number of suggested pages and file size grouped by date.
+    private void incrementSuggestedPageCount(OfflinePageItemWrapper offlineItem,
+            Map<Date, Integer> pageCountMap, Map<Date, Long> fileSizeMap) {
+        Date date = getDateWithoutTime(offlineItem.getTimestamp());
+
+        int count = pageCountMap.containsKey(date) ? pageCountMap.get(date) : 0;
+        pageCountMap.put(date, count + 1);
+
+        long fileSize = fileSizeMap.containsKey(date) ? fileSizeMap.get(date) : 0;
+        fileSizeMap.put(date, fileSize + offlineItem.getFileSize());
+    }
+
+    /**
+     * Whether the suggested pages section is expanded for a given date.
+     * @param date The download date.
+     * @return Whether the suggested pages section is expanded.
+     */
+    public boolean isSubsectionExpanded(Date date) {
+        // Default state is collpased.
+        if (mSubSectionExpanded.get(date) == null) return false;
+
+        return mSubSectionExpanded.get(date);
+    }
+
+    /**
+     * Sets the state of a subsection for a particular date.
+     * @param date The download date.
+     * @param expanded Whether the suggested pages should be expanded.
+     */
+    public void setSubsectionExpanded(Date date, boolean expanded) {
+        mSubSectionExpanded.put(date, expanded);
+        clear(false);
+        filter(mFilter);
+    }
+
+    @Override
+    protected boolean isSubsectionHeader(TimedItem timedItem) {
+        return timedItem instanceof SubsectionHeader;
     }
 
     private void initializeOfflinePageBridge() {
         mOfflinePageObserver = new OfflinePageDownloadBridge.Observer() {
             @Override
             public void onItemsLoaded() {
                 onAllOfflinePagesRetrieved(getOfflinePageBridge().getAllItems());
             }
 
             @Override
@@ skipping 59 matching lines @@
         RecordHistogram.recordCountHistogram("Android.DownloadManager.InitialCount.Video",
                 itemCounts[DownloadFilter.FILTER_VIDEO]);
     }
 
     private void recordTotalDownloadCountHistogram() {
         // The total count intentionally leaves out incognito downloads. This should be revisited
         // if/when incognito downloads are persistently available in downloads home.
         RecordHistogram.recordCountHistogram("Android.DownloadManager.InitialCount.Total",
                 mRegularDownloadItems.size() + mOfflinePageItems.size());
     }
+
+    /**
+     * Calculates the {@link Date} for midnight of the date represented by the timestamp.
+     */
+    private Date getDateWithoutTime(long timestamp) {
+        Calendar cal = Calendar.getInstance();
+        cal.setTimeInMillis(timestamp);
+        cal.set(Calendar.HOUR_OF_DAY, 0);
+        cal.set(Calendar.MINUTE, 0);
+        cal.set(Calendar.SECOND, 0);
+        cal.set(Calendar.MILLISECOND, 0);
+        return cal.getTime();
+    }
 }