android_view_ThreadedRenderer.cpp revision 918ad523b2780e0c893f3d2a32d4ec13f2a7e921 
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 <EGL/egl.h>
26#include <EGL/eglext.h>
27#include <EGL/egl_cache.h>
28
29#include <utils/StrongPointer.h>
30#include <android_runtime/android_view_Surface.h>
31#include <system/window.h>
32
33#include "android_view_GraphicBuffer.h"
34
35#include <Animator.h>
36#include <RenderNode.h>
37#include <renderthread/CanvasContext.h>
38#include <renderthread/RenderProxy.h>
39#include <renderthread/RenderTask.h>
40#include <renderthread/RenderThread.h>
41#include <Vector.h>
42
43namespace android {
44
45#ifdef USE_OPENGL_RENDERER
46
47using namespace android::uirenderer;
48using namespace android::uirenderer::renderthread;
49
50static JNIEnv* getenv(JavaVM* vm) {
51    JNIEnv* env;
52    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
53        LOG_ALWAYS_FATAL("Failed to get JNIEnv for JavaVM: %p", vm);
54    }
55    return env;
56}
57
58class OnFinishedEvent {
59public:
60    OnFinishedEvent(BaseRenderNodeAnimator* animator, AnimationListener* listener)
61            : animator(animator), listener(listener) {}
62    sp<BaseRenderNodeAnimator> animator;
63    sp<AnimationListener> listener;
64};
65
66class InvokeAnimationListeners : public MessageHandler {
67public:
68    InvokeAnimationListeners(std::vector<OnFinishedEvent>& events) {
69        mOnFinishedEvents.swap(events);
70    }
71
72    static void callOnFinished(OnFinishedEvent& event) {
73        event.listener->onAnimationFinished(event.animator.get());
74    }
75
76    virtual void handleMessage(const Message& message) {
77        std::for_each(mOnFinishedEvents.begin(), mOnFinishedEvents.end(), callOnFinished);
78        mOnFinishedEvents.clear();
79    }
80
81private:
82    std::vector<OnFinishedEvent> mOnFinishedEvents;
83};
84
85class RenderingException : public MessageHandler {
86public:
87    RenderingException(JavaVM* vm, const std::string& message)
88            : mVm(vm)
89            , mMessage(message) {
90    }
91
92    virtual void handleMessage(const Message&) {
93        throwException(mVm, mMessage);
94    }
95
96    static void throwException(JavaVM* vm, const std::string& message) {
97        JNIEnv* env = getenv(vm);
98        jniThrowException(env, "java/lang/IllegalStateException", message.c_str());
99    }
100
101private:
102    JavaVM* mVm;
103    std::string mMessage;
104};
105
106class RootRenderNode : public RenderNode, AnimationHook, ErrorHandler {
107public:
108    RootRenderNode(JNIEnv* env) : RenderNode() {
109        mLooper = Looper::getForThread();
110        LOG_ALWAYS_FATAL_IF(!mLooper.get(),
111                "Must create RootRenderNode on a thread with a looper!");
112        env->GetJavaVM(&mVm);
113    }
114
115    virtual ~RootRenderNode() {}
116
117    virtual void callOnFinished(BaseRenderNodeAnimator* animator, AnimationListener* listener) {
118        OnFinishedEvent event(animator, listener);
119        mOnFinishedEvents.push_back(event);
120    }
121
122    virtual void onError(const std::string& message) {
123        mLooper->sendMessage(new RenderingException(mVm, message), 0);
124    }
125
126    virtual void prepareTree(TreeInfo& info) {
127        info.animationHook = this;
128        info.errorHandler = this;
129        RenderNode::prepareTree(info);
130        info.animationHook = NULL;
131        info.errorHandler = NULL;
132
133        // post all the finished stuff
134        if (mOnFinishedEvents.size()) {
135            sp<InvokeAnimationListeners> message
136                    = new InvokeAnimationListeners(mOnFinishedEvents);
137            mLooper->sendMessage(message, 0);
138        }
139    }
140
141protected:
142    virtual void damageSelf(TreeInfo& info) {
143        // Intentionally a no-op. As RootRenderNode gets a new DisplayListData
144        // every frame this would result in every draw push being a full inval,
145        // which is wrong. Only RootRenderNode has this issue.
146    }
147
148private:
149    sp<Looper> mLooper;
150    std::vector<OnFinishedEvent> mOnFinishedEvents;
151    JavaVM* mVm;
152};
153
154static void android_view_ThreadedRenderer_setAtlas(JNIEnv* env, jobject clazz,
155        jlong proxyPtr, 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    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
166    proxy->setTextureAtlas(buffer, map, len);
167}
168
169static jlong android_view_ThreadedRenderer_createRootRenderNode(JNIEnv* env, jobject clazz) {
170    RootRenderNode* node = new RootRenderNode(env);
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, jlong recordDuration, jfloat density) {
242    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
243    return proxy->syncAndDrawFrame(frameTimeNanos, recordDuration, density);
244}
245
246static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
247        jlong proxyPtr) {
248    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
249    proxy->destroyCanvasAndSurface();
250}
251
252static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
253        jlong functorPtr, jboolean waitForCompletion) {
254    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
255    RenderProxy::invokeFunctor(functor, waitForCompletion);
256}
257
258static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
259        jlong proxyPtr, jint width, jint height) {
260    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
261    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
262    return reinterpret_cast<jlong>(layer);
263}
264
265static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
266        jlong proxyPtr) {
267    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
268    DeferredLayerUpdater* layer = proxy->createTextureLayer();
269    return reinterpret_cast<jlong>(layer);
270}
271
272static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
273        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
274    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
275    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
276    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
277    return proxy->copyLayerInto(layer, bitmap);
278}
279
280static void android_view_ThreadedRenderer_pushLayerUpdate(JNIEnv* env, jobject clazz,
281        jlong proxyPtr, jlong layerPtr) {
282    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
283    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
284    proxy->pushLayerUpdate(layer);
285}
286
287static void android_view_ThreadedRenderer_cancelLayerUpdate(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->cancelLayerUpdate(layer);
292}
293
294static void android_view_ThreadedRenderer_detachSurfaceTexture(JNIEnv* env, jobject clazz,
295        jlong proxyPtr, jlong layerPtr) {
296    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
297    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
298    proxy->detachSurfaceTexture(layer);
299}
300
301static void android_view_ThreadedRenderer_flushCaches(JNIEnv* env, jobject clazz,
302        jlong proxyPtr, jint flushMode) {
303    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
304    proxy->flushCaches(static_cast<Caches::FlushMode>(flushMode));
305}
306
307static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
308        jlong proxyPtr) {
309    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
310    proxy->fence();
311}
312
313static void android_view_ThreadedRenderer_notifyFramePending(JNIEnv* env, jobject clazz,
314        jlong proxyPtr) {
315    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
316    proxy->notifyFramePending();
317}
318
319static void android_view_ThreadedRenderer_dumpProfileInfo(JNIEnv* env, jobject clazz,
320        jlong proxyPtr, jobject javaFileDescriptor) {
321    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
322    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
323    proxy->dumpProfileInfo(fd);
324}
325
326#endif
327
328// ----------------------------------------------------------------------------
329// Shaders
330// ----------------------------------------------------------------------------
331
332static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
333        jstring diskCachePath) {
334
335    const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
336    egl_cache_t::get()->setCacheFilename(cacheArray);
337    env->ReleaseStringUTFChars(diskCachePath, cacheArray);
338}
339
340// ----------------------------------------------------------------------------
341// JNI Glue
342// ----------------------------------------------------------------------------
343
344const char* const kClassPathName = "android/view/ThreadedRenderer";
345
346static JNINativeMethod gMethods[] = {
347#ifdef USE_OPENGL_RENDERER
348    { "nSetAtlas", "(JLandroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
349    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
350    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
351    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
352    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
353    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
354    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
355    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
356    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
357    { "nSetup", "(JIIFFFF)V", (void*) android_view_ThreadedRenderer_setup },
358    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
359    { "nSyncAndDrawFrame", "(JJJF)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
360    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
361    { "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
362    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
363    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
364    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
365    { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
366    { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
367    { "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture },
368    { "nFlushCaches", "(JI)V", (void*) android_view_ThreadedRenderer_flushCaches },
369    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
370    { "nNotifyFramePending", "(J)V", (void*) android_view_ThreadedRenderer_notifyFramePending },
371    { "nDumpProfileInfo", "(JLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileInfo },
372#endif
373    { "setupShadersDiskCache", "(Ljava/lang/String;)V",
374                (void*) android_view_ThreadedRenderer_setupShadersDiskCache },
375};
376
377int register_android_view_ThreadedRenderer(JNIEnv* env) {
378    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
379}
380
381}; // namespace android
382