blob: 73a13fb67fcd64f6990d04caac01202d6c9f6e4f [file] [log] [blame]
/*
* Copyright (C) 2012 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.internal.policy.impl.keyguard;
import android.app.Activity;
import android.app.ActivityManager;
import android.app.ActivityOptions;
import android.app.AlertDialog;
import android.app.SearchManager;
import android.app.admin.DevicePolicyManager;
import android.appwidget.AppWidgetHost;
import android.appwidget.AppWidgetHostView;
import android.appwidget.AppWidgetManager;
import android.appwidget.AppWidgetProviderInfo;
import android.content.ComponentName;
import android.content.Context;
import android.content.Intent;
import android.content.IntentSender;
import android.content.pm.UserInfo;
import android.content.res.Resources;
import android.graphics.Canvas;
import android.graphics.Rect;
import android.os.Looper;
import android.os.Parcel;
import android.os.Parcelable;
import android.os.SystemClock;
import android.os.UserHandle;
import android.os.UserManager;
import android.provider.Settings;
import android.util.AttributeSet;
import android.util.Log;
import android.util.Slog;
import android.view.KeyEvent;
import android.view.LayoutInflater;
import android.view.MotionEvent;
import android.view.View;
import android.view.WindowManager;
import android.view.animation.AnimationUtils;
import android.widget.RemoteViews.OnClickHandler;
import com.android.internal.R;
import com.android.internal.policy.impl.keyguard.KeyguardSecurityModel.SecurityMode;
import com.android.internal.widget.LockPatternUtils;
import java.io.File;
import java.util.List;
public class KeyguardHostView extends KeyguardViewBase {
private static final String TAG = "KeyguardHostView";
// Use this to debug all of keyguard
public static boolean DEBUG = KeyguardViewMediator.DEBUG;
// Found in KeyguardAppWidgetPickActivity.java
static final int APPWIDGET_HOST_ID = 0x4B455947;
private final int MAX_WIDGETS = 5;
private AppWidgetHost mAppWidgetHost;
private AppWidgetManager mAppWidgetManager;
private KeyguardWidgetPager mAppWidgetContainer;
private KeyguardSecurityViewFlipper mSecurityViewContainer;
private KeyguardSelectorView mKeyguardSelectorView;
private KeyguardTransportControlView mTransportControl;
private boolean mIsVerifyUnlockOnly;
private boolean mEnableFallback; // TODO: This should get the value from KeyguardPatternView
private SecurityMode mCurrentSecuritySelection = SecurityMode.Invalid;
private int mAppWidgetToShow;
private boolean mCheckAppWidgetConsistencyOnBootCompleted = false;
private boolean mCleanupAppWidgetsOnBootCompleted = false;
protected OnDismissAction mDismissAction;
protected int mFailedAttempts;
private LockPatternUtils mLockPatternUtils;
private KeyguardSecurityModel mSecurityModel;
private KeyguardViewStateManager mViewStateManager;
private Rect mTempRect = new Rect();
private int mDisabledFeatures;
private boolean mCameraDisabled;
private boolean mSafeModeEnabled;
private boolean mUserSetupCompleted;
// User for whom this host view was created
private int mUserId;
/*package*/ interface TransportCallback {
void onListenerDetached();
void onListenerAttached();
void onPlayStateChanged();
}
/*package*/ interface UserSwitcherCallback {
void hideSecurityView(int duration);
void showSecurityView();
void showUnlockHint();
void userActivity();
}
/*package*/ interface OnDismissAction {
/* returns true if the dismiss should be deferred */
boolean onDismiss();
}
public KeyguardHostView(Context context) {
this(context, null);
}
public KeyguardHostView(Context context, AttributeSet attrs) {
super(context, attrs);
mLockPatternUtils = new LockPatternUtils(context);
mUserId = mLockPatternUtils.getCurrentUser();
mAppWidgetHost = new AppWidgetHost(
context, APPWIDGET_HOST_ID, mOnClickHandler, Looper.myLooper());
mAppWidgetHost.setUserId(mUserId);
cleanupAppWidgetIds();
mAppWidgetManager = AppWidgetManager.getInstance(mContext);
mSecurityModel = new KeyguardSecurityModel(context);
mViewStateManager = new KeyguardViewStateManager(this);
DevicePolicyManager dpm =
(DevicePolicyManager) mContext.getSystemService(Context.DEVICE_POLICY_SERVICE);
if (dpm != null) {
mDisabledFeatures = getDisabledFeatures(dpm);
mCameraDisabled = dpm.getCameraDisabled(null);
}
mSafeModeEnabled = LockPatternUtils.isSafeModeEnabled();
mUserSetupCompleted = Settings.Secure.getIntForUser(mContext.getContentResolver(),
Settings.Secure.USER_SETUP_COMPLETE, 0, UserHandle.USER_CURRENT) != 0;
if (mSafeModeEnabled) {
Log.v(TAG, "Keyguard widgets disabled by safe mode");
}
if ((mDisabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_WIDGETS_ALL) != 0) {
Log.v(TAG, "Keyguard widgets disabled by DPM");
}
if ((mDisabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_SECURE_CAMERA) != 0) {
Log.v(TAG, "Keyguard secure camera disabled by DPM");
}
}
private void cleanupAppWidgetIds() {
// Since this method may delete a widget (which we can't do until boot completed) we
// may have to defer it until after boot complete.
if (!KeyguardUpdateMonitor.getInstance(mContext).hasBootCompleted()) {
mCleanupAppWidgetsOnBootCompleted = true;
return;
}
// Clean up appWidgetIds that are bound to lockscreen, but not actually used
// This is only to clean up after another bug: we used to not call
// deleteAppWidgetId when a user manually deleted a widget in keyguard. This code
// shouldn't have to run more than once per user. AppWidgetProviders rely on callbacks
// that are triggered by deleteAppWidgetId, which is why we're doing this
int[] appWidgetIdsInKeyguardSettings = mLockPatternUtils.getAppWidgets();
int[] appWidgetIdsBoundToHost = mAppWidgetHost.getAppWidgetIds();
for (int i = 0; i < appWidgetIdsBoundToHost.length; i++) {
int appWidgetId = appWidgetIdsBoundToHost[i];
if (!contains(appWidgetIdsInKeyguardSettings, appWidgetId)) {
Log.d(TAG, "Found a appWidgetId that's not being used by keyguard, deleting id "
+ appWidgetId);
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
}
}
}
private static boolean contains(int[] array, int target) {
for (int value : array) {
if (value == target) {
return true;
}
}
return false;
}
private KeyguardUpdateMonitorCallback mUpdateMonitorCallbacks =
new KeyguardUpdateMonitorCallback() {
@Override
public void onBootCompleted() {
if (mCheckAppWidgetConsistencyOnBootCompleted) {
checkAppWidgetConsistency();
mSwitchPageRunnable.run();
mCheckAppWidgetConsistencyOnBootCompleted = false;
}
if (mCleanupAppWidgetsOnBootCompleted) {
cleanupAppWidgetIds();
mCleanupAppWidgetsOnBootCompleted = false;
}
}
};
private SlidingChallengeLayout mSlidingChallengeLayout;
@Override
public boolean onTouchEvent(MotionEvent ev) {
boolean result = super.onTouchEvent(ev);
mTempRect.set(0, 0, 0, 0);
offsetRectIntoDescendantCoords(mSecurityViewContainer, mTempRect);
ev.offsetLocation(mTempRect.left, mTempRect.top);
result = mSecurityViewContainer.dispatchTouchEvent(ev) || result;
ev.offsetLocation(-mTempRect.left, -mTempRect.top);
return result;
}
@Override
protected void dispatchDraw(Canvas canvas) {
super.dispatchDraw(canvas);
if (mViewMediatorCallback != null) {
mViewMediatorCallback.keyguardDoneDrawing();
}
}
private int getWidgetPosition(int id) {
final int children = mAppWidgetContainer.getChildCount();
for (int i = 0; i < children; i++) {
if (mAppWidgetContainer.getWidgetPageAt(i).getContent().getId() == id) {
return i;
}
}
return -1;
}
@Override
protected void onFinishInflate() {
// Grab instances of and make any necessary changes to the main layouts. Create
// view state manager and wire up necessary listeners / callbacks.
View deleteDropTarget = findViewById(R.id.keyguard_widget_pager_delete_target);
mAppWidgetContainer = (KeyguardWidgetPager) findViewById(R.id.app_widget_container);
mAppWidgetContainer.setVisibility(VISIBLE);
mAppWidgetContainer.setCallbacks(mWidgetCallbacks);
mAppWidgetContainer.setDeleteDropTarget(deleteDropTarget);
mAppWidgetContainer.setMinScale(0.5f);
mSlidingChallengeLayout = (SlidingChallengeLayout) findViewById(R.id.sliding_layout);
if (mSlidingChallengeLayout != null) {
mSlidingChallengeLayout.setOnChallengeScrolledListener(mViewStateManager);
}
mAppWidgetContainer.setViewStateManager(mViewStateManager);
mAppWidgetContainer.setLockPatternUtils(mLockPatternUtils);
ChallengeLayout challenge = mSlidingChallengeLayout != null ? mSlidingChallengeLayout :
(ChallengeLayout) findViewById(R.id.multi_pane_challenge);
challenge.setOnBouncerStateChangedListener(mViewStateManager);
mAppWidgetContainer.setBouncerAnimationDuration(challenge.getBouncerAnimationDuration());
mViewStateManager.setPagedView(mAppWidgetContainer);
mViewStateManager.setChallengeLayout(challenge);
mSecurityViewContainer = (KeyguardSecurityViewFlipper) findViewById(R.id.view_flipper);
mKeyguardSelectorView = (KeyguardSelectorView) findViewById(R.id.keyguard_selector_view);
mViewStateManager.setSecurityViewContainer(mSecurityViewContainer);
if (!(mContext instanceof Activity)) {
setSystemUiVisibility(getSystemUiVisibility() | View.STATUS_BAR_DISABLE_BACK);
}
addDefaultWidgets();
addWidgetsFromSettings();
if (!shouldEnableAddWidget()) {
mAppWidgetContainer.setAddWidgetEnabled(false);
}
checkAppWidgetConsistency();
mSwitchPageRunnable.run();
// This needs to be called after the pages are all added.
mViewStateManager.showUsabilityHints();
showPrimarySecurityScreen(false);
updateSecurityViews();
// Make sure at least this view is focusable in case nothing below it is. Otherwise,
// requestFocus() on this view will fail and allow events, such as volume keys, to be
// handled by the fallback handler. See bug 7546960 for details.
setFocusableInTouchMode(true);
}
private boolean shouldEnableAddWidget() {
return numWidgets() < MAX_WIDGETS && mUserSetupCompleted;
}
private int getDisabledFeatures(DevicePolicyManager dpm) {
int disabledFeatures = DevicePolicyManager.KEYGUARD_DISABLE_FEATURES_NONE;
if (dpm != null) {
final int currentUser = mLockPatternUtils.getCurrentUser();
disabledFeatures = dpm.getKeyguardDisabledFeatures(null, currentUser);
}
return disabledFeatures;
}
private boolean widgetsDisabledByDpm() {
return (mDisabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_WIDGETS_ALL) != 0;
}
private boolean cameraDisabledByDpm() {
return mCameraDisabled
|| (mDisabledFeatures & DevicePolicyManager.KEYGUARD_DISABLE_SECURE_CAMERA) != 0;
}
private void updateSecurityViews() {
int children = mSecurityViewContainer.getChildCount();
for (int i = 0; i < children; i++) {
updateSecurityView(mSecurityViewContainer.getChildAt(i));
}
}
private void updateSecurityView(View view) {
if (view instanceof KeyguardSecurityView) {
KeyguardSecurityView ksv = (KeyguardSecurityView) view;
ksv.setKeyguardCallback(mCallback);
ksv.setLockPatternUtils(mLockPatternUtils);
if (mViewStateManager.isBouncing()) {
ksv.showBouncer(0);
} else {
ksv.hideBouncer(0);
}
} else {
Log.w(TAG, "View " + view + " is not a KeyguardSecurityView");
}
}
void setLockPatternUtils(LockPatternUtils utils) {
mSecurityModel.setLockPatternUtils(utils);
mLockPatternUtils = utils;
updateSecurityViews();
}
@Override
protected void onAttachedToWindow() {
super.onAttachedToWindow();
mAppWidgetHost.startListeningAsUser(mUserId);
KeyguardUpdateMonitor.getInstance(mContext).registerCallback(mUpdateMonitorCallbacks);
}
@Override
protected void onDetachedFromWindow() {
super.onDetachedFromWindow();
mAppWidgetHost.stopListeningAsUser(mUserId);
KeyguardUpdateMonitor.getInstance(mContext).removeCallback(mUpdateMonitorCallbacks);
}
private AppWidgetHost getAppWidgetHost() {
return mAppWidgetHost;
}
void addWidget(AppWidgetHostView view, int pageIndex) {
mAppWidgetContainer.addWidget(view, pageIndex);
}
private KeyguardWidgetPager.Callbacks mWidgetCallbacks
= new KeyguardWidgetPager.Callbacks() {
@Override
public void userActivity() {
KeyguardHostView.this.userActivity();
}
@Override
public void onUserActivityTimeoutChanged() {
KeyguardHostView.this.onUserActivityTimeoutChanged();
}
@Override
public void onAddView(View v) {
if (!shouldEnableAddWidget()) {
mAppWidgetContainer.setAddWidgetEnabled(false);
}
}
@Override
public void onRemoveView(View v, boolean deletePermanently) {
if (deletePermanently) {
final int appWidgetId = ((KeyguardWidgetFrame) v).getContentAppWidgetId();
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID &&
appWidgetId != LockPatternUtils.ID_DEFAULT_STATUS_WIDGET) {
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
}
}
}
@Override
public void onRemoveViewAnimationCompleted() {
if (shouldEnableAddWidget()) {
mAppWidgetContainer.setAddWidgetEnabled(true);
}
}
};
public void userActivity() {
if (mViewMediatorCallback != null) {
mViewMediatorCallback.userActivity();
}
}
public void onUserActivityTimeoutChanged() {
if (mViewMediatorCallback != null) {
mViewMediatorCallback.onUserActivityTimeoutChanged();
}
}
@Override
public long getUserActivityTimeout() {
// Currently only considering user activity timeouts needed by widgets.
// Could also take into account longer timeouts for certain security views.
if (mAppWidgetContainer != null) {
return mAppWidgetContainer.getUserActivityTimeout();
}
return -1;
}
private KeyguardSecurityCallback mCallback = new KeyguardSecurityCallback() {
public void userActivity(long timeout) {
if (mViewMediatorCallback != null) {
mViewMediatorCallback.userActivity(timeout);
}
}
public void dismiss(boolean authenticated) {
showNextSecurityScreenOrFinish(authenticated);
}
public boolean isVerifyUnlockOnly() {
return mIsVerifyUnlockOnly;
}
public void reportSuccessfulUnlockAttempt() {
KeyguardUpdateMonitor.getInstance(mContext).clearFailedUnlockAttempts();
mLockPatternUtils.reportSuccessfulPasswordAttempt();
}
public void reportFailedUnlockAttempt() {
if (mCurrentSecuritySelection == SecurityMode.Biometric) {
KeyguardUpdateMonitor.getInstance(mContext).reportFailedBiometricUnlockAttempt();
} else {
KeyguardHostView.this.reportFailedUnlockAttempt();
}
}
public int getFailedAttempts() {
return KeyguardUpdateMonitor.getInstance(mContext).getFailedUnlockAttempts();
}
@Override
public void showBackupSecurity() {
KeyguardHostView.this.showBackupSecurityScreen();
}
@Override
public void setOnDismissAction(OnDismissAction action) {
KeyguardHostView.this.setOnDismissAction(action);
}
};
private void showDialog(String title, String message) {
final AlertDialog dialog = new AlertDialog.Builder(mContext)
.setTitle(title)
.setMessage(message)
.setNeutralButton(com.android.internal.R.string.ok, null)
.create();
if (!(mContext instanceof Activity)) {
dialog.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG);
}
dialog.show();
}
private void showTimeoutDialog() {
int timeoutInSeconds = (int) LockPatternUtils.FAILED_ATTEMPT_TIMEOUT_MS / 1000;
int messageId = 0;
switch (mSecurityModel.getSecurityMode()) {
case Pattern:
messageId = R.string.kg_too_many_failed_pattern_attempts_dialog_message;
break;
case PIN:
messageId = R.string.kg_too_many_failed_pin_attempts_dialog_message;
break;
case Password:
messageId = R.string.kg_too_many_failed_password_attempts_dialog_message;
break;
}
if (messageId != 0) {
final String message = mContext.getString(messageId,
KeyguardUpdateMonitor.getInstance(mContext).getFailedUnlockAttempts(),
timeoutInSeconds);
showDialog(null, message);
}
}
private void showAlmostAtWipeDialog(int attempts, int remaining) {
int timeoutInSeconds = (int) LockPatternUtils.FAILED_ATTEMPT_TIMEOUT_MS / 1000;
String message = mContext.getString(R.string.kg_failed_attempts_almost_at_wipe,
attempts, remaining);
showDialog(null, message);
}
private void showWipeDialog(int attempts) {
String message = mContext.getString(R.string.kg_failed_attempts_now_wiping, attempts);
showDialog(null, message);
}
private void showAlmostAtAccountLoginDialog() {
final int timeoutInSeconds = (int) LockPatternUtils.FAILED_ATTEMPT_TIMEOUT_MS / 1000;
final int count = LockPatternUtils.FAILED_ATTEMPTS_BEFORE_RESET
- LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT;
String message = mContext.getString(R.string.kg_failed_attempts_almost_at_login,
count, LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT, timeoutInSeconds);
showDialog(null, message);
}
private void reportFailedUnlockAttempt() {
final KeyguardUpdateMonitor monitor = KeyguardUpdateMonitor.getInstance(mContext);
final int failedAttempts = monitor.getFailedUnlockAttempts() + 1; // +1 for this time
if (DEBUG) Log.d(TAG, "reportFailedPatternAttempt: #" + failedAttempts);
SecurityMode mode = mSecurityModel.getSecurityMode();
final boolean usingPattern = mode == KeyguardSecurityModel.SecurityMode.Pattern;
final int failedAttemptsBeforeWipe = mLockPatternUtils.getDevicePolicyManager()
.getMaximumFailedPasswordsForWipe(null, mLockPatternUtils.getCurrentUser());
final int failedAttemptWarning = LockPatternUtils.FAILED_ATTEMPTS_BEFORE_RESET
- LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT;
final int remainingBeforeWipe = failedAttemptsBeforeWipe > 0 ?
(failedAttemptsBeforeWipe - failedAttempts)
: Integer.MAX_VALUE; // because DPM returns 0 if no restriction
boolean showTimeout = false;
if (remainingBeforeWipe < LockPatternUtils.FAILED_ATTEMPTS_BEFORE_WIPE_GRACE) {
// If we reach this code, it means the user has installed a DevicePolicyManager
// that requests device wipe after N attempts. Once we get below the grace
// period, we'll post this dialog every time as a clear warning until the
// bombshell hits and the device is wiped.
if (remainingBeforeWipe > 0) {
showAlmostAtWipeDialog(failedAttempts, remainingBeforeWipe);
} else {
// Too many attempts. The device will be wiped shortly.
Slog.i(TAG, "Too many unlock attempts; device will be wiped!");
showWipeDialog(failedAttempts);
}
} else {
showTimeout =
(failedAttempts % LockPatternUtils.FAILED_ATTEMPTS_BEFORE_TIMEOUT) == 0;
if (usingPattern && mEnableFallback) {
if (failedAttempts == failedAttemptWarning) {
showAlmostAtAccountLoginDialog();
showTimeout = false; // don't show both dialogs
} else if (failedAttempts >= LockPatternUtils.FAILED_ATTEMPTS_BEFORE_RESET) {
mLockPatternUtils.setPermanentlyLocked(true);
showSecurityScreen(SecurityMode.Account);
// don't show timeout dialog because we show account unlock screen next
showTimeout = false;
}
}
}
monitor.reportFailedUnlockAttempt();
mLockPatternUtils.reportFailedPasswordAttempt();
if (showTimeout) {
showTimeoutDialog();
}
}
/**
* Shows the primary security screen for the user. This will be either the multi-selector
* or the user's security method.
* @param turningOff true if the device is being turned off
*/
void showPrimarySecurityScreen(boolean turningOff) {
SecurityMode securityMode = mSecurityModel.getSecurityMode();
if (DEBUG) Log.v(TAG, "showPrimarySecurityScreen(turningOff=" + turningOff + ")");
if (!turningOff &&
KeyguardUpdateMonitor.getInstance(mContext).isAlternateUnlockEnabled()) {
// If we're not turning off, then allow biometric alternate.
// We'll reload it when the device comes back on.
securityMode = mSecurityModel.getAlternateFor(securityMode);
}
showSecurityScreen(securityMode);
}
/**
* Shows the backup security screen for the current security mode. This could be used for
* password recovery screens but is currently only used for pattern unlock to show the
* account unlock screen and biometric unlock to show the user's normal unlock.
*/
private void showBackupSecurityScreen() {
if (DEBUG) Log.d(TAG, "showBackupSecurity()");
SecurityMode backup = mSecurityModel.getBackupSecurityMode(mCurrentSecuritySelection);
showSecurityScreen(backup);
}
public boolean showNextSecurityScreenIfPresent() {
SecurityMode securityMode = mSecurityModel.getSecurityMode();
// Allow an alternate, such as biometric unlock
securityMode = mSecurityModel.getAlternateFor(securityMode);
if (SecurityMode.None == securityMode) {
return false;
} else {
showSecurityScreen(securityMode); // switch to the alternate security view
return true;
}
}
private void showNextSecurityScreenOrFinish(boolean authenticated) {
if (DEBUG) Log.d(TAG, "showNextSecurityScreenOrFinish(" + authenticated + ")");
boolean finish = false;
if (SecurityMode.None == mCurrentSecuritySelection) {
SecurityMode securityMode = mSecurityModel.getSecurityMode();
// Allow an alternate, such as biometric unlock
securityMode = mSecurityModel.getAlternateFor(securityMode);
if (SecurityMode.None == securityMode) {
finish = true; // no security required
} else {
showSecurityScreen(securityMode); // switch to the alternate security view
}
} else if (authenticated) {
switch (mCurrentSecuritySelection) {
case Pattern:
case Password:
case PIN:
case Account:
case Biometric:
finish = true;
break;
case SimPin:
case SimPuk:
// Shortcut for SIM PIN/PUK to go to directly to user's security screen or home
SecurityMode securityMode = mSecurityModel.getSecurityMode();
if (securityMode != SecurityMode.None) {
showSecurityScreen(securityMode);
} else {
finish = true;
}
break;
default:
Log.v(TAG, "Bad security screen " + mCurrentSecuritySelection + ", fail safe");
showPrimarySecurityScreen(false);
break;
}
} else {
showPrimarySecurityScreen(false);
}
if (finish) {
// If the alternate unlock was suppressed, it can now be safely
// enabled because the user has left keyguard.
KeyguardUpdateMonitor.getInstance(mContext).setAlternateUnlockEnabled(true);
// If there's a pending runnable because the user interacted with a widget
// and we're leaving keyguard, then run it.
boolean deferKeyguardDone = false;
if (mDismissAction != null) {
deferKeyguardDone = mDismissAction.onDismiss();
mDismissAction = null;
}
if (mViewMediatorCallback != null) {
if (deferKeyguardDone) {
mViewMediatorCallback.keyguardDonePending();
} else {
mViewMediatorCallback.keyguardDone(true);
}
}
} else {
mViewStateManager.showBouncer(true);
}
}
private OnClickHandler mOnClickHandler = new OnClickHandler() {
@Override
public boolean onClickHandler(final View view,
final android.app.PendingIntent pendingIntent,
final Intent fillInIntent) {
if (pendingIntent.isActivity()) {
setOnDismissAction(new OnDismissAction() {
public boolean onDismiss() {
try {
// TODO: Unregister this handler if PendingIntent.FLAG_ONE_SHOT?
Context context = view.getContext();
ActivityOptions opts = ActivityOptions.makeScaleUpAnimation(view,
0, 0,
view.getMeasuredWidth(), view.getMeasuredHeight());
context.startIntentSender(
pendingIntent.getIntentSender(), fillInIntent,
Intent.FLAG_ACTIVITY_NEW_TASK,
Intent.FLAG_ACTIVITY_NEW_TASK, 0, opts.toBundle());
} catch (IntentSender.SendIntentException e) {
android.util.Log.e(TAG, "Cannot send pending intent: ", e);
} catch (Exception e) {
android.util.Log.e(TAG, "Cannot send pending intent due to " +
"unknown exception: ", e);
}
return false;
}
});
if (mViewStateManager.isChallengeShowing()) {
mViewStateManager.showBouncer(true);
} else {
mCallback.dismiss(false);
}
return true;
} else {
return super.onClickHandler(view, pendingIntent, fillInIntent);
}
};
};
// Used to ignore callbacks from methods that are no longer current (e.g. face unlock).
// This avoids unwanted asynchronous events from messing with the state.
private KeyguardSecurityCallback mNullCallback = new KeyguardSecurityCallback() {
@Override
public void userActivity(long timeout) {
}
@Override
public void showBackupSecurity() {
}
@Override
public void setOnDismissAction(OnDismissAction action) {
}
@Override
public void reportSuccessfulUnlockAttempt() {
}
@Override
public void reportFailedUnlockAttempt() {
}
@Override
public boolean isVerifyUnlockOnly() {
return false;
}
@Override
public int getFailedAttempts() {
return 0;
}
@Override
public void dismiss(boolean securityVerified) {
}
};
protected boolean mShowSecurityWhenReturn;
@Override
public void reset() {
mIsVerifyUnlockOnly = false;
mAppWidgetContainer.setCurrentPage(getWidgetPosition(R.id.keyguard_status_view));
}
/**
* Sets an action to perform when keyguard is dismissed.
* @param action
*/
protected void setOnDismissAction(OnDismissAction action) {
mDismissAction = action;
}
private KeyguardSecurityView getSecurityView(SecurityMode securityMode) {
final int securityViewIdForMode = getSecurityViewIdForMode(securityMode);
KeyguardSecurityView view = null;
final int children = mSecurityViewContainer.getChildCount();
for (int child = 0; child < children; child++) {
if (mSecurityViewContainer.getChildAt(child).getId() == securityViewIdForMode) {
view = ((KeyguardSecurityView)mSecurityViewContainer.getChildAt(child));
break;
}
}
int layoutId = getLayoutIdFor(securityMode);
if (view == null && layoutId != 0) {
final LayoutInflater inflater = LayoutInflater.from(mContext);
if (DEBUG) Log.v(TAG, "inflating id = " + layoutId);
View v = inflater.inflate(layoutId, mSecurityViewContainer, false);
mSecurityViewContainer.addView(v);
updateSecurityView(v);
view = (KeyguardSecurityView)v;
}
if (view instanceof KeyguardSelectorView) {
KeyguardSelectorView selectorView = (KeyguardSelectorView) view;
View carrierText = selectorView.findViewById(R.id.keyguard_selector_fade_container);
selectorView.setCarrierArea(carrierText);
}
return view;
}
/**
* Switches to the given security view unless it's already being shown, in which case
* this is a no-op.
*
* @param securityMode
*/
private void showSecurityScreen(SecurityMode securityMode) {
if (DEBUG) Log.d(TAG, "showSecurityScreen(" + securityMode + ")");
if (securityMode == mCurrentSecuritySelection) return;
KeyguardSecurityView oldView = getSecurityView(mCurrentSecuritySelection);
KeyguardSecurityView newView = getSecurityView(securityMode);
// Enter full screen mode if we're in SIM or Account screen
boolean fullScreenEnabled = getResources().getBoolean(
com.android.internal.R.bool.kg_sim_puk_account_full_screen);
boolean isSimOrAccount = securityMode == SecurityMode.SimPin
|| securityMode == SecurityMode.SimPuk
|| securityMode == SecurityMode.Account;
mAppWidgetContainer.setVisibility(
isSimOrAccount && fullScreenEnabled ? View.GONE : View.VISIBLE);
if (mSlidingChallengeLayout != null) {
mSlidingChallengeLayout.setChallengeInteractive(!fullScreenEnabled);
}
// Emulate Activity life cycle
if (oldView != null) {
oldView.onPause();
oldView.setKeyguardCallback(mNullCallback); // ignore requests from old view
}
newView.onResume(KeyguardSecurityView.VIEW_REVEALED);
newView.setKeyguardCallback(mCallback);
final boolean needsInput = newView.needsInput();
if (mViewMediatorCallback != null) {
mViewMediatorCallback.setNeedsInput(needsInput);
}
// Find and show this child.
final int childCount = mSecurityViewContainer.getChildCount();
mSecurityViewContainer.setInAnimation(
AnimationUtils.loadAnimation(mContext, R.anim.keyguard_security_fade_in));
mSecurityViewContainer.setOutAnimation(
AnimationUtils.loadAnimation(mContext, R.anim.keyguard_security_fade_out));
final int securityViewIdForMode = getSecurityViewIdForMode(securityMode);
for (int i = 0; i < childCount; i++) {
if (mSecurityViewContainer.getChildAt(i).getId() == securityViewIdForMode) {
mSecurityViewContainer.setDisplayedChild(i);
break;
}
}
if (securityMode == SecurityMode.None) {
// Discard current runnable if we're switching back to the selector view
setOnDismissAction(null);
}
mCurrentSecuritySelection = securityMode;
}
@Override
public void onScreenTurnedOn() {
if (DEBUG) Log.d(TAG, "screen on, instance " + Integer.toHexString(hashCode()));
showPrimarySecurityScreen(false);
getSecurityView(mCurrentSecuritySelection).onResume(KeyguardSecurityView.SCREEN_ON);
// This is a an attempt to fix bug 7137389 where the device comes back on but the entire
// layout is blank but forcing a layout causes it to reappear (e.g. with with
// hierarchyviewer).
requestLayout();
if (mViewStateManager != null) {
mViewStateManager.showUsabilityHints();
}
requestFocus();
}
@Override
public void onScreenTurnedOff() {
if (DEBUG) Log.d(TAG, String.format("screen off, instance %s at %s",
Integer.toHexString(hashCode()), SystemClock.uptimeMillis()));
// Once the screen turns off, we no longer consider this to be first boot and we want the
// biometric unlock to start next time keyguard is shown.
KeyguardUpdateMonitor.getInstance(mContext).setAlternateUnlockEnabled(true);
// We use mAppWidgetToShow to show a particular widget after you add it-- once the screen
// turns off we reset that behavior
clearAppWidgetToShow();
checkAppWidgetConsistency();
showPrimarySecurityScreen(true);
getSecurityView(mCurrentSecuritySelection).onPause();
CameraWidgetFrame cameraPage = findCameraPage();
if (cameraPage != null) {
cameraPage.onScreenTurnedOff();
}
clearFocus();
}
public void clearAppWidgetToShow() {
mAppWidgetToShow = AppWidgetManager.INVALID_APPWIDGET_ID;
}
@Override
public void show() {
if (DEBUG) Log.d(TAG, "show()");
showPrimarySecurityScreen(false);
}
private boolean isSecure() {
SecurityMode mode = mSecurityModel.getSecurityMode();
switch (mode) {
case Pattern:
return mLockPatternUtils.isLockPatternEnabled();
case Password:
case PIN:
return mLockPatternUtils.isLockPasswordEnabled();
case SimPin:
case SimPuk:
case Account:
return true;
case None:
return false;
default:
throw new IllegalStateException("Unknown security mode " + mode);
}
}
@Override
public void wakeWhenReadyTq(int keyCode) {
if (DEBUG) Log.d(TAG, "onWakeKey");
if (keyCode == KeyEvent.KEYCODE_MENU && isSecure()) {
if (DEBUG) Log.d(TAG, "switching screens to unlock screen because wake key was MENU");
showSecurityScreen(SecurityMode.None);
} else {
if (DEBUG) Log.d(TAG, "poking wake lock immediately");
}
if (mViewMediatorCallback != null) {
mViewMediatorCallback.wakeUp();
}
}
@Override
public void verifyUnlock() {
SecurityMode securityMode = mSecurityModel.getSecurityMode();
if (securityMode == KeyguardSecurityModel.SecurityMode.None) {
if (mViewMediatorCallback != null) {
mViewMediatorCallback.keyguardDone(true);
}
} else if (securityMode != KeyguardSecurityModel.SecurityMode.Pattern
&& securityMode != KeyguardSecurityModel.SecurityMode.PIN
&& securityMode != KeyguardSecurityModel.SecurityMode.Password) {
// can only verify unlock when in pattern/password mode
if (mViewMediatorCallback != null) {
mViewMediatorCallback.keyguardDone(false);
}
} else {
// otherwise, go to the unlock screen, see if they can verify it
mIsVerifyUnlockOnly = true;
showSecurityScreen(securityMode);
}
}
private int getSecurityViewIdForMode(SecurityMode securityMode) {
switch (securityMode) {
case None: return R.id.keyguard_selector_view;
case Pattern: return R.id.keyguard_pattern_view;
case PIN: return R.id.keyguard_pin_view;
case Password: return R.id.keyguard_password_view;
case Biometric: return R.id.keyguard_face_unlock_view;
case Account: return R.id.keyguard_account_view;
case SimPin: return R.id.keyguard_sim_pin_view;
case SimPuk: return R.id.keyguard_sim_puk_view;
}
return 0;
}
private int getLayoutIdFor(SecurityMode securityMode) {
switch (securityMode) {
case None: return R.layout.keyguard_selector_view;
case Pattern: return R.layout.keyguard_pattern_view;
case PIN: return R.layout.keyguard_pin_view;
case Password: return R.layout.keyguard_password_view;
case Biometric: return R.layout.keyguard_face_unlock_view;
case Account: return R.layout.keyguard_account_view;
case SimPin: return R.layout.keyguard_sim_pin_view;
case SimPuk: return R.layout.keyguard_sim_puk_view;
default:
return 0;
}
}
private boolean addWidget(int appId, int pageIndex, boolean updateDbIfFailed) {
AppWidgetProviderInfo appWidgetInfo = mAppWidgetManager.getAppWidgetInfo(appId);
if (appWidgetInfo != null) {
AppWidgetHostView view = getAppWidgetHost().createView(mContext, appId, appWidgetInfo);
addWidget(view, pageIndex);
return true;
} else {
if (updateDbIfFailed) {
Log.w(TAG, "AppWidgetInfo for app widget id " + appId + " was null, deleting");
mAppWidgetHost.deleteAppWidgetId(appId);
mLockPatternUtils.removeAppWidget(appId);
}
return false;
}
}
private final CameraWidgetFrame.Callbacks mCameraWidgetCallbacks =
new CameraWidgetFrame.Callbacks() {
@Override
public void onLaunchingCamera() {
setSliderHandleAlpha(0);
}
@Override
public void onCameraLaunchedSuccessfully() {
if (mAppWidgetContainer.isCameraPage(mAppWidgetContainer.getCurrentPage())) {
mAppWidgetContainer.scrollLeft();
}
setSliderHandleAlpha(1);
mShowSecurityWhenReturn = true;
}
@Override
public void onCameraLaunchedUnsuccessfully() {
setSliderHandleAlpha(1);
}
private void setSliderHandleAlpha(float alpha) {
SlidingChallengeLayout slider =
(SlidingChallengeLayout) findViewById(R.id.sliding_layout);
if (slider != null) {
slider.setHandleAlpha(alpha);
}
}
};
private final KeyguardActivityLauncher mActivityLauncher = new KeyguardActivityLauncher() {
@Override
Context getContext() {
return mContext;
}
@Override
KeyguardSecurityCallback getCallback() {
return mCallback;
}
@Override
LockPatternUtils getLockPatternUtils() {
return mLockPatternUtils;
}
};
private int numWidgets() {
final int childCount = mAppWidgetContainer.getChildCount();
int widgetCount = 0;
for (int i = 0; i < childCount; i++) {
if (mAppWidgetContainer.isWidgetPage(i)) {
widgetCount++;
}
}
return widgetCount;
}
private void addDefaultWidgets() {
LayoutInflater inflater = LayoutInflater.from(mContext);
inflater.inflate(R.layout.keyguard_transport_control_view, this, true);
if (!mSafeModeEnabled && !widgetsDisabledByDpm()) {
View addWidget = inflater.inflate(R.layout.keyguard_add_widget, this, false);
mAppWidgetContainer.addWidget(addWidget, 0);
View addWidgetButton = addWidget.findViewById(R.id.keyguard_add_widget_view);
addWidgetButton.setOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
// Pass in an invalid widget id... the picker will allocate an ID for us
mActivityLauncher.launchWidgetPicker(AppWidgetManager.INVALID_APPWIDGET_ID);
}
});
}
// We currently disable cameras in safe mode because we support loading 3rd party
// cameras we can't trust. TODO: plumb safe mode into camera creation code and only
// inflate system-provided camera?
if (!mSafeModeEnabled && !cameraDisabledByDpm() && mUserSetupCompleted
&& mContext.getResources().getBoolean(R.bool.kg_enable_camera_default_widget)) {
View cameraWidget =
CameraWidgetFrame.create(mContext, mCameraWidgetCallbacks, mActivityLauncher);
if (cameraWidget != null) {
mAppWidgetContainer.addWidget(cameraWidget);
}
}
enableUserSelectorIfNecessary();
initializeTransportControl();
}
private boolean removeTransportFromWidgetPager() {
int page = getWidgetPosition(R.id.keyguard_transport_control);
if (page != -1) {
mAppWidgetContainer.removeWidget(mTransportControl);
// XXX keep view attached so we still get show/hide events from AudioManager
KeyguardHostView.this.addView(mTransportControl);
mTransportControl.setVisibility(View.GONE);
mViewStateManager.setTransportState(KeyguardViewStateManager.TRANSPORT_GONE);
return true;
}
return false;
}
private void addTransportToWidgetPager() {
if (getWidgetPosition(R.id.keyguard_transport_control) == -1) {
KeyguardHostView.this.removeView(mTransportControl);
// insert to left of camera if it exists, otherwise after right-most widget
int lastWidget = mAppWidgetContainer.getChildCount() - 1;
int position = 0; // handle no widget case
if (lastWidget >= 0) {
position = mAppWidgetContainer.isCameraPage(lastWidget) ?
lastWidget : lastWidget + 1;
}
mAppWidgetContainer.addWidget(mTransportControl, position);
mTransportControl.setVisibility(View.VISIBLE);
}
}
private void initializeTransportControl() {
mTransportControl =
(KeyguardTransportControlView) findViewById(R.id.keyguard_transport_control);
mTransportControl.setVisibility(View.GONE);
// This code manages showing/hiding the transport control. We keep it around and only
// add it to the hierarchy if it needs to be present.
if (mTransportControl != null) {
mTransportControl.setKeyguardCallback(new TransportCallback() {
@Override
public void onListenerDetached() {
if (removeTransportFromWidgetPager()) {
mTransportControl.post(mSwitchPageRunnable);
}
}
@Override
public void onListenerAttached() {
// Transport will be added when playstate changes...
mTransportControl.post(mSwitchPageRunnable);
}
@Override
public void onPlayStateChanged() {
mTransportControl.post(mSwitchPageRunnable);
}
});
}
}
private int getInsertPageIndex() {
View addWidget = mAppWidgetContainer.findViewById(R.id.keyguard_add_widget);
int insertionIndex = mAppWidgetContainer.indexOfChild(addWidget);
if (insertionIndex < 0) {
insertionIndex = 0; // no add widget page found
} else {
insertionIndex++; // place after add widget
}
return insertionIndex;
}
private void addDefaultStatusWidget(int index) {
LayoutInflater inflater = LayoutInflater.from(mContext);
View statusWidget = inflater.inflate(R.layout.keyguard_status_view, null, true);
mAppWidgetContainer.addWidget(statusWidget, index);
}
private void addWidgetsFromSettings() {
if (mSafeModeEnabled || widgetsDisabledByDpm()) {
return;
}
int insertionIndex = getInsertPageIndex();
// Add user-selected widget
final int[] widgets = mLockPatternUtils.getAppWidgets();
if (widgets == null) {
Log.d(TAG, "Problem reading widgets");
} else {
for (int i = widgets.length -1; i >= 0; i--) {
if (widgets[i] == LockPatternUtils.ID_DEFAULT_STATUS_WIDGET) {
addDefaultStatusWidget(insertionIndex);
} else {
// We add the widgets from left to right, starting after the first page after
// the add page. We count down, since the order will be persisted from right
// to left, starting after camera.
addWidget(widgets[i], insertionIndex, true);
}
}
}
}
private int allocateIdForDefaultAppWidget() {
int appWidgetId;
Resources res = getContext().getResources();
ComponentName defaultAppWidget = new ComponentName(
res.getString(R.string.widget_default_package_name),
res.getString(R.string.widget_default_class_name));
// Note: we don't support configuring the widget
appWidgetId = mAppWidgetHost.allocateAppWidgetId();
try {
mAppWidgetManager.bindAppWidgetId(appWidgetId, defaultAppWidget);
} catch (IllegalArgumentException e) {
Log.e(TAG, "Error when trying to bind default AppWidget: " + e);
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
appWidgetId = AppWidgetManager.INVALID_APPWIDGET_ID;
}
return appWidgetId;
}
public void checkAppWidgetConsistency() {
// Since this method may bind a widget (which we can't do until boot completed) we
// may have to defer it until after boot complete.
if (!KeyguardUpdateMonitor.getInstance(mContext).hasBootCompleted()) {
mCheckAppWidgetConsistencyOnBootCompleted = true;
return;
}
final int childCount = mAppWidgetContainer.getChildCount();
boolean widgetPageExists = false;
for (int i = 0; i < childCount; i++) {
if (mAppWidgetContainer.isWidgetPage(i)) {
widgetPageExists = true;
break;
}
}
if (!widgetPageExists) {
final int insertPageIndex = getInsertPageIndex();
final boolean userAddedWidgetsEnabled = !widgetsDisabledByDpm();
boolean addedDefaultAppWidget = false;
if (!mSafeModeEnabled) {
if (userAddedWidgetsEnabled) {
int appWidgetId = allocateIdForDefaultAppWidget();
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
addedDefaultAppWidget = addWidget(appWidgetId, insertPageIndex, true);
}
} else {
// note: even if widgetsDisabledByDpm() returns true, we still bind/create
// the default appwidget if possible
int appWidgetId = mLockPatternUtils.getFallbackAppWidgetId();
if (appWidgetId == AppWidgetManager.INVALID_APPWIDGET_ID) {
appWidgetId = allocateIdForDefaultAppWidget();
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
mLockPatternUtils.writeFallbackAppWidgetId(appWidgetId);
}
}
if (appWidgetId != AppWidgetManager.INVALID_APPWIDGET_ID) {
addedDefaultAppWidget = addWidget(appWidgetId, insertPageIndex, false);
if (!addedDefaultAppWidget) {
mAppWidgetHost.deleteAppWidgetId(appWidgetId);
mLockPatternUtils.writeFallbackAppWidgetId(
AppWidgetManager.INVALID_APPWIDGET_ID);
}
}
}
}
// Use the built-in status/clock view if we can't inflate the default widget
if (!addedDefaultAppWidget) {
addDefaultStatusWidget(insertPageIndex);
}
// trigger DB updates only if user-added widgets are enabled
if (!mSafeModeEnabled && userAddedWidgetsEnabled) {
mAppWidgetContainer.onAddView(
mAppWidgetContainer.getChildAt(insertPageIndex), insertPageIndex);
}
}
}
Runnable mSwitchPageRunnable = new Runnable() {
@Override
public void run() {
showAppropriateWidgetPage();
}
};
static class SavedState extends BaseSavedState {
int transportState;
int appWidgetToShow = AppWidgetManager.INVALID_APPWIDGET_ID;
SavedState(Parcelable superState) {
super(superState);
}
private SavedState(Parcel in) {
super(in);
this.transportState = in.readInt();
this.appWidgetToShow = in.readInt();
}
@Override
public void writeToParcel(Parcel out, int flags) {
super.writeToParcel(out, flags);
out.writeInt(this.transportState);
out.writeInt(this.appWidgetToShow);
}
public static final Parcelable.Creator<SavedState> CREATOR
= new Parcelable.Creator<SavedState>() {
public SavedState createFromParcel(Parcel in) {
return new SavedState(in);
}
public SavedState[] newArray(int size) {
return new SavedState[size];
}
};
}
@Override
public Parcelable onSaveInstanceState() {
if (DEBUG) Log.d(TAG, "onSaveInstanceState");
Parcelable superState = super.onSaveInstanceState();
SavedState ss = new SavedState(superState);
ss.transportState = mViewStateManager.getTransportState();
ss.appWidgetToShow = mAppWidgetToShow;
return ss;
}
@Override
public void onRestoreInstanceState(Parcelable state) {
if (DEBUG) Log.d(TAG, "onRestoreInstanceState");
if (!(state instanceof SavedState)) {
super.onRestoreInstanceState(state);
return;
}
SavedState ss = (SavedState) state;
super.onRestoreInstanceState(ss.getSuperState());
mViewStateManager.setTransportState(ss.transportState);
mAppWidgetToShow = ss.appWidgetToShow;
post(mSwitchPageRunnable);
}
@Override
public void onWindowFocusChanged(boolean hasWindowFocus) {
super.onWindowFocusChanged(hasWindowFocus);
if (DEBUG) Log.d(TAG, "Window is " + (hasWindowFocus ? "focused" : "unfocused"));
if (hasWindowFocus && mShowSecurityWhenReturn) {
SlidingChallengeLayout slider =
(SlidingChallengeLayout) findViewById(R.id.sliding_layout);
if (slider != null) {
slider.setHandleAlpha(1);
slider.showChallenge(true);
}
mShowSecurityWhenReturn = false;
}
}
private void showAppropriateWidgetPage() {
int state = mViewStateManager.getTransportState();
boolean isMusicPlaying = mTransportControl.isMusicPlaying()
|| state == KeyguardViewStateManager.TRANSPORT_VISIBLE;
if (isMusicPlaying) {
mViewStateManager.setTransportState(KeyguardViewStateManager.TRANSPORT_VISIBLE);
addTransportToWidgetPager();
} else if (state == KeyguardViewStateManager.TRANSPORT_VISIBLE) {
mViewStateManager.setTransportState(KeyguardViewStateManager.TRANSPORT_INVISIBLE);
}
int pageToShow = getAppropriateWidgetPage(isMusicPlaying);
mAppWidgetContainer.setCurrentPage(pageToShow);
}
private CameraWidgetFrame findCameraPage() {
for (int i = mAppWidgetContainer.getChildCount() - 1; i >= 0; i--) {
if (mAppWidgetContainer.isCameraPage(i)) {
return (CameraWidgetFrame) mAppWidgetContainer.getChildAt(i);
}
}
return null;
}
boolean isMusicPage(int pageIndex) {
return pageIndex >= 0 && pageIndex == getWidgetPosition(R.id.keyguard_transport_control);
}
private int getAppropriateWidgetPage(boolean isMusicPlaying) {
// assumes at least one widget (besides camera + add)
if (mAppWidgetToShow != AppWidgetManager.INVALID_APPWIDGET_ID) {
final int childCount = mAppWidgetContainer.getChildCount();
for (int i = 0; i < childCount; i++) {
if (mAppWidgetContainer.getWidgetPageAt(i).getContentAppWidgetId()
== mAppWidgetToShow) {
return i;
}
}
mAppWidgetToShow = AppWidgetManager.INVALID_APPWIDGET_ID;
}
// if music playing, show transport
if (isMusicPlaying) {
if (DEBUG) Log.d(TAG, "Music playing, show transport");
return mAppWidgetContainer.getWidgetPageIndex(mTransportControl);
}
// else show the right-most widget (except for camera)
int rightMost = mAppWidgetContainer.getChildCount() - 1;
if (mAppWidgetContainer.isCameraPage(rightMost)) {
rightMost--;
}
if (DEBUG) Log.d(TAG, "Show right-most page " + rightMost);
return rightMost;
}
private void enableUserSelectorIfNecessary() {
if (!UserManager.supportsMultipleUsers()) {
return; // device doesn't support multi-user mode
}
final UserManager um = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
if (um == null) {
Throwable t = new Throwable();
t.fillInStackTrace();
Log.e(TAG, "user service is null.", t);
return;
}
// if there are multiple users, we need to enable to multi-user switcher
final List<UserInfo> users = um.getUsers(true);
if (users == null) {
Throwable t = new Throwable();
t.fillInStackTrace();
Log.e(TAG, "list of users is null.", t);
return;
}
final View multiUserView = findViewById(R.id.keyguard_user_selector);
if (multiUserView == null) {
Throwable t = new Throwable();
t.fillInStackTrace();
Log.e(TAG, "can't find user_selector in layout.", t);
return;
}
if (users.size() > 1) {
if (multiUserView instanceof KeyguardMultiUserSelectorView) {
KeyguardMultiUserSelectorView multiUser =
(KeyguardMultiUserSelectorView) multiUserView;
multiUser.setVisibility(View.VISIBLE);
multiUser.addUsers(users);
UserSwitcherCallback callback = new UserSwitcherCallback() {
@Override
public void hideSecurityView(int duration) {
mSecurityViewContainer.animate().alpha(0).setDuration(duration);
}
@Override
public void showSecurityView() {
mSecurityViewContainer.setAlpha(1.0f);
}
@Override
public void showUnlockHint() {
if (mKeyguardSelectorView != null) {
mKeyguardSelectorView.showUsabilityHint();
}
}
@Override
public void userActivity() {
if (mViewMediatorCallback != null) {
mViewMediatorCallback.userActivity();
}
}
};
multiUser.setCallback(callback);
} else {
Throwable t = new Throwable();
t.fillInStackTrace();
if (multiUserView == null) {
Log.e(TAG, "could not find the user_selector.", t);
} else {
Log.e(TAG, "user_selector is the wrong type.", t);
}
}
}
}
@Override
public void cleanUp() {
}
/**
* In general, we enable unlocking the insecure keyguard with the menu key. However, there are
* some cases where we wish to disable it, notably when the menu button placement or technology
* is prone to false positives.
*
* @return true if the menu key should be enabled
*/
private static final String ENABLE_MENU_KEY_FILE = "/data/local/enable_menu_key";
private boolean shouldEnableMenuKey() {
final Resources res = getResources();
final boolean configDisabled = res.getBoolean(
com.android.internal.R.bool.config_disableMenuKeyInLockScreen);
final boolean isTestHarness = ActivityManager.isRunningInTestHarness();
final boolean fileOverride = (new File(ENABLE_MENU_KEY_FILE)).exists();
return !configDisabled || isTestHarness || fileOverride;
}
public void goToUserSwitcher() {
mAppWidgetContainer.setCurrentPage(getWidgetPosition(R.id.keyguard_multi_user_selector));
}
public void goToWidget(int appWidgetId) {
mAppWidgetToShow = appWidgetId;
mSwitchPageRunnable.run();
}
public boolean handleMenuKey() {
// The following enables the MENU key to work for testing automation
if (shouldEnableMenuKey()) {
showNextSecurityScreenOrFinish(false);
return true;
}
return false;
}
public boolean handleBackKey() {
if (mCurrentSecuritySelection != SecurityMode.None) {
mCallback.dismiss(false);
return true;
}
return false;
}
/**
* Dismisses the keyguard by going to the next screen or making it gone.
*/
public void dismiss() {
showNextSecurityScreenOrFinish(false);
}
public void showAssistant() {
final Intent intent = ((SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE))
.getAssistIntent(mContext, UserHandle.USER_CURRENT);
if (intent == null) return;
final ActivityOptions opts = ActivityOptions.makeCustomAnimation(mContext,
R.anim.keyguard_action_assist_enter, R.anim.keyguard_action_assist_exit,
getHandler(), null);
intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
mActivityLauncher.launchActivityWithAnimation(
intent, false, opts.toBundle(), null, null);
}
}