Java Code Examples for android.content.Intent#parseUri()

/**
 * Fetches the list of resolve infos from the PackageManager that can handle the URL.
 *
 * @param context The application context.
 * @param url The url to check.
 * @return The list of resolve infos found that can handle the URL.
 */
private static List<ResolveInfo> resolveInfosForUrl(Context context, String url) {
    Intent intent;
    try {
        intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME);
    } catch (Exception e) {
        return new LinkedList<>();
    }

    intent.addCategory(Intent.CATEGORY_BROWSABLE);
    intent.setComponent(null);
    Intent selector = intent.getSelector();
    if (selector != null) {
        selector.addCategory(Intent.CATEGORY_BROWSABLE);
        selector.setComponent(null);
    }
    return context.getPackageManager().queryIntentActivities(
            intent, PackageManager.GET_RESOLVED_FILTER);
}
 

@Override
public void onClick(View v) {
    if (mResetCertDecisionsButton == v) {
        nativeResetCertDecisions(mNativeConnectionInfoPopup, mWebContents);
        mDialog.dismiss();
    } else if (mCertificateViewer == v) {
        byte[][] certChain = CertificateChainHelper.getCertificateChain(mWebContents);
        if (certChain == null) {
            // The WebContents may have been destroyed/invalidated. If so,
            // ignore this request.
            return;
        }
        CertificateViewer.showCertificateChain(mContext, certChain);
    } else if (mMoreInfoLink == v) {
        mDialog.dismiss();
        try {
            Intent i = Intent.parseUri(mLinkUrl, Intent.URI_INTENT_SCHEME);
            i.putExtra(Browser.EXTRA_CREATE_NEW_TAB, true);
            i.putExtra(Browser.EXTRA_APPLICATION_ID, mContext.getPackageName());
            mContext.startActivity(i);
        } catch (Exception ex) {
            // Do nothing intentionally.
            Log.w(TAG, "Bad URI %s", mLinkUrl, ex);
        }
    }
}
 

private static void launchCustomApp(String uri) {
    if (uri == null) {
        try {
            Handler handler = (Handler) XposedHelpers.getObjectField(mPhoneWindowManager, "mHandler");
            handler.post(new Runnable() {
                @Override
                public void run() {
                    Toast.makeText(mContext, mStrCustomAppNone, Toast.LENGTH_SHORT).show();
                }
            });
        } catch (Throwable t) {
        }
        return;
    }

    try {
        Intent i = Intent.parseUri(uri, 0);
        launchCustomApp(i);
    } catch (URISyntaxException e) {
        log("launchCustomApp: error parsing uri: " + e.getMessage());
    }
}
 

public static CharSequence getDisplayValue(Context context, String value) {
    if (TextUtils.isEmpty(value)) {
        return context.getString(R.string.pref_shortcut_default);
    }

    Intent intent;
    try {
        intent = Intent.parseUri(value, Intent.URI_INTENT_SCHEME);
    } catch (URISyntaxException e) {
        return context.getString(R.string.pref_shortcut_default);
    }

    PackageManager pm = context.getPackageManager();
    List<ResolveInfo> resolveInfos = pm.queryIntentActivities(intent, 0);
    if (resolveInfos.size() == 0) {
        return null;
    }

    StringBuilder label = new StringBuilder();
    label.append(resolveInfos.get(0).loadLabel(pm));
    if (intent.getData() != null && intent.getData().getScheme() != null &&
            intent.getData().getScheme().startsWith("http")) {
        label.append(": ").append(intent.getDataString());
    }
    return label;
}
 

/**
 * @return Whether the |url| could be handled by an external application on the system.
 */
public boolean canExternalAppHandleUrl(String url) {
    if (url.startsWith(SCHEME_WTAI_MC)) return true;
    try {
        Intent intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME);
        if (intent.getPackage() != null) return true;

        List<ResolveInfo> resolvingInfos = mDelegate.queryIntentActivities(intent);
        if (resolvingInfos != null && resolvingInfos.size() > 0) return true;
    } catch (Exception ex) {
        // Ignore the error.
        Log.w(TAG, "Bad URI %s", url, ex);
    }
    return false;
}
 

