[Offline pages] Downloads UI: Adding bridge for issuing notifications

chrome/android/java/src/org/chromium/chrome/browser/download/DownloadNotificationService.java

 // Copyright 2015 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;
 
 import android.app.DownloadManager;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
@@ skipping 10 matching lines @@
 
 import org.chromium.base.ContextUtils;
 import org.chromium.base.Log;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.library_loader.ProcessInitException;
 import org.chromium.chrome.R;
 import org.chromium.chrome.browser.ChromeApplication;
 import org.chromium.chrome.browser.init.BrowserParts;
 import org.chromium.chrome.browser.init.ChromeBrowserInitializer;
 import org.chromium.chrome.browser.init.EmptyBrowserParts;
+import org.chromium.chrome.browser.offlinepages.downloads.OfflinePageDownloadBridge;
 import org.chromium.chrome.browser.util.IntentUtils;
 
 import java.text.NumberFormat;
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Locale;
 import java.util.Set;
 
 /**
  * Service responsible for creating and updating download notifications even after
  * Chrome gets killed.
  */
 public class DownloadNotificationService extends Service {
     static final String EXTRA_DOWNLOAD_NOTIFICATION_ID = "DownloadNotificationId";
     static final String EXTRA_DOWNLOAD_GUID = "DownloadGuid";
     static final String EXTRA_DOWNLOAD_FILE_NAME = "DownloadFileName";
     static final String EXTRA_NOTIFICATION_DISMISSED = "NotificationDismissed";
     static final String EXTRA_DOWNLOAD_IS_OFF_THE_RECORD = "DownloadIsOffTheRecord";
     static final String ACTION_DOWNLOAD_CANCEL =
             "org.chromium.chrome.browser.download.DOWNLOAD_CANCEL";
     static final String ACTION_DOWNLOAD_PAUSE =
             "org.chromium.chrome.browser.download.DOWNLOAD_PAUSE";
     static final String ACTION_DOWNLOAD_RESUME =
             "org.chromium.chrome.browser.download.DOWNLOAD_RESUME";
     public static final String ACTION_DOWNLOAD_RESUME_ALL =
             "org.chromium.chrome.browser.download.DOWNLOAD_RESUME_ALL";
+    public static final String ACTION_DOWNLOAD_OPEN =
+            "org.chromium.chrome.browser.download.DOWNLOAD_OPEN";
     static final int INVALID_DOWNLOAD_PERCENTAGE = -1;
     @VisibleForTesting
     static final String PENDING_DOWNLOAD_NOTIFICATIONS = "PendingDownloadNotifications";
     static final String NOTIFICATION_NAMESPACE = "DownloadNotificationService";
     private static final String TAG = "DownloadNotification";
     private static final String NEXT_DOWNLOAD_NOTIFICATION_ID = "NextDownloadNotificationId";
     // Notification Id starting value, to avoid conflicts from IDs used in prior versions.
     private static final int STARTING_NOTIFICATION_ID = 1000000;
     private static final String AUTO_RESUMPTION_ATTEMPT_LEFT = "ResumptionAttemptLeft";
     private static final int MAX_RESUMPTION_ATTEMPT_LEFT = 5;
@@ skipping 125 matching lines @@
      * @param fileName File name of the download.
      * @param percentage Percentage completed. Value should be between 0 to 100 if
      *        the percentage can be determined, or -1 if it is unknown.
      * @param timeRemainingInMillis Remaining download time in milliseconds.
      * @param startTime Time when download started.
      * @param isOffTheRecord Whether the download is off the record.
      * @param canDownloadWhileMetered Whether the download can happen in metered network.
      */
     public void notifyDownloadProgress(String downloadGuid, String fileName, int percentage,
             long timeRemainingInMillis, long startTime, boolean isOffTheRecord,
-            boolean canDownloadWhileMetered) {
+            boolean canDownloadWhileMetered, boolean isOfflinePage) {
         boolean indeterminate = percentage == INVALID_DOWNLOAD_PERCENTAGE;
         NotificationCompat.Builder builder = buildNotification(
                 android.R.drawable.stat_sys_download, fileName, null);
         builder.setOngoing(true).setProgress(100, percentage, indeterminate);
         builder.setPriority(Notification.PRIORITY_HIGH);
         if (!indeterminate) {
             NumberFormat formatter = NumberFormat.getPercentInstance(Locale.getDefault());
             String percentText = formatter.format(percentage / 100.0);
             String duration = formatRemainingTime(mContext, timeRemainingInMillis);
             builder.setContentText(duration);
             if (Build.VERSION.CODENAME.equals("N")
                     || Build.VERSION.SDK_INT > Build.VERSION_CODES.M) {
                 builder.setSubText(percentText);
             } else {
                 builder.setContentInfo(percentText);
             }
         }
         int notificationId = getNotificationId(downloadGuid);
+        int itemType = isOfflinePage ? DownloadSharedPreferenceEntry.ITEM_TYPE_OFFLINE_PAGE
+                                     : DownloadSharedPreferenceEntry.ITEM_TYPE_DOWNLOAD;
         addOrReplaceSharedPreferenceEntry(new DownloadSharedPreferenceEntry(notificationId,
-                isOffTheRecord, canDownloadWhileMetered, downloadGuid, fileName,
-                DownloadSharedPreferenceEntry.ITEM_TYPE_DOWNLOAD));
+                isOffTheRecord, canDownloadWhileMetered, downloadGuid, fileName, itemType));
         if (startTime > 0) builder.setWhen(startTime);
         Intent cancelIntent = buildActionIntent(
                 ACTION_DOWNLOAD_CANCEL, notificationId, downloadGuid, fileName);
         builder.addAction(R.drawable.btn_close_white,
                 mContext.getResources().getString(R.string.download_notification_cancel_button),
                 buildPendingIntent(cancelIntent, notificationId));
         Intent pauseIntent = buildActionIntent(
                 ACTION_DOWNLOAD_PAUSE, notificationId, downloadGuid, fileName);
         builder.addAction(R.drawable.ic_vidcontrol_pause,
                 mContext.getResources().getString(R.string.download_notification_pause_button),
@@ skipping 68 matching lines @@
     }
 
     /**
      * Add a download successful notification.
      * @param downloadGuid GUID of the download.
      * @param fileName GUID of the download.
      * @param systemDownloadId Download ID assigned by system DownloadManager.
      * @return ID of the successful download notification. Used for removing the notification when
      *         user click on the snackbar.
      */
