1 /* 2 * Copyright (C) 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License 15 */ 16 17 package com.android.server.am; 18 19 import static android.app.ActivityManager.StackId.DOCKED_STACK_ID; 20 import static android.os.Trace.TRACE_TAG_ACTIVITY_MANAGER; 21 import static android.view.Display.DEFAULT_DISPLAY; 22 import static android.view.Display.INVALID_DISPLAY; 23 import static android.view.WindowManagerPolicy.KEYGUARD_GOING_AWAY_FLAG_NO_WINDOW_ANIMATIONS; 24 import static android.view.WindowManagerPolicy.KEYGUARD_GOING_AWAY_FLAG_TO_SHADE; 25 import static android.view.WindowManagerPolicy.KEYGUARD_GOING_AWAY_FLAG_WITH_WALLPAPER; 26 import static com.android.server.am.ActivityManagerDebugConfig.TAG_AM; 27 import static com.android.server.am.ActivityManagerDebugConfig.TAG_WITH_CLASS_NAME; 28 import static com.android.server.am.ActivityStackSupervisor.PRESERVE_WINDOWS; 29 import static com.android.server.wm.AppTransition.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION; 30 import static com.android.server.wm.AppTransition.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE; 31 import static com.android.server.wm.AppTransition.TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER; 32 import static com.android.server.wm.AppTransition.TRANSIT_KEYGUARD_GOING_AWAY; 33 import static com.android.server.wm.AppTransition.TRANSIT_KEYGUARD_OCCLUDE; 34 import static com.android.server.wm.AppTransition.TRANSIT_KEYGUARD_UNOCCLUDE; 35 import static com.android.server.wm.AppTransition.TRANSIT_UNSET; 36 37 import android.app.ActivityManagerInternal.SleepToken; 38 import android.os.IBinder; 39 import android.os.RemoteException; 40 import android.os.Trace; 41 import android.util.Slog; 42 43 import com.android.internal.policy.IKeyguardDismissCallback; 44 import com.android.server.wm.WindowManagerService; 45 46 import java.io.PrintWriter; 47 import java.util.ArrayList; 48 49 /** 50 * Controls Keyguard occluding, dismissing and transitions depending on what kind of activities are 51 * currently visible. 52 * <p> 53 * Note that everything in this class should only be accessed with the AM lock being held. 54 */ 55 class KeyguardController { 56 57 private static final String TAG = TAG_WITH_CLASS_NAME ? "KeyguardController" : TAG_AM; 58 59 private final ActivityManagerService mService; 60 private final ActivityStackSupervisor mStackSupervisor; 61 private WindowManagerService mWindowManager; 62 private boolean mKeyguardShowing; 63 private boolean mKeyguardGoingAway; 64 private boolean mOccluded; 65 private boolean mDismissalRequested; 66 private ActivityRecord mDismissingKeyguardActivity; 67 private int mBeforeUnoccludeTransit; 68 private int mVisibilityTransactionDepth; 69 private SleepToken mSleepToken; 70 private int mSecondaryDisplayShowing = INVALID_DISPLAY; 71 72 KeyguardController(ActivityManagerService service, 73 ActivityStackSupervisor stackSupervisor) { 74 mService = service; 75 mStackSupervisor = stackSupervisor; 76 } 77 78 void setWindowManager(WindowManagerService windowManager) { 79 mWindowManager = windowManager; 80 } 81 82 /** 83 * @return true if Keyguard is showing, not going away, and not being occluded on the given 84 * display, false otherwise 85 */ 86 boolean isKeyguardShowing(int displayId) { 87 return mKeyguardShowing && !mKeyguardGoingAway && 88 (displayId == DEFAULT_DISPLAY ? !mOccluded : displayId == mSecondaryDisplayShowing); 89 } 90 91 /** 92 * @return true if Keyguard is either showing or occluded, but not going away 93 */ 94 boolean isKeyguardLocked() { 95 return mKeyguardShowing && !mKeyguardGoingAway; 96 } 97 98 /** 99 * Update the Keyguard showing state. 100 */ 101 void setKeyguardShown(boolean showing, int secondaryDisplayShowing) { 102 boolean showingChanged = showing != mKeyguardShowing; 103 if (!showingChanged && secondaryDisplayShowing == mSecondaryDisplayShowing) { 104 return; 105 } 106 mKeyguardShowing = showing; 107 mSecondaryDisplayShowing = secondaryDisplayShowing; 108 if (showingChanged) { 109 dismissDockedStackIfNeeded(); 110 if (showing) { 111 setKeyguardGoingAway(false); 112 mDismissalRequested = false; 113 } 114 } 115 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 116 updateKeyguardSleepToken(); 117 } 118 119 /** 120 * Called when Keyguard is going away. 121 * 122 * @param flags See {@link android.view.WindowManagerPolicy#KEYGUARD_GOING_AWAY_FLAG_TO_SHADE} 123 * etc. 124 */ 125 void keyguardGoingAway(int flags) { 126 if (!mKeyguardShowing) { 127 return; 128 } 129 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "keyguardGoingAway"); 130 mWindowManager.deferSurfaceLayout(); 131 try { 132 setKeyguardGoingAway(true); 133 mWindowManager.prepareAppTransition(TRANSIT_KEYGUARD_GOING_AWAY, 134 false /* alwaysKeepCurrent */, convertTransitFlags(flags), 135 false /* forceOverride */); 136 updateKeyguardSleepToken(); 137 138 // Some stack visibility might change (e.g. docked stack) 139 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 140 mStackSupervisor.addStartingWindowsForVisibleActivities(true /* taskSwitch */); 141 mWindowManager.executeAppTransition(); 142 } finally { 143 Trace.traceBegin(TRACE_TAG_ACTIVITY_MANAGER, "keyguardGoingAway: surfaceLayout"); 144 mWindowManager.continueSurfaceLayout(); 145 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER); 146 147 Trace.traceEnd(TRACE_TAG_ACTIVITY_MANAGER); 148 } 149 } 150 151 void dismissKeyguard(IBinder token, IKeyguardDismissCallback callback) { 152 final ActivityRecord activityRecord = ActivityRecord.forTokenLocked(token); 153 if (activityRecord == null || !activityRecord.visibleIgnoringKeyguard) { 154 failCallback(callback); 155 return; 156 } 157 Slog.i(TAG, "Activity requesting to dismiss Keyguard: " + activityRecord); 158 159 // If the client has requested to dismiss the keyguard and the Activity has the flag to 160 // turn the screen on, wakeup the screen if it's the top Activity. 161 if (activityRecord.getTurnScreenOnFlag() && activityRecord.isTopRunningActivity()) { 162 mStackSupervisor.wakeUp("dismissKeyguard"); 163 } 164 165 mWindowManager.dismissKeyguard(callback); 166 } 167 168 private void setKeyguardGoingAway(boolean keyguardGoingAway) { 169 mKeyguardGoingAway = keyguardGoingAway; 170 mWindowManager.setKeyguardGoingAway(keyguardGoingAway); 171 } 172 173 private void failCallback(IKeyguardDismissCallback callback) { 174 try { 175 callback.onDismissError(); 176 } catch (RemoteException e) { 177 Slog.w(TAG, "Failed to call callback", e); 178 } 179 } 180 181 private int convertTransitFlags(int keyguardGoingAwayFlags) { 182 int result = 0; 183 if ((keyguardGoingAwayFlags & KEYGUARD_GOING_AWAY_FLAG_TO_SHADE) != 0) { 184 result |= TRANSIT_FLAG_KEYGUARD_GOING_AWAY_TO_SHADE; 185 } 186 if ((keyguardGoingAwayFlags & KEYGUARD_GOING_AWAY_FLAG_NO_WINDOW_ANIMATIONS) != 0) { 187 result |= TRANSIT_FLAG_KEYGUARD_GOING_AWAY_NO_ANIMATION; 188 } 189 if ((keyguardGoingAwayFlags & KEYGUARD_GOING_AWAY_FLAG_WITH_WALLPAPER) != 0) { 190 result |= TRANSIT_FLAG_KEYGUARD_GOING_AWAY_WITH_WALLPAPER; 191 } 192 return result; 193 } 194 195 /** 196 * Starts a batch of visibility updates. 197 */ 198 void beginActivityVisibilityUpdate() { 199 mVisibilityTransactionDepth++; 200 } 201 202 /** 203 * Ends a batch of visibility updates. After all batches are done, this method makes sure to 204 * update lockscreen occluded/dismiss state if needed. 205 */ 206 void endActivityVisibilityUpdate() { 207 mVisibilityTransactionDepth--; 208 if (mVisibilityTransactionDepth == 0) { 209 visibilitiesUpdated(); 210 } 211 } 212 213 /** 214 * @return True if we may show an activity while Keyguard is showing because we are in the 215 * process of dismissing it anyways, false otherwise. 216 */ 217 boolean canShowActivityWhileKeyguardShowing(ActivityRecord r, boolean dismissKeyguard) { 218 219 // Allow to show it when we are about to dismiss Keyguard. This isn't allowed if r is 220 // already the dismissing activity, in which case we don't allow it to repeatedly dismiss 221 // Keyguard. 222 return dismissKeyguard && canDismissKeyguard() && 223 (mDismissalRequested || r != mDismissingKeyguardActivity); 224 } 225 226 /** 227 * @return True if we may show an activity while Keyguard is occluded, false otherwise. 228 */ 229 boolean canShowWhileOccluded(boolean dismissKeyguard, boolean showWhenLocked) { 230 return showWhenLocked || dismissKeyguard && !mWindowManager.isKeyguardSecure(); 231 } 232 233 private void visibilitiesUpdated() { 234 final boolean lastOccluded = mOccluded; 235 final ActivityRecord lastDismissingKeyguardActivity = mDismissingKeyguardActivity; 236 mOccluded = false; 237 mDismissingKeyguardActivity = null; 238 final ArrayList<ActivityStack> stacks = mStackSupervisor.getStacksOnDefaultDisplay(); 239 for (int stackNdx = stacks.size() - 1; stackNdx >= 0; --stackNdx) { 240 final ActivityStack stack = stacks.get(stackNdx); 241 242 // Only the focused stack top activity may control occluded state 243 if (mStackSupervisor.isFocusedStack(stack)) { 244 245 // A dismissing activity occludes Keyguard in the insecure case for legacy reasons. 246 final ActivityRecord topDismissing = stack.getTopDismissingKeyguardActivity(); 247 mOccluded = stack.topActivityOccludesKeyguard() 248 || (topDismissing != null 249 && stack.topRunningActivityLocked() == topDismissing 250 && canShowWhileOccluded(true /* dismissKeyguard */, 251 false /* showWhenLocked */)); 252 } 253 if (mDismissingKeyguardActivity == null 254 && stack.getTopDismissingKeyguardActivity() != null) { 255 mDismissingKeyguardActivity = stack.getTopDismissingKeyguardActivity(); 256 } 257 } 258 mOccluded |= mWindowManager.isShowingDream(); 259 if (mOccluded != lastOccluded) { 260 handleOccludedChanged(); 261 } 262 if (mDismissingKeyguardActivity != lastDismissingKeyguardActivity) { 263 handleDismissKeyguard(); 264 } 265 } 266 267 /** 268 * Called when occluded state changed. 269 */ 270 private void handleOccludedChanged() { 271 mWindowManager.onKeyguardOccludedChanged(mOccluded); 272 if (isKeyguardLocked()) { 273 mWindowManager.deferSurfaceLayout(); 274 try { 275 mWindowManager.prepareAppTransition(resolveOccludeTransit(), 276 false /* alwaysKeepCurrent */, 0 /* flags */, true /* forceOverride */); 277 updateKeyguardSleepToken(); 278 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 279 mWindowManager.executeAppTransition(); 280 } finally { 281 mWindowManager.continueSurfaceLayout(); 282 } 283 } 284 dismissDockedStackIfNeeded(); 285 } 286 287 /** 288 * Called when somebody might want to dismiss the Keyguard. 289 */ 290 private void handleDismissKeyguard() { 291 // We only allow dismissing Keyguard via the flag when Keyguard is secure for legacy 292 // reasons, because that's how apps used to dismiss Keyguard in the secure case. In the 293 // insecure case, we actually show it on top of the lockscreen. See #canShowWhileOccluded. 294 if (!mOccluded && mDismissingKeyguardActivity != null 295 && mWindowManager.isKeyguardSecure()) { 296 mWindowManager.dismissKeyguard(null /* callback */); 297 mDismissalRequested = true; 298 299 // If we are about to unocclude the Keyguard, but we can dismiss it without security, 300 // we immediately dismiss the Keyguard so the activity gets shown without a flicker. 301 if (mKeyguardShowing && canDismissKeyguard() 302 && mWindowManager.getPendingAppTransition() == TRANSIT_KEYGUARD_UNOCCLUDE) { 303 mWindowManager.prepareAppTransition(mBeforeUnoccludeTransit, 304 false /* alwaysKeepCurrent */, 0 /* flags */, true /* forceOverride */); 305 mStackSupervisor.ensureActivitiesVisibleLocked(null, 0, !PRESERVE_WINDOWS); 306 mWindowManager.executeAppTransition(); 307 } 308 } 309 } 310 311 /** 312 * @return true if Keyguard can be currently dismissed without entering credentials. 313 */ 314 boolean canDismissKeyguard() { 315 return mWindowManager.isKeyguardTrusted() || !mWindowManager.isKeyguardSecure(); 316 } 317 318 private int resolveOccludeTransit() { 319 if (mBeforeUnoccludeTransit != TRANSIT_UNSET 320 && mWindowManager.getPendingAppTransition() == TRANSIT_KEYGUARD_UNOCCLUDE 321 && mOccluded) { 322 323 // Reuse old transit in case we are occluding Keyguard again, meaning that we never 324 // actually occclude/unocclude Keyguard, but just run a normal transition. 325 return mBeforeUnoccludeTransit; 326 } else if (!mOccluded) { 327 328 // Save transit in case we dismiss/occlude Keyguard shortly after. 329 mBeforeUnoccludeTransit = mWindowManager.getPendingAppTransition(); 330 return TRANSIT_KEYGUARD_UNOCCLUDE; 331 } else { 332 return TRANSIT_KEYGUARD_OCCLUDE; 333 } 334 } 335 336 private void dismissDockedStackIfNeeded() { 337 if (mKeyguardShowing && mOccluded) { 338 // The lock screen is currently showing, but is occluded by a window that can 339 // show on top of the lock screen. In this can we want to dismiss the docked 340 // stack since it will be complicated/risky to try to put the activity on top 341 // of the lock screen in the right fullscreen configuration. 342 mStackSupervisor.moveTasksToFullscreenStackLocked(DOCKED_STACK_ID, 343 mStackSupervisor.mFocusedStack.getStackId() == DOCKED_STACK_ID); 344 } 345 } 346 347 private void updateKeyguardSleepToken() { 348 if (mSleepToken == null && isKeyguardShowing(DEFAULT_DISPLAY)) { 349 mSleepToken = mService.acquireSleepToken("Keyguard", DEFAULT_DISPLAY); 350 } else if (mSleepToken != null && !isKeyguardShowing(DEFAULT_DISPLAY)) { 351 mSleepToken.release(); 352 mSleepToken = null; 353 } 354 } 355 356 void dump(PrintWriter pw, String prefix) { 357 pw.println(prefix + "KeyguardController:"); 358 pw.println(prefix + " mKeyguardShowing=" + mKeyguardShowing); 359 pw.println(prefix + " mKeyguardGoingAway=" + mKeyguardGoingAway); 360 pw.println(prefix + " mOccluded=" + mOccluded); 361 pw.println(prefix + " mDismissingKeyguardActivity=" + mDismissingKeyguardActivity); 362 pw.println(prefix + " mDismissalRequested=" + mDismissalRequested); 363 pw.println(prefix + " mVisibilityTransactionDepth=" + mVisibilityTransactionDepth); 364 } 365 } 366