android_view_ThreadedRenderer.cpp revision 18f16e6fba74eda173e1e7c869e6e2e2acc073ff 
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 void android_view_ThreadedRenderer_setFrameInterval(JNIEnv* env, jobject clazz,
156        jlong proxyPtr, jlong frameIntervalNanos) {
157    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
158    proxy->setFrameInterval(frameIntervalNanos);
159}
160
161static jboolean android_view_ThreadedRenderer_initialize(JNIEnv* env, jobject clazz,
162        jlong proxyPtr, jobject jsurface) {
163    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
164    sp<ANativeWindow> window = android_view_Surface_getNativeWindow(env, jsurface);
165    return proxy->initialize(window);
166}
167
168static void android_view_ThreadedRenderer_updateSurface(JNIEnv* env, jobject clazz,
169        jlong proxyPtr, jobject jsurface) {
170    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
171    sp<ANativeWindow> window;
172    if (jsurface) {
173        window = android_view_Surface_getNativeWindow(env, jsurface);
174    }
175    proxy->updateSurface(window);
176}
177
178static void android_view_ThreadedRenderer_pauseSurface(JNIEnv* env, jobject clazz,
179        jlong proxyPtr, jobject jsurface) {
180    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
181    sp<ANativeWindow> window;
182    if (jsurface) {
183        window = android_view_Surface_getNativeWindow(env, jsurface);
184    }
185    proxy->pauseSurface(window);
186}
187
188static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz,
189        jlong proxyPtr, jint width, jint height) {
190    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
191    proxy->setup(width, height);
192}
193
194static void android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
195        jlong proxyPtr, jlong frameTimeNanos, jint dirtyLeft, jint dirtyTop,
196        jint dirtyRight, jint dirtyBottom) {
197    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
198    proxy->syncAndDrawFrame(frameTimeNanos, dirtyLeft, dirtyTop, dirtyRight, dirtyBottom);
199}
200
201static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
202        jlong proxyPtr) {
203    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
204    proxy->destroyCanvasAndSurface();
205}
206
207static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
208        jlong proxyPtr, jlong functorPtr, jboolean waitForCompletion) {
209    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
210    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
211    proxy->invokeFunctor(functor, waitForCompletion);
212}
213
214static void android_view_ThreadedRenderer_runWithGlContext(JNIEnv* env, jobject clazz,
215        jlong proxyPtr, jobject jrunnable) {
216    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
217    RenderTask* task = new JavaTask(env, jrunnable);
218    proxy->runWithGlContext(task);
219}
220
221static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
222        jlong proxyPtr, jint width, jint height) {
223    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
224    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
225    return reinterpret_cast<jlong>(layer);
226}
227
228static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
229        jlong proxyPtr) {
230    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
231    DeferredLayerUpdater* layer = proxy->createTextureLayer();
232    return reinterpret_cast<jlong>(layer);
233}
234
235static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
236        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
237    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
238    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
239    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
240    return proxy->copyLayerInto(layer, bitmap);
241}
242
243static void android_view_ThreadedRenderer_destroyLayer(JNIEnv* env, jobject clazz,
244        jlong proxyPtr, jlong layerPtr) {
245    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
246    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
247    proxy->destroyLayer(layer);
248}
249
250static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
251        jlong proxyPtr) {
252    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
253    proxy->fence();
254}
255
256#endif
257
258// ----------------------------------------------------------------------------
259// JNI Glue
260// ----------------------------------------------------------------------------
261
262const char* const kClassPathName = "android/view/ThreadedRenderer";
263
264static JNINativeMethod gMethods[] = {
265#ifdef USE_OPENGL_RENDERER
266    { "postToRenderThread", "(Ljava/lang/Runnable;)V",   (void*) android_view_ThreadedRenderer_postToRenderThread },
267    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
268    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
269    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
270    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
271    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
272    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
273    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
274    { "nSetup", "(JII)V", (void*) android_view_ThreadedRenderer_setup },
275    { "nSyncAndDrawFrame", "(JJIIII)V", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
276    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
277    { "nInvokeFunctor", "(JJZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
278    { "nRunWithGlContext", "(JLjava/lang/Runnable;)V", (void*) android_view_ThreadedRenderer_runWithGlContext },
279    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
280    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
281    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
282    { "nDestroyLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_destroyLayer },
283    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
284#endif
285};
286
287int register_android_view_ThreadedRenderer(JNIEnv* env) {
288#ifdef USE_OPENGL_RENDERER
289    jclass cls = env->FindClass("java/lang/Runnable");
290    gRunnableMethod = env->GetMethodID(cls, "run", "()V");
291    env->DeleteLocalRef(cls);
292#endif
293    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
294}
295
296}; // namespace android
297