From fc29424a3c6c710c0b27d5b59e115fbbb6365192 Mon Sep 17 00:00:00 2001 From: Chris Craik Date: Tue, 13 Dec 2016 18:10:46 -0800 Subject: [PATCH] CriticalNative for RenderNode and DisplayListCanvas Bug: 33460152 Test: adb shell am instrument -w -e class android.view.ViewShowHidePerfTest com.android.perftests.core/android.support.test.runner.AndroidJUnitRunner - Also FastNative for setDisplayList, simplifying upcall into field setter. - Also removes depth sweep parameter for ViewShowHideTests for now, they're not providing much extra info. Together with Outline/Path CL, about 25% faster visibility toggles 960MHz Bullhead Before (prior to Outline/Path CL): $ adb shell am instrument -w -e class android.view.ViewShowHidePerfTest com.android.perftests.core/android.support.test.runner.AndroidJUnitRunner | grep min INSTRUMENTATION_STATUS: add[Factory:NestedLinearLayoutTree,depth:6]_min=743505 INSTRUMENTATION_STATUS: goneToVisible[Factory:NestedLinearLayoutTree,depth:6]_min=332420 INSTRUMENTATION_STATUS: invisibleToVisible[Factory:NestedLinearLayoutTree,depth:6]_min=354154 INSTRUMENTATION_STATUS: recordAfterAdd[Factory:NestedLinearLayoutTree,depth:6]_min=1106095 INSTRUMENTATION_STATUS: remove[Factory:NestedLinearLayoutTree,depth:6]_min=1261290 INSTRUMENTATION_STATUS: visibleToGone[Factory:NestedLinearLayoutTree,depth:6]_min=356153 INSTRUMENTATION_STATUS: visibleToInvisible[Factory:NestedLinearLayoutTree,depth:6]_min=362149 After (this CL + Outline/Path CL): $ adb shell am instrument -w -e class android.view.ViewShowHidePerfTest com.android.perftests.core/android.support.test.runner.AndroidJUnitRunner | grep min INSTRUMENTATION_STATUS: add[Factory:NestedLinearLayoutTree,depth:6]_min=636061 INSTRUMENTATION_STATUS: goneToVisible[Factory:NestedLinearLayoutTree,depth:6]_min=267481 INSTRUMENTATION_STATUS: invisibleToVisible[Factory:NestedLinearLayoutTree,depth:6]_min=289433 INSTRUMENTATION_STATUS: recordAfterAdd[Factory:NestedLinearLayoutTree,depth:6]_min=976827 INSTRUMENTATION_STATUS: remove[Factory:NestedLinearLayoutTree,depth:6]_min=1207286 INSTRUMENTATION_STATUS: visibleToGone[Factory:NestedLinearLayoutTree,depth:6]_min=286148 INSTRUMENTATION_STATUS: visibleToInvisible[Factory:NestedLinearLayoutTree,depth:6]_min=292834 Change-Id: Iaddfa9550bdbab807c662595d005126d98cdc277 --- .../android/view/ViewShowHidePerfTest.java | 17 +- core/java/android/app/ActivityThread.java | 13 +- core/java/android/view/DisplayListCanvas.java | 40 ++-- core/java/android/view/RenderNode.java | 136 +++++------ core/jni/android_view_DisplayListCanvas.cpp | 154 ++++++------- core/jni/android_view_RenderNode.cpp | 215 +++++++----------- 6 files changed, 265 insertions(+), 310 deletions(-) diff --git a/apct-tests/perftests/core/src/android/view/ViewShowHidePerfTest.java b/apct-tests/perftests/core/src/android/view/ViewShowHidePerfTest.java index c7da48c112f53..6159da4fc3f5d 100644 --- a/apct-tests/perftests/core/src/android/view/ViewShowHidePerfTest.java +++ b/apct-tests/perftests/core/src/android/view/ViewShowHidePerfTest.java @@ -121,7 +121,7 @@ public class ViewShowHidePerfTest { @Parameterized.Parameters(name = "Factory:{0},depth:{1}") public static Iterable params() { List params = new ArrayList<>(); - for (int depth : new int[] {1, 6, 10}) { + for (int depth : new int[] { 6 }) { for (SubTreeFactory subTreeFactory : sSubTreeFactories) { params.add(new Object[]{ subTreeFactory, depth }); } @@ -198,6 +198,21 @@ public class ViewShowHidePerfTest { }); } + @Test + public void testRecordAfterAdd() throws Throwable { + testParentWithChild((state, width, height, parent, child) -> { + while (state.keepRunning()) { + state.pauseTiming(); + parent.removeAllViews(); + updateAndValidateDisplayList(parent); // Note, done to be safe, likely not needed + parent.addView(child); + layout(width, height, child); + state.resumeTiming(); + + updateAndValidateDisplayList(parent); + } + }); + } private void testVisibility(int fromVisibility, int toVisibility) throws Throwable { testParentWithChild((state, width, height, parent, child) -> { diff --git a/core/java/android/app/ActivityThread.java b/core/java/android/app/ActivityThread.java index 9a92764596574..e34fabced5179 100644 --- a/core/java/android/app/ActivityThread.java +++ b/core/java/android/app/ActivityThread.java @@ -113,9 +113,6 @@ import android.view.Window; import android.view.WindowManager; import android.view.WindowManagerGlobal; import android.renderscript.RenderScriptCacheDir; -import android.system.Os; -import android.system.OsConstants; -import android.system.ErrnoException; import android.webkit.WebView; import com.android.internal.annotations.GuardedBy; @@ -138,11 +135,9 @@ import java.io.IOException; import java.io.PrintWriter; import java.lang.ref.WeakReference; import java.lang.reflect.Field; -import java.lang.reflect.InvocationTargetException; import java.net.InetAddress; import java.text.DateFormat; import java.util.ArrayList; -import java.util.Collections; import java.util.List; import java.util.Locale; import java.util.Map; @@ -653,8 +648,6 @@ public final class ActivityThread { } } - private native void dumpGraphicsInfo(FileDescriptor fd); - private class ApplicationThread extends IApplicationThread.Stub { private static final String DB_INFO_FORMAT = " %8s %8s %14s %14s %s"; @@ -1195,7 +1188,7 @@ public final class ActivityThread { @Override public void dumpGfxInfo(ParcelFileDescriptor pfd, String[] args) { - dumpGraphicsInfo(pfd.getFileDescriptor()); + nDumpGraphicsInfo(pfd.getFileDescriptor()); WindowManagerGlobal.getInstance().dumpGfxInfo(pfd.getFileDescriptor(), args); IoUtils.closeQuietly(pfd); } @@ -6240,4 +6233,8 @@ public final class ActivityThread { throw new RuntimeException("Main thread loop unexpectedly exited"); } + + // ------------------ Regular JNI ------------------------ + + private native void nDumpGraphicsInfo(FileDescriptor fd); } diff --git a/core/java/android/view/DisplayListCanvas.java b/core/java/android/view/DisplayListCanvas.java index 106f1729569fb..8f9ae0e3f48c9 100644 --- a/core/java/android/view/DisplayListCanvas.java +++ b/core/java/android/view/DisplayListCanvas.java @@ -23,6 +23,7 @@ import android.graphics.CanvasProperty; import android.graphics.Paint; import android.util.Pools.SynchronizedPool; +import dalvik.annotation.optimization.CriticalNative; import dalvik.annotation.optimization.FastNative; /** @@ -230,30 +231,37 @@ public final class DisplayListCanvas extends RecordingCanvas { } } - @FastNative - private static native long nCreateDisplayListCanvas(long node, int width, int height); - @FastNative - private static native void nResetDisplayListCanvas(long canvas, long node, - int width, int height); - @FastNative - private static native int nGetMaximumTextureWidth(); - @FastNative - private static native int nGetMaximumTextureHeight(); - @FastNative - private static native void nInsertReorderBarrier(long renderer, boolean enableReorder); + + // ------------------ Fast JNI ------------------------ + @FastNative private static native void nCallDrawGLFunction(long renderer, long drawGLFunction, Runnable releasedCallback); - @FastNative + + + // ------------------ Critical JNI ------------------------ + + @CriticalNative + private static native long nCreateDisplayListCanvas(long node, int width, int height); + @CriticalNative + private static native void nResetDisplayListCanvas(long canvas, long node, + int width, int height); + @CriticalNative + private static native int nGetMaximumTextureWidth(); + @CriticalNative + private static native int nGetMaximumTextureHeight(); + @CriticalNative + private static native void nInsertReorderBarrier(long renderer, boolean enableReorder); + @CriticalNative private static native long nFinishRecording(long renderer); - @FastNative + @CriticalNative private static native void nDrawRenderNode(long renderer, long renderNode); - @FastNative + @CriticalNative private static native void nDrawLayer(long renderer, long layer); - @FastNative + @CriticalNative private static native void nDrawCircle(long renderer, long propCx, long propCy, long propRadius, long propPaint); - @FastNative + @CriticalNative private static native void nDrawRoundRect(long renderer, long propLeft, long propTop, long propRight, long propBottom, long propRx, long propRy, long propPaint); } diff --git a/core/java/android/view/RenderNode.java b/core/java/android/view/RenderNode.java index 8eca43158ef2e..fc666975ee25a 100644 --- a/core/java/android/view/RenderNode.java +++ b/core/java/android/view/RenderNode.java @@ -24,6 +24,7 @@ import android.graphics.Paint; import android.graphics.Rect; import android.graphics.drawable.AnimatedVectorDrawable; +import dalvik.annotation.optimization.CriticalNative; import dalvik.annotation.optimization.FastNative; import libcore.util.NativeAllocationRegistry; @@ -138,7 +139,9 @@ public class RenderNode { RenderNode.class.getClassLoader(), nGetNativeFinalizer(), 1024); } + // Note: written by native when display lists are detached private boolean mValid; + // Do not access directly unless you are ThreadedRenderer final long mNativeRenderNode; private final View mOwningView; @@ -792,13 +795,6 @@ public class RenderNode { return nGetDebugSize(mNativeRenderNode); } - /** - * Called by native when the passed displaylist is removed from the draw tree - */ - void onRenderNodeDetached() { - discardDisplayList(); - } - /////////////////////////////////////////////////////////////////////////// // Animations /////////////////////////////////////////////////////////////////////////// @@ -828,14 +824,13 @@ public class RenderNode { } /////////////////////////////////////////////////////////////////////////// - // Native methods + // Regular JNI methods /////////////////////////////////////////////////////////////////////////// // Intentionally not static because it acquires a reference to 'this' private native long nCreate(String name); private static native long nGetNativeFinalizer(); - private static native void nSetDisplayList(long renderNode, long newData); private static native void nOutput(long renderNode); private static native int nGetDebugSize(long renderNode); private static native void nRequestPositionUpdates(long renderNode, SurfaceView callback); @@ -845,132 +840,141 @@ public class RenderNode { private static native void nAddAnimator(long renderNode, long animatorPtr); private static native void nEndAllAnimators(long renderNode); + /////////////////////////////////////////////////////////////////////////// - // Fast native methods + // @FastNative methods + /////////////////////////////////////////////////////////////////////////// + + @FastNative + private static native void nSetDisplayList(long renderNode, long newData); + + + /////////////////////////////////////////////////////////////////////////// + // @CriticalNative methods /////////////////////////////////////////////////////////////////////////// // Matrix - @FastNative + @CriticalNative private static native void nGetTransformMatrix(long renderNode, long nativeMatrix); - @FastNative + @CriticalNative private static native void nGetInverseTransformMatrix(long renderNode, long nativeMatrix); - @FastNative + @CriticalNative private static native boolean nHasIdentityMatrix(long renderNode); // Properties - @FastNative + @CriticalNative private static native boolean nOffsetTopAndBottom(long renderNode, int offset); - @FastNative + @CriticalNative private static native boolean nOffsetLeftAndRight(long renderNode, int offset); - @FastNative + @CriticalNative private static native boolean nSetLeftTopRightBottom(long renderNode, int left, int top, int right, int bottom); - @FastNative + @CriticalNative private static native boolean nSetBottom(long renderNode, int bottom); - @FastNative + @CriticalNative private static native boolean nSetRight(long renderNode, int right); - @FastNative + @CriticalNative private static native boolean nSetTop(long renderNode, int top); - @FastNative + @CriticalNative private static native boolean nSetLeft(long renderNode, int left); - @FastNative + @CriticalNative private static native boolean nSetCameraDistance(long renderNode, float distance); - @FastNative + @CriticalNative private static native boolean nSetPivotY(long renderNode, float pivotY); - @FastNative + @CriticalNative private static native boolean nSetPivotX(long renderNode, float pivotX); - @FastNative + @CriticalNative private static native boolean nSetLayerType(long renderNode, int layerType); - @FastNative + @CriticalNative private static native boolean nSetLayerPaint(long renderNode, long paint); - @FastNative + @CriticalNative private static native boolean nSetClipToBounds(long renderNode, boolean clipToBounds); - @FastNative + @CriticalNative private static native boolean nSetClipBounds(long renderNode, int left, int top, int right, int bottom); - @FastNative + @CriticalNative private static native boolean nSetClipBoundsEmpty(long renderNode); - @FastNative + @CriticalNative private static native boolean nSetProjectBackwards(long renderNode, boolean shouldProject); - @FastNative + @CriticalNative private static native boolean nSetProjectionReceiver(long renderNode, boolean shouldRecieve); - @FastNative + @CriticalNative private static native boolean nSetOutlineRoundRect(long renderNode, int left, int top, int right, int bottom, float radius, float alpha); - @FastNative + @CriticalNative private static native boolean nSetOutlineConvexPath(long renderNode, long nativePath, float alpha); - @FastNative + @CriticalNative private static native boolean nSetOutlineEmpty(long renderNode); - @FastNative + @CriticalNative private static native boolean nSetOutlineNone(long renderNode); - @FastNative + @CriticalNative private static native boolean nHasShadow(long renderNode); - @FastNative + @CriticalNative private static native boolean nSetClipToOutline(long renderNode, boolean clipToOutline); - @FastNative + @CriticalNative private static native boolean nSetRevealClip(long renderNode, boolean shouldClip, float x, float y, float radius); - @FastNative + @CriticalNative private static native boolean nSetAlpha(long renderNode, float alpha); - @FastNative + @CriticalNative private static native boolean nSetHasOverlappingRendering(long renderNode, boolean hasOverlappingRendering); - @FastNative + @CriticalNative private static native boolean nSetElevation(long renderNode, float lift); - @FastNative + @CriticalNative private static native boolean nSetTranslationX(long renderNode, float translationX); - @FastNative + @CriticalNative private static native boolean nSetTranslationY(long renderNode, float translationY); - @FastNative + @CriticalNative private static native boolean nSetTranslationZ(long renderNode, float translationZ); - @FastNative + @CriticalNative private static native boolean nSetRotation(long renderNode, float rotation); - @FastNative + @CriticalNative private static native boolean nSetRotationX(long renderNode, float rotationX); - @FastNative + @CriticalNative private static native boolean nSetRotationY(long renderNode, float rotationY); - @FastNative + @CriticalNative private static native boolean nSetScaleX(long renderNode, float scaleX); - @FastNative + @CriticalNative private static native boolean nSetScaleY(long renderNode, float scaleY); - @FastNative + @CriticalNative private static native boolean nSetStaticMatrix(long renderNode, long nativeMatrix); - @FastNative + @CriticalNative private static native boolean nSetAnimationMatrix(long renderNode, long animationMatrix); - @FastNative + @CriticalNative private static native boolean nHasOverlappingRendering(long renderNode); - @FastNative + @CriticalNative private static native boolean nGetClipToOutline(long renderNode); - @FastNative + @CriticalNative private static native float nGetAlpha(long renderNode); - @FastNative + @CriticalNative private static native float nGetCameraDistance(long renderNode); - @FastNative + @CriticalNative private static native float nGetScaleX(long renderNode); - @FastNative + @CriticalNative private static native float nGetScaleY(long renderNode); - @FastNative + @CriticalNative private static native float nGetElevation(long renderNode); - @FastNative + @CriticalNative private static native float nGetTranslationX(long renderNode); - @FastNative + @CriticalNative private static native float nGetTranslationY(long renderNode); - @FastNative + @CriticalNative private static native float nGetTranslationZ(long renderNode); - @FastNative + @CriticalNative private static native float nGetRotation(long renderNode); - @FastNative + @CriticalNative private static native float nGetRotationX(long renderNode); - @FastNative + @CriticalNative private static native float nGetRotationY(long renderNode); - @FastNative + @CriticalNative private static native boolean nIsPivotExplicitlySet(long renderNode); - @FastNative + @CriticalNative private static native float nGetPivotX(long renderNode); - @FastNative + @CriticalNative private static native float nGetPivotY(long renderNode); } diff --git a/core/jni/android_view_DisplayListCanvas.cpp b/core/jni/android_view_DisplayListCanvas.cpp index 74c073f84165c..2c4771c18d0f1 100644 --- a/core/jni/android_view_DisplayListCanvas.cpp +++ b/core/jni/android_view_DisplayListCanvas.cpp @@ -87,19 +87,17 @@ private: sp mMessage; }; -// ---------------------------------------------------------------------------- -// Setup -// ---------------------------------------------------------------------------- -static void android_view_DisplayListCanvas_insertReorderBarrier(JNIEnv* env, jobject clazz, - jlong canvasPtr, jboolean reorderEnable) { - Canvas* canvas = reinterpret_cast(canvasPtr); - canvas->insertReorderBarrier(reorderEnable); +// ---------------- Regular JNI ----------------------------- + +static void +android_app_ActivityThread_dumpGraphics(JNIEnv* env, jobject clazz, jobject javaFileDescriptor) { + int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor); + android::uirenderer::renderthread::RenderProxy::dumpGraphicsMemory(fd); } -// ---------------------------------------------------------------------------- -// Functor -// ---------------------------------------------------------------------------- + +// ---------------- @FastNative ----------------------------- static void android_view_DisplayListCanvas_callDrawGLFunction(JNIEnv* env, jobject clazz, jlong canvasPtr, jlong functorPtr, jobject releasedCallback) { @@ -112,31 +110,62 @@ static void android_view_DisplayListCanvas_callDrawGLFunction(JNIEnv* env, jobje canvas->callDrawGLFunction(functor, bridge.get()); } -// ---------------------------------------------------------------------------- -// Misc -// ---------------------------------------------------------------------------- -static jint android_view_DisplayListCanvas_getMaxTextureWidth(JNIEnv* env, jobject clazz) { +// ---------------- @CriticalNative ------------------------- + +static jlong android_view_DisplayListCanvas_createDisplayListCanvas(jlong renderNodePtr, + jint width, jint height) { + RenderNode* renderNode = reinterpret_cast(renderNodePtr); + return reinterpret_cast(Canvas::create_recording_canvas(width, height, renderNode)); +} + +static void android_view_DisplayListCanvas_resetDisplayListCanvas(jlong canvasPtr, + jlong renderNodePtr, jint width, jint height) { + Canvas* canvas = reinterpret_cast(canvasPtr); + RenderNode* renderNode = reinterpret_cast(renderNodePtr); + canvas->resetRecording(width, height, renderNode); +} + +static jint android_view_DisplayListCanvas_getMaxTextureWidth() { if (!Caches::hasInstance()) { android::uirenderer::renderthread::RenderProxy::staticFence(); } return Caches::getInstance().maxTextureSize; } -static jint android_view_DisplayListCanvas_getMaxTextureHeight(JNIEnv* env, jobject clazz) { +static jint android_view_DisplayListCanvas_getMaxTextureHeight() { if (!Caches::hasInstance()) { android::uirenderer::renderthread::RenderProxy::staticFence(); } return Caches::getInstance().maxTextureSize; } -// ---------------------------------------------------------------------------- -// Drawing -// ---------------------------------------------------------------------------- +static void android_view_DisplayListCanvas_insertReorderBarrier(jlong canvasPtr, + jboolean reorderEnable) { + Canvas* canvas = reinterpret_cast(canvasPtr); + canvas->insertReorderBarrier(reorderEnable); +} -static void android_view_DisplayListCanvas_drawRoundRectProps(JNIEnv* env, jobject clazz, - jlong canvasPtr, jlong leftPropPtr, jlong topPropPtr, jlong rightPropPtr, - jlong bottomPropPtr, jlong rxPropPtr, jlong ryPropPtr, jlong paintPropPtr) { +static jlong android_view_DisplayListCanvas_finishRecording(jlong canvasPtr) { + Canvas* canvas = reinterpret_cast(canvasPtr); + return reinterpret_cast(canvas->finishRecording()); +} + +static void android_view_DisplayListCanvas_drawRenderNode(jlong canvasPtr, jlong renderNodePtr) { + Canvas* canvas = reinterpret_cast(canvasPtr); + RenderNode* renderNode = reinterpret_cast(renderNodePtr); + canvas->drawRenderNode(renderNode); +} + +static void android_view_DisplayListCanvas_drawLayer(jlong canvasPtr, jlong layerPtr) { + Canvas* canvas = reinterpret_cast(canvasPtr); + DeferredLayerUpdater* layer = reinterpret_cast(layerPtr); + canvas->drawLayer(layer); +} + +static void android_view_DisplayListCanvas_drawRoundRectProps(jlong canvasPtr, + jlong leftPropPtr, jlong topPropPtr, jlong rightPropPtr, jlong bottomPropPtr, + jlong rxPropPtr, jlong ryPropPtr, jlong paintPropPtr) { Canvas* canvas = reinterpret_cast(canvasPtr); CanvasPropertyPrimitive* leftProp = reinterpret_cast(leftPropPtr); CanvasPropertyPrimitive* topProp = reinterpret_cast(topPropPtr); @@ -148,8 +177,8 @@ static void android_view_DisplayListCanvas_drawRoundRectProps(JNIEnv* env, jobje canvas->drawRoundRect(leftProp, topProp, rightProp, bottomProp, rxProp, ryProp, paintProp); } -static void android_view_DisplayListCanvas_drawCircleProps(JNIEnv* env, jobject clazz, - jlong canvasPtr, jlong xPropPtr, jlong yPropPtr, jlong radiusPropPtr, jlong paintPropPtr) { +static void android_view_DisplayListCanvas_drawCircleProps(jlong canvasPtr, + jlong xPropPtr, jlong yPropPtr, jlong radiusPropPtr, jlong paintPropPtr) { Canvas* canvas = reinterpret_cast(canvasPtr); CanvasPropertyPrimitive* xProp = reinterpret_cast(xPropPtr); CanvasPropertyPrimitive* yProp = reinterpret_cast(yPropPtr); @@ -158,58 +187,6 @@ static void android_view_DisplayListCanvas_drawCircleProps(JNIEnv* env, jobject canvas->drawCircle(xProp, yProp, radiusProp, paintProp); } -// ---------------------------------------------------------------------------- -// Display lists -// ---------------------------------------------------------------------------- - -static jlong android_view_DisplayListCanvas_finishRecording(JNIEnv* env, - jobject clazz, jlong canvasPtr) { - Canvas* canvas = reinterpret_cast(canvasPtr); - return reinterpret_cast(canvas->finishRecording()); -} - -static jlong android_view_DisplayListCanvas_createDisplayListCanvas(JNIEnv* env, jobject clazz, - jlong renderNodePtr, jint width, jint height) { - RenderNode* renderNode = reinterpret_cast(renderNodePtr); - return reinterpret_cast(Canvas::create_recording_canvas(width, height, renderNode)); -} - -static void android_view_DisplayListCanvas_resetDisplayListCanvas(JNIEnv* env, jobject clazz, - jlong canvasPtr, jlong renderNodePtr, jint width, jint height) { - Canvas* canvas = reinterpret_cast(canvasPtr); - RenderNode* renderNode = reinterpret_cast(renderNodePtr); - canvas->resetRecording(width, height, renderNode); -} - - -static void android_view_DisplayListCanvas_drawRenderNode(JNIEnv* env, - jobject clazz, jlong canvasPtr, jlong renderNodePtr) { - Canvas* canvas = reinterpret_cast(canvasPtr); - RenderNode* renderNode = reinterpret_cast(renderNodePtr); - canvas->drawRenderNode(renderNode); -} - -// ---------------------------------------------------------------------------- -// Layers -// ---------------------------------------------------------------------------- - -static void android_view_DisplayListCanvas_drawLayer(JNIEnv* env, jobject clazz, - jlong canvasPtr, jlong layerPtr) { - Canvas* canvas = reinterpret_cast(canvasPtr); - DeferredLayerUpdater* layer = reinterpret_cast(layerPtr); - canvas->drawLayer(layer); -} - -// ---------------------------------------------------------------------------- -// Logging -// ---------------------------------------------------------------------------- - -static void -android_app_ActivityThread_dumpGraphics(JNIEnv* env, jobject clazz, jobject javaFileDescriptor) { - int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor); - android::uirenderer::renderthread::RenderProxy::dumpGraphicsMemory(fd); -} - // ---------------------------------------------------------------------------- // JNI Glue // ---------------------------------------------------------------------------- @@ -220,28 +197,25 @@ static JNINativeMethod gMethods[] = { // ------------ @FastNative ------------------ - { "nInsertReorderBarrier","(JZ)V", (void*) android_view_DisplayListCanvas_insertReorderBarrier }, - { "nCallDrawGLFunction", "(JJLjava/lang/Runnable;)V", (void*) android_view_DisplayListCanvas_callDrawGLFunction }, - { "nDrawRoundRect", "(JJJJJJJJ)V", (void*) android_view_DisplayListCanvas_drawRoundRectProps }, - { "nDrawCircle", "(JJJJJ)V", (void*) android_view_DisplayListCanvas_drawCircleProps }, - - { "nFinishRecording", "(J)J", (void*) android_view_DisplayListCanvas_finishRecording }, - { "nDrawRenderNode", "(JJ)V", (void*) android_view_DisplayListCanvas_drawRenderNode }, - + // ------------ @CriticalNative -------------- { "nCreateDisplayListCanvas", "(JII)J", (void*) android_view_DisplayListCanvas_createDisplayListCanvas }, - { "nResetDisplayListCanvas", "(JJII)V", (void*) android_view_DisplayListCanvas_resetDisplayListCanvas }, - - { "nDrawLayer", "(JJ)V", (void*) android_view_DisplayListCanvas_drawLayer }, - - { "nGetMaximumTextureWidth", "()I", (void*) android_view_DisplayListCanvas_getMaxTextureWidth }, - { "nGetMaximumTextureHeight", "()I", (void*) android_view_DisplayListCanvas_getMaxTextureHeight }, + { "nResetDisplayListCanvas", "(JJII)V", (void*) android_view_DisplayListCanvas_resetDisplayListCanvas }, + { "nGetMaximumTextureWidth", "()I", (void*) android_view_DisplayListCanvas_getMaxTextureWidth }, + { "nGetMaximumTextureHeight", "()I", (void*) android_view_DisplayListCanvas_getMaxTextureHeight }, + { "nInsertReorderBarrier", "(JZ)V", (void*) android_view_DisplayListCanvas_insertReorderBarrier }, + { "nFinishRecording", "(J)J", (void*) android_view_DisplayListCanvas_finishRecording }, + { "nDrawRenderNode", "(JJ)V", (void*) android_view_DisplayListCanvas_drawRenderNode }, + { "nDrawLayer", "(JJ)V", (void*) android_view_DisplayListCanvas_drawLayer }, + { "nDrawCircle", "(JJJJJ)V", (void*) android_view_DisplayListCanvas_drawCircleProps }, + { "nDrawRoundRect", "(JJJJJJJJ)V",(void*) android_view_DisplayListCanvas_drawRoundRectProps }, }; static JNINativeMethod gActivityThreadMethods[] = { - { "dumpGraphicsInfo", "(Ljava/io/FileDescriptor;)V", + // ------------ Regular JNI ------------------ + { "nDumpGraphicsInfo", "(Ljava/io/FileDescriptor;)V", (void*) android_app_ActivityThread_dumpGraphics } }; diff --git a/core/jni/android_view_RenderNode.cpp b/core/jni/android_view_RenderNode.cpp index dd2a7a98b7a07..81b0fcbb96d36 100644 --- a/core/jni/android_view_RenderNode.cpp +++ b/core/jni/android_view_RenderNode.cpp @@ -51,7 +51,7 @@ static JNIEnv* getenv(JavaVM* vm) { return env; } -static jmethodID gOnRenderNodeDetached; +static jfieldID gRenderNode_validFieldID; class RenderNodeContext : public VirtualLightRefBase { public: @@ -87,7 +87,10 @@ void onRenderNodeRemoved(JNIEnv* env, RenderNode* node) { node->setUserContext(nullptr); return; } - env->CallVoidMethod(jnode, gOnRenderNodeDetached); + + // Update the valid field, since native has already removed + // the staging DisplayList + env->SetBooleanField(jnode, gRenderNode_validFieldID, false); env->DeleteLocalRef(jnode); } @@ -95,14 +98,12 @@ void onRenderNodeRemoved(JNIEnv* env, RenderNode* node) { // DisplayList view properties // ---------------------------------------------------------------------------- -static void android_view_RenderNode_output(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static void android_view_RenderNode_output(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->output(); } -static jint android_view_RenderNode_getDebugSize(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jint android_view_RenderNode_getDebugSize(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->getDebugSize(); } @@ -153,59 +154,53 @@ static void android_view_RenderNode_setDisplayList(JNIEnv* env, // RenderProperties - setters // ---------------------------------------------------------------------------- -static jboolean android_view_RenderNode_setLayerType(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jint jlayerType) { +static jboolean android_view_RenderNode_setLayerType(jlong renderNodePtr, jint jlayerType) { LayerType layerType = static_cast(jlayerType); return SET_AND_DIRTY(mutateLayerProperties().setType, layerType, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setLayerPaint(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong paintPtr) { +static jboolean android_view_RenderNode_setLayerPaint(jlong renderNodePtr, jlong paintPtr) { Paint* paint = reinterpret_cast(paintPtr); return SET_AND_DIRTY(mutateLayerProperties().setFromPaint, paint, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setStaticMatrix(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong matrixPtr) { +static jboolean android_view_RenderNode_setStaticMatrix(jlong renderNodePtr, jlong matrixPtr) { SkMatrix* matrix = reinterpret_cast(matrixPtr); return SET_AND_DIRTY(setStaticMatrix, matrix, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setAnimationMatrix(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong matrixPtr) { +static jboolean android_view_RenderNode_setAnimationMatrix(jlong renderNodePtr, jlong matrixPtr) { SkMatrix* matrix = reinterpret_cast(matrixPtr); return SET_AND_DIRTY(setAnimationMatrix, matrix, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setClipToBounds(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jboolean clipToBounds) { +static jboolean android_view_RenderNode_setClipToBounds(jlong renderNodePtr, + jboolean clipToBounds) { return SET_AND_DIRTY(setClipToBounds, clipToBounds, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setClipBounds(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jint left, jint top, jint right, jint bottom) { +static jboolean android_view_RenderNode_setClipBounds(jlong renderNodePtr, + jint left, jint top, jint right, jint bottom) { android::uirenderer::Rect clipBounds(left, top, right, bottom); return SET_AND_DIRTY(setClipBounds, clipBounds, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setClipBoundsEmpty(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_setClipBoundsEmpty(jlong renderNodePtr) { return SET_AND_DIRTY(setClipBoundsEmpty,, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setProjectBackwards(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jboolean shouldProject) { +static jboolean android_view_RenderNode_setProjectBackwards(jlong renderNodePtr, + jboolean shouldProject) { return SET_AND_DIRTY(setProjectBackwards, shouldProject, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setProjectionReceiver(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jboolean shouldRecieve) { +static jboolean android_view_RenderNode_setProjectionReceiver(jlong renderNodePtr, + jboolean shouldRecieve) { return SET_AND_DIRTY(setProjectionReceiver, shouldRecieve, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setOutlineRoundRect(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jint left, jint top, - jint right, jint bottom, jfloat radius, jfloat alpha) { +static jboolean android_view_RenderNode_setOutlineRoundRect(jlong renderNodePtr, + jint left, jint top, jint right, jint bottom, jfloat radius, jfloat alpha) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().mutableOutline().setRoundRect(left, top, right, bottom, radius, alpha); @@ -213,8 +208,8 @@ static jboolean android_view_RenderNode_setOutlineRoundRect(JNIEnv* env, return true; } -static jboolean android_view_RenderNode_setOutlineConvexPath(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong outlinePathPtr, jfloat alpha) { +static jboolean android_view_RenderNode_setOutlineConvexPath(jlong renderNodePtr, + jlong outlinePathPtr, jfloat alpha) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); SkPath* outlinePath = reinterpret_cast(outlinePathPtr); renderNode->mutateStagingProperties().mutableOutline().setConvexPath(outlinePath, alpha); @@ -222,38 +217,34 @@ static jboolean android_view_RenderNode_setOutlineConvexPath(JNIEnv* env, return true; } -static jboolean android_view_RenderNode_setOutlineEmpty(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_setOutlineEmpty(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().mutableOutline().setEmpty(); renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); return true; } -static jboolean android_view_RenderNode_setOutlineNone(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_setOutlineNone(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().mutableOutline().setNone(); renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); return true; } -static jboolean android_view_RenderNode_hasShadow(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_hasShadow(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().hasShadow(); } -static jboolean android_view_RenderNode_setClipToOutline(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jboolean clipToOutline) { +static jboolean android_view_RenderNode_setClipToOutline(jlong renderNodePtr, + jboolean clipToOutline) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().mutableOutline().setShouldClip(clipToOutline); renderNode->setPropertyFieldsDirty(RenderNode::GENERIC); return true; } -static jboolean android_view_RenderNode_setRevealClip(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jboolean shouldClip, +static jboolean android_view_RenderNode_setRevealClip(jlong renderNodePtr, jboolean shouldClip, jfloat x, jfloat y, jfloat radius) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().mutableRevealClip().set( @@ -262,100 +253,82 @@ static jboolean android_view_RenderNode_setRevealClip(JNIEnv* env, return true; } -static jboolean android_view_RenderNode_setAlpha(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float alpha) { +static jboolean android_view_RenderNode_setAlpha(jlong renderNodePtr, float alpha) { return SET_AND_DIRTY(setAlpha, alpha, RenderNode::ALPHA); } -static jboolean android_view_RenderNode_setHasOverlappingRendering(JNIEnv* env, - jobject clazz, jlong renderNodePtr, bool hasOverlappingRendering) { +static jboolean android_view_RenderNode_setHasOverlappingRendering(jlong renderNodePtr, + bool hasOverlappingRendering) { return SET_AND_DIRTY(setHasOverlappingRendering, hasOverlappingRendering, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setElevation(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float elevation) { +static jboolean android_view_RenderNode_setElevation(jlong renderNodePtr, float elevation) { return SET_AND_DIRTY(setElevation, elevation, RenderNode::Z); } -static jboolean android_view_RenderNode_setTranslationX(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float tx) { +static jboolean android_view_RenderNode_setTranslationX(jlong renderNodePtr, float tx) { return SET_AND_DIRTY(setTranslationX, tx, RenderNode::TRANSLATION_X | RenderNode::X); } -static jboolean android_view_RenderNode_setTranslationY(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float ty) { +static jboolean android_view_RenderNode_setTranslationY(jlong renderNodePtr, float ty) { return SET_AND_DIRTY(setTranslationY, ty, RenderNode::TRANSLATION_Y | RenderNode::Y); } -static jboolean android_view_RenderNode_setTranslationZ(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float tz) { +static jboolean android_view_RenderNode_setTranslationZ(jlong renderNodePtr, float tz) { return SET_AND_DIRTY(setTranslationZ, tz, RenderNode::TRANSLATION_Z | RenderNode::Z); } -static jboolean android_view_RenderNode_setRotation(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float rotation) { +static jboolean android_view_RenderNode_setRotation(jlong renderNodePtr, float rotation) { return SET_AND_DIRTY(setRotation, rotation, RenderNode::ROTATION); } -static jboolean android_view_RenderNode_setRotationX(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float rx) { +static jboolean android_view_RenderNode_setRotationX(jlong renderNodePtr, float rx) { return SET_AND_DIRTY(setRotationX, rx, RenderNode::ROTATION_X); } -static jboolean android_view_RenderNode_setRotationY(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float ry) { +static jboolean android_view_RenderNode_setRotationY(jlong renderNodePtr, float ry) { return SET_AND_DIRTY(setRotationY, ry, RenderNode::ROTATION_Y); } -static jboolean android_view_RenderNode_setScaleX(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float sx) { +static jboolean android_view_RenderNode_setScaleX(jlong renderNodePtr, float sx) { return SET_AND_DIRTY(setScaleX, sx, RenderNode::SCALE_X); } -static jboolean android_view_RenderNode_setScaleY(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float sy) { +static jboolean android_view_RenderNode_setScaleY(jlong renderNodePtr, float sy) { return SET_AND_DIRTY(setScaleY, sy, RenderNode::SCALE_Y); } -static jboolean android_view_RenderNode_setPivotX(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float px) { +static jboolean android_view_RenderNode_setPivotX(jlong renderNodePtr, float px) { return SET_AND_DIRTY(setPivotX, px, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setPivotY(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float py) { +static jboolean android_view_RenderNode_setPivotY(jlong renderNodePtr, float py) { return SET_AND_DIRTY(setPivotY, py, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setCameraDistance(JNIEnv* env, - jobject clazz, jlong renderNodePtr, float distance) { +static jboolean android_view_RenderNode_setCameraDistance(jlong renderNodePtr, float distance) { return SET_AND_DIRTY(setCameraDistance, distance, RenderNode::GENERIC); } -static jboolean android_view_RenderNode_setLeft(JNIEnv* env, - jobject clazz, jlong renderNodePtr, int left) { +static jboolean android_view_RenderNode_setLeft(jlong renderNodePtr, int left) { return SET_AND_DIRTY(setLeft, left, RenderNode::X); } -static jboolean android_view_RenderNode_setTop(JNIEnv* env, - jobject clazz, jlong renderNodePtr, int top) { +static jboolean android_view_RenderNode_setTop(jlong renderNodePtr, int top) { return SET_AND_DIRTY(setTop, top, RenderNode::Y); } -static jboolean android_view_RenderNode_setRight(JNIEnv* env, - jobject clazz, jlong renderNodePtr, int right) { +static jboolean android_view_RenderNode_setRight(jlong renderNodePtr, int right) { return SET_AND_DIRTY(setRight, right, RenderNode::X); } -static jboolean android_view_RenderNode_setBottom(JNIEnv* env, - jobject clazz, jlong renderNodePtr, int bottom) { +static jboolean android_view_RenderNode_setBottom(jlong renderNodePtr, int bottom) { return SET_AND_DIRTY(setBottom, bottom, RenderNode::Y); } -static jboolean android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env, - jobject clazz, jlong renderNodePtr, int left, int top, - int right, int bottom) { +static jboolean android_view_RenderNode_setLeftTopRightBottom(jlong renderNodePtr, + int left, int top, int right, int bottom) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); if (renderNode->mutateStagingProperties().setLeftTopRightBottom(left, top, right, bottom)) { renderNode->setPropertyFieldsDirty(RenderNode::X | RenderNode::Y); @@ -364,13 +337,11 @@ static jboolean android_view_RenderNode_setLeftTopRightBottom(JNIEnv* env, return false; } -static jboolean android_view_RenderNode_offsetLeftAndRight(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jint offset) { +static jboolean android_view_RenderNode_offsetLeftAndRight(jlong renderNodePtr, jint offset) { return SET_AND_DIRTY(offsetLeftRight, offset, RenderNode::X); } -static jboolean android_view_RenderNode_offsetTopAndBottom(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jint offset) { +static jboolean android_view_RenderNode_offsetTopAndBottom(jlong renderNodePtr, jint offset) { return SET_AND_DIRTY(offsetTopBottom, offset, RenderNode::Y); } @@ -378,92 +349,77 @@ static jboolean android_view_RenderNode_offsetTopAndBottom(JNIEnv* env, // RenderProperties - getters // ---------------------------------------------------------------------------- -static jboolean android_view_RenderNode_hasOverlappingRendering(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_hasOverlappingRendering(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().hasOverlappingRendering(); } -static jboolean android_view_RenderNode_getClipToOutline(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_getClipToOutline(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getOutline().getShouldClip(); } -static jfloat android_view_RenderNode_getAlpha(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getAlpha(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getAlpha(); } -static jfloat android_view_RenderNode_getCameraDistance(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getCameraDistance(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getCameraDistance(); } -static jfloat android_view_RenderNode_getScaleX(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getScaleX(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getScaleX(); } -static jfloat android_view_RenderNode_getScaleY(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getScaleY(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getScaleY(); } -static jfloat android_view_RenderNode_getElevation(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getElevation(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getElevation(); } -static jfloat android_view_RenderNode_getTranslationX(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getTranslationX(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getTranslationX(); } -static jfloat android_view_RenderNode_getTranslationY(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getTranslationY(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getTranslationY(); } -static jfloat android_view_RenderNode_getTranslationZ(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getTranslationZ(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getTranslationZ(); } -static jfloat android_view_RenderNode_getRotation(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getRotation(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getRotation(); } -static jfloat android_view_RenderNode_getRotationX(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getRotationX(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getRotationX(); } -static jfloat android_view_RenderNode_getRotationY(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getRotationY(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().getRotationY(); } -static jboolean android_view_RenderNode_isPivotExplicitlySet(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_isPivotExplicitlySet(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); return renderNode->stagingProperties().isPivotExplicitlySet(); } -static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jboolean android_view_RenderNode_hasIdentityMatrix(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().updateMatrix(); return !renderNode->stagingProperties().hasTransformMatrix(); @@ -473,8 +429,7 @@ static jboolean android_view_RenderNode_hasIdentityMatrix(JNIEnv* env, // RenderProperties - computed getters // ---------------------------------------------------------------------------- -static void android_view_RenderNode_getTransformMatrix(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) { +static void android_view_RenderNode_getTransformMatrix(jlong renderNodePtr, jlong outMatrixPtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); SkMatrix* outMatrix = reinterpret_cast(outMatrixPtr); @@ -488,10 +443,10 @@ static void android_view_RenderNode_getTransformMatrix(JNIEnv* env, } } -static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env, - jobject clazz, jlong renderNodePtr, jlong outMatrixPtr) { +static void android_view_RenderNode_getInverseTransformMatrix(jlong renderNodePtr, + jlong outMatrixPtr) { // load transform matrix - android_view_RenderNode_getTransformMatrix(env, clazz, renderNodePtr, outMatrixPtr); + android_view_RenderNode_getTransformMatrix(renderNodePtr, outMatrixPtr); SkMatrix* outMatrix = reinterpret_cast(outMatrixPtr); // return it inverted @@ -501,15 +456,13 @@ static void android_view_RenderNode_getInverseTransformMatrix(JNIEnv* env, } } -static jfloat android_view_RenderNode_getPivotX(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getPivotX(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().updateMatrix(); return renderNode->stagingProperties().getPivotX(); } -static jfloat android_view_RenderNode_getPivotY(JNIEnv* env, - jobject clazz, jlong renderNodePtr) { +static jfloat android_view_RenderNode_getPivotY(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->mutateStagingProperties().updateMatrix(); return renderNode->stagingProperties().getPivotY(); @@ -519,15 +472,13 @@ static jfloat android_view_RenderNode_getPivotY(JNIEnv* env, // RenderProperties - Animations // ---------------------------------------------------------------------------- -static void android_view_RenderNode_addAnimator(JNIEnv* env, jobject clazz, - jlong renderNodePtr, jlong animatorPtr) { +static void android_view_RenderNode_addAnimator(jlong renderNodePtr, jlong animatorPtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); RenderPropertyAnimator* animator = reinterpret_cast(animatorPtr); renderNode->addAnimator(animator); } -static void android_view_RenderNode_endAllAnimators(JNIEnv* env, jobject clazz, - jlong renderNodePtr) { +static void android_view_RenderNode_endAllAnimators(jlong renderNodePtr) { RenderNode* renderNode = reinterpret_cast(renderNodePtr); renderNode->animators().endAllStagingAnimators(); } @@ -651,15 +602,22 @@ static const JNINativeMethod gMethods[] = { // ---------------------------------------------------------------------------- { "nCreate", "(Ljava/lang/String;)J", (void*) android_view_RenderNode_create }, { "nGetNativeFinalizer", "()J", (void*) android_view_RenderNode_getNativeFinalizer }, - { "nSetDisplayList", "(JJ)V", (void*) android_view_RenderNode_setDisplayList }, { "nOutput", "(J)V", (void*) android_view_RenderNode_output }, { "nGetDebugSize", "(J)I", (void*) android_view_RenderNode_getDebugSize }, { "nAddAnimator", "(JJ)V", (void*) android_view_RenderNode_addAnimator }, { "nEndAllAnimators", "(J)V", (void*) android_view_RenderNode_endAllAnimators }, { "nRequestPositionUpdates", "(JLandroid/view/SurfaceView;)V", (void*) android_view_RenderNode_requestPositionUpdates }, + { "nSetDisplayList", "(JJ)V", (void*) android_view_RenderNode_setDisplayList }, + // ---------------------------------------------------------------------------- -// Fast JNI via @FastNative annotation in RenderNode.java +// Fast JNI via @CriticalNative annotation in RenderNode.java +// ---------------------------------------------------------------------------- + { "nSetDisplayList", "(JJ)V", (void*) android_view_RenderNode_setDisplayList }, + + +// ---------------------------------------------------------------------------- +// Critical JNI via @CriticalNative annotation in RenderNode.java // ---------------------------------------------------------------------------- { "nSetLayerType", "(JI)Z", (void*) android_view_RenderNode_setLayerType }, { "nSetLayerPaint", "(JJ)Z", (void*) android_view_RenderNode_setLayerPaint }, @@ -732,8 +690,7 @@ int register_android_view_RenderNode(JNIEnv* env) { gSurfaceViewPositionLostMethod = GetMethodIDOrDie(env, clazz, "windowPositionLost_uiRtSync", "(J)V"); clazz = FindClassOrDie(env, "android/view/RenderNode"); - gOnRenderNodeDetached = GetMethodIDOrDie(env, clazz, - "onRenderNodeDetached", "()V"); + gRenderNode_validFieldID = GetFieldIDOrDie(env, clazz, "mValid", "Z"); return RegisterMethodsOrDie(env, kClassPathName, gMethods, NELEM(gMethods)); }