Jorim Jaggi | b10e33f | 2015-02-04 21:57:40 +0100 | [diff] [blame] | 1 | package com.android.server.policy.keyguard; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 2 | |
David Stevens | 67c036b | 2017-08-23 18:41:49 -0700 | [diff] [blame] | 3 | import static android.view.Display.INVALID_DISPLAY; |
| 4 | |
Sudheer Shanka | dc589ac | 2016-11-10 15:30:17 -0800 | [diff] [blame] | 5 | import android.app.ActivityManager; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 6 | import android.content.ComponentName; |
| 7 | import android.content.Context; |
| 8 | import android.content.Intent; |
| 9 | import android.content.ServiceConnection; |
Bryce Lee | 2a18cbc | 2015-03-09 15:49:23 +0000 | [diff] [blame] | 10 | import android.content.res.Resources; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 11 | import android.os.Bundle; |
Jorim Jaggi | 4a0e791 | 2015-07-29 15:46:29 -0700 | [diff] [blame] | 12 | import android.os.Handler; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 13 | import android.os.IBinder; |
| 14 | import android.os.RemoteException; |
| 15 | import android.os.UserHandle; |
| 16 | import android.util.Log; |
| 17 | import android.util.Slog; |
| 18 | import android.view.WindowManagerPolicy.OnKeyguardExitResult; |
| 19 | |
Jorim Jaggi | 241ae10 | 2016-11-02 21:57:33 -0700 | [diff] [blame] | 20 | import com.android.internal.policy.IKeyguardDismissCallback; |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 21 | import com.android.internal.policy.IKeyguardDrawnCallback; |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 22 | import com.android.internal.policy.IKeyguardExitCallback; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 23 | import com.android.internal.policy.IKeyguardService; |
Adrian Roos | 691546e | 2016-02-09 10:13:41 -0800 | [diff] [blame] | 24 | import com.android.server.UiThread; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 25 | |
Jorim Jaggi | 84dc08a | 2015-09-11 17:45:22 -0700 | [diff] [blame] | 26 | import java.io.PrintWriter; |
| 27 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 28 | /** |
| 29 | * A local class that keeps a cache of keyguard state that can be restored in the event |
| 30 | * keyguard crashes. It currently also allows runtime-selectable |
| 31 | * local or remote instances of keyguard. |
| 32 | */ |
| 33 | public class KeyguardServiceDelegate { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 34 | private static final String TAG = "KeyguardServiceDelegate"; |
Joe Onorato | 82ba91d | 2017-04-27 16:18:05 -0700 | [diff] [blame] | 35 | private static final boolean DEBUG = false; |
Jim Miller | ab95454 | 2014-10-10 18:21:49 -0700 | [diff] [blame] | 36 | |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 37 | private static final int SCREEN_STATE_OFF = 0; |
| 38 | private static final int SCREEN_STATE_TURNING_ON = 1; |
| 39 | private static final int SCREEN_STATE_ON = 2; |
Adrian Roos | 369907f | 2017-07-14 14:53:39 +0200 | [diff] [blame] | 40 | private static final int SCREEN_STATE_TURNING_OFF = 3; |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 41 | |
| 42 | private static final int INTERACTIVE_STATE_SLEEP = 0; |
Adrian Roos | 369907f | 2017-07-14 14:53:39 +0200 | [diff] [blame] | 43 | private static final int INTERACTIVE_STATE_WAKING = 1; |
| 44 | private static final int INTERACTIVE_STATE_AWAKE = 2; |
| 45 | private static final int INTERACTIVE_STATE_GOING_TO_SLEEP = 3; |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 46 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 47 | protected KeyguardServiceWrapper mKeyguardService; |
Jim Miller | ab95454 | 2014-10-10 18:21:49 -0700 | [diff] [blame] | 48 | private final Context mContext; |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 49 | private final Handler mHandler; |
Jim Miller | ab95454 | 2014-10-10 18:21:49 -0700 | [diff] [blame] | 50 | private final KeyguardState mKeyguardState = new KeyguardState(); |
Jorim Jaggi | e69c931 | 2016-10-31 18:24:38 -0700 | [diff] [blame] | 51 | private final KeyguardStateMonitor.StateCallback mCallback; |
| 52 | |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 53 | private DrawnListener mDrawnListenerWhenConnect; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 54 | |
Adrian Roos | 3542f7d | 2015-07-13 15:57:53 -0700 | [diff] [blame] | 55 | private static final class KeyguardState { |
Jim Miller | e5f17ab | 2013-11-13 15:40:48 -0800 | [diff] [blame] | 56 | KeyguardState() { |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 57 | reset(); |
Jim Miller | e5f17ab | 2013-11-13 15:40:48 -0800 | [diff] [blame] | 58 | } |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 59 | boolean showing; |
Jorim Jaggi | 5cf1787 | 2014-03-26 18:31:48 +0100 | [diff] [blame] | 60 | boolean showingAndNotOccluded; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 61 | boolean inputRestricted; |
Jorim Jaggi | 5cf1787 | 2014-03-26 18:31:48 +0100 | [diff] [blame] | 62 | boolean occluded; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 63 | boolean secure; |
| 64 | boolean dreaming; |
| 65 | boolean systemIsReady; |
Jim Miller | a8800f7 | 2014-12-12 13:34:43 -0800 | [diff] [blame] | 66 | boolean deviceHasKeyguard; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 67 | public boolean enabled; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 68 | public int offReason; |
| 69 | public int currentUser; |
Jim Miller | e5f910a | 2013-10-16 18:15:46 -0700 | [diff] [blame] | 70 | public boolean bootCompleted; |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 71 | public int screenState; |
| 72 | public int interactiveState; |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 73 | |
| 74 | private void reset() { |
| 75 | // Assume keyguard is showing and secure until we know for sure. This is here in |
| 76 | // the event something checks before the service is actually started. |
| 77 | // KeyguardService itself should default to this state until the real state is known. |
| 78 | showing = true; |
| 79 | showingAndNotOccluded = true; |
| 80 | secure = true; |
| 81 | deviceHasKeyguard = true; |
| 82 | enabled = true; |
| 83 | currentUser = UserHandle.USER_NULL; |
| 84 | } |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 85 | }; |
| 86 | |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 87 | public interface DrawnListener { |
| 88 | void onDrawn(); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 89 | } |
| 90 | |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 91 | // A delegate class to map a particular invocation with a ShowListener object. |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 92 | private final class KeyguardShowDelegate extends IKeyguardDrawnCallback.Stub { |
| 93 | private DrawnListener mDrawnListener; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 94 | |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 95 | KeyguardShowDelegate(DrawnListener drawnListener) { |
| 96 | mDrawnListener = drawnListener; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 97 | } |
| 98 | |
| 99 | @Override |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 100 | public void onDrawn() throws RemoteException { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 101 | if (DEBUG) Log.v(TAG, "**** SHOWN CALLED ****"); |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 102 | if (mDrawnListener != null) { |
| 103 | mDrawnListener.onDrawn(); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 104 | } |
| 105 | } |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 106 | }; |
| 107 | |
| 108 | // A delegate class to map a particular invocation with an OnKeyguardExitResult object. |
| 109 | private final class KeyguardExitDelegate extends IKeyguardExitCallback.Stub { |
| 110 | private OnKeyguardExitResult mOnKeyguardExitResult; |
| 111 | |
| 112 | KeyguardExitDelegate(OnKeyguardExitResult onKeyguardExitResult) { |
| 113 | mOnKeyguardExitResult = onKeyguardExitResult; |
| 114 | } |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 115 | |
| 116 | @Override |
| 117 | public void onKeyguardExitResult(boolean success) throws RemoteException { |
| 118 | if (DEBUG) Log.v(TAG, "**** onKeyguardExitResult(" + success +") CALLED ****"); |
| 119 | if (mOnKeyguardExitResult != null) { |
| 120 | mOnKeyguardExitResult.onKeyguardExitResult(success); |
| 121 | } |
| 122 | } |
| 123 | }; |
| 124 | |
Jorim Jaggi | e69c931 | 2016-10-31 18:24:38 -0700 | [diff] [blame] | 125 | public KeyguardServiceDelegate(Context context, KeyguardStateMonitor.StateCallback callback) { |
Jim Miller | ab95454 | 2014-10-10 18:21:49 -0700 | [diff] [blame] | 126 | mContext = context; |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 127 | mHandler = UiThread.getHandler(); |
Jorim Jaggi | e69c931 | 2016-10-31 18:24:38 -0700 | [diff] [blame] | 128 | mCallback = callback; |
Jason Monk | 5eeebf5 | 2014-09-26 12:36:51 -0400 | [diff] [blame] | 129 | } |
| 130 | |
| 131 | public void bindService(Context context) { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 132 | Intent intent = new Intent(); |
Bryce Lee | 2a18cbc | 2015-03-09 15:49:23 +0000 | [diff] [blame] | 133 | final Resources resources = context.getApplicationContext().getResources(); |
| 134 | |
| 135 | final ComponentName keyguardComponent = ComponentName.unflattenFromString( |
| 136 | resources.getString(com.android.internal.R.string.config_keyguardComponent)); |
Jeff Sharkey | 2f3e353 | 2015-12-21 14:16:43 -0700 | [diff] [blame] | 137 | intent.addFlags(Intent.FLAG_DEBUG_TRIAGED_MISSING); |
Bryce Lee | 2a18cbc | 2015-03-09 15:49:23 +0000 | [diff] [blame] | 138 | intent.setComponent(keyguardComponent); |
| 139 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 140 | if (!context.bindServiceAsUser(intent, mKeyguardConnection, |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 141 | Context.BIND_AUTO_CREATE, mHandler, UserHandle.SYSTEM)) { |
Bryce Lee | 2a18cbc | 2015-03-09 15:49:23 +0000 | [diff] [blame] | 142 | Log.v(TAG, "*** Keyguard: can't bind to " + keyguardComponent); |
Jim Miller | fb5fcea | 2014-01-08 14:57:54 -0800 | [diff] [blame] | 143 | mKeyguardState.showing = false; |
Jorim Jaggi | 5cf1787 | 2014-03-26 18:31:48 +0100 | [diff] [blame] | 144 | mKeyguardState.showingAndNotOccluded = false; |
Jim Miller | fb5fcea | 2014-01-08 14:57:54 -0800 | [diff] [blame] | 145 | mKeyguardState.secure = false; |
Adrian Roos | 3542f7d | 2015-07-13 15:57:53 -0700 | [diff] [blame] | 146 | synchronized (mKeyguardState) { |
| 147 | // TODO: Fix synchronisation model in this class. The other state in this class |
| 148 | // is at least self-healing but a race condition here can lead to the scrim being |
| 149 | // stuck on keyguard-less devices. |
| 150 | mKeyguardState.deviceHasKeyguard = false; |
Adrian Roos | 3542f7d | 2015-07-13 15:57:53 -0700 | [diff] [blame] | 151 | } |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 152 | } else { |
| 153 | if (DEBUG) Log.v(TAG, "*** Keyguard started"); |
| 154 | } |
| 155 | } |
| 156 | |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 157 | private final ServiceConnection mKeyguardConnection = new ServiceConnection() { |
| 158 | @Override |
| 159 | public void onServiceConnected(ComponentName name, IBinder service) { |
| 160 | if (DEBUG) Log.v(TAG, "*** Keyguard connected (yay!)"); |
Jim Miller | ab95454 | 2014-10-10 18:21:49 -0700 | [diff] [blame] | 161 | mKeyguardService = new KeyguardServiceWrapper(mContext, |
Jorim Jaggi | e69c931 | 2016-10-31 18:24:38 -0700 | [diff] [blame] | 162 | IKeyguardService.Stub.asInterface(service), mCallback); |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 163 | if (mKeyguardState.systemIsReady) { |
Jim Miller | c0b676d | 2013-03-22 16:11:08 -0700 | [diff] [blame] | 164 | // If the system is ready, it means keyguard crashed and restarted. |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 165 | mKeyguardService.onSystemReady(); |
Suprabh Shukla | 323d2bb | 2016-07-27 17:00:12 -0700 | [diff] [blame] | 166 | if (mKeyguardState.currentUser != UserHandle.USER_NULL) { |
| 167 | // There has been a user switch earlier |
| 168 | mKeyguardService.setCurrentUser(mKeyguardState.currentUser); |
| 169 | } |
Jim Miller | c0b676d | 2013-03-22 16:11:08 -0700 | [diff] [blame] | 170 | // This is used to hide the scrim once keyguard displays. |
Adrian Roos | 369907f | 2017-07-14 14:53:39 +0200 | [diff] [blame] | 171 | if (mKeyguardState.interactiveState == INTERACTIVE_STATE_AWAKE |
| 172 | || mKeyguardState.interactiveState == INTERACTIVE_STATE_WAKING) { |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 173 | mKeyguardService.onStartedWakingUp(); |
| 174 | } |
Adrian Roos | 369907f | 2017-07-14 14:53:39 +0200 | [diff] [blame] | 175 | if (mKeyguardState.interactiveState == INTERACTIVE_STATE_AWAKE) { |
| 176 | mKeyguardService.onFinishedWakingUp(); |
| 177 | } |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 178 | if (mKeyguardState.screenState == SCREEN_STATE_ON |
| 179 | || mKeyguardState.screenState == SCREEN_STATE_TURNING_ON) { |
| 180 | mKeyguardService.onScreenTurningOn( |
| 181 | new KeyguardShowDelegate(mDrawnListenerWhenConnect)); |
| 182 | } |
| 183 | if (mKeyguardState.screenState == SCREEN_STATE_ON) { |
| 184 | mKeyguardService.onScreenTurnedOn(); |
| 185 | } |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 186 | mDrawnListenerWhenConnect = null; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 187 | } |
Jim Miller | e5f910a | 2013-10-16 18:15:46 -0700 | [diff] [blame] | 188 | if (mKeyguardState.bootCompleted) { |
| 189 | mKeyguardService.onBootCompleted(); |
| 190 | } |
Adrian Roos | f253eeb | 2015-04-15 18:03:08 -0700 | [diff] [blame] | 191 | if (mKeyguardState.occluded) { |
Jorim Jaggi | 6626f54 | 2016-08-22 13:08:44 -0700 | [diff] [blame] | 192 | mKeyguardService.setOccluded(mKeyguardState.occluded, false /* animate */); |
Adrian Roos | f253eeb | 2015-04-15 18:03:08 -0700 | [diff] [blame] | 193 | } |
Tony Mak | 2c0d6dc | 2016-04-29 16:16:54 +0100 | [diff] [blame] | 194 | if (!mKeyguardState.enabled) { |
| 195 | mKeyguardService.setKeyguardEnabled(mKeyguardState.enabled); |
| 196 | } |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 197 | } |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 198 | |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 199 | @Override |
| 200 | public void onServiceDisconnected(ComponentName name) { |
| 201 | if (DEBUG) Log.v(TAG, "*** Keyguard disconnected (boo!)"); |
| 202 | mKeyguardService = null; |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 203 | mKeyguardState.reset(); |
| 204 | mHandler.post(() -> { |
| 205 | try { |
David Stevens | 67c036b | 2017-08-23 18:41:49 -0700 | [diff] [blame] | 206 | // There are no longer any keyguard windows on secondary displays, so pass |
| 207 | // INVALID_DISPLAY. All that means is that showWhenLocked activities on |
| 208 | // secondary displays now get to show. |
| 209 | ActivityManager.getService().setLockScreenShown(true, INVALID_DISPLAY); |
Jorim Jaggi | 73294b6 | 2016-10-26 18:02:36 -0700 | [diff] [blame] | 210 | } catch (RemoteException e) { |
| 211 | // Local call. |
| 212 | } |
| 213 | }); |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 214 | } |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 215 | }; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 216 | |
| 217 | public boolean isShowing() { |
| 218 | if (mKeyguardService != null) { |
| 219 | mKeyguardState.showing = mKeyguardService.isShowing(); |
| 220 | } |
| 221 | return mKeyguardState.showing; |
| 222 | } |
| 223 | |
Adrian Roos | d88eb26 | 2016-08-04 14:50:48 -0700 | [diff] [blame] | 224 | public boolean isTrusted() { |
| 225 | if (mKeyguardService != null) { |
| 226 | return mKeyguardService.isTrusted(); |
| 227 | } |
| 228 | return false; |
| 229 | } |
| 230 | |
Jorim Jaggi | d11d1a9 | 2016-08-16 16:02:32 -0700 | [diff] [blame] | 231 | public boolean hasLockscreenWallpaper() { |
| 232 | if (mKeyguardService != null) { |
| 233 | return mKeyguardService.hasLockscreenWallpaper(); |
| 234 | } |
| 235 | return false; |
| 236 | } |
| 237 | |
eddy-sh.chen | 0df686d | 2018-02-22 18:10:21 +0800 | [diff] [blame] | 238 | public boolean hasKeyguard() { |
| 239 | return mKeyguardState.deviceHasKeyguard; |
| 240 | } |
| 241 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 242 | public boolean isInputRestricted() { |
| 243 | if (mKeyguardService != null) { |
| 244 | mKeyguardState.inputRestricted = mKeyguardService.isInputRestricted(); |
| 245 | } |
| 246 | return mKeyguardState.inputRestricted; |
| 247 | } |
| 248 | |
| 249 | public void verifyUnlock(final OnKeyguardExitResult onKeyguardExitResult) { |
| 250 | if (mKeyguardService != null) { |
Jim Miller | 2519057 | 2013-02-28 17:36:24 -0800 | [diff] [blame] | 251 | mKeyguardService.verifyUnlock(new KeyguardExitDelegate(onKeyguardExitResult)); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 252 | } |
| 253 | } |
| 254 | |
Jorim Jaggi | 6626f54 | 2016-08-22 13:08:44 -0700 | [diff] [blame] | 255 | public void setOccluded(boolean isOccluded, boolean animate) { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 256 | if (mKeyguardService != null) { |
Jorim Jaggi | 6626f54 | 2016-08-22 13:08:44 -0700 | [diff] [blame] | 257 | if (DEBUG) Log.v(TAG, "setOccluded(" + isOccluded + ") animate=" + animate); |
| 258 | mKeyguardService.setOccluded(isOccluded, animate); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 259 | } |
Jorim Jaggi | 5cf1787 | 2014-03-26 18:31:48 +0100 | [diff] [blame] | 260 | mKeyguardState.occluded = isOccluded; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 261 | } |
| 262 | |
Jorim Jaggi | 241ae10 | 2016-11-02 21:57:33 -0700 | [diff] [blame] | 263 | public void dismiss(IKeyguardDismissCallback callback) { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 264 | if (mKeyguardService != null) { |
Jorim Jaggi | 241ae10 | 2016-11-02 21:57:33 -0700 | [diff] [blame] | 265 | mKeyguardService.dismiss(callback); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 266 | } |
| 267 | } |
| 268 | |
Jim Miller | e4044bb | 2016-05-10 18:38:25 -0700 | [diff] [blame] | 269 | public boolean isSecure(int userId) { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 270 | if (mKeyguardService != null) { |
Jim Miller | e4044bb | 2016-05-10 18:38:25 -0700 | [diff] [blame] | 271 | mKeyguardState.secure = mKeyguardService.isSecure(userId); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 272 | } |
| 273 | return mKeyguardState.secure; |
| 274 | } |
| 275 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 276 | public void onDreamingStarted() { |
| 277 | if (mKeyguardService != null) { |
| 278 | mKeyguardService.onDreamingStarted(); |
| 279 | } |
| 280 | mKeyguardState.dreaming = true; |
| 281 | } |
| 282 | |
| 283 | public void onDreamingStopped() { |
| 284 | if (mKeyguardService != null) { |
| 285 | mKeyguardService.onDreamingStopped(); |
| 286 | } |
| 287 | mKeyguardState.dreaming = false; |
| 288 | } |
| 289 | |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 290 | public void onStartedWakingUp() { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 291 | if (mKeyguardService != null) { |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 292 | if (DEBUG) Log.v(TAG, "onStartedWakingUp()"); |
| 293 | mKeyguardService.onStartedWakingUp(); |
| 294 | } |
Adrian Roos | 369907f | 2017-07-14 14:53:39 +0200 | [diff] [blame] | 295 | mKeyguardState.interactiveState = INTERACTIVE_STATE_WAKING; |
| 296 | } |
| 297 | |
| 298 | public void onFinishedWakingUp() { |
| 299 | if (mKeyguardService != null) { |
| 300 | if (DEBUG) Log.v(TAG, "onFinishedWakingUp()"); |
| 301 | mKeyguardService.onFinishedWakingUp(); |
| 302 | } |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 303 | mKeyguardState.interactiveState = INTERACTIVE_STATE_AWAKE; |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 304 | } |
| 305 | |
Adrian Roos | 369907f | 2017-07-14 14:53:39 +0200 | [diff] [blame] | 306 | public void onScreenTurningOff() { |
| 307 | if (mKeyguardService != null) { |
| 308 | if (DEBUG) Log.v(TAG, "onScreenTurningOff()"); |
| 309 | mKeyguardService.onScreenTurningOff(); |
| 310 | } |
| 311 | mKeyguardState.screenState = SCREEN_STATE_TURNING_OFF; |
| 312 | } |
| 313 | |
Jorim Jaggi | 0d210f6 | 2015-07-10 14:24:44 -0700 | [diff] [blame] | 314 | public void onScreenTurnedOff() { |
| 315 | if (mKeyguardService != null) { |
| 316 | if (DEBUG) Log.v(TAG, "onScreenTurnedOff()"); |
| 317 | mKeyguardService.onScreenTurnedOff(); |
| 318 | } |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 319 | mKeyguardState.screenState = SCREEN_STATE_OFF; |
Jorim Jaggi | 0d210f6 | 2015-07-10 14:24:44 -0700 | [diff] [blame] | 320 | } |
| 321 | |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 322 | public void onScreenTurningOn(final DrawnListener drawnListener) { |
| 323 | if (mKeyguardService != null) { |
| 324 | if (DEBUG) Log.v(TAG, "onScreenTurnedOn(showListener = " + drawnListener + ")"); |
| 325 | mKeyguardService.onScreenTurningOn(new KeyguardShowDelegate(drawnListener)); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 326 | } else { |
| 327 | // try again when we establish a connection |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 328 | Slog.w(TAG, "onScreenTurningOn(): no keyguard service!"); |
Jim Miller | a8800f7 | 2014-12-12 13:34:43 -0800 | [diff] [blame] | 329 | // This shouldn't happen, but if it does, show the scrim immediately and |
| 330 | // invoke the listener's callback after the service actually connects. |
Jorim Jaggi | 740452e | 2015-07-09 12:13:59 -0700 | [diff] [blame] | 331 | mDrawnListenerWhenConnect = drawnListener; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 332 | } |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 333 | mKeyguardState.screenState = SCREEN_STATE_TURNING_ON; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 334 | } |
| 335 | |
Jorim Jaggi | 0d210f6 | 2015-07-10 14:24:44 -0700 | [diff] [blame] | 336 | public void onScreenTurnedOn() { |
| 337 | if (mKeyguardService != null) { |
| 338 | if (DEBUG) Log.v(TAG, "onScreenTurnedOn()"); |
| 339 | mKeyguardService.onScreenTurnedOn(); |
| 340 | } |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 341 | mKeyguardState.screenState = SCREEN_STATE_ON; |
Jorim Jaggi | 0d210f6 | 2015-07-10 14:24:44 -0700 | [diff] [blame] | 342 | } |
| 343 | |
Jorim Jaggi | d175b6c | 2015-05-27 15:39:09 -0700 | [diff] [blame] | 344 | public void onStartedGoingToSleep(int why) { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 345 | if (mKeyguardService != null) { |
Jorim Jaggi | d175b6c | 2015-05-27 15:39:09 -0700 | [diff] [blame] | 346 | mKeyguardService.onStartedGoingToSleep(why); |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 347 | } |
| 348 | mKeyguardState.offReason = why; |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 349 | mKeyguardState.interactiveState = INTERACTIVE_STATE_GOING_TO_SLEEP; |
Jorim Jaggi | d175b6c | 2015-05-27 15:39:09 -0700 | [diff] [blame] | 350 | } |
| 351 | |
Jorim Jaggi | f1cdf95 | 2016-04-05 21:41:06 -0700 | [diff] [blame] | 352 | public void onFinishedGoingToSleep(int why, boolean cameraGestureTriggered) { |
Jorim Jaggi | d175b6c | 2015-05-27 15:39:09 -0700 | [diff] [blame] | 353 | if (mKeyguardService != null) { |
Jorim Jaggi | f1cdf95 | 2016-04-05 21:41:06 -0700 | [diff] [blame] | 354 | mKeyguardService.onFinishedGoingToSleep(why, cameraGestureTriggered); |
Jorim Jaggi | d175b6c | 2015-05-27 15:39:09 -0700 | [diff] [blame] | 355 | } |
Jorim Jaggi | c049607 | 2015-08-19 15:14:52 -0700 | [diff] [blame] | 356 | mKeyguardState.interactiveState = INTERACTIVE_STATE_SLEEP; |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 357 | } |
| 358 | |
| 359 | public void setKeyguardEnabled(boolean enabled) { |
| 360 | if (mKeyguardService != null) { |
| 361 | mKeyguardService.setKeyguardEnabled(enabled); |
| 362 | } |
| 363 | mKeyguardState.enabled = enabled; |
| 364 | } |
| 365 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 366 | public void onSystemReady() { |
| 367 | if (mKeyguardService != null) { |
| 368 | mKeyguardService.onSystemReady(); |
| 369 | } else { |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 370 | mKeyguardState.systemIsReady = true; |
| 371 | } |
| 372 | } |
| 373 | |
| 374 | public void doKeyguardTimeout(Bundle options) { |
| 375 | if (mKeyguardService != null) { |
| 376 | mKeyguardService.doKeyguardTimeout(options); |
| 377 | } |
| 378 | } |
| 379 | |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 380 | public void setCurrentUser(int newUserId) { |
| 381 | if (mKeyguardService != null) { |
| 382 | mKeyguardService.setCurrentUser(newUserId); |
| 383 | } |
| 384 | mKeyguardState.currentUser = newUserId; |
| 385 | } |
| 386 | |
Evan Rosky | 1839645 | 2016-07-27 15:19:37 -0700 | [diff] [blame] | 387 | public void setSwitchingUser(boolean switching) { |
| 388 | if (mKeyguardService != null) { |
| 389 | mKeyguardService.setSwitchingUser(switching); |
| 390 | } |
| 391 | } |
| 392 | |
Jorim Jaggi | e29b2db | 2014-05-30 23:17:03 +0200 | [diff] [blame] | 393 | public void startKeyguardExitAnimation(long startTime, long fadeoutDuration) { |
Jorim Jaggi | 0d67462 | 2014-05-21 01:34:15 +0200 | [diff] [blame] | 394 | if (mKeyguardService != null) { |
Jorim Jaggi | e29b2db | 2014-05-30 23:17:03 +0200 | [diff] [blame] | 395 | mKeyguardService.startKeyguardExitAnimation(startTime, fadeoutDuration); |
Jorim Jaggi | 0d67462 | 2014-05-21 01:34:15 +0200 | [diff] [blame] | 396 | } |
| 397 | } |
| 398 | |
Jim Miller | e5f910a | 2013-10-16 18:15:46 -0700 | [diff] [blame] | 399 | public void onBootCompleted() { |
| 400 | if (mKeyguardService != null) { |
| 401 | mKeyguardService.onBootCompleted(); |
| 402 | } |
| 403 | mKeyguardState.bootCompleted = true; |
| 404 | } |
| 405 | |
Andrew Zeng | b4045d3 | 2017-03-16 17:25:07 -0700 | [diff] [blame] | 406 | public void onShortPowerPressedGoHome() { |
| 407 | if (mKeyguardService != null) { |
| 408 | mKeyguardService.onShortPowerPressedGoHome(); |
| 409 | } |
| 410 | } |
| 411 | |
Jorim Jaggi | 84dc08a | 2015-09-11 17:45:22 -0700 | [diff] [blame] | 412 | public void dump(String prefix, PrintWriter pw) { |
| 413 | pw.println(prefix + TAG); |
| 414 | prefix += " "; |
| 415 | pw.println(prefix + "showing=" + mKeyguardState.showing); |
| 416 | pw.println(prefix + "showingAndNotOccluded=" + mKeyguardState.showingAndNotOccluded); |
| 417 | pw.println(prefix + "inputRestricted=" + mKeyguardState.inputRestricted); |
| 418 | pw.println(prefix + "occluded=" + mKeyguardState.occluded); |
| 419 | pw.println(prefix + "secure=" + mKeyguardState.secure); |
| 420 | pw.println(prefix + "dreaming=" + mKeyguardState.dreaming); |
| 421 | pw.println(prefix + "systemIsReady=" + mKeyguardState.systemIsReady); |
| 422 | pw.println(prefix + "deviceHasKeyguard=" + mKeyguardState.deviceHasKeyguard); |
| 423 | pw.println(prefix + "enabled=" + mKeyguardState.enabled); |
| 424 | pw.println(prefix + "offReason=" + mKeyguardState.offReason); |
| 425 | pw.println(prefix + "currentUser=" + mKeyguardState.currentUser); |
| 426 | pw.println(prefix + "bootCompleted=" + mKeyguardState.bootCompleted); |
| 427 | pw.println(prefix + "screenState=" + mKeyguardState.screenState); |
| 428 | pw.println(prefix + "interactiveState=" + mKeyguardState.interactiveState); |
| 429 | if (mKeyguardService != null) { |
| 430 | mKeyguardService.dump(prefix, pw); |
| 431 | } |
| 432 | } |
Jim Miller | 5ecd811 | 2013-01-09 18:50:26 -0800 | [diff] [blame] | 433 | } |