content: /*
   * Copyright (C) 2011 The Android Open Source Project
   *
   * Licensed under the Apache License, Version 2.0 (the "License");
   * you may not use this file except in compliance with the License.
   * You may obtain a copy of the License at
   *
   *      http://www.apache.org/licenses/LICENSE-2.0
   *
   * Unless required by applicable law or agreed to in writing, software
   * distributed under the License is distributed on an "AS IS" BASIS,
   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   * See the License for the specific language governing permissions and
   * limitations under the License.
   */
  
  package android.view;
  
  import android.annotation.Nullable;
  import android.annotation.UnsupportedAppUsage;
  import android.content.Context;
  import android.graphics.Bitmap;
  import android.graphics.Canvas;
  import android.graphics.Matrix;
  import android.graphics.Paint;
  import android.graphics.RecordingCanvas;
  import android.graphics.Rect;
  import android.graphics.SurfaceTexture;
  import android.graphics.drawable.Drawable;
  import android.util.AttributeSet;
  import android.util.Log;
  
  /**
   * <p>A TextureView can be used to display a content stream. Such a content
   * stream can for instance be a video or an OpenGL scene. The content stream
   * can come from the application's process as well as a remote process.</p>
   *
   * <p>TextureView can only be used in a hardware accelerated window. When
   * rendered in software, TextureView will draw nothing.</p>
   *
   * <p>Unlike {@link SurfaceView}, TextureView does not create a separate
   * window but behaves as a regular View. This key difference allows a
   * TextureView to be moved, transformed, animated, etc. For instance, you
   * can make a TextureView semi-translucent by calling
   * <code>myView.setAlpha(0.5f)</code>.</p>
   *
   * <p>Using a TextureView is simple: all you need to do is get its
   * {@link SurfaceTexture}. The {@link SurfaceTexture} can then be used to
   * render content. The following example demonstrates how to render the
   * camera preview into a TextureView:</p>
   *
   * <pre>
   *  public class LiveCameraActivity extends Activity implements TextureView.SurfaceTextureListener {
   *      private Camera mCamera;
   *      private TextureView mTextureView;
   *
   *      protected void onCreate(Bundle savedInstanceState) {
   *          super.onCreate(savedInstanceState);
   *
   *          mTextureView = new TextureView(this);
   *          mTextureView.setSurfaceTextureListener(this);
   *
   *          setContentView(mTextureView);
   *      }
   *
   *      public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
   *          mCamera = Camera.open();
   *
   *          try {
   *              mCamera.setPreviewTexture(surface);
   *              mCamera.startPreview();
   *          } catch (IOException ioe) {
   *              // Something bad happened
   *          }
   *      }
   *
   *      public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
   *          // Ignored, Camera does all the work for us
   *      }
   *
   *      public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
   *          mCamera.stopPreview();
   *          mCamera.release();
   *          return true;
   *      }
   *
   *      public void onSurfaceTextureUpdated(SurfaceTexture surface) {
   *          // Invoked every time there's a new Camera preview frame
   *      }
   *  }
   * </pre>
   *
   * <p>A TextureView's SurfaceTexture can be obtained either by invoking
   * {@link #getSurfaceTexture()} or by using a {@link SurfaceTextureListener}.
   * It is important to know that a SurfaceTexture is available only after the
   * TextureView is attached to a window (and {@link #onAttachedToWindow()} has
   * been invoked.) It is therefore highly recommended you use a listener to
   * be notified when the SurfaceTexture becomes available.</p>
   *
   * <p>It is important to note that only one producer can use the TextureView.
   * For instance, if you use a TextureView to display the camera preview, you
   * cannot use {@link #lockCanvas()} to draw onto the TextureView at the same
   * time.</p>
   *
   * @see SurfaceView
   * @see SurfaceTexture
   */
  public class TextureView extends View {
      private static final String LOG_TAG = "TextureView";
  
      @UnsupportedAppUsage
      private TextureLayer mLayer;
      @UnsupportedAppUsage
      private SurfaceTexture mSurface;
      private SurfaceTextureListener mListener;
      private boolean mHadSurface;
  
      @UnsupportedAppUsage
      private boolean mOpaque = true;
  
      private final Matrix mMatrix = new Matrix();
      private boolean mMatrixChanged;
  
      private final Object[] mLock = new Object[0];
      private boolean mUpdateLayer;
      @UnsupportedAppUsage
      private boolean mUpdateSurface;
  
      private Canvas mCanvas;
      private int mSaveCount;
  
      private final Object[] mNativeWindowLock = new Object[0];
      // Set by native code, do not write!
      @UnsupportedAppUsage
      private long mNativeWindow;
  
      /**
       * Creates a new TextureView.
       *
       * @param context The context to associate this view with.
       */
      public TextureView(Context context) {
          super(context);
      }
  
      /**
       * Creates a new TextureView.
       *
       * @param context The context to associate this view with.
       * @param attrs The attributes of the XML tag that is inflating the view.
       */
      public TextureView(Context context, AttributeSet attrs) {
          super(context, attrs);
      }
  
      /**
       * Creates a new TextureView.
       *
       * @param context The context to associate this view with.
       * @param attrs The attributes of the XML tag that is inflating the view.
       * @param defStyleAttr An attribute in the current theme that contains a
       *        reference to a style resource that supplies default values for
       *        the view. Can be 0 to not look for defaults.
       */
      public TextureView(Context context, AttributeSet attrs, int defStyleAttr) {
          super(context, attrs, defStyleAttr);
      }
  
      /**
       * Creates a new TextureView.
       *
       * @param context The context to associate this view with.
       * @param attrs The attributes of the XML tag that is inflating the view.
       * @param defStyleAttr An attribute in the current theme that contains a
       *        reference to a style resource that supplies default values for
       *        the view. Can be 0 to not look for defaults.
       * @param defStyleRes A resource identifier of a style resource that
       *        supplies default values for the view, used only if
       *        defStyleAttr is 0 or can not be found in the theme. Can be 0
       *        to not look for defaults.
       */
      public TextureView(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
          super(context, attrs, defStyleAttr, defStyleRes);
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public boolean isOpaque() {
          return mOpaque;
      }
  
      /**
       * Indicates whether the content of this TextureView is opaque. The
       * content is assumed to be opaque by default.
       *
       * @param opaque True if the content of this TextureView is opaque,
       *               false otherwise
       */
      public void setOpaque(boolean opaque) {
          if (opaque != mOpaque) {
              mOpaque = opaque;
              if (mLayer != null) {
                  updateLayerAndInvalidate();
              }
          }
      }
  
      @Override
      protected void onAttachedToWindow() {
          super.onAttachedToWindow();
  
          if (!isHardwareAccelerated()) {
              Log.w(LOG_TAG, "A TextureView or a subclass can only be "
                      + "used with hardware acceleration enabled.");
          }
  
          if (mHadSurface) {
              invalidate(true);
              mHadSurface = false;
          }
      }
  
      /** @hide */
      @Override
      @UnsupportedAppUsage
      protected void onDetachedFromWindowInternal() {
          destroyHardwareLayer();
          releaseSurfaceTexture();
          super.onDetachedFromWindowInternal();
      }
  
      /**
       * @hide
       */
      @Override
      @UnsupportedAppUsage
      protected void destroyHardwareResources() {
          super.destroyHardwareResources();
          destroyHardwareLayer();
      }
  
      @UnsupportedAppUsage
      private void destroyHardwareLayer() {
          if (mLayer != null) {
              mLayer.detachSurfaceTexture();
              mLayer.destroy();
              mLayer = null;
              mMatrixChanged = true;
          }
      }
  
      private void releaseSurfaceTexture() {
          if (mSurface != null) {
              boolean shouldRelease = true;
  
              if (mListener != null) {
                  shouldRelease = mListener.onSurfaceTextureDestroyed(mSurface);
              }
  
              synchronized (mNativeWindowLock) {
                  nDestroyNativeWindow();
              }
  
              if (shouldRelease) {
                  mSurface.release();
              }
              mSurface = null;
              mHadSurface = true;
          }
      }
  
      /**
       * The layer type of a TextureView is ignored since a TextureView is always
       * considered to act as a hardware layer. The optional paint supplied to this
       * method will however be taken into account when rendering the content of
       * this TextureView.
       *
       * @param layerType The type of layer to use with this view, must be one of
       *        {@link #LAYER_TYPE_NONE}, {@link #LAYER_TYPE_SOFTWARE} or
       *        {@link #LAYER_TYPE_HARDWARE}
       * @param paint The paint used to compose the layer. This argument is optional
       *        and can be null. It is ignored when the layer type is
       *        {@link #LAYER_TYPE_NONE}
       */
      @Override
      public void setLayerType(int layerType, @Nullable Paint paint) {
          setLayerPaint(paint);
      }
  
      @Override
      public void setLayerPaint(@Nullable Paint paint) {
          if (paint != mLayerPaint) {
              mLayerPaint = paint;
              invalidate();
          }
      }
  
      /**
       * Always returns {@link #LAYER_TYPE_HARDWARE}.
       */
      @Override
      public int getLayerType() {
          return LAYER_TYPE_HARDWARE;
      }
  
      /**
       * Calling this method has no effect.
       */
      @Override
      public void buildLayer() {
      }
  
      @Override
      public void setForeground(Drawable foreground) {
          if (foreground != null && !sTextureViewIgnoresDrawableSetters) {
              throw new UnsupportedOperationException(
                      "TextureView doesn't support displaying a foreground drawable");
          }
      }
  
      @Override
      public void setBackgroundDrawable(Drawable background) {
          if (background != null && !sTextureViewIgnoresDrawableSetters) {
              throw new UnsupportedOperationException(
                      "TextureView doesn't support displaying a background drawable");
          }
      }
  
      /**
       * Subclasses of TextureView cannot do their own rendering
       * with the {@link Canvas} object.
       *
       * @param canvas The Canvas to which the View is rendered.
       */
      @Override
      public final void draw(Canvas canvas) {
          // NOTE: Maintain this carefully (see View#draw)
          mPrivateFlags = (mPrivateFlags & ~PFLAG_DIRTY_MASK) | PFLAG_DRAWN;
  
          /* Simplify drawing to guarantee the layer is the only thing drawn - so e.g. no background,
          scrolling, or fading edges. This guarantees all drawing is in the layer, so drawing
          properties (alpha, layer paint) affect all of the content of a TextureView. */
  
          if (canvas.isHardwareAccelerated()) {
              RecordingCanvas recordingCanvas = (RecordingCanvas) canvas;
  
              TextureLayer layer = getTextureLayer();
              if (layer != null) {
                  applyUpdate();
                  applyTransformMatrix();
  
                  mLayer.setLayerPaint(mLayerPaint); // ensure layer paint is up to date
                  recordingCanvas.drawTextureLayer(layer);
              }
          }
      }
  
      /**
       * Subclasses of TextureView cannot do their own rendering
       * with the {@link Canvas} object.
       *
       * @param canvas The Canvas to which the View is rendered.
       */
      @Override
      protected final void onDraw(Canvas canvas) {
      }
  
      @Override
      protected void onSizeChanged(int w, int h, int oldw, int oldh) {
          super.onSizeChanged(w, h, oldw, oldh);
          if (mSurface != null) {
              mSurface.setDefaultBufferSize(getWidth(), getHeight());
              updateLayer();
              if (mListener != null) {
                  mListener.onSurfaceTextureSizeChanged(mSurface, getWidth(), getHeight());
              }
          }
      }
  
      TextureLayer getTextureLayer() {
          if (mLayer == null) {
              if (mAttachInfo == null || mAttachInfo.mThreadedRenderer == null) {
                  return null;
              }
  
              mLayer = mAttachInfo.mThreadedRenderer.createTextureLayer();
              boolean createNewSurface = (mSurface == null);
              if (createNewSurface) {
                  // Create a new SurfaceTexture for the layer.
                  mSurface = new SurfaceTexture(false);
                  nCreateNativeWindow(mSurface);
              }
              mLayer.setSurfaceTexture(mSurface);
              mSurface.setDefaultBufferSize(getWidth(), getHeight());
              mSurface.setOnFrameAvailableListener(mUpdateListener, mAttachInfo.mHandler);
  
              if (mListener != null && createNewSurface) {
                  mListener.onSurfaceTextureAvailable(mSurface, getWidth(), getHeight());
              }
              mLayer.setLayerPaint(mLayerPaint);
          }
  
          if (mUpdateSurface) {
              // Someone has requested that we use a specific SurfaceTexture, so
              // tell mLayer about it and set the SurfaceTexture to use the
              // current view size.
              mUpdateSurface = false;
  
              // Since we are updating the layer, force an update to ensure its
              // parameters are correct (width, height, transform, etc.)
              updateLayer();
              mMatrixChanged = true;
  
              mLayer.setSurfaceTexture(mSurface);
              mSurface.setDefaultBufferSize(getWidth(), getHeight());
          }
  
          return mLayer;
      }
  
      @Override
      protected void onVisibilityChanged(View changedView, int visibility) {
          super.onVisibilityChanged(changedView, visibility);
  
          if (mSurface != null) {
              // When the view becomes invisible, stop updating it, it's a waste of CPU
              // To cancel updates, the easiest thing to do is simply to remove the
              // updates listener
              if (visibility == VISIBLE) {
                  if (mLayer != null) {
                      mSurface.setOnFrameAvailableListener(mUpdateListener, mAttachInfo.mHandler);
                  }
                  updateLayerAndInvalidate();
              } else {
                  mSurface.setOnFrameAvailableListener(null);
              }
          }
      }
  
      private void updateLayer() {
          synchronized (mLock) {
              mUpdateLayer = true;
          }
      }
  
      private void updateLayerAndInvalidate() {
          synchronized (mLock) {
              mUpdateLayer = true;
          }
          invalidate();
      }
  
      private void applyUpdate() {
          if (mLayer == null) {
              return;
          }
  
          synchronized (mLock) {
              if (mUpdateLayer) {
                  mUpdateLayer = false;
              } else {
                  return;
              }
          }
  
          mLayer.prepare(getWidth(), getHeight(), mOpaque);
          mLayer.updateSurfaceTexture();
  
          if (mListener != null) {
              mListener.onSurfaceTextureUpdated(mSurface);
          }
      }
  
      /**
       * <p>Sets the transform to associate with this texture view.
       * The specified transform applies to the underlying surface
       * texture and does not affect the size or position of the view
       * itself, only of its content.</p>
       *
       * <p>Some transforms might prevent the content from drawing
       * all the pixels contained within this view's bounds. In such
       * situations, make sure this texture view is not marked opaque.</p>
       *
       * @param transform The transform to apply to the content of
       *        this view.
       *
       * @see #getTransform(android.graphics.Matrix)
       * @see #isOpaque()
       * @see #setOpaque(boolean)
       */
      public void setTransform(Matrix transform) {
          mMatrix.set(transform);
          mMatrixChanged = true;
          invalidateParentIfNeeded();
      }
  
      /**
       * Returns the transform associated with this texture view.
       *
       * @param transform The {@link Matrix} in which to copy the current
       *        transform. Can be null.
       *
       * @return The specified matrix if not null or a new {@link Matrix}
       *         instance otherwise.
       *
       * @see #setTransform(android.graphics.Matrix)
       */
      public Matrix getTransform(Matrix transform) {
          if (transform == null) {
              transform = new Matrix();
          }
  
          transform.set(mMatrix);
  
          return transform;
      }
  
      private void applyTransformMatrix() {
          if (mMatrixChanged && mLayer != null) {
              mLayer.setTransform(mMatrix);
              mMatrixChanged = false;
          }
      }
  
      /**
       * <p>Returns a {@link android.graphics.Bitmap} representation of the content
       * of the associated surface texture. If the surface texture is not available,
       * this method returns null.</p>
       *
       * <p>The bitmap returned by this method uses the {@link Bitmap.Config#ARGB_8888}
       * pixel format and its dimensions are the same as this view's.</p>
       *
       * <p><strong>Do not</strong> invoke this method from a drawing method
       * ({@link #onDraw(android.graphics.Canvas)} for instance).</p>
       *
       * <p>If an error occurs during the copy, an empty bitmap will be returned.</p>
       *
       * @return A valid {@link Bitmap.Config#ARGB_8888} bitmap, or null if the surface
       *         texture is not available or the width &lt;= 0 or the height &lt;= 0
       *
       * @see #isAvailable()
       * @see #getBitmap(android.graphics.Bitmap)
       * @see #getBitmap(int, int)
       */
      public Bitmap getBitmap() {
          return getBitmap(getWidth(), getHeight());
      }
  
      /**
       * <p>Returns a {@link android.graphics.Bitmap} representation of the content
       * of the associated surface texture. If the surface texture is not available,
       * this method returns null.</p>
       *
       * <p>The bitmap returned by this method uses the {@link Bitmap.Config#ARGB_8888}
       * pixel format.</p>
       *
       * <p><strong>Do not</strong> invoke this method from a drawing method
       * ({@link #onDraw(android.graphics.Canvas)} for instance).</p>
       *
       * <p>If an error occurs during the copy, an empty bitmap will be returned.</p>
       *
       * @param width The width of the bitmap to create
       * @param height The height of the bitmap to create
       *
       * @return A valid {@link Bitmap.Config#ARGB_8888} bitmap, or null if the surface
       *         texture is not available or width is &lt;= 0 or height is &lt;= 0
       *
       * @see #isAvailable()
       * @see #getBitmap(android.graphics.Bitmap)
       * @see #getBitmap()
       */
      public Bitmap getBitmap(int width, int height) {
          if (isAvailable() && width > 0 && height > 0) {
              return getBitmap(Bitmap.createBitmap(getResources().getDisplayMetrics(),
                      width, height, Bitmap.Config.ARGB_8888));
          }
          return null;
      }
  
      /**
       * <p>Copies the content of this view's surface texture into the specified
       * bitmap. If the surface texture is not available, the copy is not executed.
       * The content of the surface texture will be scaled to fit exactly inside
       * the specified bitmap.</p>
       *
       * <p><strong>Do not</strong> invoke this method from a drawing method
       * ({@link #onDraw(android.graphics.Canvas)} for instance).</p>
       *
       * <p>If an error occurs, the bitmap is left unchanged.</p>
       *
       * @param bitmap The bitmap to copy the content of the surface texture into,
       *               cannot be null, all configurations are supported
       *
       * @return The bitmap specified as a parameter
       *
       * @see #isAvailable()
       * @see #getBitmap(int, int)
       * @see #getBitmap()
       *
       * @throws IllegalStateException if the hardware rendering context cannot be
       *         acquired to capture the bitmap
       */
      public Bitmap getBitmap(Bitmap bitmap) {
          if (bitmap != null && isAvailable()) {
              applyUpdate();
              applyTransformMatrix();
  
              // This case can happen if the app invokes setSurfaceTexture() before
              // we are able to create the hardware layer. We can safely initialize
              // the layer here thanks to the validate() call at the beginning of
              // this method
              if (mLayer == null && mUpdateSurface) {
                  getTextureLayer();
              }
  
              if (mLayer != null) {
                  mLayer.copyInto(bitmap);
              }
          }
          return bitmap;
      }
  
      /**
       * Returns true if the {@link SurfaceTexture} associated with this
       * TextureView is available for rendering. When this method returns
       * true, {@link #getSurfaceTexture()} returns a valid surface texture.
       */
      public boolean isAvailable() {
          return mSurface != null;
      }
  
      /**
       * <p>Start editing the pixels in the surface.  The returned Canvas can be used
       * to draw into the surface's bitmap.  A null is returned if the surface has
       * not been created or otherwise cannot be edited. You will usually need
       * to implement
       * {@link SurfaceTextureListener#onSurfaceTextureAvailable(android.graphics.SurfaceTexture, int, int)}
       * to find out when the Surface is available for use.</p>
       *
       * <p>The content of the Surface is never preserved between unlockCanvas()
       * and lockCanvas(), for this reason, every pixel within the Surface area
       * must be written. The only exception to this rule is when a dirty
       * rectangle is specified, in which case, non-dirty pixels will be
       * preserved.</p>
       *
       * <p>This method can only be used if the underlying surface is not already
       * owned by another producer. For instance, if the TextureView is being used
       * to render the camera's preview you cannot invoke this method.</p>
       *
       * @return A Canvas used to draw into the surface.
       *
       * @see #lockCanvas(android.graphics.Rect)
       * @see #unlockCanvasAndPost(android.graphics.Canvas)
       */
      public Canvas lockCanvas() {
          return lockCanvas(null);
      }
  
      /**
       * Just like {@link #lockCanvas()} but allows specification of a dirty
       * rectangle. Every pixel within that rectangle must be written; however
       * pixels outside the dirty rectangle will be preserved by the next call
       * to lockCanvas().
       *
       * This method can return null if the underlying surface texture is not
       * available (see {@link #isAvailable()} or if the surface texture is
       * already connected to an image producer (for instance: the camera,
       * OpenGL, a media player, etc.)
       *
       * @param dirty Area of the surface that will be modified.
  
       * @return A Canvas used to draw into the surface.
       *
       * @see #lockCanvas()
       * @see #unlockCanvasAndPost(android.graphics.Canvas)
       * @see #isAvailable()
       */
      public Canvas lockCanvas(Rect dirty) {
          if (!isAvailable()) return null;
  
          if (mCanvas == null) {
              mCanvas = new Canvas();
          }
  
          synchronized (mNativeWindowLock) {
              if (!nLockCanvas(mNativeWindow, mCanvas, dirty)) {
                  return null;
              }
          }
          mSaveCount = mCanvas.save();
  
          return mCanvas;
      }
  
      /**
       * Finish editing pixels in the surface. After this call, the surface's
       * current pixels will be shown on the screen, but its content is lost,
       * in particular there is no guarantee that the content of the Surface
       * will remain unchanged when lockCanvas() is called again.
       *
       * @param canvas The Canvas previously returned by lockCanvas()
       *
       * @see #lockCanvas()
       * @see #lockCanvas(android.graphics.Rect)
       */
      public void unlockCanvasAndPost(Canvas canvas) {
          if (mCanvas != null && canvas == mCanvas) {
              canvas.restoreToCount(mSaveCount);
              mSaveCount = 0;
  
              synchronized (mNativeWindowLock) {
                  nUnlockCanvasAndPost(mNativeWindow, mCanvas);
              }
          }
      }
  
      /**
       * Returns the {@link SurfaceTexture} used by this view. This method
       * may return null if the view is not attached to a window or if the surface
       * texture has not been initialized yet.
       *
       * @see #isAvailable()
       */
      public SurfaceTexture getSurfaceTexture() {
          return mSurface;
      }
  
      /**
       * Set the {@link SurfaceTexture} for this view to use. If a {@link
       * SurfaceTexture} is already being used by this view, it is immediately
       * released and not usable any more.  The {@link
       * SurfaceTextureListener#onSurfaceTextureDestroyed} callback is <b>not</b>
       * called for the previous {@link SurfaceTexture}.  Similarly, the {@link
       * SurfaceTextureListener#onSurfaceTextureAvailable} callback is <b>not</b>
       * called for the {@link SurfaceTexture} passed to setSurfaceTexture.
       *
       * The {@link SurfaceTexture} object must be detached from all OpenGL ES
       * contexts prior to calling this method.
       *
       * @param surfaceTexture The {@link SurfaceTexture} that the view should use.
       * @see SurfaceTexture#detachFromGLContext()
       */
      public void setSurfaceTexture(SurfaceTexture surfaceTexture) {
          if (surfaceTexture == null) {
              throw new NullPointerException("surfaceTexture must not be null");
          }
          if (surfaceTexture == mSurface) {
              throw new IllegalArgumentException("Trying to setSurfaceTexture to " +
                      "the same SurfaceTexture that's already set.");
          }
          if (surfaceTexture.isReleased()) {
              throw new IllegalArgumentException("Cannot setSurfaceTexture to a " +
                      "released SurfaceTexture");
          }
          if (mSurface != null) {
              nDestroyNativeWindow();
              mSurface.release();
          }
          mSurface = surfaceTexture;
          nCreateNativeWindow(mSurface);
  
          /*
           * If the view is visible and we already made a layer, update the
           * listener in the new surface to use the existing listener in the view.
           * Otherwise this will be called when the view becomes visible or the
           * layer is created
           */
          if (((mViewFlags & VISIBILITY_MASK) == VISIBLE) && mLayer != null) {
              mSurface.setOnFrameAvailableListener(mUpdateListener, mAttachInfo.mHandler);
          }
          mUpdateSurface = true;
          invalidateParentIfNeeded();
      }
  
      /**
       * Returns the {@link SurfaceTextureListener} currently associated with this
       * texture view.
       *
       * @see #setSurfaceTextureListener(android.view.TextureView.SurfaceTextureListener)
       * @see SurfaceTextureListener
       */
      public SurfaceTextureListener getSurfaceTextureListener() {
          return mListener;
      }
  
      /**
       * Sets the {@link SurfaceTextureListener} used to listen to surface
       * texture events.
       *
       * @see #getSurfaceTextureListener()
       * @see SurfaceTextureListener
       */
      public void setSurfaceTextureListener(SurfaceTextureListener listener) {
          mListener = listener;
      }
  
      @UnsupportedAppUsage
      private final SurfaceTexture.OnFrameAvailableListener mUpdateListener =
              new SurfaceTexture.OnFrameAvailableListener() {
          @Override
          public void onFrameAvailable(SurfaceTexture surfaceTexture) {
              updateLayer();
              invalidate();
          }
      };
  
      /**
       * This listener can be used to be notified when the surface texture
       * associated with this texture view is available.
       */
      public static interface SurfaceTextureListener {
          /**
           * Invoked when a {@link TextureView}'s SurfaceTexture is ready for use.
           *
           * @param surface The surface returned by
           *                {@link android.view.TextureView#getSurfaceTexture()}
           * @param width The width of the surface
           * @param height The height of the surface
           */
          public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height);
  
          /**
           * Invoked when the {@link SurfaceTexture}'s buffers size changed.
           *
           * @param surface The surface returned by
           *                {@link android.view.TextureView#getSurfaceTexture()}
           * @param width The new width of the surface
           * @param height The new height of the surface
           */
          public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height);
  
          /**
           * Invoked when the specified {@link SurfaceTexture} is about to be destroyed.
           * If returns true, no rendering should happen inside the surface texture after this method
           * is invoked. If returns false, the client needs to call {@link SurfaceTexture#release()}.
           * Most applications should return true.
           *
           * @param surface The surface about to be destroyed
           */
          public boolean onSurfaceTextureDestroyed(SurfaceTexture surface);
  
          /**
           * Invoked when the specified {@link SurfaceTexture} is updated through
           * {@link SurfaceTexture#updateTexImage()}.
           *
           * @param surface The surface just updated
           */
          public void onSurfaceTextureUpdated(SurfaceTexture surface);
      }
  
      @UnsupportedAppUsage
      private native void nCreateNativeWindow(SurfaceTexture surface);
      @UnsupportedAppUsage
      private native void nDestroyNativeWindow();
  
      private static native boolean nLockCanvas(long nativeWindow, Canvas canvas, Rect dirty);
      private static native void nUnlockCanvasAndPost(long nativeWindow, Canvas canvas);
  }
  