android_view_ThreadedRenderer.cpp revision 3e8249568cc428296ac76c7ddce3f0382d40fe5b 
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
141private:
142    sp<Looper> mLooper;
143    std::vector<OnFinishedEvent> mOnFinishedEvents;
144    JavaVM* mVm;
145};
146
147static void android_view_ThreadedRenderer_setAtlas(JNIEnv* env, jobject clazz,
148        jlong proxyPtr, jobject graphicBuffer, jlongArray atlasMapArray) {
149    sp<GraphicBuffer> buffer = graphicBufferForJavaObject(env, graphicBuffer);
150    jsize len = env->GetArrayLength(atlasMapArray);
151    if (len <= 0) {
152        ALOGW("Failed to initialize atlas, invalid map length: %d", len);
153        return;
154    }
155    int64_t* map = new int64_t[len];
156    env->GetLongArrayRegion(atlasMapArray, 0, len, map);
157
158    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
159    proxy->setTextureAtlas(buffer, map, len);
160}
161
162static jlong android_view_ThreadedRenderer_createRootRenderNode(JNIEnv* env, jobject clazz) {
163    RootRenderNode* node = new RootRenderNode(env);
164    node->incStrong(0);
165    node->setName("RootRenderNode");
166    return reinterpret_cast<jlong>(node);
167}
168
169static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject clazz,
170        jboolean translucent, jlong rootRenderNodePtr) {
171    RenderNode* rootRenderNode = reinterpret_cast<RenderNode*>(rootRenderNodePtr);
172    return (jlong) new RenderProxy(translucent, rootRenderNode);
173}
174
175static void android_view_ThreadedRenderer_deleteProxy(JNIEnv* env, jobject clazz,
176        jlong proxyPtr) {
177    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
178    delete proxy;
179}
180
181static void android_view_ThreadedRenderer_setFrameInterval(JNIEnv* env, jobject clazz,
182        jlong proxyPtr, jlong frameIntervalNanos) {
183    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
184    proxy->setFrameInterval(frameIntervalNanos);
185}
186
187static jboolean android_view_ThreadedRenderer_loadSystemProperties(JNIEnv* env, jobject clazz,
188        jlong proxyPtr) {
189    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
190    return proxy->loadSystemProperties();
191}
192
193static jboolean android_view_ThreadedRenderer_initialize(JNIEnv* env, jobject clazz,
194        jlong proxyPtr, jobject jsurface) {
195    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
196    sp<ANativeWindow> window = android_view_Surface_getNativeWindow(env, jsurface);
197    return proxy->initialize(window);
198}
199
200static void android_view_ThreadedRenderer_updateSurface(JNIEnv* env, jobject clazz,
201        jlong proxyPtr, jobject jsurface) {
202    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
203    sp<ANativeWindow> window;
204    if (jsurface) {
205        window = android_view_Surface_getNativeWindow(env, jsurface);
206    }
207    proxy->updateSurface(window);
208}
209
210static void android_view_ThreadedRenderer_pauseSurface(JNIEnv* env, jobject clazz,
211        jlong proxyPtr, jobject jsurface) {
212    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
213    sp<ANativeWindow> window;
214    if (jsurface) {
215        window = android_view_Surface_getNativeWindow(env, jsurface);
216    }
217    proxy->pauseSurface(window);
218}
219
220static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz, jlong proxyPtr,
221        jint width, jint height,
222        jfloat lightX, jfloat lightY, jfloat lightZ, jfloat lightRadius,
223        jint ambientShadowAlpha, jint spotShadowAlpha) {
224    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
225    proxy->setup(width, height, (Vector3){lightX, lightY, lightZ}, lightRadius,
226            ambientShadowAlpha, spotShadowAlpha);
227}
228
229static void android_view_ThreadedRenderer_setOpaque(JNIEnv* env, jobject clazz,
230        jlong proxyPtr, jboolean opaque) {
231    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
232    proxy->setOpaque(opaque);
233}
234
235static int android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
236        jlong proxyPtr, jlong frameTimeNanos, jlong recordDuration, jfloat density) {
237    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
238    return proxy->syncAndDrawFrame(frameTimeNanos, recordDuration, density);
239}
240
241static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
242        jlong proxyPtr) {
243    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
244    proxy->destroyCanvasAndSurface();
245}
246
247static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
248        jlong functorPtr, jboolean waitForCompletion) {
249    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
250    RenderProxy::invokeFunctor(functor, waitForCompletion);
251}
252
253static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
254        jlong proxyPtr, jint width, jint height) {
255    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
256    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
257    return reinterpret_cast<jlong>(layer);
258}
259
260static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
261        jlong proxyPtr) {
262    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
263    DeferredLayerUpdater* layer = proxy->createTextureLayer();
264    return reinterpret_cast<jlong>(layer);
265}
266
267static void android_view_ThreadedRenderer_buildLayer(JNIEnv* env, jobject clazz,
268        jlong proxyPtr, jlong nodePtr) {
269    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
270    RenderNode* node = reinterpret_cast<RenderNode*>(nodePtr);
271    proxy->buildLayer(node);
272}
273
274static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
275        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
276    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
277    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
278    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
279    return proxy->copyLayerInto(layer, bitmap);
280}
281
282static void android_view_ThreadedRenderer_pushLayerUpdate(JNIEnv* env, jobject clazz,
283        jlong proxyPtr, jlong layerPtr) {
284    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
285    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
286    proxy->pushLayerUpdate(layer);
287}
288
289static void android_view_ThreadedRenderer_cancelLayerUpdate(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->cancelLayerUpdate(layer);
294}
295
296static void android_view_ThreadedRenderer_detachSurfaceTexture(JNIEnv* env, jobject clazz,
297        jlong proxyPtr, jlong layerPtr) {
298    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
299    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
300    proxy->detachSurfaceTexture(layer);
301}
302
303static void android_view_ThreadedRenderer_destroyHardwareResources(JNIEnv* env, jobject clazz,
304        jlong proxyPtr) {
305    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
306    proxy->destroyHardwareResources();
307}
308
309static void android_view_ThreadedRenderer_trimMemory(JNIEnv* env, jobject clazz,
310        jint level) {
311    RenderProxy::trimMemory(level);
312}
313
314static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
315        jlong proxyPtr) {
316    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
317    proxy->fence();
318}
319
320static void android_view_ThreadedRenderer_stopDrawing(JNIEnv* env, jobject clazz,
321        jlong proxyPtr) {
322    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
323    proxy->stopDrawing();
324}
325
326static void android_view_ThreadedRenderer_notifyFramePending(JNIEnv* env, jobject clazz,
327        jlong proxyPtr) {
328    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
329    proxy->notifyFramePending();
330}
331
332static void android_view_ThreadedRenderer_dumpProfileInfo(JNIEnv* env, jobject clazz,
333        jlong proxyPtr, jobject javaFileDescriptor) {
334    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
335    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
336    proxy->dumpProfileInfo(fd);
337}
338
339#endif
340
341// ----------------------------------------------------------------------------
342// Shaders
343// ----------------------------------------------------------------------------
344
345static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
346        jstring diskCachePath) {
347
348    const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
349    egl_cache_t::get()->setCacheFilename(cacheArray);
350    env->ReleaseStringUTFChars(diskCachePath, cacheArray);
351}
352
353// ----------------------------------------------------------------------------
354// JNI Glue
355// ----------------------------------------------------------------------------
356
357const char* const kClassPathName = "android/view/ThreadedRenderer";
358
359static JNINativeMethod gMethods[] = {
360#ifdef USE_OPENGL_RENDERER
361    { "nSetAtlas", "(JLandroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
362    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
363    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
364    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
365    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
366    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
367    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
368    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
369    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
370    { "nSetup", "(JIIFFFFII)V", (void*) android_view_ThreadedRenderer_setup },
371    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
372    { "nSyncAndDrawFrame", "(JJJF)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
373    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
374    { "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
375    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
376    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
377    { "nBuildLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_buildLayer },
378    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
379    { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
380    { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
381    { "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture },
382    { "nDestroyHardwareResources", "(J)V", (void*) android_view_ThreadedRenderer_destroyHardwareResources },
383    { "nTrimMemory", "(I)V", (void*) android_view_ThreadedRenderer_trimMemory },
384    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
385    { "nStopDrawing", "(J)V", (void*) android_view_ThreadedRenderer_stopDrawing },
386    { "nNotifyFramePending", "(J)V", (void*) android_view_ThreadedRenderer_notifyFramePending },
387    { "nDumpProfileInfo", "(JLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileInfo },
388#endif
389    { "setupShadersDiskCache", "(Ljava/lang/String;)V",
390                (void*) android_view_ThreadedRenderer_setupShadersDiskCache },
391};
392
393int register_android_view_ThreadedRenderer(JNIEnv* env) {
394    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
395}
396
397}; // namespace android
398