Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 107843de authored by Tom Hudson's avatar Tom Hudson
Browse files

Remove status return from all uirenderer::Renderer functions 

This moves the interface closer to android::Canvas. The only use of
return values was in the OpenGLRenderer subclass; that is replaced
with an internal dirty flag: returned from finish(), checked by
CanvasContext.

This is part of a series of CLs to refactor the Graphics JNI bindings.

BUG:15672762
R=djsollen@google.com,ccraik@google.com

Change-Id: Ifd533eb8839a254b0d3a5d04fc5a2905afdfc89e
parent daccecb2

core/java/android/view/GLES20Canvas.java

+12 −12
Original line number Diff line number Diff line
@@ -191,17 +191,17 @@ class GLES20Canvas extends HardwareCanvas { 
    private static native void nInsertReorderBarrier(long renderer, boolean enableReorder);



    @Override

    public int onPreDraw(Rect dirty) {

    public void onPreDraw(Rect dirty) {

        if (dirty != null) {

            return nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom,

            nPrepareDirty(mRenderer, dirty.left, dirty.top, dirty.right, dirty.bottom,

                    mOpaque);

        } else {

            return nPrepare(mRenderer, mOpaque);

            nPrepare(mRenderer, mOpaque);

        }

    }



    private static native int nPrepare(long renderer, boolean opaque);

    private static native int nPrepareDirty(long renderer, int left, int top, int right, int bottom,

    private static native void nPrepare(long renderer, boolean opaque);

    private static native void nPrepareDirty(long renderer, int left, int top, int right, int bottom,

            boolean opaque);



    @Override
@@ -216,11 +216,11 @@ class GLES20Canvas extends HardwareCanvas { 
    ///////////////////////////////////////////////////////////////////////////



    @Override

    public int callDrawGLFunction(long drawGLFunction) {

        return nCallDrawGLFunction(mRenderer, drawGLFunction);

    public void callDrawGLFunction(long drawGLFunction) {

        nCallDrawGLFunction(mRenderer, drawGLFunction);

    }



    private static native int nCallDrawGLFunction(long renderer, long drawGLFunction);

    private static native void nCallDrawGLFunction(long renderer, long drawGLFunction);



    ///////////////////////////////////////////////////////////////////////////

    // Display list
@@ -229,12 +229,12 @@ class GLES20Canvas extends HardwareCanvas { 
    protected static native long nFinishRecording(long renderer);



    @Override

    public int drawRenderNode(RenderNode renderNode, Rect dirty, int flags) {

        return nDrawRenderNode(mRenderer, renderNode.getNativeDisplayList(), dirty, flags);

    public void drawRenderNode(RenderNode renderNode, int flags) {

        nDrawRenderNode(mRenderer, renderNode.getNativeDisplayList(), flags);

    }



    private static native int nDrawRenderNode(long renderer, long renderNode,

            Rect dirty, int flags);

    private static native void nDrawRenderNode(long renderer, long renderNode,

            int flags);



    ///////////////////////////////////////////////////////////////////////////

    // Hardware layer

core/java/android/view/HardwareCanvas.java

+4 −12
Original line number Diff line number Diff line
@@ -43,12 +43,10 @@ public abstract class HardwareCanvas extends Canvas { 
     * Invoked before any drawing operation is performed in this canvas.

     *

     * @param dirty The dirty rectangle to update, can be null.

     * @return {@link RenderNode#STATUS_DREW} if anything was drawn (such as a call to clear

     *         the canvas).

     *

     * @hide

     */

    public abstract int onPreDraw(Rect dirty);

    public abstract void onPreDraw(Rect dirty);



    /**

     * Invoked after all drawing operation have been performed.
@@ -64,7 +62,7 @@ public abstract class HardwareCanvas extends Canvas { 
     * @param renderNode The RenderNode to replay.

     */

    public void drawRenderNode(RenderNode renderNode) {

        drawRenderNode(renderNode, null, RenderNode.FLAG_CLIP_CHILDREN);

        drawRenderNode(renderNode, RenderNode.FLAG_CLIP_CHILDREN);

    }



    /**
@@ -75,12 +73,9 @@ public abstract class HardwareCanvas extends Canvas { 
     * @param flags Optional flags about drawing, see {@link RenderNode} for

     *              the possible flags.

     *

     * @return One of {@link RenderNode#STATUS_DONE} or {@link RenderNode#STATUS_DREW}

     *         if anything was drawn.

     *

     * @hide

     */

    public abstract int drawRenderNode(RenderNode renderNode, Rect dirty, int flags);

    public abstract void drawRenderNode(RenderNode renderNode, int flags);



    /**

     * Draws the specified layer onto this canvas.
@@ -101,13 +96,10 @@ public abstract class HardwareCanvas extends Canvas { 
     *

     * @param drawGLFunction A native function pointer

     *

     * @return {@link RenderNode#STATUS_DONE}

     *

     * @hide

     */

    public int callDrawGLFunction(long drawGLFunction) {

    public void callDrawGLFunction(long drawGLFunction) {

        // Noop - this is done in the display list recorder subclass

        return RenderNode.STATUS_DONE;

    }



    public abstract void drawCircle(CanvasProperty<Float> cx, CanvasProperty<Float> cy,

core/java/android/view/View.java

+1 −1
Original line number Diff line number Diff line
@@ -15202,7 +15202,7 @@ public class View implements Drawable.Callback, KeyEvent.Callback, 
                    }

                } else {

                    mPrivateFlags &= ~PFLAG_DIRTY_MASK;

                    ((HardwareCanvas) canvas).drawRenderNode(renderNode, null, flags);

                    ((HardwareCanvas) canvas).drawRenderNode(renderNode, flags);

                }

            }

        } else if (cache != null) {

core/java/android/widget/Editor.java

+1 −1
Original line number Diff line number Diff line
@@ -1402,7 +1402,7 @@ public class Editor { 
                    blockDisplayList.setLeftTopRightBottom(left, top, right, bottom);

                }



                ((HardwareCanvas) canvas).drawRenderNode(blockDisplayList, null,

                ((HardwareCanvas) canvas).drawRenderNode(blockDisplayList,

                        0 /* no child clipping, our TextView parent enforces it */);



                endOfPreviousBlock = blockEndLine;

core/jni/android_view_GLES20Canvas.cpp

+15 −20
Original line number Diff line number Diff line
@@ -111,17 +111,17 @@ static void android_view_GLES20Canvas_insertReorderBarrier(JNIEnv* env, jobject 
    renderer->insertReorderBarrier(reorderEnable);

}



static int android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,

static void android_view_GLES20Canvas_prepare(JNIEnv* env, jobject clazz,

        jlong rendererPtr, jboolean opaque) {

    DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);

    return renderer->prepare(opaque);

    renderer->prepare(opaque);

}



static int android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,

static void android_view_GLES20Canvas_prepareDirty(JNIEnv* env, jobject clazz,

        jlong rendererPtr, jint left, jint top, jint right, jint bottom,

        jboolean opaque) {

    DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);

    return renderer->prepareDirty(left, top, right, bottom, opaque);

    renderer->prepareDirty(left, top, right, bottom, opaque);

}



static void android_view_GLES20Canvas_finish(JNIEnv* env, jobject clazz,
@@ -152,12 +152,12 @@ static void android_view_GLES20Canvas_setProperty(JNIEnv* env, 
// Functor

// ----------------------------------------------------------------------------



static jint android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz,

static void android_view_GLES20Canvas_callDrawGLFunction(JNIEnv* env, jobject clazz,

        jlong rendererPtr, jlong functorPtr) {

    DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);

    Functor* functor = reinterpret_cast<Functor*>(functorPtr);

    android::uirenderer::Rect dirty;

    return renderer->callDrawGLFunction(functor, dirty);

    renderer->callDrawGLFunction(functor, dirty);

}



// ----------------------------------------------------------------------------
@@ -802,18 +802,13 @@ static jlong android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv* env, jo 
    return reinterpret_cast<jlong>(new DisplayListRenderer);

}



static jint android_view_GLES20Canvas_drawRenderNode(JNIEnv* env,

static void android_view_GLES20Canvas_drawRenderNode(JNIEnv* env,

        jobject clazz, jlong rendererPtr, jlong renderNodePtr,

        jobject dirty, jint flags) {

        jint flags) {

    DisplayListRenderer* renderer = reinterpret_cast<DisplayListRenderer*>(rendererPtr);

    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);

    android::uirenderer::Rect bounds;

    status_t status = renderer->drawRenderNode(renderNode, bounds, flags);

    if (status != DrawGlInfo::kStatusDone && dirty != NULL) {

        env->CallVoidMethod(dirty, gRectClassInfo.set,

                int(bounds.left), int(bounds.top), int(bounds.right), int(bounds.bottom));

    }

    return status;

    renderer->drawRenderNode(renderNode, bounds, flags);

}



// ----------------------------------------------------------------------------
@@ -876,13 +871,13 @@ static JNINativeMethod gMethods[] = { 
    { "nSetViewport",       "(JII)V",          (void*) android_view_GLES20Canvas_setViewport },

    { "nSetHighContrastText","(JZ)V",          (void*) android_view_GLES20Canvas_setHighContrastText },

    { "nInsertReorderBarrier","(JZ)V",         (void*) android_view_GLES20Canvas_insertReorderBarrier },

    { "nPrepare",           "(JZ)I",           (void*) android_view_GLES20Canvas_prepare },

    { "nPrepareDirty",      "(JIIIIZ)I",       (void*) android_view_GLES20Canvas_prepareDirty },

    { "nPrepare",           "(JZ)V",           (void*) android_view_GLES20Canvas_prepare },

    { "nPrepareDirty",      "(JIIIIZ)V",       (void*) android_view_GLES20Canvas_prepareDirty },

    { "nFinish",            "(J)V",            (void*) android_view_GLES20Canvas_finish },

    { "nSetProperty",           "(Ljava/lang/String;Ljava/lang/String;)V",

            (void*) android_view_GLES20Canvas_setProperty },



    { "nCallDrawGLFunction", "(JJ)I",          (void*) android_view_GLES20Canvas_callDrawGLFunction },

    { "nCallDrawGLFunction", "(JJ)V",          (void*) android_view_GLES20Canvas_callDrawGLFunction },



    { "nSave",              "(JI)I",           (void*) android_view_GLES20Canvas_save },

    { "nRestore",           "(J)V",            (void*) android_view_GLES20Canvas_restore },
@@ -949,7 +944,7 @@ static JNINativeMethod gMethods[] = { 
    { "nGetClipBounds",     "(JLandroid/graphics/Rect;)Z", (void*) android_view_GLES20Canvas_getClipBounds },



    { "nFinishRecording",   "(J)J",            (void*) android_view_GLES20Canvas_finishRecording },

    { "nDrawRenderNode",    "(JJLandroid/graphics/Rect;I)I", (void*) android_view_GLES20Canvas_drawRenderNode },

    { "nDrawRenderNode",    "(JJI)V",          (void*) android_view_GLES20Canvas_drawRenderNode },



    { "nCreateDisplayListRenderer", "()J",     (void*) android_view_GLES20Canvas_createDisplayListRenderer },