Java Code Examples for android.os.storage.StorageManager#isUserKeyUnlocked()

@Override
public boolean requestQuietModeEnabled(@NonNull String callingPackage, boolean enableQuietMode,
        int userHandle, @Nullable IntentSender target) {
    Preconditions.checkNotNull(callingPackage);

    if (enableQuietMode && target != null) {
        throw new IllegalArgumentException(
                "target should only be specified when we are disabling quiet mode.");
    }

    ensureCanModifyQuietMode(callingPackage, Binder.getCallingUid(), target != null);
    final long identity = Binder.clearCallingIdentity();
    try {
        if (enableQuietMode) {
            setQuietModeEnabled(userHandle, true /* enableQuietMode */, target);
            return true;
        } else {
            boolean needToShowConfirmCredential =
                    mLockPatternUtils.isSecure(userHandle)
                            && !StorageManager.isUserKeyUnlocked(userHandle);
            if (needToShowConfirmCredential) {
                showConfirmCredentialToDisableQuietMode(userHandle, target);
                return false;
            } else {
                setQuietModeEnabled(userHandle, false /* enableQuietMode */, target);
                return true;
            }
        }
    } finally {
        Binder.restoreCallingIdentity(identity);
    }
}
 

@Override
public boolean isUserUnlockingOrUnlocked(int userId) {
    int state;
    synchronized (mUserStates) {
        state = mUserStates.get(userId, -1);
    }
    // Special case, in the stopping/shutdown state user key can still be unlocked
    if (state == UserState.STATE_STOPPING || state == UserState.STATE_SHUTDOWN) {
        return StorageManager.isUserKeyUnlocked(userId);
    }
    return (state == UserState.STATE_RUNNING_UNLOCKING)
            || (state == UserState.STATE_RUNNING_UNLOCKED);
}
 

@Override
public boolean isUserUnlocked(int userId) {
    int state;
    synchronized (mUserStates) {
        state = mUserStates.get(userId, -1);
    }
    // Special case, in the stopping/shutdown state user key can still be unlocked
    if (state == UserState.STATE_STOPPING || state == UserState.STATE_SHUTDOWN) {
        return StorageManager.isUserKeyUnlocked(userId);
    }
    return state == UserState.STATE_RUNNING_UNLOCKED;
}
 

/**
 * Step from {@link UserState#STATE_RUNNING_LOCKED} to
 * {@link UserState#STATE_RUNNING_UNLOCKING}.
 */
private void finishUserUnlocking(final UserState uss) {
    final int userId = uss.mHandle.getIdentifier();
    // Only keep marching forward if user is actually unlocked
    if (!StorageManager.isUserKeyUnlocked(userId)) return;
    synchronized (mLock) {
        // Do not proceed if unexpected state or a stale user
        if (mStartedUsers.get(userId) != uss || uss.state != STATE_RUNNING_LOCKED) {
            return;
        }
    }
    uss.mUnlockProgress.start();

    // Prepare app storage before we go any further
    uss.mUnlockProgress.setProgress(5,
                mInjector.getContext().getString(R.string.android_start_title));

    // Call onBeforeUnlockUser on a worker thread that allows disk I/O
    FgThread.getHandler().post(() -> {
        if (!StorageManager.isUserKeyUnlocked(userId)) {
            Slog.w(TAG, "User key got locked unexpectedly, leaving user locked.");
            return;
        }
        mInjector.getUserManager().onBeforeUnlockUser(userId);
        synchronized (mLock) {
            // Do not proceed if unexpected state
            if (!uss.setState(STATE_RUNNING_LOCKED, STATE_RUNNING_UNLOCKING)) {
                return;
            }
        }
        mInjector.getUserManagerInternal().setUserState(userId, uss.state);

        uss.mUnlockProgress.setProgress(20);

        // Dispatch unlocked to system services; when fully dispatched,
        // that calls through to the next "unlocked" phase
        mHandler.obtainMessage(SYSTEM_USER_UNLOCK_MSG, userId, 0, uss)
                .sendToTarget();
    });
}
 

/** Checks whether the activity should be shown for current user. */
public boolean okToShowLocked() {
    // We cannot show activities when the device is locked and the application is not
    // encryption aware.
    if (!StorageManager.isUserKeyUnlocked(userId)
            && !info.applicationInfo.isEncryptionAware()) {
        return false;
    }

    return (info.flags & FLAG_SHOW_FOR_ALL_USERS) != 0
            || (mStackSupervisor.isCurrentProfileLocked(userId)
            && service.mUserController.isUserRunning(userId, 0 /* flags */));
}
 

/**
 * Step from {@link UserState#STATE_RUNNING_UNLOCKING} to
 * {@link UserState#STATE_RUNNING_UNLOCKED}.
 */
