1 /* 2 * Copyright (C) 2011 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 static com.android.server.wm.WindowManagerService.DEBUG_CONFIGURATION; 20 import static com.android.server.wm.WindowManagerService.DEBUG_LAYOUT; 21 import static com.android.server.wm.WindowManagerService.DEBUG_ORIENTATION; 22 import static com.android.server.wm.WindowManagerService.DEBUG_RESIZE; 23 import static com.android.server.wm.WindowManagerService.DEBUG_VISIBILITY; 24 25 import static android.view.WindowManager.LayoutParams.FIRST_SUB_WINDOW; 26 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_KEYGUARD; 27 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW; 28 import static android.view.WindowManager.LayoutParams.LAST_SUB_WINDOW; 29 import static android.view.WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION; 30 import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD; 31 import static android.view.WindowManager.LayoutParams.TYPE_INPUT_METHOD_DIALOG; 32 import static android.view.WindowManager.LayoutParams.TYPE_APPLICATION_STARTING; 33 import static android.view.WindowManager.LayoutParams.TYPE_WALLPAPER; 34 35 import android.app.AppOpsManager; 36 import android.os.Debug; 37 import android.os.RemoteCallbackList; 38 import android.os.SystemClock; 39 import android.util.TimeUtils; 40 import android.view.Display; 41 import android.view.IWindowFocusObserver; 42 import android.view.IWindowId; 43 import com.android.server.input.InputWindowHandle; 44 45 import android.content.Context; 46 import android.content.res.Configuration; 47 import android.graphics.Matrix; 48 import android.graphics.PixelFormat; 49 import android.graphics.Rect; 50 import android.graphics.RectF; 51 import android.graphics.Region; 52 import android.os.IBinder; 53 import android.os.RemoteException; 54 import android.os.UserHandle; 55 import android.util.Slog; 56 import android.view.DisplayInfo; 57 import android.view.Gravity; 58 import android.view.IApplicationToken; 59 import android.view.IWindow; 60 import android.view.InputChannel; 61 import android.view.View; 62 import android.view.ViewTreeObserver; 63 import android.view.WindowManager; 64 import android.view.WindowManagerPolicy; 65 66 import java.io.PrintWriter; 67 import java.util.ArrayList; 68 69 class WindowList extends ArrayList<WindowState> { 70 } 71 72 /** 73 * A window in the window manager. 74 */ 75 final class WindowState implements WindowManagerPolicy.WindowState { 76 static final String TAG = "WindowState"; 77 78 final WindowManagerService mService; 79 final WindowManagerPolicy mPolicy; 80 final Context mContext; 81 final Session mSession; 82 final IWindow mClient; 83 final int mAppOp; 84 // UserId and appId of the owner. Don't display windows of non-current user. 85 final int mOwnerUid; 86 final IWindowId mWindowId; 87 WindowToken mToken; 88 WindowToken mRootToken; 89 AppWindowToken mAppToken; 90 AppWindowToken mTargetAppToken; 91 92 // mAttrs.flags is tested in animation without being locked. If the bits tested are ever 93 // modified they will need to be locked. 94 final WindowManager.LayoutParams mAttrs = new WindowManager.LayoutParams(); 95 final DeathRecipient mDeathRecipient; 96 final WindowState mAttachedWindow; 97 final WindowList mChildWindows = new WindowList(); 98 final int mBaseLayer; 99 final int mSubLayer; 100 final boolean mLayoutAttached; 101 final boolean mIsImWindow; 102 final boolean mIsWallpaper; 103 final boolean mIsFloatingLayer; 104 int mSeq; 105 boolean mEnforceSizeCompat; 106 int mViewVisibility; 107 int mSystemUiVisibility; 108 boolean mPolicyVisibility = true; 109 boolean mPolicyVisibilityAfterAnim = true; 110 boolean mAppOpVisibility = true; 111 boolean mAppFreezing; 112 boolean mAttachedHidden; // is our parent window hidden? 113 boolean mWallpaperVisible; // for wallpaper, what was last vis report? 114 115 RemoteCallbackList<IWindowFocusObserver> mFocusCallbacks; 116 117 /** 118 * The window size that was requested by the application. These are in 119 * the application's coordinate space (without compatibility scale applied). 120 */ 121 int mRequestedWidth; 122 int mRequestedHeight; 123 int mLastRequestedWidth; 124 int mLastRequestedHeight; 125 126 int mLayer; 127 boolean mHaveFrame; 128 boolean mObscured; 129 boolean mTurnOnScreen; 130 131 int mLayoutSeq = -1; 132 133 Configuration mConfiguration = null; 134 // Sticky answer to isConfigChanged(), remains true until new Configuration is assigned. 135 // Used only on {@link #TYPE_KEYGUARD}. 136 private boolean mConfigHasChanged; 137 138 /** 139 * Actual frame shown on-screen (may be modified by animation). These 140 * are in the screen's coordinate space (WITH the compatibility scale 141 * applied). 142 */ 143 final RectF mShownFrame = new RectF(); 144 145 /** 146 * Insets that determine the actually visible area. These are in the application's 147 * coordinate space (without compatibility scale applied). 148 */ 149 final Rect mVisibleInsets = new Rect(); 150 final Rect mLastVisibleInsets = new Rect(); 151 boolean mVisibleInsetsChanged; 152 153 /** 154 * Insets that are covered by system windows (such as the status bar) and 155 * transient docking windows (such as the IME). These are in the application's 156 * coordinate space (without compatibility scale applied). 157 */ 158 final Rect mContentInsets = new Rect(); 159 final Rect mLastContentInsets = new Rect(); 160 boolean mContentInsetsChanged; 161 162 /** 163 * Insets that determine the area covered by the display overscan region. These are in the 164 * application's coordinate space (without compatibility scale applied). 165 */ 166 final Rect mOverscanInsets = new Rect(); 167 final Rect mLastOverscanInsets = new Rect(); 168 boolean mOverscanInsetsChanged; 169 170 /** 171 * Insets that determine the area covered by the stable system windows. These are in the 172 * application's coordinate space (without compatibility scale applied). 173 */ 174 final Rect mStableInsets = new Rect(); 175 final Rect mLastStableInsets = new Rect(); 176 boolean mStableInsetsChanged; 177 178 /** 179 * Set to true if we are waiting for this window to receive its 180 * given internal insets before laying out other windows based on it. 181 */ 182 boolean mGivenInsetsPending; 183 184 /** 185 * These are the content insets that were given during layout for 186 * this window, to be applied to windows behind it. 187 */ 188 final Rect mGivenContentInsets = new Rect(); 189 190 /** 191 * These are the visible insets that were given during layout for 192 * this window, to be applied to windows behind it. 193 */ 194 final Rect mGivenVisibleInsets = new Rect(); 195 196 /** 197 * This is the given touchable area relative to the window frame, or null if none. 198 */ 199 final Region mGivenTouchableRegion = new Region(); 200 201 /** 202 * Flag indicating whether the touchable region should be adjusted by 203 * the visible insets; if false the area outside the visible insets is 204 * NOT touchable, so we must use those to adjust the frame during hit 205 * tests. 206 */ 207 int mTouchableInsets = ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME; 208 209 /** 210 * This is rectangle of the window's surface that is not covered by 211 * system decorations. 212 */ 213 final Rect mSystemDecorRect = new Rect(); 214 final Rect mLastSystemDecorRect = new Rect(); 215 216 // Current transformation being applied. 217 float mGlobalScale=1; 218 float mInvGlobalScale=1; 219 float mHScale=1, mVScale=1; 220 float mLastHScale=1, mLastVScale=1; 221 final Matrix mTmpMatrix = new Matrix(); 222 223 // "Real" frame that the application sees, in display coordinate space. 224 final Rect mFrame = new Rect(); 225 final Rect mLastFrame = new Rect(); 226 // Frame that is scaled to the application's coordinate space when in 227 // screen size compatibility mode. 228 final Rect mCompatFrame = new Rect(); 229 230 final Rect mContainingFrame = new Rect(); 231 232 final Rect mParentFrame = new Rect(); 233 234 // The entire screen area of the device. 235 final Rect mDisplayFrame = new Rect(); 236 237 // The region of the display frame that the display type supports displaying content on. This 238 // is mostly a special case for TV where some displays don’t have the entire display usable. 239 // {@link WindowManager.LayoutParams#FLAG_LAYOUT_IN_OVERSCAN} flag can be used to allow 240 // window display contents to extend into the overscan region. 241 final Rect mOverscanFrame = new Rect(); 242 243 // The display frame minus the stable insets. This value is always constant regardless of if 244 // the status bar or navigation bar is visible. 245 final Rect mStableFrame = new Rect(); 246 247 // The area not occupied by the status and navigation bars. So, if both status and navigation 248 // bars are visible, the decor frame is equal to the stable frame. 249 final Rect mDecorFrame = new Rect(); 250 251 // Equal to the decor frame if the IME (e.g. keyboard) is not present. Equal to the decor frame 252 // minus the area occupied by the IME if the IME is present. 253 final Rect mContentFrame = new Rect(); 254 255 // Legacy stuff. Generally equal to the content frame expect when the IME for older apps 256 // displays hint text. 257 final Rect mVisibleFrame = new Rect(); 258 259 boolean mContentChanged; 260 261 // If a window showing a wallpaper: the requested offset for the 262 // wallpaper; if a wallpaper window: the currently applied offset. 263 float mWallpaperX = -1; 264 float mWallpaperY = -1; 265 266 // If a window showing a wallpaper: what fraction of the offset 267 // range corresponds to a full virtual screen. 268 float mWallpaperXStep = -1; 269 float mWallpaperYStep = -1; 270 271 // If a window showing a wallpaper: a raw pixel offset to forcibly apply 272 // to its window; if a wallpaper window: not used. 273 int mWallpaperDisplayOffsetX = Integer.MIN_VALUE; 274 int mWallpaperDisplayOffsetY = Integer.MIN_VALUE; 275 276 // Wallpaper windows: pixels offset based on above variables. 277 int mXOffset; 278 int mYOffset; 279 280 /** 281 * This is set after IWindowSession.relayout() has been called at 282 * least once for the window. It allows us to detect the situation 283 * where we don't yet have a surface, but should have one soon, so 284 * we can give the window focus before waiting for the relayout. 285 */ 286 boolean mRelayoutCalled; 287 288 /** 289 * If the application has called relayout() with changes that can 290 * impact its window's size, we need to perform a layout pass on it 291 * even if it is not currently visible for layout. This is set 292 * when in that case until the layout is done. 293 */ 294 boolean mLayoutNeeded; 295 296 /** Currently running an exit animation? */ 297 boolean mExiting; 298 299 /** Currently on the mDestroySurface list? */ 300 boolean mDestroying; 301 302 /** Completely remove from window manager after exit animation? */ 303 boolean mRemoveOnExit; 304 305 /** 306 * Set when the orientation is changing and this window has not yet 307 * been updated for the new orientation. 308 */ 309 boolean mOrientationChanging; 310 311 /** 312 * How long we last kept the screen frozen. 313 */ 314 int mLastFreezeDuration; 315 316 /** Is this window now (or just being) removed? */ 317 boolean mRemoved; 318 319 /** 320 * Temp for keeping track of windows that have been removed when 321 * rebuilding window list. 322 */ 323 boolean mRebuilding; 324 325 // Input channel and input window handle used by the input dispatcher. 326 final InputWindowHandle mInputWindowHandle; 327 InputChannel mInputChannel; 328 329 // Used to improve performance of toString() 330 String mStringNameCache; 331 CharSequence mLastTitle; 332 boolean mWasExiting; 333 334 final WindowStateAnimator mWinAnimator; 335 336 boolean mHasSurface = false; 337 338 boolean mNotOnAppsDisplay = false; 339 DisplayContent mDisplayContent; 340 341 /** When true this window can be displayed on screens owther than mOwnerUid's */ 342 private boolean mShowToOwnerOnly; 343 344 /** When true this window is at the top of the screen and should be layed out to extend under 345 * the status bar */ 346 boolean mUnderStatusBar = true; 347 WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token, WindowState attachedWindow, int appOp, int seq, WindowManager.LayoutParams a, int viewVisibility, final DisplayContent displayContent)348 WindowState(WindowManagerService service, Session s, IWindow c, WindowToken token, 349 WindowState attachedWindow, int appOp, int seq, WindowManager.LayoutParams a, 350 int viewVisibility, final DisplayContent displayContent) { 351 mService = service; 352 mSession = s; 353 mClient = c; 354 mAppOp = appOp; 355 mToken = token; 356 mOwnerUid = s.mUid; 357 mWindowId = new IWindowId.Stub() { 358 @Override 359 public void registerFocusObserver(IWindowFocusObserver observer) { 360 WindowState.this.registerFocusObserver(observer); 361 } 362 @Override 363 public void unregisterFocusObserver(IWindowFocusObserver observer) { 364 WindowState.this.unregisterFocusObserver(observer); 365 } 366 @Override 367 public boolean isFocused() { 368 return WindowState.this.isFocused(); 369 } 370 }; 371 mAttrs.copyFrom(a); 372 mViewVisibility = viewVisibility; 373 mDisplayContent = displayContent; 374 mPolicy = mService.mPolicy; 375 mContext = mService.mContext; 376 DeathRecipient deathRecipient = new DeathRecipient(); 377 mSeq = seq; 378 mEnforceSizeCompat = (mAttrs.privateFlags & PRIVATE_FLAG_COMPATIBLE_WINDOW) != 0; 379 if (WindowManagerService.localLOGV) Slog.v( 380 TAG, "Window " + this + " client=" + c.asBinder() 381 + " token=" + token + " (" + mAttrs.token + ")" + " params=" + a); 382 try { 383 c.asBinder().linkToDeath(deathRecipient, 0); 384 } catch (RemoteException e) { 385 mDeathRecipient = null; 386 mAttachedWindow = null; 387 mLayoutAttached = false; 388 mIsImWindow = false; 389 mIsWallpaper = false; 390 mIsFloatingLayer = false; 391 mBaseLayer = 0; 392 mSubLayer = 0; 393 mInputWindowHandle = null; 394 mWinAnimator = null; 395 return; 396 } 397 mDeathRecipient = deathRecipient; 398 399 if ((mAttrs.type >= FIRST_SUB_WINDOW && 400 mAttrs.type <= LAST_SUB_WINDOW)) { 401 // The multiplier here is to reserve space for multiple 402 // windows in the same type layer. 403 mBaseLayer = mPolicy.windowTypeToLayerLw( 404 attachedWindow.mAttrs.type) * WindowManagerService.TYPE_LAYER_MULTIPLIER 405 + WindowManagerService.TYPE_LAYER_OFFSET; 406 mSubLayer = mPolicy.subWindowTypeToLayerLw(a.type); 407 mAttachedWindow = attachedWindow; 408 if (WindowManagerService.DEBUG_ADD_REMOVE) Slog.v(TAG, "Adding " + this + " to " + mAttachedWindow); 409 410 int children_size = mAttachedWindow.mChildWindows.size(); 411 if (children_size == 0) { 412 mAttachedWindow.mChildWindows.add(this); 413 } else { 414 for (int i = 0; i < children_size; i++) { 415 WindowState child = (WindowState)mAttachedWindow.mChildWindows.get(i); 416 if (this.mSubLayer < child.mSubLayer) { 417 mAttachedWindow.mChildWindows.add(i, this); 418 break; 419 } else if (this.mSubLayer > child.mSubLayer) { 420 continue; 421 } 422 423 if (this.mBaseLayer <= child.mBaseLayer) { 424 mAttachedWindow.mChildWindows.add(i, this); 425 break; 426 } else { 427 continue; 428 } 429 } 430 if (children_size == mAttachedWindow.mChildWindows.size()) { 431 mAttachedWindow.mChildWindows.add(this); 432 } 433 } 434 435 mLayoutAttached = mAttrs.type != 436 WindowManager.LayoutParams.TYPE_APPLICATION_ATTACHED_DIALOG; 437 mIsImWindow = attachedWindow.mAttrs.type == TYPE_INPUT_METHOD 438 || attachedWindow.mAttrs.type == TYPE_INPUT_METHOD_DIALOG; 439 mIsWallpaper = attachedWindow.mAttrs.type == TYPE_WALLPAPER; 440 mIsFloatingLayer = mIsImWindow || mIsWallpaper; 441 } else { 442 // The multiplier here is to reserve space for multiple 443 // windows in the same type layer. 444 mBaseLayer = mPolicy.windowTypeToLayerLw(a.type) 445 * WindowManagerService.TYPE_LAYER_MULTIPLIER 446 + WindowManagerService.TYPE_LAYER_OFFSET; 447 mSubLayer = 0; 448 mAttachedWindow = null; 449 mLayoutAttached = false; 450 mIsImWindow = mAttrs.type == TYPE_INPUT_METHOD 451 || mAttrs.type == TYPE_INPUT_METHOD_DIALOG; 452 mIsWallpaper = mAttrs.type == TYPE_WALLPAPER; 453 mIsFloatingLayer = mIsImWindow || mIsWallpaper; 454 } 455 456 WindowState appWin = this; 457 while (appWin.mAttachedWindow != null) { 458 appWin = appWin.mAttachedWindow; 459 } 460 WindowToken appToken = appWin.mToken; 461 while (appToken.appWindowToken == null) { 462 WindowToken parent = mService.mTokenMap.get(appToken.token); 463 if (parent == null || appToken == parent) { 464 break; 465 } 466 appToken = parent; 467 } 468 mRootToken = appToken; 469 mAppToken = appToken.appWindowToken; 470 if (mAppToken != null) { 471 final DisplayContent appDisplay = getDisplayContent(); 472 mNotOnAppsDisplay = displayContent != appDisplay; 473 } 474 475 mWinAnimator = new WindowStateAnimator(this); 476 mWinAnimator.mAlpha = a.alpha; 477 478 mRequestedWidth = 0; 479 mRequestedHeight = 0; 480 mLastRequestedWidth = 0; 481 mLastRequestedHeight = 0; 482 mXOffset = 0; 483 mYOffset = 0; 484 mLayer = 0; 485 mInputWindowHandle = new InputWindowHandle( 486 mAppToken != null ? mAppToken.mInputApplicationHandle : null, this, 487 displayContent.getDisplayId()); 488 } 489 attach()490 void attach() { 491 if (WindowManagerService.localLOGV) Slog.v( 492 TAG, "Attaching " + this + " token=" + mToken 493 + ", list=" + mToken.windows); 494 mSession.windowAddedLocked(); 495 } 496 497 @Override getOwningUid()498 public int getOwningUid() { 499 return mOwnerUid; 500 } 501 502 @Override getOwningPackage()503 public String getOwningPackage() { 504 return mAttrs.packageName; 505 } 506 507 @Override computeFrameLw(Rect pf, Rect df, Rect of, Rect cf, Rect vf, Rect dcf, Rect sf)508 public void computeFrameLw(Rect pf, Rect df, Rect of, Rect cf, Rect vf, Rect dcf, Rect sf) { 509 mHaveFrame = true; 510 511 TaskStack stack = mAppToken != null ? getStack() : null; 512 if (stack != null && !stack.isFullscreen()) { 513 getStackBounds(stack, mContainingFrame); 514 if (mUnderStatusBar) { 515 mContainingFrame.top = pf.top; 516 } 517 } else { 518 mContainingFrame.set(pf); 519 } 520 521 mDisplayFrame.set(df); 522 523 final int pw = mContainingFrame.width(); 524 final int ph = mContainingFrame.height(); 525 526 int w,h; 527 if ((mAttrs.flags & WindowManager.LayoutParams.FLAG_SCALED) != 0) { 528 if (mAttrs.width < 0) { 529 w = pw; 530 } else if (mEnforceSizeCompat) { 531 w = (int)(mAttrs.width * mGlobalScale + .5f); 532 } else { 533 w = mAttrs.width; 534 } 535 if (mAttrs.height < 0) { 536 h = ph; 537 } else if (mEnforceSizeCompat) { 538 h = (int)(mAttrs.height * mGlobalScale + .5f); 539 } else { 540 h = mAttrs.height; 541 } 542 } else { 543 if (mAttrs.width == WindowManager.LayoutParams.MATCH_PARENT) { 544 w = pw; 545 } else if (mEnforceSizeCompat) { 546 w = (int)(mRequestedWidth * mGlobalScale + .5f); 547 } else { 548 w = mRequestedWidth; 549 } 550 if (mAttrs.height == WindowManager.LayoutParams.MATCH_PARENT) { 551 h = ph; 552 } else if (mEnforceSizeCompat) { 553 h = (int)(mRequestedHeight * mGlobalScale + .5f); 554 } else { 555 h = mRequestedHeight; 556 } 557 } 558 559 if (!mParentFrame.equals(pf)) { 560 //Slog.i(TAG, "Window " + this + " content frame from " + mParentFrame 561 // + " to " + pf); 562 mParentFrame.set(pf); 563 mContentChanged = true; 564 } 565 if (mRequestedWidth != mLastRequestedWidth || mRequestedHeight != mLastRequestedHeight) { 566 mLastRequestedWidth = mRequestedWidth; 567 mLastRequestedHeight = mRequestedHeight; 568 mContentChanged = true; 569 } 570 571 mOverscanFrame.set(of); 572 mContentFrame.set(cf); 573 mVisibleFrame.set(vf); 574 mDecorFrame.set(dcf); 575 mStableFrame.set(sf); 576 577 final int fw = mFrame.width(); 578 final int fh = mFrame.height(); 579 580 //System.out.println("In: w=" + w + " h=" + h + " container=" + 581 // container + " x=" + mAttrs.x + " y=" + mAttrs.y); 582 583 float x, y; 584 if (mEnforceSizeCompat) { 585 x = mAttrs.x * mGlobalScale; 586 y = mAttrs.y * mGlobalScale; 587 } else { 588 x = mAttrs.x; 589 y = mAttrs.y; 590 } 591 592 Gravity.apply(mAttrs.gravity, w, h, mContainingFrame, 593 (int) (x + mAttrs.horizontalMargin * pw), 594 (int) (y + mAttrs.verticalMargin * ph), mFrame); 595 596 //System.out.println("Out: " + mFrame); 597 598 // Now make sure the window fits in the overall display. 599 Gravity.applyDisplay(mAttrs.gravity, df, mFrame); 600 601 // Make sure the content and visible frames are inside of the 602 // final window frame. 603 mContentFrame.set(Math.max(mContentFrame.left, mFrame.left), 604 Math.max(mContentFrame.top, mFrame.top), 605 Math.min(mContentFrame.right, mFrame.right), 606 Math.min(mContentFrame.bottom, mFrame.bottom)); 607 608 mVisibleFrame.set(Math.max(mVisibleFrame.left, mFrame.left), 609 Math.max(mVisibleFrame.top, mFrame.top), 610 Math.min(mVisibleFrame.right, mFrame.right), 611 Math.min(mVisibleFrame.bottom, mFrame.bottom)); 612 613 mStableFrame.set(Math.max(mStableFrame.left, mFrame.left), 614 Math.max(mStableFrame.top, mFrame.top), 615 Math.min(mStableFrame.right, mFrame.right), 616 Math.min(mStableFrame.bottom, mFrame.bottom)); 617 618 mOverscanInsets.set(Math.max(mOverscanFrame.left - mFrame.left, 0), 619 Math.max(mOverscanFrame.top - mFrame.top, 0), 620 Math.max(mFrame.right - mOverscanFrame.right, 0), 621 Math.max(mFrame.bottom - mOverscanFrame.bottom, 0)); 622 623 mContentInsets.set(mContentFrame.left - mFrame.left, 624 mContentFrame.top - mFrame.top, 625 mFrame.right - mContentFrame.right, 626 mFrame.bottom - mContentFrame.bottom); 627 628 mVisibleInsets.set(mVisibleFrame.left - mFrame.left, 629 mVisibleFrame.top - mFrame.top, 630 mFrame.right - mVisibleFrame.right, 631 mFrame.bottom - mVisibleFrame.bottom); 632 633 mStableInsets.set(Math.max(mStableFrame.left - mFrame.left, 0), 634 Math.max(mStableFrame.top - mFrame.top, 0), 635 Math.max(mFrame.right - mStableFrame.right, 0), 636 Math.max(mFrame.bottom - mStableFrame.bottom, 0)); 637 638 mCompatFrame.set(mFrame); 639 if (mEnforceSizeCompat) { 640 // If there is a size compatibility scale being applied to the 641 // window, we need to apply this to its insets so that they are 642 // reported to the app in its coordinate space. 643 mOverscanInsets.scale(mInvGlobalScale); 644 mContentInsets.scale(mInvGlobalScale); 645 mVisibleInsets.scale(mInvGlobalScale); 646 mStableInsets.scale(mInvGlobalScale); 647 648 // Also the scaled frame that we report to the app needs to be 649 // adjusted to be in its coordinate space. 650 mCompatFrame.scale(mInvGlobalScale); 651 } 652 653 if (mIsWallpaper && (fw != mFrame.width() || fh != mFrame.height())) { 654 final DisplayContent displayContent = getDisplayContent(); 655 if (displayContent != null) { 656 final DisplayInfo displayInfo = displayContent.getDisplayInfo(); 657 mService.updateWallpaperOffsetLocked(this, 658 displayInfo.logicalWidth, displayInfo.logicalHeight, false); 659 } 660 } 661 662 if (DEBUG_LAYOUT || WindowManagerService.localLOGV) Slog.v(TAG, 663 "Resolving (mRequestedWidth=" 664 + mRequestedWidth + ", mRequestedheight=" 665 + mRequestedHeight + ") to" + " (pw=" + pw + ", ph=" + ph 666 + "): frame=" + mFrame.toShortString() 667 + " ci=" + mContentInsets.toShortString() 668 + " vi=" + mVisibleInsets.toShortString() 669 + " vi=" + mStableInsets.toShortString()); 670 } 671 672 @Override getFrameLw()673 public Rect getFrameLw() { 674 return mFrame; 675 } 676 677 @Override getShownFrameLw()678 public RectF getShownFrameLw() { 679 return mShownFrame; 680 } 681 682 @Override getDisplayFrameLw()683 public Rect getDisplayFrameLw() { 684 return mDisplayFrame; 685 } 686 687 @Override getOverscanFrameLw()688 public Rect getOverscanFrameLw() { 689 return mOverscanFrame; 690 } 691 692 @Override getContentFrameLw()693 public Rect getContentFrameLw() { 694 return mContentFrame; 695 } 696 697 @Override getVisibleFrameLw()698 public Rect getVisibleFrameLw() { 699 return mVisibleFrame; 700 } 701 702 @Override getGivenInsetsPendingLw()703 public boolean getGivenInsetsPendingLw() { 704 return mGivenInsetsPending; 705 } 706 707 @Override getGivenContentInsetsLw()708 public Rect getGivenContentInsetsLw() { 709 return mGivenContentInsets; 710 } 711 712 @Override getGivenVisibleInsetsLw()713 public Rect getGivenVisibleInsetsLw() { 714 return mGivenVisibleInsets; 715 } 716 717 @Override getAttrs()718 public WindowManager.LayoutParams getAttrs() { 719 return mAttrs; 720 } 721 722 @Override getNeedsMenuLw(WindowManagerPolicy.WindowState bottom)723 public boolean getNeedsMenuLw(WindowManagerPolicy.WindowState bottom) { 724 int index = -1; 725 WindowState ws = this; 726 WindowList windows = getWindowList(); 727 while (true) { 728 if (ws.mAttrs.needsMenuKey != WindowManager.LayoutParams.NEEDS_MENU_UNSET) { 729 return ws.mAttrs.needsMenuKey == WindowManager.LayoutParams.NEEDS_MENU_SET_TRUE; 730 } 731 // If we reached the bottom of the range of windows we are considering, 732 // assume no menu is needed. 733 if (ws == bottom) { 734 return false; 735 } 736 // The current window hasn't specified whether menu key is needed; 737 // look behind it. 738 // First, we may need to determine the starting position. 739 if (index < 0) { 740 index = windows.indexOf(ws); 741 } 742 index--; 743 if (index < 0) { 744 return false; 745 } 746 ws = windows.get(index); 747 } 748 } 749 750 @Override getSystemUiVisibility()751 public int getSystemUiVisibility() { 752 return mSystemUiVisibility; 753 } 754 755 @Override getSurfaceLayer()756 public int getSurfaceLayer() { 757 return mLayer; 758 } 759 760 @Override getAppToken()761 public IApplicationToken getAppToken() { 762 return mAppToken != null ? mAppToken.appToken : null; 763 } 764 765 @Override isVoiceInteraction()766 public boolean isVoiceInteraction() { 767 return mAppToken != null ? mAppToken.voiceInteraction : false; 768 } 769 setInsetsChanged()770 boolean setInsetsChanged() { 771 mOverscanInsetsChanged |= !mLastOverscanInsets.equals(mOverscanInsets); 772 mContentInsetsChanged |= !mLastContentInsets.equals(mContentInsets); 773 mVisibleInsetsChanged |= !mLastVisibleInsets.equals(mVisibleInsets); 774 mStableInsetsChanged |= !mLastStableInsets.equals(mStableInsets); 775 return mOverscanInsetsChanged || mContentInsetsChanged || mVisibleInsetsChanged; 776 } 777 getDisplayContent()778 public DisplayContent getDisplayContent() { 779 if (mAppToken == null || mNotOnAppsDisplay) { 780 return mDisplayContent; 781 } 782 final TaskStack stack = getStack(); 783 return stack == null ? mDisplayContent : stack.getDisplayContent(); 784 } 785 getDisplayId()786 public int getDisplayId() { 787 final DisplayContent displayContent = getDisplayContent(); 788 if (displayContent == null) { 789 return -1; 790 } 791 return displayContent.getDisplayId(); 792 } 793 getStack()794 TaskStack getStack() { 795 AppWindowToken wtoken = mAppToken == null ? mService.mFocusedApp : mAppToken; 796 if (wtoken != null) { 797 Task task = mService.mTaskIdToTask.get(wtoken.groupId); 798 if (task != null) { 799 if (task.mStack != null) { 800 return task.mStack; 801 } 802 Slog.e(TAG, "getStack: mStack null for task=" + task); 803 } else { 804 Slog.e(TAG, "getStack: " + this + " couldn't find taskId=" + wtoken.groupId 805 + " Callers=" + Debug.getCallers(4)); 806 } 807 } 808 return mDisplayContent.getHomeStack(); 809 } 810 getStackBounds(Rect bounds)811 void getStackBounds(Rect bounds) { 812 getStackBounds(getStack(), bounds); 813 } 814 getStackBounds(TaskStack stack, Rect bounds)815 private void getStackBounds(TaskStack stack, Rect bounds) { 816 if (stack != null) { 817 stack.getBounds(bounds); 818 return; 819 } 820 bounds.set(mFrame); 821 } 822 getInputDispatchingTimeoutNanos()823 public long getInputDispatchingTimeoutNanos() { 824 return mAppToken != null 825 ? mAppToken.inputDispatchingTimeoutNanos 826 : WindowManagerService.DEFAULT_INPUT_DISPATCHING_TIMEOUT_NANOS; 827 } 828 829 @Override hasAppShownWindows()830 public boolean hasAppShownWindows() { 831 return mAppToken != null && (mAppToken.firstWindowDrawn || mAppToken.startingDisplayed); 832 } 833 isIdentityMatrix(float dsdx, float dtdx, float dsdy, float dtdy)834 boolean isIdentityMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { 835 if (dsdx < .99999f || dsdx > 1.00001f) return false; 836 if (dtdy < .99999f || dtdy > 1.00001f) return false; 837 if (dtdx < -.000001f || dtdx > .000001f) return false; 838 if (dsdy < -.000001f || dsdy > .000001f) return false; 839 return true; 840 } 841 prelayout()842 void prelayout() { 843 if (mEnforceSizeCompat) { 844 mGlobalScale = mService.mCompatibleScreenScale; 845 mInvGlobalScale = 1/mGlobalScale; 846 } else { 847 mGlobalScale = mInvGlobalScale = 1; 848 } 849 } 850 851 /** 852 * Is this window visible? It is not visible if there is no 853 * surface, or we are in the process of running an exit animation 854 * that will remove the surface, or its app token has been hidden. 855 */ 856 @Override isVisibleLw()857 public boolean isVisibleLw() { 858 final AppWindowToken atoken = mAppToken; 859 return mHasSurface && mPolicyVisibility && !mAttachedHidden 860 && (atoken == null || !atoken.hiddenRequested) 861 && !mExiting && !mDestroying; 862 } 863 864 /** 865 * Like {@link #isVisibleLw}, but also counts a window that is currently 866 * "hidden" behind the keyguard as visible. This allows us to apply 867 * things like window flags that impact the keyguard. 868 * XXX I am starting to think we need to have ANOTHER visibility flag 869 * for this "hidden behind keyguard" state rather than overloading 870 * mPolicyVisibility. Ungh. 871 */ 872 @Override isVisibleOrBehindKeyguardLw()873 public boolean isVisibleOrBehindKeyguardLw() { 874 if (mRootToken.waitingToShow && 875 mService.mAppTransition.isTransitionSet()) { 876 return false; 877 } 878 final AppWindowToken atoken = mAppToken; 879 final boolean animating = atoken != null 880 ? (atoken.mAppAnimator.animation != null) : false; 881 return mHasSurface && !mDestroying && !mExiting 882 && (atoken == null ? mPolicyVisibility : !atoken.hiddenRequested) 883 && ((!mAttachedHidden && mViewVisibility == View.VISIBLE 884 && !mRootToken.hidden) 885 || mWinAnimator.mAnimation != null || animating); 886 } 887 888 /** 889 * Is this window visible, ignoring its app token? It is not visible 890 * if there is no surface, or we are in the process of running an exit animation 891 * that will remove the surface. 892 */ isWinVisibleLw()893 public boolean isWinVisibleLw() { 894 final AppWindowToken atoken = mAppToken; 895 return mHasSurface && mPolicyVisibility && !mAttachedHidden 896 && (atoken == null || !atoken.hiddenRequested || atoken.mAppAnimator.animating) 897 && !mExiting && !mDestroying; 898 } 899 900 /** 901 * The same as isVisible(), but follows the current hidden state of 902 * the associated app token, not the pending requested hidden state. 903 */ isVisibleNow()904 boolean isVisibleNow() { 905 return mHasSurface && mPolicyVisibility && !mAttachedHidden 906 && (!mRootToken.hidden || mAttrs.type == TYPE_APPLICATION_STARTING) 907 && !mExiting && !mDestroying; 908 } 909 910 /** 911 * Can this window possibly be a drag/drop target? The test here is 912 * a combination of the above "visible now" with the check that the 913 * Input Manager uses when discarding windows from input consideration. 914 */ isPotentialDragTarget()915 boolean isPotentialDragTarget() { 916 return isVisibleNow() && !mRemoved 917 && mInputChannel != null && mInputWindowHandle != null; 918 } 919 920 /** 921 * Same as isVisible(), but we also count it as visible between the 922 * call to IWindowSession.add() and the first relayout(). 923 */ isVisibleOrAdding()924 boolean isVisibleOrAdding() { 925 final AppWindowToken atoken = mAppToken; 926 return (mHasSurface || (!mRelayoutCalled && mViewVisibility == View.VISIBLE)) 927 && mPolicyVisibility && !mAttachedHidden 928 && (atoken == null || !atoken.hiddenRequested) 929 && !mExiting && !mDestroying; 930 } 931 932 /** 933 * Is this window currently on-screen? It is on-screen either if it 934 * is visible or it is currently running an animation before no longer 935 * being visible. 936 */ isOnScreen()937 boolean isOnScreen() { 938 return mPolicyVisibility && isOnScreenIgnoringKeyguard(); 939 } 940 941 /** 942 * Like isOnScreen(), but ignores any force hiding of the window due 943 * to the keyguard. 944 */ isOnScreenIgnoringKeyguard()945 boolean isOnScreenIgnoringKeyguard() { 946 if (!mHasSurface || mDestroying) { 947 return false; 948 } 949 final AppWindowToken atoken = mAppToken; 950 if (atoken != null) { 951 return ((!mAttachedHidden && !atoken.hiddenRequested) 952 || mWinAnimator.mAnimation != null || atoken.mAppAnimator.animation != null); 953 } 954 return !mAttachedHidden || mWinAnimator.mAnimation != null; 955 } 956 957 /** 958 * Like isOnScreen(), but we don't return true if the window is part 959 * of a transition that has not yet been started. 960 */ isReadyForDisplay()961 boolean isReadyForDisplay() { 962 if (mRootToken.waitingToShow && 963 mService.mAppTransition.isTransitionSet()) { 964 return false; 965 } 966 return mHasSurface && mPolicyVisibility && !mDestroying 967 && ((!mAttachedHidden && mViewVisibility == View.VISIBLE 968 && !mRootToken.hidden) 969 || mWinAnimator.mAnimation != null 970 || ((mAppToken != null) && (mAppToken.mAppAnimator.animation != null))); 971 } 972 973 /** 974 * Like isReadyForDisplay(), but ignores any force hiding of the window due 975 * to the keyguard. 976 */ isReadyForDisplayIgnoringKeyguard()977 boolean isReadyForDisplayIgnoringKeyguard() { 978 if (mRootToken.waitingToShow && mService.mAppTransition.isTransitionSet()) { 979 return false; 980 } 981 final AppWindowToken atoken = mAppToken; 982 if (atoken == null && !mPolicyVisibility) { 983 // If this is not an app window, and the policy has asked to force 984 // hide, then we really do want to hide. 985 return false; 986 } 987 return mHasSurface && !mDestroying 988 && ((!mAttachedHidden && mViewVisibility == View.VISIBLE 989 && !mRootToken.hidden) 990 || mWinAnimator.mAnimation != null 991 || ((atoken != null) && (atoken.mAppAnimator.animation != null) 992 && !mWinAnimator.isDummyAnimation())); 993 } 994 995 /** 996 * Like isOnScreen, but returns false if the surface hasn't yet 997 * been drawn. 998 */ 999 @Override isDisplayedLw()1000 public boolean isDisplayedLw() { 1001 final AppWindowToken atoken = mAppToken; 1002 return isDrawnLw() && mPolicyVisibility 1003 && ((!mAttachedHidden && 1004 (atoken == null || !atoken.hiddenRequested)) 1005 || mWinAnimator.mAnimating 1006 || (atoken != null && atoken.mAppAnimator.animation != null)); 1007 } 1008 1009 /** 1010 * Return true if this window or its app token is currently animating. 1011 */ 1012 @Override isAnimatingLw()1013 public boolean isAnimatingLw() { 1014 return mWinAnimator.mAnimation != null 1015 || (mAppToken != null && mAppToken.mAppAnimator.animation != null); 1016 } 1017 1018 @Override isGoneForLayoutLw()1019 public boolean isGoneForLayoutLw() { 1020 final AppWindowToken atoken = mAppToken; 1021 return mViewVisibility == View.GONE 1022 || !mRelayoutCalled 1023 || (atoken == null && mRootToken.hidden) 1024 || (atoken != null && (atoken.hiddenRequested || atoken.hidden)) 1025 || mAttachedHidden 1026 || (mExiting && !isAnimatingLw()) 1027 || mDestroying; 1028 } 1029 1030 /** 1031 * Returns true if the window has a surface that it has drawn a 1032 * complete UI in to. 1033 */ isDrawFinishedLw()1034 public boolean isDrawFinishedLw() { 1035 return mHasSurface && !mDestroying && 1036 (mWinAnimator.mDrawState == WindowStateAnimator.COMMIT_DRAW_PENDING 1037 || mWinAnimator.mDrawState == WindowStateAnimator.READY_TO_SHOW 1038 || mWinAnimator.mDrawState == WindowStateAnimator.HAS_DRAWN); 1039 } 1040 1041 /** 1042 * Returns true if the window has a surface that it has drawn a 1043 * complete UI in to. 1044 */ isDrawnLw()1045 public boolean isDrawnLw() { 1046 return mHasSurface && !mDestroying && 1047 (mWinAnimator.mDrawState == WindowStateAnimator.READY_TO_SHOW 1048 || mWinAnimator.mDrawState == WindowStateAnimator.HAS_DRAWN); 1049 } 1050 1051 /** 1052 * Return true if the window is opaque and fully drawn. This indicates 1053 * it may obscure windows behind it. 1054 */ isOpaqueDrawn()1055 boolean isOpaqueDrawn() { 1056 return (mAttrs.format == PixelFormat.OPAQUE 1057 || mAttrs.type == TYPE_WALLPAPER) 1058 && isDrawnLw() && mWinAnimator.mAnimation == null 1059 && (mAppToken == null || mAppToken.mAppAnimator.animation == null); 1060 } 1061 1062 /** 1063 * Return whether this window is wanting to have a translation 1064 * animation applied to it for an in-progress move. (Only makes 1065 * sense to call from performLayoutAndPlaceSurfacesLockedInner().) 1066 */ shouldAnimateMove()1067 boolean shouldAnimateMove() { 1068 return mContentChanged && !mExiting && !mWinAnimator.mLastHidden && mService.okToDisplay() 1069 && (mFrame.top != mLastFrame.top 1070 || mFrame.left != mLastFrame.left) 1071 && (mAttrs.privateFlags&PRIVATE_FLAG_NO_MOVE_ANIMATION) == 0 1072 && (mAttachedWindow == null || !mAttachedWindow.shouldAnimateMove()); 1073 } 1074 isFullscreen(int screenWidth, int screenHeight)1075 boolean isFullscreen(int screenWidth, int screenHeight) { 1076 return mFrame.left <= 0 && mFrame.top <= 0 && 1077 mFrame.right >= screenWidth && mFrame.bottom >= screenHeight; 1078 } 1079 isConfigChanged()1080 boolean isConfigChanged() { 1081 boolean configChanged = mConfiguration != mService.mCurConfiguration 1082 && (mConfiguration == null 1083 || (mConfiguration.diff(mService.mCurConfiguration) != 0)); 1084 1085 if ((mAttrs.privateFlags & PRIVATE_FLAG_KEYGUARD) != 0) { 1086 // Retain configuration changed status until resetConfiguration called. 1087 mConfigHasChanged |= configChanged; 1088 configChanged = mConfigHasChanged; 1089 } 1090 1091 return configChanged; 1092 } 1093 removeLocked()1094 void removeLocked() { 1095 disposeInputChannel(); 1096 1097 if (mAttachedWindow != null) { 1098 if (WindowManagerService.DEBUG_ADD_REMOVE) Slog.v(TAG, "Removing " + this + " from " + mAttachedWindow); 1099 mAttachedWindow.mChildWindows.remove(this); 1100 } 1101 mWinAnimator.destroyDeferredSurfaceLocked(); 1102 mWinAnimator.destroySurfaceLocked(); 1103 mSession.windowRemovedLocked(); 1104 try { 1105 mClient.asBinder().unlinkToDeath(mDeathRecipient, 0); 1106 } catch (RuntimeException e) { 1107 // Ignore if it has already been removed (usually because 1108 // we are doing this as part of processing a death note.) 1109 } 1110 } 1111 setConfiguration(final Configuration newConfig)1112 void setConfiguration(final Configuration newConfig) { 1113 mConfiguration = newConfig; 1114 mConfigHasChanged = false; 1115 } 1116 setInputChannel(InputChannel inputChannel)1117 void setInputChannel(InputChannel inputChannel) { 1118 if (mInputChannel != null) { 1119 throw new IllegalStateException("Window already has an input channel."); 1120 } 1121 1122 mInputChannel = inputChannel; 1123 mInputWindowHandle.inputChannel = inputChannel; 1124 } 1125 disposeInputChannel()1126 void disposeInputChannel() { 1127 if (mInputChannel != null) { 1128 mService.mInputManager.unregisterInputChannel(mInputChannel); 1129 1130 mInputChannel.dispose(); 1131 mInputChannel = null; 1132 } 1133 1134 mInputWindowHandle.inputChannel = null; 1135 } 1136 1137 private class DeathRecipient implements IBinder.DeathRecipient { 1138 @Override binderDied()1139 public void binderDied() { 1140 try { 1141 synchronized(mService.mWindowMap) { 1142 WindowState win = mService.windowForClientLocked(mSession, mClient, false); 1143 Slog.i(TAG, "WIN DEATH: " + win); 1144 if (win != null) { 1145 mService.removeWindowLocked(mSession, win); 1146 } else if (mHasSurface) { 1147 Slog.e(TAG, "!!! LEAK !!! Window removed but surface still valid."); 1148 mService.removeWindowLocked(mSession, WindowState.this); 1149 } 1150 } 1151 } catch (IllegalArgumentException ex) { 1152 // This will happen if the window has already been 1153 // removed. 1154 } 1155 } 1156 } 1157 1158 /** 1159 * @return true if this window desires key events. 1160 */ canReceiveKeys()1161 public final boolean canReceiveKeys() { 1162 return isVisibleOrAdding() 1163 && (mViewVisibility == View.VISIBLE) 1164 && ((mAttrs.flags & WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE) == 0); 1165 } 1166 1167 @Override hasDrawnLw()1168 public boolean hasDrawnLw() { 1169 return mWinAnimator.mDrawState == WindowStateAnimator.HAS_DRAWN; 1170 } 1171 1172 @Override showLw(boolean doAnimation)1173 public boolean showLw(boolean doAnimation) { 1174 return showLw(doAnimation, true); 1175 } 1176 showLw(boolean doAnimation, boolean requestAnim)1177 boolean showLw(boolean doAnimation, boolean requestAnim) { 1178 if (isHiddenFromUserLocked()) { 1179 return false; 1180 } 1181 if (!mAppOpVisibility) { 1182 // Being hidden due to app op request. 1183 return false; 1184 } 1185 if (mPolicyVisibility && mPolicyVisibilityAfterAnim) { 1186 // Already showing. 1187 return false; 1188 } 1189 if (DEBUG_VISIBILITY) Slog.v(TAG, "Policy visibility true: " + this); 1190 if (doAnimation) { 1191 if (DEBUG_VISIBILITY) Slog.v(TAG, "doAnimation: mPolicyVisibility=" 1192 + mPolicyVisibility + " mAnimation=" + mWinAnimator.mAnimation); 1193 if (!mService.okToDisplay()) { 1194 doAnimation = false; 1195 } else if (mPolicyVisibility && mWinAnimator.mAnimation == null) { 1196 // Check for the case where we are currently visible and 1197 // not animating; we do not want to do animation at such a 1198 // point to become visible when we already are. 1199 doAnimation = false; 1200 } 1201 } 1202 mPolicyVisibility = true; 1203 mPolicyVisibilityAfterAnim = true; 1204 if (doAnimation) { 1205 mWinAnimator.applyAnimationLocked(WindowManagerPolicy.TRANSIT_ENTER, true); 1206 } 1207 if (requestAnim) { 1208 mService.scheduleAnimationLocked(); 1209 } 1210 return true; 1211 } 1212 1213 @Override hideLw(boolean doAnimation)1214 public boolean hideLw(boolean doAnimation) { 1215 return hideLw(doAnimation, true); 1216 } 1217 hideLw(boolean doAnimation, boolean requestAnim)1218 boolean hideLw(boolean doAnimation, boolean requestAnim) { 1219 if (doAnimation) { 1220 if (!mService.okToDisplay()) { 1221 doAnimation = false; 1222 } 1223 } 1224 boolean current = doAnimation ? mPolicyVisibilityAfterAnim 1225 : mPolicyVisibility; 1226 if (!current) { 1227 // Already hiding. 1228 return false; 1229 } 1230 if (doAnimation) { 1231 mWinAnimator.applyAnimationLocked(WindowManagerPolicy.TRANSIT_EXIT, false); 1232 if (mWinAnimator.mAnimation == null) { 1233 doAnimation = false; 1234 } 1235 } 1236 if (doAnimation) { 1237 mPolicyVisibilityAfterAnim = false; 1238 } else { 1239 if (DEBUG_VISIBILITY) Slog.v(TAG, "Policy visibility false: " + this); 1240 mPolicyVisibilityAfterAnim = false; 1241 mPolicyVisibility = false; 1242 // Window is no longer visible -- make sure if we were waiting 1243 // for it to be displayed before enabling the display, that 1244 // we allow the display to be enabled now. 1245 mService.enableScreenIfNeededLocked(); 1246 if (mService.mCurrentFocus == this) { 1247 if (WindowManagerService.DEBUG_FOCUS_LIGHT) Slog.i(TAG, 1248 "WindowState.hideLw: setting mFocusMayChange true"); 1249 mService.mFocusMayChange = true; 1250 } 1251 } 1252 if (requestAnim) { 1253 mService.scheduleAnimationLocked(); 1254 } 1255 return true; 1256 } 1257 setAppOpVisibilityLw(boolean state)1258 public void setAppOpVisibilityLw(boolean state) { 1259 if (mAppOpVisibility != state) { 1260 mAppOpVisibility = state; 1261 if (state) { 1262 // If the policy visibility had last been to hide, then this 1263 // will incorrectly show at this point since we lost that 1264 // information. Not a big deal -- for the windows that have app 1265 // ops modifies they should only be hidden by policy due to the 1266 // lock screen, and the user won't be changing this if locked. 1267 // Plus it will quickly be fixed the next time we do a layout. 1268 showLw(true, true); 1269 } else { 1270 hideLw(true, true); 1271 } 1272 } 1273 } 1274 1275 @Override isAlive()1276 public boolean isAlive() { 1277 return mClient.asBinder().isBinderAlive(); 1278 } 1279 isClosing()1280 boolean isClosing() { 1281 return mExiting || (mService.mClosingApps.contains(mAppToken)); 1282 } 1283 1284 @Override isDefaultDisplay()1285 public boolean isDefaultDisplay() { 1286 final DisplayContent displayContent = getDisplayContent(); 1287 if (displayContent == null) { 1288 // Only a window that was on a non-default display can be detached from it. 1289 return false; 1290 } 1291 return displayContent.isDefaultDisplay; 1292 } 1293 setShowToOwnerOnlyLocked(boolean showToOwnerOnly)1294 public void setShowToOwnerOnlyLocked(boolean showToOwnerOnly) { 1295 mShowToOwnerOnly = showToOwnerOnly; 1296 } 1297 isHiddenFromUserLocked()1298 boolean isHiddenFromUserLocked() { 1299 // Attached windows are evaluated based on the window that they are attached to. 1300 WindowState win = this; 1301 while (win.mAttachedWindow != null) { 1302 win = win.mAttachedWindow; 1303 } 1304 if (win.mAttrs.type < WindowManager.LayoutParams.FIRST_SYSTEM_WINDOW 1305 && win.mAppToken != null && win.mAppToken.showWhenLocked) { 1306 // Save some cycles by not calling getDisplayInfo unless it is an application 1307 // window intended for all users. 1308 final DisplayContent displayContent = win.getDisplayContent(); 1309 if (displayContent == null) { 1310 return true; 1311 } 1312 final DisplayInfo displayInfo = displayContent.getDisplayInfo(); 1313 if (win.mFrame.left <= 0 && win.mFrame.top <= 0 1314 && win.mFrame.right >= displayInfo.appWidth 1315 && win.mFrame.bottom >= displayInfo.appHeight) { 1316 // Is a fullscreen window, like the clock alarm. Show to everyone. 1317 return false; 1318 } 1319 } 1320 1321 return win.mShowToOwnerOnly 1322 && !mService.isCurrentProfileLocked(UserHandle.getUserId(win.mOwnerUid)); 1323 } 1324 applyInsets(Region outRegion, Rect frame, Rect inset)1325 private static void applyInsets(Region outRegion, Rect frame, Rect inset) { 1326 outRegion.set( 1327 frame.left + inset.left, frame.top + inset.top, 1328 frame.right - inset.right, frame.bottom - inset.bottom); 1329 } 1330 getTouchableRegion(Region outRegion)1331 public void getTouchableRegion(Region outRegion) { 1332 final Rect frame = mFrame; 1333 switch (mTouchableInsets) { 1334 default: 1335 case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_FRAME: 1336 outRegion.set(frame); 1337 break; 1338 case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_CONTENT: 1339 applyInsets(outRegion, frame, mGivenContentInsets); 1340 break; 1341 case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_VISIBLE: 1342 applyInsets(outRegion, frame, mGivenVisibleInsets); 1343 break; 1344 case ViewTreeObserver.InternalInsetsInfo.TOUCHABLE_INSETS_REGION: { 1345 final Region givenTouchableRegion = mGivenTouchableRegion; 1346 outRegion.set(givenTouchableRegion); 1347 outRegion.translate(frame.left, frame.top); 1348 break; 1349 } 1350 } 1351 } 1352 getWindowList()1353 WindowList getWindowList() { 1354 final DisplayContent displayContent = getDisplayContent(); 1355 return displayContent == null ? null : displayContent.getWindowList(); 1356 } 1357 1358 /** 1359 * Report a focus change. Must be called with no locks held, and consistently 1360 * from the same serialized thread (such as dispatched from a handler). 1361 */ reportFocusChangedSerialized(boolean focused, boolean inTouchMode)1362 public void reportFocusChangedSerialized(boolean focused, boolean inTouchMode) { 1363 try { 1364 mClient.windowFocusChanged(focused, inTouchMode); 1365 } catch (RemoteException e) { 1366 } 1367 if (mFocusCallbacks != null) { 1368 final int N = mFocusCallbacks.beginBroadcast(); 1369 for (int i=0; i<N; i++) { 1370 IWindowFocusObserver obs = mFocusCallbacks.getBroadcastItem(i); 1371 try { 1372 if (focused) { 1373 obs.focusGained(mWindowId.asBinder()); 1374 } else { 1375 obs.focusLost(mWindowId.asBinder()); 1376 } 1377 } catch (RemoteException e) { 1378 } 1379 } 1380 mFocusCallbacks.finishBroadcast(); 1381 } 1382 } 1383 reportResized()1384 void reportResized() { 1385 try { 1386 if (DEBUG_RESIZE || DEBUG_ORIENTATION) Slog.v(TAG, "Reporting new frame to " + this 1387 + ": " + mCompatFrame); 1388 boolean configChanged = isConfigChanged(); 1389 if ((DEBUG_RESIZE || DEBUG_ORIENTATION || DEBUG_CONFIGURATION) && configChanged) { 1390 Slog.i(TAG, "Sending new config to window " + this + ": " 1391 + mWinAnimator.mSurfaceW + "x" + mWinAnimator.mSurfaceH 1392 + " / " + mService.mCurConfiguration); 1393 } 1394 setConfiguration(mService.mCurConfiguration); 1395 if (DEBUG_ORIENTATION && mWinAnimator.mDrawState == WindowStateAnimator.DRAW_PENDING) 1396 Slog.i(TAG, "Resizing " + this + " WITH DRAW PENDING"); 1397 1398 final Rect frame = mFrame; 1399 final Rect overscanInsets = mLastOverscanInsets; 1400 final Rect contentInsets = mLastContentInsets; 1401 final Rect visibleInsets = mLastVisibleInsets; 1402 final Rect stableInsets = mLastStableInsets; 1403 final boolean reportDraw = mWinAnimator.mDrawState == WindowStateAnimator.DRAW_PENDING; 1404 final Configuration newConfig = configChanged ? mConfiguration : null; 1405 if (mAttrs.type != WindowManager.LayoutParams.TYPE_APPLICATION_STARTING 1406 && mClient instanceof IWindow.Stub) { 1407 // To prevent deadlock simulate one-way call if win.mClient is a local object. 1408 mService.mH.post(new Runnable() { 1409 @Override 1410 public void run() { 1411 try { 1412 mClient.resized(frame, overscanInsets, contentInsets, 1413 visibleInsets, stableInsets, reportDraw, newConfig); 1414 } catch (RemoteException e) { 1415 // Not a remote call, RemoteException won't be raised. 1416 } 1417 } 1418 }); 1419 } else { 1420 mClient.resized(frame, overscanInsets, contentInsets, visibleInsets, stableInsets, 1421 reportDraw, newConfig); 1422 } 1423 1424 //TODO (multidisplay): Accessibility supported only for the default display. 1425 if (mService.mAccessibilityController != null 1426 && getDisplayId() == Display.DEFAULT_DISPLAY) { 1427 mService.mAccessibilityController.onSomeWindowResizedOrMovedLocked(); 1428 } 1429 1430 mOverscanInsetsChanged = false; 1431 mContentInsetsChanged = false; 1432 mVisibleInsetsChanged = false; 1433 mStableInsetsChanged = false; 1434 mWinAnimator.mSurfaceResized = false; 1435 } catch (RemoteException e) { 1436 mOrientationChanging = false; 1437 mLastFreezeDuration = (int)(SystemClock.elapsedRealtime() 1438 - mService.mDisplayFreezeTime); 1439 } 1440 } 1441 registerFocusObserver(IWindowFocusObserver observer)1442 public void registerFocusObserver(IWindowFocusObserver observer) { 1443 synchronized(mService.mWindowMap) { 1444 if (mFocusCallbacks == null) { 1445 mFocusCallbacks = new RemoteCallbackList<IWindowFocusObserver>(); 1446 } 1447 mFocusCallbacks.register(observer); 1448 } 1449 } 1450 unregisterFocusObserver(IWindowFocusObserver observer)1451 public void unregisterFocusObserver(IWindowFocusObserver observer) { 1452 synchronized(mService.mWindowMap) { 1453 if (mFocusCallbacks != null) { 1454 mFocusCallbacks.unregister(observer); 1455 } 1456 } 1457 } 1458 isFocused()1459 public boolean isFocused() { 1460 synchronized(mService.mWindowMap) { 1461 return mService.mCurrentFocus == this; 1462 } 1463 } 1464 dump(PrintWriter pw, String prefix, boolean dumpAll)1465 void dump(PrintWriter pw, String prefix, boolean dumpAll) { 1466 pw.print(prefix); pw.print("mDisplayId="); pw.print(getDisplayId()); 1467 pw.print(" mSession="); pw.print(mSession); 1468 pw.print(" mClient="); pw.println(mClient.asBinder()); 1469 pw.print(prefix); pw.print("mOwnerUid="); pw.print(mOwnerUid); 1470 pw.print(" mShowToOwnerOnly="); pw.print(mShowToOwnerOnly); 1471 pw.print(" package="); pw.print(mAttrs.packageName); 1472 pw.print(" appop="); pw.println(AppOpsManager.opToName(mAppOp)); 1473 pw.print(prefix); pw.print("mAttrs="); pw.println(mAttrs); 1474 pw.print(prefix); pw.print("Requested w="); pw.print(mRequestedWidth); 1475 pw.print(" h="); pw.print(mRequestedHeight); 1476 pw.print(" mLayoutSeq="); pw.println(mLayoutSeq); 1477 if (mRequestedWidth != mLastRequestedWidth || mRequestedHeight != mLastRequestedHeight) { 1478 pw.print(prefix); pw.print("LastRequested w="); pw.print(mLastRequestedWidth); 1479 pw.print(" h="); pw.println(mLastRequestedHeight); 1480 } 1481 if (mAttachedWindow != null || mLayoutAttached) { 1482 pw.print(prefix); pw.print("mAttachedWindow="); pw.print(mAttachedWindow); 1483 pw.print(" mLayoutAttached="); pw.println(mLayoutAttached); 1484 } 1485 if (mIsImWindow || mIsWallpaper || mIsFloatingLayer) { 1486 pw.print(prefix); pw.print("mIsImWindow="); pw.print(mIsImWindow); 1487 pw.print(" mIsWallpaper="); pw.print(mIsWallpaper); 1488 pw.print(" mIsFloatingLayer="); pw.print(mIsFloatingLayer); 1489 pw.print(" mWallpaperVisible="); pw.println(mWallpaperVisible); 1490 } 1491 if (dumpAll) { 1492 pw.print(prefix); pw.print("mBaseLayer="); pw.print(mBaseLayer); 1493 pw.print(" mSubLayer="); pw.print(mSubLayer); 1494 pw.print(" mAnimLayer="); pw.print(mLayer); pw.print("+"); 1495 pw.print((mTargetAppToken != null ? 1496 mTargetAppToken.mAppAnimator.animLayerAdjustment 1497 : (mAppToken != null ? mAppToken.mAppAnimator.animLayerAdjustment : 0))); 1498 pw.print("="); pw.print(mWinAnimator.mAnimLayer); 1499 pw.print(" mLastLayer="); pw.println(mWinAnimator.mLastLayer); 1500 } 1501 if (dumpAll) { 1502 pw.print(prefix); pw.print("mToken="); pw.println(mToken); 1503 pw.print(prefix); pw.print("mRootToken="); pw.println(mRootToken); 1504 if (mAppToken != null) { 1505 pw.print(prefix); pw.print("mAppToken="); pw.println(mAppToken); 1506 } 1507 if (mTargetAppToken != null) { 1508 pw.print(prefix); pw.print("mTargetAppToken="); pw.println(mTargetAppToken); 1509 } 1510 pw.print(prefix); pw.print("mViewVisibility=0x"); 1511 pw.print(Integer.toHexString(mViewVisibility)); 1512 pw.print(" mHaveFrame="); pw.print(mHaveFrame); 1513 pw.print(" mObscured="); pw.println(mObscured); 1514 pw.print(prefix); pw.print("mSeq="); pw.print(mSeq); 1515 pw.print(" mSystemUiVisibility=0x"); 1516 pw.println(Integer.toHexString(mSystemUiVisibility)); 1517 } 1518 if (!mPolicyVisibility || !mPolicyVisibilityAfterAnim || !mAppOpVisibility 1519 || mAttachedHidden) { 1520 pw.print(prefix); pw.print("mPolicyVisibility="); 1521 pw.print(mPolicyVisibility); 1522 pw.print(" mPolicyVisibilityAfterAnim="); 1523 pw.print(mPolicyVisibilityAfterAnim); 1524 pw.print(" mAppOpVisibility="); 1525 pw.print(mAppOpVisibility); 1526 pw.print(" mAttachedHidden="); pw.println(mAttachedHidden); 1527 } 1528 if (!mRelayoutCalled || mLayoutNeeded) { 1529 pw.print(prefix); pw.print("mRelayoutCalled="); pw.print(mRelayoutCalled); 1530 pw.print(" mLayoutNeeded="); pw.println(mLayoutNeeded); 1531 } 1532 if (mXOffset != 0 || mYOffset != 0) { 1533 pw.print(prefix); pw.print("Offsets x="); pw.print(mXOffset); 1534 pw.print(" y="); pw.println(mYOffset); 1535 } 1536 if (dumpAll) { 1537 pw.print(prefix); pw.print("mGivenContentInsets="); 1538 mGivenContentInsets.printShortString(pw); 1539 pw.print(" mGivenVisibleInsets="); 1540 mGivenVisibleInsets.printShortString(pw); 1541 pw.println(); 1542 if (mTouchableInsets != 0 || mGivenInsetsPending) { 1543 pw.print(prefix); pw.print("mTouchableInsets="); pw.print(mTouchableInsets); 1544 pw.print(" mGivenInsetsPending="); pw.println(mGivenInsetsPending); 1545 Region region = new Region(); 1546 getTouchableRegion(region); 1547 pw.print(prefix); pw.print("touchable region="); pw.println(region); 1548 } 1549 pw.print(prefix); pw.print("mConfiguration="); pw.println(mConfiguration); 1550 } 1551 pw.print(prefix); pw.print("mHasSurface="); pw.print(mHasSurface); 1552 pw.print(" mShownFrame="); mShownFrame.printShortString(pw); 1553 pw.print(" isReadyForDisplay()="); pw.println(isReadyForDisplay()); 1554 if (dumpAll) { 1555 pw.print(prefix); pw.print("mFrame="); mFrame.printShortString(pw); 1556 pw.print(" last="); mLastFrame.printShortString(pw); 1557 pw.println(); 1558 pw.print(prefix); pw.print("mSystemDecorRect="); mSystemDecorRect.printShortString(pw); 1559 pw.print(" last="); mLastSystemDecorRect.printShortString(pw); 1560 pw.println(); 1561 } 1562 if (mEnforceSizeCompat) { 1563 pw.print(prefix); pw.print("mCompatFrame="); mCompatFrame.printShortString(pw); 1564 pw.println(); 1565 } 1566 if (dumpAll) { 1567 pw.print(prefix); pw.print("Frames: containing="); 1568 mContainingFrame.printShortString(pw); 1569 pw.print(" parent="); mParentFrame.printShortString(pw); 1570 pw.println(); 1571 pw.print(prefix); pw.print(" display="); mDisplayFrame.printShortString(pw); 1572 pw.print(" overscan="); mOverscanFrame.printShortString(pw); 1573 pw.println(); 1574 pw.print(prefix); pw.print(" content="); mContentFrame.printShortString(pw); 1575 pw.print(" visible="); mVisibleFrame.printShortString(pw); 1576 pw.println(); 1577 pw.print(prefix); pw.print(" decor="); mDecorFrame.printShortString(pw); 1578 pw.println(); 1579 pw.print(prefix); pw.print("Cur insets: overscan="); 1580 mOverscanInsets.printShortString(pw); 1581 pw.print(" content="); mContentInsets.printShortString(pw); 1582 pw.print(" visible="); mVisibleInsets.printShortString(pw); 1583 pw.print(" stable="); mStableInsets.printShortString(pw); 1584 pw.println(); 1585 pw.print(prefix); pw.print("Lst insets: overscan="); 1586 mLastOverscanInsets.printShortString(pw); 1587 pw.print(" content="); mLastContentInsets.printShortString(pw); 1588 pw.print(" visible="); mLastVisibleInsets.printShortString(pw); 1589 pw.print(" stable="); mLastStableInsets.printShortString(pw); 1590 pw.println(); 1591 } 1592 pw.print(prefix); pw.print(mWinAnimator); pw.println(":"); 1593 mWinAnimator.dump(pw, prefix + " ", dumpAll); 1594 if (mExiting || mRemoveOnExit || mDestroying || mRemoved) { 1595 pw.print(prefix); pw.print("mExiting="); pw.print(mExiting); 1596 pw.print(" mRemoveOnExit="); pw.print(mRemoveOnExit); 1597 pw.print(" mDestroying="); pw.print(mDestroying); 1598 pw.print(" mRemoved="); pw.println(mRemoved); 1599 } 1600 if (mOrientationChanging || mAppFreezing || mTurnOnScreen) { 1601 pw.print(prefix); pw.print("mOrientationChanging="); 1602 pw.print(mOrientationChanging); 1603 pw.print(" mAppFreezing="); pw.print(mAppFreezing); 1604 pw.print(" mTurnOnScreen="); pw.println(mTurnOnScreen); 1605 } 1606 if (mLastFreezeDuration != 0) { 1607 pw.print(prefix); pw.print("mLastFreezeDuration="); 1608 TimeUtils.formatDuration(mLastFreezeDuration, pw); pw.println(); 1609 } 1610 if (mHScale != 1 || mVScale != 1) { 1611 pw.print(prefix); pw.print("mHScale="); pw.print(mHScale); 1612 pw.print(" mVScale="); pw.println(mVScale); 1613 } 1614 if (mWallpaperX != -1 || mWallpaperY != -1) { 1615 pw.print(prefix); pw.print("mWallpaperX="); pw.print(mWallpaperX); 1616 pw.print(" mWallpaperY="); pw.println(mWallpaperY); 1617 } 1618 if (mWallpaperXStep != -1 || mWallpaperYStep != -1) { 1619 pw.print(prefix); pw.print("mWallpaperXStep="); pw.print(mWallpaperXStep); 1620 pw.print(" mWallpaperYStep="); pw.println(mWallpaperYStep); 1621 } 1622 if (mWallpaperDisplayOffsetX != Integer.MIN_VALUE 1623 || mWallpaperDisplayOffsetY != Integer.MIN_VALUE) { 1624 pw.print(prefix); pw.print("mWallpaperDisplayOffsetX="); 1625 pw.print(mWallpaperDisplayOffsetX); 1626 pw.print(" mWallpaperDisplayOffsetY="); 1627 pw.println(mWallpaperDisplayOffsetY); 1628 } 1629 } 1630 makeInputChannelName()1631 String makeInputChannelName() { 1632 return Integer.toHexString(System.identityHashCode(this)) 1633 + " " + mAttrs.getTitle(); 1634 } 1635 1636 @Override toString()1637 public String toString() { 1638 CharSequence title = mAttrs.getTitle(); 1639 if (title == null || title.length() <= 0) { 1640 title = mAttrs.packageName; 1641 } 1642 if (mStringNameCache == null || mLastTitle != title || mWasExiting != mExiting) { 1643 mLastTitle = title; 1644 mWasExiting = mExiting; 1645 mStringNameCache = "Window{" + Integer.toHexString(System.identityHashCode(this)) 1646 + " u" + UserHandle.getUserId(mSession.mUid) 1647 + " " + mLastTitle + (mExiting ? " EXITING}" : "}"); 1648 } 1649 return mStringNameCache; 1650 } 1651 } 1652