Upstream: Launch WebApkActivity from WebAPK.

chrome/android/java/src/org/chromium/chrome/browser/webapps/ActivityAssigner.java

 // Copyright 2015 The Chromium Authors. All rights reserved.

[gone, 2016/05/25 21:50:13]

It makes more sense to have two ActivityAssigner instances (one for
WebappActivity and one for WebApkActivity) instead of doing what you're doing
here.  You wouldn't have to manage multiple arrays and the class would almost
exactly stay the same as the original implementation, except for the bits where
you change the preference name.  You'd need to:

1) Change ActivityAssigner#instance() to return the correct instance for the
Activity type
2) Change the preference saving code to automatically append ".webapk" or
whatever to the preference key being stored if the ActivityAssigner is making
them for WebApks.

 // 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.webapps;
 
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.os.SystemClock;
 import android.util.Log;
 
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.metrics.RecordHistogram;
+import org.chromium.webapk.lib.common.WebApkConstants;
 
 import java.util.ArrayList;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 /**
- * Manages a rotating LRU buffer of WebappActivities to assign webapps to.
+ * Manages two rotating LRU buffers, one for WebappActivities, and the other one for
+ * WebApkActivities to assign webapps to.
  *

[gone, 2016/05/25 21:50:14]

Don't need to / everything, especially since you left a bunch of "webapps" in
here.  Try this:

Before Lollipop, the only way to create multiple retargetable instances of the
same Activity was to explicitly define them in the Manifest.  Given that the
user can potentially have an unlimited number of shortcuts for launching these
Activities, we have to actively assign shortcuts when they launch.  Activities
are reused in order of when they were last used, with the least recently used
ones reassigned first.

<everything else>

- * In order to accommodate a limited number of WebappActivities with a potentially unlimited number
- * of webapps, we have to rotate the available WebappActivities between the webapps we start up.
+ * In order to accommodate a limited number of WebappActivitiess/WebApkActivities with a
+ * potentially unlimited number of webapps, we have to rotate the available
+ * WebappActivities/WebApkActivities between the webapps we start up.
  * Activities are reused in order of when they were last used, with the least recently used
  * ones culled first.
  *
  * It is impossible to know whether Tasks have been removed from the Recent Task list without the
  * GET_TASKS permission.  As a result, the list of Activities inside the Recent Task list will
  * be highly unlikely to match the list maintained in memory.  Instead, we store the mapping as it
- * was the last time we changed it, which allows us to launch webapps in the WebappActivity they
- * were most recently associated with in cases where a user restarts a webapp from the Recent Tasks.
+ * was the last time we changed it, which allows us to launch webapps in the
+ * WebappActivity/WebApkActivity they were most recently associated with in cases where a user
+ * restarts a webapp from the Recent Tasks.
  * Note that in situations where the user manually clears the app data, we will again have an
  * incorrect mapping.
  *
  * Unless otherwise noted, all methods MUST be called on the UI thread to avoid threading issues.
  *
  * EXAMPLE:
  * - 3 Activities are available for assignment (0, 1, 2).
  * - 4 webapps exist (X, Y, Z, W).
  *
  *    ACTION        EFFECT                                                ACTIVITY LIST
@@ skipping 11 matching lines @@
     // Don't ever change this.  10 is enough for everyone.
     static final int NUM_WEBAPP_ACTIVITIES = 10;
 
     // A sanity check limit to ensure that we aren't reading an unreasonable number of preferences.
     // This number is different from above because the number of WebappActivities available may
     // change.
     static final int MAX_WEBAPP_ACTIVITIES_EVER = 100;
 
     // Don't ever change the package.  Left for backwards compatibility.
     @VisibleForTesting
-    static final String PREF_PACKAGE = "com.google.android.apps.chrome.webapps";
-    static final String PREF_NUM_SAVED_ENTRIES = "ActivityAssigner.numSavedEntries";
-    static final String PREF_ACTIVITY_INDEX = "ActivityAssigner.activityIndex";
-    static final String PREF_WEBAPP_ID = "ActivityAssigner.webappId";
+    static final String PREF_PACKAGE[] = {"com.google.android.apps.chrome.webapps",

[gone, 2016/05/25 21:50:13]

Don't bother with adding another package -- just use the same one that is
currently used.  It was a mistake to do this instead of using the default shared
prefs when I first wrote this class :/

+        "com.google.android.apps.chrome.webapps.webapk"};
+
+    static final String PREF_NUM_SAVED_ENTRIES[] = {"ActivityAssigner.numSavedEntries",
+        "ActivityAssigner.numSavedEntries.webapk"};
+    static final String PREF_ACTIVITY_INDEX[] = {"ActivityAssigner.activityIndex",
+        "ActivityAssigner.activityIndex.webapk"};
+    static final String PREF_WEBAPP_ID[] = {"ActivityAssigner.webappId",
+        "ActivityAssigner.webappId.webapk"};
 
     static final int INVALID_ACTIVITY_INDEX = -1;
+    static final int WEBAPP_ACTIVITY_INDEX = 0;
+    static final int WEBAPK_ACTIVITY_INDEX = 1;
+    static final int ACTIVITY_TYPES = 2;

[gone, 2016/05/25 21:50:14]

nit: ACTIVITY_TYPE_COUNT

 
     private static ActivityAssigner sInstance;
 
     private final Context mContext;
-    private final List<ActivityEntry> mActivityList;
+    private final List<ActivityEntry>[] mActivityList;
 
     /**
      * Pre-load shared prefs to avoid being blocked on the
      * disk access async task in the future.
      */
     public static void warmUpSharedPrefs(Context context) {
-        context.getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
+        for (int i = 0; i < ACTIVITY_TYPES; ++i) {
+            context.getSharedPreferences(PREF_PACKAGE[i], Context.MODE_PRIVATE);
+        }
     }
 
     static class ActivityEntry {
         final int mActivityIndex;
         final String mWebappId;
 
         ActivityEntry(int activity, String webapp) {
             mActivityIndex = activity;
             mWebappId = webapp;
         }
     }
 
     /**
      * Returns the singleton instance, creating it if necessary.
      */
     public static ActivityAssigner instance(Context context) {
         ThreadUtils.assertOnUiThread();
         if (sInstance == null) {
             sInstance = new ActivityAssigner(context);
         }
         return sInstance;
     }
 
     private ActivityAssigner(Context context) {
         mContext = context.getApplicationContext();
-        mActivityList = new ArrayList<ActivityEntry>();
-
-        restoreActivityList();
+        mActivityList = new ArrayList[ACTIVITY_TYPES];
+        for (int i = 0; i < mActivityList.length; i++) {
+            mActivityList[i] = new ArrayList<ActivityEntry>();
+            restoreActivityList(i);
+        }
     }
 
     /**
-     * Assigns the webapp with the given ID to one of the available WebappActivities.
+     * Assigns the webapp with the given ID to one of the available
+     * WebappActivities/WebApkActivities.

[gone, 2016/05/25 21:50:13]

Assign the app with the given ID to one of the available Activity instances.

      * If we know that the webapp was previously launched in one of the Activities, re-use it.

[gone, 2016/05/25 21:50:13]

webapp -> app

least recently used ID and use that

-     * Otherwise, take the least recently used WebappActivity ID and use that.
+     * Otherwise, take the least recently used WebappActivity/WebApkActivity ID and use that.
      * @param webappId ID of the webapp.
      * @return Index of the Activity to use for the webapp.
      */
     int assign(String webappId) {
         // Reuse a running Activity with the same ID, if it exists.
         int activityIndex = checkIfAssigned(webappId);
 
         // Allocate the one in the front of the list.
         if (activityIndex == INVALID_ACTIVITY_INDEX) {
-            activityIndex = mActivityList.get(0).mActivityIndex;
+            // Get index of the LRU buffer depending on the {@link webappId}.
+            int index = getIndex(webappId);
+            activityIndex = mActivityList[index].get(0).mActivityIndex;
             ActivityEntry newEntry = new ActivityEntry(activityIndex, webappId);
-            mActivityList.set(0, newEntry);
+            mActivityList[index].set(0, newEntry);
         }
 
         markActivityUsed(activityIndex, webappId);
         return activityIndex;
     }
 
     /**
+     * Returns {@link WEBAPP_ACTIVITY_INDEX} for WebappActivity, {@link WEBAPK_ACTIVITY_INDEX} for
+     * WebApkActivity whose webappId starts with "webapk:".
+     */
+    int getIndex(String webappId) {
+        return webappId.startsWith(WebApkConstants.WEBAPK_ID_PREFIX) ? WEBAPK_ACTIVITY_INDEX
+                : WEBAPP_ACTIVITY_INDEX;
+    }
+
+    /**
      * Checks if the webapp with the given ID has been assigned to an Activity already.
      * @param webappId ID of the webapp being displayed.
      * @return Index of the Activity for the webapp if assigned, INVALID_ACTIVITY_INDEX otherwise.
      */
     int checkIfAssigned(String webappId) {
         if (webappId == null) {
             return INVALID_ACTIVITY_INDEX;
         }
 
         // Go backwards in the queue to catch more recent instances of any duplicated webapps.
-        for (int i = mActivityList.size() - 1; i >= 0; i--) {
-            if (webappId.equals(mActivityList.get(i).mWebappId)) {
-                return mActivityList.get(i).mActivityIndex;
+        int index = getIndex(webappId);
+        for (int i = mActivityList[index].size() - 1; i >= 0; i--) {
+            if (webappId.equals(mActivityList[index].get(i).mWebappId)) {
+                return mActivityList[index].get(i).mActivityIndex;
             }
         }
         return INVALID_ACTIVITY_INDEX;
     }
 
     /**
-     * Moves a WebappActivity to the back of the queue, indicating that the Webapp is still in use
-     * and shouldn't be killed.
-     * @param activityIndex Index of the WebappActivity.
-     * @param webappId ID of the webapp being shown in the WebappActivity.
+     * Moves a WebappActivity/WebApkActivity to the back of the queue, indicating that the Webapp
+     * is still in use and shouldn't be killed.
+     * @param activityIndex Index of the WebappActivity/WebApkActivity.
+     * @param webappId ID of the webapp being shown in the WebappActivity/WebApkActivity.
      */
     void markActivityUsed(int activityIndex, String webappId) {
         // Find the entry corresponding to the Activity.
-        int elementIndex = findActivityElement(activityIndex);
+        int index = getIndex(webappId);
+        int elementIndex = findActivityElement(activityIndex, index);
 
         if (elementIndex == -1) {
             Log.e(TAG, "Failed to find WebappActivity entry: " + activityIndex + ", " + webappId);
             return;
         }
 
         // We have to reassign the webapp ID in case WebappActivities get repurposed.
         ActivityEntry updatedEntry = new ActivityEntry(activityIndex, webappId);
-        mActivityList.remove(elementIndex);
-        mActivityList.add(updatedEntry);
-        storeActivityList();
+        mActivityList[index].remove(elementIndex);
+        mActivityList[index].add(updatedEntry);
+        storeActivityList(index);
     }
 
     /**
      * Finds the index of the ActivityElement corresponding to the given activityIndex.
      * @param activityIndex Index of the activity to find.
+     * @param typeIndex Index of WebappActivities or WebApkActivities in {@link mActivityIndex}.
      * @return The index of the ActivityElement in the activity list, or -1 if it couldn't be found.
      */
-    private int findActivityElement(int activityIndex) {
-        for (int elementIndex = 0; elementIndex < mActivityList.size(); elementIndex++) {
-            if (mActivityList.get(elementIndex).mActivityIndex == activityIndex) {
+    private int findActivityElement(int activityIndex, int typeIndex) {
+        for (int elementIndex = 0; elementIndex < mActivityList[typeIndex].size(); elementIndex++) {
+            if (mActivityList[typeIndex].get(elementIndex).mActivityIndex == activityIndex) {
                 return elementIndex;
             }
         }
         return -1;
     }
 
     /**
      * Returns the current mapping between Activities and webapps.
      */
     @VisibleForTesting
-    List<ActivityEntry> getEntries() {
+    List<ActivityEntry>[] getEntries() {
         return mActivityList;
     }
 
     /**
-     * Restores/creates the mapping between webapps and WebappActivities.
+     * Restores/creates the mapping between webapps and WebappActivities/WebApkActivities depending
+     * on the {@link index}.
      * The logic is slightly complicated to future-proof against situations where the number of
-     * WebappActivities is changed.
+     * WebappActivities/WebApkActivity is changed.
      */
-    private void restoreActivityList() {
+    private void restoreActivityList(int index) {
         boolean isMapDirty = false;
-        mActivityList.clear();
+        mActivityList[index].clear();
 
         // Create a Set of indices corresponding to every possible Activity.
         // As ActivityEntries are read, they are and removed from this list to indicate that the
         // Activity has already been assigned.
         Set<Integer> availableWebapps = new HashSet<Integer>();
         for (int i = 0; i < NUM_WEBAPP_ACTIVITIES; ++i) {
             availableWebapps.add(i);
         }
 
         // Restore any entries that were previously saved.  If it seems that the preferences have
         // been corrupted somehow, just discard the whole map.
-        SharedPreferences prefs = mContext.getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
+        SharedPreferences prefs = mContext.getSharedPreferences(PREF_PACKAGE[index],
+                Context.MODE_PRIVATE);
         try {
             long time = SystemClock.elapsedRealtime();
-            final int numSavedEntries = prefs.getInt(PREF_NUM_SAVED_ENTRIES, 0);
+            final int numSavedEntries = prefs.getInt(PREF_NUM_SAVED_ENTRIES[index], 0);
             try {
                 RecordHistogram.recordTimesHistogram("Android.StrictMode.WebappSharedPrefs",
                         SystemClock.elapsedRealtime() - time, TimeUnit.MILLISECONDS);
             } catch (UnsatisfiedLinkError error) {
                 // Intentionally ignored - it's ok to miss recording the metric occasionally.
             }
             if (numSavedEntries <= NUM_WEBAPP_ACTIVITIES) {
                 for (int i = 0; i < numSavedEntries; ++i) {
-                    String currentActivityIndexPref = PREF_ACTIVITY_INDEX + i;
-                    String currentWebappIdPref = PREF_WEBAPP_ID + i;
+                    String currentActivityIndexPref = PREF_ACTIVITY_INDEX[index] + i;
+                    String currentWebappIdPref = PREF_WEBAPP_ID[index] + i;
 
                     int activityIndex = prefs.getInt(currentActivityIndexPref, i);
                     String webappId = prefs.getString(currentWebappIdPref, null);
                     ActivityEntry entry = new ActivityEntry(activityIndex, webappId);
 
                     if (availableWebapps.remove(entry.mActivityIndex)) {
-                        mActivityList.add(entry);
+                        mActivityList[index].add(entry);
                     } else {
                         // If the same activity was assigned to two different entries, or if the
                         // number of activities changed, discard it and mark that it needs to be
                         // rewritten.
                         isMapDirty = true;
                     }
                 }
             }
         } catch (ClassCastException exception) {
             // Something went wrong reading the preferences.  Nuke everything.
-            mActivityList.clear();
+            mActivityList[index].clear();
             availableWebapps.clear();
             for (int i = 0; i < NUM_WEBAPP_ACTIVITIES; ++i) {
                 availableWebapps.add(i);
             }
         }
 
-        // Add entries for any missing WebappActivities.
+        // Add entries for any missing WebappActivities/WebApkActivities.
         for (Integer availableIndex : availableWebapps) {
             ActivityEntry entry = new ActivityEntry(availableIndex, null);
-            mActivityList.add(entry);
+            mActivityList[index].add(entry);
             isMapDirty = true;
         }
 
         if (isMapDirty) {
-            storeActivityList();
+            storeActivityList(index);
         }
     }
 
     /**
-     * Saves the mapping between webapps and WebappActivities.
+     * Saves the mapping between webapps and WebappActivities/WebApkActivities depending on the
+     * {@link index}.
      */
-    private void storeActivityList() {
-        SharedPreferences prefs = mContext.getSharedPreferences(PREF_PACKAGE, Context.MODE_PRIVATE);
+    private void storeActivityList(int index) {
+        SharedPreferences prefs = mContext.getSharedPreferences(PREF_PACKAGE[index],
+                Context.MODE_PRIVATE);
         SharedPreferences.Editor editor = prefs.edit();
         editor.clear();
-        editor.putInt(PREF_NUM_SAVED_ENTRIES, mActivityList.size());
-        for (int i = 0; i < mActivityList.size(); ++i) {
-            String currentActivityIndexPref = PREF_ACTIVITY_INDEX + i;
-            String currentWebappIdPref = PREF_WEBAPP_ID + i;
-            editor.putInt(currentActivityIndexPref, mActivityList.get(i).mActivityIndex);
-            editor.putString(currentWebappIdPref, mActivityList.get(i).mWebappId);
+        editor.putInt(PREF_NUM_SAVED_ENTRIES[index], mActivityList[index].size());
+        for (int i = 0; i < mActivityList[index].size(); ++i) {
+            String currentActivityIndexPref = PREF_ACTIVITY_INDEX[index] + i;
+            String currentWebappIdPref = PREF_WEBAPP_ID[index] + i;
+            editor.putInt(currentActivityIndexPref, mActivityList[index].get(i).mActivityIndex);
+            editor.putString(currentWebappIdPref, mActivityList[index].get(i).mWebappId);
         }
         editor.apply();
     }
 }