1 /* 2 * Copyright (C) 2007 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 "Surface" 18 19 #include <stdio.h> 20 21 #include "jni.h" 22 #include <nativehelper/JNIHelp.h> 23 #include "android_os_Parcel.h" 24 #include "android/graphics/GraphicBuffer.h" 25 #include "android/graphics/GraphicsJNI.h" 26 27 #include "core_jni_helpers.h" 28 #include <android_runtime/android_view_Surface.h> 29 #include <android_runtime/android_graphics_SurfaceTexture.h> 30 #include <android_runtime/Log.h> 31 32 #include <binder/Parcel.h> 33 34 #include <gui/Surface.h> 35 #include <gui/view/Surface.h> 36 #include <gui/SurfaceControl.h> 37 #include <gui/GLConsumer.h> 38 39 #include <ui/Rect.h> 40 #include <ui/Region.h> 41 42 #include <SkCanvas.h> 43 #include <SkBitmap.h> 44 #include <SkImage.h> 45 #include <SkRegion.h> 46 47 #include <utils/misc.h> 48 #include <utils/Log.h> 49 50 #include <nativehelper/ScopedUtfChars.h> 51 52 #include <AnimationContext.h> 53 #include <FrameInfo.h> 54 #include <RenderNode.h> 55 #include <renderthread/RenderProxy.h> 56 57 // ---------------------------------------------------------------------------- 58 59 namespace android { 60 61 static const char* const OutOfResourcesException = 62 "android/view/Surface$OutOfResourcesException"; 63 64 static struct { 65 jclass clazz; 66 jfieldID mNativeObject; 67 jfieldID mLock; 68 jmethodID ctor; 69 } gSurfaceClassInfo; 70 71 static struct { 72 jfieldID left; 73 jfieldID top; 74 jfieldID right; 75 jfieldID bottom; 76 } gRectClassInfo; 77 78 // ---------------------------------------------------------------------------- 79 80 // this is just a pointer we use to pass to inc/decStrong 81 static const void *sRefBaseOwner; 82 83 bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) { 84 return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz); 85 } 86 87 sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) { 88 return android_view_Surface_getSurface(env, surfaceObj); 89 } 90 91 sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) { 92 sp<Surface> sur; 93 jobject lock = env->GetObjectField(surfaceObj, 94 gSurfaceClassInfo.mLock); 95 if (env->MonitorEnter(lock) == JNI_OK) { 96 sur = reinterpret_cast<Surface *>( 97 env->GetLongField(surfaceObj, gSurfaceClassInfo.mNativeObject)); 98 env->MonitorExit(lock); 99 } 100 env->DeleteLocalRef(lock); 101 return sur; 102 } 103 104 jobject android_view_Surface_createFromSurface(JNIEnv* env, const sp<Surface>& surface) { 105 jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz, 106 gSurfaceClassInfo.ctor, (jlong)surface.get()); 107 if (surfaceObj == NULL) { 108 if (env->ExceptionCheck()) { 109 ALOGE("Could not create instance of Surface from IGraphicBufferProducer."); 110 LOGE_EX(env); 111 env->ExceptionClear(); 112 } 113 return NULL; 114 } 115 surface->incStrong(&sRefBaseOwner); 116 return surfaceObj; 117 } 118 119 jobject android_view_Surface_createFromIGraphicBufferProducer(JNIEnv* env, 120 const sp<IGraphicBufferProducer>& bufferProducer) { 121 if (bufferProducer == NULL) { 122 return NULL; 123 } 124 125 sp<Surface> surface(new Surface(bufferProducer, true)); 126 return android_view_Surface_createFromSurface(env, surface); 127 } 128 129 int android_view_Surface_mapPublicFormatToHalFormat(PublicFormat f) { 130 131 switch(f) { 132 case PublicFormat::JPEG: 133 case PublicFormat::DEPTH_POINT_CLOUD: 134 return HAL_PIXEL_FORMAT_BLOB; 135 case PublicFormat::DEPTH16: 136 return HAL_PIXEL_FORMAT_Y16; 137 case PublicFormat::RAW_SENSOR: 138 case PublicFormat::RAW_DEPTH: 139 return HAL_PIXEL_FORMAT_RAW16; 140 default: 141 // Most formats map 1:1 142 return static_cast<int>(f); 143 } 144 } 145 146 android_dataspace android_view_Surface_mapPublicFormatToHalDataspace( 147 PublicFormat f) { 148 switch(f) { 149 case PublicFormat::JPEG: 150 return HAL_DATASPACE_V0_JFIF; 151 case PublicFormat::DEPTH_POINT_CLOUD: 152 case PublicFormat::DEPTH16: 153 case PublicFormat::RAW_DEPTH: 154 return HAL_DATASPACE_DEPTH; 155 case PublicFormat::RAW_SENSOR: 156 case PublicFormat::RAW_PRIVATE: 157 case PublicFormat::RAW10: 158 case PublicFormat::RAW12: 159 return HAL_DATASPACE_ARBITRARY; 160 case PublicFormat::YUV_420_888: 161 case PublicFormat::NV21: 162 case PublicFormat::YV12: 163 return HAL_DATASPACE_V0_JFIF; 164 default: 165 // Most formats map to UNKNOWN 166 return HAL_DATASPACE_UNKNOWN; 167 } 168 } 169 170 PublicFormat android_view_Surface_mapHalFormatDataspaceToPublicFormat( 171 int format, android_dataspace dataSpace) { 172 switch(format) { 173 case HAL_PIXEL_FORMAT_RGBA_8888: 174 case HAL_PIXEL_FORMAT_RGBX_8888: 175 case HAL_PIXEL_FORMAT_RGBA_FP16: 176 case HAL_PIXEL_FORMAT_RGBA_1010102: 177 case HAL_PIXEL_FORMAT_RGB_888: 178 case HAL_PIXEL_FORMAT_RGB_565: 179 case HAL_PIXEL_FORMAT_Y8: 180 case HAL_PIXEL_FORMAT_RAW10: 181 case HAL_PIXEL_FORMAT_RAW12: 182 case HAL_PIXEL_FORMAT_YCbCr_420_888: 183 case HAL_PIXEL_FORMAT_YV12: 184 // Enums overlap in both name and value 185 return static_cast<PublicFormat>(format); 186 case HAL_PIXEL_FORMAT_RAW16: 187 switch (dataSpace) { 188 case HAL_DATASPACE_DEPTH: 189 return PublicFormat::RAW_DEPTH; 190 default: 191 return PublicFormat::RAW_SENSOR; 192 } 193 case HAL_PIXEL_FORMAT_RAW_OPAQUE: 194 // Name differs, though value is the same 195 return PublicFormat::RAW_PRIVATE; 196 case HAL_PIXEL_FORMAT_YCbCr_422_SP: 197 // Name differs, though the value is the same 198 return PublicFormat::NV16; 199 case HAL_PIXEL_FORMAT_YCrCb_420_SP: 200 // Name differs, though the value is the same 201 return PublicFormat::NV21; 202 case HAL_PIXEL_FORMAT_YCbCr_422_I: 203 // Name differs, though the value is the same 204 return PublicFormat::YUY2; 205 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED: 206 // Name differs, though the value is the same 207 return PublicFormat::PRIVATE; 208 case HAL_PIXEL_FORMAT_Y16: 209 // Dataspace-dependent 210 switch (dataSpace) { 211 case HAL_DATASPACE_DEPTH: 212 return PublicFormat::DEPTH16; 213 default: 214 // Assume non-depth Y16 is just Y16. 215 return PublicFormat::Y16; 216 } 217 break; 218 case HAL_PIXEL_FORMAT_BLOB: 219 // Dataspace-dependent 220 switch (dataSpace) { 221 case HAL_DATASPACE_DEPTH: 222 return PublicFormat::DEPTH_POINT_CLOUD; 223 case HAL_DATASPACE_V0_JFIF: 224 return PublicFormat::JPEG; 225 default: 226 // Assume otherwise-marked blobs are also JPEG 227 return PublicFormat::JPEG; 228 } 229 break; 230 case HAL_PIXEL_FORMAT_BGRA_8888: 231 // Not defined in public API 232 return PublicFormat::UNKNOWN; 233 234 default: 235 return PublicFormat::UNKNOWN; 236 } 237 } 238 // ---------------------------------------------------------------------------- 239 240 static inline bool isSurfaceValid(const sp<Surface>& sur) { 241 return Surface::isValid(sur); 242 } 243 244 // ---------------------------------------------------------------------------- 245 246 static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz, 247 jobject surfaceTextureObj) { 248 sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj)); 249 if (producer == NULL) { 250 jniThrowException(env, "java/lang/IllegalArgumentException", 251 "SurfaceTexture has already been released"); 252 return 0; 253 } 254 255 sp<Surface> surface(new Surface(producer, true)); 256 if (surface == NULL) { 257 jniThrowException(env, OutOfResourcesException, NULL); 258 return 0; 259 } 260 261 surface->incStrong(&sRefBaseOwner); 262 return jlong(surface.get()); 263 } 264 265 static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) { 266 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 267 sur->decStrong(&sRefBaseOwner); 268 } 269 270 static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) { 271 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 272 return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE; 273 } 274 275 static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) { 276 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 277 if (!isSurfaceValid(sur)) { 278 doThrowIAE(env); 279 return JNI_FALSE; 280 } 281 int value = 0; 282 ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get()); 283 anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value); 284 return value; 285 } 286 287 static inline SkColorType convertPixelFormat(PixelFormat format) { 288 /* note: if PIXEL_FORMAT_RGBX_8888 means that all alpha bytes are 0xFF, then 289 we can map to kN32_SkColorType, and optionally call 290 bitmap.setAlphaType(kOpaque_SkAlphaType) on the resulting SkBitmap 291 (as an accelerator) 292 */ 293 switch (format) { 294 case PIXEL_FORMAT_RGBX_8888: return kN32_SkColorType; 295 case PIXEL_FORMAT_RGBA_8888: return kN32_SkColorType; 296 case PIXEL_FORMAT_RGBA_FP16: return kRGBA_F16_SkColorType; 297 case PIXEL_FORMAT_RGB_565: return kRGB_565_SkColorType; 298 default: return kUnknown_SkColorType; 299 } 300 } 301 302 static jlong nativeLockCanvas(JNIEnv* env, jclass clazz, 303 jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) { 304 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); 305 306 if (!isSurfaceValid(surface)) { 307 doThrowIAE(env); 308 return 0; 309 } 310 311 Rect dirtyRect(Rect::EMPTY_RECT); 312 Rect* dirtyRectPtr = NULL; 313 314 if (dirtyRectObj) { 315 dirtyRect.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left); 316 dirtyRect.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top); 317 dirtyRect.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right); 318 dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom); 319 dirtyRectPtr = &dirtyRect; 320 } 321 322 ANativeWindow_Buffer outBuffer; 323 status_t err = surface->lock(&outBuffer, dirtyRectPtr); 324 if (err < 0) { 325 const char* const exception = (err == NO_MEMORY) ? 326 OutOfResourcesException : 327 "java/lang/IllegalArgumentException"; 328 jniThrowException(env, exception, NULL); 329 return 0; 330 } 331 332 SkImageInfo info = SkImageInfo::Make(outBuffer.width, outBuffer.height, 333 convertPixelFormat(outBuffer.format), 334 outBuffer.format == PIXEL_FORMAT_RGBX_8888 335 ? kOpaque_SkAlphaType : kPremul_SkAlphaType, 336 GraphicsJNI::defaultColorSpace()); 337 338 SkBitmap bitmap; 339 ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format); 340 bitmap.setInfo(info, bpr); 341 if (outBuffer.width > 0 && outBuffer.height > 0) { 342 bitmap.setPixels(outBuffer.bits); 343 } else { 344 // be safe with an empty bitmap. 345 bitmap.setPixels(NULL); 346 } 347 348 Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj); 349 nativeCanvas->setBitmap(bitmap); 350 351 if (dirtyRectPtr) { 352 nativeCanvas->clipRect(dirtyRect.left, dirtyRect.top, 353 dirtyRect.right, dirtyRect.bottom, SkClipOp::kIntersect); 354 } 355 356 if (dirtyRectObj) { 357 env->SetIntField(dirtyRectObj, gRectClassInfo.left, dirtyRect.left); 358 env->SetIntField(dirtyRectObj, gRectClassInfo.top, dirtyRect.top); 359 env->SetIntField(dirtyRectObj, gRectClassInfo.right, dirtyRect.right); 360 env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom); 361 } 362 363 // Create another reference to the surface and return it. This reference 364 // should be passed to nativeUnlockCanvasAndPost in place of mNativeObject, 365 // because the latter could be replaced while the surface is locked. 366 sp<Surface> lockedSurface(surface); 367 lockedSurface->incStrong(&sRefBaseOwner); 368 return (jlong) lockedSurface.get(); 369 } 370 371 static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz, 372 jlong nativeObject, jobject canvasObj) { 373 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); 374 if (!isSurfaceValid(surface)) { 375 return; 376 } 377 378 // detach the canvas from the surface 379 Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj); 380 nativeCanvas->setBitmap(SkBitmap()); 381 382 // unlock surface 383 status_t err = surface->unlockAndPost(); 384 if (err < 0) { 385 doThrowIAE(env); 386 } 387 } 388 389 static void nativeAllocateBuffers(JNIEnv* /* env */ , jclass /* clazz */, 390 jlong nativeObject) { 391 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject)); 392 if (!isSurfaceValid(surface)) { 393 return; 394 } 395 396 surface->allocateBuffers(); 397 } 398 399 // ---------------------------------------------------------------------------- 400 401 static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz, 402 jlong surfaceControlNativeObj) { 403 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj)); 404 sp<Surface> surface(ctrl->createSurface()); 405 if (surface != NULL) { 406 surface->incStrong(&sRefBaseOwner); 407 } 408 return reinterpret_cast<jlong>(surface.get()); 409 } 410 411 static jlong nativeGetFromSurfaceControl(JNIEnv* env, jclass clazz, 412 jlong surfaceControlNativeObj) { 413 /* 414 * This is used by the WindowManagerService just after constructing 415 * a Surface and is necessary for returning the Surface reference to 416 * the caller. At this point, we should only have a SurfaceControl. 417 */ 418 419 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj)); 420 sp<Surface> surface(ctrl->getSurface()); 421 if (surface != NULL) { 422 surface->incStrong(&sRefBaseOwner); 423 } 424 return reinterpret_cast<jlong>(surface.get()); 425 } 426 427 static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz, 428 jlong nativeObject, jobject parcelObj) { 429 Parcel* parcel = parcelForJavaObject(env, parcelObj); 430 if (parcel == NULL) { 431 doThrowNPE(env); 432 return 0; 433 } 434 435 android::view::Surface surfaceShim; 436 437 // Calling code in Surface.java has already read the name of the Surface 438 // from the Parcel 439 surfaceShim.readFromParcel(parcel, /*nameAlreadyRead*/true); 440 441 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject)); 442 443 // update the Surface only if the underlying IGraphicBufferProducer 444 // has changed. 445 if (self != nullptr 446 && (IInterface::asBinder(self->getIGraphicBufferProducer()) == 447 IInterface::asBinder(surfaceShim.graphicBufferProducer))) { 448 // same IGraphicBufferProducer, return ourselves 449 return jlong(self.get()); 450 } 451 452 sp<Surface> sur; 453 if (surfaceShim.graphicBufferProducer != nullptr) { 454 // we have a new IGraphicBufferProducer, create a new Surface for it 455 sur = new Surface(surfaceShim.graphicBufferProducer, true); 456 // and keep a reference before passing to java 457 sur->incStrong(&sRefBaseOwner); 458 } 459 460 if (self != NULL) { 461 // and loose the java reference to ourselves 462 self->decStrong(&sRefBaseOwner); 463 } 464 465 return jlong(sur.get()); 466 } 467 468 static void nativeWriteToParcel(JNIEnv* env, jclass clazz, 469 jlong nativeObject, jobject parcelObj) { 470 Parcel* parcel = parcelForJavaObject(env, parcelObj); 471 if (parcel == NULL) { 472 doThrowNPE(env); 473 return; 474 } 475 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject)); 476 android::view::Surface surfaceShim; 477 if (self != nullptr) { 478 surfaceShim.graphicBufferProducer = self->getIGraphicBufferProducer(); 479 } 480 // Calling code in Surface.java has already written the name of the Surface 481 // to the Parcel 482 surfaceShim.writeToParcel(parcel, /*nameAlreadyWritten*/true); 483 } 484 485 static jint nativeGetWidth(JNIEnv* env, jclass clazz, jlong nativeObject) { 486 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 487 ANativeWindow* anw = static_cast<ANativeWindow*>(surface); 488 int value = 0; 489 anw->query(anw, NATIVE_WINDOW_WIDTH, &value); 490 return value; 491 } 492 493 static jint nativeGetHeight(JNIEnv* env, jclass clazz, jlong nativeObject) { 494 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 495 ANativeWindow* anw = static_cast<ANativeWindow*>(surface); 496 int value = 0; 497 anw->query(anw, NATIVE_WINDOW_HEIGHT, &value); 498 return value; 499 } 500 501 static jlong nativeGetNextFrameNumber(JNIEnv *env, jclass clazz, jlong nativeObject) { 502 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 503 return surface->getNextFrameNumber(); 504 } 505 506 static jint nativeSetScalingMode(JNIEnv *env, jclass clazz, jlong nativeObject, jint scalingMode) { 507 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 508 return surface->setScalingMode(scalingMode); 509 } 510 511 static jint nativeForceScopedDisconnect(JNIEnv *env, jclass clazz, jlong nativeObject) { 512 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 513 return surface->disconnect(-1, IGraphicBufferProducer::DisconnectMode::AllLocal); 514 } 515 516 static jint nativeAttachAndQueueBuffer(JNIEnv *env, jclass clazz, jlong nativeObject, 517 jobject graphicBuffer) { 518 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 519 sp<GraphicBuffer> bp = graphicBufferForJavaObject(env, graphicBuffer); 520 if (bp == nullptr) { 521 return BAD_VALUE; 522 } 523 int err = ((ANativeWindow*)surface)->perform(surface, NATIVE_WINDOW_API_CONNECT, 524 NATIVE_WINDOW_API_CPU); 525 if (err != OK) { 526 return err; 527 } 528 err = surface->attachBuffer(bp->getNativeBuffer()); 529 if (err != OK) { 530 return err; 531 } 532 err = ((ANativeWindow*)surface)->queueBuffer(surface, bp->getNativeBuffer(), -1); 533 if (err != OK) { 534 return err; 535 } 536 err = surface->disconnect(NATIVE_WINDOW_API_CPU); 537 return err; 538 } 539 540 static jint nativeSetSharedBufferModeEnabled(JNIEnv* env, jclass clazz, jlong nativeObject, 541 jboolean enabled) { 542 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 543 return ((ANativeWindow*) nativeObject)->perform(surface, 544 NATIVE_WINDOW_SET_SHARED_BUFFER_MODE, enabled); 545 } 546 547 static jint nativeSetAutoRefreshEnabled(JNIEnv* env, jclass clazz, jlong nativeObject, 548 jboolean enabled) { 549 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 550 return ((ANativeWindow*) nativeObject)->perform(surface, 551 NATIVE_WINDOW_SET_AUTO_REFRESH, enabled); 552 } 553 554 namespace uirenderer { 555 556 using namespace android::uirenderer::renderthread; 557 558 class ContextFactory : public IContextFactory { 559 public: 560 virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) { 561 return new AnimationContext(clock); 562 } 563 }; 564 565 static jlong create(JNIEnv* env, jclass clazz, jlong rootNodePtr, jlong surfacePtr) { 566 RenderNode* rootNode = reinterpret_cast<RenderNode*>(rootNodePtr); 567 sp<Surface> surface(reinterpret_cast<Surface*>(surfacePtr)); 568 ContextFactory factory; 569 RenderProxy* proxy = new RenderProxy(false, rootNode, &factory); 570 proxy->loadSystemProperties(); 571 proxy->setSwapBehavior(SwapBehavior::kSwap_discardBuffer); 572 proxy->initialize(surface); 573 // Shadows can't be used via this interface, so just set the light source 574 // to all 0s. 575 proxy->setup(0, 0, 0); 576 proxy->setLightCenter((Vector3){0, 0, 0}); 577 return (jlong) proxy; 578 } 579 580 static void setSurface(JNIEnv* env, jclass clazz, jlong rendererPtr, jlong surfacePtr) { 581 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr); 582 sp<Surface> surface(reinterpret_cast<Surface*>(surfacePtr)); 583 proxy->updateSurface(surface); 584 } 585 586 static void draw(JNIEnv* env, jclass clazz, jlong rendererPtr) { 587 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr); 588 nsecs_t vsync = systemTime(CLOCK_MONOTONIC); 589 UiFrameInfoBuilder(proxy->frameInfo()) 590 .setVsync(vsync, vsync) 591 .addFlag(FrameInfoFlags::SurfaceCanvas); 592 proxy->syncAndDrawFrame(); 593 } 594 595 static void destroy(JNIEnv* env, jclass clazz, jlong rendererPtr) { 596 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr); 597 delete proxy; 598 } 599 600 } // uirenderer 601 602 // ---------------------------------------------------------------------------- 603 604 namespace hwui = android::uirenderer; 605 606 static const JNINativeMethod gSurfaceMethods[] = { 607 {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J", 608 (void*)nativeCreateFromSurfaceTexture }, 609 {"nativeRelease", "(J)V", 610 (void*)nativeRelease }, 611 {"nativeIsValid", "(J)Z", 612 (void*)nativeIsValid }, 613 {"nativeIsConsumerRunningBehind", "(J)Z", 614 (void*)nativeIsConsumerRunningBehind }, 615 {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J", 616 (void*)nativeLockCanvas }, 617 {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V", 618 (void*)nativeUnlockCanvasAndPost }, 619 {"nativeAllocateBuffers", "(J)V", 620 (void*)nativeAllocateBuffers }, 621 {"nativeCreateFromSurfaceControl", "(J)J", 622 (void*)nativeCreateFromSurfaceControl }, 623 {"nativeGetFromSurfaceControl", "(J)J", 624 (void*)nativeGetFromSurfaceControl }, 625 {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J", 626 (void*)nativeReadFromParcel }, 627 {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V", 628 (void*)nativeWriteToParcel }, 629 {"nativeGetWidth", "(J)I", (void*)nativeGetWidth }, 630 {"nativeGetHeight", "(J)I", (void*)nativeGetHeight }, 631 {"nativeGetNextFrameNumber", "(J)J", (void*)nativeGetNextFrameNumber }, 632 {"nativeSetScalingMode", "(JI)I", (void*)nativeSetScalingMode }, 633 {"nativeForceScopedDisconnect", "(J)I", (void*)nativeForceScopedDisconnect}, 634 {"nativeAttachAndQueueBuffer", "(JLandroid/graphics/GraphicBuffer;)I", (void*)nativeAttachAndQueueBuffer}, 635 {"nativeSetSharedBufferModeEnabled", "(JZ)I", (void*)nativeSetSharedBufferModeEnabled}, 636 {"nativeSetAutoRefreshEnabled", "(JZ)I", (void*)nativeSetAutoRefreshEnabled}, 637 638 // HWUI context 639 {"nHwuiCreate", "(JJ)J", (void*) hwui::create }, 640 {"nHwuiSetSurface", "(JJ)V", (void*) hwui::setSurface }, 641 {"nHwuiDraw", "(J)V", (void*) hwui::draw }, 642 {"nHwuiDestroy", "(J)V", (void*) hwui::destroy }, 643 }; 644 645 int register_android_view_Surface(JNIEnv* env) 646 { 647 int err = RegisterMethodsOrDie(env, "android/view/Surface", 648 gSurfaceMethods, NELEM(gSurfaceMethods)); 649 650 jclass clazz = FindClassOrDie(env, "android/view/Surface"); 651 gSurfaceClassInfo.clazz = MakeGlobalRefOrDie(env, clazz); 652 gSurfaceClassInfo.mNativeObject = GetFieldIDOrDie(env, 653 gSurfaceClassInfo.clazz, "mNativeObject", "J"); 654 gSurfaceClassInfo.mLock = GetFieldIDOrDie(env, 655 gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;"); 656 gSurfaceClassInfo.ctor = GetMethodIDOrDie(env, gSurfaceClassInfo.clazz, "<init>", "(J)V"); 657 658 clazz = FindClassOrDie(env, "android/graphics/Rect"); 659 gRectClassInfo.left = GetFieldIDOrDie(env, clazz, "left", "I"); 660 gRectClassInfo.top = GetFieldIDOrDie(env, clazz, "top", "I"); 661 gRectClassInfo.right = GetFieldIDOrDie(env, clazz, "right", "I"); 662 gRectClassInfo.bottom = GetFieldIDOrDie(env, clazz, "bottom", "I"); 663 664 return err; 665 } 666 667 }; 668