android_view_ThreadedRenderer.cpp revision 06f5bc70a667a02b14e31d3f53f91d3661e30666 
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 "core_jni_helpers.h"
24#include <GraphicsJNI.h>
25#include <ScopedPrimitiveArray.h>
26
27#include <EGL/egl.h>
28#include <EGL/eglext.h>
29#include <EGL/egl_cache.h>
30
31#include <utils/Looper.h>
32#include <utils/RefBase.h>
33#include <utils/StrongPointer.h>
34#include <android_runtime/android_view_Surface.h>
35#include <system/window.h>
36
37#include "android_view_GraphicBuffer.h"
38#include "android_os_MessageQueue.h"
39
40#include <Animator.h>
41#include <AnimationContext.h>
42#include <FrameInfo.h>
43#include <IContextFactory.h>
44#include <JankTracker.h>
45#include <RenderNode.h>
46#include <renderthread/CanvasContext.h>
47#include <renderthread/RenderProxy.h>
48#include <renderthread/RenderTask.h>
49#include <renderthread/RenderThread.h>
50#include <Vector.h>
51
52namespace android {
53
54using namespace android::uirenderer;
55using namespace android::uirenderer::renderthread;
56
57struct {
58    jfieldID buffer;
59    jfieldID messageQueue;
60    jmethodID notifyData;
61} gFrameStatsObserverClassInfo;
62
63static JNIEnv* getenv(JavaVM* vm) {
64    JNIEnv* env;
65    if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
66        LOG_ALWAYS_FATAL("Failed to get JNIEnv for JavaVM: %p", vm);
67    }
68    return env;
69}
70
71class OnFinishedEvent {
72public:
73    OnFinishedEvent(BaseRenderNodeAnimator* animator, AnimationListener* listener)
74            : animator(animator), listener(listener) {}
75    sp<BaseRenderNodeAnimator> animator;
76    sp<AnimationListener> listener;
77};
78
79class InvokeAnimationListeners : public MessageHandler {
80public:
81    InvokeAnimationListeners(std::vector<OnFinishedEvent>& events) {
82        mOnFinishedEvents.swap(events);
83    }
84
85    static void callOnFinished(OnFinishedEvent& event) {
86        event.listener->onAnimationFinished(event.animator.get());
87    }
88
89    virtual void handleMessage(const Message& message) {
90        std::for_each(mOnFinishedEvents.begin(), mOnFinishedEvents.end(), callOnFinished);
91        mOnFinishedEvents.clear();
92    }
93
94private:
95    std::vector<OnFinishedEvent> mOnFinishedEvents;
96};
97
98class RenderingException : public MessageHandler {
99public:
100    RenderingException(JavaVM* vm, const std::string& message)
101            : mVm(vm)
102            , mMessage(message) {
103    }
104
105    virtual void handleMessage(const Message&) {
106        throwException(mVm, mMessage);
107    }
108
109    static void throwException(JavaVM* vm, const std::string& message) {
110        JNIEnv* env = getenv(vm);
111        jniThrowException(env, "java/lang/IllegalStateException", message.c_str());
112    }
113
114private:
115    JavaVM* mVm;
116    std::string mMessage;
117};
118
119class RootRenderNode : public RenderNode, ErrorHandler {
120public:
121    RootRenderNode(JNIEnv* env) : RenderNode() {
122        mLooper = Looper::getForThread();
123        LOG_ALWAYS_FATAL_IF(!mLooper.get(),
124                "Must create RootRenderNode on a thread with a looper!");
125        env->GetJavaVM(&mVm);
126    }
127
128    virtual ~RootRenderNode() {}
129
130    virtual void onError(const std::string& message) {
131        mLooper->sendMessage(new RenderingException(mVm, message), 0);
132    }
133
134    virtual void prepareTree(TreeInfo& info) {
135        info.errorHandler = this;
136        RenderNode::prepareTree(info);
137        info.errorHandler = NULL;
138    }
139
140    void sendMessage(const sp<MessageHandler>& handler) {
141        mLooper->sendMessage(handler, 0);
142    }
143
144    void attachAnimatingNode(RenderNode* animatingNode) {
145        mPendingAnimatingRenderNodes.push_back(animatingNode);
146    }
147
148    void doAttachAnimatingNodes(AnimationContext* context) {
149        for (size_t i = 0; i < mPendingAnimatingRenderNodes.size(); i++) {
150            RenderNode* node = mPendingAnimatingRenderNodes[i].get();
151            context->addAnimatingRenderNode(*node);
152        }
153        mPendingAnimatingRenderNodes.clear();
154    }
155
156private:
157    sp<Looper> mLooper;
158    JavaVM* mVm;
159    std::vector< sp<RenderNode> > mPendingAnimatingRenderNodes;
160};
161
162class AnimationContextBridge : public AnimationContext {
163public:
164    AnimationContextBridge(renderthread::TimeLord& clock, RootRenderNode* rootNode)
165            : AnimationContext(clock), mRootNode(rootNode) {
166    }
167
168    virtual ~AnimationContextBridge() {}
169
170    // Marks the start of a frame, which will update the frame time and move all
171    // next frame animations into the current frame
172    virtual void startFrame(TreeInfo::TraversalMode mode) {
173        if (mode == TreeInfo::MODE_FULL) {
174            mRootNode->doAttachAnimatingNodes(this);
175        }
176        AnimationContext::startFrame(mode);
177    }
178
179    // Runs any animations still left in mCurrentFrameAnimations
180    virtual void runRemainingAnimations(TreeInfo& info) {
181        AnimationContext::runRemainingAnimations(info);
182        postOnFinishedEvents();
183    }
184
185    virtual void callOnFinished(BaseRenderNodeAnimator* animator, AnimationListener* listener) {
186        OnFinishedEvent event(animator, listener);
187        mOnFinishedEvents.push_back(event);
188    }
189
190    virtual void destroy() {
191        AnimationContext::destroy();
192        postOnFinishedEvents();
193    }
194
195private:
196    sp<RootRenderNode> mRootNode;
197    std::vector<OnFinishedEvent> mOnFinishedEvents;
198
199    void postOnFinishedEvents() {
200        if (mOnFinishedEvents.size()) {
201            sp<InvokeAnimationListeners> message
202                    = new InvokeAnimationListeners(mOnFinishedEvents);
203            mRootNode->sendMessage(message);
204        }
205    }
206};
207
208class ContextFactoryImpl : public IContextFactory {
209public:
210    ContextFactoryImpl(RootRenderNode* rootNode) : mRootNode(rootNode) {}
211
212    virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) {
213        return new AnimationContextBridge(clock, mRootNode);
214    }
215
216private:
217    RootRenderNode* mRootNode;
218};
219
220class ObserverProxy;
221
222class NotifyHandler : public MessageHandler {
223public:
224    NotifyHandler(JavaVM* vm) : mVm(vm) {}
225
226    void setObserver(ObserverProxy* observer) {
227        mObserver = observer;
228    }
229
230    void setBuffer(BufferPool::Buffer* buffer) {
231        mBuffer = buffer;
232    }
233
234    virtual void handleMessage(const Message& message);
235
236private:
237    JavaVM* mVm;
238
239    sp<ObserverProxy> mObserver;
240    BufferPool::Buffer* mBuffer;
241};
242
243class ObserverProxy : public FrameStatsObserver {
244public:
245    ObserverProxy(JavaVM *vm, jobject fso) : mVm(vm) {
246        JNIEnv* env = getenv(mVm);
247
248        jlongArray longArrayLocal = env->NewLongArray(kBufferSize);
249        LOG_ALWAYS_FATAL_IF(longArrayLocal == nullptr,
250                "OOM: can't allocate frame stats buffer");
251        env->SetObjectField(fso, gFrameStatsObserverClassInfo.buffer, longArrayLocal);
252
253        mFsoWeak = env->NewWeakGlobalRef(fso);
254        LOG_ALWAYS_FATAL_IF(mFsoWeak == nullptr,
255                "unable to create frame stats observer reference");
256
257        jobject messageQueueLocal =
258                env->GetObjectField(fso, gFrameStatsObserverClassInfo.messageQueue);
259        mMessageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueLocal);
260        LOG_ALWAYS_FATAL_IF(mMessageQueue == nullptr, "message queue not available");
261
262        mMessageHandler = new NotifyHandler(mVm);
263        LOG_ALWAYS_FATAL_IF(mMessageHandler == nullptr,
264                "OOM: unable to allocate NotifyHandler");
265    }
266
267    ~ObserverProxy() {
268        JNIEnv* env = getenv(mVm);
269        env->DeleteWeakGlobalRef(mFsoWeak);
270    }
271
272    jweak getJavaObjectRef() {
273        return mFsoWeak;
274    }
275
276    virtual void notify(BufferPool::Buffer* buffer) {
277        buffer->incRef();
278        mMessageHandler->setBuffer(buffer);
279        mMessageHandler->setObserver(this);
280        mMessageQueue->getLooper()->sendMessage(mMessageHandler, mMessage);
281    }
282
283private:
284    static const int kBufferSize = static_cast<int>(FrameInfoIndex::NumIndexes);
285
286    JavaVM* mVm;
287    jweak mFsoWeak;
288
289    sp<MessageQueue> mMessageQueue;
290    sp<NotifyHandler> mMessageHandler;
291    Message mMessage;
292};
293
294void NotifyHandler::handleMessage(const Message& message) {
295    JNIEnv* env = getenv(mVm);
296
297    jobject target = env->NewLocalRef(mObserver->getJavaObjectRef());
298
299    if (target != nullptr) {
300        jobject javaBuffer = env->GetObjectField(target, gFrameStatsObserverClassInfo.buffer);
301        if (javaBuffer != nullptr) {
302            env->SetLongArrayRegion(reinterpret_cast<jlongArray>(javaBuffer),
303                    0, mBuffer->getSize(), mBuffer->getBuffer());
304            env->CallVoidMethod(target, gFrameStatsObserverClassInfo.notifyData);
305            env->DeleteLocalRef(target);
306        }
307    }
308
309    mBuffer->release();
310    mObserver.clear();
311}
312
313static void android_view_ThreadedRenderer_setAtlas(JNIEnv* env, jobject clazz,
314        jlong proxyPtr, jobject graphicBuffer, jlongArray atlasMapArray) {
315    sp<GraphicBuffer> buffer = graphicBufferForJavaObject(env, graphicBuffer);
316    jsize len = env->GetArrayLength(atlasMapArray);
317    if (len <= 0) {
318        ALOGW("Failed to initialize atlas, invalid map length: %d", len);
319        return;
320    }
321    int64_t* map = new int64_t[len];
322    env->GetLongArrayRegion(atlasMapArray, 0, len, map);
323
324    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
325    proxy->setTextureAtlas(buffer, map, len);
326}
327
328static void android_view_ThreadedRenderer_setProcessStatsBuffer(JNIEnv* env, jobject clazz,
329        jlong proxyPtr, jint fd) {
330    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
331    proxy->setProcessStatsBuffer(fd);
332}
333
334static jlong android_view_ThreadedRenderer_createRootRenderNode(JNIEnv* env, jobject clazz) {
335    RootRenderNode* node = new RootRenderNode(env);
336    node->incStrong(0);
337    node->setName("RootRenderNode");
338    return reinterpret_cast<jlong>(node);
339}
340
341static jlong android_view_ThreadedRenderer_createProxy(JNIEnv* env, jobject clazz,
342        jboolean translucent, jlong rootRenderNodePtr) {
343    RootRenderNode* rootRenderNode = reinterpret_cast<RootRenderNode*>(rootRenderNodePtr);
344    ContextFactoryImpl factory(rootRenderNode);
345    return (jlong) new RenderProxy(translucent, rootRenderNode, &factory);
346}
347
348static void android_view_ThreadedRenderer_deleteProxy(JNIEnv* env, jobject clazz,
349        jlong proxyPtr) {
350    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
351    delete proxy;
352}
353
354static jboolean android_view_ThreadedRenderer_loadSystemProperties(JNIEnv* env, jobject clazz,
355        jlong proxyPtr) {
356    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
357    return proxy->loadSystemProperties();
358}
359
360static void android_view_ThreadedRenderer_setName(JNIEnv* env, jobject clazz,
361        jlong proxyPtr, jstring jname) {
362    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
363    const char* name = env->GetStringUTFChars(jname, NULL);
364    proxy->setName(name);
365    env->ReleaseStringUTFChars(jname, name);
366}
367
368static void android_view_ThreadedRenderer_initialize(JNIEnv* env, jobject clazz,
369        jlong proxyPtr, jobject jsurface) {
370    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
371    sp<ANativeWindow> window = android_view_Surface_getNativeWindow(env, jsurface);
372    proxy->initialize(window);
373}
374
375static void android_view_ThreadedRenderer_updateSurface(JNIEnv* env, jobject clazz,
376        jlong proxyPtr, jobject jsurface) {
377    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
378    sp<ANativeWindow> window;
379    if (jsurface) {
380        window = android_view_Surface_getNativeWindow(env, jsurface);
381    }
382    proxy->updateSurface(window);
383}
384
385static jboolean android_view_ThreadedRenderer_pauseSurface(JNIEnv* env, jobject clazz,
386        jlong proxyPtr, jobject jsurface) {
387    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
388    sp<ANativeWindow> window;
389    if (jsurface) {
390        window = android_view_Surface_getNativeWindow(env, jsurface);
391    }
392    return proxy->pauseSurface(window);
393}
394
395static void android_view_ThreadedRenderer_setup(JNIEnv* env, jobject clazz, jlong proxyPtr,
396        jint width, jint height, jfloat lightRadius, jint ambientShadowAlpha, jint spotShadowAlpha) {
397    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
398    proxy->setup(width, height, lightRadius, ambientShadowAlpha, spotShadowAlpha);
399}
400
401static void android_view_ThreadedRenderer_setLightCenter(JNIEnv* env, jobject clazz,
402        jlong proxyPtr, jfloat lightX, jfloat lightY, jfloat lightZ) {
403    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
404    proxy->setLightCenter((Vector3){lightX, lightY, lightZ});
405}
406
407static void android_view_ThreadedRenderer_setOpaque(JNIEnv* env, jobject clazz,
408        jlong proxyPtr, jboolean opaque) {
409    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
410    proxy->setOpaque(opaque);
411}
412
413static int android_view_ThreadedRenderer_syncAndDrawFrame(JNIEnv* env, jobject clazz,
414        jlong proxyPtr, jlongArray frameInfo, jint frameInfoSize) {
415    LOG_ALWAYS_FATAL_IF(frameInfoSize != UI_THREAD_FRAME_INFO_SIZE,
416            "Mismatched size expectations, given %d expected %d",
417            frameInfoSize, UI_THREAD_FRAME_INFO_SIZE);
418    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
419    env->GetLongArrayRegion(frameInfo, 0, frameInfoSize, proxy->frameInfo());
420    return proxy->syncAndDrawFrame();
421}
422
423static void android_view_ThreadedRenderer_destroy(JNIEnv* env, jobject clazz,
424        jlong proxyPtr) {
425    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
426    proxy->destroy();
427}
428
429static void android_view_ThreadedRenderer_registerAnimatingRenderNode(JNIEnv* env, jobject clazz,
430        jlong rootNodePtr, jlong animatingNodePtr) {
431    RootRenderNode* rootRenderNode = reinterpret_cast<RootRenderNode*>(rootNodePtr);
432    RenderNode* animatingNode = reinterpret_cast<RenderNode*>(animatingNodePtr);
433    rootRenderNode->attachAnimatingNode(animatingNode);
434}
435
436static void android_view_ThreadedRenderer_invokeFunctor(JNIEnv* env, jobject clazz,
437        jlong functorPtr, jboolean waitForCompletion) {
438    Functor* functor = reinterpret_cast<Functor*>(functorPtr);
439    RenderProxy::invokeFunctor(functor, waitForCompletion);
440}
441
442static jlong android_view_ThreadedRenderer_createTextureLayer(JNIEnv* env, jobject clazz,
443        jlong proxyPtr) {
444    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
445    DeferredLayerUpdater* layer = proxy->createTextureLayer();
446    return reinterpret_cast<jlong>(layer);
447}
448
449static void android_view_ThreadedRenderer_buildLayer(JNIEnv* env, jobject clazz,
450        jlong proxyPtr, jlong nodePtr) {
451    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
452    RenderNode* node = reinterpret_cast<RenderNode*>(nodePtr);
453    proxy->buildLayer(node);
454}
455
456static jboolean android_view_ThreadedRenderer_copyLayerInto(JNIEnv* env, jobject clazz,
457        jlong proxyPtr, jlong layerPtr, jobject jbitmap) {
458    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
459    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
460    SkBitmap bitmap;
461    GraphicsJNI::getSkBitmap(env, jbitmap, &bitmap);
462    return proxy->copyLayerInto(layer, bitmap);
463}
464
465static void android_view_ThreadedRenderer_pushLayerUpdate(JNIEnv* env, jobject clazz,
466        jlong proxyPtr, jlong layerPtr) {
467    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
468    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
469    proxy->pushLayerUpdate(layer);
470}
471
472static void android_view_ThreadedRenderer_cancelLayerUpdate(JNIEnv* env, jobject clazz,
473        jlong proxyPtr, jlong layerPtr) {
474    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
475    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
476    proxy->cancelLayerUpdate(layer);
477}
478
479static void android_view_ThreadedRenderer_detachSurfaceTexture(JNIEnv* env, jobject clazz,
480        jlong proxyPtr, jlong layerPtr) {
481    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
482    DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerPtr);
483    proxy->detachSurfaceTexture(layer);
484}
485
486static void android_view_ThreadedRenderer_destroyHardwareResources(JNIEnv* env, jobject clazz,
487        jlong proxyPtr) {
488    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
489    proxy->destroyHardwareResources();
490}
491
492static void android_view_ThreadedRenderer_trimMemory(JNIEnv* env, jobject clazz,
493        jint level) {
494    RenderProxy::trimMemory(level);
495}
496
497static void android_view_ThreadedRenderer_overrideProperty(JNIEnv* env, jobject clazz,
498        jstring name, jstring value) {
499    const char* nameCharArray = env->GetStringUTFChars(name, NULL);
500    const char* valueCharArray = env->GetStringUTFChars(value, NULL);
501    RenderProxy::overrideProperty(nameCharArray, valueCharArray);
502    env->ReleaseStringUTFChars(name, nameCharArray);
503    env->ReleaseStringUTFChars(name, valueCharArray);
504}
505
506static void android_view_ThreadedRenderer_fence(JNIEnv* env, jobject clazz,
507        jlong proxyPtr) {
508    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
509    proxy->fence();
510}
511
512static void android_view_ThreadedRenderer_stopDrawing(JNIEnv* env, jobject clazz,
513        jlong proxyPtr) {
514    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
515    proxy->stopDrawing();
516}
517
518static void android_view_ThreadedRenderer_notifyFramePending(JNIEnv* env, jobject clazz,
519        jlong proxyPtr) {
520    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
521    proxy->notifyFramePending();
522}
523
524static void android_view_ThreadedRenderer_serializeDisplayListTree(JNIEnv* env, jobject clazz,
525        jlong proxyPtr) {
526    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
527    proxy->serializeDisplayListTree();
528}
529
530static void android_view_ThreadedRenderer_dumpProfileInfo(JNIEnv* env, jobject clazz,
531        jlong proxyPtr, jobject javaFileDescriptor, jint dumpFlags) {
532    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
533    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
534    proxy->dumpProfileInfo(fd, dumpFlags);
535}
536
537static void android_view_ThreadedRenderer_dumpProfileData(JNIEnv* env, jobject clazz,
538        jbyteArray jdata, jobject javaFileDescriptor) {
539    int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor);
540    ScopedByteArrayRO buffer(env, jdata);
541    if (buffer.get()) {
542        JankTracker::dumpBuffer(buffer.get(), buffer.size(), fd);
543    }
544}
545
546static void android_view_ThreadedRenderer_addRenderNode(JNIEnv* env, jobject clazz,
547        jlong proxyPtr, jlong renderNodePtr, jboolean placeFront) {
548    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
549    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
550    proxy->addRenderNode(renderNode, placeFront);
551}
552
553static void android_view_ThreadedRenderer_removeRenderNode(JNIEnv* env, jobject clazz,
554        jlong proxyPtr, jlong renderNodePtr) {
555    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
556    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
557    proxy->removeRenderNode(renderNode);
558}
559
560static void android_view_ThreadedRendererd_drawRenderNode(JNIEnv* env, jobject clazz,
561        jlong proxyPtr, jlong renderNodePtr) {
562    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
563    RenderNode* renderNode = reinterpret_cast<RenderNode*>(renderNodePtr);
564    proxy->drawRenderNode(renderNode);
565}
566
567static void android_view_ThreadedRenderer_setContentDrawBounds(JNIEnv* env,
568        jobject clazz, jlong proxyPtr, jint left, jint top, jint right, jint bottom) {
569    RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
570    proxy->setContentDrawBounds(left, top, right, bottom);
571}
572
573// ----------------------------------------------------------------------------
574// FrameStatsObserver
575// ----------------------------------------------------------------------------
576
577static jlong android_view_ThreadedRenderer_addFrameStatsObserver(JNIEnv* env,
578        jclass clazz, jlong proxyPtr, jobject fso) {
579    JavaVM* vm = nullptr;
580    if (env->GetJavaVM(&vm) != JNI_OK) {
581        LOG_ALWAYS_FATAL("Unable to get Java VM");
582        return 0;
583    }
584
585    renderthread::RenderProxy* renderProxy =
586            reinterpret_cast<renderthread::RenderProxy*>(proxyPtr);
587
588    FrameStatsObserver* observer = new ObserverProxy(vm, fso);
589    renderProxy->addFrameStatsObserver(observer);
590    return reinterpret_cast<jlong>(observer);
591}
592
593static void android_view_ThreadedRenderer_removeFrameStatsObserver(JNIEnv* env, jclass clazz,
594        jlong proxyPtr, jlong observerPtr) {
595    FrameStatsObserver* observer = reinterpret_cast<FrameStatsObserver*>(observerPtr);
596    renderthread::RenderProxy* renderProxy =
597            reinterpret_cast<renderthread::RenderProxy*>(proxyPtr);
598
599    renderProxy->removeFrameStatsObserver(observer);
600}
601
602static jint android_view_ThreadedRenderer_getDroppedFrameReportCount(JNIEnv* env, jclass clazz,
603        jlong proxyPtr) {
604    renderthread::RenderProxy* renderProxy =
605            reinterpret_cast<renderthread::RenderProxy*>(proxyPtr);
606    return renderProxy->getDroppedFrameReportCount();
607}
608
609// ----------------------------------------------------------------------------
610// Shaders
611// ----------------------------------------------------------------------------
612
613static void android_view_ThreadedRenderer_setupShadersDiskCache(JNIEnv* env, jobject clazz,
614        jstring diskCachePath) {
615    const char* cacheArray = env->GetStringUTFChars(diskCachePath, NULL);
616    egl_cache_t::get()->setCacheFilename(cacheArray);
617    env->ReleaseStringUTFChars(diskCachePath, cacheArray);
618}
619
620// ----------------------------------------------------------------------------
621// JNI Glue
622// ----------------------------------------------------------------------------
623
624const char* const kClassPathName = "android/view/ThreadedRenderer";
625
626static const JNINativeMethod gMethods[] = {
627    { "nSetAtlas", "(JLandroid/view/GraphicBuffer;[J)V",   (void*) android_view_ThreadedRenderer_setAtlas },
628    { "nSetProcessStatsBuffer", "(JI)V", (void*) android_view_ThreadedRenderer_setProcessStatsBuffer },
629    { "nCreateRootRenderNode", "()J", (void*) android_view_ThreadedRenderer_createRootRenderNode },
630    { "nCreateProxy", "(ZJ)J", (void*) android_view_ThreadedRenderer_createProxy },
631    { "nDeleteProxy", "(J)V", (void*) android_view_ThreadedRenderer_deleteProxy },
632    { "nLoadSystemProperties", "(J)Z", (void*) android_view_ThreadedRenderer_loadSystemProperties },
633    { "nSetName", "(JLjava/lang/String;)V", (void*) android_view_ThreadedRenderer_setName },
634    { "nInitialize", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_initialize },
635    { "nUpdateSurface", "(JLandroid/view/Surface;)V", (void*) android_view_ThreadedRenderer_updateSurface },
636    { "nPauseSurface", "(JLandroid/view/Surface;)Z", (void*) android_view_ThreadedRenderer_pauseSurface },
637    { "nSetup", "(JIIFII)V", (void*) android_view_ThreadedRenderer_setup },
638    { "nSetLightCenter", "(JFFF)V", (void*) android_view_ThreadedRenderer_setLightCenter },
639    { "nSetOpaque", "(JZ)V", (void*) android_view_ThreadedRenderer_setOpaque },
640    { "nSyncAndDrawFrame", "(J[JI)I", (void*) android_view_ThreadedRenderer_syncAndDrawFrame },
641    { "nDestroy", "(J)V", (void*) android_view_ThreadedRenderer_destroy },
642    { "nRegisterAnimatingRenderNode", "(JJ)V", (void*) android_view_ThreadedRenderer_registerAnimatingRenderNode },
643    { "nInvokeFunctor", "(JZ)V", (void*) android_view_ThreadedRenderer_invokeFunctor },
644    { "nCreateTextureLayer", "(J)J", (void*) android_view_ThreadedRenderer_createTextureLayer },
645    { "nBuildLayer", "(JJ)V", (void*) android_view_ThreadedRenderer_buildLayer },
646    { "nCopyLayerInto", "(JJLandroid/graphics/Bitmap;)Z", (void*) android_view_ThreadedRenderer_copyLayerInto },
647    { "nPushLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_pushLayerUpdate },
648    { "nCancelLayerUpdate", "(JJ)V", (void*) android_view_ThreadedRenderer_cancelLayerUpdate },
649    { "nDetachSurfaceTexture", "(JJ)V", (void*) android_view_ThreadedRenderer_detachSurfaceTexture },
650    { "nDestroyHardwareResources", "(J)V", (void*) android_view_ThreadedRenderer_destroyHardwareResources },
651    { "nTrimMemory", "(I)V", (void*) android_view_ThreadedRenderer_trimMemory },
652    { "nOverrideProperty", "(Ljava/lang/String;Ljava/lang/String;)V",  (void*) android_view_ThreadedRenderer_overrideProperty },
653    { "nFence", "(J)V", (void*) android_view_ThreadedRenderer_fence },
654    { "nStopDrawing", "(J)V", (void*) android_view_ThreadedRenderer_stopDrawing },
655    { "nNotifyFramePending", "(J)V", (void*) android_view_ThreadedRenderer_notifyFramePending },
656    { "nSerializeDisplayListTree", "(J)V", (void*) android_view_ThreadedRenderer_serializeDisplayListTree },
657    { "nDumpProfileInfo", "(JLjava/io/FileDescriptor;I)V", (void*) android_view_ThreadedRenderer_dumpProfileInfo },
658    { "nDumpProfileData", "([BLjava/io/FileDescriptor;)V", (void*) android_view_ThreadedRenderer_dumpProfileData },
659    { "setupShadersDiskCache", "(Ljava/lang/String;)V",
660                (void*) android_view_ThreadedRenderer_setupShadersDiskCache },
661    { "nAddRenderNode", "(JJZ)V", (void*) android_view_ThreadedRenderer_addRenderNode},
662    { "nRemoveRenderNode", "(JJ)V", (void*) android_view_ThreadedRenderer_removeRenderNode},
663    { "nDrawRenderNode", "(JJ)V", (void*) android_view_ThreadedRendererd_drawRenderNode},
664    { "nSetContentDrawBounds", "(JIIII)V", (void*)android_view_ThreadedRenderer_setContentDrawBounds},
665    { "nAddFrameStatsObserver",
666            "(JLandroid/view/FrameStatsObserver;)J",
667            (void*)android_view_ThreadedRenderer_addFrameStatsObserver },
668    { "nRemoveFrameStatsObserver",
669            "(JJ)V",
670            (void*)android_view_ThreadedRenderer_removeFrameStatsObserver },
671    { "nGetDroppedFrameReportCount",
672            "(J)J",
673            (void*)android_view_ThreadedRenderer_getDroppedFrameReportCount },
674};
675
676int register_android_view_ThreadedRenderer(JNIEnv* env) {
677    jclass clazz = FindClassOrDie(env, "android/view/FrameStatsObserver");
678    gFrameStatsObserverClassInfo.messageQueue  =
679            GetFieldIDOrDie(env, clazz, "mMessageQueue", "Landroid/os/MessageQueue;");
680    gFrameStatsObserverClassInfo.buffer =
681            GetFieldIDOrDie(env, clazz, "mBuffer", "[J");
682    gFrameStatsObserverClassInfo.notifyData =
683            GetMethodIDOrDie(env, clazz, "notifyDataAvailable", "()V");
684
685    return RegisterMethodsOrDie(env, kClassPathName, gMethods, NELEM(gMethods));
686}
687
688}; // namespace android
689