-    public int notifyDownloadSuccessful(String downloadGuid, String fileName,
-            long systemDownloadId) {
+    public int notifyDownloadSuccessful(
+            String downloadGuid, String fileName, long systemDownloadId, boolean isOfflinePage) {
         int notificationId = getNotificationId(downloadGuid);
         NotificationCompat.Builder builder = buildNotification(
                 android.R.drawable.stat_sys_download_done, fileName,
                 mContext.getResources().getString(R.string.download_notification_completed));
         ComponentName component = new ComponentName(
                 mContext.getPackageName(), DownloadBroadcastReceiver.class.getName());
-        Intent intent = new Intent(DownloadManager.ACTION_NOTIFICATION_CLICKED);
+        Intent intent;
+        if (isOfflinePage) {
+            intent =
+                    buildActionIntent(ACTION_DOWNLOAD_OPEN, notificationId, downloadGuid, fileName);
+        } else {
+            intent = new Intent(DownloadManager.ACTION_NOTIFICATION_CLICKED);
+            long[] idArray = {systemDownloadId};
+            intent.putExtra(DownloadManager.EXTRA_NOTIFICATION_CLICK_DOWNLOAD_IDS, idArray);
+        }
         intent.setComponent(component);
-        long[] idArray = {systemDownloadId};
-        intent.putExtra(DownloadManager.EXTRA_NOTIFICATION_CLICK_DOWNLOAD_IDS, idArray);
         builder.setContentIntent(PendingIntent.getBroadcast(
                 mContext, notificationId, intent, PendingIntent.FLAG_UPDATE_CURRENT));
         updateNotification(notificationId, builder.build());
         removeSharedPreferenceEntry(downloadGuid);
         mDownloadsInProgress.remove(downloadGuid);
         return notificationId;
     }
 
     /**
      * Add a download failed notification.
@@ skipping 127 matching lines @@
                 // If user manually resumes a download, update the network type if it
                 // is not metered previously.
                 entry.canDownloadWhileMetered = metered;
             }
             // Update the SharedPreference entry.
             addOrReplaceSharedPreferenceEntry(entry);
         } else if (intent.getAction() == ACTION_DOWNLOAD_RESUME_ALL
                 && (mDownloadSharedPreferenceEntries.isEmpty()
                         || DownloadManagerService.hasDownloadManagerService())) {
             return;
+        } else if (intent.getAction() == ACTION_DOWNLOAD_OPEN) {
+            // TODO(fgorski): Do we even need to do anything special here, before we launch Chrome?
         }
 
         BrowserParts parts = new EmptyBrowserParts() {
             @Override
             public boolean shouldStartGpuProcess() {
                 return false;
             }
 
             @Override
             public void finishNativeInitialization() {
-                DownloadServiceDelegate downloadServiceDelegate = getDelegateForEntry(entry);
+                DownloadServiceDelegate downloadServiceDelegate =
+                        getServiceDelegate(intent.getAction() == ACTION_DOWNLOAD_OPEN
+                                        ? DownloadSharedPreferenceEntry.ITEM_TYPE_OFFLINE_PAGE

[qinmin, 2016/08/18 23:46:59]

fix indentation

[fgorski, 2016/08/19 17:03:24]

Done. Problem here is that this is the product of "git cl format"
I'll try to check this in without an automated "fix".

+                                        : entry.itemType);
                 switch (intent.getAction()) {
                     case ACTION_DOWNLOAD_CANCEL:
                         // TODO(qinmin): Alternatively, we can delete the downloaded content on
                         // SD card, and remove the download ID from the SharedPreferences so we
                         // don't need to restart the browser process. http://crbug.com/579643.
                         cancelNotification(entry.notificationId, entry.downloadGuid);
                         downloadServiceDelegate.cancelDownload(entry.downloadGuid,
                                 entry.isOffTheRecord, IntentUtils.safeGetBooleanExtra(
                                         intent, EXTRA_NOTIFICATION_DISMISSED, false));
                         break;
                     case ACTION_DOWNLOAD_PAUSE:
                         downloadServiceDelegate.pauseDownload(entry.downloadGuid,
                                 entry.isOffTheRecord);
                         break;
                     case ACTION_DOWNLOAD_RESUME:
                         notifyDownloadProgress(entry.downloadGuid, entry.fileName,
                                 INVALID_DOWNLOAD_PERCENTAGE, 0, 0, entry.isOffTheRecord,
-                                entry.canDownloadWhileMetered);
+                                entry.canDownloadWhileMetered, isOfflinePage(entry));
                         downloadServiceDelegate.resumeDownload(entry.buildDownloadItem(), true);
                         break;
                     case ACTION_DOWNLOAD_RESUME_ALL:
                         assert entry == null;
                         resumeAllPendingDownloads();
                         break;
+                    case ACTION_DOWNLOAD_OPEN:
+                        assert entry == null;
+                        String guid = IntentUtils.safeGetStringExtra(intent, EXTRA_DOWNLOAD_GUID);
+                        downloadServiceDelegate.openItem(guid);
+                        break;
                     default:
                         Log.e(TAG, "Unrecognized intent action.", intent);
                         break;
                 }
+                downloadServiceDelegate.destroyServiceDelegate();
             }
         };
         try {
             ChromeBrowserInitializer.getInstance(mContext).handlePreNativeStartup(parts);
             ChromeBrowserInitializer.getInstance(mContext).handlePostNativeStartup(true, parts);
         } catch (ProcessInitException e) {
             Log.e(TAG, "Unable to load native library.", e);
             ChromeApplication.reportStartupErrorAndExit(e);
         }
     }
 
     /**
      * Gets appropriate download delegate that can handle interactions with download item referred
      * to by the entry.
-     * @param entry download entry for which the delegate is provided
+     * @param forOfflinePage Whether the service should deal with offline pages or downloads.
      * @return delegate for interactions with the entry
      */
-    DownloadServiceDelegate getDelegateForEntry(DownloadSharedPreferenceEntry entry) {
-        // TODO(fgorski): handle cases where entry is an offline page once implemented.
+    DownloadServiceDelegate getServiceDelegate(int downloadItemType) {
+        if (downloadItemType == DownloadSharedPreferenceEntry.ITEM_TYPE_OFFLINE_PAGE) {
+            return OfflinePageDownloadBridge.getDownloadServiceDelegate();
+        }
+        if (downloadItemType != DownloadSharedPreferenceEntry.ITEM_TYPE_DOWNLOAD) {
+            Log.e(TAG, "Unrecognized intent type.", downloadItemType);
+        }
         return DownloadManagerService.getDownloadManagerService(getApplicationContext());
     }
 
     /**
      * Update the notification with id.
      * @param id Id of the notification that has to be updated.
      * @param notification the notification object that needs to be updated.
      */
     @VisibleForTesting
     void updateNotification(int id, Notification notification) {
         mNotificationManager.notify(NOTIFICATION_NAMESPACE, id, notification);
     }
 
     /**
      * Checks if an intent requires operations on a download.
      * @param intent An intent to validate.
      * @return true if the intent requires actions, or false otherwise.
      */
     static boolean isDownloadOperationIntent(Intent intent) {
         if (intent == null) return false;
         if (ACTION_DOWNLOAD_RESUME_ALL.equals(intent.getAction())) return true;
         if (!ACTION_DOWNLOAD_CANCEL.equals(intent.getAction())
                 && !ACTION_DOWNLOAD_RESUME.equals(intent.getAction())
-                && !ACTION_DOWNLOAD_PAUSE.equals(intent.getAction())) {
+                && !ACTION_DOWNLOAD_PAUSE.equals(intent.getAction())
+                && !ACTION_DOWNLOAD_OPEN.equals(intent.getAction())) {
             return false;
         }
         if (!intent.hasExtra(EXTRA_DOWNLOAD_NOTIFICATION_ID)
                 || !intent.hasExtra(EXTRA_DOWNLOAD_FILE_NAME)
                 || !intent.hasExtra(EXTRA_DOWNLOAD_GUID)) {
             return false;
         }
         final int notificationId =
                 IntentUtils.safeGetIntExtra(intent, EXTRA_DOWNLOAD_NOTIFICATION_ID, -1);
         if (notificationId == -1) return false;
@@ skipping 49 matching lines @@
      * Resumes all pending downloads from |mDownloadSharedPreferenceEntries|. If a download is
      * already in progress, do nothing.
      */
     public void resumeAllPendingDownloads() {
         boolean isNetworkMetered = DownloadManagerService.isActiveNetworkMetered(mContext);
         if (!DownloadManagerService.hasDownloadManagerService()) return;
         for (int i = 0; i < mDownloadSharedPreferenceEntries.size(); ++i) {
             DownloadSharedPreferenceEntry entry = mDownloadSharedPreferenceEntries.get(i);
             if (mDownloadsInProgress.contains(entry.downloadGuid)) continue;
             if (!entry.canDownloadWhileMetered && isNetworkMetered) continue;
-            notifyDownloadProgress(entry.downloadGuid, entry.fileName,
-                    INVALID_DOWNLOAD_PERCENTAGE, 0, 0, false, entry.canDownloadWhileMetered);
-            getDelegateForEntry(entry).resumeDownload(entry.buildDownloadItem(), false);
+            notifyDownloadProgress(entry.downloadGuid, entry.fileName, INVALID_DOWNLOAD_PERCENTAGE,
+                    0, 0, false, entry.canDownloadWhileMetered, isOfflinePage(entry));
+            DownloadServiceDelegate downloadServiceDelegate = getServiceDelegate(entry.itemType);
+            downloadServiceDelegate.resumeDownload(entry.buildDownloadItem(), false);
+            downloadServiceDelegate.destroyServiceDelegate();
         }
     }
 
     /**
      * Parse a list of the DownloadSharedPreferenceEntry and the number of auto resumption attempt
      * left from the shared preference.
      */
     void parseDownloadSharedPrefs() {
         mNumAutoResumptionAttemptLeft = mSharedPrefs.getInt(AUTO_RESUMPTION_ATTEMPT_LEFT,
                 MAX_RESUMPTION_ATTEMPT_LEFT);
@@ skipping 45 matching lines @@
         if (entry != null) return entry.notificationId;
         int notificationId = mNextNotificationId;
         mNextNotificationId = mNextNotificationId == Integer.MAX_VALUE
                 ? STARTING_NOTIFICATION_ID : mNextNotificationId + 1;
         SharedPreferences.Editor editor = mSharedPrefs.edit();
         editor.putInt(NEXT_DOWNLOAD_NOTIFICATION_ID, mNextNotificationId);
         editor.apply();
         return notificationId;
     }
 
+    private boolean isOfflinePage(DownloadSharedPreferenceEntry entry) {
+        return entry.itemType == DownloadSharedPreferenceEntry.ITEM_TYPE_OFFLINE_PAGE;
+    }
+
     /**
      * Format remaining time for the given millis, in the following format:
      * 5 hours; will include 1 unit, can go down to seconds precision.
      * This is similar to what android.java.text.Formatter.formatShortElapsedTime() does. Don't use
      * ui::TimeFormat::Simple() as it is very expensive.
      *
      * @param context the application context.
      * @param millis the remaining time in milli seconds.
      * @return the formatted remaining time.
      */
@@ skipping 32 matching lines @@
             return context.getString(R.string.remaining_duration_minutes, minutes);
         } else if (minutes > 0) {
             return context.getString(R.string.remaining_duration_one_minute);
         } else if (seconds == 1) {
             return context.getString(R.string.remaining_duration_one_second);
         } else {
             return context.getString(R.string.remaining_duration_seconds, seconds);
         }
     }
 }