A TextureView can be used to display a content stream, such as that * coming from a camera preview, a video, or an OpenGL scene. The content stream * can come from the application's process as well as a remote process.
* *TextureView can only be used in a hardware accelerated window. When * rendered in software, TextureView will draw nothing.
* *TextureView vs. SurfaceView Capabilities
**
| * | TextureView | *SurfaceView | *
|---|---|---|
| Supports View alpha | *X | *U+ | *
| Supports rotations | *X | ** |
| Supports clipping | *X | ** |
| HDR support | *Limited (on Android T+) | *Full | *
| Renders DRM content | ** | X | *
Unlike {@link SurfaceView}, TextureView does not create a separate
* window but behaves as a regular View. This key difference allows a
* TextureView to have translucency, arbitrary rotations, and complex
* clipping. For example, you can make a TextureView semi-translucent by
* calling myView.setAlpha(0.5f).
One implication of this integration of TextureView into the view * hierarchy is that it may have slower performance than * SurfaceView. TextureView contents must be copied, internally, from the * underlying surface into the view displaying those contents. For * that reason, SurfaceView is recommended as a more general solution * to problems requiring rendering to surfaces.
* *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 a video * into a TextureView:
* *
* public class MyActivity extends Activity implements TextureView.SurfaceTextureListener {
* private MediaPlayer mMediaPlayer;
* private TextureView mTextureView;
*
* protected void onCreate(Bundle savedInstanceState) {
* super.onCreate(savedInstanceState);
*
* mMediaPlayer = new MediaPlayer();
*
* mTextureView = new TextureView(this);
* mTextureView.setSurfaceTextureListener(this);
* setContentView(mTextureView);
* }
*
* public void onSurfaceTextureAvailable(@NonNull SurfaceTexture surfaceTexture,
* int width, int height) {
* AssetFileDescriptor fileDescriptor = // get file descriptor
* mMediaPlayer.setDataSource(fileDescriptor);
* mMediaPlayer.setSurface(new Surface(surfaceTexture));
* mMediaPlayer.prepareAsync();
* mMediaPlayer.setOnPreparedListener(new MediaPlayer.OnPreparedListener() {
* @Override
* public void onPrepared(MediaPlayer mp) {
* mMediaPlayer.start();
* }
* });
* } catch (IOException e) {
* e.printStackTrace();
* }
* }
*
* @Override
* public void onSurfaceTextureSizeChanged(@NonNull SurfaceTexture surfaceTexture,
* int width, int height) {
* // Handle size change depending on media needs
* }
*
* @Override
* public boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surfaceTexture) {
* // Release unneeded resources
* mMediaPlayer.stop();
* mMediaPlayer.release();
* return true;
* }
*
* @Override
* public void onSurfaceTextureUpdated(@NonNull SurfaceTexture surfaceTexture) {
* // Invoked every time there's a new video frame
* }
*
* }
*
*
* Similarly, TextureView can supply the surface needed for GL rendering or * camera previews. Camera2 APIs require the surface created by TextureView, * although developers are recommended to use the CameraX APIs instead, for which * PreviewView creates its own TextureView or SurfaceView internally.
* *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.
* *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.
* * @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(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private boolean mOpaque = true; private final Matrix mMatrix = new Matrix(); private boolean mMatrixChanged; private final Object[] mLock = new Object[0]; private boolean mUpdateLayer; @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private boolean mUpdateSurface; private Canvas mCanvas; private int mSaveCount; private final Object[] mNativeWindowLock = new Object[0]; // Set by native code, do not write! @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private long mNativeWindow; // Used for VRR detecting "normal" frame rate rather than "high". This is the previous // interval for drawing. This can be removed when NORMAL is the default rate for Views. // (b/329156944) private long mMinusTwoFrameIntervalMillis = 0; // Used for VRR detecting "normal" frame rate rather than "high". This is the last // frame time for drawing. This can be removed when NORMAL is the default rate for Views. // (b/329156944) private long mLastFrameTimeMillis = 0; /** * Creates a new TextureView. * * @param context The context to associate this view with. */ public TextureView(@NonNull Context context) { super(context); mRenderNode.setIsTextureView(); } /** * 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(@NonNull Context context, @Nullable AttributeSet attrs) { super(context, attrs); mRenderNode.setIsTextureView(); } /** * 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(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr) { super(context, attrs, defStyleAttr); mRenderNode.setIsTextureView(); } /** * 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(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) { super(context, attrs, defStyleAttr, defStyleRes); mRenderNode.setIsTextureView(); } /** * {@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(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) protected void onDetachedFromWindowInternal() { destroyHardwareLayer(); releaseSurfaceTexture(); super.onDetachedFromWindowInternal(); } /** * @hide */ @Override @UnsupportedAppUsage protected void destroyHardwareResources() { super.destroyHardwareResources(); destroyHardwareLayer(); } @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private void destroyHardwareLayer() { if (mLayer != null) { mLayer.detachSurfaceTexture(); mLayer.close(); 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) { Trace.traceBegin(Trace.TRACE_TAG_VIEW, "TextureView#draw()"); applyUpdate(); applyTransformMatrix(); mLayer.setLayerPaint(mLayerPaint); // ensure layer paint is up to date recordingCanvas.drawTextureLayer(layer); Trace.traceEnd(Trace.TRACE_TAG_VIEW); } } } /** * 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 (Flags.toolkitSetFrameRateReadOnly()) { mSurface.setOnSetFrameRateListener( (surfaceTexture, frameRate, compatibility, strategy) -> { if (Trace.isTagEnabled(Trace.TRACE_TAG_VIEW)) { Trace.instant(Trace.TRACE_TAG_VIEW, "setFrameRate: " + frameRate); } setRequestedFrameRate(frameRate); mFrameRateCompatibility = compatibility; }, 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); } } /** *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.
* *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.
* * @param transform The transform to apply to the content of * this view. If null the transform will be set to identity. * * @see #getTransform(android.graphics.Matrix) * @see #isOpaque() * @see #setOpaque(boolean) */ public void setTransform(@Nullable 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 @NonNull Matrix getTransform(@Nullable 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; } } /** *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.
* *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.
* *Do not invoke this method from a drawing method * ({@link #onDraw(android.graphics.Canvas)} for instance).
* *If an error occurs during the copy, an empty bitmap will be returned.
* * @return A valid {@link Bitmap.Config#ARGB_8888} bitmap, or null if the surface * texture is not available or the width <= 0 or the height <= 0 * * @see #isAvailable() * @see #getBitmap(android.graphics.Bitmap) * @see #getBitmap(int, int) */ public @Nullable Bitmap getBitmap() { return getBitmap(getWidth(), getHeight()); } /** *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.
* *The bitmap returned by this method uses the {@link Bitmap.Config#ARGB_8888} * pixel format.
* *Do not invoke this method from a drawing method * ({@link #onDraw(android.graphics.Canvas)} for instance).
* *If an error occurs during the copy, an empty bitmap will be returned.
* * @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 <= 0 or height is <= 0 * * @see #isAvailable() * @see #getBitmap(android.graphics.Bitmap) * @see #getBitmap() */ public @Nullable 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; } /** *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.
* *Do not invoke this method from a drawing method * ({@link #onDraw(android.graphics.Canvas)} for instance).
* *If an error occurs, the bitmap is left unchanged.
* * @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 @NonNull Bitmap getBitmap(@NonNull 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; } /** *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.
* *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.
* *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.
* * @return A Canvas used to draw into the surface, or null if the surface cannot be locked for * drawing (see {@link #isAvailable()}). * * @see #lockCanvas(android.graphics.Rect) * @see #unlockCanvasAndPost(android.graphics.Canvas) */ public @Nullable 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. If null the area of the entire * surface is used. * @return A Canvas used to draw into the surface, or null if the surface cannot be locked for * drawing (see {@link #isAvailable()}). * * @see #lockCanvas() * @see #unlockCanvasAndPost(android.graphics.Canvas) * @see #isAvailable() */ public @Nullable Canvas lockCanvas(@Nullable 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(@NonNull 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 @Nullable 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 not * called for the previous {@link SurfaceTexture}. Similarly, the {@link * SurfaceTextureListener#onSurfaceTextureAvailable} callback is not * 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(@NonNull 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 @Nullable SurfaceTextureListener getSurfaceTextureListener() { return mListener; } /** * Sets the {@link SurfaceTextureListener} used to listen to surface * texture events. * * @see #getSurfaceTextureListener() * @see SurfaceTextureListener */ public void setSurfaceTextureListener(@Nullable SurfaceTextureListener listener) { mListener = listener; } /** * @hide */ @Override protected int calculateFrameRateCategory() { long now = getDrawingTime(); // This isn't necessary when the default frame rate is NORMAL (b/329156944) if (mMinusTwoFrameIntervalMillis > 15 && (now - mLastFrameTimeMillis) > 15) { return FRAME_RATE_CATEGORY_NORMAL; } return super.calculateFrameRateCategory(); } /** * @hide */ @Override protected void votePreferredFrameRate() { super.votePreferredFrameRate(); // This isn't necessary when the default frame rate is NORMAL (b/329156944) long now = getDrawingTime(); mMinusTwoFrameIntervalMillis = now - mLastFrameTimeMillis; mLastFrameTimeMillis = now; } @UnsupportedAppUsage private final SurfaceTexture.OnFrameAvailableListener mUpdateListener = surfaceTexture -> { updateLayer(); invalidate(); }; /** * This listener can be used to be notified when the surface texture * associated with this texture view is available. */ public 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 */ void onSurfaceTextureAvailable(@NonNull 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 */ void onSurfaceTextureSizeChanged(@NonNull 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 */ boolean onSurfaceTextureDestroyed(@NonNull SurfaceTexture surface); /** * Invoked when the specified {@link SurfaceTexture} is updated through * {@link SurfaceTexture#updateTexImage()}. * * @param surface The surface just updated */ void onSurfaceTextureUpdated(@NonNull SurfaceTexture surface); } @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private native void nCreateNativeWindow(SurfaceTexture surface); @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.R, trackingBug = 170729553) private native void nDestroyNativeWindow(); private static native boolean nLockCanvas(long nativeWindow, Canvas canvas, Rect dirty); private static native void nUnlockCanvasAndPost(long nativeWindow, Canvas canvas); }