Protocol Handler support

Author: gstepniewski-google

androidbrowserhelper/src/main/java/com/google/androidbrowserhelper/trusted/LaunchUrlBundle.java

@@ -0,0 +1,39 @@
+package com.google.androidbrowserhelper.trusted;
+
+import android.net.Uri;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * Storage container for URLs that will be passed to the browser within a
+ * {@link androidx.browser.trusted.TrustedWebActivityIntent}.
+ */
+public class LaunchUrlBundle {
+
+    private @NonNull final Uri resolvedUrl;
+    private @Nullable final Uri originalUrl;
+
+    public LaunchUrlBundle(@NonNull Uri resolvedUrl, @Nullable Uri originalUrl) {
+        this.resolvedUrl = resolvedUrl;
+        this.originalUrl = originalUrl;
+    }
+
+    /**
+     * This is the target URL that will be opened by the browser in a TWA context.
+     * It is always present here.
+     */
+    public @NonNull Uri getResolvedUrl() {
+        return resolvedUrl;
+    }
+
+    /**
+     * The URL that was originally invoked before being processed and converted into the resolved
+     * URL. Currently the only use case for this is Protocol Handlers, which convert a URL with a
+     * custom data scheme into a http/https location. If the URL was never processed and the
+     * resolved URL is the same as the original, this returns null.
+     */
+    public @Nullable Uri getOriginalUrl() {
+        return originalUrl;
+    }
+}

androidbrowserhelper/src/main/java/com/google/androidbrowserhelper/trusted/LauncherActivity.java

@@ -38,6 +38,10 @@
 
 import org.json.JSONException;
 
+import java.util.Collections;
+import java.util.Map;
+import java.util.Objects;
+
 /**
  * A convenience class to make using Trusted Web Activities easier. You can extend this class for
  * basic modifications to the behaviour.
@@ -200,8 +204,9 @@ protected void launchTwa() {
                         getColorCompat(mMetadata.navigationBarDividerColorDarkId))
                 .build();
 
+        LaunchUrlBundle launchUrlBundle = getLaunchUrlBundle();
         TrustedWebActivityIntentBuilder twaBuilder =
-                new TrustedWebActivityIntentBuilder(getLaunchingUrl())
+                new TrustedWebActivityIntentBuilder(launchUrlBundle.getResolvedUrl())
                         .setToolbarColor(getColorCompat(mMetadata.statusBarColorId))
                         .setNavigationBarColor(getColorCompat(mMetadata.navigationBarColorId))
                         .setNavigationBarDividerColor(
@@ -212,6 +217,9 @@ protected void launchTwa() {
                         .setDisplayMode(getDisplayMode())
                         .setScreenOrientation(mMetadata.screenOrientation);
 
+        // TODO When available
+        // twaBuilder.setOriginalLaunchUrl(launchUrlBundle.getOriginalUrl());
+
         if (mMetadata.additionalTrustedOrigins != null) {
             twaBuilder.setAdditionalTrustedOrigins(mMetadata.additionalTrustedOrigins);
         }
@@ -339,26 +347,54 @@ public void onEnterAnimationComplete() {
     }
 
     /**
-     * Returns the URL that the Trusted Web Activity should be launched to. By default this
-     * implementation checks to see if the Activity was launched with an Intent with data, if so
-     * attempt to launch to that URL. If not, read the
+     * Override this to enable Protocol Handler support.
+     * Keys of this map are data schemes, e.g. "bitcoin", "irc", "xmpp", "web+coffee", and values
+     * are templates that will be used to construct the full URL. The template must contain a "%s"
+     * token and be an absolute location with http/https scheme and the same origin as the TWA.
+     *
+     * An example valid entry in the map would be:
+     * ["web+coffee"] -> ["https://coffee.com/?type=%s"]
+     * This would result in a link "web+coffee://latte" being converted to
+     * "https://coffee.com/?type=latte".
+     *
+     * {@see https://developer.mozilla.org/en-US/docs/Web/Progressive_web_apps/Manifest/Reference/protocol_handlers}
+     */
+    protected Map<String, Uri> getProtocolHandlers() {
+        return Collections.emptyMap();
+    }
+
+    /**
+     * Returns the {@link LaunchUrlBundle} that the Trusted Web Activity should be launched to.
+     * By default this implementation starts by checking if the Activity was launched with an Intent
+     * with data. If so, check if that URL is a Protocol Handler custom scheme and if so, convert
+     * it to an appropriate http/https location (keeping the original custom scheme URL in the
+     * bundle). Otherwise, read the
      * "android.support.customtabs.trusted.DEFAULT_URL" metadata from the manifest.
      *
      * Override this for special handling (such as ignoring or sanitising data from the Intent).
      */