void finishUserUnlocked(final UserState uss) {
    final int userId = uss.mHandle.getIdentifier();
    // Only keep marching forward if user is actually unlocked
    if (!StorageManager.isUserKeyUnlocked(userId)) return;
    synchronized (mLock) {
        // Bail if we ended up with a stale user
        if (mStartedUsers.get(uss.mHandle.getIdentifier()) != uss) return;

        // Do not proceed if unexpected state
        if (!uss.setState(STATE_RUNNING_UNLOCKING, STATE_RUNNING_UNLOCKED)) {
            return;
        }
    }
    mInjector.getUserManagerInternal().setUserState(userId, uss.state);
    uss.mUnlockProgress.finish();

    // Get unaware persistent apps running and start any unaware providers
    // in already-running apps that are partially aware
    if (userId == UserHandle.USER_SYSTEM) {
        mInjector.startPersistentApps(PackageManager.MATCH_DIRECT_BOOT_UNAWARE);
    }
    mInjector.installEncryptionUnawareProviders(userId);

    // Dispatch unlocked to external apps
    final Intent unlockedIntent = new Intent(Intent.ACTION_USER_UNLOCKED);
    unlockedIntent.putExtra(Intent.EXTRA_USER_HANDLE, userId);
    unlockedIntent.addFlags(
            Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
    mInjector.broadcastIntent(unlockedIntent, null, null, 0, null,
            null, null, AppOpsManager.OP_NONE, null, false, false, MY_PID, SYSTEM_UID,
            userId);

    if (getUserInfo(userId).isManagedProfile()) {
        UserInfo parent = mInjector.getUserManager().getProfileParent(userId);
        if (parent != null) {
            final Intent profileUnlockedIntent = new Intent(
                    Intent.ACTION_MANAGED_PROFILE_UNLOCKED);
            profileUnlockedIntent.putExtra(Intent.EXTRA_USER, UserHandle.of(userId));
            profileUnlockedIntent.addFlags(
                    Intent.FLAG_RECEIVER_REGISTERED_ONLY
                            | Intent.FLAG_RECEIVER_FOREGROUND);
            mInjector.broadcastIntent(profileUnlockedIntent,
                    null, null, 0, null, null, null, AppOpsManager.OP_NONE,
                    null, false, false, MY_PID, SYSTEM_UID,
                    parent.id);
        }
    }

    // Send PRE_BOOT broadcasts if user fingerprint changed; we
    // purposefully block sending BOOT_COMPLETED until after all
    // PRE_BOOT receivers are finished to avoid ANR'ing apps
    final UserInfo info = getUserInfo(userId);
    if (!Objects.equals(info.lastLoggedInFingerprint, Build.FINGERPRINT)) {
        // Suppress double notifications for managed profiles that
        // were unlocked automatically as part of their parent user
        // being unlocked.
        final boolean quiet;
        if (info.isManagedProfile()) {
            quiet = !uss.tokenProvided
                    || !mLockPatternUtils.isSeparateProfileChallengeEnabled(userId);
        } else {
            quiet = false;
        }
        mInjector.sendPreBootBroadcast(userId, quiet,
                () -> finishUserUnlockedCompleted(uss));
    } else {
        finishUserUnlockedCompleted(uss);
    }
}
 

private boolean unlockUserCleared(final int userId, byte[] token, byte[] secret,
        IProgressListener listener) {
    UserState uss;
    if (!StorageManager.isUserKeyUnlocked(userId)) {
        final UserInfo userInfo = getUserInfo(userId);
        final IStorageManager storageManager = getStorageManager();
        try {
            // We always want to unlock user storage, even user is not started yet
            storageManager.unlockUserKey(userId, userInfo.serialNumber, token, secret);
        } catch (RemoteException | RuntimeException e) {
            Slog.w(TAG, "Failed to unlock: " + e.getMessage());
        }
    }
    synchronized (mLock) {
        // Register the given listener to watch for unlock progress
        uss = mStartedUsers.get(userId);
        if (uss != null) {
            uss.mUnlockProgress.addListener(listener);
            uss.tokenProvided = (token != null);
        }
    }
    // Bail if user isn't actually running
    if (uss == null) {
        notifyFinished(userId, listener);
        return false;
    }

    finishUserUnlocking(uss);

    // We just unlocked a user, so let's now attempt to unlock any
    // managed profiles under that user.

    // First, get list of userIds. Requires mLock, so we cannot make external calls, e.g. to UMS
    int[] userIds;
    synchronized (mLock) {
        userIds = new int[mStartedUsers.size()];
        for (int i = 0; i < userIds.length; i++) {
            userIds[i] = mStartedUsers.keyAt(i);
        }
    }
    for (int testUserId : userIds) {
        final UserInfo parent = mInjector.getUserManager().getProfileParent(testUserId);
        if (parent != null && parent.id == userId && testUserId != userId) {
            Slog.d(TAG, "User " + testUserId + " (parent " + parent.id
                    + "): attempting unlock because parent was just unlocked");
            maybeUnlockUser(testUserId);
        }
    }

    return true;
}
 

boolean isUserRunning(int userId, int flags) {
    UserState state = getStartedUserState(userId);
    if (state == null) {
        return false;
    }
    if ((flags & ActivityManager.FLAG_OR_STOPPED) != 0) {
        return true;
    }
    if ((flags & ActivityManager.FLAG_AND_LOCKED) != 0) {
        switch (state.state) {
            case UserState.STATE_BOOTING:
            case UserState.STATE_RUNNING_LOCKED:
                return true;
            default:
                return false;
        }
    }
    if ((flags & ActivityManager.FLAG_AND_UNLOCKING_OR_UNLOCKED) != 0) {
        switch (state.state) {
            case UserState.STATE_RUNNING_UNLOCKING:
            case UserState.STATE_RUNNING_UNLOCKED:
                return true;
            // In the stopping/shutdown state return unlock state of the user key
            case UserState.STATE_STOPPING:
            case UserState.STATE_SHUTDOWN:
                return StorageManager.isUserKeyUnlocked(userId);
            default:
                return false;
        }
    }
    if ((flags & ActivityManager.FLAG_AND_UNLOCKED) != 0) {
        switch (state.state) {
            case UserState.STATE_RUNNING_UNLOCKED:
                return true;
            // In the stopping/shutdown state return unlock state of the user key
            case UserState.STATE_STOPPING:
            case UserState.STATE_SHUTDOWN:
                return StorageManager.isUserKeyUnlocked(userId);
            default:
                return false;
        }
    }

    return state.state != UserState.STATE_STOPPING && state.state != UserState.STATE_SHUTDOWN;
}