Add Controller for Emergency Button. (f8cb6b24) · Commits · e / os / android_frameworks_base

packages/SystemUI/src/com/android/keyguard/EmergencyButton.java

+4 −136

Original line number	Diff line number	Diff line
		@@ -16,34 +16,16 @@

		package com.android.keyguard;

		import static com.android.systemui.DejankUtils.whitelistIpcs;

		import android.app.ActivityOptions;
		import android.app.ActivityTaskManager;
		import android.content.Context;
		import android.content.Intent;
		import android.content.res.Configuration;
		import android.os.PowerManager;
		import android.os.RemoteException;
		import android.os.SystemClock;
		import android.os.UserHandle;
		import android.telecom.TelecomManager;
		import android.telephony.TelephonyManager;
		import android.util.AttributeSet;
		import android.util.Log;
		import android.util.Slog;
		import android.view.MotionEvent;
		import android.view.View;
		import android.view.ViewConfiguration;
		import android.widget.Button;

		import com.android.internal.logging.MetricsLogger;
		import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
		import com.android.internal.util.EmergencyAffordanceManager;
		import com.android.internal.widget.LockPatternUtils;
		import com.android.settingslib.Utils;
		import com.android.systemui.Dependency;
		import com.android.systemui.util.EmergencyDialerConstants;

		/**
		* This class implements a smart emergency button that updates itself based
		@@ -53,34 +35,14 @@ import com.android.systemui.util.EmergencyDialerConstants;
		*/
		public class EmergencyButton extends Button {

		private static final String LOG_TAG = "EmergencyButton";
		private final EmergencyAffordanceManager mEmergencyAffordanceManager;

		private int mDownX;
		private int mDownY;
		KeyguardUpdateMonitorCallback mInfoCallback = new KeyguardUpdateMonitorCallback() {

		@Override
		public void onSimStateChanged(int subId, int slotId, int simState) {
		updateEmergencyCallButton();
		}

		@Override
		public void onPhoneStateChanged(int phoneState) {
		updateEmergencyCallButton();
		}
		};
		private boolean mLongPressWasDragged;

		public interface EmergencyButtonCallback {
		public void onEmergencyButtonClickedWhenInCall();
		}

		private LockPatternUtils mLockPatternUtils;
		private PowerManager mPowerManager;
		private EmergencyButtonCallback mEmergencyButtonCallback;

		private final boolean mIsVoiceCapable;
		private final boolean mEnableEmergencyCallWhileSimLocked;

		public EmergencyButton(Context context) {
		@@ -89,34 +51,15 @@ public class EmergencyButton extends Button {

		public EmergencyButton(Context context, AttributeSet attrs) {
		super(context, attrs);
		mIsVoiceCapable = getTelephonyManager().isVoiceCapable();
		mEnableEmergencyCallWhileSimLocked = mContext.getResources().getBoolean(
		com.android.internal.R.bool.config_enable_emergency_call_while_sim_locked);
		mEmergencyAffordanceManager = new EmergencyAffordanceManager(context);
		}

		private TelephonyManager getTelephonyManager() {
		return (TelephonyManager) mContext.getSystemService(Context.TELEPHONY_SERVICE);
		}

		@Override
		protected void onAttachedToWindow() {
		super.onAttachedToWindow();
		Dependency.get(KeyguardUpdateMonitor.class).registerCallback(mInfoCallback);
		}

		@Override
		protected void onDetachedFromWindow() {
		super.onDetachedFromWindow();
		Dependency.get(KeyguardUpdateMonitor.class).removeCallback(mInfoCallback);
		}

		@Override
		protected void onFinishInflate() {
		super.onFinishInflate();
		mLockPatternUtils = new LockPatternUtils(mContext);
		mPowerManager = (PowerManager) mContext.getSystemService(Context.POWER_SERVICE);
		setOnClickListener(v -> takeEmergencyCallAction());
		if (mEmergencyAffordanceManager.needsEmergencyAffordance()) {
		setOnLongClickListener(v -> {
		if (!mLongPressWasDragged
		@@ -127,7 +70,6 @@ public class EmergencyButton extends Button {
		return false;
		});
		}
		whitelistIpcs(this::updateEmergencyCallButton);
		}

		@Override
		@@ -165,65 +107,13 @@ public class EmergencyButton extends Button {
		return super.performLongClick();
		}

		@Override
		protected void onConfigurationChanged(Configuration newConfig) {
		super.onConfigurationChanged(newConfig);
		updateEmergencyCallButton();
		}

		/**
		* Shows the emergency dialer or returns the user to the existing call.
		*/
		public void takeEmergencyCallAction() {
		MetricsLogger.action(mContext, MetricsEvent.ACTION_EMERGENCY_CALL);
		if (mPowerManager != null) {
		mPowerManager.userActivity(SystemClock.uptimeMillis(), true);
		}
		try {
		ActivityTaskManager.getService().stopSystemLockTaskMode();
		} catch (RemoteException e) {
		Slog.w(LOG_TAG, "Failed to stop app pinning");
		}
		if (isInCall()) {
		resumeCall();
		if (mEmergencyButtonCallback != null) {
		mEmergencyButtonCallback.onEmergencyButtonClickedWhenInCall();
		}
		} else {
		KeyguardUpdateMonitor updateMonitor = Dependency.get(KeyguardUpdateMonitor.class);
		if (updateMonitor != null) {
		updateMonitor.reportEmergencyCallAction(true /* bypassHandler */);
		} else {
		Log.w(LOG_TAG, "KeyguardUpdateMonitor was null, launching intent anyway.");
		}
		TelecomManager telecomManager = getTelecommManager();
		if (telecomManager == null) {
		Log.wtf(LOG_TAG, "TelecomManager was null, cannot launch emergency dialer");
		return;
		}
		Intent emergencyDialIntent =
		telecomManager.createLaunchEmergencyDialerIntent(null /* number*/)
		.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
		\| Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
		\| Intent.FLAG_ACTIVITY_CLEAR_TOP)
		.putExtra(EmergencyDialerConstants.EXTRA_ENTRY_TYPE,
		EmergencyDialerConstants.ENTRY_TYPE_LOCKSCREEN_BUTTON);

		getContext().startActivityAsUser(emergencyDialIntent,
		ActivityOptions.makeCustomAnimation(getContext(), 0, 0).toBundle(),
		new UserHandle(KeyguardUpdateMonitor.getCurrentUser()));
		}
		}

		private void updateEmergencyCallButton() {
		void updateEmergencyCallButton(boolean isInCall, boolean isVoiceCapable, boolean simLocked) {
		boolean visible = false;
		if (mIsVoiceCapable) {
		if (isVoiceCapable) {
		// Emergency calling requires voice capability.
		if (isInCall()) {
		if (isInCall) {
		visible = true; // always show "return to call" if phone is off-hook
		} else {
		final boolean simLocked = Dependency.get(KeyguardUpdateMonitor.class)
		.isSimPinVoiceSecure();
		if (simLocked) {
		// Some countries can't handle emergency calls while SIM is locked.
		visible = mEnableEmergencyCallWhileSimLocked;
		@@ -237,7 +127,7 @@ public class EmergencyButton extends Button {
		setVisibility(View.VISIBLE);

		int textId;
		if (isInCall()) {
		if (isInCall) {
		textId = com.android.internal.R.string.lockscreen_return_to_call;
		} else {
		textId = com.android.internal.R.string.lockscreen_emergency_call;
		@@ -247,26 +137,4 @@ public class EmergencyButton extends Button {
		setVisibility(View.GONE);
		}
		}

		public void setCallback(EmergencyButtonCallback callback) {
		mEmergencyButtonCallback = callback;
		}

		/**
		* Resumes a call in progress.
		*/
		private void resumeCall() {
		getTelecommManager().showInCallScreen(false);
		}

		/**
		* @return {@code true} if there is a call currently in progress.
		*/
		private boolean isInCall() {
		return getTelecommManager().isInCall();
		}

		private TelecomManager getTelecommManager() {
		return (TelecomManager) mContext.getSystemService(Context.TELECOM_SERVICE);
		}
		}

packages/SystemUI/src/com/android/keyguard/EmergencyButtonController.java

0 → 100644

+196 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2021 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.keyguard;

		import static com.android.systemui.DejankUtils.whitelistIpcs;

		import android.app.ActivityOptions;
		import android.app.ActivityTaskManager;
		import android.content.Intent;
		import android.content.res.Configuration;
		import android.os.PowerManager;
		import android.os.SystemClock;
		import android.os.UserHandle;
		import android.telecom.TelecomManager;
		import android.telephony.TelephonyManager;
		import android.util.Log;

		import androidx.annotation.Nullable;

		import com.android.internal.logging.MetricsLogger;
		import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
		import com.android.keyguard.dagger.KeyguardBouncerScope;
		import com.android.systemui.statusbar.policy.ConfigurationController;
		import com.android.systemui.statusbar.policy.ConfigurationController.ConfigurationListener;
		import com.android.systemui.util.EmergencyDialerConstants;
		import com.android.systemui.util.ViewController;

		import javax.inject.Inject;

		/** View Controller for {@link com.android.keyguard.EmergencyButton}. */
		@KeyguardBouncerScope
		public class EmergencyButtonController extends ViewController<EmergencyButton> {
		static final String LOG_TAG = "EmergencyButton";
		private final ConfigurationController mConfigurationController;
		private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;
		private final TelephonyManager mTelephonyManager;
		private final PowerManager mPowerManager;
		private final ActivityTaskManager mActivityTaskManager;
		private final TelecomManager mTelecomManager;
		private final MetricsLogger mMetricsLogger;

		private EmergencyButtonCallback mEmergencyButtonCallback;

		private final KeyguardUpdateMonitorCallback mInfoCallback =
		new KeyguardUpdateMonitorCallback() {
		@Override
		public void onSimStateChanged(int subId, int slotId, int simState) {
		updateEmergencyCallButton();
		}

		@Override
		public void onPhoneStateChanged(int phoneState) {
		updateEmergencyCallButton();
		}
		};

		private final ConfigurationListener mConfigurationListener = new ConfigurationListener() {
		@Override
		public void onConfigChanged(Configuration newConfig) {
		updateEmergencyCallButton();
		}
		};

		private EmergencyButtonController(@Nullable EmergencyButton view,
		ConfigurationController configurationController,
		KeyguardUpdateMonitor keyguardUpdateMonitor, TelephonyManager telephonyManager,
		PowerManager powerManager, ActivityTaskManager activityTaskManager,
		@Nullable TelecomManager telecomManager, MetricsLogger metricsLogger) {
		super(view);
		mConfigurationController = configurationController;
		mKeyguardUpdateMonitor = keyguardUpdateMonitor;
		mTelephonyManager = telephonyManager;
		mPowerManager = powerManager;
		mActivityTaskManager = activityTaskManager;
		mTelecomManager = telecomManager;
		mMetricsLogger = metricsLogger;
		}

		@Override
		protected void onInit() {
		whitelistIpcs(this::updateEmergencyCallButton);
		}

		@Override
		protected void onViewAttached() {
		mKeyguardUpdateMonitor.registerCallback(mInfoCallback);
		mConfigurationController.addCallback(mConfigurationListener);
		mView.setOnClickListener(v -> takeEmergencyCallAction());
		}

		@Override
		protected void onViewDetached() {
		mKeyguardUpdateMonitor.removeCallback(mInfoCallback);
		mConfigurationController.removeCallback(mConfigurationListener);
		}

		private void updateEmergencyCallButton() {
		if (mView != null) {
		mView.updateEmergencyCallButton(
		mTelecomManager != null && mTelecomManager.isInCall(),
		mTelephonyManager.isVoiceCapable(),
		mKeyguardUpdateMonitor.isSimPinVoiceSecure());
		}
		}

		public void setEmergencyButtonCallback(EmergencyButtonCallback callback) {
		mEmergencyButtonCallback = callback;
		}
		/**
		* Shows the emergency dialer or returns the user to the existing call.
		*/
		public void takeEmergencyCallAction() {
		mMetricsLogger.action(MetricsEvent.ACTION_EMERGENCY_CALL);
		if (mPowerManager != null) {
		mPowerManager.userActivity(SystemClock.uptimeMillis(), true);
		}
		mActivityTaskManager.stopSystemLockTaskMode();
		if (mTelecomManager != null && mTelecomManager.isInCall()) {
		mTelecomManager.showInCallScreen(false);
		if (mEmergencyButtonCallback != null) {
		mEmergencyButtonCallback.onEmergencyButtonClickedWhenInCall();
		}
		} else {
		mKeyguardUpdateMonitor.reportEmergencyCallAction(true /* bypassHandler */);
		if (mTelecomManager == null) {
		Log.wtf(LOG_TAG, "TelecomManager was null, cannot launch emergency dialer");
		return;
		}
		Intent emergencyDialIntent =
		mTelecomManager.createLaunchEmergencyDialerIntent(null /* number*/)
		.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK
		\| Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS
		\| Intent.FLAG_ACTIVITY_CLEAR_TOP)
		.putExtra(EmergencyDialerConstants.EXTRA_ENTRY_TYPE,
		EmergencyDialerConstants.ENTRY_TYPE_LOCKSCREEN_BUTTON);

		getContext().startActivityAsUser(emergencyDialIntent,
		ActivityOptions.makeCustomAnimation(getContext(), 0, 0).toBundle(),
		new UserHandle(KeyguardUpdateMonitor.getCurrentUser()));
		}
		}

		/** */
		public interface EmergencyButtonCallback {
		/** */
		void onEmergencyButtonClickedWhenInCall();
		}

		/** Injectable Factory for creating {@link EmergencyButtonController}. */
		public static class Factory {
		private final ConfigurationController mConfigurationController;
		private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;
		private final TelephonyManager mTelephonyManager;
		private final PowerManager mPowerManager;
		private final ActivityTaskManager mActivityTaskManager;
		@Nullable
		private final TelecomManager mTelecomManager;
		private final MetricsLogger mMetricsLogger;

		@Inject
		public Factory(ConfigurationController configurationController,
		KeyguardUpdateMonitor keyguardUpdateMonitor, TelephonyManager telephonyManager,
		PowerManager powerManager, ActivityTaskManager activityTaskManager,
		@Nullable TelecomManager telecomManager, MetricsLogger metricsLogger) {

		mConfigurationController = configurationController;
		mKeyguardUpdateMonitor = keyguardUpdateMonitor;
		mTelephonyManager = telephonyManager;
		mPowerManager = powerManager;
		mActivityTaskManager = activityTaskManager;
		mTelecomManager = telecomManager;
		mMetricsLogger = metricsLogger;
		}

		/** Construct an {@link com.android.keyguard.EmergencyButtonController}. */
		public EmergencyButtonController create(EmergencyButton view) {
		return new EmergencyButtonController(view, mConfigurationController,
		mKeyguardUpdateMonitor, mTelephonyManager, mPowerManager, mActivityTaskManager,
		mTelecomManager, mMetricsLogger);
		}
		}
		}

packages/SystemUI/src/com/android/keyguard/KeyguardAbsKeyInputViewController.java

+7 −7

Original line number	Diff line number	Diff line
		@@ -31,7 +31,7 @@ import com.android.internal.util.LatencyTracker;
		import com.android.internal.widget.LockPatternChecker;
		import com.android.internal.widget.LockPatternUtils;
		import com.android.internal.widget.LockscreenCredential;
		import com.android.keyguard.EmergencyButton.EmergencyButtonCallback;
		import com.android.keyguard.EmergencyButtonController.EmergencyButtonCallback;
		import com.android.keyguard.KeyguardAbsKeyInputView.KeyDownListener;
		import com.android.keyguard.KeyguardSecurityModel.SecurityMode;
		import com.android.systemui.R;
		@@ -41,6 +41,7 @@ public abstract class KeyguardAbsKeyInputViewController<T extends KeyguardAbsKey
		private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;
		private final LockPatternUtils mLockPatternUtils;
		private final LatencyTracker mLatencyTracker;
		private final EmergencyButtonController mEmergencyButtonController;
		private CountDownTimer mCountdownTimer;
		protected KeyguardMessageAreaController mMessageAreaController;
		private boolean mDismissing;
		@@ -70,11 +71,12 @@ public abstract class KeyguardAbsKeyInputViewController<T extends KeyguardAbsKey
		LockPatternUtils lockPatternUtils,
		KeyguardSecurityCallback keyguardSecurityCallback,
		KeyguardMessageAreaController.Factory messageAreaControllerFactory,
		LatencyTracker latencyTracker) {
		super(view, securityMode, keyguardSecurityCallback);
		LatencyTracker latencyTracker, EmergencyButtonController emergencyButtonController) {
		super(view, securityMode, keyguardSecurityCallback, emergencyButtonController);
		mKeyguardUpdateMonitor = keyguardUpdateMonitor;
		mLockPatternUtils = lockPatternUtils;
		mLatencyTracker = latencyTracker;
		mEmergencyButtonController = emergencyButtonController;
		KeyguardMessageArea kma = KeyguardMessageArea.findSecurityMessageDisplay(mView);
		mMessageAreaController = messageAreaControllerFactory.create(kma);
		}
		@@ -83,6 +85,7 @@ public abstract class KeyguardAbsKeyInputViewController<T extends KeyguardAbsKey

		@Override
		public void onInit() {
		super.onInit();
		mMessageAreaController.init();
		}

		@@ -91,10 +94,7 @@ public abstract class KeyguardAbsKeyInputViewController<T extends KeyguardAbsKey
		super.onViewAttached();
		mView.setKeyDownListener(mKeyDownListener);
		mView.setEnableHaptics(mLockPatternUtils.isTactileFeedbackEnabled());
		EmergencyButton button = mView.findViewById(R.id.emergency_call_button);
		if (button != null) {
		button.setCallback(mEmergencyButtonCallback);
		}
		mEmergencyButtonController.setEmergencyButtonCallback(mEmergencyButtonCallback);
		}

		@Override

packages/SystemUI/src/com/android/keyguard/KeyguardInputViewController.java

+31 −9

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@ public abstract class KeyguardInputViewController<T extends KeyguardInputView>
		private final SecurityMode mSecurityMode;
		private final KeyguardSecurityCallback mKeyguardSecurityCallback;
		private final EmergencyButton mEmergencyButton;
		private final EmergencyButtonController mEmergencyButtonController;
		private boolean mPaused;


		@@ -68,11 +69,18 @@ public abstract class KeyguardInputViewController<T extends KeyguardInputView>
		};

		protected KeyguardInputViewController(T view, SecurityMode securityMode,
		KeyguardSecurityCallback keyguardSecurityCallback) {
		KeyguardSecurityCallback keyguardSecurityCallback,
		EmergencyButtonController emergencyButtonController) {
		super(view);
		mSecurityMode = securityMode;
		mKeyguardSecurityCallback = keyguardSecurityCallback;
		mEmergencyButton = view == null ? null : view.findViewById(R.id.emergency_call_button);
		mEmergencyButtonController = emergencyButtonController;
		}

		@Override
		protected void onInit() {
		mEmergencyButtonController.init();
		}

		@Override
		@@ -154,8 +162,9 @@ public abstract class KeyguardInputViewController<T extends KeyguardInputView>
		private final InputMethodManager mInputMethodManager;
		private final DelayableExecutor mMainExecutor;
		private final Resources mResources;
		private LiftToActivateListener mLiftToActivateListener;
		private TelephonyManager mTelephonyManager;
		private final LiftToActivateListener mLiftToActivateListener;
		private final TelephonyManager mTelephonyManager;
		private final EmergencyButtonController.Factory mEmergencyButtonControllerFactory;
		private final FalsingCollector mFalsingCollector;

		@Inject
		@@ -165,7 +174,9 @@ public abstract class KeyguardInputViewController<T extends KeyguardInputView>
		KeyguardMessageAreaController.Factory messageAreaControllerFactory,
		InputMethodManager inputMethodManager, @Main DelayableExecutor mainExecutor,
		@Main Resources resources, LiftToActivateListener liftToActivateListener,
		TelephonyManager telephonyManager, FalsingCollector falsingCollector) {
		TelephonyManager telephonyManager,
		EmergencyButtonController.Factory emergencyButtonControllerFactory,
		FalsingCollector falsingCollector) {
		mKeyguardUpdateMonitor = keyguardUpdateMonitor;
		mLockPatternUtils = lockPatternUtils;
		mLatencyTracker = latencyTracker;
		@@ -175,36 +186,47 @@ public abstract class KeyguardInputViewController<T extends KeyguardInputView>
		mResources = resources;
		mLiftToActivateListener = liftToActivateListener;
		mTelephonyManager = telephonyManager;
		mEmergencyButtonControllerFactory = emergencyButtonControllerFactory;
		mFalsingCollector = falsingCollector;
		}

		/** Create a new {@link KeyguardInputViewController}. */
		public KeyguardInputViewController create(KeyguardInputView keyguardInputView,
		SecurityMode securityMode, KeyguardSecurityCallback keyguardSecurityCallback) {
		EmergencyButtonController emergencyButtonController =
		mEmergencyButtonControllerFactory.create(
		keyguardInputView.findViewById(R.id.emergency_call_button));

		if (keyguardInputView instanceof KeyguardPatternView) {
		return new KeyguardPatternViewController((KeyguardPatternView) keyguardInputView,
		mKeyguardUpdateMonitor, securityMode, mLockPatternUtils,
		keyguardSecurityCallback, mLatencyTracker, mMessageAreaControllerFactory);
		keyguardSecurityCallback, mLatencyTracker,
		emergencyButtonController,
		mMessageAreaControllerFactory);
		} else if (keyguardInputView instanceof KeyguardPasswordView) {
		return new KeyguardPasswordViewController((KeyguardPasswordView) keyguardInputView,
		mKeyguardUpdateMonitor, securityMode, mLockPatternUtils,
		keyguardSecurityCallback, mMessageAreaControllerFactory, mLatencyTracker,
		mInputMethodManager, mMainExecutor, mResources);
		mInputMethodManager, emergencyButtonController, mMainExecutor, mResources);
		} else if (keyguardInputView instanceof KeyguardPINView) {
		return new KeyguardPinViewController((KeyguardPINView) keyguardInputView,
		mKeyguardUpdateMonitor, securityMode, mLockPatternUtils,
		keyguardSecurityCallback, mMessageAreaControllerFactory, mLatencyTracker,
		mLiftToActivateListener, mFalsingCollector);
		mLiftToActivateListener, emergencyButtonController, mFalsingCollector);
		} else if (keyguardInputView instanceof KeyguardSimPinView) {
		return new KeyguardSimPinViewController((KeyguardSimPinView) keyguardInputView,
		mKeyguardUpdateMonitor, securityMode, mLockPatternUtils,
		keyguardSecurityCallback, mMessageAreaControllerFactory, mLatencyTracker,
		mLiftToActivateListener, mTelephonyManager, mFalsingCollector);
		mLiftToActivateListener, mTelephonyManager,
		emergencyButtonController,
		mFalsingCollector);
		} else if (keyguardInputView instanceof KeyguardSimPukView) {
		return new KeyguardSimPukViewController((KeyguardSimPukView) keyguardInputView,
		mKeyguardUpdateMonitor, securityMode, mLockPatternUtils,
		keyguardSecurityCallback, mMessageAreaControllerFactory, mLatencyTracker,
		mLiftToActivateListener, mTelephonyManager, mFalsingCollector);
		mLiftToActivateListener, mTelephonyManager,
		emergencyButtonController,
		mFalsingCollector);
		}

		throw new RuntimeException("Unable to find controller for " + keyguardInputView);

packages/SystemUI/src/com/android/keyguard/KeyguardPasswordViewController.java

+2 −1

Original line number	Diff line number	Diff line
		@@ -111,10 +111,11 @@ public class KeyguardPasswordViewController
		KeyguardMessageAreaController.Factory messageAreaControllerFactory,
		LatencyTracker latencyTracker,
		InputMethodManager inputMethodManager,
		EmergencyButtonController emergencyButtonController,
		@Main DelayableExecutor mainExecutor,
		@Main Resources resources) {
		super(view, keyguardUpdateMonitor, securityMode, lockPatternUtils, keyguardSecurityCallback,
		messageAreaControllerFactory, latencyTracker);
		messageAreaControllerFactory, latencyTracker, emergencyButtonController);
		mKeyguardSecurityCallback = keyguardSecurityCallback;
		mInputMethodManager = inputMethodManager;
		mMainExecutor = mainExecutor;