android_view_ThreadedRenderer.cpp revision 0a97330b98dd633b58dcfff405d94476c89e867d 
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    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
224    proxy->setup(width, height, Vector3(lightX, lightY, lightZ), lightRadius);
225}
226
227static void android_view_ThreadedRenderer_setOpaque(JNIEnv* env, jobject clazz,
228        jlong proxyPtr, jboolean opaque) {
229    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
230    proxy->setOpaque(opaque);
231}
232
233static int android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
234        jlong proxyPtr, jlong frameTimeNanos, jlong recordDuration, jfloat density) {
235    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
236    return proxy->syncAndDrawFrame(frameTimeNanos, recordDuration, density);
237}
238
239static void android_view_ThreadedRenderer_destroyCanvasAndSurface(JNIEnv* env, jobject clazz,
240        jlong proxyPtr) {
241    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
242    proxy->destroyCanvasAndSurface();
243}
244
245static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
246        jlong functorPtr, jboolean waitForCompletion) {
247    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
248    RenderProxy::invokeFunctor(functor, waitForCompletion);
249}
250
251static jlong android_view_ThreadedRenderer_createDisplayListLayer(JNIEnv* env, jobject clazz,
252        jlong proxyPtr, jint width, jint height) {
253    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
254    DeferredLayerUpdater* layer = proxy->createDisplayListLayer(width, height);
255    return reinterpret_cast<jlong>(layer);
256}
257
258static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
259        jlong proxyPtr) {
260    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
261    DeferredLayerUpdater* layer = proxy->createTextureLayer();
262    return reinterpret_cast<jlong>(layer);
263}
264
265static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
266        jlong proxyPtr, jlong layerPtr, jlong bitmapPtr) {
267    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
268    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
269    SkBitmap* bitmap = reinterpret_cast<SkBitmap*>(bitmapPtr);
270    return proxy->copyLayerInto(layer, bitmap);
271}
272
273static void android_view_ThreadedRenderer_pushLayerUpdate(JNIEnv* env, jobject clazz,
274        jlong proxyPtr, jlong layerPtr) {
275    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
276    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
277    proxy->pushLayerUpdate(layer);
278}
279
280static void android_view_ThreadedRenderer_cancelLayerUpdate(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->cancelLayerUpdate(layer);
285}
286
287static void android_view_ThreadedRenderer_detachSurfaceTexture(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->detachSurfaceTexture(layer);
292}
293
294static void android_view_ThreadedRenderer_destroyHardwareResources(JNIEnv* env, jobject clazz,
295        jlong proxyPtr) {
296    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
297    proxy->destroyHardwareResources();
298}
299
300static void android_view_ThreadedRenderer_trimMemory(JNIEnv* env, jobject clazz,
301        jint level) {
302    RenderProxy::trimMemory(level);
303}
304
305static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
306        jlong proxyPtr) {
307    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
308    proxy->fence();
309}
310
311static void android_view_ThreadedRenderer_stopDrawing(JNIEnv* env, jobject clazz,
312        jlong proxyPtr) {
313    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
314    proxy->stopDrawing();
315}
316
317static void android_view_ThreadedRenderer_notifyFramePending(JNIEnv* env, jobject clazz,
318        jlong proxyPtr) {
319    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
320    proxy->notifyFramePending();
321}
322
323static void android_view_ThreadedRenderer_dumpProfileInfo(JNIEnv* env, jobject clazz,
324        jlong proxyPtr, jobject javaFileDescriptor) {
325    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
326    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
327    proxy->dumpProfileInfo(fd);
328}
329
330#endif
331
332// ----------------------------------------------------------------------------
333// Shaders
334// ----------------------------------------------------------------------------
335
336static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
337        jstring diskCachePath) {
338
339    const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
340    egl_cache_t::get()->setCacheFilename(cacheArray);
341    env->ReleaseStringUTFChars(diskCachePath, cacheArray);
342}
343
344// ----------------------------------------------------------------------------
345// JNI Glue
346// ----------------------------------------------------------------------------
347
348const char* const kClassPathName = "android/view/ThreadedRenderer";
349
350static JNINativeMethod gMethods[] = {
351#ifdef USE_OPENGL_RENDERER
352    { "nSetAtlas", "(JLandroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
353    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
354    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
355    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
356    { "nSetFrameInterval", "(JJ)V", (void*) android_view_ThreadedRenderer_setFrameInterval },
357    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
358    { "nInitialize", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_initialize },
359    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
360    { "nPauseSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_pauseSurface },
361    { "nSetup", "(JIIFFFF)V", (void*) android_view_ThreadedRenderer_setup },
362    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
363    { "nSyncAndDrawFrame", "(JJJF)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
364    { "nDestroyCanvasAndSurface", "(J)V", (void*) android_view_ThreadedRenderer_destroyCanvasAndSurface },
365    { "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
366    { "nCreateDisplayListLayer", "(JII)J", (void*) android_view_ThreadedRenderer_createDisplayListLayer },
367    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
368    { "nCopyLayerInto", "(JJJ)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
369    { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
370    { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
371    { "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture },
372    { "nDestroyHardwareResources", "(J)V", (void*) android_view_ThreadedRenderer_destroyHardwareResources },
373    { "nTrimMemory", "(I)V", (void*) android_view_ThreadedRenderer_trimMemory },
374    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
375    { "nStopDrawing", "(J)V", (void*) android_view_ThreadedRenderer_stopDrawing },
376    { "nNotifyFramePending", "(J)V", (void*) android_view_ThreadedRenderer_notifyFramePending },
377    { "nDumpProfileInfo", "(JLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileInfo },
378#endif
379    { "setupShadersDiskCache", "(Ljava/lang/String;)V",
380                (void*) android_view_ThreadedRenderer_setupShadersDiskCache },
381};
382
383int register_android_view_ThreadedRenderer(JNIEnv* env) {
384    return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods));
385}
386
387}; // namespace android
388