core/java/android/view/SurfaceView.java

   1 /*
   2  * Copyright (C) 2006 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 android.view;
  18
  19 import com.android.internal.view.BaseIWindow;
  20
  21 import android.content.Context;
  22 import android.content.res.Configuration;
  23 import android.content.res.CompatibilityInfo.Translator;
  24 import android.graphics.Canvas;
  25 import android.graphics.PixelFormat;
  26 import android.graphics.PorterDuff;
  27 import android.graphics.Rect;
  28 import android.graphics.Region;
  29 import android.os.Handler;
  30 import android.os.Message;
  31 import android.os.RemoteException;
  32 import android.os.SystemClock;
  33 import android.os.ParcelFileDescriptor;
  34 import android.util.AttributeSet;
  35 import android.util.Log;
  36
  37 import java.lang.ref.WeakReference;
  38 import java.util.ArrayList;
  39 import java.util.concurrent.locks.ReentrantLock;
  40
  41 /**
  42  * Provides a dedicated drawing surface embedded inside of a view hierarchy.
  43  * You can control the format of this surface and, if you like, its size; the
  44  * SurfaceView takes care of placing the surface at the correct location on the
  45  * screen
  46  *
  47  * <p>The surface is Z ordered so that it is behind the window holding its
  48  * SurfaceView; the SurfaceView punches a hole in its window to allow its
  49  * surface to be displayed. The view hierarchy will take care of correctly
  50  * compositing with the Surface any siblings of the SurfaceView that would
  51  * normally appear on top of it. This can be used to place overlays such as
  52  * buttons on top of the Surface, though note however that it can have an
  53  * impact on performance since a full alpha-blended composite will be performed
  54  * each time the Surface changes.
  55  *
  56  * <p> The transparent region that makes the surface visible is based on the
  57  * layout positions in the view hierarchy. If the post-layout transform
  58  * properties are used to draw a sibling view on top of the SurfaceView, the
  59  * view may not be properly composited with the surface.
  60  *
  61  * <p>Access to the underlying surface is provided via the SurfaceHolder interface,
  62  * which can be retrieved by calling {@link #getHolder}.
  63  *
  64  * <p>The Surface will be created for you while the SurfaceView's window is
  65  * visible; you should implement {@link SurfaceHolder.Callback#surfaceCreated}
  66  * and {@link SurfaceHolder.Callback#surfaceDestroyed} to discover when the
  67  * Surface is created and destroyed as the window is shown and hidden.
  68  *
  69  * <p>One of the purposes of this class is to provide a surface in which a
  70  * secondary thread can render into the screen. If you are going to use it
  71  * this way, you need to be aware of some threading semantics:
  72  *
  73  * <ul>
  74  * <li> All SurfaceView and
  75  * {@link SurfaceHolder.Callback SurfaceHolder.Callback} methods will be called
  76  * from the thread running the SurfaceView's window (typically the main thread
  77  * of the application). They thus need to correctly synchronize with any
  78  * state that is also touched by the drawing thread.
  79  * <li> You must ensure that the drawing thread only touches the underlying
  80  * Surface while it is valid -- between
  81  * {@link SurfaceHolder.Callback#surfaceCreated SurfaceHolder.Callback.surfaceCreated()}
  82  * and
  83  * {@link SurfaceHolder.Callback#surfaceDestroyed SurfaceHolder.Callback.surfaceDestroyed()}.
  84  * </ul>
  85  *
  86  * <p class="note"><strong>Note:</strong> Starting in platform version
  87  * {@link android.os.Build.VERSION_CODES#N}, SurfaceView's window position is
  88  * updated synchronously with other View rendering. This means that translating
  89  * and scaling a SurfaceView on screen will not cause rendering artifacts. Such
  90  * artifacts may occur on previous versions of the platform when its window is
  91  * positioned asynchronously.</p>
  92  */
  93 public class SurfaceView extends View {
  94     static private final String TAG = "SurfaceView";
  95     static private final boolean DEBUG = false;
  96
  97     final ArrayList<SurfaceHolder.Callback> mCallbacks
  98             = new ArrayList<SurfaceHolder.Callback>();
  99
 100     final int[] mLocation = new int[2];
 101
 102     final ReentrantLock mSurfaceLock = new ReentrantLock();
 103     final Surface mSurface = new Surface();       // Current surface in use
 104     final Surface mNewSurface = new Surface();    // New surface we are switching to
 105     boolean mDrawingStopped = true;
 106
 107     final WindowManager.LayoutParams mLayout
 108             = new WindowManager.LayoutParams();
 109     IWindowSession mSession;
 110     MyWindow mWindow;
 111     final Rect mVisibleInsets = new Rect();
 112     final Rect mWinFrame = new Rect();
 113     final Rect mOverscanInsets = new Rect();
 114     final Rect mContentInsets = new Rect();
 115     final Rect mStableInsets = new Rect();
 116     final Rect mOutsets = new Rect();
 117     final Rect mBackdropFrame = new Rect();
 118     final Configuration mConfiguration = new Configuration();
 119
 120     static final int KEEP_SCREEN_ON_MSG = 1;
 121     static final int GET_NEW_SURFACE_MSG = 2;
 122     static final int UPDATE_WINDOW_MSG = 3;
 123
 124     int mWindowType = WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
 125
 126     boolean mIsCreating = false;
 127     private volatile boolean mRtHandlingPositionUpdates = false;
 128
 129     final Handler mHandler = new Handler() {
 130         @Override
 131         public void handleMessage(Message msg) {
 132             switch (msg.what) {
 133                 case KEEP_SCREEN_ON_MSG: {
 134                     setKeepScreenOn(msg.arg1 != 0);
 135                 } break;
 136                 case GET_NEW_SURFACE_MSG: {
 137                     handleGetNewSurface();
 138                 } break;
 139                 case UPDATE_WINDOW_MSG: {
 140                     updateWindow(false, false);
 141                 } break;
 142             }
 143         }
 144     };
 145
 146     private final ViewTreeObserver.OnScrollChangedListener mScrollChangedListener
 147             = new ViewTreeObserver.OnScrollChangedListener() {
 148                     @Override
 149                     public void onScrollChanged() {
 150                         updateWindow(false, false);
 151                     }
 152             };
 153
 154     private final ViewTreeObserver.OnPreDrawListener mDrawListener =
 155             new ViewTreeObserver.OnPreDrawListener() {
 156                 @Override
 157                 public boolean onPreDraw() {
 158                     // reposition ourselves where the surface is
 159                     mHaveFrame = getWidth() > 0 && getHeight() > 0;
 160                     updateWindow(false, false);
 161                     return true;
 162                 }
 163             };
 164
 165     boolean mRequestedVisible = false;
 166     boolean mWindowVisibility = false;
 167     boolean mViewVisibility = false;
 168     int mRequestedWidth = -1;
 169     int mRequestedHeight = -1;
 170     /* Set SurfaceView's format to 565 by default to maintain backward
 171      * compatibility with applications assuming this format.
 172      */
 173     int mRequestedFormat = PixelFormat.RGB_565;
 174
 175     boolean mHaveFrame = false;
 176     boolean mSurfaceCreated = false;
 177     long mLastLockTime = 0;
 178
 179     boolean mVisible = false;
 180     int mWindowSpaceLeft = -1;
 181     int mWindowSpaceTop = -1;
 182     int mWindowSpaceWidth = -1;
 183     int mWindowSpaceHeight = -1;
 184     int mFormat = -1;
 185     final Rect mSurfaceFrame = new Rect();
 186     int mLastSurfaceWidth = -1, mLastSurfaceHeight = -1;
 187     boolean mUpdateWindowNeeded;
 188     boolean mReportDrawNeeded;
 189     private Translator mTranslator;
 190     private int mWindowInsetLeft;
 191     private int mWindowInsetTop;
 192
 193     private boolean mGlobalListenersAdded;
 194
 195     public SurfaceView(Context context) {
 196         super(context);
 197         init();
 198     }
 199
 200     public SurfaceView(Context context, AttributeSet attrs) {
 201         super(context, attrs);
 202         init();
 203     }
 204
 205     public SurfaceView(Context context, AttributeSet attrs, int defStyleAttr) {
 206         super(context, attrs, defStyleAttr);
 207         init();
 208     }
 209
 210     public SurfaceView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
 211         super(context, attrs, defStyleAttr, defStyleRes);
 212         init();
 213     }
 214
 215     private void init() {
 216         setWillNotDraw(true);
 217     }
 218
 219     /**
 220      * Return the SurfaceHolder providing access and control over this
 221      * SurfaceView's underlying surface.
 222      *
 223      * @return SurfaceHolder The holder of the surface.
 224      */
 225     public SurfaceHolder getHolder() {
 226         return mSurfaceHolder;
 227     }
 228
 229     @Override
 230     protected void onAttachedToWindow() {
 231         super.onAttachedToWindow();
 232         mParent.requestTransparentRegion(this);
 233         mSession = getWindowSession();
 234         mLayout.token = getWindowToken();
 235         mLayout.setTitle("SurfaceView - " + getViewRootImpl().getTitle());
 236         mViewVisibility = getVisibility() == VISIBLE;
 237
 238         if (!mGlobalListenersAdded) {
 239             ViewTreeObserver observer = getViewTreeObserver();
 240             observer.addOnScrollChangedListener(mScrollChangedListener);
 241             observer.addOnPreDrawListener(mDrawListener);
 242             mGlobalListenersAdded = true;
 243         }
 244     }
 245
 246     @Override
 247     protected void onWindowVisibilityChanged(int visibility) {
 248         super.onWindowVisibilityChanged(visibility);
 249         mWindowVisibility = visibility == VISIBLE;
 250         mRequestedVisible = mWindowVisibility && mViewVisibility;
 251         updateWindow(false, false);
 252     }
 253
 254     @Override
 255     public void setVisibility(int visibility) {
 256         super.setVisibility(visibility);
 257         mViewVisibility = visibility == VISIBLE;
 258         boolean newRequestedVisible = mWindowVisibility && mViewVisibility;
 259         if (newRequestedVisible != mRequestedVisible) {
 260             // our base class (View) invalidates the layout only when
 261             // we go from/to the GONE state. However, SurfaceView needs
 262             // to request a re-layout when the visibility changes at all.
 263             // This is needed because the transparent region is computed
 264             // as part of the layout phase, and it changes (obviously) when
 265             // the visibility changes.
 266             requestLayout();
 267         }
 268         mRequestedVisible = newRequestedVisible;
 269         updateWindow(false, false);
 270     }
 271
 272     @Override
 273     protected void onDetachedFromWindow() {
 274         if (mGlobalListenersAdded) {
 275             ViewTreeObserver observer = getViewTreeObserver();
 276             observer.removeOnScrollChangedListener(mScrollChangedListener);
 277             observer.removeOnPreDrawListener(mDrawListener);
 278             mGlobalListenersAdded = false;
 279         }
 280
 281         mRequestedVisible = false;
 282         updateWindow(false, false);
 283         mHaveFrame = false;
 284         if (mWindow != null) {
 285             try {
 286                 mSession.remove(mWindow);
 287             } catch (RemoteException ex) {
 288                 // Not much we can do here...
 289             }
 290             mWindow = null;
 291         }
 292         mSession = null;
 293         mLayout.token = null;
 294
 295         super.onDetachedFromWindow();
 296     }
 297
 298     @Override
 299     protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
 300         int width = mRequestedWidth >= 0
 301                 ? resolveSizeAndState(mRequestedWidth, widthMeasureSpec, 0)
 302                 : getDefaultSize(0, widthMeasureSpec);
 303         int height = mRequestedHeight >= 0
 304                 ? resolveSizeAndState(mRequestedHeight, heightMeasureSpec, 0)
 305                 : getDefaultSize(0, heightMeasureSpec);
 306         setMeasuredDimension(width, height);
 307     }
 308
 309     /** @hide */
 310     @Override
 311     protected boolean setFrame(int left, int top, int right, int bottom) {
 312         boolean result = super.setFrame(left, top, right, bottom);
 313         updateWindow(false, false);
 314         return result;
 315     }
 316
 317     @Override
 318     public boolean gatherTransparentRegion(Region region) {
 319         if (mWindowType == WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) {
 320             return super.gatherTransparentRegion(region);
 321         }
 322
 323         boolean opaque = true;
 324         if ((mPrivateFlags & PFLAG_SKIP_DRAW) == 0) {
 325             // this view draws, remove it from the transparent region
 326             opaque = super.gatherTransparentRegion(region);
 327         } else if (region != null) {
 328             int w = getWidth();
 329             int h = getHeight();
 330             if (w>0 && h>0) {
 331                 getLocationInWindow(mLocation);
 332                 // otherwise, punch a hole in the whole hierarchy
 333                 int l = mLocation[0];
 334                 int t = mLocation[1];
 335                 region.op(l, t, l+w, t+h, Region.Op.UNION);
 336             }
 337         }
 338         if (PixelFormat.formatHasAlpha(mRequestedFormat)) {
 339             opaque = false;
 340         }
 341         return opaque;
 342     }
 343
 344     @Override
 345     public void draw(Canvas canvas) {
 346         if (mWindowType != WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) {
 347             // draw() is not called when SKIP_DRAW is set
 348             if ((mPrivateFlags & PFLAG_SKIP_DRAW) == 0) {
 349                 // punch a whole in the view-hierarchy below us
 350                 canvas.drawColor(0, PorterDuff.Mode.CLEAR);
 351             }
 352         }
 353         super.draw(canvas);
 354     }
 355
 356     @Override
 357     protected void dispatchDraw(Canvas canvas) {
 358         if (mWindowType != WindowManager.LayoutParams.TYPE_APPLICATION_PANEL) {
 359             // if SKIP_DRAW is cleared, draw() has already punched a hole
 360             if ((mPrivateFlags & PFLAG_SKIP_DRAW) == PFLAG_SKIP_DRAW) {
 361                 // punch a whole in the view-hierarchy below us
 362                 canvas.drawColor(0, PorterDuff.Mode.CLEAR);
 363             }
 364         }
 365         super.dispatchDraw(canvas);
 366     }
 367
 368     /**
 369      * Control whether the surface view's surface is placed on top of another
 370      * regular surface view in the window (but still behind the window itself).
 371      * This is typically used to place overlays on top of an underlying media
 372      * surface view.
 373      *
 374      * <p>Note that this must be set before the surface view's containing
 375      * window is attached to the window manager.
 376      *
 377      * <p>Calling this overrides any previous call to {@link #setZOrderOnTop}.
 378      */
 379     public void setZOrderMediaOverlay(boolean isMediaOverlay) {
 380         mWindowType = isMediaOverlay
 381                 ? WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA_OVERLAY
 382                 : WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
 383     }
 384
 385     /**
 386      * Control whether the surface view's surface is placed on top of its
 387      * window.  Normally it is placed behind the window, to allow it to
 388      * (for the most part) appear to composite with the views in the
 389      * hierarchy.  By setting this, you cause it to be placed above the
 390      * window.  This means that none of the contents of the window this
 391      * SurfaceView is in will be visible on top of its surface.
 392      *
 393      * <p>Note that this must be set before the surface view's containing
 394      * window is attached to the window manager.
 395      *
 396      * <p>Calling this overrides any previous call to {@link #setZOrderMediaOverlay}.
 397      */
 398     public void setZOrderOnTop(boolean onTop) {
 399         if (onTop) {
 400             mWindowType = WindowManager.LayoutParams.TYPE_APPLICATION_PANEL;
 401             // ensures the surface is placed below the IME
 402             mLayout.flags |= WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
 403         } else {
 404             mWindowType = WindowManager.LayoutParams.TYPE_APPLICATION_MEDIA;
 405             mLayout.flags &= ~WindowManager.LayoutParams.FLAG_ALT_FOCUSABLE_IM;
 406         }
 407     }
 408
 409     /**
 410      * Control whether the surface view's content should be treated as secure,
 411      * preventing it from appearing in screenshots or from being viewed on
 412      * non-secure displays.
 413      *
 414      * <p>Note that this must be set before the surface view's containing
 415      * window is attached to the window manager.
 416      *
 417      * <p>See {@link android.view.Display#FLAG_SECURE} for details.
 418      *
 419      * @param isSecure True if the surface view is secure.
 420      */
 421     public void setSecure(boolean isSecure) {
 422         if (isSecure) {
 423             mLayout.flags |= WindowManager.LayoutParams.FLAG_SECURE;
 424         } else {
 425             mLayout.flags &= ~WindowManager.LayoutParams.FLAG_SECURE;
 426         }
 427     }
 428
 429     /**
 430      * Hack to allow special layering of windows.  The type is one of the
 431      * types in WindowManager.LayoutParams.  This is a hack so:
 432      * @hide
 433      */
 434     public void setWindowType(int type) {
 435         mWindowType = type;
 436     }
 437
 438     /** @hide */
 439     protected void updateWindow(boolean force, boolean redrawNeeded) {
 440         if (!mHaveFrame) {
 441             return;
 442         }
 443         ViewRootImpl viewRoot = getViewRootImpl();
 444         if (viewRoot != null) {
 445             mTranslator = viewRoot.mTranslator;
 446         }
 447
 448         if (mTranslator != null) {
 449             mSurface.setCompatibilityTranslator(mTranslator);
 450         }
 451
 452         int myWidth = mRequestedWidth;
 453         if (myWidth <= 0) myWidth = getWidth();
 454         int myHeight = mRequestedHeight;
 455         if (myHeight <= 0) myHeight = getHeight();
 456
 457         final boolean creating = mWindow == null;
 458         final boolean formatChanged = mFormat != mRequestedFormat;
 459         final boolean sizeChanged = mWindowSpaceWidth != myWidth || mWindowSpaceHeight != myHeight;
 460         final boolean visibleChanged = mVisible != mRequestedVisible;
 461         final boolean layoutSizeChanged = getWidth() != mLayout.width
 462                 || getHeight() != mLayout.height;
 463
 464         if (force || creating || formatChanged || sizeChanged || visibleChanged
 465             || mUpdateWindowNeeded || mReportDrawNeeded || redrawNeeded) {
 466             getLocationInWindow(mLocation);
 467
 468             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 469                     + "Changes: creating=" + creating
 470                     + " format=" + formatChanged + " size=" + sizeChanged
 471                     + " visible=" + visibleChanged
 472                     + " left=" + (mWindowSpaceLeft != mLocation[0])
 473                     + " top=" + (mWindowSpaceTop != mLocation[1]));
 474
 475             try {
 476                 final boolean visible = mVisible = mRequestedVisible;
 477                 mWindowSpaceLeft = mLocation[0];
 478                 mWindowSpaceTop = mLocation[1];
 479                 mWindowSpaceWidth = myWidth;
 480                 mWindowSpaceHeight = myHeight;
 481                 mFormat = mRequestedFormat;
 482
 483                 // Scaling/Translate window's layout here because mLayout is not used elsewhere.
 484
 485                 // Places the window relative
 486                 mLayout.x = mWindowSpaceLeft;
 487                 mLayout.y = mWindowSpaceTop;
 488                 mLayout.width = getWidth();
 489                 mLayout.height = getHeight();
 490                 if (mTranslator != null) {
 491                     mTranslator.translateLayoutParamsInAppWindowToScreen(mLayout);
 492                 }
 493
 494                 mLayout.format = mRequestedFormat;
 495                 mLayout.flags |=WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
 496                               | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
 497                               | WindowManager.LayoutParams.FLAG_LAYOUT_NO_LIMITS
 498                               | WindowManager.LayoutParams.FLAG_SCALED
 499                               | WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE
 500                               | WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE
 501                               ;
 502                 if (!creating && !force && !mUpdateWindowNeeded && !sizeChanged) {
 503                     mLayout.privateFlags |=
 504                             WindowManager.LayoutParams.PRIVATE_FLAG_PRESERVE_GEOMETRY;
 505                 } else {
 506                     mLayout.privateFlags &=
 507                             ~WindowManager.LayoutParams.PRIVATE_FLAG_PRESERVE_GEOMETRY;
 508                 }
 509
 510                 if (!getContext().getResources().getCompatibilityInfo().supportsScreen()) {
 511                     mLayout.privateFlags |=
 512                             WindowManager.LayoutParams.PRIVATE_FLAG_COMPATIBLE_WINDOW;
 513                 }
 514                 mLayout.privateFlags |= WindowManager.LayoutParams.PRIVATE_FLAG_NO_MOVE_ANIMATION
 515                     | WindowManager.LayoutParams.PRIVATE_FLAG_LAYOUT_CHILD_WINDOW_IN_PARENT_FRAME;
 516
 517                 if (mWindow == null) {
 518                     Display display = getDisplay();
 519                     mWindow = new MyWindow(this);
 520                     mLayout.type = mWindowType;
 521                     mLayout.gravity = Gravity.START|Gravity.TOP;
 522                     mSession.addToDisplayWithoutInputChannel(mWindow, mWindow.mSeq, mLayout,
 523                             mVisible ? VISIBLE : GONE, display.getDisplayId(), mContentInsets,
 524                             mStableInsets);
 525                 }
 526
 527                 boolean realSizeChanged;
 528                 boolean reportDrawNeeded;
 529
 530                 int relayoutResult;
 531
 532                 mSurfaceLock.lock();
 533                 try {
 534                     mUpdateWindowNeeded = false;
 535                     reportDrawNeeded = mReportDrawNeeded;
 536                     mReportDrawNeeded = false;
 537                     mDrawingStopped = !visible;
 538
 539                     if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 540                             + "Cur surface: " + mSurface);
 541
 542                     relayoutResult = mSession.relayout(
 543                         mWindow, mWindow.mSeq, mLayout, mWindowSpaceWidth, mWindowSpaceHeight,
 544                             visible ? VISIBLE : GONE,
 545                             WindowManagerGlobal.RELAYOUT_DEFER_SURFACE_DESTROY,
 546                             mWinFrame, mOverscanInsets, mContentInsets,
 547                             mVisibleInsets, mStableInsets, mOutsets, mBackdropFrame,
 548                             mConfiguration, mNewSurface);
 549                     if ((relayoutResult & WindowManagerGlobal.RELAYOUT_RES_FIRST_TIME) != 0) {
 550                         reportDrawNeeded = true;
 551                     }
 552
 553                     if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 554                             + "New surface: " + mNewSurface
 555                             + ", vis=" + visible + ", frame=" + mWinFrame);
 556
 557                     mSurfaceFrame.left = 0;
 558                     mSurfaceFrame.top = 0;
 559                     if (mTranslator == null) {
 560                         mSurfaceFrame.right = mWinFrame.width();
 561                         mSurfaceFrame.bottom = mWinFrame.height();
 562                     } else {
 563                         float appInvertedScale = mTranslator.applicationInvertedScale;
 564                         mSurfaceFrame.right = (int) (mWinFrame.width() * appInvertedScale + 0.5f);
 565                         mSurfaceFrame.bottom = (int) (mWinFrame.height() * appInvertedScale + 0.5f);
 566                     }
 567
 568                     final int surfaceWidth = mSurfaceFrame.right;
 569                     final int surfaceHeight = mSurfaceFrame.bottom;
 570                     realSizeChanged = mLastSurfaceWidth != surfaceWidth
 571                             || mLastSurfaceHeight != surfaceHeight;
 572                     mLastSurfaceWidth = surfaceWidth;
 573                     mLastSurfaceHeight = surfaceHeight;
 574                 } finally {
 575                     mSurfaceLock.unlock();
 576                 }
 577
 578                 try {
 579                     redrawNeeded |= creating | reportDrawNeeded;
 580
 581                     SurfaceHolder.Callback callbacks[] = null;
 582
 583                     final boolean surfaceChanged = (relayoutResult
 584                             & WindowManagerGlobal.RELAYOUT_RES_SURFACE_CHANGED) != 0;
 585                     if (mSurfaceCreated && (surfaceChanged || (!visible && visibleChanged))) {
 586                         mSurfaceCreated = false;
 587                         if (mSurface.isValid()) {
 588                             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 589                                     + "visibleChanged -- surfaceDestroyed");
 590                             callbacks = getSurfaceCallbacks();
 591                             for (SurfaceHolder.Callback c : callbacks) {
 592                                 c.surfaceDestroyed(mSurfaceHolder);
 593                             }
 594                         }
 595                     }
 596
 597                     mSurface.transferFrom(mNewSurface);
 598                     if (visible && mSurface.isValid()) {
 599                         if (!mSurfaceCreated && (surfaceChanged || visibleChanged)) {
 600                             mSurfaceCreated = true;
 601                             mIsCreating = true;
 602                             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 603                                     + "visibleChanged -- surfaceCreated");
 604                             if (callbacks == null) {
 605                                 callbacks = getSurfaceCallbacks();
 606                             }
 607                             for (SurfaceHolder.Callback c : callbacks) {
 608                                 c.surfaceCreated(mSurfaceHolder);
 609                             }
 610                         }
 611                         if (creating || formatChanged || sizeChanged
 612                                 || visibleChanged || realSizeChanged) {
 613                             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 614                                     + "surfaceChanged -- format=" + mFormat
 615                                     + " w=" + myWidth + " h=" + myHeight);
 616                             if (callbacks == null) {
 617                                 callbacks = getSurfaceCallbacks();
 618                             }
 619                             for (SurfaceHolder.Callback c : callbacks) {
 620                                 c.surfaceChanged(mSurfaceHolder, mFormat, myWidth, myHeight);
 621                             }
 622                         }
 623                         if (redrawNeeded) {
 624                             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 625                                     + "surfaceRedrawNeeded");
 626                             if (callbacks == null) {
 627                                 callbacks = getSurfaceCallbacks();
 628                             }
 629                             for (SurfaceHolder.Callback c : callbacks) {
 630                                 if (c instanceof SurfaceHolder.Callback2) {
 631                                     ((SurfaceHolder.Callback2)c).surfaceRedrawNeeded(
 632                                             mSurfaceHolder);
 633                                 }
 634                             }
 635                         }
 636                     }
 637                 } finally {
 638                     mIsCreating = false;
 639                     if (redrawNeeded) {
 640                         if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " "
 641                                 + "finishedDrawing");
 642                         mSession.finishDrawing(mWindow);
 643                     }
 644                     mSession.performDeferredDestroy(mWindow);
 645                 }
 646             } catch (RemoteException ex) {
 647                 Log.e(TAG, "Exception from relayout", ex);
 648             }
 649             if (DEBUG) Log.v(
 650                 TAG, "Layout: x=" + mLayout.x + " y=" + mLayout.y +
 651                 " w=" + mLayout.width + " h=" + mLayout.height +
 652                 ", frame=" + mSurfaceFrame);
 653         } else {
 654             // Calculate the window position in case RT loses the window
 655             // and we need to fallback to a UI-thread driven position update
 656             getLocationInWindow(mLocation);
 657             final boolean positionChanged = mWindowSpaceLeft != mLocation[0]
 658                     || mWindowSpaceTop != mLocation[1];
 659             if (positionChanged || layoutSizeChanged) { // Only the position has changed
 660                 mWindowSpaceLeft = mLocation[0];
 661                 mWindowSpaceTop = mLocation[1];
 662                 // For our size changed check, we keep mLayout.width and mLayout.height
 663                 // in view local space.
 664                 mLocation[0] = mLayout.width = getWidth();
 665                 mLocation[1] = mLayout.height = getHeight();
 666
 667                 transformFromViewToWindowSpace(mLocation);
 668
 669                 mWinFrame.set(mWindowSpaceLeft, mWindowSpaceTop,
 670                         mLocation[0], mLocation[1]);
 671
 672                 if (mTranslator != null) {
 673                     mTranslator.translateRectInAppWindowToScreen(mWinFrame);
 674                 }
 675
 676                 if (!isHardwareAccelerated() || !mRtHandlingPositionUpdates) {
 677                     try {
 678                         if (DEBUG) Log.d(TAG, String.format("%d updateWindowPosition UI, " +
 679                                 "postion = [%d, %d, %d, %d]", System.identityHashCode(this),
 680                                 mWinFrame.left, mWinFrame.top,
 681                                 mWinFrame.right, mWinFrame.bottom));
 682                         mSession.repositionChild(mWindow, mWinFrame.left, mWinFrame.top,
 683                                 mWinFrame.right, mWinFrame.bottom, -1, mWinFrame);
 684                     } catch (RemoteException ex) {
 685                         Log.e(TAG, "Exception from relayout", ex);
 686                     }
 687                 }
 688             }
 689         }
 690     }
 691
 692     private Rect mRTLastReportedPosition = new Rect();
 693
 694     /**
 695      * Called by native on RenderThread to update the window position
 696      * @hide
 697      */
 698     public final void updateWindowPositionRT(long frameNumber,
 699             int left, int top, int right, int bottom) {
 700         IWindowSession session = mSession;
 701         MyWindow window = mWindow;
 702         if (session == null || window == null) {
 703             // Guess we got detached, that sucks
 704             return;
 705         }
 706         // TODO: This is teensy bit racey in that a brand new SurfaceView moving on
 707         // its 2nd frame if RenderThread is running slowly could potentially see
 708         // this as false, enter the branch, get pre-empted, then this comes along
 709         // and reports a new position, then the UI thread resumes and reports
 710         // its position. This could therefore be de-sync'd in that interval, but
 711         // the synchronization would violate the rule that RT must never block
 712         // on the UI thread which would open up potential deadlocks. The risk of
 713         // a single-frame desync is therefore preferable for now.
 714         mRtHandlingPositionUpdates = true;
 715         if (mRTLastReportedPosition.left == left
 716                 && mRTLastReportedPosition.top == top
 717                 && mRTLastReportedPosition.right == right
 718                 && mRTLastReportedPosition.bottom == bottom) {
 719             return;
 720         }
 721         try {
 722             if (DEBUG) {
 723                 Log.d(TAG, String.format("%d updateWindowPosition RT, frameNr = %d, " +
 724                         "postion = [%d, %d, %d, %d]", System.identityHashCode(this),
 725                         frameNumber, left, top, right, bottom));
 726             }
 727             // Just using mRTLastReportedPosition as a dummy rect here
 728             session.repositionChild(window, left, top, right, bottom,
 729                     frameNumber,
 730                     mRTLastReportedPosition);
 731             // Now overwrite mRTLastReportedPosition with our values
 732             mRTLastReportedPosition.set(left, top, right, bottom);
 733         } catch (RemoteException ex) {
 734             Log.e(TAG, "Exception from repositionChild", ex);
 735         }
 736     }
 737
 738     /**
 739      * Called by native on RenderThread to notify that the window is no longer in the
 740      * draw tree
 741      * @hide
 742      */
 743     public final void windowPositionLostRT(long frameNumber) {
 744         if (DEBUG) {
 745             Log.d(TAG, String.format("%d windowPositionLostRT RT, frameNr = %d",
 746                     System.identityHashCode(this), frameNumber));
 747         }
 748         IWindowSession session = mSession;
 749         MyWindow window = mWindow;
 750         if (session == null || window == null) {
 751             // We got detached prior to receiving this, abort
 752             return;
 753         }
 754         if (mRtHandlingPositionUpdates) {
 755             mRtHandlingPositionUpdates = false;
 756             // This callback will happen while the UI thread is blocked, so we can
 757             // safely access other member variables at this time.
 758             // So do what the UI thread would have done if RT wasn't handling position
 759             // updates.
 760             if (!mWinFrame.isEmpty() && !mWinFrame.equals(mRTLastReportedPosition)) {
 761                 try {
 762                     if (DEBUG) Log.d(TAG, String.format("%d updateWindowPosition, " +
 763                             "postion = [%d, %d, %d, %d]", System.identityHashCode(this),
 764                             mWinFrame.left, mWinFrame.top,
 765                             mWinFrame.right, mWinFrame.bottom));
 766                     session.repositionChild(window, mWinFrame.left, mWinFrame.top,
 767                             mWinFrame.right, mWinFrame.bottom, frameNumber, mWinFrame);
 768                 } catch (RemoteException ex) {
 769                     Log.e(TAG, "Exception from relayout", ex);
 770                 }
 771             }
 772             mRTLastReportedPosition.setEmpty();
 773         }
 774     }
 775
 776     private SurfaceHolder.Callback[] getSurfaceCallbacks() {
 777         SurfaceHolder.Callback callbacks[];
 778         synchronized (mCallbacks) {
 779             callbacks = new SurfaceHolder.Callback[mCallbacks.size()];
 780             mCallbacks.toArray(callbacks);
 781         }
 782         return callbacks;
 783     }
 784
 785     void handleGetNewSurface() {
 786         updateWindow(false, false);
 787     }
 788
 789     /**
 790      * Check to see if the surface has fixed size dimensions or if the surface's
 791      * dimensions are dimensions are dependent on its current layout.
 792      *
 793      * @return true if the surface has dimensions that are fixed in size
 794      * @hide
 795      */
 796     public boolean isFixedSize() {
 797         return (mRequestedWidth != -1 || mRequestedHeight != -1);
 798     }
 799
 800     private static class MyWindow extends BaseIWindow {
 801         private final WeakReference<SurfaceView> mSurfaceView;
 802
 803         public MyWindow(SurfaceView surfaceView) {
 804             mSurfaceView = new WeakReference<SurfaceView>(surfaceView);
 805         }
 806
 807         @Override
 808         public void resized(Rect frame, Rect overscanInsets, Rect contentInsets,
 809                 Rect visibleInsets, Rect stableInsets, Rect outsets, boolean reportDraw,
 810                 Configuration newConfig, Rect backDropRect, boolean forceLayout,
 811                 boolean alwaysConsumeNavBar) {
 812             SurfaceView surfaceView = mSurfaceView.get();
 813             if (surfaceView != null) {
 814                 if (DEBUG) Log.v(TAG, surfaceView + " got resized: w=" + frame.width()
 815                         + " h=" + frame.height() + ", cur w=" + mCurWidth + " h=" + mCurHeight);
 816                 surfaceView.mSurfaceLock.lock();
 817                 try {
 818                     if (reportDraw) {
 819                         surfaceView.mUpdateWindowNeeded = true;
 820                         surfaceView.mReportDrawNeeded = true;
 821                         surfaceView.mHandler.sendEmptyMessage(UPDATE_WINDOW_MSG);
 822                     } else if (surfaceView.mWinFrame.width() != frame.width()
 823                             || surfaceView.mWinFrame.height() != frame.height()
 824                             || forceLayout) {
 825                         surfaceView.mUpdateWindowNeeded = true;
 826                         surfaceView.mHandler.sendEmptyMessage(UPDATE_WINDOW_MSG);
 827                     }
 828                 } finally {
 829                     surfaceView.mSurfaceLock.unlock();
 830                 }
 831             }
 832         }
 833
 834         @Override
 835         public void dispatchAppVisibility(boolean visible) {
 836             // The point of SurfaceView is to let the app control the surface.
 837         }
 838
 839         @Override
 840         public void dispatchGetNewSurface() {
 841             SurfaceView surfaceView = mSurfaceView.get();
 842             if (surfaceView != null) {
 843                 Message msg = surfaceView.mHandler.obtainMessage(GET_NEW_SURFACE_MSG);
 844                 surfaceView.mHandler.sendMessage(msg);
 845             }
 846         }
 847
 848         @Override
 849         public void windowFocusChanged(boolean hasFocus, boolean touchEnabled) {
 850             Log.w("SurfaceView", "Unexpected focus in surface: focus=" + hasFocus + ", touchEnabled=" + touchEnabled);
 851         }
 852
 853         @Override
 854         public void executeCommand(String command, String parameters, ParcelFileDescriptor out) {
 855         }
 856
 857         int mCurWidth = -1;
 858         int mCurHeight = -1;
 859     }
 860
 861     private final SurfaceHolder mSurfaceHolder = new SurfaceHolder() {
 862
 863         private static final String LOG_TAG = "SurfaceHolder";
 864
 865         @Override
 866         public boolean isCreating() {
 867             return mIsCreating;
 868         }
 869
 870         @Override
 871         public void addCallback(Callback callback) {
 872             synchronized (mCallbacks) {
 873                 // This is a linear search, but in practice we'll
 874                 // have only a couple callbacks, so it doesn't matter.
 875                 if (mCallbacks.contains(callback) == false) {
 876                     mCallbacks.add(callback);
 877                 }
 878             }
 879         }
 880
 881         @Override
 882         public void removeCallback(Callback callback) {
 883             synchronized (mCallbacks) {
 884                 mCallbacks.remove(callback);
 885             }
 886         }
 887
 888         @Override
 889         public void setFixedSize(int width, int height) {
 890             if (mRequestedWidth != width || mRequestedHeight != height) {
 891                 mRequestedWidth = width;
 892                 mRequestedHeight = height;
 893                 requestLayout();
 894             }
 895         }
 896
 897         @Override
 898         public void setSizeFromLayout() {
 899             if (mRequestedWidth != -1 || mRequestedHeight != -1) {
 900                 mRequestedWidth = mRequestedHeight = -1;
 901                 requestLayout();
 902             }
 903         }
 904
 905         @Override
 906         public void setFormat(int format) {
 907
 908             // for backward compatibility reason, OPAQUE always
 909             // means 565 for SurfaceView
 910             if (format == PixelFormat.OPAQUE)
 911                 format = PixelFormat.RGB_565;
 912
 913             mRequestedFormat = format;
 914             if (mWindow != null) {
 915                 updateWindow(false, false);
 916             }
 917         }
 918
 919         /**
 920          * @deprecated setType is now ignored.
 921          */
 922         @Override
 923         @Deprecated
 924         public void setType(int type) { }
 925
 926         @Override
 927         public void setKeepScreenOn(boolean screenOn) {
 928             Message msg = mHandler.obtainMessage(KEEP_SCREEN_ON_MSG);
 929             msg.arg1 = screenOn ? 1 : 0;
 930             mHandler.sendMessage(msg);
 931         }
 932
 933         /**
 934          * Gets a {@link Canvas} for drawing into the SurfaceView's Surface
 935          *
 936          * After drawing into the provided {@link Canvas}, the caller must
 937          * invoke {@link #unlockCanvasAndPost} to post the new contents to the surface.
 938          *
 939          * The caller must redraw the entire surface.
 940          * @return A canvas for drawing into the surface.
 941          */
 942         @Override
 943         public Canvas lockCanvas() {
 944             return internalLockCanvas(null);
 945         }
 946
 947         /**
 948          * Gets a {@link Canvas} for drawing into the SurfaceView's Surface
 949          *
 950          * After drawing into the provided {@link Canvas}, the caller must
 951          * invoke {@link #unlockCanvasAndPost} to post the new contents to the surface.
 952          *
 953          * @param inOutDirty A rectangle that represents the dirty region that the caller wants
 954          * to redraw.  This function may choose to expand the dirty rectangle if for example
 955          * the surface has been resized or if the previous contents of the surface were
 956          * not available.  The caller must redraw the entire dirty region as represented
 957          * by the contents of the inOutDirty rectangle upon return from this function.
 958          * The caller may also pass <code>null</code> instead, in the case where the
 959          * entire surface should be redrawn.
 960          * @return A canvas for drawing into the surface.
 961          */
 962         @Override
 963         public Canvas lockCanvas(Rect inOutDirty) {
 964             return internalLockCanvas(inOutDirty);
 965         }
 966
 967         private final Canvas internalLockCanvas(Rect dirty) {
 968             mSurfaceLock.lock();
 969
 970             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " " + "Locking canvas... stopped="
 971                     + mDrawingStopped + ", win=" + mWindow);
 972
 973             Canvas c = null;
 974             if (!mDrawingStopped && mWindow != null) {
 975                 try {
 976                     c = mSurface.lockCanvas(dirty);
 977                 } catch (Exception e) {
 978                     Log.e(LOG_TAG, "Exception locking surface", e);
 979                 }
 980             }
 981
 982             if (DEBUG) Log.i(TAG, System.identityHashCode(this) + " " + "Returned canvas: " + c);
 983             if (c != null) {
 984                 mLastLockTime = SystemClock.uptimeMillis();
 985                 return c;
 986             }
 987
 988             // If the Surface is not ready to be drawn, then return null,
 989             // but throttle calls to this function so it isn't called more
 990             // than every 100ms.
 991             long now = SystemClock.uptimeMillis();
 992             long nextTime = mLastLockTime + 100;
 993             if (nextTime > now) {
 994                 try {
 995                     Thread.sleep(nextTime-now);
 996                 } catch (InterruptedException e) {
 997                 }
 998                 now = SystemClock.uptimeMillis();
 999             }
1000             mLastLockTime = now;
1001             mSurfaceLock.unlock();
1002
1003             return null;
1004         }
1005
1006         /**
1007          * Posts the new contents of the {@link Canvas} to the surface and
1008          * releases the {@link Canvas}.
1009          *
1010          * @param canvas The canvas previously obtained from {@link #lockCanvas}.
1011          */
1012         @Override
1013         public void unlockCanvasAndPost(Canvas canvas) {
1014             mSurface.unlockCanvasAndPost(canvas);
1015             mSurfaceLock.unlock();
1016         }
1017
1018         @Override
1019         public Surface getSurface() {
1020             return mSurface;
1021         }
1022
1023         @Override
1024         public Rect getSurfaceFrame() {
1025             return mSurfaceFrame;
1026         }
1027     };
1028 }