android_view_ThreadedRenderer.cpp revision f47a594f5250b1914c36423ee6b371f0b8db09d0 
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_destroyHardwareResources(JNIEnv* env, jobject clazz,
302        jlong proxyPtr) {
303    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
304    proxy->destroyHardwareResources();
305}
306
307static void android_view_ThreadedRenderer_trimMemory(JNIEnv* env, jobject clazz,
308        jint level) {
309    RenderProxy::trimMemory(level);
310}
311
312static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
313        jlong proxyPtr) {
314    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
315    proxy->fence();
316}
317
318static void android_view_ThreadedRenderer_stopDrawing(JNIEnv* env, jobject clazz,
319        jlong proxyPtr) {
320    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
321    proxy->stopDrawing();
322}
323
324static void android_view_ThreadedRenderer_notifyFramePending(JNIEnv* env, jobject clazz,
325        jlong proxyPtr) {
326    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
327    proxy->notifyFramePending();
328}
329
330static void android_view_ThreadedRenderer_dumpProfileInfo(JNIEnv* env, jobject clazz,
331        jlong proxyPtr, jobject javaFileDescriptor) {
332    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
333    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
334    proxy->dumpProfileInfo(fd);
335}
336
337#endif
338
339// ----------------------------------------------------------------------------
340// Shaders
341// ----------------------------------------------------------------------------
342
343static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
344        jstring diskCachePath) {
345
346    const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
347    egl_cache_t::get()->setCacheFilename(cacheArray);
348    env->ReleaseStringUTFChars(diskCachePath, cacheArray);
349}
350
351// ----------------------------------------------------------------------------
352// JNI Glue
353// ----------------------------------------------------------------------------
354
355const char* const kClassPathName = "android/view/ThreadedRenderer";
356
357static JNINativeMethod gMethods[] = {
358#ifdef USE_OPENGL_RENDERER
359    { "nSetAtlas", "(JLandroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
360    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
361    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
362    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
363    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
364    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
365    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
366    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
367    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
368    { "nSetup", "(JIIFFFF)V", (void*) android_view_ThreadedRenderer_setup },
369    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
370    { "nSyncAndDrawFrame", "(JJJF)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
371    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
372    { "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
373    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
374    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
375    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
376    { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
377    { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
378    { "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture },
379    { "nDestroyHardwareResources", "(J)V", (void*) android_view_ThreadedRenderer_destroyHardwareResources },
380    { "nTrimMemory", "(I)V", (void*) android_view_ThreadedRenderer_trimMemory },
381    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
382    { "nStopDrawing", "(J)V", (void*) android_view_ThreadedRenderer_stopDrawing },
383    { "nNotifyFramePending", "(J)V", (void*) android_view_ThreadedRenderer_notifyFramePending },
384    { "nDumpProfileInfo", "(JLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileInfo },
385#endif
386    { "setupShadersDiskCache", "(Ljava/lang/String;)V",
387                (void*) android_view_ThreadedRenderer_setupShadersDiskCache },
388};
389
390int register_android_view_ThreadedRenderer(JNIEnv* env) {
391    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
392}
393
394}; // namespace android
395