From b823e12d6c7d2fd1f07321ffc2c07dddaf32c3a5 Mon Sep 17 00:00:00 2001 From: Yohei Yukawa Date: Wed, 16 Dec 2015 12:50:23 -0800 Subject: [PATCH] Hide settings-key until the device is unlocked. Starting in N, we are going to have new APIs to officially support the situation where apps need to run before the user has unlocked their device for the first time. For IME developers those APIs would be important not only because IMEs developers may want to support other apps that support that feature but also because IMEs developers have already needed to pay attention to the same situation where the IME is running so that the user can enter the initial password (e.g. for an encrypted device). Bug 11270326 is a perfect example of this scenario. Now we can disable settings-key until the device is unlocked by using the new API when running in Android N devices. Bug: 11270326 Change-Id: Ie1c6efa63b60b91430f1a78dde624d0f3dff3c69 --- .../compat/UserManagerCompatUtils.java | 80 +++++++++++++++++++ .../keyboard/KeyboardLayoutSet.java | 11 +++ 2 files changed, 91 insertions(+) create mode 100644 java/src/com/android/inputmethod/compat/UserManagerCompatUtils.java diff --git a/java/src/com/android/inputmethod/compat/UserManagerCompatUtils.java b/java/src/com/android/inputmethod/compat/UserManagerCompatUtils.java new file mode 100644 index 000000000..5dee31629 --- /dev/null +++ b/java/src/com/android/inputmethod/compat/UserManagerCompatUtils.java @@ -0,0 +1,80 @@ +/* + * Copyright (C) 2016 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.inputmethod.compat; + +import android.content.Context; +import android.os.Build; +import android.os.UserManager; +import android.support.annotation.IntDef; + +import java.lang.annotation.Retention; +import java.lang.reflect.Method; + +import static java.lang.annotation.RetentionPolicy.SOURCE; + +/** + * A temporary solution until {@code UserManagerCompat.isUserUnlocked()} in the support-v4 library + * becomes publicly available. + */ +public final class UserManagerCompatUtils { + private static final Method METHOD_isUserUnlocked; + + static { + // We do not try to search the method in Android M and prior. + if (BuildCompatUtils.EFFECTIVE_SDK_INT <= Build.VERSION_CODES.M) { + METHOD_isUserUnlocked = null; + } else { + METHOD_isUserUnlocked = CompatUtils.getMethod(UserManager.class, "isUserUnlocked"); + } + } + + private UserManagerCompatUtils() { + // This utility class is not publicly instantiable. + } + + public static final int LOCK_STATE_UNKNOWN = 0; + public static final int LOCK_STATE_UNLOCKED = 1; + public static final int LOCK_STATE_LOCKED = 2; + + @Retention(SOURCE) + @IntDef({LOCK_STATE_UNKNOWN, LOCK_STATE_UNLOCKED, LOCK_STATE_LOCKED}) + public @interface LockState {} + + /** + * Check if the calling user is running in an "unlocked" state. A user is unlocked only after + * they've entered their credentials (such as a lock pattern or PIN), and credential-encrypted + * private app data storage is available. + * @param context context from which {@link UserManager} should be obtained. + * @return One of {@link LockState}. + */ + @LockState + public static int getUserLockState(final Context context) { + if (METHOD_isUserUnlocked == null) { + return LOCK_STATE_UNKNOWN; + } + final UserManager userManager = context.getSystemService(UserManager.class); + if (userManager == null) { + return LOCK_STATE_UNKNOWN; + } + final Boolean result = + (Boolean) CompatUtils.invoke(userManager, null, METHOD_isUserUnlocked); + if (result == null) { + return LOCK_STATE_UNKNOWN; + } + return result ? LOCK_STATE_UNLOCKED : LOCK_STATE_LOCKED; + } +} diff --git a/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java b/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java index 47013fe9e..26ff051bb 100644 --- a/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java +++ b/java/src/com/android/inputmethod/keyboard/KeyboardLayoutSet.java @@ -32,6 +32,7 @@ import android.view.inputmethod.InputMethodSubtype; import com.android.inputmethod.compat.EditorInfoCompatUtils; import com.android.inputmethod.compat.InputMethodSubtypeCompatUtils; +import com.android.inputmethod.compat.UserManagerCompatUtils; import com.android.inputmethod.keyboard.internal.KeyboardBuilder; import com.android.inputmethod.keyboard.internal.KeyboardParams; import com.android.inputmethod.keyboard.internal.UniqueKeysCache; @@ -275,6 +276,16 @@ public final class KeyboardLayoutSet { params.mIsPasswordField = InputTypeUtils.isPasswordInputType(editorInfo.inputType); params.mNoSettingsKey = InputAttributes.inPrivateImeOptions( mPackageName, NO_SETTINGS_KEY, editorInfo); + + // When the device is still unlocked, features like showing the IME setting app need to + // be locked down. + // TODO: Switch to {@code UserManagerCompat.isUserUnlocked()} in the support-v4 library + // when it becomes publicly available. + @UserManagerCompatUtils.LockState + final int lockState = UserManagerCompatUtils.getUserLockState(context); + if (lockState == UserManagerCompatUtils.LOCK_STATE_LOCKED) { + params.mNoSettingsKey = true; + } } public Builder setKeyboardGeometry(final int keyboardWidth, final int keyboardHeight) {