980 lines
35 KiB
Java
980 lines
35 KiB
Java
/*
|
|
* 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 static android.view.Surface.FRAME_RATE_CATEGORY_NORMAL;
|
|
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.compat.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.TextureLayer;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.os.Build;
|
|
import android.os.Trace;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.view.flags.Flags;
|
|
|
|
/**
|
|
* <p>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.</p>
|
|
*
|
|
* <p>TextureView can only be used in a hardware accelerated window. When
|
|
* rendered in software, TextureView will draw nothing.</p>
|
|
*
|
|
* <p><b>TextureView vs. SurfaceView Capabilities</b></p>
|
|
|
|
* <p>
|
|
* <table>
|
|
* <tr>
|
|
* <th> </th>
|
|
* <th style="text-align: center;">TextureView</th>
|
|
* <th style="text-align: center;">SurfaceView</th>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>Supports View alpha</td>
|
|
* <td style="text-align: center;">X</td>
|
|
* <td style="text-align: center;">U+</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>Supports rotations</td>
|
|
* <td style="text-align: center;">X</td>
|
|
* <td style="text-align: center;"> </td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>Supports clipping</td>
|
|
* <td style="text-align: center;">X</td>
|
|
* <td style="text-align: center;"> </td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>HDR support</td>
|
|
* <td style="text-align: center;">Limited (on Android T+)</td>
|
|
* <td style="text-align: center;">Full</td>
|
|
* </tr>
|
|
* <tr>
|
|
* <td>Renders DRM content</td>
|
|
* <td style="text-align: center;"> </td>
|
|
* <td style="text-align: center;">X</td>
|
|
* </tr>
|
|
* </table>
|
|
* </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 have translucency, arbitrary rotations, and complex
|
|
* clipping. For example, you can make a TextureView semi-translucent by
|
|
* calling <code>myView.setAlpha(0.5f)</code>.</p>
|
|
*
|
|
* <p>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, <b>SurfaceView is recommended as a more general solution
|
|
* to problems requiring rendering to surfaces.</b></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 a video
|
|
* into a TextureView:</p>
|
|
*
|
|
* <pre>
|
|
* 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
|
|
* }
|
|
*
|
|
* }
|
|
* </pre>
|
|
*
|
|
* <p>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.</p>
|
|
*
|
|
* <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(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);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <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. 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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* <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 <= 0 or the height <= 0
|
|
*
|
|
* @see #isAvailable()
|
|
* @see #getBitmap(android.graphics.Bitmap)
|
|
* @see #getBitmap(int, int)
|
|
*/
|
|
public @Nullable 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 <= 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;
|
|
}
|
|
|
|
/**
|
|
* <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 @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;
|
|
}
|
|
|
|
/**
|
|
* <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, 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 <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(@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);
|
|
}
|