TextureView 放大缩小旋转闪屏怎样解决

TextureView 放大缩小旋转闪屏问题可能是由于 TextureView 的重绘导致的。为了解决这个问题，可以尝试以下几种方法：

1. 在旋转屏幕或放大缩小 TextureView 时，先将 TextureView 隐藏，等操作完成后再显示出来，这样可以减少重绘的次数。

2. 通过设置 TextureView 的缓冲区大小和格式，来减少 TextureView 重绘的次数。可以使用 setBufferSize 方法设置缓冲区大小，使用 setOpaque 方法设置是否为不透明。

3. 在进行旋转或放大缩小操作时，可以将 TextureView 转换为 Bitmap，然后对 Bitmap 进行操作，操作完成后再将 Bitmap 显示到 TextureView 中，这样可以避免 TextureView 重绘导致的闪屏问题。

4. 在 Android 4.4 及以上版本中，可以使用 TextureView 的 setTransform 方法来实现旋转和缩放操作，这样可以避免 TextureView 重绘导致的闪屏问题。

5. 如果以上方法都无法解决问题，可以考虑使用 SurfaceView 来替代 TextureView，因为 SurfaceView 的绘制方式不同于 TextureView，可以更好地避免闪屏问题。但是要注意，使用 SurfaceView 也有一些限制，例如 SurfaceView 不能在 XML 布局中使用，需要通过代码创建。

相关问题

写出一个TextureView放大缩小旋转的例子并处理闪屏问题

这里有一个使用TextureView放大缩小旋转的例子，并处理了闪屏问题。

public class TextureViewActivity extends AppCompatActivity implements TextureView.SurfaceTextureListener {

    private static final String TAG = "TextureViewActivity";
    private TextureView mTextureView;
    private float mLastX, mLastY;
    private int mRotation;
    private boolean mIsEnlarged;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_texture_view);

        mTextureView = findViewById(R.id.textureView);
        mTextureView.setSurfaceTextureListener(this);
        mTextureView.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        mLastX = event.getX();
                        mLastY = event.getY();
                        break;
                    case MotionEvent.ACTION_MOVE:
                        float offsetX = event.getX() - mLastX;
                        float offsetY = event.getY() - mLastY;
                        if (Math.abs(offsetX) > Math.abs(offsetY)) {
                            rotateTextureView(offsetX);
                        } else {
                            scaleTextureView(offsetY);
                        }
                        mLastX = event.getX();
                        mLastY = event.getY();
                        break;
                }
                return true;
            }
        });
    }

    private void rotateTextureView(float offsetX) {
        mRotation -= offsetX / 10;
        if (mRotation < 0) {
            mRotation += 360;
        } else if (mRotation >= 360) {
            mRotation -= 360;
        }
        mTextureView.setRotation(mRotation);
    }

    private void scaleTextureView(float offsetY) {
        float scaleY = mTextureView.getScaleY();
        scaleY += offsetY / 1000;
        if (scaleY < 0.1f) {
            scaleY = 0.1f;
        } else if (scaleY > 2.0f) {
            scaleY = 2.0f;
        }
        mTextureView.setScaleX(scaleY);
        mTextureView.setScaleY(scaleY);
        if (scaleY > 1.0f) {
            mIsEnlarged = true;
        } else {
            mIsEnlarged = false;
        }
    }

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        Log.d(TAG, "onSurfaceTextureAvailable");
        Canvas canvas = mTextureView.lockCanvas();
        if (canvas != null) {
            canvas.drawColor(Color.BLACK);
            mTextureView.unlockCanvasAndPost(canvas);
        }
    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
        Log.d(TAG, "onSurfaceTextureSizeChanged");
        Canvas canvas = mTextureView.lockCanvas();
        if (canvas != null) {
            canvas.drawColor(Color.BLACK);
            mTextureView.unlockCanvasAndPost(canvas);
        }
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        Log.d(TAG, "onSurfaceTextureDestroyed");
        return true;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {
        Log.d(TAG, "onSurfaceTextureUpdated");
        if (!mIsEnlarged) {
            Canvas canvas = mTextureView.lockCanvas();
            if (canvas != null) {
                canvas.drawColor(Color.BLACK);
                mTextureView.unlockCanvasAndPost(canvas);
            }
        }
    }
}

在这个例子中，我们使用`TextureView`展示视频画面，并通过手势实现了放大缩小和旋转功能，同时还处理了闪屏问题。

在`onCreate()`方法中，我们首先设置了`TextureView`的`SurfaceTextureListener`和`OnTouchListener`，其中`SurfaceTextureListener`用于监听`SurfaceTexture`的创建、大小改变和销毁，而`OnTouchListener`用于监听用户手势操作。

在`onTouch()`方法中，我们根据手势的横向偏移量来旋转`TextureView`，根据手势的纵向偏移量来缩放`TextureView`。由于`TextureView`的缩放会导致视图出现闪屏，因此我们在缩小到原始大小时重新绘制`TextureView`，避免了闪屏问题。