-    protected Uri getLaunchingUrl() {
-        Uri uri = getIntent().getData();
-        if (uri != null) {
-            Log.d(TAG, "Using URL from Intent (" + uri + ").");
-            return uri;
-        }
-
-        if (mMetadata.defaultUrl != null) {
-            Log.d(TAG, "Using URL from Manifest (" + mMetadata.defaultUrl + ").");
-            return Uri.parse(mMetadata.defaultUrl);
+    protected LaunchUrlBundle getLaunchUrlBundle() {
+        Uri baseUrl = Uri.parse(mMetadata.defaultUrl);
+
+        Uri intentUrl = getIntent().getData();
+
+        if (intentUrl != null) {
+            Map<String, Uri> protocolHandlers = getProtocolHandlers();
+            String scheme = intentUrl.getScheme();
+            if (protocolHandlers.containsKey(scheme)) {
+                String format = Objects.requireNonNull(protocolHandlers.get(scheme)).toString();
+                String target = intentUrl.toString().replace(scheme + "://", "");
+                Uri targetUrl =  Uri.parse(String.format(format, target));
+                Log.d(TAG, "Using protocol handler url: " + targetUrl);
+                return new LaunchUrlBundle(targetUrl, intentUrl);
+            }
+
+            Log.d(TAG, "Using url from Intent: " + intentUrl);
+            return new LaunchUrlBundle(intentUrl, null);
         }
 
-        return Uri.parse("https://www.example.com/");
+        Log.d(TAG, "Using url from Manifest: " + baseUrl);
+        return new LaunchUrlBundle(baseUrl, null);
     }
 
     /**

demos/twa-firebase-analytics/src/main/java/com/google/androidbrowserhelper/demos/twa_firebase_analytics/FirebaseAnalyticsLauncherActivity.java

@@ -17,11 +17,9 @@
 import android.net.Uri;
 import android.os.Bundle;
 
-import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
-import com.google.android.gms.tasks.OnCompleteListener;
-import com.google.android.gms.tasks.Task;
+import com.google.androidbrowserhelper.trusted.LaunchUrlBundle;
 import com.google.androidbrowserhelper.trusted.LauncherActivity;
 import com.google.firebase.analytics.FirebaseAnalytics;
 
@@ -60,12 +58,14 @@ protected boolean shouldLaunchImmediately() {
     }
 
     @Override
-    protected Uri getLaunchingUrl() {
-        Uri uri = super.getLaunchingUrl();
+    protected LaunchUrlBundle getLaunchUrlBundle() {
+        LaunchUrlBundle bundle = super.getLaunchUrlBundle();
         // Attach the Firebase instance Id to the launchUrl. This example uses "appInstanceId" as
         // the parameter name.
-        return uri.buildUpon()
+        Uri resolvedUrl = bundle.getResolvedUrl().buildUpon()
                 .appendQueryParameter("appInstanceId", mAppInstanceId)
                 .build();
+
+        return new LaunchUrlBundle(resolvedUrl, bundle.getOriginalUrl());
     }
 }