diff options
Diffstat (limited to 'mobile/android/base/java/org/mozilla/gecko/IntentHelper.java')
| -rw-r--r-- | mobile/android/base/java/org/mozilla/gecko/IntentHelper.java | 593 |
1 files changed, 593 insertions, 0 deletions
diff --git a/mobile/android/base/java/org/mozilla/gecko/IntentHelper.java b/mobile/android/base/java/org/mozilla/gecko/IntentHelper.java new file mode 100644 index 000000000..efe9576d7 --- /dev/null +++ b/mobile/android/base/java/org/mozilla/gecko/IntentHelper.java @@ -0,0 +1,593 @@ +/* -*- Mode: Java; c-basic-offset: 4; tab-width: 4; indent-tabs-mode: nil; -*- + * This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +package org.mozilla.gecko; + +import org.mozilla.gecko.overlays.ui.ShareDialog; +import org.mozilla.gecko.util.ActivityResultHandler; +import org.mozilla.gecko.util.EventCallback; +import org.mozilla.gecko.util.GeckoEventListener; +import org.mozilla.gecko.util.JSONUtils; +import org.mozilla.gecko.util.NativeEventListener; +import org.mozilla.gecko.util.NativeJSObject; +import org.mozilla.gecko.widget.ExternalIntentDuringPrivateBrowsingPromptFragment; + +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; + +import android.annotation.TargetApi; +import android.content.Context; +import android.content.Intent; +import android.content.pm.PackageManager; +import android.content.pm.ResolveInfo; +import android.net.Uri; +import android.provider.Browser; +import android.support.annotation.Nullable; +import android.support.v4.app.FragmentActivity; +import android.text.TextUtils; +import android.util.Log; +import android.webkit.MimeTypeMap; + +import java.io.UnsupportedEncodingException; +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URLEncoder; +import java.util.Arrays; +import java.util.List; +import java.util.Locale; + +public final class IntentHelper implements GeckoEventListener, + NativeEventListener { + + private static final String LOGTAG = "GeckoIntentHelper"; + private static final String[] EVENTS = { + "Intent:GetHandlers", + "Intent:Open", + "Intent:OpenForResult", + }; + + private static final String[] NATIVE_EVENTS = { + "Intent:OpenNoHandler", + }; + + // via http://developer.android.com/distribute/tools/promote/linking.html + private static String MARKET_INTENT_URI_PACKAGE_PREFIX = "market://details?id="; + private static String EXTRA_BROWSER_FALLBACK_URL = "browser_fallback_url"; + + /** A partial URI to an error page - the encoded error URI should be appended before loading. */ + private static String UNKNOWN_PROTOCOL_URI_PREFIX = "about:neterror?e=unknownProtocolFound&u="; + + private static IntentHelper instance; + + private final FragmentActivity activity; + + private IntentHelper(final FragmentActivity activity) { + this.activity = activity; + EventDispatcher.getInstance().registerGeckoThreadListener((GeckoEventListener) this, EVENTS); + EventDispatcher.getInstance().registerGeckoThreadListener((NativeEventListener) this, NATIVE_EVENTS); + } + + public static IntentHelper init(final FragmentActivity activity) { + if (instance == null) { + instance = new IntentHelper(activity); + } else { + Log.w(LOGTAG, "IntentHelper.init() called twice, ignoring."); + } + + return instance; + } + + public static void destroy() { + if (instance != null) { + EventDispatcher.getInstance().unregisterGeckoThreadListener((GeckoEventListener) instance, EVENTS); + EventDispatcher.getInstance().unregisterGeckoThreadListener((NativeEventListener) instance, NATIVE_EVENTS); + instance = null; + } + } + + /** + * Given the inputs to <code>getOpenURIIntent</code>, plus an optional + * package name and class name, create and fire an intent to open the + * provided URI. If a class name is specified but a package name is not, + * we will default to using the current fennec package. + * + * @param targetURI the string spec of the URI to open. + * @param mimeType an optional MIME type string. + * @param packageName an optional app package name. + * @param className an optional intent class name. + * @param action an Android action specifier, such as + * <code>Intent.ACTION_SEND</code>. + * @param title the title to use in <code>ACTION_SEND</code> intents. + * @param showPromptInPrivateBrowsing whether or not the user should be prompted when opening + * this uri from private browsing. This should be true + * when the user doesn't explicitly choose to open an an + * external app (e.g. just clicked a link). + * @return true if the activity started successfully or the user was prompted to open the + * application; false otherwise. + */ + public static boolean openUriExternal(String targetURI, + String mimeType, + String packageName, + String className, + String action, + String title, + final boolean showPromptInPrivateBrowsing) { + final GeckoAppShell.GeckoInterface gi = GeckoAppShell.getGeckoInterface(); + final Context activityContext = gi != null ? gi.getActivity() : null; + final Context context = activityContext != null ? activityContext : GeckoAppShell.getApplicationContext(); + final Intent intent = getOpenURIIntent(context, targetURI, + mimeType, action, title); + + if (intent == null) { + return false; + } + + if (!TextUtils.isEmpty(className)) { + if (!TextUtils.isEmpty(packageName)) { + intent.setClassName(packageName, className); + } else { + // Default to using the fennec app context. + intent.setClassName(context, className); + } + } + + if (!showPromptInPrivateBrowsing || activityContext == null) { + if (activityContext == null) { + intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + } + return ActivityHandlerHelper.startIntentAndCatch(LOGTAG, context, intent); + } else { + // Ideally we retrieve the Activity from the calling args, rather than + // statically, but since this method is called from Gecko and I'm + // unfamiliar with that code, this is a simpler solution. + final FragmentActivity fragmentActivity = (FragmentActivity) activityContext; + return ExternalIntentDuringPrivateBrowsingPromptFragment.showDialogOrAndroidChooser( + context, fragmentActivity.getSupportFragmentManager(), intent); + } + } + + public static boolean hasHandlersForIntent(Intent intent) { + try { + return !GeckoAppShell.queryIntentActivities(intent).isEmpty(); + } catch (Exception ex) { + Log.e(LOGTAG, "Exception in hasHandlersForIntent"); + return false; + } + } + + public static String[] getHandlersForIntent(Intent intent) { + final PackageManager pm = GeckoAppShell.getApplicationContext().getPackageManager(); + try { + final List<ResolveInfo> list = GeckoAppShell.queryIntentActivities(intent); + + int numAttr = 4; + final String[] ret = new String[list.size() * numAttr]; + for (int i = 0; i < list.size(); i++) { + ResolveInfo resolveInfo = list.get(i); + ret[i * numAttr] = resolveInfo.loadLabel(pm).toString(); + if (resolveInfo.isDefault) + ret[i * numAttr + 1] = "default"; + else + ret[i * numAttr + 1] = ""; + ret[i * numAttr + 2] = resolveInfo.activityInfo.applicationInfo.packageName; + ret[i * numAttr + 3] = resolveInfo.activityInfo.name; + } + return ret; + } catch (Exception ex) { + Log.e(LOGTAG, "Exception in getHandlersForIntent"); + return new String[0]; + } + } + + public static Intent getIntentForActionString(String aAction) { + // Default to the view action if no other action as been specified. + if (TextUtils.isEmpty(aAction)) { + return new Intent(Intent.ACTION_VIEW); + } + return new Intent(aAction); + } + + /** + * Given a URI, a MIME type, and a title, + * produce a share intent which can be used to query all activities + * than can open the specified URI. + * + * @param context a <code>Context</code> instance. + * @param targetURI the string spec of the URI to open. + * @param mimeType an optional MIME type string. + * @param title the title to use in <code>ACTION_SEND</code> intents. + * @return an <code>Intent</code>, or <code>null</code> if none could be + * produced. + */ + public static Intent getShareIntent(final Context context, + final String targetURI, + final String mimeType, + final String title) { + Intent shareIntent = getIntentForActionString(Intent.ACTION_SEND); + shareIntent.putExtra(Intent.EXTRA_TEXT, targetURI); + shareIntent.putExtra(Intent.EXTRA_SUBJECT, title); + shareIntent.putExtra(ShareDialog.INTENT_EXTRA_DEVICES_ONLY, true); + + // Note that EXTRA_TITLE is intended to be used for share dialog + // titles. Common usage (e.g., Pocket) suggests that it's sometimes + // interpreted as an alternate to EXTRA_SUBJECT, so we include it. + shareIntent.putExtra(Intent.EXTRA_TITLE, title); + + if (mimeType != null && mimeType.length() > 0) { + shareIntent.setType(mimeType); + } + + return shareIntent; + } + + /** + * Given a URI, a MIME type, an Android intent "action", and a title, + * produce an intent which can be used to start an activity to open + * the specified URI. + * + * @param context a <code>Context</code> instance. + * @param targetURI the string spec of the URI to open. + * @param mimeType an optional MIME type string. + * @param action an Android action specifier, such as + * <code>Intent.ACTION_SEND</code>. + * @param title the title to use in <code>ACTION_SEND</code> intents. + * @return an <code>Intent</code>, or <code>null</code> if none could be + * produced. + */ + static Intent getOpenURIIntent(final Context context, + final String targetURI, + final String mimeType, + final String action, + final String title) { + + // The resultant chooser can return non-exported activities in 4.1 and earlier. + // https://code.google.com/p/android/issues/detail?id=29535 + final Intent intent = getOpenURIIntentInner(context, targetURI, mimeType, action, title); + + if (intent != null) { + // Some applications use this field to return to the same browser after processing the + // Intent. While there is some danger (e.g. denial of service), other major browsers already + // use it and so it's the norm. + intent.putExtra(Browser.EXTRA_APPLICATION_ID, AppConstants.ANDROID_PACKAGE_NAME); + } + + return intent; + } + + private static Intent getOpenURIIntentInner(final Context context, final String targetURI, + final String mimeType, final String action, final String title) { + + if (action.equalsIgnoreCase(Intent.ACTION_SEND)) { + Intent shareIntent = getShareIntent(context, targetURI, mimeType, title); + return Intent.createChooser(shareIntent, + context.getResources().getString(R.string.share_title)); + } + + Uri uri = normalizeUriScheme(targetURI.indexOf(':') >= 0 ? Uri.parse(targetURI) : new Uri.Builder().scheme(targetURI).build()); + if (!TextUtils.isEmpty(mimeType)) { + Intent intent = getIntentForActionString(action); + intent.setDataAndType(uri, mimeType); + return intent; + } + + if (!GeckoAppShell.isUriSafeForScheme(uri)) { + return null; + } + + final String scheme = uri.getScheme(); + if ("intent".equals(scheme) || "android-app".equals(scheme)) { + final Intent intent; + try { + intent = Intent.parseUri(targetURI, 0); + } catch (final URISyntaxException e) { + Log.e(LOGTAG, "Unable to parse URI - " + e); + return null; + } + + // Only open applications which can accept arbitrary data from a browser. + intent.addCategory(Intent.CATEGORY_BROWSABLE); + + // Prevent site from explicitly opening our internal activities, which can leak data. + intent.setComponent(null); + nullIntentSelector(intent); + + return intent; + } + + // Compute our most likely intent, then check to see if there are any + // custom handlers that would apply. + // Start with the original URI. If we end up modifying it, we'll + // overwrite it. + final String extension = MimeTypeMap.getFileExtensionFromUrl(targetURI); + final Intent intent = getIntentForActionString(action); + intent.setData(uri); + + if ("file".equals(scheme)) { + // Only set explicit mimeTypes on file://. + final String mimeType2 = GeckoAppShell.getMimeTypeFromExtension(extension); + intent.setType(mimeType2); + return intent; + } + + // Have a special handling for SMS based schemes, as the query parameters + // are not extracted from the URI automatically. + if (!"sms".equals(scheme) && !"smsto".equals(scheme) && !"mms".equals(scheme) && !"mmsto".equals(scheme)) { + return intent; + } + + final String query = uri.getEncodedQuery(); + if (TextUtils.isEmpty(query)) { + return intent; + } + + // It is common to see sms*/mms* uris on the web without '//', it is W3C standard not to have the slashes, + // but android's Uri builder & Uri require the slashes and will interpret those without as malformed. + String currentUri = uri.toString(); + String correctlyFormattedDataURIScheme = scheme + "://"; + if (!currentUri.contains(correctlyFormattedDataURIScheme)) { + uri = Uri.parse(currentUri.replaceFirst(scheme + ":", correctlyFormattedDataURIScheme)); + } + + final String[] fields = query.split("&"); + boolean shouldUpdateIntent = false; + String resultQuery = ""; + for (String field : fields) { + if (field.startsWith("body=")) { + final String body = Uri.decode(field.substring(5)); + intent.putExtra("sms_body", body); + shouldUpdateIntent = true; + } else if (field.startsWith("subject=")) { + final String subject = Uri.decode(field.substring(8)); + intent.putExtra("subject", subject); + shouldUpdateIntent = true; + } else if (field.startsWith("cc=")) { + final String ccNumber = Uri.decode(field.substring(3)); + String phoneNumber = uri.getAuthority(); + if (phoneNumber != null) { + uri = uri.buildUpon().encodedAuthority(phoneNumber + ";" + ccNumber).build(); + } + shouldUpdateIntent = true; + } else { + resultQuery = resultQuery.concat(resultQuery.length() > 0 ? "&" + field : field); + } + } + + if (!shouldUpdateIntent) { + // No need to rewrite the URI, then. + return intent; + } + + // Form a new URI without the extracted fields in the query part, and + // push that into the new Intent. + final String newQuery = resultQuery.length() > 0 ? "?" + resultQuery : ""; + final Uri pruned = uri.buildUpon().encodedQuery(newQuery).build(); + intent.setData(pruned); + + return intent; + } + + // We create a separate method to better encapsulate the @TargetApi use. + @TargetApi(15) + private static void nullIntentSelector(final Intent intent) { + intent.setSelector(null); + } + + /** + * Return a <code>Uri</code> instance which is equivalent to <code>u</code>, + * but with a guaranteed-lowercase scheme as if the API level 16 method + * <code>u.normalizeScheme</code> had been called. + * + * @param u the <code>Uri</code> to normalize. + * @return a <code>Uri</code>, which might be <code>u</code>. + */ + private static Uri normalizeUriScheme(final Uri u) { + final String scheme = u.getScheme(); + final String lower = scheme.toLowerCase(Locale.US); + if (lower.equals(scheme)) { + return u; + } + + // Otherwise, return a new URI with a normalized scheme. + return u.buildUpon().scheme(lower).build(); + } + + @Override + public void handleMessage(final String event, final NativeJSObject message, final EventCallback callback) { + if (event.equals("Intent:OpenNoHandler")) { + openNoHandler(message, callback); + } + } + + @Override + public void handleMessage(String event, JSONObject message) { + try { + if (event.equals("Intent:GetHandlers")) { + getHandlers(message); + } else if (event.equals("Intent:Open")) { + open(message); + } else if (event.equals("Intent:OpenForResult")) { + openForResult(message); + } + } catch (JSONException e) { + Log.e(LOGTAG, "Exception handling message \"" + event + "\":", e); + } + } + + private void getHandlers(JSONObject message) throws JSONException { + final Intent intent = getOpenURIIntent(activity, + message.optString("url"), + message.optString("mime"), + message.optString("action"), + message.optString("title")); + final List<String> appList = Arrays.asList(getHandlersForIntent(intent)); + + final JSONObject response = new JSONObject(); + response.put("apps", new JSONArray(appList)); + EventDispatcher.sendResponse(message, response); + } + + private void open(JSONObject message) throws JSONException { + openUriExternal(message.optString("url"), + message.optString("mime"), + message.optString("packageName"), + message.optString("className"), + message.optString("action"), + message.optString("title"), false); + } + + private void openForResult(final JSONObject message) throws JSONException { + Intent intent = getOpenURIIntent(activity, + message.optString("url"), + message.optString("mime"), + message.optString("action"), + message.optString("title")); + intent.setClassName(message.optString("packageName"), message.optString("className")); + intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP); + + final ResultHandler handler = new ResultHandler(message); + try { + ActivityHandlerHelper.startIntentForActivity(activity, intent, handler); + } catch (SecurityException e) { + Log.w(LOGTAG, "Forbidden to launch activity.", e); + } + } + + /** + * Opens a URI without any valid handlers on device. In the best case, a package is specified + * and we can bring the user directly to the application page in an app market. If a package is + * not specified and there is a fallback url in the intent extras, we open that url. If neither + * is present, we alert the user that we were unable to open the link. + * + * @param msg A message with the uri with no handlers as the value for the "uri" key + * @param callback A callback that will be called with success & no params if Java loads a page, or with error and + * the uri to load if Java does not load a page + */ + private void openNoHandler(final NativeJSObject msg, final EventCallback callback) { + final String uri = msg.getString("uri"); + + if (TextUtils.isEmpty(uri)) { + Log.w(LOGTAG, "Received empty URL - loading about:neterror"); + callback.sendError(getUnknownProtocolErrorPageUri("")); + return; + } + + final Intent intent; + try { + // TODO (bug 1173626): This will not handle android-app uris on non 5.1 devices. + intent = Intent.parseUri(uri, 0); + } catch (final URISyntaxException e) { + String errorUri; + try { + errorUri = getUnknownProtocolErrorPageUri(URLEncoder.encode(uri, "UTF-8")); + } catch (final UnsupportedEncodingException encodingE) { + errorUri = getUnknownProtocolErrorPageUri(""); + } + + // Don't log the exception to prevent leaking URIs. + Log.w(LOGTAG, "Unable to parse Intent URI - loading about:neterror"); + callback.sendError(errorUri); + return; + } + + // For this flow, we follow Chrome's lead: + // https://developer.chrome.com/multidevice/android/intents + final String fallbackUrl = intent.getStringExtra(EXTRA_BROWSER_FALLBACK_URL); + if (isFallbackUrlValid(fallbackUrl)) { + // Opens the page in JS. + callback.sendError(fallbackUrl); + + } else if (intent.getPackage() != null) { + // Note on alternative flows: we could get the intent package from a component, however, for + // security reasons, components are ignored when opening URIs (bug 1168998) so we should + // ignore it here too. + // + // Our old flow used to prompt the user to search for their app in the market by scheme and + // while this could help the user find a new app, there is not always a correlation in + // scheme to application name and we could end up steering the user wrong (potentially to + // malicious software). Better to leave that one alone. + final String marketUri = MARKET_INTENT_URI_PACKAGE_PREFIX + intent.getPackage(); + final Intent marketIntent = new Intent(Intent.ACTION_VIEW, Uri.parse(marketUri)); + marketIntent.addCategory(Intent.CATEGORY_BROWSABLE); + marketIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); + + // (Bug 1192436) We don't know if marketIntent matches any Activities (e.g. non-Play + // Store devices). If it doesn't, clicking the link will cause no action to occur. + ExternalIntentDuringPrivateBrowsingPromptFragment.showDialogOrAndroidChooser( + activity, activity.getSupportFragmentManager(), marketIntent); + callback.sendSuccess(null); + + } else { + // We return the error page here, but it will only be shown if we think the load did + // not come from clicking a link. Chrome does not show error pages in that case, and + // many websites have catered to this behavior. For example, the site might set a timeout and load a play + // store url for their app if the intent link fails to load, i.e. the app is not installed. + // These work-arounds would often end with our users seeing about:neterror instead of the intended experience. + // While I feel showing about:neterror is a better solution for users (when not hacked around), + // we should match the status quo for the good of our users. + // + // Don't log the URI to prevent leaking it. + Log.w(LOGTAG, "Unable to open URI, maybe showing neterror"); + callback.sendError(getUnknownProtocolErrorPageUri(intent.getData().toString())); + } + } + + private static boolean isFallbackUrlValid(@Nullable final String fallbackUrl) { + if (fallbackUrl == null) { + return false; + } + + try { + final String anyCaseScheme = new URI(fallbackUrl).getScheme(); + final String scheme = (anyCaseScheme == null) ? null : anyCaseScheme.toLowerCase(Locale.US); + if ("http".equals(scheme) || "https".equals(scheme)) { + return true; + } else { + Log.w(LOGTAG, "Fallback URI uses unsupported scheme: " + scheme + ". Try http or https."); + } + } catch (final URISyntaxException e) { + // Do not include Exception to avoid leaking uris. + Log.w(LOGTAG, "URISyntaxException parsing fallback URI"); + } + return false; + } + + /** + * Returns an about:neterror uri with the unknownProtocolFound text as a parameter. + * @param encodedUri The encoded uri. While the page does not open correctly without specifying + * a uri parameter, it happily accepts the empty String so this argument may + * be the empty String. + */ + private String getUnknownProtocolErrorPageUri(final String encodedUri) { + return UNKNOWN_PROTOCOL_URI_PREFIX + encodedUri; + } + + private static class ResultHandler implements ActivityResultHandler { + private final JSONObject message; + + public ResultHandler(JSONObject message) { + this.message = message; + } + + @Override + public void onActivityResult(int resultCode, Intent data) { + JSONObject response = new JSONObject(); + try { + if (data != null) { + if (data.getExtras() != null) { + response.put("extras", JSONUtils.bundleToJSON(data.getExtras())); + } + if (data.getData() != null) { + response.put("uri", data.getData().toString()); + } + } + response.put("resultCode", resultCode); + } catch (JSONException e) { + Log.w(LOGTAG, "Error building JSON response.", e); + } + EventDispatcher.sendResponse(message, response); + } + } +} |