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 59namespace android { 60 61static const char* const OutOfResourcesException = 62 "android/view/Surface$OutOfResourcesException"; 63 64static struct { 65 jclass clazz; 66 jfieldID mNativeObject; 67 jfieldID mLock; 68 jmethodID ctor; 69} gSurfaceClassInfo; 70 71static 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 81static const void *sRefBaseOwner; 82 83bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) { 84 return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz); 85} 86 87sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) { 88 return android_view_Surface_getSurface(env, surfaceObj); 89} 90 91sp<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 104jobject 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 119jobject 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 129int 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 146android_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 170PublicFormat 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 240static inline bool isSurfaceValid(const sp<Surface>& sur) { 241 return Surface::isValid(sur); 242} 243 244// ---------------------------------------------------------------------------- 245 246static 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 265static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) { 266 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject)); 267 sur->decStrong(&sRefBaseOwner); 268} 269 270static 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 275static 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 287static 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 302static 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 371static 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 389static 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 401static 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 411static 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 427static 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 468static 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 485static 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 493static 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 501static jlong nativeGetNextFrameNumber(JNIEnv *env, jclass clazz, jlong nativeObject) { 502 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 503 return surface->getNextFrameNumber(); 504} 505 506static jint nativeSetScalingMode(JNIEnv *env, jclass clazz, jlong nativeObject, jint scalingMode) { 507 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 508 return surface->setScalingMode(scalingMode); 509} 510 511static 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 516static 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 int err = Surface::attachAndQueueBuffer(surface, bp); 521 return err; 522} 523 524static jint nativeSetSharedBufferModeEnabled(JNIEnv* env, jclass clazz, jlong nativeObject, 525 jboolean enabled) { 526 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 527 ANativeWindow* anw = static_cast<ANativeWindow*>(surface); 528 return anw->perform(surface, NATIVE_WINDOW_SET_SHARED_BUFFER_MODE, int(enabled)); 529} 530 531static jint nativeSetAutoRefreshEnabled(JNIEnv* env, jclass clazz, jlong nativeObject, 532 jboolean enabled) { 533 Surface* surface = reinterpret_cast<Surface*>(nativeObject); 534 ANativeWindow* anw = static_cast<ANativeWindow*>(surface); 535 return anw->perform(surface, NATIVE_WINDOW_SET_AUTO_REFRESH, int(enabled)); 536} 537 538namespace uirenderer { 539 540using namespace android::uirenderer::renderthread; 541 542class ContextFactory : public IContextFactory { 543public: 544 virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) { 545 return new AnimationContext(clock); 546 } 547}; 548 549static jlong create(JNIEnv* env, jclass clazz, jlong rootNodePtr, jlong surfacePtr, 550 jboolean isWideColorGamut) { 551 RenderNode* rootNode = reinterpret_cast<RenderNode*>(rootNodePtr); 552 sp<Surface> surface(reinterpret_cast<Surface*>(surfacePtr)); 553 ContextFactory factory; 554 RenderProxy* proxy = new RenderProxy(false, rootNode, &factory); 555 proxy->loadSystemProperties(); 556 if (isWideColorGamut) { 557 proxy->setWideGamut(true); 558 } 559 proxy->setSwapBehavior(SwapBehavior::kSwap_discardBuffer); 560 proxy->initialize(surface); 561 // Shadows can't be used via this interface, so just set the light source 562 // to all 0s. 563 proxy->setup(0, 0, 0); 564 proxy->setLightCenter((Vector3){0, 0, 0}); 565 return (jlong) proxy; 566} 567 568static void setSurface(JNIEnv* env, jclass clazz, jlong rendererPtr, jlong surfacePtr) { 569 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr); 570 sp<Surface> surface(reinterpret_cast<Surface*>(surfacePtr)); 571 proxy->updateSurface(surface); 572} 573 574static void draw(JNIEnv* env, jclass clazz, jlong rendererPtr) { 575 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr); 576 nsecs_t vsync = systemTime(CLOCK_MONOTONIC); 577 UiFrameInfoBuilder(proxy->frameInfo()) 578 .setVsync(vsync, vsync) 579 .addFlag(FrameInfoFlags::SurfaceCanvas); 580 proxy->syncAndDrawFrame(); 581} 582 583static void destroy(JNIEnv* env, jclass clazz, jlong rendererPtr) { 584 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr); 585 delete proxy; 586} 587 588} // uirenderer 589 590// ---------------------------------------------------------------------------- 591 592namespace hwui = android::uirenderer; 593 594static const JNINativeMethod gSurfaceMethods[] = { 595 {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J", 596 (void*)nativeCreateFromSurfaceTexture }, 597 {"nativeRelease", "(J)V", 598 (void*)nativeRelease }, 599 {"nativeIsValid", "(J)Z", 600 (void*)nativeIsValid }, 601 {"nativeIsConsumerRunningBehind", "(J)Z", 602 (void*)nativeIsConsumerRunningBehind }, 603 {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J", 604 (void*)nativeLockCanvas }, 605 {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V", 606 (void*)nativeUnlockCanvasAndPost }, 607 {"nativeAllocateBuffers", "(J)V", 608 (void*)nativeAllocateBuffers }, 609 {"nativeCreateFromSurfaceControl", "(J)J", 610 (void*)nativeCreateFromSurfaceControl }, 611 {"nativeGetFromSurfaceControl", "(J)J", 612 (void*)nativeGetFromSurfaceControl }, 613 {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J", 614 (void*)nativeReadFromParcel }, 615 {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V", 616 (void*)nativeWriteToParcel }, 617 {"nativeGetWidth", "(J)I", (void*)nativeGetWidth }, 618 {"nativeGetHeight", "(J)I", (void*)nativeGetHeight }, 619 {"nativeGetNextFrameNumber", "(J)J", (void*)nativeGetNextFrameNumber }, 620 {"nativeSetScalingMode", "(JI)I", (void*)nativeSetScalingMode }, 621 {"nativeForceScopedDisconnect", "(J)I", (void*)nativeForceScopedDisconnect}, 622 {"nativeAttachAndQueueBuffer", "(JLandroid/graphics/GraphicBuffer;)I", (void*)nativeAttachAndQueueBuffer}, 623 {"nativeSetSharedBufferModeEnabled", "(JZ)I", (void*)nativeSetSharedBufferModeEnabled}, 624 {"nativeSetAutoRefreshEnabled", "(JZ)I", (void*)nativeSetAutoRefreshEnabled}, 625 626 // HWUI context 627 {"nHwuiCreate", "(JJZ)J", (void*) hwui::create }, 628 {"nHwuiSetSurface", "(JJ)V", (void*) hwui::setSurface }, 629 {"nHwuiDraw", "(J)V", (void*) hwui::draw }, 630 {"nHwuiDestroy", "(J)V", (void*) hwui::destroy }, 631}; 632 633int register_android_view_Surface(JNIEnv* env) 634{ 635 int err = RegisterMethodsOrDie(env, "android/view/Surface", 636 gSurfaceMethods, NELEM(gSurfaceMethods)); 637 638 jclass clazz = FindClassOrDie(env, "android/view/Surface"); 639 gSurfaceClassInfo.clazz = MakeGlobalRefOrDie(env, clazz); 640 gSurfaceClassInfo.mNativeObject = GetFieldIDOrDie(env, 641 gSurfaceClassInfo.clazz, "mNativeObject", "J"); 642 gSurfaceClassInfo.mLock = GetFieldIDOrDie(env, 643 gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;"); 644 gSurfaceClassInfo.ctor = GetMethodIDOrDie(env, gSurfaceClassInfo.clazz, "<init>", "(J)V"); 645 646 clazz = FindClassOrDie(env, "android/graphics/Rect"); 647 gRectClassInfo.left = GetFieldIDOrDie(env, clazz, "left", "I"); 648 gRectClassInfo.top = GetFieldIDOrDie(env, clazz, "top", "I"); 649 gRectClassInfo.right = GetFieldIDOrDie(env, clazz, "right", "I"); 650 gRectClassInfo.bottom = GetFieldIDOrDie(env, clazz, "bottom", "I"); 651 652 return err; 653} 654 655}; 656