android_view_ThreadedRenderer.cpp revision 66f0be65a1046f54ddce0498b242c1fa0776b1ea 
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 "android_view_GraphicBuffer.h"
30
31#include <Animator.h>
32#include <RenderNode.h>
33#include <renderthread/CanvasContext.h>
34#include <renderthread/RenderProxy.h>
35#include <renderthread/RenderTask.h>
36#include <renderthread/RenderThread.h>
37
38namespace android {
39
40#ifdef USE_OPENGL_RENDERER
41
42using namespace android::uirenderer;
43using namespace android::uirenderer::renderthread;
44
45static jmethodID gRunnableMethod;
46
47class JavaTask : public RenderTask {
48public:
49    JavaTask(JNIEnv* env, jobject jrunnable) {
50        env->GetJavaVM(&mVm);
51        mRunnable = env->NewGlobalRef(jrunnable);
52    }
53
54    virtual void run() {
55        env()->CallVoidMethod(mRunnable, gRunnableMethod);
56        env()->DeleteGlobalRef(mRunnable);
57        delete this;
58    };
59
60private:
61    JNIEnv* env() {
62        JNIEnv* env;
63        if (mVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
64            return 0;
65        }
66        return env;
67    }
68
69    JavaVM* mVm;
70    jobject mRunnable;
71};
72
73class SetAtlasTask : public RenderTask {
74public:
75    SetAtlasTask(const sp<GraphicBuffer>& buffer, int64_t* map, size_t size)
76            : mBuffer(buffer)
77            , mMap(map)
78            , mMapSize(size) {
79    }
80
81    virtual void run() {
82        CanvasContext::setTextureAtlas(mBuffer, mMap, mMapSize);
83        mMap = 0;
84        delete this;
85    }
86
87private:
88    sp<GraphicBuffer> mBuffer;
89    int64_t* mMap;
90    size_t mMapSize;
91};
92
93class OnFinishedEvent {
94public:
95    OnFinishedEvent(BaseAnimator* animator, AnimationListener* listener)
96            : animator(animator), listener(listener) {}
97    sp<BaseAnimator> animator;
98    sp<AnimationListener> listener;
99};
100
101class InvokeAnimationListeners : public MessageHandler {
102public:
103    InvokeAnimationListeners(std::vector<OnFinishedEvent>& events) {
104        mOnFinishedEvents.swap(events);
105    }
106
107    static void callOnFinished(OnFinishedEvent& event) {
108        event.listener->onAnimationFinished(event.animator.get());
109    }
110
111    virtual void handleMessage(const Message& message) {
112        std::for_each(mOnFinishedEvents.begin(), mOnFinishedEvents.end(), callOnFinished);
113        mOnFinishedEvents.clear();
114    }
115
116private:
117    std::vector<OnFinishedEvent> mOnFinishedEvents;
118};
119
120class RootRenderNode : public RenderNode, public AnimationHook {
121public:
122    RootRenderNode() : RenderNode() {
123        mLooper = Looper::getForThread();
124        LOG_ALWAYS_FATAL_IF(!mLooper.get(),
125                "Must create RootRenderNode on a thread with a looper!");
126    }
127
128    virtual ~RootRenderNode() {}
129
130    virtual void callOnFinished(BaseAnimator* animator, AnimationListener* listener) {
131        OnFinishedEvent event(animator, listener);
132        mOnFinishedEvents.push_back(event);
133    }
134
135    virtual void prepareTree(TreeInfo& info) {
136        info.animationHook = this;
137        RenderNode::prepareTree(info);
138        info.animationHook = NULL;
139
140        // post all the finished stuff
141        if (mOnFinishedEvents.size()) {
142            sp<InvokeAnimationListeners> message
143                    = new InvokeAnimationListeners(mOnFinishedEvents);
144            mLooper->sendMessage(message, 0);
145        }
146    }
147
148private:
149    sp<Looper> mLooper;
150    std::vector<OnFinishedEvent> mOnFinishedEvents;
151};
152
153static void android_view_ThreadedRenderer_setAtlas(JNIEnv* env, jobject clazz,
154        jobject graphicBuffer, jlongArray atlasMapArray) {
155    sp<GraphicBuffer> buffer = graphicBufferForJavaObject(env, graphicBuffer);
156    jsize len = env->GetArrayLength(atlasMapArray);
157    if (len <= 0) {
158        ALOGW("Failed to initialize atlas, invalid map length: %d", len);
159        return;
160    }
161    int64_t* map = new int64_t[len];
162    env->GetLongArrayRegion(atlasMapArray, 0, len, map);
163
164    SetAtlasTask* task = new SetAtlasTask(buffer, map, len);
165    RenderThread::getInstance().queue(task);
166}
167
168static jlong android_view_ThreadedRenderer_createRootRenderNode(JNIEnv* env, jobject clazz) {
169    RootRenderNode* node = new RootRenderNode();
170    node->incStrong(0);
171    node->setName("RootRenderNode");
172    return reinterpret_cast<jlong>(node);
173}
174
175static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject clazz,
176        jboolean translucent, jlong rootRenderNodePtr) {
177    RenderNode* rootRenderNode = reinterpret_cast<RenderNode*>(rootRenderNodePtr);
178    return (jlong) new RenderProxy(translucent, rootRenderNode);
179}
180
181static void android_view_ThreadedRenderer_deleteProxy(JNIEnv* env, jobject clazz,
182        jlong proxyPtr) {
183    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
184    delete proxy;
185}
186
187static void android_view_ThreadedRenderer_setFrameInterval(JNIEnv* env, jobject clazz,
188        jlong proxyPtr, jlong frameIntervalNanos) {
189    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
190    proxy->setFrameInterval(frameIntervalNanos);
191}
192
193static jboolean android_view_ThreadedRenderer_loadSystemProperties(JNIEnv* env, jobject clazz,
194        jlong proxyPtr) {
195    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
196    return proxy->loadSystemProperties();
197}
198
199static jboolean android_view_ThreadedRenderer_initialize(JNIEnv* env, jobject clazz,
200        jlong proxyPtr, jobject jsurface) {
201    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
202    sp<ANativeWindow> window = android_view_Surface_getNativeWindow(env, jsurface);
203    return proxy->initialize(window);
204}
205
206static void android_view_ThreadedRenderer_updateSurface(JNIEnv* env, jobject clazz,
207        jlong proxyPtr, jobject jsurface) {
208    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
209    sp<ANativeWindow> window;
210    if (jsurface) {
211        window = android_view_Surface_getNativeWindow(env, jsurface);
212    }
213    proxy->updateSurface(window);
214}
215
216static void android_view_ThreadedRenderer_pauseSurface(JNIEnv* env, jobject clazz,
217        jlong proxyPtr, jobject jsurface) {
218    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
219    sp<ANativeWindow> window;
220    if (jsurface) {
221        window = android_view_Surface_getNativeWindow(env, jsurface);
222    }
223    proxy->pauseSurface(window);
224}
225
226static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz,
227        jlong proxyPtr, jint width, jint height) {
228    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
229    proxy->setup(width, height);
230}
231
232static void android_view_ThreadedRenderer_setOpaque(JNIEnv* env, jobject clazz,
233        jlong proxyPtr, jboolean opaque) {
234    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
235    proxy->setOpaque(opaque);
236}
237
238static int android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
239        jlong proxyPtr, jlong frameTimeNanos, jint dirtyLeft, jint dirtyTop,
240        jint dirtyRight, jint dirtyBottom) {
241    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
242    return proxy->syncAndDrawFrame(frameTimeNanos, dirtyLeft, dirtyTop, dirtyRight, dirtyBottom);
243}
244
245static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
246        jlong proxyPtr) {
247    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
248    proxy->destroyCanvasAndSurface();
249}
250
251static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
252        jlong proxyPtr, jlong functorPtr, jboolean waitForCompletion) {
253    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
254    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
255    proxy->invokeFunctor(functor, waitForCompletion);
256}
257
258static void android_view_ThreadedRenderer_runWithGlContext(JNIEnv* env, jobject clazz,
259        jlong proxyPtr, jobject jrunnable) {
260    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
261    RenderTask* task = new JavaTask(env, jrunnable);
262    proxy->runWithGlContext(task);
263}
264
265static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
266        jlong proxyPtr, jint width, jint height) {
267    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
268    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
269    return reinterpret_cast<jlong>(layer);
270}
271
272static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
273        jlong proxyPtr) {
274    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
275    DeferredLayerUpdater* layer = proxy->createTextureLayer();
276    return reinterpret_cast<jlong>(layer);
277}
278
279static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
280        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
281    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
282    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
283    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
284    return proxy->copyLayerInto(layer, bitmap);
285}
286
287static void android_view_ThreadedRenderer_destroyLayer(JNIEnv* env, jobject clazz,
288        jlong proxyPtr, jlong layerPtr) {
289    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
290    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
291    proxy->destroyLayer(layer);
292}
293
294static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
295        jlong proxyPtr) {
296    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
297    proxy->fence();
298}
299
300#endif
301
302// ----------------------------------------------------------------------------
303// JNI Glue
304// ----------------------------------------------------------------------------
305
306const char* const kClassPathName = "android/view/ThreadedRenderer";
307
308static JNINativeMethod gMethods[] = {
309#ifdef USE_OPENGL_RENDERER
310    { "nSetAtlas", "(Landroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
311    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
312    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
313    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
314    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
315    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
316    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
317    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
318    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
319    { "nSetup", "(JII)V", (void*) android_view_ThreadedRenderer_setup },
320    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
321    { "nSyncAndDrawFrame", "(JJIIII)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
322    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
323    { "nInvokeFunctor", "(JJZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
324    { "nRunWithGlContext", "(JLjava/lang/Runnable;)V", (void*) android_view_ThreadedRenderer_runWithGlContext },
325    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
326    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
327    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
328    { "nDestroyLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_destroyLayer },
329    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
330#endif
331};
332
333int register_android_view_ThreadedRenderer(JNIEnv* env) {
334#ifdef USE_OPENGL_RENDERER
335    jclass cls = env->FindClass("java/lang/Runnable");
336    gRunnableMethod = env->GetMethodID(cls, "run", "()V");
337    env->DeleteLocalRef(cls);
338#endif
339    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
340}
341
342}; // namespace android
343