Automatic sources dropoff on 2020-06-10 18:32:38.095721
The change is generated with prebuilt drop tool.
Change-Id: I24cbf6ba6db262a1ae1445db1427a08fee35b3b4
diff --git a/android/view/TextureLayer.java b/android/view/TextureLayer.java
new file mode 100644
index 0000000..46dd436
--- /dev/null
+++ b/android/view/TextureLayer.java
@@ -0,0 +1,154 @@
+/*
+ * Copyright (C) 2011 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package android.view;
+
+import android.annotation.Nullable;
+import android.graphics.Bitmap;
+import android.graphics.HardwareRenderer;
+import android.graphics.Matrix;
+import android.graphics.Paint;
+import android.graphics.SurfaceTexture;
+
+import com.android.internal.util.VirtualRefBasePtr;
+
+/**
+ * TextureLayer represents a SurfaceTexture that will be composited by RenderThread into the
+ * frame when drawn in a HW accelerated Canvas. This is backed by a DeferredLayerUpdater on
+ * the native side.
+ *
+ * @hide
+ */
+public final class TextureLayer {
+ private HardwareRenderer mRenderer;
+ private VirtualRefBasePtr mFinalizer;
+
+ private TextureLayer(HardwareRenderer renderer, long deferredUpdater) {
+ if (renderer == null || deferredUpdater == 0) {
+ throw new IllegalArgumentException("Either hardware renderer: " + renderer
+ + " or deferredUpdater: " + deferredUpdater + " is invalid");
+ }
+ mRenderer = renderer;
+ mFinalizer = new VirtualRefBasePtr(deferredUpdater);
+ }
+
+ /**
+ * Update the paint used when drawing this layer.
+ *
+ * @param paint The paint used when the layer is drawn into the destination canvas.
+ * @see View#setLayerPaint(android.graphics.Paint)
+ */
+ public void setLayerPaint(@Nullable Paint paint) {
+ nSetLayerPaint(mFinalizer.get(), paint != null ? paint.getNativeInstance() : 0);
+ mRenderer.pushLayerUpdate(this);
+ }
+
+ /**
+ * Indicates whether this layer can be rendered.
+ *
+ * @return True if the layer can be rendered into, false otherwise
+ */
+ public boolean isValid() {
+ return mFinalizer != null && mFinalizer.get() != 0;
+ }
+
+ /**
+ * Destroys resources without waiting for a GC.
+ */
+ public void destroy() {
+ if (!isValid()) {
+ // Already destroyed
+ return;
+ }
+ mRenderer.onLayerDestroyed(this);
+ mRenderer = null;
+ mFinalizer.release();
+ mFinalizer = null;
+ }
+
+ public long getDeferredLayerUpdater() {
+ return mFinalizer.get();
+ }
+
+ /**
+ * Copies this layer into the specified bitmap.
+ *
+ * @param bitmap The bitmap to copy they layer into
+ *
+ * @return True if the copy was successful, false otherwise
+ */
+ public boolean copyInto(Bitmap bitmap) {
+ return mRenderer.copyLayerInto(this, bitmap);
+ }
+
+ /**
+ * Update the layer's properties. Note that after calling this isValid() may
+ * return false if the requested width/height cannot be satisfied
+ *
+ * @param width The new width of this layer
+ * @param height The new height of this layer
+ * @param isOpaque Whether this layer is opaque
+ *
+ * @return true if the layer's properties will change, false if they already
+ * match the desired values.
+ */
+ public boolean prepare(int width, int height, boolean isOpaque) {
+ return nPrepare(mFinalizer.get(), width, height, isOpaque);
+ }
+
+ /**
+ * Sets an optional transform on this layer.
+ *
+ * @param matrix The transform to apply to the layer.
+ */
+ public void setTransform(Matrix matrix) {
+ nSetTransform(mFinalizer.get(), matrix.native_instance);
+ mRenderer.pushLayerUpdate(this);
+ }
+
+ /**
+ * Indicates that this layer has lost its texture.
+ */
+ public void detachSurfaceTexture() {
+ mRenderer.detachSurfaceTexture(mFinalizer.get());
+ }
+
+ public long getLayerHandle() {
+ return mFinalizer.get();
+ }
+
+ public void setSurfaceTexture(SurfaceTexture surface) {
+ nSetSurfaceTexture(mFinalizer.get(), surface);
+ mRenderer.pushLayerUpdate(this);
+ }
+
+ public void updateSurfaceTexture() {
+ nUpdateSurfaceTexture(mFinalizer.get());
+ mRenderer.pushLayerUpdate(this);
+ }
+
+ /** @hide */
+ public static TextureLayer adoptTextureLayer(HardwareRenderer renderer, long layer) {
+ return new TextureLayer(renderer, layer);
+ }
+
+ private static native boolean nPrepare(long layerUpdater, int width, int height,
+ boolean isOpaque);
+ private static native void nSetLayerPaint(long layerUpdater, long paint);
+ private static native void nSetTransform(long layerUpdater, long matrix);
+ private static native void nSetSurfaceTexture(long layerUpdater, SurfaceTexture surface);
+ private static native void nUpdateSurfaceTexture(long layerUpdater);
+}
