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