在`onSurfaceTextureAvailable()`和`onSurfaceTextureSizeChanged()`方法中，我们在`TextureView`上绘制了一个黑色背景，以避免闪屏问题。

在`onSurfaceTextureDestroyed()`方法中，我们返回`true`，表示要销毁`SurfaceTexture`，这样就可以在`onSurfaceTextureUpdated()`方法中重新绘制`TextureView`，避免了闪屏问题。

需要注意的是，为了避免闪屏问题，我们在缩小到原始大小时重新绘制了`TextureView`，这可能会影响性能。因此，如果你需要高性能的应用程序，可以考虑使用OpenGL ES来绘制视频画面，这样可以更好地处理缩放和旋转，而且不会出现闪屏问题。

写一个TextureView 可以放大缩小和旋转使用setTransform避免闪屏

好的，可以参考以下代码实现：

public class ZoomRotateTextureView extends TextureView implements ScaleGestureDetector.OnScaleGestureListener {

    private static final int INVALID_POINTER_ID = -1;

    private ScaleGestureDetector mScaleGestureDetector;
    private int mActivePointerId = INVALID_POINTER_ID;
    private float mLastTouchX;
    private float mLastTouchY;
    private float mPosX;
    private float mPosY;

    public ZoomRotateTextureView(Context context) {
        super(context);
        mScaleGestureDetector = new ScaleGestureDetector(context, this);
    }

    public ZoomRotateTextureView(Context context, AttributeSet attrs) {
        super(context, attrs);
        mScaleGestureDetector = new ScaleGestureDetector(context, this);
    }

    public ZoomRotateTextureView(Context context, AttributeSet attrs, int defStyleAttr) {
        super(context, attrs, defStyleAttr);
        mScaleGestureDetector = new ScaleGestureDetector(context, this);
    }

    @Override
    public boolean onTouchEvent(MotionEvent event) {
        mScaleGestureDetector.onTouchEvent(event);

        final int action = event.getAction();
        switch (action & MotionEvent.ACTION_MASK) {
            case MotionEvent.ACTION_DOWN: {
                final float x = event.getX();
                final float y = event.getY();

                mLastTouchX = x;
                mLastTouchY = y;
                mActivePointerId = event.getPointerId(0);
                break;
            }

            case MotionEvent.ACTION_MOVE: {
                final int pointerIndex = event.findPointerIndex(mActivePointerId);
                final float x = event.getX(pointerIndex);
                final float y = event.getY(pointerIndex);

                // Only move if the ScaleGestureDetector isn't processing a gesture.
                if (!mScaleGestureDetector.isInProgress()) {
                    final float dx = x - mLastTouchX;
                    final float dy = y - mLastTouchY;

                    mPosX += dx;
                    mPosY += dy;

                    setTransform();
                }

                mLastTouchX = x;
                mLastTouchY = y;
                break;
            }

            case MotionEvent.ACTION_UP: {
                mActivePointerId = INVALID_POINTER_ID;
                break;
            }

            case MotionEvent.ACTION_CANCEL: {
                mActivePointerId = INVALID_POINTER_ID;
                break;
            }

            case MotionEvent.ACTION_POINTER_UP: {
                final int pointerIndex = (event.getAction() & MotionEvent.ACTION_POINTER_INDEX_MASK)
                        >> MotionEvent.ACTION_POINTER_INDEX_SHIFT;
                final int pointerId = event.getPointerId(pointerIndex);
                if (pointerId == mActivePointerId) {
                    // This was our active pointer going up. Choose a new
                    // active pointer and adjust accordingly.
                    final int newPointerIndex = pointerIndex == 0 ? 1 : 0;
                    mLastTouchX = event.getX(newPointerIndex);
                    mLastTouchY = event.getY(newPointerIndex);
                    mActivePointerId = event.getPointerId(newPointerIndex);
                }
                break;
            }
        }
        return true;
    }

    private void setTransform() {
        Matrix matrix = new Matrix();
        matrix.postTranslate(mPosX, mPosY);
        setTransform(matrix);
    }

    @Override
    public boolean onScale(ScaleGestureDetector detector) {
        float scaleFactor = detector.getScaleFactor();
        setPivotX(detector.getFocusX());
        setPivotY(detector.getFocusY());

        Matrix matrix = new Matrix(getTransform());
        matrix.postScale(scaleFactor, scaleFactor, detector.getFocusX(), detector.getFocusY());
        setTransform(matrix);

        return true;
    }

    @Override
    public boolean onScaleBegin(ScaleGestureDetector detector) {
        return true;
    }

    @Override
    public void onScaleEnd(ScaleGestureDetector detector) {

    }
}

这个类继承自TextureView，并实现了ScaleGestureDetector.OnScaleGestureListener接口，在触摸事件中处理触摸事件，实现缩放和拖动操作，通过setTransform()方法设置TextureView的变换矩阵，避免闪屏问题。