Add support for webapk without runtimeHost

chrome/android/webapk/shell_apk/src/org/chromium/webapk/shell_apk/WebApkUtils.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.webapk.shell_apk;
 
 import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
+import android.content.pm.ResolveInfo;
+import android.net.Uri;
 import android.os.Bundle;
+import android.text.TextUtils;
 
+import org.chromium.webapk.lib.common.WebApkConstants;
 import org.chromium.webapk.lib.common.WebApkMetaDataKeys;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
 /**
  * Contains utility methods for interacting with WebAPKs.
  */
 public class WebApkUtils {
+    public static final String SHARED_PREF_RUNTIME_HOST = "runtime_host";
+
+    // The package names of the channels of Chrome that support WebAPKs. The most preferred one
+    // comes first.
+    private static List<String> sBrowsersSupportingWebApk = new ArrayList<String>(
+            Arrays.asList("com.google.android.apps.chrome", "com.android.chrome", "com.chrome.beta",
+                    "com.chrome.dev", "com.chrome.canary"));
 
     /**
-     * Caches the value read from Application Metadata which specifies the host browser's package
-     * name.
+     * Caches the package name of the host browser. {@link sHostPackage} might refer to a browser
+     * which has been uninstalled. A notification can keep the WebAPK process alive after the host
+     * browser has been uninstalled.
      */
     private static String sHostPackage;
 
+    public static void resetCachedHostPackageForTesting() {

[Yaron, 2017/05/15 18:41:37]

Can you confirm whether these are removed for release builds after proguarding?
If not, I think you'll want to follow what we do with RemovableInRelease

[Xi Han, 2017/05/16 13:50:39]

I have confirmed that these functions aren't in the release build, and they are
in the debug build which doesn't use proguarding.

+        sHostPackage = null;
+    }
+
+    public static void setBrowsersSupportingWebApkForTesting(List<String> browsers) {
+        sBrowsersSupportingWebApk = browsers;
+    }
+
     /**
      * Returns a Context for the host browser that was specified when building the WebAPK.
      * @param context A context.
      * @return The remote context. Returns null on an error.
      */
     public static Context getHostBrowserContext(Context context) {
         try {
             String hostPackage = getHostBrowserPackageName(context);
             return context.getApplicationContext().createPackageContext(
                             hostPackage,
                             Context.CONTEXT_IGNORE_SECURITY | Context.CONTEXT_INCLUDE_CODE);
         } catch (NameNotFoundException e) {
             e.printStackTrace();
         }
         return null;
     }
 
     /**
-     * Returns the package name for the host browser that was specified when building the WebAPK.
+     * Returns the package name of the host browser to launch the WebAPK. Also caches the package
+     * name in the SharedPreference if it is not null.
      * @param context A context.
      * @return The package name. Returns null on an error.
      */
     public static String getHostBrowserPackageName(Context context) {
-        if (sHostPackage != null) return sHostPackage;
-        String hostPackage = null;
-        try {
-            ApplicationInfo ai = context.getPackageManager().getApplicationInfo(
-                    context.getPackageName(), PackageManager.GET_META_DATA);
-            Bundle bundle = ai.metaData;
-            hostPackage = bundle.getString(WebApkMetaDataKeys.RUNTIME_HOST);
-        } catch (NameNotFoundException e) {
-            e.printStackTrace();
+        if (sHostPackage == null) {
+            sHostPackage = getHostBrowserPackageNameInternal(context);
+            if (sHostPackage != null) {
+                writeHostBrowserToSharedPref(context, sHostPackage);
+            }
         }
-        // Set {@link sHostPackage} to a non-null value so that the value is computed only once.
-        sHostPackage = hostPackage != null ? hostPackage : "";
+
         return sHostPackage;
     }
 
     /**
+     * Returns the package name of the host browser to launch the WebAPK, or null if not find one.
+     */
+    private static String getHostBrowserPackageNameInternal(Context context) {
+        // Gets all installed browsers that support WebAPKs.
+        List<String> installedBrowsers = getInstalledBrowsers(context.getPackageManager());
+        if (installedBrowsers.isEmpty()) {
+            return null;
+        }
+
+        // Gets the package name of the host browser if it is specified in AndroidManifest.xml.
+        String hostBrowserFromManifest = getHostBrowserFromAndroidManifest(
+                context.getPackageManager(), context.getPackageName());
+        if (!TextUtils.isEmpty(hostBrowserFromManifest)
+                && installedBrowsers.contains(hostBrowserFromManifest)) {
+            return hostBrowserFromManifest;
+        }
+
+        // Gets the package name of the host browser if it is stored in the SharedPreference.
+        String cachedHostBrowser = getHostBrowserFromSharedPreference(context);
+        if (!TextUtils.isEmpty(cachedHostBrowser)
+                && installedBrowsers.contains(cachedHostBrowser)) {
+            return cachedHostBrowser;
+        }
+
+        // Gets the package name of the default browser on the Android device.
+        // TODO(hanxi): Investigate the best way to know which browser supports WebAPKs.
+        String defaultBrowser = getDefaultBrowserPackageName(context.getPackageManager());
+        if (!TextUtils.isEmpty(defaultBrowser) && installedBrowsers.contains(defaultBrowser)
+                && sBrowsersSupportingWebApk.contains(defaultBrowser)) {
+            return defaultBrowser;
+        }
+
+        // TODO(hanxi): adds a new dialog to ask users to select a host browser when the default
+        // browser doesn't support WebAPKs.
+        for (String name : sBrowsersSupportingWebApk) {
+            if (installedBrowsers.contains(name)) {
+                return name;
+            }
+        }
+
+        return null;
+    }
+
+    /**
      * Returns the uid for the host browser that was specified when building the WebAPK.
      * @param context A context.
      * @return The application uid. Returns -1 on an error.
      */
     public static int getHostBrowserUid(Context context) {
         String hostPackageName = getHostBrowserPackageName(context);
         if (hostPackageName == null) {
             return -1;
         }
         try {
             PackageManager packageManager = context.getPackageManager();
             ApplicationInfo appInfo = packageManager.getApplicationInfo(
                     hostPackageName, PackageManager.GET_META_DATA);
             return appInfo.uid;
         } catch (NameNotFoundException e) {
             e.printStackTrace();
         }
         return -1;
     }
+
+    /** Returns the package name of the host browser cached in the SharedPreferences. */
+    private static String getHostBrowserFromSharedPreference(Context context) {
+        SharedPreferences sharedPref =
+                context.getSharedPreferences(WebApkConstants.PREF_PACKAGE, Context.MODE_PRIVATE);
+        return sharedPref.getString(SHARED_PREF_RUNTIME_HOST, null);
+    }
+
+    /** Returns a list of package names of all the installed browsers on the device. */
+    private static List<String> getInstalledBrowsers(PackageManager packageManager) {

[Yaron, 2017/05/15 18:41:38]

Ok, so Peter was right that ordering matters for the other collection but this
can still use Set (and would make for faster |contains| checks)

[Xi Han, 2017/05/16 13:50:39]

You are right, updated to set.

+        Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://"));
+        List<ResolveInfo> resolvedActivityList = packageManager.queryIntentActivities(
+                browserIntent, PackageManager.MATCH_DEFAULT_ONLY);
+
+        List<String> packagesSupportingWebApks = new ArrayList<>();
+        for (ResolveInfo info : resolvedActivityList) {
+            packagesSupportingWebApks.add(info.activityInfo.packageName);
+        }
+        return packagesSupportingWebApks;
+    }
+
+    /** Returns the package name of the "runtime host" in the AndroidManifest.xml. */
+    private static String getHostBrowserFromAndroidManifest(
+            PackageManager packageManager, String webApkPackageName) {
+        try {
+            ApplicationInfo ai = packageManager.getApplicationInfo(
+                    webApkPackageName, PackageManager.GET_META_DATA);
+            Bundle bundle = ai.metaData;
+            return bundle.getString(WebApkMetaDataKeys.RUNTIME_HOST);
+        } catch (NameNotFoundException e) {
+            return null;
+        }
+    }
+
+    /** Returns the package name of the default browser on the Android device. */
+    private static String getDefaultBrowserPackageName(PackageManager packageManager) {
+        Intent browserIntent = new Intent(Intent.ACTION_VIEW, Uri.parse("http://"));
+        ResolveInfo resolveInfo =
+                packageManager.resolveActivity(browserIntent, PackageManager.MATCH_DEFAULT_ONLY);
+        if (resolveInfo == null || resolveInfo.activityInfo == null) return null;
+
+        return resolveInfo.activityInfo.packageName;
+    }
+
+    /** Writes the package name of the host browser to the SharedPreferences. */
+    private static void writeHostBrowserToSharedPref(
+            final Context context, final String hostPackage) {
+        if (TextUtils.isEmpty(hostPackage)) return;
+
+        SharedPreferences sharedPref =
+                context.getSharedPreferences(WebApkConstants.PREF_PACKAGE, Context.MODE_PRIVATE);
+        SharedPreferences.Editor editor = sharedPref.edit();
+        editor.putString(SHARED_PREF_RUNTIME_HOST, hostPackage);
+        editor.apply();
+    }
 }