private void openApp(String url) {
    Intent intent;
    try {
        intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_SINGLE_TOP);
        XUtil.getContext().startActivity(intent);
    } catch (Exception e) {
        XToastUtils.error("您所打开的第三方App未安装！");
    }
}
 

@Override
public void onClick(View v) {
    mDialog.dismiss();
    if (mCertificateViewer == v) {
        byte[][] certChain = nativeGetCertificateChain(mContentViewCore);
        CertificateViewer.showCertificateChain(mContext, certChain);
    } else if (mMoreInfoLink == v) {
        try {
            Intent i = Intent.parseUri(mLinkUrl, Intent.URI_INTENT_SCHEME);
            i.putExtra(Browser.EXTRA_CREATE_NEW_TAB, true);
            i.putExtra(Browser.EXTRA_APPLICATION_ID, mContext.getPackageName());
            mContext.startActivity(i);
        } catch (URISyntaxException ex) {}
    }
}
 

/**
 * Determines whether the URL needs to be sent as an intent to the system,
 * and sends it, if appropriate.
 * @return Whether the URL generated an intent, caused a navigation in
 *         current tab, or wasn't handled at all.
 */
public OverrideUrlLoadingResult shouldOverrideUrlLoading(ExternalNavigationParams params) {
    Intent intent;
    // Perform generic parsing of the URI to turn it into an Intent.
    try {
        intent = Intent.parseUri(params.getUrl(), Intent.URI_INTENT_SCHEME);
    } catch (Exception ex) {
        Log.w(TAG, "Bad URI %s", params.getUrl(), ex);
        return OverrideUrlLoadingResult.NO_OVERRIDE;
    }

    boolean hasBrowserFallbackUrl = false;
    String browserFallbackUrl =
            IntentUtils.safeGetStringExtra(intent, EXTRA_BROWSER_FALLBACK_URL);
    if (browserFallbackUrl != null
            && UrlUtilities.isValidForIntentFallbackNavigation(browserFallbackUrl)) {
        hasBrowserFallbackUrl = true;
    } else {
        browserFallbackUrl = null;
    }

    long time = SystemClock.elapsedRealtime();
    OverrideUrlLoadingResult result = shouldOverrideUrlLoadingInternal(
            params, intent, hasBrowserFallbackUrl, browserFallbackUrl);
    RecordHistogram.recordTimesHistogram("Android.StrictMode.OverrideUrlLoadingTime",
            SystemClock.elapsedRealtime() - time, TimeUnit.MILLISECONDS);

    if (result == OverrideUrlLoadingResult.NO_OVERRIDE && hasBrowserFallbackUrl
            && (params.getRedirectHandler() == null
                    // For instance, if this is a chained fallback URL, we ignore it.
                    || !params.getRedirectHandler().shouldNotOverrideUrlLoading())) {
        return clobberCurrentTabWithFallbackUrl(browserFallbackUrl, params);
    }
    return result;
}
 

@Override
protected Intent parseIntent(XmlResourceParser parser) {
    String uri;
    try {
        uri = getAttributeValue(parser, ATTR_URI);
        return Intent.parseUri(uri, 0);
    } catch (URISyntaxException e) {
        e.printStackTrace();
        return null; // Oh well
    }
}
 

public Intent getIntent() {

        Intent intent = null;
        try {
            intent = Intent.parseUri(action, Intent.URI_INTENT_SCHEME);
            intent.putExtra(Observations.Contract.ID, id);
            intent.putExtra(Observations.Contract.CONCEPT, concept);
        } catch (URISyntaxException e) {
            e.printStackTrace();
        }
        return intent;
    }
 

public static Intent getIntentValue(String value, Intent defaultIntent) {
    try {
        if (TextUtils.isEmpty(value)) {
            return defaultIntent;
        }

        return Intent.parseUri(value, Intent.URI_INTENT_SCHEME);
    } catch (URISyntaxException e) {
        return defaultIntent;
    }
}
 

