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