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