/**
 * Creates intent to launch a WebAPK.
 * @param webApkPackageName Package name of the WebAPK to launch.
 * @param url URL to navigate WebAPK to.
 * @param forceNavigation Whether the WebAPK should be navigated to the url if the WebAPK is
 *        already open. If {@link forceNavigation} is false and the WebAPK is already running,
 *        the WebAPK will be brought to the foreground.
 * @return The intent.
 */
public static Intent createLaunchWebApkIntent(
        String webApkPackageName, String url, boolean forceNavigation) {
    Intent intent;
    try {
        intent = Intent.parseUri(url, Intent.URI_INTENT_SCHEME);
    } catch (Exception e) {
        return null;
    }

    intent.setPackage(webApkPackageName);
    intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    intent.putExtra(WebApkConstants.EXTRA_WEBAPK_FORCE_NAVIGATION, forceNavigation);
    return intent;
}
 

public static Intent getIntentFromString(String string) {
    try {
        return Intent.parseUri(string, 0);
    } catch (Exception e) {
        e.printStackTrace();
        return null;
    }
}
 

public static boolean startIntentUrl(Activity activity, String intentFullUrl) {
    try {
        Intent intent = Intent.parseUri(
                intentFullUrl,
                Intent.URI_INTENT_SCHEME
        );
        activity.startActivity(intent);
        return true;
    } catch (URISyntaxException e) {
        e.printStackTrace();
        return false;
    }
}
 

@Override
protected Intent handleOk(Intent request, Intent response) {
    int requestCode = (request != null)
            ? Intents.parseActionDescriptor(request) : Intents.NULL;
    Uri uri = (response != null) ? response.getData() : Uri.EMPTY;
    Logf.D(TAG, "handleOk(Intent)", "requestCode: " + requestCode
            + ", response descriptor: " + Uris.getDescriptor(uri));
    boolean m = false;
    // determine and return what replaces the top of the stack
    switch (requestCode) {
        case Intents.NULL:
            Logf.D(TAG, "handleOk(Intent)", "....at NULL");
            // If stack was empty send finish code
            if (request == null) {
                Logf.D(TAG, ".... Empty stack or unrecognizable Uri");
                return new Intent(Intents.ACTION_FINISH);
            } else {
                Logf.D(TAG, "handleOk(Intent)", ".... Returning to pick activity");
                return goTo(Intents.PICK_ACTIVITY);
            }
        case Intents.MAIN:
            Logf.D(TAG, "handleOk(Intent)", "....at MAIN");
            // MAIN should be root of stack so we
            return PICK_OBSERVER;
        case Intents.PICK_ACTIVITY:
            Logf.D(TAG, "handleOk(Intent)", "....at PICK_ACTIVITY");
            // the returned intent should hold the next intent to launch as
            // the data
            try {
                return Intent.parseUri(response.getDataString(),
                        Intent.URI_INTENT_SCHEME);
            } catch (URISyntaxException e) {
                e.printStackTrace();
                throw new IllegalArgumentException(e);
            }
        case Intents.INSERT:
            if (!m) Logf.D(TAG, "handleOk(Intent)", "....at INSERT");
            m = true;
        case Intents.INSERT_OR_EDIT:
            if (!m) Logf.D(TAG, "handleOk(Intent)", "....at INSERT_OR_EDIT");
            m = true;
        case Intents.PICK:
            if (!m) Logf.D(TAG, "handleOk(Intent)", "....at PICK");
            m = true;
            // content pick intent we should get data back
            switch (Uris.getDescriptor(uri)) {
                case Uris.OBSERVER_ITEM:
                case Uris.OBSERVER_UUID:
                    Logf.D(TAG, "handleOk(Intent)", "....at PICK Observer-Selected");
                    return new Intent(Intents.ACTION_PICK_ACTIVITY);
                case Uris.SUBJECT_ITEM:
                case Uris.SUBJECT_UUID:
                    Logf.D(TAG, "handleOk(Intent)", "....at PICK Subject-Selected");
                    return PICK_PROCEDURE;
                case Uris.ENCOUNTER_ITEM:
                case Uris.ENCOUNTER_UUID:
                    Logf.D(TAG, "handleOk(Intent)", "....at PICK Procedure-Selected");
                    // require the subject to be set
                    return new Intent(Intent.ACTION_VIEW, uri);
                case Uris.NOTIFICATION_ITEM:
                case Uris.NOTIFICATION_UUID:
                    Logf.D(TAG, "handleOk(Intent)", "....at PICK Notification-Selected");
                    // require the subject to be set
                    return new Intent(Intent.ACTION_VIEW, uri);
                case Uris.PROCEDURE_ITEM:
                case Uris.PROCEDURE_UUID:
                    Logf.D(TAG, "handleOk(Intent)", "....at PICK Procedure-Selected");
                    // require the subject to be set
                    return new Intent(Intent.ACTION_VIEW, uri);
                // DIR should indicate create new
                case Uris.SUBJECT_DIR:
                    Logf.D(TAG, "handleOk(Intent)", "....at PICK Subject-None Picked");
                default:
                    return goTo(Intents.PICK_ACTIVITY);
            }
        case Intents.VIEW:
            // return to the predecessor of the view
            Logf.D(TAG, "....at VIEW");
            return goTo(Intents.PICK_ACTIVITY);
    }

    // Return the result intent back to the top
    // stack should never be empty here
    return goTo(Intents.PICK_ACTIVITY);
}
 

