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.wm; 18 19 import android.content.res.Configuration; 20 import android.graphics.Rect; 21 import android.hardware.power.V1_0.PowerHint; 22 import android.os.Binder; 23 import android.os.Debug; 24 import android.os.Handler; 25 import android.os.IBinder; 26 import android.os.Looper; 27 import android.os.Message; 28 import android.os.ParcelFileDescriptor; 29 import android.os.PowerManager; 30 import android.os.RemoteException; 31 import android.os.SystemClock; 32 import android.os.UserHandle; 33 import android.provider.Settings; 34 import android.util.EventLog; 35 import android.util.Slog; 36 import android.util.SparseIntArray; 37 import android.view.Display; 38 import android.view.DisplayInfo; 39 import android.view.WindowManager; 40 41 import com.android.internal.os.SomeArgs; 42 import com.android.internal.util.ArrayUtils; 43 import com.android.server.EventLogTags; 44 45 import java.io.FileDescriptor; 46 import java.io.PrintWriter; 47 import java.util.ArrayList; 48 import java.util.function.Consumer; 49 50 import static android.app.AppOpsManager.MODE_ALLOWED; 51 import static android.app.AppOpsManager.MODE_DEFAULT; 52 import static android.app.AppOpsManager.OP_NONE; 53 import static android.view.Display.DEFAULT_DISPLAY; 54 import static android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON; 55 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD; 56 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_SUSTAINED_PERFORMANCE_MODE; 57 import static android.view.WindowManager.LayoutParams.TYPE_DREAM; 58 import static android.view.WindowManager.LayoutParams.TYPE_KEYGUARD_DIALOG; 59 import static android.view.WindowManagerPolicy.FINISH_LAYOUT_REDO_ANIM; 60 import static android.view.WindowManagerPolicy.FINISH_LAYOUT_REDO_LAYOUT; 61 import static android.view.WindowManagerPolicy.FINISH_LAYOUT_REDO_WALLPAPER; 62 63 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_DISPLAY; 64 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_KEEP_SCREEN_ON; 65 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_LAYOUT_REPEATS; 66 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_ORIENTATION; 67 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_POWER; 68 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_VISIBILITY; 69 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_WALLPAPER_LIGHT; 70 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_WINDOW_TRACE; 71 import static com.android.server.wm.WindowManagerDebugConfig.SHOW_LIGHT_TRANSACTIONS; 72 import static com.android.server.wm.WindowManagerDebugConfig.SHOW_SURFACE_ALLOC; 73 import static com.android.server.wm.WindowManagerDebugConfig.SHOW_TRANSACTIONS; 74 import static com.android.server.wm.WindowManagerDebugConfig.TAG_KEEP_SCREEN_ON; 75 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME; 76 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM; 77 import static com.android.server.wm.WindowManagerService.H.REPORT_LOSING_FOCUS; 78 import static com.android.server.wm.WindowManagerService.H.SEND_NEW_CONFIGURATION; 79 import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_PLACING_SURFACES; 80 import static com.android.server.wm.WindowManagerService.UPDATE_FOCUS_WILL_PLACE_SURFACES; 81 import static com.android.server.wm.WindowManagerService.WINDOWS_FREEZING_SCREENS_NONE; 82 import static com.android.server.wm.WindowManagerService.H.WINDOW_FREEZE_TIMEOUT; 83 import static com.android.server.wm.WindowManagerService.logSurface; 84 import static com.android.server.wm.WindowSurfacePlacer.SET_FORCE_HIDING_CHANGED; 85 import static com.android.server.wm.WindowSurfacePlacer.SET_ORIENTATION_CHANGE_COMPLETE; 86 import static com.android.server.wm.WindowSurfacePlacer.SET_TURN_ON_SCREEN; 87 import static com.android.server.wm.WindowSurfacePlacer.SET_UPDATE_ROTATION; 88 import static com.android.server.wm.WindowSurfacePlacer.SET_WALLPAPER_ACTION_PENDING; 89 import static com.android.server.wm.WindowSurfacePlacer.SET_WALLPAPER_MAY_CHANGE; 90 91 /** Root {@link WindowContainer} for the device. */ 92 class RootWindowContainer extends WindowContainer<DisplayContent> { 93 private static final String TAG = TAG_WITH_CLASS_NAME ? "RootWindowContainer" : TAG_WM; 94 95 private static final int SET_SCREEN_BRIGHTNESS_OVERRIDE = 1; 96 private static final int SET_USER_ACTIVITY_TIMEOUT = 2; 97 98 WindowManagerService mService; 99 100 private boolean mWallpaperForceHidingChanged = false; 101 private Object mLastWindowFreezeSource = null; 102 private Session mHoldScreen = null; 103 private float mScreenBrightness = -1; 104 private long mUserActivityTimeout = -1; 105 private boolean mUpdateRotation = false; 106 // Following variables are for debugging screen wakelock only. 107 // Last window that requires screen wakelock 108 WindowState mHoldScreenWindow = null; 109 // Last window that obscures all windows below 110 WindowState mObscuringWindow = null; 111 // Only set while traversing the default display based on its content. 112 // Affects the behavior of mirroring on secondary displays. 113 private boolean mObscureApplicationContentOnSecondaryDisplays = false; 114 115 private boolean mSustainedPerformanceModeEnabled = false; 116 private boolean mSustainedPerformanceModeCurrent = false; 117 118 boolean mWallpaperMayChange = false; 119 // During an orientation change, we track whether all windows have rendered 120 // at the new orientation, and this will be false from changing orientation until that occurs. 121 // For seamless rotation cases this always stays true, as the windows complete their orientation 122 // changes 1 by 1 without disturbing global state. 123 boolean mOrientationChangeComplete = true; 124 boolean mWallpaperActionPending = false; 125 126 private final ArrayList<Integer> mChangedStackList = new ArrayList(); 127 128 // State for the RemoteSurfaceTrace system used in testing. If this is enabled SurfaceControl 129 // instances will be replaced with an instance that writes a binary representation of all 130 // commands to mSurfaceTraceFd. 131 boolean mSurfaceTraceEnabled; 132 ParcelFileDescriptor mSurfaceTraceFd; 133 RemoteEventTrace mRemoteEventTrace; 134 135 private final WindowLayersController mLayersController; 136 final WallpaperController mWallpaperController; 137 138 private final Handler mHandler; 139 140 private String mCloseSystemDialogsReason; 141 private final Consumer<WindowState> mCloseSystemDialogsConsumer = w -> { 142 if (w.mHasSurface) { 143 try { 144 w.mClient.closeSystemDialogs(mCloseSystemDialogsReason); 145 } catch (RemoteException e) { 146 } 147 } 148 }; 149 150 private static final Consumer<WindowState> sRemoveReplacedWindowsConsumer = w -> { 151 final AppWindowToken aToken = w.mAppToken; 152 if (aToken != null) { 153 aToken.removeReplacedWindowIfNeeded(w); 154 } 155 }; 156 157 RootWindowContainer(WindowManagerService service) { 158 mService = service; 159 mHandler = new MyHandler(service.mH.getLooper()); 160 mLayersController = new WindowLayersController(mService); 161 mWallpaperController = new WallpaperController(mService); 162 } 163 164 WindowState computeFocusedWindow() { 165 for (int i = mChildren.size() - 1; i >= 0; i--) { 166 final DisplayContent dc = mChildren.get(i); 167 final WindowState win = dc.findFocusedWindow(); 168 if (win != null) { 169 return win; 170 } 171 } 172 return null; 173 } 174 175 /** 176 * Get an array with display ids ordered by focus priority - last items should be given 177 * focus first. Sparse array just maps position to displayId. 178 */ 179 void getDisplaysInFocusOrder(SparseIntArray displaysInFocusOrder) { 180 displaysInFocusOrder.clear(); 181 182 final int size = mChildren.size(); 183 for (int i = 0; i < size; ++i) { 184 final DisplayContent displayContent = mChildren.get(i); 185 if (displayContent.isRemovalDeferred()) { 186 // Don't report displays that are going to be removed soon. 187 continue; 188 } 189 displaysInFocusOrder.put(i, displayContent.getDisplayId()); 190 } 191 } 192 193 /** 194 * Retrieve the DisplayContent for the specified displayId. Will create a new DisplayContent if 195 * there is a Display for the displayId. 196 * 197 * @param displayId The display the caller is interested in. 198 * @return The DisplayContent associated with displayId or null if there is no Display for it. 199 */ 200 DisplayContent getDisplayContentOrCreate(int displayId) { 201 DisplayContent dc = getDisplayContent(displayId); 202 203 if (dc == null) { 204 final Display display = mService.mDisplayManager.getDisplay(displayId); 205 if (display != null) { 206 final long callingIdentity = Binder.clearCallingIdentity(); 207 try { 208 dc = createDisplayContent(display); 209 } finally { 210 Binder.restoreCallingIdentity(callingIdentity); 211 } 212 } 213 } 214 return dc; 215 } 216 217 DisplayContent getDisplayContent(int displayId) { 218 for (int i = mChildren.size() - 1; i >= 0; --i) { 219 final DisplayContent current = mChildren.get(i); 220 if (current.getDisplayId() == displayId) { 221 return current; 222 } 223 } 224 return null; 225 } 226 227 private DisplayContent createDisplayContent(final Display display) { 228 final DisplayContent dc = new DisplayContent(display, mService, mLayersController, 229 mWallpaperController); 230 final int displayId = display.getDisplayId(); 231 232 if (DEBUG_DISPLAY) Slog.v(TAG_WM, "Adding display=" + display); 233 234 final DisplayInfo displayInfo = dc.getDisplayInfo(); 235 final Rect rect = new Rect(); 236 mService.mDisplaySettings.getOverscanLocked(displayInfo.name, displayInfo.uniqueId, rect); 237 displayInfo.overscanLeft = rect.left; 238 displayInfo.overscanTop = rect.top; 239 displayInfo.overscanRight = rect.right; 240 displayInfo.overscanBottom = rect.bottom; 241 if (mService.mDisplayManagerInternal != null) { 242 mService.mDisplayManagerInternal.setDisplayInfoOverrideFromWindowManager( 243 displayId, displayInfo); 244 mService.configureDisplayPolicyLocked(dc); 245 246 // TODO(multi-display): Create an input channel for each display with touch capability. 247 if (displayId == DEFAULT_DISPLAY && mService.canDispatchPointerEvents()) { 248 dc.mTapDetector = new TaskTapPointerEventListener( 249 mService, dc); 250 mService.registerPointerEventListener(dc.mTapDetector); 251 mService.registerPointerEventListener(mService.mMousePositionTracker); 252 } 253 } 254 255 return dc; 256 } 257 258 boolean isLayoutNeeded() { 259 final int numDisplays = mChildren.size(); 260 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 261 final DisplayContent displayContent = mChildren.get(displayNdx); 262 if (displayContent.isLayoutNeeded()) { 263 return true; 264 } 265 } 266 return false; 267 } 268 269 void getWindowsByName(ArrayList<WindowState> output, String name) { 270 int objectId = 0; 271 // See if this is an object ID. 272 try { 273 objectId = Integer.parseInt(name, 16); 274 name = null; 275 } catch (RuntimeException e) { 276 } 277 278 getWindowsByName(output, name, objectId); 279 } 280 281 private void getWindowsByName(ArrayList<WindowState> output, String name, int objectId) { 282 forAllWindows((w) -> { 283 if (name != null) { 284 if (w.mAttrs.getTitle().toString().contains(name)) { 285 output.add(w); 286 } 287 } else if (System.identityHashCode(w) == objectId) { 288 output.add(w); 289 } 290 }, true /* traverseTopToBottom */); 291 } 292 293 /** 294 * Returns the app window token for the input binder if it exist in the system. 295 * NOTE: Only one AppWindowToken is allowed to exist in the system for a binder token, since 296 * AppWindowToken represents an activity which can only exist on one display. 297 */ 298 AppWindowToken getAppWindowToken(IBinder binder) { 299 for (int i = mChildren.size() - 1; i >= 0; --i) { 300 final DisplayContent dc = mChildren.get(i); 301 final AppWindowToken atoken = dc.getAppWindowToken(binder); 302 if (atoken != null) { 303 return atoken; 304 } 305 } 306 return null; 307 } 308 309 /** Returns the display object the input window token is currently mapped on. */ 310 DisplayContent getWindowTokenDisplay(WindowToken token) { 311 if (token == null) { 312 return null; 313 } 314 315 for (int i = mChildren.size() - 1; i >= 0; --i) { 316 final DisplayContent dc = mChildren.get(i); 317 final WindowToken current = dc.getWindowToken(token.token); 318 if (current == token) { 319 return dc; 320 } 321 } 322 323 return null; 324 } 325 326 /** 327 * Set new display override config and return array of ids of stacks that were changed during 328 * update. If called for the default display, global configuration will also be updated. 329 */ 330 int[] setDisplayOverrideConfigurationIfNeeded(Configuration newConfiguration, int displayId) { 331 final DisplayContent displayContent = getDisplayContent(displayId); 332 if (displayContent == null) { 333 throw new IllegalArgumentException("Display not found for id: " + displayId); 334 } 335 336 final Configuration currentConfig = displayContent.getOverrideConfiguration(); 337 final boolean configChanged = currentConfig.diff(newConfiguration) != 0; 338 if (!configChanged) { 339 return null; 340 } 341 displayContent.onOverrideConfigurationChanged(newConfiguration); 342 343 if (displayId == DEFAULT_DISPLAY) { 344 // Override configuration of the default display duplicates global config. In this case 345 // we also want to update the global config. 346 return setGlobalConfigurationIfNeeded(newConfiguration); 347 } else { 348 return updateStackBoundsAfterConfigChange(displayId); 349 } 350 } 351 352 private int[] setGlobalConfigurationIfNeeded(Configuration newConfiguration) { 353 final boolean configChanged = getConfiguration().diff(newConfiguration) != 0; 354 if (!configChanged) { 355 return null; 356 } 357 onConfigurationChanged(newConfiguration); 358 return updateStackBoundsAfterConfigChange(); 359 } 360 361 @Override 362 void onConfigurationChanged(Configuration newParentConfig) { 363 prepareFreezingTaskBounds(); 364 super.onConfigurationChanged(newParentConfig); 365 366 mService.mPolicy.onConfigurationChanged(); 367 } 368 369 /** 370 * Callback used to trigger bounds update after configuration change and get ids of stacks whose 371 * bounds were updated. 372 */ 373 private int[] updateStackBoundsAfterConfigChange() { 374 mChangedStackList.clear(); 375 376 final int numDisplays = mChildren.size(); 377 for (int i = 0; i < numDisplays; ++i) { 378 final DisplayContent dc = mChildren.get(i); 379 dc.updateStackBoundsAfterConfigChange(mChangedStackList); 380 } 381 382 return mChangedStackList.isEmpty() ? null : ArrayUtils.convertToIntArray(mChangedStackList); 383 } 384 385 /** Same as {@link #updateStackBoundsAfterConfigChange()} but only for a specific display. */ 386 private int[] updateStackBoundsAfterConfigChange(int displayId) { 387 mChangedStackList.clear(); 388 389 final DisplayContent dc = getDisplayContent(displayId); 390 dc.updateStackBoundsAfterConfigChange(mChangedStackList); 391 392 return mChangedStackList.isEmpty() ? null : ArrayUtils.convertToIntArray(mChangedStackList); 393 } 394 395 private void prepareFreezingTaskBounds() { 396 for (int i = mChildren.size() - 1; i >= 0; i--) { 397 mChildren.get(i).prepareFreezingTaskBounds(); 398 } 399 } 400 401 TaskStack getStackById(int stackId) { 402 for (int i = mChildren.size() - 1; i >= 0; i--) { 403 final DisplayContent dc = mChildren.get(i); 404 final TaskStack stack = dc.getStackById(stackId); 405 if (stack != null) { 406 return stack; 407 } 408 } 409 return null; 410 } 411 412 void setSecureSurfaceState(int userId, boolean disabled) { 413 forAllWindows((w) -> { 414 if (w.mHasSurface && userId == UserHandle.getUserId(w.mOwnerUid)) { 415 w.mWinAnimator.setSecureLocked(disabled); 416 } 417 }, true /* traverseTopToBottom */); 418 } 419 420 void updateAppOpsState() { 421 forAllWindows((w) -> { 422 if (w.mAppOp == OP_NONE) { 423 return; 424 } 425 final int mode = mService.mAppOps.checkOpNoThrow(w.mAppOp, w.getOwningUid(), 426 w.getOwningPackage()); 427 w.setAppOpVisibilityLw(mode == MODE_ALLOWED || mode == MODE_DEFAULT); 428 }, false /* traverseTopToBottom */); 429 } 430 431 boolean canShowStrictModeViolation(int pid) { 432 final WindowState win = getWindow((w) -> w.mSession.mPid == pid && w.isVisibleLw()); 433 return win != null; 434 } 435 436 void closeSystemDialogs(String reason) { 437 mCloseSystemDialogsReason = reason; 438 forAllWindows(mCloseSystemDialogsConsumer, false /* traverseTopToBottom */); 439 } 440 441 void removeReplacedWindows() { 442 if (SHOW_TRANSACTIONS) Slog.i(TAG, ">>> OPEN TRANSACTION removeReplacedWindows"); 443 mService.openSurfaceTransaction(); 444 try { 445 forAllWindows(sRemoveReplacedWindowsConsumer, true /* traverseTopToBottom */); 446 } finally { 447 mService.closeSurfaceTransaction(); 448 if (SHOW_TRANSACTIONS) Slog.i(TAG, "<<< CLOSE TRANSACTION removeReplacedWindows"); 449 } 450 } 451 452 boolean hasPendingLayoutChanges(WindowAnimator animator) { 453 boolean hasChanges = false; 454 455 final int count = mChildren.size(); 456 for (int i = 0; i < count; ++i) { 457 final DisplayContent dc = mChildren.get(i); 458 final int pendingChanges = animator.getPendingLayoutChanges(dc.getDisplayId()); 459 if ((pendingChanges & FINISH_LAYOUT_REDO_WALLPAPER) != 0) { 460 animator.mBulkUpdateParams |= SET_WALLPAPER_ACTION_PENDING; 461 } 462 if (pendingChanges != 0) { 463 hasChanges = true; 464 } 465 } 466 467 return hasChanges; 468 } 469 470 boolean reclaimSomeSurfaceMemory(WindowStateAnimator winAnimator, String operation, 471 boolean secure) { 472 final WindowSurfaceController surfaceController = winAnimator.mSurfaceController; 473 boolean leakedSurface = false; 474 boolean killedApps = false; 475 476 EventLog.writeEvent(EventLogTags.WM_NO_SURFACE_MEMORY, winAnimator.mWin.toString(), 477 winAnimator.mSession.mPid, operation); 478 479 final long callingIdentity = Binder.clearCallingIdentity(); 480 try { 481 // There was some problem...first, do a sanity check of the window list to make sure 482 // we haven't left any dangling surfaces around. 483 484 Slog.i(TAG_WM, "Out of memory for surface! Looking for leaks..."); 485 final int numDisplays = mChildren.size(); 486 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 487 leakedSurface |= mChildren.get(displayNdx).destroyLeakedSurfaces(); 488 } 489 490 if (!leakedSurface) { 491 Slog.w(TAG_WM, "No leaked surfaces; killing applications!"); 492 final SparseIntArray pidCandidates = new SparseIntArray(); 493 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 494 mChildren.get(displayNdx).forAllWindows((w) -> { 495 if (mService.mForceRemoves.contains(w)) { 496 return; 497 } 498 final WindowStateAnimator wsa = w.mWinAnimator; 499 if (wsa.mSurfaceController != null) { 500 pidCandidates.append(wsa.mSession.mPid, wsa.mSession.mPid); 501 } 502 }, false /* traverseTopToBottom */); 503 504 if (pidCandidates.size() > 0) { 505 int[] pids = new int[pidCandidates.size()]; 506 for (int i = 0; i < pids.length; i++) { 507 pids[i] = pidCandidates.keyAt(i); 508 } 509 try { 510 if (mService.mActivityManager.killPids(pids, "Free memory", secure)) { 511 killedApps = true; 512 } 513 } catch (RemoteException e) { 514 } 515 } 516 } 517 } 518 519 if (leakedSurface || killedApps) { 520 // We managed to reclaim some memory, so get rid of the trouble surface and ask the 521 // app to request another one. 522 Slog.w(TAG_WM, 523 "Looks like we have reclaimed some memory, clearing surface for retry."); 524 if (surfaceController != null) { 525 if (SHOW_TRANSACTIONS || SHOW_SURFACE_ALLOC) logSurface(winAnimator.mWin, 526 "RECOVER DESTROY", false); 527 winAnimator.destroySurface(); 528 if (winAnimator.mWin.mAppToken != null 529 && winAnimator.mWin.mAppToken.getController() != null) { 530 winAnimator.mWin.mAppToken.getController().removeStartingWindow(); 531 } 532 } 533 534 try { 535 winAnimator.mWin.mClient.dispatchGetNewSurface(); 536 } catch (RemoteException e) { 537 } 538 } 539 } finally { 540 Binder.restoreCallingIdentity(callingIdentity); 541 } 542 543 return leakedSurface || killedApps; 544 } 545 546 // "Something has changed! Let's make it correct now." 547 // TODO: Super crazy long method that should be broken down... 548 void performSurfacePlacement(boolean recoveringMemory) { 549 if (DEBUG_WINDOW_TRACE) Slog.v(TAG, "performSurfacePlacementInner: entry. Called by " 550 + Debug.getCallers(3)); 551 552 int i; 553 boolean updateInputWindowsNeeded = false; 554 555 if (mService.mFocusMayChange) { 556 mService.mFocusMayChange = false; 557 updateInputWindowsNeeded = mService.updateFocusedWindowLocked( 558 UPDATE_FOCUS_WILL_PLACE_SURFACES, false /*updateInputWindows*/); 559 } 560 561 // Initialize state of exiting tokens. 562 final int numDisplays = mChildren.size(); 563 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 564 final DisplayContent displayContent = mChildren.get(displayNdx); 565 displayContent.setExitingTokensHasVisible(false); 566 } 567 568 mHoldScreen = null; 569 mScreenBrightness = -1; 570 mUserActivityTimeout = -1; 571 mObscureApplicationContentOnSecondaryDisplays = false; 572 mSustainedPerformanceModeCurrent = false; 573 mService.mTransactionSequence++; 574 575 // TODO(multi-display): 576 final DisplayContent defaultDisplay = mService.getDefaultDisplayContentLocked(); 577 final DisplayInfo defaultInfo = defaultDisplay.getDisplayInfo(); 578 final int defaultDw = defaultInfo.logicalWidth; 579 final int defaultDh = defaultInfo.logicalHeight; 580 581 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, 582 ">>> OPEN TRANSACTION performLayoutAndPlaceSurfaces"); 583 mService.openSurfaceTransaction(); 584 try { 585 applySurfaceChangesTransaction(recoveringMemory, defaultDw, defaultDh); 586 } catch (RuntimeException e) { 587 Slog.wtf(TAG, "Unhandled exception in Window Manager", e); 588 } finally { 589 mService.closeSurfaceTransaction(); 590 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, 591 "<<< CLOSE TRANSACTION performLayoutAndPlaceSurfaces"); 592 } 593 594 final WindowSurfacePlacer surfacePlacer = mService.mWindowPlacerLocked; 595 596 // If we are ready to perform an app transition, check through all of the app tokens to be 597 // shown and see if they are ready to go. 598 if (mService.mAppTransition.isReady()) { 599 defaultDisplay.pendingLayoutChanges |= 600 surfacePlacer.handleAppTransitionReadyLocked(); 601 if (DEBUG_LAYOUT_REPEATS) 602 surfacePlacer.debugLayoutRepeats("after handleAppTransitionReadyLocked", 603 defaultDisplay.pendingLayoutChanges); 604 } 605 606 if (!mService.mAnimator.mAppWindowAnimating && mService.mAppTransition.isRunning()) { 607 // We have finished the animation of an app transition. To do this, we have delayed a 608 // lot of operations like showing and hiding apps, moving apps in Z-order, etc. The app 609 // token list reflects the correct Z-order, but the window list may now be out of sync 610 // with it. So here we will just rebuild the entire app window list. Fun! 611 defaultDisplay.pendingLayoutChanges |= 612 mService.handleAnimatingStoppedAndTransitionLocked(); 613 if (DEBUG_LAYOUT_REPEATS) 614 surfacePlacer.debugLayoutRepeats("after handleAnimStopAndXitionLock", 615 defaultDisplay.pendingLayoutChanges); 616 } 617 618 if (mWallpaperForceHidingChanged && defaultDisplay.pendingLayoutChanges == 0 619 && !mService.mAppTransition.isReady()) { 620 // At this point, there was a window with a wallpaper that was force hiding other 621 // windows behind it, but now it is going away. This may be simple -- just animate away 622 // the wallpaper and its window -- or it may be hard -- the wallpaper now needs to be 623 // shown behind something that was hidden. 624 defaultDisplay.pendingLayoutChanges |= FINISH_LAYOUT_REDO_LAYOUT; 625 if (DEBUG_LAYOUT_REPEATS) surfacePlacer.debugLayoutRepeats( 626 "after animateAwayWallpaperLocked", defaultDisplay.pendingLayoutChanges); 627 } 628 mWallpaperForceHidingChanged = false; 629 630 if (mWallpaperMayChange) { 631 if (DEBUG_WALLPAPER_LIGHT) Slog.v(TAG, "Wallpaper may change! Adjusting"); 632 defaultDisplay.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER; 633 if (DEBUG_LAYOUT_REPEATS) surfacePlacer.debugLayoutRepeats("WallpaperMayChange", 634 defaultDisplay.pendingLayoutChanges); 635 } 636 637 if (mService.mFocusMayChange) { 638 mService.mFocusMayChange = false; 639 if (mService.updateFocusedWindowLocked(UPDATE_FOCUS_PLACING_SURFACES, 640 false /*updateInputWindows*/)) { 641 updateInputWindowsNeeded = true; 642 defaultDisplay.pendingLayoutChanges |= FINISH_LAYOUT_REDO_ANIM; 643 } 644 } 645 646 if (isLayoutNeeded()) { 647 defaultDisplay.pendingLayoutChanges |= FINISH_LAYOUT_REDO_LAYOUT; 648 if (DEBUG_LAYOUT_REPEATS) surfacePlacer.debugLayoutRepeats("mLayoutNeeded", 649 defaultDisplay.pendingLayoutChanges); 650 } 651 652 for (i = mService.mResizingWindows.size() - 1; i >= 0; i--) { 653 WindowState win = mService.mResizingWindows.get(i); 654 if (win.mAppFreezing) { 655 // Don't remove this window until rotation has completed. 656 continue; 657 } 658 // Discard the saved surface if window size is changed, it can't be reused. 659 if (win.mAppToken != null) { 660 win.mAppToken.destroySavedSurfaces(); 661 } 662 win.reportResized(); 663 mService.mResizingWindows.remove(i); 664 } 665 666 if (DEBUG_ORIENTATION && mService.mDisplayFrozen) Slog.v(TAG, 667 "With display frozen, orientationChangeComplete=" + mOrientationChangeComplete); 668 if (mOrientationChangeComplete) { 669 if (mService.mWindowsFreezingScreen != WINDOWS_FREEZING_SCREENS_NONE) { 670 mService.mWindowsFreezingScreen = WINDOWS_FREEZING_SCREENS_NONE; 671 mService.mLastFinishedFreezeSource = mLastWindowFreezeSource; 672 mService.mH.removeMessages(WINDOW_FREEZE_TIMEOUT); 673 } 674 mService.stopFreezingDisplayLocked(); 675 } 676 677 // Destroy the surface of any windows that are no longer visible. 678 boolean wallpaperDestroyed = false; 679 i = mService.mDestroySurface.size(); 680 if (i > 0) { 681 do { 682 i--; 683 WindowState win = mService.mDestroySurface.get(i); 684 win.mDestroying = false; 685 if (mService.mInputMethodWindow == win) { 686 mService.setInputMethodWindowLocked(null); 687 } 688 if (win.getDisplayContent().mWallpaperController.isWallpaperTarget(win)) { 689 wallpaperDestroyed = true; 690 } 691 win.destroyOrSaveSurfaceUnchecked(); 692 } while (i > 0); 693 mService.mDestroySurface.clear(); 694 } 695 696 // Time to remove any exiting tokens? 697 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 698 final DisplayContent displayContent = mChildren.get(displayNdx); 699 displayContent.removeExistingTokensIfPossible(); 700 } 701 702 if (wallpaperDestroyed) { 703 defaultDisplay.pendingLayoutChanges |= FINISH_LAYOUT_REDO_WALLPAPER; 704 defaultDisplay.setLayoutNeeded(); 705 } 706 707 for (int displayNdx = 0; displayNdx < numDisplays; ++displayNdx) { 708 final DisplayContent displayContent = mChildren.get(displayNdx); 709 if (displayContent.pendingLayoutChanges != 0) { 710 displayContent.setLayoutNeeded(); 711 } 712 } 713 714 // Finally update all input windows now that the window changes have stabilized. 715 mService.mInputMonitor.updateInputWindowsLw(true /*force*/); 716 717 mService.setHoldScreenLocked(mHoldScreen); 718 if (!mService.mDisplayFrozen) { 719 final int brightness = mScreenBrightness < 0 || mScreenBrightness > 1.0f 720 ? -1 : toBrightnessOverride(mScreenBrightness); 721 722 // Post these on a handler such that we don't call into power manager service while 723 // holding the window manager lock to avoid lock contention with power manager lock. 724 mHandler.obtainMessage(SET_SCREEN_BRIGHTNESS_OVERRIDE, brightness, 0).sendToTarget(); 725 mHandler.obtainMessage(SET_USER_ACTIVITY_TIMEOUT, mUserActivityTimeout).sendToTarget(); 726 } 727 728 if (mSustainedPerformanceModeCurrent != mSustainedPerformanceModeEnabled) { 729 mSustainedPerformanceModeEnabled = mSustainedPerformanceModeCurrent; 730 mService.mPowerManagerInternal.powerHint( 731 PowerHint.SUSTAINED_PERFORMANCE, 732 (mSustainedPerformanceModeEnabled ? 1 : 0)); 733 } 734 735 if (mService.mTurnOnScreen) { 736 if (mService.mAllowTheaterModeWakeFromLayout 737 || Settings.Global.getInt(mService.mContext.getContentResolver(), 738 Settings.Global.THEATER_MODE_ON, 0) == 0) { 739 if (DEBUG_VISIBILITY || DEBUG_POWER) { 740 Slog.v(TAG, "Turning screen on after layout!"); 741 } 742 mService.mPowerManager.wakeUp(SystemClock.uptimeMillis(), 743 "android.server.wm:TURN_ON"); 744 } 745 mService.mTurnOnScreen = false; 746 } 747 748 if (mUpdateRotation) { 749 if (DEBUG_ORIENTATION) Slog.d(TAG, "Performing post-rotate rotation"); 750 // TODO(multi-display): Update rotation for different displays separately. 751 final int displayId = defaultDisplay.getDisplayId(); 752 if (defaultDisplay.updateRotationUnchecked(false /* inTransaction */)) { 753 mService.mH.obtainMessage(SEND_NEW_CONFIGURATION, displayId).sendToTarget(); 754 } else { 755 mUpdateRotation = false; 756 } 757 } 758 759 if (mService.mWaitingForDrawnCallback != null || 760 (mOrientationChangeComplete && !defaultDisplay.isLayoutNeeded() 761 && !mUpdateRotation)) { 762 mService.checkDrawnWindowsLocked(); 763 } 764 765 final int N = mService.mPendingRemove.size(); 766 if (N > 0) { 767 if (mService.mPendingRemoveTmp.length < N) { 768 mService.mPendingRemoveTmp = new WindowState[N+10]; 769 } 770 mService.mPendingRemove.toArray(mService.mPendingRemoveTmp); 771 mService.mPendingRemove.clear(); 772 ArrayList<DisplayContent> displayList = new ArrayList(); 773 for (i = 0; i < N; i++) { 774 final WindowState w = mService.mPendingRemoveTmp[i]; 775 w.removeImmediately(); 776 final DisplayContent displayContent = w.getDisplayContent(); 777 if (displayContent != null && !displayList.contains(displayContent)) { 778 displayList.add(displayContent); 779 } 780 } 781 782 for (int j = displayList.size() - 1; j >= 0; --j) { 783 final DisplayContent dc = displayList.get(j); 784 dc.assignWindowLayers(true /*setLayoutNeeded*/); 785 } 786 } 787 788 // Remove all deferred displays stacks, tasks, and activities. 789 for (int displayNdx = mChildren.size() - 1; displayNdx >= 0; --displayNdx) { 790 mChildren.get(displayNdx).checkCompleteDeferredRemoval(); 791 } 792 793 if (updateInputWindowsNeeded) { 794 mService.mInputMonitor.updateInputWindowsLw(false /*force*/); 795 } 796 mService.setFocusTaskRegionLocked(null); 797 798 // Check to see if we are now in a state where the screen should 799 // be enabled, because the window obscured flags have changed. 800 mService.enableScreenIfNeededLocked(); 801 802 mService.scheduleAnimationLocked(); 803 mService.mWindowPlacerLocked.destroyPendingSurfaces(); 804 805 if (DEBUG_WINDOW_TRACE) Slog.e(TAG, 806 "performSurfacePlacementInner exit: animating=" + mService.mAnimator.isAnimating()); 807 } 808 809 private void applySurfaceChangesTransaction(boolean recoveringMemory, int defaultDw, 810 int defaultDh) { 811 mHoldScreenWindow = null; 812 mObscuringWindow = null; 813 814 // TODO(multi-display): Support these features on secondary screens. 815 if (mService.mWatermark != null) { 816 mService.mWatermark.positionSurface(defaultDw, defaultDh); 817 } 818 if (mService.mStrictModeFlash != null) { 819 mService.mStrictModeFlash.positionSurface(defaultDw, defaultDh); 820 } 821 if (mService.mCircularDisplayMask != null) { 822 mService.mCircularDisplayMask.positionSurface(defaultDw, defaultDh, 823 mService.getDefaultDisplayRotation()); 824 } 825 if (mService.mEmulatorDisplayOverlay != null) { 826 mService.mEmulatorDisplayOverlay.positionSurface(defaultDw, defaultDh, 827 mService.getDefaultDisplayRotation()); 828 } 829 830 boolean focusDisplayed = false; 831 832 final int count = mChildren.size(); 833 for (int j = 0; j < count; ++j) { 834 final DisplayContent dc = mChildren.get(j); 835 focusDisplayed |= dc.applySurfaceChangesTransaction(recoveringMemory); 836 } 837 838 if (focusDisplayed) { 839 mService.mH.sendEmptyMessage(REPORT_LOSING_FOCUS); 840 } 841 842 // Give the display manager a chance to adjust properties like display rotation if it needs 843 // to. 844 mService.mDisplayManagerInternal.performTraversalInTransactionFromWindowManager(); 845 } 846 847 /** 848 * @param w WindowState this method is applied to. 849 * @param obscured True if there is a window on top of this obscuring the display. 850 * @param syswin System window? 851 * @return True when the display contains content to show the user. When false, the display 852 * manager may choose to mirror or blank the display. 853 */ 854 boolean handleNotObscuredLocked(WindowState w, boolean obscured, boolean syswin) { 855 final WindowManager.LayoutParams attrs = w.mAttrs; 856 final int attrFlags = attrs.flags; 857 final boolean canBeSeen = w.isDisplayedLw(); 858 final int privateflags = attrs.privateFlags; 859 boolean displayHasContent = false; 860 861 if (w.mHasSurface && canBeSeen) { 862 if ((attrFlags & FLAG_KEEP_SCREEN_ON) != 0) { 863 mHoldScreen = w.mSession; 864 mHoldScreenWindow = w; 865 } else if (DEBUG_KEEP_SCREEN_ON && w == mService.mLastWakeLockHoldingWindow) { 866 Slog.d(TAG_KEEP_SCREEN_ON, "handleNotObscuredLocked: " + w + " was holding " 867 + "screen wakelock but no longer has FLAG_KEEP_SCREEN_ON!!! called by" 868 + Debug.getCallers(10)); 869 } 870 if (!syswin && w.mAttrs.screenBrightness >= 0 && mScreenBrightness < 0) { 871 mScreenBrightness = w.mAttrs.screenBrightness; 872 } 873 if (!syswin && w.mAttrs.userActivityTimeout >= 0 && mUserActivityTimeout < 0) { 874 mUserActivityTimeout = w.mAttrs.userActivityTimeout; 875 } 876 877 final int type = attrs.type; 878 // This function assumes that the contents of the default display are processed first 879 // before secondary displays. 880 final DisplayContent displayContent = w.getDisplayContent(); 881 if (displayContent != null && displayContent.isDefaultDisplay) { 882 // While a dream or keyguard is showing, obscure ordinary application content on 883 // secondary displays (by forcibly enabling mirroring unless there is other content 884 // we want to show) but still allow opaque keyguard dialogs to be shown. 885 if (type == TYPE_DREAM || (attrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) { 886 mObscureApplicationContentOnSecondaryDisplays = true; 887 } 888 displayHasContent = true; 889 } else if (displayContent != null && 890 (!mObscureApplicationContentOnSecondaryDisplays 891 || (obscured && type == TYPE_KEYGUARD_DIALOG))) { 892 // Allow full screen keyguard presentation dialogs to be seen. 893 displayHasContent = true; 894 } 895 if ((privateflags & PRIVATE_FLAG_SUSTAINED_PERFORMANCE_MODE) != 0) { 896 mSustainedPerformanceModeCurrent = true; 897 } 898 } 899 900 return displayHasContent; 901 } 902 903 boolean copyAnimToLayoutParams() { 904 boolean doRequest = false; 905 906 final int bulkUpdateParams = mService.mAnimator.mBulkUpdateParams; 907 if ((bulkUpdateParams & SET_UPDATE_ROTATION) != 0) { 908 mUpdateRotation = true; 909 doRequest = true; 910 } 911 if ((bulkUpdateParams & SET_WALLPAPER_MAY_CHANGE) != 0) { 912 mWallpaperMayChange = true; 913 doRequest = true; 914 } 915 if ((bulkUpdateParams & SET_FORCE_HIDING_CHANGED) != 0) { 916 mWallpaperForceHidingChanged = true; 917 doRequest = true; 918 } 919 if ((bulkUpdateParams & SET_ORIENTATION_CHANGE_COMPLETE) == 0) { 920 mOrientationChangeComplete = false; 921 } else { 922 mOrientationChangeComplete = true; 923 mLastWindowFreezeSource = mService.mAnimator.mLastWindowFreezeSource; 924 if (mService.mWindowsFreezingScreen != WINDOWS_FREEZING_SCREENS_NONE) { 925 doRequest = true; 926 } 927 } 928 if ((bulkUpdateParams & SET_TURN_ON_SCREEN) != 0) { 929 mService.mTurnOnScreen = true; 930 } 931 if ((bulkUpdateParams & SET_WALLPAPER_ACTION_PENDING) != 0) { 932 mWallpaperActionPending = true; 933 } 934 935 return doRequest; 936 } 937 938 private static int toBrightnessOverride(float value) { 939 return (int)(value * PowerManager.BRIGHTNESS_ON); 940 } 941 942 private final class MyHandler extends Handler { 943 944 public MyHandler(Looper looper) { 945 super(looper); 946 } 947 948 @Override 949 public void handleMessage(Message msg) { 950 switch (msg.what) { 951 case SET_SCREEN_BRIGHTNESS_OVERRIDE: 952 mService.mPowerManagerInternal.setScreenBrightnessOverrideFromWindowManager( 953 msg.arg1); 954 break; 955 case SET_USER_ACTIVITY_TIMEOUT: 956 mService.mPowerManagerInternal.setUserActivityTimeoutOverrideFromWindowManager( 957 (Long) msg.obj); 958 break; 959 default: 960 break; 961 } 962 } 963 } 964 965 void enableSurfaceTrace(ParcelFileDescriptor pfd) { 966 final FileDescriptor fd = pfd.getFileDescriptor(); 967 if (mSurfaceTraceEnabled) { 968 disableSurfaceTrace(); 969 } 970 mSurfaceTraceEnabled = true; 971 mRemoteEventTrace = new RemoteEventTrace(mService, fd); 972 mSurfaceTraceFd = pfd; 973 for (int displayNdx = mChildren.size() - 1; displayNdx >= 0; --displayNdx) { 974 final DisplayContent dc = mChildren.get(displayNdx); 975 dc.enableSurfaceTrace(fd); 976 } 977 } 978 979 void disableSurfaceTrace() { 980 mSurfaceTraceEnabled = false; 981 mRemoteEventTrace = null; 982 mSurfaceTraceFd = null; 983 for (int displayNdx = mChildren.size() - 1; displayNdx >= 0; --displayNdx) { 984 final DisplayContent dc = mChildren.get(displayNdx); 985 dc.disableSurfaceTrace(); 986 } 987 } 988 989 void dumpDisplayContents(PrintWriter pw) { 990 pw.println("WINDOW MANAGER DISPLAY CONTENTS (dumpsys window displays)"); 991 if (mService.mDisplayReady) { 992 final int count = mChildren.size(); 993 for (int i = 0; i < count; ++i) { 994 final DisplayContent displayContent = mChildren.get(i); 995 displayContent.dump(" ", pw); 996 } 997 } else { 998 pw.println(" NO DISPLAY"); 999 } 1000 } 1001 1002 void dumpLayoutNeededDisplayIds(PrintWriter pw) { 1003 if (!isLayoutNeeded()) { 1004 return; 1005 } 1006 pw.print(" mLayoutNeeded on displays="); 1007 final int count = mChildren.size(); 1008 for (int displayNdx = 0; displayNdx < count; ++displayNdx) { 1009 final DisplayContent displayContent = mChildren.get(displayNdx); 1010 if (displayContent.isLayoutNeeded()) { 1011 pw.print(displayContent.getDisplayId()); 1012 } 1013 } 1014 pw.println(); 1015 } 1016 1017 void dumpWindowsNoHeader(PrintWriter pw, boolean dumpAll, ArrayList<WindowState> windows) { 1018 final int[] index = new int[1]; 1019 forAllWindows((w) -> { 1020 if (windows == null || windows.contains(w)) { 1021 pw.println(" Window #" + index[0] + " " + w + ":"); 1022 w.dump(pw, " ", dumpAll || windows != null); 1023 index[0] = index[0] + 1; 1024 } 1025 }, true /* traverseTopToBottom */); 1026 } 1027 1028 void dumpTokens(PrintWriter pw, boolean dumpAll) { 1029 pw.println(" All tokens:"); 1030 for (int i = mChildren.size() - 1; i >= 0; --i) { 1031 mChildren.get(i).dumpTokens(pw, dumpAll); 1032 } 1033 } 1034 1035 @Override 1036 String getName() { 1037 return "ROOT"; 1038 } 1039 } 1040