android_view_ThreadedRenderer.cpp revision 52244fff29042926e21fa897ef5ab11148e35299 
1/*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#define LOG_TAG "ThreadedRenderer"
18
19#include <algorithm>
20
21#include "jni.h"
22#include <nativehelper/JNIHelp.h>
23#include <android_runtime/AndroidRuntime.h>
24
25#include <utils/StrongPointer.h>
26#include <android_runtime/android_view_Surface.h>
27#include <system/window.h>
28
29#include <Animator.h>
30#include <RenderNode.h>
31#include <renderthread/RenderProxy.h>
32#include <renderthread/RenderTask.h>
33#include <renderthread/RenderThread.h>
34
35namespace android {
36
37#ifdef USE_OPENGL_RENDERER
38
39using namespace android::uirenderer;
40using namespace android::uirenderer::renderthread;
41
42static jmethodID gRunnableMethod;
43
44class JavaTask : public RenderTask {
45public:
46    JavaTask(JNIEnv* env, jobject jrunnable) {
47        env->GetJavaVM(&mVm);
48        mRunnable = env->NewGlobalRef(jrunnable);
49    }
50
51    virtual void run() {
52        env()->CallVoidMethod(mRunnable, gRunnableMethod);
53        env()->DeleteGlobalRef(mRunnable);
54        delete this;
55    };
56
57private:
58    JNIEnv* env() {
59        JNIEnv* env;
60        if (mVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
61            return 0;
62        }
63        return env;
64    }
65
66    JavaVM* mVm;
67    jobject mRunnable;
68};
69
70class OnFinishedEvent {
71public:
72    OnFinishedEvent(BaseAnimator* animator, AnimationListener* listener)
73            : animator(animator), listener(listener) {}
74    sp<BaseAnimator> animator;
75    sp<AnimationListener> listener;
76};
77
78class InvokeAnimationListeners : public MessageHandler {
79public:
80    InvokeAnimationListeners(std::vector<OnFinishedEvent>& events) {
81        mOnFinishedEvents.swap(events);
82    }
83
84    static void callOnFinished(OnFinishedEvent& event) {
85        event.listener->onAnimationFinished(event.animator.get());
86    }
87
88    virtual void handleMessage(const Message& message) {
89        std::for_each(mOnFinishedEvents.begin(), mOnFinishedEvents.end(), callOnFinished);
90        mOnFinishedEvents.clear();
91    }
92
93private:
94    std::vector<OnFinishedEvent> mOnFinishedEvents;
95};
96
97class RootRenderNode : public RenderNode, public AnimationHook {
98public:
99    RootRenderNode() : RenderNode() {
100        mLooper = Looper::getForThread();
101        LOG_ALWAYS_FATAL_IF(!mLooper.get(),
102                "Must create RootRenderNode on a thread with a looper!");
103    }
104
105    virtual ~RootRenderNode() {}
106
107    virtual void callOnFinished(BaseAnimator* animator, AnimationListener* listener) {
108        OnFinishedEvent event(animator, listener);
109        mOnFinishedEvents.push_back(event);
110    }
111
112    virtual void prepareTree(TreeInfo& info) {
113        info.animationHook = this;
114        RenderNode::prepareTree(info);
115        info.animationHook = NULL;
116
117        // post all the finished stuff
118        if (mOnFinishedEvents.size()) {
119            sp<InvokeAnimationListeners> message
120                    = new InvokeAnimationListeners(mOnFinishedEvents);
121            mLooper->sendMessage(message, 0);
122        }
123    }
124
125private:
126    sp<Looper> mLooper;
127    std::vector<OnFinishedEvent> mOnFinishedEvents;
128};
129
130static void android_view_ThreadedRenderer_postToRenderThread(JNIEnv* env, jobject clazz,
131        jobject jrunnable) {
132    RenderTask* task = new JavaTask(env, jrunnable);
133    RenderThread::getInstance().queue(task);
134}
135
136static jlong android_view_ThreadedRenderer_createRootRenderNode(JNIEnv* env, jobject clazz) {
137    RootRenderNode* node = new RootRenderNode();
138    node->incStrong(0);
139    node->setName("RootRenderNode");
140    return reinterpret_cast<jlong>(node);
141}
142
143static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject clazz,
144        jboolean translucent, jlong rootRenderNodePtr) {
145    RenderNode* rootRenderNode = reinterpret_cast<RenderNode*>(rootRenderNodePtr);
146    return (jlong) new RenderProxy(translucent, rootRenderNode);
147}
148
149static void android_view_ThreadedRenderer_deleteProxy(JNIEnv* env, jobject clazz,
150        jlong proxyPtr) {
151    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
152    delete proxy;
153}
154
155static jboolean android_view_ThreadedRenderer_initialize(JNIEnv* env, jobject clazz,
156        jlong proxyPtr, jobject jsurface) {
157    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
158    sp<ANativeWindow> window = android_view_Surface_getNativeWindow(env, jsurface);
159    return proxy->initialize(window);
160}
161
162static void android_view_ThreadedRenderer_updateSurface(JNIEnv* env, jobject clazz,
163        jlong proxyPtr, jobject jsurface) {
164    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
165    sp<ANativeWindow> window;
166    if (jsurface) {
167        window = android_view_Surface_getNativeWindow(env, jsurface);
168    }
169    proxy->updateSurface(window);
170}
171
172static void android_view_ThreadedRenderer_pauseSurface(JNIEnv* env, jobject clazz,
173        jlong proxyPtr, jobject jsurface) {
174    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
175    sp<ANativeWindow> window;
176    if (jsurface) {
177        window = android_view_Surface_getNativeWindow(env, jsurface);
178    }
179    proxy->pauseSurface(window);
180}
181
182static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz,
183        jlong proxyPtr, jint width, jint height) {
184    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
185    proxy->setup(width, height);
186}
187
188static void android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
189        jlong proxyPtr, jint dirtyLeft, jint dirtyTop,
190        jint dirtyRight, jint dirtyBottom) {
191    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
192    proxy->syncAndDrawFrame(dirtyLeft, dirtyTop, dirtyRight, dirtyBottom);
193}
194
195static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
196        jlong proxyPtr) {
197    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
198    proxy->destroyCanvasAndSurface();
199}
200
201static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
202        jlong proxyPtr, jlong functorPtr, jboolean waitForCompletion) {
203    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
204    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
205    proxy->invokeFunctor(functor, waitForCompletion);
206}
207
208static void android_view_ThreadedRenderer_runWithGlContext(JNIEnv* env, jobject clazz,
209        jlong proxyPtr, jobject jrunnable) {
210    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
211    RenderTask* task = new JavaTask(env, jrunnable);
212    proxy->runWithGlContext(task);
213}
214
215static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
216        jlong proxyPtr, jint width, jint height) {
217    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
218    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
219    return reinterpret_cast<jlong>(layer);
220}
221
222static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
223        jlong proxyPtr) {
224    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
225    DeferredLayerUpdater* layer = proxy->createTextureLayer();
226    return reinterpret_cast<jlong>(layer);
227}
228
229static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
230        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
231    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
232    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
233    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
234    return proxy->copyLayerInto(layer, bitmap);
235}
236
237static void android_view_ThreadedRenderer_destroyLayer(JNIEnv* env, jobject clazz,
238        jlong proxyPtr, jlong layerPtr) {
239    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
240    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
241    proxy->destroyLayer(layer);
242}
243
244static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
245        jlong proxyPtr) {
246    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
247    proxy->fence();
248}
249
250#endif
251
252// ----------------------------------------------------------------------------
253// JNI Glue
254// ----------------------------------------------------------------------------
255
256const char* const kClassPathName = "android/view/ThreadedRenderer";
257
258static JNINativeMethod gMethods[] = {
259#ifdef USE_OPENGL_RENDERER
260    { "postToRenderThread", "(Ljava/lang/Runnable;)V",   (void*) android_view_ThreadedRenderer_postToRenderThread },
261    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
262    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
263    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
264    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
265    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
266    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
267    { "nSetup", "(JII)V", (void*) android_view_ThreadedRenderer_setup },
268    { "nSyncAndDrawFrame", "(JIIII)V", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
269    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
270    { "nInvokeFunctor", "(JJZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
271    { "nRunWithGlContext", "(JLjava/lang/Runnable;)V", (void*) android_view_ThreadedRenderer_runWithGlContext },
272    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
273    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
274    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
275    { "nDestroyLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_destroyLayer },
276    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
277#endif
278};
279
280int register_android_view_ThreadedRenderer(JNIEnv* env) {
281#ifdef USE_OPENGL_RENDERER
282    jclass cls = env->FindClass("java/lang/Runnable");
283    gRunnableMethod = env->GetMethodID(cls, "run", "()V");
284    env->DeleteLocalRef(cls);
285#endif
286    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
287}
288
289}; // namespace android
290