/** A Volume {@link android.view.KeyEvent} has been long pressed. */
public void onVolumeLongPress(KeyEvent event) {
    if (null == event) return;

    // Set the action based on the KeyEvent.
    String longPressAction = null;
    switch (event.getKeyCode()) {
        case KeyEvent.KEYCODE_VOLUME_UP:
            longPressAction = longPressActionUp;
            break;
        case KeyEvent.KEYCODE_VOLUME_DOWN:
            longPressAction = longPressActionDown;
            break;
    }

    // If the event was volume up/ down, handle it. If the user is currently
    // in the middle of a call, only handle volume up/ down events.
    LOGI("VolumePanel", "onVolumeLongPress(" + event.getKeyCode() + ") action=" + longPressAction);
    boolean callIdle = (mCallState == TelephonyManager.CALL_STATE_IDLE);
    if (!TextUtils.isEmpty(longPressAction) && callIdle) {
        try {
            Intent action = Intent.parseUri(longPressAction, Intent.URI_INTENT_SCHEME);
            startActivity(action);
        } catch (URISyntaxException e) {
            LOGE("VolumePanel", "Error parsing long press action as an Intent.", e);
        }
    } else {
        // If we don't have a long press event, use this timeout as
        // a key timeout for volume manipulation.
        final int adjust = ((event.getKeyCode() == KeyEvent.KEYCODE_VOLUME_UP) ?
                AudioManager.ADJUST_RAISE : AudioManager.ADJUST_LOWER);
        int flags = getFlags(lastStreamType);
        flags &= ~FLAG_PLAY_SOUND;
        flags &= ~FLAG_VIBRATE;
        // Adjust stream volume, but avoid making noises continuously.
        int stream = lastStreamType;
        if (hasDefaultStream()) stream = defaultStream;
        boolean ringerAffected = mAudioHelper.isStreamAffectedByRingerMode(stream);

        // Ringer mode transition for long-press actions
        /*if (ringerAffected) {
            int volume = getStreamVolume(stream);
            // If we're already at silent, stop listening.
            if ((adjust == ADJUST_LOWER) && (volume == 0) &&
                    (mRingerMode == AudioManager.RINGER_MODE_SILENT)) {
                return;
            } else if (adjust == ADJUST_RAISE && volume == 0) {
                int nextRinger = Utils.nextRingerMode(adjust, mRingerMode);
                mAudioManager.setRingerMode(nextRinger);
            }
        }*/

        LOGI("VolumePanel", "[stream=" + stream + ", lastStream=" + lastStreamType +
            ", ringerAffected=" + ringerAffected + ']');

        adjustSuggestedStreamVolume(adjust, stream, flags);
        mVolumeDirty = true; // This is needed to show our volume change!
        mIgnoreNextKeyUp = false; // This is key to avoid infinite loops!
        if (!noLongPress || hasLongPressAction(event.getKeyCode())) {
            mHandler.sendMessageDelayed(mHandler.obtainMessage(
                    MSG_VOLUME_LONG_PRESS, event), (mLongPressTimeout / 3));
        }
        show();
    }
}
 

