Merge "Add thread annotations (1/n)"

package com.android.server.rollback;

import android.Manifest;

import android.annotation.AnyThread;

import android.annotation.NonNull;

import android.annotation.UserIdInt;

import android.annotation.WorkerThread;

import android.app.AppOpsManager;

import android.content.BroadcastReceiver;

import android.content.Context;

/**

 * Implementation of service that manages APK level rollbacks.

 *

 * Threading model:

 *

 * - @AnyThread annotates thread-safe methods.

 * - @WorkerThread annotates methods that should be called from the handler thread only.

 */

class RollbackManagerServiceImpl extends IRollbackManager.Stub {

        registerTimeChangeReceiver();

    }

    @AnyThread

    private void registerUserCallbacks(UserHandle user) {

        Context context = getContextAsUser(user);

        if (context == null) {

                    callerPackageName, statusReceiver));

    }

    @AnyThread

    private void registerTimeChangeReceiver() {

        final BroadcastReceiver timeChangeIntentReceiver = new BroadcastReceiver() {

            @Override

                null /* broadcastPermission */, getHandler());

    }

    @AnyThread

    private static long calculateRelativeBootTime() {

        return System.currentTimeMillis() - SystemClock.elapsedRealtime();

    }

     * The work is done on the current thread. This may be a long running

     * operation.

     */

    @WorkerThread

    private void commitRollbackInternal(int rollbackId, List<VersionedPackage> causePackages,

            String callerPackageName, IntentSender statusReceiver) {

        Slog.i(TAG, "commitRollback id=" + rollbackId + " caller=" + callerPackageName);

        });

    }

    @WorkerThread

    private void queueSleepIfNeeded() {

        if (mSleepDuration.size() == 0) {

            return;

        }

    }

    @WorkerThread

    private void updateRollbackLifetimeDurationInMillis() {

        mRollbackLifetimeDurationInMillis = DeviceConfig.getLong(

                DeviceConfig.NAMESPACE_ROLLBACK_BOOT,

        }

    }

    @AnyThread

    void onBootCompleted() {

        getHandler().post(() -> updateRollbackLifetimeDurationInMillis());

        // Also posts to handler thread

     * Removes all backups for the package not matching the currently

     * installed package version.

     */

    @WorkerThread

    private void onPackageReplaced(String packageName) {

        // TODO: Could this end up incorrectly deleting a rollback for a

        // package that is about to be installed?

     * Called when a package has been completely removed from the device.

     * Removes all backups and rollback history for the given package.

     */

    @WorkerThread

    private void onPackageFullyRemoved(String packageName) {

        expireRollbackForPackage(packageName);

    }

     * @param status the RollbackManager.STATUS_* code with the failure.

     * @param message the failure message.

     */

    @AnyThread

    static void sendFailure(Context context, IntentSender statusReceiver,

            @RollbackManager.Status int status, String message) {

        Slog.e(TAG, message);

    // Check to see if anything needs expiration, and if so, expire it.

    // Schedules future expiration as appropriate.

    @WorkerThread

    private void runExpiration() {

        Instant now = Instant.now();

        Instant oldest = null;

     * Schedules an expiration check to be run after the given duration in

     * milliseconds has gone by.

     */

    @AnyThread

    private void scheduleExpiration(long duration) {

        getHandler().postDelayed(() -> runExpiration(), duration);

    }

    @AnyThread

    private Handler getHandler() {

        return mHandlerThread.getThreadHandler();

    }

    // Returns true if <code>session</code> has installFlags and code path

    // matching the installFlags and new package code path given to

    // enableRollback.

    @WorkerThread

    private boolean sessionMatchesForEnableRollback(PackageInstaller.SessionInfo session,

            int installFlags, File newPackageCodePath) {

        if (session == null || session.resolvedBaseCodePath == null) {

        return false;

    }

    @AnyThread

    private Context getContextAsUser(UserHandle user) {

        try {

            return mContext.createPackageContextAsUser(mContext.getPackageName(), 0, user);

     * @param token the distinct rollback token sent by package manager.

     * @return true if enabling the rollback succeeds, false otherwise.

     */

    @WorkerThread

    private boolean enableRollback(

            int installFlags, File newPackageCodePath, @UserIdInt int user, int token) {

        if (LOCAL_LOGV) {

        return enableRollbackForPackageSession(newRollback.rollback, packageSession);

    }

    @WorkerThread

    private void removeRollbackForPackageSessionId(int sessionId) {

        if (LOCAL_LOGV) {

            Slog.v(TAG, "removeRollbackForPackageSessionId=" + sessionId);

     *

     * @return true on success, false on failure.

     */

    @WorkerThread

    private boolean enableRollbackForPackageSession(Rollback rollback,

            PackageInstaller.SessionInfo session) {

        // TODO: Don't attempt to enable rollback for split installs.

        });

    }

    @WorkerThread

    private void snapshotUserDataInternal(String packageName, int[] userIds) {

        if (LOCAL_LOGV) {

            Slog.v(TAG, "snapshotUserData pkg=" + packageName

        }

    }

    @WorkerThread

    private void restoreUserDataInternal(

            String packageName, int[] userIds, int appId, String seInfo) {

        if (LOCAL_LOGV) {

     * Returns true if the installer is allowed to enable rollback for the

     * given named package, false otherwise.

     */

    @AnyThread

    private boolean enableRollbackAllowed(String installerPackageName, String packageName) {

        if (installerPackageName == null) {

            return false;

    /**

     * Returns true is this package is eligible for enabling rollback.

     */

    @AnyThread

    private boolean isRollbackWhitelisted(String packageName) {

        // TODO: Remove #isModule when the white list is ready.

        return SystemConfig.getInstance().getRollbackWhitelistedPackages().contains(packageName)

    /**

     * Returns true if the package name is the name of a module.

     */

    @AnyThread

    private boolean isModule(String packageName) {

        PackageManager pm = mContext.getPackageManager();

        final ModuleInfo moduleInfo;

     * Gets the version of the package currently installed.

     * Returns -1 if the package is not currently installed.

     */

    @AnyThread

    private long getInstalledPackageVersion(String packageName) {

        PackageInfo pkgInfo;

        try {

     *

     * @throws PackageManager.NameNotFoundException if no such package is installed.

     */

    @AnyThread

    private PackageInfo getPackageInfo(String packageName)

            throws PackageManager.NameNotFoundException {

        PackageManager pm = mContext.getPackageManager();

        }

    }

    @WorkerThread

    private class SessionCallback extends PackageInstaller.SessionCallback {

        @Override

     * @return the Rollback instance for a successfully enable-completed rollback,

     * or null on error.

     */

    @WorkerThread

    private Rollback completeEnableRollback(NewRollback newRollback) {

        Rollback rollback = newRollback.rollback;

        if (LOCAL_LOGV) {

        return rollback;

    }

    @WorkerThread

    @GuardedBy("rollback.getLock")

    private void makeRollbackAvailable(Rollback rollback) {

        if (LOCAL_LOGV) {

    /*

     * Returns the rollback with the given rollbackId, if any.

     */

    @WorkerThread

    private Rollback getRollbackForId(int rollbackId) {

        synchronized (mLock) {

            for (int i = 0; i < mRollbacks.size(); ++i) {

        return null;

    }

    @WorkerThread

    @GuardedBy("mLock")

    private int allocateRollbackIdLocked() {

        int n = 0;

        }

    }

    @AnyThread

    private void enforceManageRollbacks(@NonNull String message) {

        if ((PackageManager.PERMISSION_GRANTED != mContext.checkCallingOrSelfPermission(

                        Manifest.permission.MANAGE_ROLLBACKS))

        }

    }

    @WorkerThread

    @GuardedBy("mLock")

    private NewRollback createNewRollbackLocked(PackageInstaller.SessionInfo parentSession) {

        int rollbackId = allocateRollbackIdLocked();

     * Returns null if no NewRollback is found for the given package

     * session.

     */

    @WorkerThread

    @GuardedBy("mLock")

    NewRollback getNewRollbackForPackageSessionLocked(int packageSessionId) {

        // We expect mNewRollbacks to be a very small list; linear search