shell/platform/android/io/flutter/plugin/platform/PlatformViewWrapper.java - mirrors/engine - Git at Google

 // Copyright 2013 The Flutter Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package io.flutter.plugin.platform;

 import static android.content.ComponentCallbacks2.TRIM_MEMORY_COMPLETE;

 import android.annotation.SuppressLint;
 import android.annotation.TargetApi;
 import android.content.Context;
 import android.graphics.BlendMode;
 import android.graphics.Canvas;
 import android.graphics.Color;
 import android.graphics.Matrix;
 import android.graphics.Rect;
 import android.graphics.SurfaceTexture;
 import android.os.Build;
 import android.view.MotionEvent;
 import android.view.Surface;
 import android.view.View;
 import android.view.ViewParent;
 import android.view.ViewTreeObserver;
 import android.widget.FrameLayout;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.VisibleForTesting;
 import io.flutter.Log;
 import io.flutter.embedding.android.AndroidTouchProcessor;
 import io.flutter.util.ViewUtils;
 import io.flutter.view.TextureRegistry;
 import java.util.concurrent.atomic.AtomicLong;

 /**
  * Wraps a platform view to intercept gestures and project this view onto a {@link SurfaceTexture}.
  *
  * <p>An Android platform view is composed by the engine using a {@code TextureLayer}. The view is
  * embeded to the Android view hierarchy like a normal view, but it's projected onto a {@link
  * SurfaceTexture}, so it can be efficiently composed by the engine.
  *
  * <p>Since the view is in the Android view hierarchy, keyboard and accessibility interactions
  * behave normally.
  */
 @TargetApi(23)
 class PlatformViewWrapper extends FrameLayout {
   private static final String TAG = "PlatformViewWrapper";

   private int prevLeft;
   private int prevTop;
   private int left;
   private int top;
   private int bufferWidth;
   private int bufferHeight;
   private SurfaceTexture tx;
   private Surface surface;
   private AndroidTouchProcessor touchProcessor;

   @Nullable @VisibleForTesting ViewTreeObserver.OnGlobalFocusChangeListener activeFocusListener;
   private final AtomicLong pendingFramesCount = new AtomicLong(0L);

   private final TextureRegistry.OnFrameConsumedListener frameConsumedListener =
       new TextureRegistry.OnFrameConsumedListener() {
         @Override
         public void onFrameConsumed() {
           if (Build.VERSION.SDK_INT == 29) {
             pendingFramesCount.decrementAndGet();
           }
         }
       };

   private boolean shouldRecreateSurfaceForLowMemory = false;
   private final TextureRegistry.OnTrimMemoryListener trimMemoryListener =
       new TextureRegistry.OnTrimMemoryListener() {
         @Override
         public void onTrimMemory(int level) {
           // When a memory pressure warning is received and the level equal {@code
           // ComponentCallbacks2.TRIM_MEMORY_COMPLETE}, the Android system releases the underlying
           // surface. If we continue to use the surface (e.g., call lockHardwareCanvas), a crash
           // occurs, and we found that this crash appeared on Android10 and above.
           // See https://github.com/flutter/flutter/issues/103870 for more details.
           //
           // Here our workaround is to recreate the surface before using it.
           if (level == TRIM_MEMORY_COMPLETE && Build.VERSION.SDK_INT >= 29) {
             shouldRecreateSurfaceForLowMemory = true;
           }
         }
       };

   private void onFrameProduced() {
     if (Build.VERSION.SDK_INT == 29) {
       pendingFramesCount.incrementAndGet();
     }
   }

   private void recreateSurfaceIfNeeded() {
     if (shouldRecreateSurfaceForLowMemory) {
       if (surface != null) {
         surface.release();
       }
       surface = createSurface(tx);
       shouldRecreateSurfaceForLowMemory = false;
     }
   }

   private boolean shouldDrawToSurfaceNow() {
     if (Build.VERSION.SDK_INT == 29) {
       return pendingFramesCount.get() <= 0L;
     }
     return true;
   }

   public PlatformViewWrapper(@NonNull Context context) {
     super(context);
     setWillNotDraw(false);
   }

   public PlatformViewWrapper(
       @NonNull Context context, @NonNull TextureRegistry.SurfaceTextureEntry textureEntry) {
     this(context);
     textureEntry.setOnFrameConsumedListener(frameConsumedListener);
     textureEntry.setOnTrimMemoryListener(trimMemoryListener);
     setTexture(textureEntry.surfaceTexture());
   }

   /**
    * Sets the touch processor that allows to intercept gestures.
    *
    * @param newTouchProcessor The touch processor.
    */
   public void setTouchProcessor(@Nullable AndroidTouchProcessor newTouchProcessor) {
     touchProcessor = newTouchProcessor;
   }

   /**
    * Sets the texture where the view is projected onto.
    *
    * <p>{@link PlatformViewWrapper} doesn't take ownership of the {@link SurfaceTexture}. As a
    * result, the caller is responsible for releasing the texture.
    *
    * <p>{@link io.flutter.view.TextureRegistry} is responsible for creating and registering textures
    * in the engine. Therefore, the engine is responsible for also releasing the texture.
    *
    * @param newTx The texture where the view is projected onto.
    */
   @SuppressLint("NewApi")
   public void setTexture(@Nullable SurfaceTexture newTx) {
     if (Build.VERSION.SDK_INT < 23) {
       Log.e(
           TAG,
           "Platform views cannot be displayed below API level 23. "
               + "You can prevent this issue by setting `minSdkVersion: 23` in build.gradle.");
       return;
     }

     tx = newTx;

     if (bufferWidth > 0 && bufferHeight > 0) {
       tx.setDefaultBufferSize(bufferWidth, bufferHeight);
     }

     if (surface != null) {
       surface.release();
     }
     surface = createSurface(newTx);

     // Fill the entire canvas with a transparent color.
     // As a result, the background color of the platform view container is displayed
     // to the user until the platform view draws its first frame.
     final Canvas canvas = surface.lockHardwareCanvas();
     try {
       if (Build.VERSION.SDK_INT >= 29) {
         canvas.drawColor(Color.TRANSPARENT, BlendMode.CLEAR);
       } else {
         canvas.drawColor(Color.TRANSPARENT);
       }
       onFrameProduced();
     } finally {
       surface.unlockCanvasAndPost(canvas);
     }
   }

   @NonNull
   @VisibleForTesting
   protected Surface createSurface(@NonNull SurfaceTexture tx) {
     return new Surface(tx);
   }

   /** Returns the texture where the view is projected. */
   @Nullable
   public SurfaceTexture getTexture() {
     return tx;
   }

   /**
    * Sets the layout parameters for this view.
    *
    * @param params The new parameters.
    */
   public void setLayoutParams(@NonNull FrameLayout.LayoutParams params) {
     super.setLayoutParams(params);

     left = params.leftMargin;
     top = params.topMargin;
   }

   /**
    * Sets the size of the image buffer.
    *
    * @param width The width of the screen buffer.
    * @param height The height of the screen buffer.
    */
   public void setBufferSize(int width, int height) {
     bufferWidth = width;
     bufferHeight = height;
     if (tx != null) {
       tx.setDefaultBufferSize(width, height);
     }
   }

   /** Returns the image buffer width. */
   public int getBufferWidth() {
     return bufferWidth;
   }

   /** Returns the image buffer height. */
   public int getBufferHeight() {
     return bufferHeight;
   }

   /** Releases the surface. */
   public void release() {
     // Don't release the texture.
     tx = null;
     if (surface != null) {
       surface.release();
       surface = null;
     }
   }

   @Override
   public boolean onInterceptTouchEvent(@NonNull MotionEvent event) {
     return true;
   }

   /** Used on Android O+, {@link invalidateChildInParent} used for previous versions. */
   @SuppressLint("NewApi")
   @Override
   public void onDescendantInvalidated(@NonNull View child, @NonNull View target) {
     super.onDescendantInvalidated(child, target);
     invalidate();
   }

   @Override
   public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
     invalidate();
     return super.invalidateChildInParent(location, dirty);
   }

   @Override
   @SuppressLint("NewApi")
   public void draw(Canvas canvas) {
     if (surface == null) {
       super.draw(canvas);
       Log.e(TAG, "Platform view cannot be composed without a surface.");
       return;
     }
     if (!surface.isValid()) {
       Log.e(TAG, "Invalid surface. The platform view cannot be displayed.");
       return;
     }
     if (tx == null || tx.isReleased()) {
       Log.e(TAG, "Invalid texture. The platform view cannot be displayed.");
       return;
     }
     // We've observed on Android Q that we have to wait for the consumer of {@link SurfaceTexture}
     // to consume the last image before continuing to draw, otherwise subsequent calls to
     // {@code dequeueBuffer} to request a free buffer from the {@link BufferQueue} will fail.
     // See https://github.com/flutter/flutter/issues/98722
     if (!shouldDrawToSurfaceNow()) {
       // If there are still frames that are not consumed, we will draw them next time.
       invalidate();
     } else {
       // We try to recreate the surface before using it to avoid the crash:
       // https://github.com/flutter/flutter/issues/103870
       recreateSurfaceIfNeeded();

       // Override the canvas that this subtree of views will use to draw.
       final Canvas surfaceCanvas = surface.lockHardwareCanvas();
       try {
         // Clear the current pixels in the canvas.
         // This helps when a WebView renders an HTML document with transparent background.
         if (Build.VERSION.SDK_INT >= 29) {
           surfaceCanvas.drawColor(Color.TRANSPARENT, BlendMode.CLEAR);
         } else {
           surfaceCanvas.drawColor(Color.TRANSPARENT);
         }
         super.draw(surfaceCanvas);
         onFrameProduced();
       } finally {
         surface.unlockCanvasAndPost(surfaceCanvas);
       }
     }
   }

   @Override
   @SuppressLint("ClickableViewAccessibility")
   public boolean onTouchEvent(@NonNull MotionEvent event) {
     if (touchProcessor == null) {
       return super.onTouchEvent(event);
     }
     final Matrix screenMatrix = new Matrix();
     switch (event.getAction()) {
       case MotionEvent.ACTION_DOWN:
         prevLeft = left;
         prevTop = top;
         screenMatrix.postTranslate(left, top);
         break;
       case MotionEvent.ACTION_MOVE:
         // While the view is dragged, use the left and top positions as
         // they were at the moment the touch event fired.
         screenMatrix.postTranslate(prevLeft, prevTop);
         prevLeft = left;
         prevTop = top;
         break;
       case MotionEvent.ACTION_UP:
       default:
         screenMatrix.postTranslate(left, top);
         break;
     }
     return touchProcessor.onTouchEvent(event, screenMatrix);
   }

   public void setOnDescendantFocusChangeListener(@NonNull OnFocusChangeListener userFocusListener) {
     unsetOnDescendantFocusChangeListener();
     final ViewTreeObserver observer = getViewTreeObserver();
     if (observer.isAlive() && activeFocusListener == null) {
       activeFocusListener =
           new ViewTreeObserver.OnGlobalFocusChangeListener() {
             @Override
             public void onGlobalFocusChanged(View oldFocus, View newFocus) {
               userFocusListener.onFocusChange(
                   PlatformViewWrapper.this, ViewUtils.childHasFocus(PlatformViewWrapper.this));
             }
           };
       observer.addOnGlobalFocusChangeListener(activeFocusListener);
     }
   }

   public void unsetOnDescendantFocusChangeListener() {
     final ViewTreeObserver observer = getViewTreeObserver();
     if (observer.isAlive() && activeFocusListener != null) {
       final ViewTreeObserver.OnGlobalFocusChangeListener currFocusListener = activeFocusListener;
       activeFocusListener = null;
       observer.removeOnGlobalFocusChangeListener(currFocusListener);
     }
   }
 }
	// Copyright 2013 The Flutter Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	package io.flutter.plugin.platform;

	import static android.content.ComponentCallbacks2.TRIM_MEMORY_COMPLETE;

	import android.annotation.SuppressLint;
	import android.annotation.TargetApi;
	import android.content.Context;
	import android.graphics.BlendMode;
	import android.graphics.Canvas;
	import android.graphics.Color;
	import android.graphics.Matrix;
	import android.graphics.Rect;
	import android.graphics.SurfaceTexture;
	import android.os.Build;
	import android.view.MotionEvent;
	import android.view.Surface;
	import android.view.View;
	import android.view.ViewParent;
	import android.view.ViewTreeObserver;
	import android.widget.FrameLayout;
	import androidx.annotation.NonNull;
	import androidx.annotation.Nullable;
	import androidx.annotation.VisibleForTesting;
	import io.flutter.Log;
	import io.flutter.embedding.android.AndroidTouchProcessor;
	import io.flutter.util.ViewUtils;
	import io.flutter.view.TextureRegistry;
	import java.util.concurrent.atomic.AtomicLong;

	/**
	* Wraps a platform view to intercept gestures and project this view onto a {@link SurfaceTexture}.
	*
	* <p>An Android platform view is composed by the engine using a {@code TextureLayer}. The view is
	* embeded to the Android view hierarchy like a normal view, but it's projected onto a {@link
	* SurfaceTexture}, so it can be efficiently composed by the engine.
	*
	* <p>Since the view is in the Android view hierarchy, keyboard and accessibility interactions
	* behave normally.
	*/
	@TargetApi(23)
	class PlatformViewWrapper extends FrameLayout {
	private static final String TAG = "PlatformViewWrapper";

	private int prevLeft;
	private int prevTop;
	private int left;
	private int top;
	private int bufferWidth;
	private int bufferHeight;
	private SurfaceTexture tx;
	private Surface surface;
	private AndroidTouchProcessor touchProcessor;

	@Nullable @VisibleForTesting ViewTreeObserver.OnGlobalFocusChangeListener activeFocusListener;
	private final AtomicLong pendingFramesCount = new AtomicLong(0L);

	private final TextureRegistry.OnFrameConsumedListener frameConsumedListener =
	new TextureRegistry.OnFrameConsumedListener() {
	@Override
	public void onFrameConsumed() {
	if (Build.VERSION.SDK_INT == 29) {
	pendingFramesCount.decrementAndGet();
	}
	}
	};

	private boolean shouldRecreateSurfaceForLowMemory = false;
	private final TextureRegistry.OnTrimMemoryListener trimMemoryListener =
	new TextureRegistry.OnTrimMemoryListener() {
	@Override
	public void onTrimMemory(int level) {
	// When a memory pressure warning is received and the level equal {@code
	// ComponentCallbacks2.TRIM_MEMORY_COMPLETE}, the Android system releases the underlying
	// surface. If we continue to use the surface (e.g., call lockHardwareCanvas), a crash
	// occurs, and we found that this crash appeared on Android10 and above.
	// See https://github.com/flutter/flutter/issues/103870 for more details.
	//
	// Here our workaround is to recreate the surface before using it.
	if (level == TRIM_MEMORY_COMPLETE && Build.VERSION.SDK_INT >= 29) {
	shouldRecreateSurfaceForLowMemory = true;
	}
	}
	};

	private void onFrameProduced() {
	if (Build.VERSION.SDK_INT == 29) {
	pendingFramesCount.incrementAndGet();
	}
	}

	private void recreateSurfaceIfNeeded() {
	if (shouldRecreateSurfaceForLowMemory) {
	if (surface != null) {
	surface.release();
	}
	surface = createSurface(tx);
	shouldRecreateSurfaceForLowMemory = false;
	}
	}

	private boolean shouldDrawToSurfaceNow() {
	if (Build.VERSION.SDK_INT == 29) {
	return pendingFramesCount.get() <= 0L;
	}
	return true;
	}

	public PlatformViewWrapper(@NonNull Context context) {
	super(context);
	setWillNotDraw(false);
	}

	public PlatformViewWrapper(
	@NonNull Context context, @NonNull TextureRegistry.SurfaceTextureEntry textureEntry) {
	this(context);
	textureEntry.setOnFrameConsumedListener(frameConsumedListener);
	textureEntry.setOnTrimMemoryListener(trimMemoryListener);
	setTexture(textureEntry.surfaceTexture());
	}

	/**
	* Sets the touch processor that allows to intercept gestures.
	*
	* @param newTouchProcessor The touch processor.
	*/
	public void setTouchProcessor(@Nullable AndroidTouchProcessor newTouchProcessor) {
	touchProcessor = newTouchProcessor;
	}

	/**
	* Sets the texture where the view is projected onto.
	*
	* <p>{@link PlatformViewWrapper} doesn't take ownership of the {@link SurfaceTexture}. As a
	* result, the caller is responsible for releasing the texture.
	*
	* <p>{@link io.flutter.view.TextureRegistry} is responsible for creating and registering textures
	* in the engine. Therefore, the engine is responsible for also releasing the texture.
	*
	* @param newTx The texture where the view is projected onto.
	*/
	@SuppressLint("NewApi")
	public void setTexture(@Nullable SurfaceTexture newTx) {
	if (Build.VERSION.SDK_INT < 23) {
	Log.e(
	TAG,
	"Platform views cannot be displayed below API level 23. "
	+ "You can prevent this issue by setting `minSdkVersion: 23` in build.gradle.");
	return;
	}

	tx = newTx;

	if (bufferWidth > 0 && bufferHeight > 0) {
	tx.setDefaultBufferSize(bufferWidth, bufferHeight);
	}

	if (surface != null) {
	surface.release();
	}
	surface = createSurface(newTx);

	// Fill the entire canvas with a transparent color.
	// As a result, the background color of the platform view container is displayed
	// to the user until the platform view draws its first frame.
	final Canvas canvas = surface.lockHardwareCanvas();
	try {
	if (Build.VERSION.SDK_INT >= 29) {
	canvas.drawColor(Color.TRANSPARENT, BlendMode.CLEAR);
	} else {
	canvas.drawColor(Color.TRANSPARENT);
	}
	onFrameProduced();
	} finally {
	surface.unlockCanvasAndPost(canvas);
	}
	}

	@NonNull
	@VisibleForTesting
	protected Surface createSurface(@NonNull SurfaceTexture tx) {
	return new Surface(tx);
	}

	/** Returns the texture where the view is projected. */
	@Nullable
	public SurfaceTexture getTexture() {
	return tx;
	}

	/**
	* Sets the layout parameters for this view.
	*
	* @param params The new parameters.
	*/
	public void setLayoutParams(@NonNull FrameLayout.LayoutParams params) {
	super.setLayoutParams(params);

	left = params.leftMargin;
	top = params.topMargin;
	}

	/**
	* Sets the size of the image buffer.
	*
	* @param width The width of the screen buffer.
	* @param height The height of the screen buffer.
	*/
	public void setBufferSize(int width, int height) {
	bufferWidth = width;
	bufferHeight = height;
	if (tx != null) {
	tx.setDefaultBufferSize(width, height);
	}
	}

	/** Returns the image buffer width. */
	public int getBufferWidth() {
	return bufferWidth;
	}

	/** Returns the image buffer height. */
	public int getBufferHeight() {
	return bufferHeight;
	}

	/** Releases the surface. */
	public void release() {
	// Don't release the texture.
	tx = null;
	if (surface != null) {
	surface.release();
	surface = null;
	}
	}

	@Override
	public boolean onInterceptTouchEvent(@NonNull MotionEvent event) {
	return true;
	}

	/** Used on Android O+, {@link invalidateChildInParent} used for previous versions. */
	@SuppressLint("NewApi")
	@Override
	public void onDescendantInvalidated(@NonNull View child, @NonNull View target) {
	super.onDescendantInvalidated(child, target);
	invalidate();
	}

	@Override
	public ViewParent invalidateChildInParent(int[] location, Rect dirty) {
	invalidate();
	return super.invalidateChildInParent(location, dirty);
	}

	@Override
	@SuppressLint("NewApi")
	public void draw(Canvas canvas) {
	if (surface == null) {
	super.draw(canvas);
	Log.e(TAG, "Platform view cannot be composed without a surface.");
	return;
	}
	if (!surface.isValid()) {
	Log.e(TAG, "Invalid surface. The platform view cannot be displayed.");
	return;
	}
	if (tx == null \|\| tx.isReleased()) {
	Log.e(TAG, "Invalid texture. The platform view cannot be displayed.");
	return;
	}
	// We've observed on Android Q that we have to wait for the consumer of {@link SurfaceTexture}
	// to consume the last image before continuing to draw, otherwise subsequent calls to
	// {@code dequeueBuffer} to request a free buffer from the {@link BufferQueue} will fail.
	// See https://github.com/flutter/flutter/issues/98722
	if (!shouldDrawToSurfaceNow()) {
	// If there are still frames that are not consumed, we will draw them next time.
	invalidate();
	} else {
	// We try to recreate the surface before using it to avoid the crash:
	// https://github.com/flutter/flutter/issues/103870
	recreateSurfaceIfNeeded();

	// Override the canvas that this subtree of views will use to draw.
	final Canvas surfaceCanvas = surface.lockHardwareCanvas();
	try {
	// Clear the current pixels in the canvas.
	// This helps when a WebView renders an HTML document with transparent background.
	if (Build.VERSION.SDK_INT >= 29) {
	surfaceCanvas.drawColor(Color.TRANSPARENT, BlendMode.CLEAR);
	} else {
	surfaceCanvas.drawColor(Color.TRANSPARENT);
	}
	super.draw(surfaceCanvas);
	onFrameProduced();
	} finally {
	surface.unlockCanvasAndPost(surfaceCanvas);
	}
	}
	}

	@Override
	@SuppressLint("ClickableViewAccessibility")
	public boolean onTouchEvent(@NonNull MotionEvent event) {
	if (touchProcessor == null) {
	return super.onTouchEvent(event);
	}
	final Matrix screenMatrix = new Matrix();
	switch (event.getAction()) {
	case MotionEvent.ACTION_DOWN:
	prevLeft = left;
	prevTop = top;
	screenMatrix.postTranslate(left, top);
	break;
	case MotionEvent.ACTION_MOVE:
	// While the view is dragged, use the left and top positions as
	// they were at the moment the touch event fired.
	screenMatrix.postTranslate(prevLeft, prevTop);
	prevLeft = left;
	prevTop = top;
	break;
	case MotionEvent.ACTION_UP:
	default:
	screenMatrix.postTranslate(left, top);
	break;
	}
	return touchProcessor.onTouchEvent(event, screenMatrix);
	}

	public void setOnDescendantFocusChangeListener(@NonNull OnFocusChangeListener userFocusListener) {
	unsetOnDescendantFocusChangeListener();
	final ViewTreeObserver observer = getViewTreeObserver();
	if (observer.isAlive() && activeFocusListener == null) {
	activeFocusListener =
	new ViewTreeObserver.OnGlobalFocusChangeListener() {
	@Override
	public void onGlobalFocusChanged(View oldFocus, View newFocus) {
	userFocusListener.onFocusChange(
	PlatformViewWrapper.this, ViewUtils.childHasFocus(PlatformViewWrapper.this));
	}
	};
	observer.addOnGlobalFocusChangeListener(activeFocusListener);
	}
	}

	public void unsetOnDescendantFocusChangeListener() {
	final ViewTreeObserver observer = getViewTreeObserver();
	if (observer.isAlive() && activeFocusListener != null) {
	final ViewTreeObserver.OnGlobalFocusChangeListener currFocusListener = activeFocusListener;
	activeFocusListener = null;
	observer.removeOnGlobalFocusChangeListener(currFocusListener);
	}
	}
	}