@Override
protected long invalidPackageOrClass(XmlResourceParser parser) {
    final String uri = getAttributeValue(parser, ATTR_URI);
    if (TextUtils.isEmpty(uri)) {
        return -1;
    }

    final Intent metaIntent;
    try {
        metaIntent = Intent.parseUri(uri, 0);
    } catch (URISyntaxException e) {
        e.printStackTrace();
        return -1;
    }

    ResolveInfo resolved = mPackageManager.resolveActivity(metaIntent,
            PackageManager.MATCH_DEFAULT_ONLY);
    final List<ResolveInfo> appList = mPackageManager.queryIntentActivities(
            metaIntent, PackageManager.MATCH_DEFAULT_ONLY);

    // Verify that the result is an app and not just the resolver dialog asking which
    // app to use.
    if (wouldLaunchResolverActivity(resolved, appList)) {
        // If only one of the results is a system app then choose that as the default.
        final ResolveInfo systemApp = getSingleSystemActivity(appList);
        if (systemApp == null) {
            // There is no logical choice for this meta-favorite, so rather than making
            // a bad choice just add nothing.
            return -1;
        }
        resolved = systemApp;
    }
    final ActivityInfo info = resolved.activityInfo;
    final Intent intent = mPackageManager.getLaunchIntentForPackage(info.packageName);
    if (intent == null) {
        return -1;
    }
    intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
            Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);

    return addShortcut(info.loadLabel(mPackageManager).toString(), intent,
            Favorites.ITEM_TYPE_APPLICATION);
}
 

private void resolveIntent() {
    try {
        mIntent = Intent.parseUri(mQuickActionUri, 0);
    } catch (URISyntaxException e) {
        // If the intent cannot be parsed, there is no quick action available.
        ContextualSearchUma.logQuickActionIntentResolution(mQuickActionCategory, 0);
        reset();
        return;
    }

    PackageManager packageManager = mContext.getPackageManager();

    // If a default is set, PackageManager#resolveActivity() will return the ResolveInfo
    // for the default activity.
    ResolveInfo possibleDefaultActivity = packageManager.resolveActivity(mIntent, 0);

    // PackageManager#queryIntentActivities() will return a list of activities that can handle
    // the intent, sorted from best to worst. If there are no matching activities, an empty
    // list is returned.
    List<ResolveInfo> resolveInfoList = packageManager.queryIntentActivities(
            mIntent, 0);

    int numMatchingActivities = 0;
    ResolveInfo defaultActivityResolveInfo = null;
    for (ResolveInfo resolveInfo : resolveInfoList) {
        // TODO(twellington): do not count browser activities as a match?
        if (resolveInfo.activityInfo != null && resolveInfo.activityInfo.exported) {
            numMatchingActivities++;

            // Return early if this resolveInfo matches the possibleDefaultActivity.
            ActivityInfo possibleDefaultActivityInfo = possibleDefaultActivity.activityInfo;
            if (possibleDefaultActivityInfo == null) continue;

            ActivityInfo resolveActivityInfo = resolveInfo.activityInfo;
            boolean matchesPossibleDefaultActivity =
                    TextUtils.equals(resolveActivityInfo.name,
                            possibleDefaultActivityInfo.name)
                    && TextUtils.equals(resolveActivityInfo.packageName,
                            possibleDefaultActivityInfo.packageName);

            if (matchesPossibleDefaultActivity) {
                defaultActivityResolveInfo = resolveInfo;
                break;
            }
        }
    }

    ContextualSearchUma.logQuickActionIntentResolution(mQuickActionCategory,
            numMatchingActivities);

    if (numMatchingActivities == 0) {
        reset();
        return;
    }

    mHasQuickAction = true;
    Drawable iconDrawable = null;
    int iconResId = 0;
    if (defaultActivityResolveInfo != null) {
        iconDrawable = defaultActivityResolveInfo.loadIcon(mContext.getPackageManager());

        if (mQuickActionCategory != QuickActionCategory.PHONE) {
            // Use the default app's name to construct the caption.
            mCaption = mContext.getResources().getString(
                    DEFAULT_APP_CAPTION_MAP.get(mQuickActionCategory),
                    defaultActivityResolveInfo.loadLabel(packageManager));
        } else {
            // The caption for phone numbers does not use the app's name.
            mCaption = mContext.getResources().getString(
                    DEFAULT_APP_CAPTION_MAP.get(mQuickActionCategory));
        }
    } else {
        iconResId = ICON_MAP.get(mQuickActionCategory);
        mCaption = mContext.getResources().getString(
                FALLBACK_CAPTION_MAP.get(mQuickActionCategory));
    }

    inflate();

    if (iconDrawable != null) {
        ((ImageView) getView()).setImageDrawable(iconDrawable);
    } else {
        ((ImageView) getView()).setImageResource(iconResId);
    }

    invalidate();
}
 

