1 /* 2 * Copyright (C) 2015 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.WindowManagerDebugConfig.SHOW_SURFACE_ALLOC; 20 import static com.android.server.wm.WindowManagerDebugConfig.SHOW_TRANSACTIONS; 21 import static com.android.server.wm.WindowManagerDebugConfig.SHOW_LIGHT_TRANSACTIONS; 22 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_SURFACE_TRACE; 23 import static com.android.server.wm.WindowManagerDebugConfig.DEBUG_VISIBILITY; 24 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WITH_CLASS_NAME; 25 import static com.android.server.wm.WindowManagerDebugConfig.TAG_WM; 26 import static android.view.Surface.SCALING_MODE_FREEZE; 27 import static android.view.Surface.SCALING_MODE_SCALE_TO_WINDOW; 28 29 import android.graphics.PixelFormat; 30 import android.graphics.Point; 31 import android.graphics.PointF; 32 import android.graphics.Rect; 33 import android.graphics.Region; 34 import android.os.IBinder; 35 import android.os.Debug; 36 import android.view.Surface; 37 import android.view.SurfaceControl; 38 import android.view.SurfaceSession; 39 import android.view.WindowContentFrameStats; 40 import android.view.Surface.OutOfResourcesException; 41 42 import android.util.Slog; 43 44 import java.io.PrintWriter; 45 import java.util.ArrayList; 46 47 class WindowSurfaceController { 48 static final String TAG = TAG_WITH_CLASS_NAME ? "WindowSurfaceController" : TAG_WM; 49 50 final WindowStateAnimator mAnimator; 51 52 private SurfaceControl mSurfaceControl; 53 54 private boolean mSurfaceShown = false; 55 private float mSurfaceX = 0; 56 private float mSurfaceY = 0; 57 private float mSurfaceW = 0; 58 private float mSurfaceH = 0; 59 60 private float mSurfaceAlpha = 0; 61 62 private int mSurfaceLayer = 0; 63 64 // Surface flinger doesn't support crop rectangles where width or height is non-positive. 65 // However, we need to somehow handle the situation where the cropping would completely hide 66 // the window. We achieve this by explicitly hiding the surface and not letting it be shown. 67 private boolean mHiddenForCrop = false; 68 69 // Initially a surface is hidden after just being created. 70 private boolean mHiddenForOtherReasons = true; 71 private final String title; 72 73 public WindowSurfaceController(SurfaceSession s, 74 String name, int w, int h, int format, int flags, WindowStateAnimator animator) { 75 mAnimator = animator; 76 77 mSurfaceW = w; 78 mSurfaceH = h; 79 80 title = name; 81 82 // For opaque child windows placed under parent windows, 83 // we use a special SurfaceControl which mirrors commands 84 // to a black-out layer placed one Z-layer below the surface. 85 // This prevents holes to whatever app/wallpaper is underneath. 86 if (animator.mWin.isChildWindow() && 87 animator.mWin.mSubLayer < 0 && 88 animator.mWin.mAppToken != null) { 89 mSurfaceControl = new SurfaceControlWithBackground(s, 90 name, w, h, format, flags, animator.mWin.mAppToken); 91 } else if (DEBUG_SURFACE_TRACE) { 92 mSurfaceControl = new SurfaceTrace( 93 s, name, w, h, format, flags); 94 } else { 95 mSurfaceControl = new SurfaceControl( 96 s, name, w, h, format, flags); 97 } 98 } 99 100 101 void logSurface(String msg, RuntimeException where) { 102 String str = " SURFACE " + msg + ": " + title; 103 if (where != null) { 104 Slog.i(TAG, str, where); 105 } else { 106 Slog.i(TAG, str); 107 } 108 } 109 110 void hideInTransaction(String reason) { 111 if (SHOW_TRANSACTIONS) logSurface("HIDE ( " + reason + " )", null); 112 mHiddenForOtherReasons = true; 113 114 mAnimator.destroyPreservedSurfaceLocked(); 115 updateVisibility(); 116 } 117 118 private void hideSurface() { 119 if (mSurfaceControl != null) { 120 mSurfaceShown = false; 121 try { 122 mSurfaceControl.hide(); 123 } catch (RuntimeException e) { 124 Slog.w(TAG, "Exception hiding surface in " + this); 125 } 126 } 127 } 128 129 void setPositionAndLayer(float left, float top, int layerStack, int layer) { 130 SurfaceControl.openTransaction(); 131 try { 132 mSurfaceX = left; 133 mSurfaceY = top; 134 135 try { 136 if (SHOW_TRANSACTIONS) logSurface( 137 "POS (setPositionAndLayer) @ (" + left + "," + top + ")", null); 138 mSurfaceControl.setPosition(left, top); 139 mSurfaceControl.setLayerStack(layerStack); 140 141 mSurfaceControl.setLayer(layer); 142 mSurfaceControl.setAlpha(0); 143 mSurfaceShown = false; 144 } catch (RuntimeException e) { 145 Slog.w(TAG, "Error creating surface in " + this, e); 146 mAnimator.reclaimSomeSurfaceMemory("create-init", true); 147 } 148 } finally { 149 SurfaceControl.closeTransaction(); 150 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, 151 "<<< CLOSE TRANSACTION setPositionAndLayer"); 152 } 153 } 154 155 void destroyInTransaction() { 156 // if (SHOW_TRANSACTIONS || SHOW_SURFACE_ALLOC) { 157 Slog.i(TAG, "Destroying surface " + this + " called by " + Debug.getCallers(8)); 158 // } 159 try { 160 if (mSurfaceControl != null) { 161 mSurfaceControl.destroy(); 162 } 163 } catch (RuntimeException e) { 164 Slog.w(TAG, "Error destroying surface in: " + this, e); 165 } finally { 166 mSurfaceShown = false; 167 mSurfaceControl = null; 168 } 169 } 170 171 void disconnectInTransaction() { 172 if (SHOW_TRANSACTIONS || SHOW_SURFACE_ALLOC) { 173 Slog.i(TAG, "Disconnecting client: " + this); 174 } 175 176 try { 177 if (mSurfaceControl != null) { 178 mSurfaceControl.disconnect(); 179 } 180 } catch (RuntimeException e) { 181 Slog.w(TAG, "Error disconnecting surface in: " + this, e); 182 } 183 } 184 185 void setCropInTransaction(Rect clipRect, boolean recoveringMemory) { 186 if (SHOW_TRANSACTIONS) logSurface( 187 "CROP " + clipRect.toShortString(), null); 188 try { 189 if (clipRect.width() > 0 && clipRect.height() > 0) { 190 mSurfaceControl.setWindowCrop(clipRect); 191 mHiddenForCrop = false; 192 updateVisibility(); 193 } else { 194 mHiddenForCrop = true; 195 mAnimator.destroyPreservedSurfaceLocked(); 196 updateVisibility(); 197 } 198 } catch (RuntimeException e) { 199 Slog.w(TAG, "Error setting crop surface of " + this 200 + " crop=" + clipRect.toShortString(), e); 201 if (!recoveringMemory) { 202 mAnimator.reclaimSomeSurfaceMemory("crop", true); 203 } 204 } 205 } 206 207 void clearCropInTransaction(boolean recoveringMemory) { 208 if (SHOW_TRANSACTIONS) logSurface( 209 "CLEAR CROP", null); 210 try { 211 Rect clipRect = new Rect(0, 0, -1, -1); 212 mSurfaceControl.setWindowCrop(clipRect); 213 } catch (RuntimeException e) { 214 Slog.w(TAG, "Error setting clearing crop of " + this, e); 215 if (!recoveringMemory) { 216 mAnimator.reclaimSomeSurfaceMemory("crop", true); 217 } 218 } 219 } 220 221 void setFinalCropInTransaction(Rect clipRect) { 222 if (SHOW_TRANSACTIONS) logSurface( 223 "FINAL CROP " + clipRect.toShortString(), null); 224 try { 225 mSurfaceControl.setFinalCrop(clipRect); 226 } catch (RuntimeException e) { 227 Slog.w(TAG, "Error disconnecting surface in: " + this, e); 228 } 229 } 230 231 void setLayer(int layer) { 232 if (mSurfaceControl != null) { 233 SurfaceControl.openTransaction(); 234 try { 235 mSurfaceControl.setLayer(layer); 236 } finally { 237 SurfaceControl.closeTransaction(); 238 } 239 } 240 } 241 242 void setPositionInTransaction(float left, float top, boolean recoveringMemory) { 243 final boolean surfaceMoved = mSurfaceX != left || mSurfaceY != top; 244 if (surfaceMoved) { 245 mSurfaceX = left; 246 mSurfaceY = top; 247 248 try { 249 if (SHOW_TRANSACTIONS) logSurface( 250 "POS (setPositionInTransaction) @ (" + left + "," + top + ")", null); 251 252 mSurfaceControl.setPosition(left, top); 253 } catch (RuntimeException e) { 254 Slog.w(TAG, "Error positioning surface of " + this 255 + " pos=(" + left + "," + top + ")", e); 256 if (!recoveringMemory) { 257 mAnimator.reclaimSomeSurfaceMemory("position", true); 258 } 259 } 260 } 261 } 262 263 void setGeometryAppliesWithResizeInTransaction(boolean recoveringMemory) { 264 mSurfaceControl.setGeometryAppliesWithResize(); 265 } 266 267 void setMatrixInTransaction(float dsdx, float dtdx, float dsdy, float dtdy, 268 boolean recoveringMemory) { 269 try { 270 if (SHOW_TRANSACTIONS) logSurface( 271 "MATRIX [" + dsdx + "," + dtdx + "," + dsdy + "," + dtdy + "]", null); 272 mSurfaceControl.setMatrix( 273 dsdx, dtdx, dsdy, dtdy); 274 } catch (RuntimeException e) { 275 // If something goes wrong with the surface (such 276 // as running out of memory), don't take down the 277 // entire system. 278 Slog.e(TAG, "Error setting matrix on surface surface" + title 279 + " MATRIX [" + dsdx + "," + dtdx + "," + dsdy + "," + dtdy + "]", null); 280 if (!recoveringMemory) { 281 mAnimator.reclaimSomeSurfaceMemory("matrix", true); 282 } 283 } 284 return; 285 } 286 287 boolean setSizeInTransaction(int width, int height, boolean recoveringMemory) { 288 final boolean surfaceResized = mSurfaceW != width || mSurfaceH != height; 289 if (surfaceResized) { 290 mSurfaceW = width; 291 mSurfaceH = height; 292 293 try { 294 if (SHOW_TRANSACTIONS) logSurface( 295 "SIZE " + width + "x" + height, null); 296 mSurfaceControl.setSize(width, height); 297 } catch (RuntimeException e) { 298 // If something goes wrong with the surface (such 299 // as running out of memory), don't take down the 300 // entire system. 301 Slog.e(TAG, "Error resizing surface of " + title 302 + " size=(" + width + "x" + height + ")", e); 303 if (!recoveringMemory) { 304 mAnimator.reclaimSomeSurfaceMemory("size", true); 305 } 306 return false; 307 } 308 return true; 309 } 310 return false; 311 } 312 313 boolean prepareToShowInTransaction(float alpha, int layer, float dsdx, float dtdx, float dsdy, 314 float dtdy, boolean recoveringMemory) { 315 if (mSurfaceControl != null) { 316 try { 317 mSurfaceAlpha = alpha; 318 mSurfaceControl.setAlpha(alpha); 319 mSurfaceLayer = layer; 320 mSurfaceControl.setLayer(layer); 321 mSurfaceControl.setMatrix( 322 dsdx, dtdx, dsdy, dtdy); 323 324 } catch (RuntimeException e) { 325 Slog.w(TAG, "Error updating surface in " + title, e); 326 if (!recoveringMemory) { 327 mAnimator.reclaimSomeSurfaceMemory("update", true); 328 } 329 return false; 330 } 331 } 332 return true; 333 } 334 335 void setTransparentRegionHint(final Region region) { 336 if (mSurfaceControl == null) { 337 Slog.w(TAG, "setTransparentRegionHint: null mSurface after mHasSurface true"); 338 return; 339 } 340 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, ">>> OPEN TRANSACTION setTransparentRegion"); 341 SurfaceControl.openTransaction(); 342 try { 343 mSurfaceControl.setTransparentRegionHint(region); 344 } finally { 345 SurfaceControl.closeTransaction(); 346 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, 347 "<<< CLOSE TRANSACTION setTransparentRegion"); 348 } 349 } 350 351 void setOpaque(boolean isOpaque) { 352 if (SHOW_TRANSACTIONS) logSurface("isOpaque=" + isOpaque, 353 null); 354 355 if (mSurfaceControl == null) { 356 return; 357 } 358 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, ">>> OPEN TRANSACTION setOpaqueLocked"); 359 SurfaceControl.openTransaction(); 360 try { 361 mSurfaceControl.setOpaque(isOpaque); 362 } finally { 363 SurfaceControl.closeTransaction(); 364 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, "<<< CLOSE TRANSACTION setOpaqueLocked"); 365 } 366 } 367 368 void setSecure(boolean isSecure) { 369 if (SHOW_TRANSACTIONS) logSurface("isSecure=" + isSecure, 370 null); 371 372 if (mSurfaceControl == null) { 373 return; 374 } 375 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, ">>> OPEN TRANSACTION setSecureLocked"); 376 SurfaceControl.openTransaction(); 377 try { 378 mSurfaceControl.setSecure(isSecure); 379 } finally { 380 SurfaceControl.closeTransaction(); 381 if (SHOW_LIGHT_TRANSACTIONS) Slog.i(TAG, "<<< CLOSE TRANSACTION setSecureLocked"); 382 } 383 } 384 385 boolean showRobustlyInTransaction() { 386 if (SHOW_TRANSACTIONS) logSurface( 387 "SHOW (performLayout)", null); 388 if (DEBUG_VISIBILITY) Slog.v(TAG, "Showing " + this 389 + " during relayout"); 390 mHiddenForOtherReasons = false; 391 return updateVisibility(); 392 } 393 394 private boolean updateVisibility() { 395 if (mHiddenForCrop || mHiddenForOtherReasons) { 396 if (mSurfaceShown) { 397 hideSurface(); 398 } 399 return false; 400 } else { 401 if (!mSurfaceShown) { 402 return showSurface(); 403 } else { 404 return true; 405 } 406 } 407 } 408 409 private boolean showSurface() { 410 try { 411 mSurfaceShown = true; 412 mSurfaceControl.show(); 413 return true; 414 } catch (RuntimeException e) { 415 Slog.w(TAG, "Failure showing surface " + mSurfaceControl + " in " + this, e); 416 } 417 418 mAnimator.reclaimSomeSurfaceMemory("show", true); 419 420 return false; 421 } 422 423 void deferTransactionUntil(IBinder handle, long frame) { 424 // TODO: Logging 425 mSurfaceControl.deferTransactionUntil(handle, frame); 426 } 427 428 void forceScaleableInTransaction(boolean force) { 429 // -1 means we don't override the default or client specified 430 // scaling mode. 431 int scalingMode = force ? SCALING_MODE_SCALE_TO_WINDOW : -1; 432 mSurfaceControl.setOverrideScalingMode(scalingMode); 433 } 434 435 boolean clearWindowContentFrameStats() { 436 if (mSurfaceControl == null) { 437 return false; 438 } 439 return mSurfaceControl.clearContentFrameStats(); 440 } 441 442 boolean getWindowContentFrameStats(WindowContentFrameStats outStats) { 443 if (mSurfaceControl == null) { 444 return false; 445 } 446 return mSurfaceControl.getContentFrameStats(outStats); 447 } 448 449 450 boolean hasSurface() { 451 return mSurfaceControl != null; 452 } 453 454 IBinder getHandle() { 455 if (mSurfaceControl == null) { 456 return null; 457 } 458 return mSurfaceControl.getHandle(); 459 } 460 461 boolean getTransformToDisplayInverse() { 462 return mSurfaceControl.getTransformToDisplayInverse(); 463 } 464 465 void getSurface(Surface outSurface) { 466 outSurface.copyFrom(mSurfaceControl); 467 } 468 469 int getLayer() { 470 return mSurfaceLayer; 471 } 472 473 boolean getShown() { 474 return mSurfaceShown; 475 } 476 477 void setShown(boolean surfaceShown) { 478 mSurfaceShown = surfaceShown; 479 } 480 481 float getX() { 482 return mSurfaceX; 483 } 484 485 float getY() { 486 return mSurfaceY; 487 } 488 489 float getWidth() { 490 return mSurfaceW; 491 } 492 493 float getHeight() { 494 return mSurfaceH; 495 } 496 497 498 public void dump(PrintWriter pw, String prefix, boolean dumpAll) { 499 if (dumpAll) { 500 pw.print(prefix); pw.print("mSurface="); pw.println(mSurfaceControl); 501 } 502 pw.print(prefix); pw.print("Surface: shown="); pw.print(mSurfaceShown); 503 pw.print(" layer="); pw.print(mSurfaceLayer); 504 pw.print(" alpha="); pw.print(mSurfaceAlpha); 505 pw.print(" rect=("); pw.print(mSurfaceX); 506 pw.print(","); pw.print(mSurfaceY); 507 pw.print(") "); pw.print(mSurfaceW); 508 pw.print(" x "); pw.println(mSurfaceH); 509 } 510 511 @Override 512 public String toString() { 513 return mSurfaceControl.toString(); 514 } 515 516 static class SurfaceTrace extends SurfaceControl { 517 private final static String SURFACE_TAG = TAG_WITH_CLASS_NAME ? "SurfaceTrace" : TAG_WM; 518 private final static boolean LOG_SURFACE_TRACE = DEBUG_SURFACE_TRACE; 519 final static ArrayList<SurfaceTrace> sSurfaces = new ArrayList<SurfaceTrace>(); 520 521 private float mSurfaceTraceAlpha = 0; 522 private int mLayer; 523 private final PointF mPosition = new PointF(); 524 private final Point mSize = new Point(); 525 private final Rect mWindowCrop = new Rect(); 526 private final Rect mFinalCrop = new Rect(); 527 private boolean mShown = false; 528 private int mLayerStack; 529 private boolean mIsOpaque; 530 private float mDsdx, mDtdx, mDsdy, mDtdy; 531 private final String mName; 532 533 public SurfaceTrace(SurfaceSession s, 534 String name, int w, int h, int format, int flags) 535 throws OutOfResourcesException { 536 super(s, name, w, h, format, flags); 537 mName = name != null ? name : "Not named"; 538 mSize.set(w, h); 539 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "ctor: " + this + ". Called by " 540 + Debug.getCallers(3)); 541 synchronized (sSurfaces) { 542 sSurfaces.add(0, this); 543 } 544 } 545 546 @Override 547 public void setAlpha(float alpha) { 548 if (mSurfaceTraceAlpha != alpha) { 549 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setAlpha(" + alpha + "): OLD:" + this + 550 ". Called by " + Debug.getCallers(3)); 551 mSurfaceTraceAlpha = alpha; 552 } 553 super.setAlpha(alpha); 554 } 555 556 @Override 557 public void setLayer(int zorder) { 558 if (zorder != mLayer) { 559 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setLayer(" + zorder + "): OLD:" + this 560 + ". Called by " + Debug.getCallers(3)); 561 mLayer = zorder; 562 } 563 super.setLayer(zorder); 564 565 synchronized (sSurfaces) { 566 sSurfaces.remove(this); 567 int i; 568 for (i = sSurfaces.size() - 1; i >= 0; i--) { 569 SurfaceTrace s = sSurfaces.get(i); 570 if (s.mLayer < zorder) { 571 break; 572 } 573 } 574 sSurfaces.add(i + 1, this); 575 } 576 } 577 578 @Override 579 public void setPosition(float x, float y) { 580 if (x != mPosition.x || y != mPosition.y) { 581 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setPosition(" + x + "," + y + "): OLD:" 582 + this + ". Called by " + Debug.getCallers(3)); 583 mPosition.set(x, y); 584 } 585 super.setPosition(x, y); 586 } 587 588 @Override 589 public void setGeometryAppliesWithResize() { 590 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setGeometryAppliesWithResize(): OLD: " 591 + this + ". Called by" + Debug.getCallers(3)); 592 super.setGeometryAppliesWithResize(); 593 } 594 595 @Override 596 public void setSize(int w, int h) { 597 if (w != mSize.x || h != mSize.y) { 598 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setSize(" + w + "," + h + "): OLD:" 599 + this + ". Called by " + Debug.getCallers(3)); 600 mSize.set(w, h); 601 } 602 super.setSize(w, h); 603 } 604 605 @Override 606 public void setWindowCrop(Rect crop) { 607 if (crop != null) { 608 if (!crop.equals(mWindowCrop)) { 609 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setWindowCrop(" 610 + crop.toShortString() + "): OLD:" + this + ". Called by " 611 + Debug.getCallers(3)); 612 mWindowCrop.set(crop); 613 } 614 } 615 super.setWindowCrop(crop); 616 } 617 618 @Override 619 public void setFinalCrop(Rect crop) { 620 if (crop != null) { 621 if (!crop.equals(mFinalCrop)) { 622 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setFinalCrop(" 623 + crop.toShortString() + "): OLD:" + this + ". Called by " 624 + Debug.getCallers(3)); 625 mFinalCrop.set(crop); 626 } 627 } 628 super.setFinalCrop(crop); 629 } 630 631 @Override 632 public void setLayerStack(int layerStack) { 633 if (layerStack != mLayerStack) { 634 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setLayerStack(" + layerStack + "): OLD:" 635 + this + ". Called by " + Debug.getCallers(3)); 636 mLayerStack = layerStack; 637 } 638 super.setLayerStack(layerStack); 639 } 640 641 @Override 642 public void setOpaque(boolean isOpaque) { 643 if (isOpaque != mIsOpaque) { 644 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setOpaque(" + isOpaque + "): OLD:" 645 + this + ". Called by " + Debug.getCallers(3)); 646 mIsOpaque = isOpaque; 647 } 648 super.setOpaque(isOpaque); 649 } 650 651 @Override 652 public void setSecure(boolean isSecure) { 653 super.setSecure(isSecure); 654 } 655 656 @Override 657 public void setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { 658 if (dsdx != mDsdx || dtdx != mDtdx || dsdy != mDsdy || dtdy != mDtdy) { 659 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setMatrix(" + dsdx + "," + dtdx + "," 660 + dsdy + "," + dtdy + "): OLD:" + this + ". Called by " 661 + Debug.getCallers(3)); 662 mDsdx = dsdx; 663 mDtdx = dtdx; 664 mDsdy = dsdy; 665 mDtdy = dtdy; 666 } 667 super.setMatrix(dsdx, dtdx, dsdy, dtdy); 668 } 669 670 @Override 671 public void hide() { 672 if (mShown) { 673 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "hide: OLD:" + this + ". Called by " 674 + Debug.getCallers(3)); 675 mShown = false; 676 } 677 super.hide(); 678 } 679 680 @Override 681 public void show() { 682 if (!mShown) { 683 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "show: OLD:" + this + ". Called by " 684 + Debug.getCallers(3)); 685 mShown = true; 686 } 687 super.show(); 688 } 689 690 @Override 691 public void destroy() { 692 super.destroy(); 693 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "destroy: " + this + ". Called by " 694 + Debug.getCallers(3)); 695 synchronized (sSurfaces) { 696 sSurfaces.remove(this); 697 } 698 } 699 700 @Override 701 public void release() { 702 super.release(); 703 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "release: " + this + ". Called by " 704 + Debug.getCallers(3)); 705 synchronized (sSurfaces) { 706 sSurfaces.remove(this); 707 } 708 } 709 710 @Override 711 public void setTransparentRegionHint(Region region) { 712 if (LOG_SURFACE_TRACE) Slog.v(SURFACE_TAG, "setTransparentRegionHint(" + region 713 + "): OLD: " + this + " . Called by " + Debug.getCallers(3)); 714 super.setTransparentRegionHint(region); 715 } 716 717 static void dumpAllSurfaces(PrintWriter pw, String header) { 718 synchronized (sSurfaces) { 719 final int N = sSurfaces.size(); 720 if (N <= 0) { 721 return; 722 } 723 if (header != null) { 724 pw.println(header); 725 } 726 pw.println("WINDOW MANAGER SURFACES (dumpsys window surfaces)"); 727 for (int i = 0; i < N; i++) { 728 SurfaceTrace s = sSurfaces.get(i); 729 pw.print(" Surface #"); pw.print(i); pw.print(": #"); 730 pw.print(Integer.toHexString(System.identityHashCode(s))); 731 pw.print(" "); pw.println(s.mName); 732 pw.print(" mLayerStack="); pw.print(s.mLayerStack); 733 pw.print(" mLayer="); pw.println(s.mLayer); 734 pw.print(" mShown="); pw.print(s.mShown); pw.print(" mAlpha="); 735 pw.print(s.mSurfaceTraceAlpha); pw.print(" mIsOpaque="); 736 pw.println(s.mIsOpaque); 737 pw.print(" mPosition="); pw.print(s.mPosition.x); pw.print(","); 738 pw.print(s.mPosition.y); 739 pw.print(" mSize="); pw.print(s.mSize.x); pw.print("x"); 740 pw.println(s.mSize.y); 741 pw.print(" mCrop="); s.mWindowCrop.printShortString(pw); pw.println(); 742 pw.print(" mFinalCrop="); s.mFinalCrop.printShortString(pw); pw.println(); 743 pw.print(" Transform: ("); pw.print(s.mDsdx); pw.print(", "); 744 pw.print(s.mDtdx); pw.print(", "); pw.print(s.mDsdy); 745 pw.print(", "); pw.print(s.mDtdy); pw.println(")"); 746 } 747 } 748 } 749 750 @Override 751 public String toString() { 752 return "Surface " + Integer.toHexString(System.identityHashCode(this)) + " " 753 + mName + " (" + mLayerStack + "): shown=" + mShown + " layer=" + mLayer 754 + " alpha=" + mSurfaceTraceAlpha + " " + mPosition.x + "," + mPosition.y 755 + " " + mSize.x + "x" + mSize.y 756 + " crop=" + mWindowCrop.toShortString() 757 + " opaque=" + mIsOpaque 758 + " (" + mDsdx + "," + mDtdx + "," + mDsdy + "," + mDtdy + ")"; 759 } 760 } 761 762 class SurfaceControlWithBackground extends SurfaceControl { 763 private SurfaceControl mBackgroundControl; 764 private boolean mOpaque = true; 765 private boolean mAppForcedInvisible = false; 766 private AppWindowToken mAppToken; 767 public boolean mVisible = false; 768 public int mLayer = -1; 769 770 public SurfaceControlWithBackground(SurfaceSession s, 771 String name, int w, int h, int format, int flags, 772 AppWindowToken token) 773 throws OutOfResourcesException { 774 super(s, name, w, h, format, flags); 775 mBackgroundControl = new SurfaceControl(s, name, w, h, 776 PixelFormat.OPAQUE, flags | SurfaceControl.FX_SURFACE_DIM); 777 mOpaque = (flags & SurfaceControl.OPAQUE) != 0; 778 mAppToken = token; 779 780 mAppToken.addSurfaceViewBackground(this); 781 } 782 783 @Override 784 public void setAlpha(float alpha) { 785 super.setAlpha(alpha); 786 mBackgroundControl.setAlpha(alpha); 787 } 788 789 @Override 790 public void setLayer(int zorder) { 791 super.setLayer(zorder); 792 mBackgroundControl.setLayer(zorder - 1); 793 if (mLayer != zorder) { 794 mLayer = zorder; 795 mAppToken.updateSurfaceViewBackgroundVisibilities(); 796 } 797 } 798 799 @Override 800 public void setPosition(float x, float y) { 801 super.setPosition(x, y); 802 mBackgroundControl.setPosition(x, y); 803 } 804 805 @Override 806 public void setSize(int w, int h) { 807 super.setSize(w, h); 808 mBackgroundControl.setSize(w, h); 809 } 810 811 @Override 812 public void setWindowCrop(Rect crop) { 813 super.setWindowCrop(crop); 814 mBackgroundControl.setWindowCrop(crop); 815 } 816 817 @Override 818 public void setFinalCrop(Rect crop) { 819 super.setFinalCrop(crop); 820 mBackgroundControl.setFinalCrop(crop); 821 } 822 823 @Override 824 public void setLayerStack(int layerStack) { 825 super.setLayerStack(layerStack); 826 mBackgroundControl.setLayerStack(layerStack); 827 } 828 829 @Override 830 public void setOpaque(boolean isOpaque) { 831 super.setOpaque(isOpaque); 832 mOpaque = isOpaque; 833 updateBackgroundVisibility(mAppForcedInvisible); 834 } 835 836 @Override 837 public void setSecure(boolean isSecure) { 838 super.setSecure(isSecure); 839 } 840 841 @Override 842 public void setMatrix(float dsdx, float dtdx, float dsdy, float dtdy) { 843 super.setMatrix(dsdx, dtdx, dsdy, dtdy); 844 mBackgroundControl.setMatrix(dsdx, dtdx, dsdy, dtdy); 845 } 846 847 @Override 848 public void hide() { 849 super.hide(); 850 if (mVisible) { 851 mVisible = false; 852 mAppToken.updateSurfaceViewBackgroundVisibilities(); 853 } 854 } 855 856 @Override 857 public void show() { 858 super.show(); 859 if (!mVisible) { 860 mVisible = true; 861 mAppToken.updateSurfaceViewBackgroundVisibilities(); 862 } 863 } 864 865 @Override 866 public void destroy() { 867 super.destroy(); 868 mBackgroundControl.destroy(); 869 mAppToken.removeSurfaceViewBackground(this); 870 } 871 872 @Override 873 public void release() { 874 super.release(); 875 mBackgroundControl.release(); 876 } 877 878 @Override 879 public void setTransparentRegionHint(Region region) { 880 super.setTransparentRegionHint(region); 881 mBackgroundControl.setTransparentRegionHint(region); 882 } 883 884 @Override 885 public void deferTransactionUntil(IBinder handle, long frame) { 886 super.deferTransactionUntil(handle, frame); 887 mBackgroundControl.deferTransactionUntil(handle, frame); 888 } 889 890 void updateBackgroundVisibility(boolean forcedInvisible) { 891 mAppForcedInvisible = forcedInvisible; 892 if (mOpaque && mVisible && !mAppForcedInvisible) { 893 mBackgroundControl.show(); 894 } else { 895 mBackgroundControl.hide(); 896 } 897 } 898 } 899 } 900
