| Methods Summary |
|---|
| protected void | announceCurrentSecurityMethod()
mSecurityContainer.announceCurrentSecurityMethod();
|
| public abstract void | cleanUp()Called before this view is being removed.
|
| public boolean | dismiss(boolean authenticated)
return mSecurityContainer.showNextSecurityScreenOrFinish(authenticated);
|
| public boolean | dismiss()Dismisses the keyguard by going to the next screen or making it gone.
return dismiss(false);
|
| protected void | dispatchDraw(android.graphics.Canvas canvas)
super.dispatchDraw(canvas);
if (mViewMediatorCallback != null) {
mViewMediatorCallback.keyguardDoneDrawing();
}
|
| public boolean | dispatchKeyEvent(android.view.KeyEvent event)
if (interceptMediaKey(event)) {
return true;
}
return super.dispatchKeyEvent(event);
|
| public boolean | dispatchPopulateAccessibilityEvent(android.view.accessibility.AccessibilityEvent event)
if (event.getEventType() == AccessibilityEvent.TYPE_WINDOW_STATE_CHANGED) {
event.getText().add(mSecurityContainer.getCurrentSecurityModeContentDescription());
return true;
} else {
return super.dispatchPopulateAccessibilityEvent(event);
}
|
| public void | dispatchSystemUiVisibilityChanged(int visibility)
super.dispatchSystemUiVisibilityChanged(visibility);
if (!(mContext instanceof Activity)) {
setSystemUiVisibility(STATUS_BAR_DISABLE_BACK);
}
|
| public void | finish()Authentication has happened and it's time to dismiss keyguard. This function
should clean up and inform KeyguardViewMediator.
// 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);
}
}
|
| protected KeyguardActivityLauncher | getActivityLauncher()
return mActivityLauncher;
|
| public com.android.keyguard.KeyguardSecurityModel.SecurityMode | getCurrentSecurityMode()
return mSecurityContainer.getCurrentSecurityMode();
|
| protected KeyguardSecurityContainer | getSecurityContainer()
return mSecurityContainer;
|
| public com.android.keyguard.KeyguardSecurityModel.SecurityMode | getSecurityMode()
return mSecurityContainer.getSecurityMode();
|
| public abstract long | getUserActivityTimeout()Gets the desired user activity timeout in milliseconds, or -1 if the
default should be used.
|
| public boolean | handleBackKey()
if (mSecurityContainer.getCurrentSecuritySelection() == SecurityMode.Account) {
// go back to primary screen
mSecurityContainer.showPrimarySecurityScreen(false /*turningOff*/);
return true;
}
if (mSecurityContainer.getCurrentSecuritySelection() != SecurityMode.None) {
mSecurityContainer.dismiss(false);
return true;
}
return false;
|
| private void | handleMediaKeyEvent(android.view.KeyEvent keyEvent)
synchronized (this) {
if (mAudioManager == null) {
mAudioManager = (AudioManager) getContext().getSystemService(
Context.AUDIO_SERVICE);
}
}
mAudioManager.dispatchMediaKeyEvent(keyEvent);
|
| public boolean | handleMenuKey()
// The following enables the MENU key to work for testing automation
if (shouldEnableMenuKey()) {
dismiss();
return true;
}
return false;
|
| public boolean | interceptMediaKey(android.view.KeyEvent event)Allows the media keys to work when the keyguard is showing.
The media keys should be of no interest to the actual keyguard view(s),
so intercepting them here should not be of any harm.
final int keyCode = event.getKeyCode();
if (event.getAction() == KeyEvent.ACTION_DOWN) {
switch (keyCode) {
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
/* Suppress PLAY/PAUSE toggle when phone is ringing or
* in-call to avoid music playback */
if (mTelephonyManager == null) {
mTelephonyManager = (TelephonyManager) getContext().getSystemService(
Context.TELEPHONY_SERVICE);
}
if (mTelephonyManager != null &&
mTelephonyManager.getCallState() != TelephonyManager.CALL_STATE_IDLE) {
return true; // suppress key event
}
case KeyEvent.KEYCODE_MUTE:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK: {
handleMediaKeyEvent(event);
return true;
}
case KeyEvent.KEYCODE_VOLUME_UP:
case KeyEvent.KEYCODE_VOLUME_DOWN:
case KeyEvent.KEYCODE_VOLUME_MUTE: {
if (KEYGUARD_MANAGES_VOLUME) {
synchronized (this) {
if (mAudioManager == null) {
mAudioManager = (AudioManager) getContext().getSystemService(
Context.AUDIO_SERVICE);
}
}
// Volume buttons should only function for music (local or remote).
// TODO: Actually handle MUTE.
mAudioManager.adjustSuggestedStreamVolume(
keyCode == KeyEvent.KEYCODE_VOLUME_UP
? AudioManager.ADJUST_RAISE
: AudioManager.ADJUST_LOWER /* direction */,
AudioManager.STREAM_MUSIC /* stream */, 0 /* flags */);
// Don't execute default volume behavior
return true;
} else {
return false;
}
}
}
} else if (event.getAction() == KeyEvent.ACTION_UP) {
switch (keyCode) {
case KeyEvent.KEYCODE_MUTE:
case KeyEvent.KEYCODE_HEADSETHOOK:
case KeyEvent.KEYCODE_MEDIA_PLAY:
case KeyEvent.KEYCODE_MEDIA_PAUSE:
case KeyEvent.KEYCODE_MEDIA_PLAY_PAUSE:
case KeyEvent.KEYCODE_MEDIA_STOP:
case KeyEvent.KEYCODE_MEDIA_NEXT:
case KeyEvent.KEYCODE_MEDIA_PREVIOUS:
case KeyEvent.KEYCODE_MEDIA_REWIND:
case KeyEvent.KEYCODE_MEDIA_RECORD:
case KeyEvent.KEYCODE_MEDIA_FAST_FORWARD:
case KeyEvent.KEYCODE_MEDIA_AUDIO_TRACK: {
handleMediaKeyEvent(event);
return true;
}
}
}
return false;
|
| public void | launchCamera()
mActivityLauncher.launchCamera(getHandler(), null);
|
| protected abstract void | onCreateOptions(android.os.Bundle options)
|
| protected abstract void | onExternalMotionEvent(android.view.MotionEvent event)
|
| protected void | onFinishInflate()
mSecurityContainer =
(KeyguardSecurityContainer) findViewById(R.id.keyguard_security_container);
mLockPatternUtils = new LockPatternUtils(mContext);
mSecurityContainer.setLockPatternUtils(mLockPatternUtils);
mSecurityContainer.setSecurityCallback(this);
mSecurityContainer.showPrimarySecurityScreen(false);
// mSecurityContainer.updateSecurityViews(false /* not bouncing */);
|
| public void | onPause()Called when the Keyguard is not actively shown anymore on the screen.
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);
mSecurityContainer.showPrimarySecurityScreen(true);
mSecurityContainer.onPause();
clearFocus();
|
| public void | onResume()Called when the Keyguard is actively shown on the screen.
if (DEBUG) Log.d(TAG, "screen on, instance " + Integer.toHexString(hashCode()));
mSecurityContainer.onResume(KeyguardSecurityView.SCREEN_ON);
requestFocus();
|
| public void | onSecurityModeChanged(com.android.keyguard.KeyguardSecurityModel.SecurityMode securityMode, boolean needsInput)
if (mViewMediatorCallback != null) {
mViewMediatorCallback.setNeedsInput(needsInput);
}
|
| protected void | onUserActivityTimeoutChanged()
if (mViewMediatorCallback != null) {
mViewMediatorCallback.onUserActivityTimeoutChanged();
}
|
| protected abstract void | onUserSwitching(boolean switching)
|
| public void | setLockPatternUtils(com.android.internal.widget.LockPatternUtils utils)
mLockPatternUtils = utils;
mSecurityContainer.setLockPatternUtils(utils);
|
| public void | setOnDismissAction(com.android.keyguard.KeyguardHostView.OnDismissAction action)Sets an action to run when keyguard finishes.
mDismissAction = action;
|
| public void | setViewMediatorCallback(ViewMediatorCallback viewMediatorCallback)
mViewMediatorCallback = viewMediatorCallback;
// Update ViewMediator with the current input method requirements
mViewMediatorCallback.setNeedsInput(mSecurityContainer.needsInput());
|
| private boolean | shouldEnableMenuKey()
final Resources res = getResources();
final boolean configDisabled = res.getBoolean(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 | showAssistant()
final Intent intent = ((SearchManager) mContext.getSystemService(Context.SEARCH_SERVICE))
.getAssistIntent(mContext, true, 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);
|
| protected void | showBouncer(boolean show)
CharSequence what = getContext().getResources().getText(
show ? R.string.keyguard_accessibility_show_bouncer
: R.string.keyguard_accessibility_hide_bouncer);
announceForAccessibility(what);
announceCurrentSecurityMethod();
|
| public void | showPrimarySecurityScreen()Called when the view needs to be shown.
if (DEBUG) Log.d(TAG, "show()");
mSecurityContainer.showPrimarySecurityScreen(false);
|
| public void | startAppearAnimation()Starts the animation when the Keyguard gets shown.
mSecurityContainer.startAppearAnimation();
|
| public void | startDisappearAnimation(java.lang.Runnable finishRunnable)
if (!mSecurityContainer.startDisappearAnimation(finishRunnable) && finishRunnable != null) {
finishRunnable.run();
}
|
| public void | userActivity()
if (mViewMediatorCallback != null) {
mViewMediatorCallback.userActivity();
}
|
| public void | verifyUnlock()Verify that the user can get past the keyguard securely. This is called,
for example, when the phone disables the keyguard but then wants to launch
something else that requires secure access.
The result will be propogated back via {@link KeyguardViewCallback#keyguardDone(boolean)}
SecurityMode securityMode = mSecurityContainer.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
mSecurityContainer.verifyUnlock();
}
|