/**
 * Find and open the appropriate app for a given Uri. If appropriate, let the user select between
 * multiple supported apps. Returns a boolean indicating whether the URL was handled. A fallback
 * URL will be opened in the supplied WebView if appropriate (in which case the URL was handled,
 * and true will also be returned). If not handled, we should  fall back to webviews error handling
 * (which ends up calling our error handling code as needed).
 *
 * Note: this method "leaks" the target Uri to Android before asking the user whether they
 * want to use an external app to open the uri. Ultimately the OS can spy on anything we're
 * doing in the app, so this isn't an actual "bug".
 */
public static boolean handleExternalUri(final Context context, final IWebView webView, final String uri) {
    // This code is largely based on Fennec's ExternalIntentDuringPrivateBrowsingPromptFragment.java
    final Intent intent;
    try {
        intent = Intent.parseUri(uri, 0);
    } catch (URISyntaxException e) {
        // Let the browser handle the url (i.e. let the browser show it's unsupported protocol /
        // invalid URL page).
        return false;
    }

    // Since we're a browser:
    intent.addCategory(Intent.CATEGORY_BROWSABLE);

    final PackageManager packageManager = context.getPackageManager();

    // This is where we "leak" the uri to the OS. If we're using the system webview, then the OS
    // already knows that we're opening this uri. Even if we're using GeckoView, the OS can still
    // see what domains we're visiting, so there's no loss of privacy here:
    final List<ResolveInfo> matchingActivities = packageManager.queryIntentActivities(intent, 0);

    if (matchingActivities.size() == 0) {
        return handleUnsupportedLink(webView, intent);
    } else if (matchingActivities.size() == 1) {
        final ResolveInfo info;

        if (matchingActivities.size() == 1) {
            info = matchingActivities.get(0);
        } else {
            // Ordering isn't guaranteed if there is more than one available activity - hence
            // we fetch the default (this code isn't currently run because we handle the > 1
            // case separately, but would be needed if we ever decide to prefer the default
            // app for the > 1 case.
            info = packageManager.resolveActivity(intent, 0);
        }
        final CharSequence externalAppTitle = info.loadLabel(packageManager);

        showConfirmationDialog(context, intent, context.getString(R.string.external_app_prompt_title), R.string.external_app_prompt, externalAppTitle);
        return true;
    } else { // matchingActivities.size() > 1
        // By explicitly showing the chooser, we can avoid having a (default) app from opening
        // the link immediately. This isn't perfect - we'd prefer to highlight the default app,
        // but it's not clear if there's any way of doing that. An alternative
        // would be to reuse the same dialog as for the single-activity case, and offer
        // a "open in other app this time" button if we have more than one matchingActivity.
        final String chooserTitle = context.getString(R.string.external_multiple_apps_matched_exit);
        final Intent chooserIntent = Intent.createChooser(intent, chooserTitle);
        context.startActivity(chooserIntent);

        return true;
    }
}
 

public static void startActivity(Context activity,String intentUri) throws URISyntaxException,ActivityNotFoundException {

        Intent intent = Intent.parseUri(intentUri,Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT);

        if(intent!= null){

            activity.startActivity(intent);
        }else {

            throw new  ActivityNotFoundException();
        }

    }