Java ThreadUtils类代码示例

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Requests an authentication token. If the account is not properly setup, it will result in
 * a failure.
 *
 * @param ctx The application context
 * @param requestData The object holding the data related to the current request
 * @param features An array of the account features to require, may be null or empty
 */
private void requestTokenWithoutActivity(
        Context ctx, RequestData requestData, String[] features) {
    if (lacksPermission(ctx, Manifest.permission.GET_ACCOUNTS, true /* onlyPreM */)) {
        // Protecting the AccountManager#getAccountsByTypeAndFeatures call.
        // API  < 23 Requires the GET_ACCOUNTS permission or throws an exception.
        // API >= 23 Requires the GET_ACCOUNTS permission (CONTACTS permission group) or
        //           returns only the accounts whose authenticator has a signature that
        //           matches our app. Working with this restriction and not requesting
        //           the permission is a valid use case in the context of WebView, so we
        //           don't require it on M+
        Log.e(TAG, "ERR_MISCONFIGURED_AUTH_ENVIRONMENT: GET_ACCOUNTS permission not "
                        + "granted. Aborting authentication.");
        nativeSetResult(requestData.nativeResultObject,
                NetError.ERR_MISCONFIGURED_AUTH_ENVIRONMENT, null);
        return;
    }
    requestData.accountManager.getAccountsByTypeAndFeatures(mAccountType, features,
            new GetAccountsCallback(requestData), new Handler(ThreadUtils.getUiThreadLooper()));
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Performs an asynchronous check to see if the user is a managed user.
 * @param callback A callback to be called with true if the user is a managed user and false
 *         otherwise.
 */
public static void isUserManaged(String email, final Callback<Boolean> callback) {
    if (nativeShouldLoadPolicyForUser(email)) {
        nativeIsUserManaged(email, callback);
    } else {
        // Although we know the result immediately, the caller may not be able to handle the
        // callback being executed during this method call. So we post the callback on the
        // looper.
        ThreadUtils.postOnUiThread(new Runnable() {
            @Override
            public void run() {
                callback.onResult(false);
            }
        });
    }
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
@Override
public void setTitleToPageTitle() {
    Tab currentTab = getToolbarDataProvider().getTab();
    if (currentTab == null || TextUtils.isEmpty(currentTab.getTitle())) {
        mTitleBar.setText("");
        return;
    }
    String title = currentTab.getTitle();

    // It takes some time to parse the title of the webcontent, and before that Tab#getTitle
    // always return the url. We postpone the title animation until the title is authentic.
    if ((mState == STATE_DOMAIN_AND_TITLE || mState == STATE_TITLE_ONLY)
            && !title.equals(currentTab.getUrl())
            && !title.equals(UrlConstants.ABOUT_BLANK)) {
        // Delay the title animation until security icon animation finishes.
        ThreadUtils.postOnUiThreadDelayed(mTitleAnimationStarter, TITLE_ANIM_DELAY_MS);
    }

    mTitleBar.setText(title);
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
private void captureNavigationInfo(final Tab tab) {
    if (mCustomTabsConnection == null) return;
    if (!mCustomTabsConnection.shouldSendNavigationInfoForSession(mSession)) return;

    final ContentBitmapCallback callback = new ContentBitmapCallback() {
        @Override
        public void onFinishGetBitmap(Bitmap bitmap, int response) {
            if (TextUtils.isEmpty(tab.getTitle()) && bitmap == null) return;
            mCustomTabsConnection.sendNavigationInfo(
                    mSession, tab.getUrl(), tab.getTitle(), bitmap);
        }
    };
    // Delay screenshot capture since the page might be doing post load tasks. And this also
    // gives time to get rid of any redirects and avoid capturing screenshots for those.
    ThreadUtils.postOnUiThreadDelayed(new Runnable() {
        @Override
        public void run() {
            if (!tab.isHidden() && mCurrentState != STATE_RESET) return;
            if (tab.getWebContents() == null) return;
            tab.getWebContents().getContentBitmapAsync(
                    Bitmap.Config.ARGB_8888, mScaleForNavigationInfo, new Rect(), callback);
            mScreenshotTakenForCurrentNavigation = true;
        }
    }, 1000);
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Checks whether Chrome is sufficiently initialized to handle a call to the
 * ChromeBrowserProvider.
 */
private boolean canHandleContentProviderApiCall() {
    if (isInUiThread()) return false;
    ensureUriMatcherInitialized();
    if (mNativeChromeBrowserProvider != 0) return true;
    synchronized (mLoadNativeLock) {
        ThreadUtils.runOnUiThreadBlocking(new Runnable() {
            @Override
            @SuppressFBWarnings("DM_EXIT")
            public void run() {
                if (mNativeChromeBrowserProvider != 0) return;
                try {
                    ChromeBrowserInitializer.getInstance(getContext())
                            .handleSynchronousStartup();
                } catch (ProcessInitException e) {
                    // Chrome browser runs in the background, so exit silently; but do exit,
                    // since otherwise the next attempt to use Chrome will find a broken JNI.
                    System.exit(-1);
                }
                ensureNativeSideInitialized();
            }
        });
    }
    return true;
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
private static void unregisterActivity(final Activity activity) {
    ThreadUtils.assertOnUiThread();

    sPendingShareActivities.remove(activity);
    if (!sPendingShareActivities.isEmpty()) return;
    ApplicationStatus.unregisterActivityStateListener(sStateListener);

    waitForPendingStateChangeTask();
    sStateChangeTask = new AsyncTask<Void, Void, Void>() {
        @Override
        protected Void doInBackground(Void... params) {
            if (!sPendingShareActivities.isEmpty()) return null;

            activity.getPackageManager().setComponentEnabledSetting(
                    new ComponentName(activity, PrintShareActivity.class),
                    PackageManager.COMPONENT_ENABLED_STATE_DISABLED,
                    PackageManager.DONT_KILL_APP);
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            if (sStateChangeTask == this) sStateChangeTask = null;
        }
    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Notify native listeners with an updated estimate of the distance to the broadcasting device.
 * No notification will be sent if the feature is in the Onboarding state.
 * @param url The Physical Web URL.
 * @param distanceEstimate The updated distance estimate.
 */
private void safeNotifyNativeListenersOnDistanceChanged(
        final String url, final double distanceEstimate) {
    if (!isNativeInitialized() || PhysicalWeb.isOnboarding()) {
        return;
    }

    ThreadUtils.postOnUiThread(new Runnable() {
        @Override
        public void run() {
            if (isNativeInitialized()) {
                nativeOnDistanceChanged(mNativePhysicalWebDataSourceAndroid, url,
                        distanceEstimate);
            }
        }
    });
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Prepares screenshot (possibly asynchronously) and invokes the callback when the screenshot
 * is available, or collection has failed. The asynchronous path is only taken when the activity
 * that is passed in is a {@link ChromeActivity}.
 * The callback is always invoked asynchronously.
 */
public static void create(Activity activity, final ScreenshotTaskCallback callback) {
    if (activity instanceof ChromeActivity) {
        Rect rect = new Rect();
        activity.getWindow().getDecorView().getRootView().getWindowVisibleDisplayFrame(rect);
        createCompositorScreenshot(((ChromeActivity) activity).getWindowAndroid(), rect,
                callback);
        return;
    }

    final Bitmap bitmap = prepareScreenshot(activity, null);
    ThreadUtils.postOnUiThread(new Runnable() {
        @Override
        public void run() {
            callback.onGotBitmap(bitmap);
        }
    });
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * A static method for native code to open the external feedback form UI.
 * @param webContents The WebContents containing the distilled content.
 * @param url The URL to report feedback for.
 * @param good True if the feedback is good and false if not.
 */
@CalledByNative
public static void reportFeedbackWithWebContents(
        WebContents webContents, String url, final boolean good) {
    ThreadUtils.assertOnUiThread();
    // TODO(mdjones): It would be better to get the WebContents from the manager so that the
    // native code does not need to depend on RenderFrame.
    Activity activity = getActivityFromWebContents(webContents);
    if (activity == null) return;

    if (sFeedbackReporter == null) {
        ChromeApplication application = (ChromeApplication) activity.getApplication();
        sFeedbackReporter = application.createFeedbackReporter();
    }
    FeedbackCollector.create(activity, Profile.getLastUsedProfile(), url,
            new FeedbackCollector.FeedbackResult() {
                @Override
                public void onResult(FeedbackCollector collector) {
                    String quality =
                            good ? DISTILLATION_QUALITY_GOOD : DISTILLATION_QUALITY_BAD;
                    collector.add(DISTILLATION_QUALITY_KEY, quality);
                    sFeedbackReporter.reportFeedback(collector);
                }
            });
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
private void preInflationStartup() {
    ThreadUtils.assertOnUiThread();
    if (mPreInflationStartupComplete) return;
    PathUtils.setPrivateDataDirectorySuffix(PRIVATE_DATA_DIRECTORY_SUFFIX);

    // Ensure critical files are available, so they aren't blocked on the file-system
    // behind long-running accesses in next phase.
    // Don't do any large file access here!
    ContentApplication.initCommandLine(mApplication);
    waitForDebuggerIfNeeded();
    ChromeStrictMode.configureStrictMode();
    ChromeWebApkHost.init();

    warmUpSharedPrefs();

    DeviceUtils.addDeviceSpecificUserAgentSwitch(mApplication);
    ApplicationStatus.registerStateListenerForAllActivities(
            createActivityStateListener());

    mPreInflationStartupComplete = true;
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Relay a postMessage request through the current channel assigned to this session.
 * @param message The message to be sent.
 * @return The result of the postMessage request. Returning true means the request was accepted,
 *         not necessarily that the postMessage was successful.
 */
public int postMessage(final String message) {
    if (mChannel == null || !mChannel[0].isReady() || mChannel[0].isClosed()) {
        return CustomTabsService.RESULT_FAILURE_MESSAGING_ERROR;
    }
    ThreadUtils.postOnUiThread(new Runnable() {
        @Override
        public void run() {
            // It is still possible that the page has navigated while this task is in the queue.
            // If that happens fail gracefully.
            if (mChannel == null || mChannel[0].isClosed()) return;
            mChannel[0].postMessage(message, null);
        }
    });
    return CustomTabsService.RESULT_SUCCESS;
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
@BinderThread
private BookmarkFolder loadBookmarks(final BookmarkId folderId) {
    final LinkedBlockingQueue<BookmarkFolder> resultQueue = new LinkedBlockingQueue<>(1);
    //A reference of BookmarkLoader is needed in binder thread to
    //prevent it from being garbage collected.
    final BookmarkLoader bookmarkLoader = new BookmarkLoader();
    ThreadUtils.runOnUiThread(new Runnable() {
        @Override
        public void run() {
            bookmarkLoader.initialize(mContext, folderId, new BookmarkLoaderCallback() {
                @Override
                public void onBookmarksLoaded(BookmarkFolder folder) {
                    resultQueue.add(folder);
                }
            });
        }
    });
    try {
        return resultQueue.take();
    } catch (InterruptedException e) {
        return null;
    }
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
@BinderThread
@Override
public int getCount() {
    //On some Sony devices, getCount() could be called before onDatasetChanged()
    //returns. If it happens, refresh widget until the bookmarks are all loaded.
    if (mCurrentFolder == null || !mPreferences.getString(PREF_CURRENT_FOLDER, "")
            .equals(mCurrentFolder.folder.id.toString())) {
        ThreadUtils.runOnUiThread(new Runnable() {
            @Override
            public void run() {
                refreshWidget();
            }
        });
    }
    if (mCurrentFolder == null) {
        return 0;
    }
    return mCurrentFolder.children.size() + (mCurrentFolder.parent != null ? 1 : 0);
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/** Warmup activities that should only happen once. */
@SuppressFBWarnings("DM_EXIT")
private static void initializeBrowser(final Application app) {
    ThreadUtils.assertOnUiThread();
    try {
        ChromeBrowserInitializer.getInstance(app).handleSynchronousStartup();
    } catch (ProcessInitException e) {
        Log.e(TAG, "ProcessInitException while starting the browser process.");
        // Cannot do anything without the native library, and cannot show a
        // dialog to the user.
        System.exit(-1);
    }
    final Context context = app.getApplicationContext();
    final ChromeApplication chrome = (ChromeApplication) context;
    ChildProcessCreationParams.set(chrome.getChildProcessCreationParams());
    new AsyncTask<Void, Void, Void>() {
        @Override
        protected Void doInBackground(Void... params) {
            ChildProcessLauncher.warmUp(context);
            return null;
        }
    }.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
    ChromeBrowserInitializer.initNetworkChangeNotifier(context);
    WarmupManager.getInstance().initializeViewHierarchy(
            context, R.layout.custom_tabs_control_container, R.layout.custom_tabs_toolbar);
}
 

import org.chromium.base.ThreadUtils; //导入依赖的package包/类
/**
 * Destroys the Incognito profile when all Incognito tabs have been closed.  Also resets the
 * delegate TabModel to be a stub EmptyTabModel.
 */
protected void destroyIncognitoIfNecessary() {
    ThreadUtils.assertOnUiThread();
    if (!isEmpty() || mDelegateModel instanceof EmptyTabModel || mIsAddingTab) {
        return;
    }

    Profile profile = getProfile();
    mDelegateModel.destroy();

    // Only delete the incognito profile if there are no incognito tabs open in any tab
    // model selector as the profile is shared between them.
    if (profile != null && !mDelegate.doIncognitoTabsExist()) {
        IncognitoNotificationManager.dismissIncognitoNotification();

        profile.destroyWhenAppropriate();
    }

    mDelegateModel = EmptyTabModel.getInstance();
}