android_view_SurfaceControl.cpp revision ed6b9dff563c5e22f040ff37e12c0d771e0478ae
1/* 2 * Copyright (C) 2013 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 "SurfaceControl" 18 19#include <stdio.h> 20 21#include "jni.h" 22#include "JNIHelp.h" 23 24#include "android_os_Parcel.h" 25#include "android_util_Binder.h" 26#include "android/graphics/GraphicsJNI.h" 27#include "android/graphics/Region.h" 28 29#include "core_jni_helpers.h" 30#include <android_runtime/android_view_Surface.h> 31#include <android_runtime/android_view_SurfaceSession.h> 32 33#include <gui/Surface.h> 34#include <gui/SurfaceComposerClient.h> 35 36#include <ui/DisplayInfo.h> 37#include <ui/FrameStats.h> 38#include <ui/Rect.h> 39#include <ui/Region.h> 40 41#include <utils/Log.h> 42 43#include <ScopedUtfChars.h> 44 45#include "SkTemplates.h" 46 47// ---------------------------------------------------------------------------- 48 49namespace android { 50 51static const char* const OutOfResourcesException = 52 "android/view/Surface$OutOfResourcesException"; 53 54static struct { 55 jclass clazz; 56 jmethodID ctor; 57 jfieldID width; 58 jfieldID height; 59 jfieldID refreshRate; 60 jfieldID density; 61 jfieldID xDpi; 62 jfieldID yDpi; 63 jfieldID secure; 64 jfieldID appVsyncOffsetNanos; 65 jfieldID presentationDeadlineNanos; 66} gPhysicalDisplayInfoClassInfo; 67 68static struct { 69 jfieldID bottom; 70 jfieldID left; 71 jfieldID right; 72 jfieldID top; 73} gRectClassInfo; 74 75// Implements SkMallocPixelRef::ReleaseProc, to delete the screenshot on unref. 76void DeleteScreenshot(void* addr, void* context) { 77 SkASSERT(addr == ((ScreenshotClient*) context)->getPixels()); 78 delete ((ScreenshotClient*) context); 79} 80 81static struct { 82 nsecs_t UNDEFINED_TIME_NANO; 83 jmethodID init; 84} gWindowContentFrameStatsClassInfo; 85 86static struct { 87 nsecs_t UNDEFINED_TIME_NANO; 88 jmethodID init; 89} gWindowAnimationFrameStatsClassInfo; 90 91// ---------------------------------------------------------------------------- 92 93static jlong nativeCreate(JNIEnv* env, jclass clazz, jobject sessionObj, 94 jstring nameStr, jint w, jint h, jint format, jint flags) { 95 ScopedUtfChars name(env, nameStr); 96 sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj)); 97 sp<SurfaceControl> surface = client->createSurface( 98 String8(name.c_str()), w, h, format, flags); 99 if (surface == NULL) { 100 jniThrowException(env, OutOfResourcesException, NULL); 101 return 0; 102 } 103 surface->incStrong((void *)nativeCreate); 104 return reinterpret_cast<jlong>(surface.get()); 105} 106 107static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) { 108 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(nativeObject)); 109 ctrl->decStrong((void *)nativeCreate); 110} 111 112static void nativeDestroy(JNIEnv* env, jclass clazz, jlong nativeObject) { 113 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(nativeObject)); 114 ctrl->clear(); 115 ctrl->decStrong((void *)nativeCreate); 116} 117 118static jobject nativeScreenshotBitmap(JNIEnv* env, jclass clazz, 119 jobject displayTokenObj, jobject sourceCropObj, jint width, jint height, 120 jint minLayer, jint maxLayer, bool allLayers, bool useIdentityTransform, 121 int rotation) { 122 sp<IBinder> displayToken = ibinderForJavaObject(env, displayTokenObj); 123 if (displayToken == NULL) { 124 return NULL; 125 } 126 127 int left = env->GetIntField(sourceCropObj, gRectClassInfo.left); 128 int top = env->GetIntField(sourceCropObj, gRectClassInfo.top); 129 int right = env->GetIntField(sourceCropObj, gRectClassInfo.right); 130 int bottom = env->GetIntField(sourceCropObj, gRectClassInfo.bottom); 131 Rect sourceCrop(left, top, right, bottom); 132 133 SkAutoTDelete<ScreenshotClient> screenshot(new ScreenshotClient()); 134 status_t res; 135 if (allLayers) { 136 minLayer = 0; 137 maxLayer = -1; 138 } 139 140 res = screenshot->update(displayToken, sourceCrop, width, height, 141 minLayer, maxLayer, useIdentityTransform, static_cast<uint32_t>(rotation)); 142 if (res != NO_ERROR) { 143 return NULL; 144 } 145 146 SkImageInfo screenshotInfo; 147 screenshotInfo.fWidth = screenshot->getWidth(); 148 screenshotInfo.fHeight = screenshot->getHeight(); 149 150 switch (screenshot->getFormat()) { 151 case PIXEL_FORMAT_RGBX_8888: { 152 screenshotInfo.fColorType = kRGBA_8888_SkColorType; 153 screenshotInfo.fAlphaType = kIgnore_SkAlphaType; 154 break; 155 } 156 case PIXEL_FORMAT_RGBA_8888: { 157 screenshotInfo.fColorType = kRGBA_8888_SkColorType; 158 screenshotInfo.fAlphaType = kPremul_SkAlphaType; 159 break; 160 } 161 case PIXEL_FORMAT_RGB_565: { 162 screenshotInfo.fColorType = kRGB_565_SkColorType; 163 screenshotInfo.fAlphaType = kIgnore_SkAlphaType; 164 break; 165 } 166 default: { 167 return NULL; 168 } 169 } 170 171 const ssize_t rowBytes = 172 screenshot->getStride() * android::bytesPerPixel(screenshot->getFormat()); 173 174 SkBitmap* bitmap = new SkBitmap(); 175 bitmap->setInfo(screenshotInfo, (size_t)rowBytes); 176 if (screenshotInfo.fWidth > 0 && screenshotInfo.fHeight > 0) { 177 // takes ownership of ScreenshotClient 178 SkMallocPixelRef* pixels = SkMallocPixelRef::NewWithProc(screenshotInfo, 179 (size_t) rowBytes, NULL, (void*) screenshot->getPixels(), &DeleteScreenshot, 180 (void*) (screenshot.get())); 181 screenshot.detach(); 182 pixels->setImmutable(); 183 bitmap->setPixelRef(pixels)->unref(); 184 bitmap->lockPixels(); 185 } 186 187 return GraphicsJNI::createBitmap(env, bitmap, 188 GraphicsJNI::kBitmapCreateFlag_Premultiplied, NULL); 189} 190 191static void nativeScreenshot(JNIEnv* env, jclass clazz, jobject displayTokenObj, 192 jobject surfaceObj, jobject sourceCropObj, jint width, jint height, 193 jint minLayer, jint maxLayer, bool allLayers, bool useIdentityTransform) { 194 sp<IBinder> displayToken = ibinderForJavaObject(env, displayTokenObj); 195 if (displayToken != NULL) { 196 sp<Surface> consumer = android_view_Surface_getSurface(env, surfaceObj); 197 if (consumer != NULL) { 198 int left = env->GetIntField(sourceCropObj, gRectClassInfo.left); 199 int top = env->GetIntField(sourceCropObj, gRectClassInfo.top); 200 int right = env->GetIntField(sourceCropObj, gRectClassInfo.right); 201 int bottom = env->GetIntField(sourceCropObj, gRectClassInfo.bottom); 202 Rect sourceCrop(left, top, right, bottom); 203 204 if (allLayers) { 205 minLayer = 0; 206 maxLayer = -1; 207 } 208 ScreenshotClient::capture(displayToken, 209 consumer->getIGraphicBufferProducer(), sourceCrop, 210 width, height, uint32_t(minLayer), uint32_t(maxLayer), 211 useIdentityTransform); 212 } 213 } 214} 215 216static void nativeOpenTransaction(JNIEnv* env, jclass clazz) { 217 SurfaceComposerClient::openGlobalTransaction(); 218} 219 220static void nativeCloseTransaction(JNIEnv* env, jclass clazz) { 221 SurfaceComposerClient::closeGlobalTransaction(); 222} 223 224static void nativeSetAnimationTransaction(JNIEnv* env, jclass clazz) { 225 SurfaceComposerClient::setAnimationTransaction(); 226} 227 228static void nativeSetLayer(JNIEnv* env, jclass clazz, jlong nativeObject, jint zorder) { 229 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 230 status_t err = ctrl->setLayer(zorder); 231 if (err < 0 && err != NO_INIT) { 232 doThrowIAE(env); 233 } 234} 235 236static void nativeSetPosition(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat x, jfloat y) { 237 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 238 status_t err = ctrl->setPosition(x, y); 239 if (err < 0 && err != NO_INIT) { 240 doThrowIAE(env); 241 } 242} 243 244static void nativeSetSize(JNIEnv* env, jclass clazz, jlong nativeObject, jint w, jint h) { 245 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 246 status_t err = ctrl->setSize(w, h); 247 if (err < 0 && err != NO_INIT) { 248 doThrowIAE(env); 249 } 250} 251 252static void nativeSetFlags(JNIEnv* env, jclass clazz, jlong nativeObject, jint flags, jint mask) { 253 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 254 status_t err = ctrl->setFlags(flags, mask); 255 if (err < 0 && err != NO_INIT) { 256 doThrowIAE(env); 257 } 258} 259 260static void nativeSetTransparentRegionHint(JNIEnv* env, jclass clazz, jlong nativeObject, jobject regionObj) { 261 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 262 SkRegion* region = android_graphics_Region_getSkRegion(env, regionObj); 263 if (!region) { 264 doThrowIAE(env); 265 return; 266 } 267 268 const SkIRect& b(region->getBounds()); 269 Region reg(Rect(b.fLeft, b.fTop, b.fRight, b.fBottom)); 270 if (region->isComplex()) { 271 SkRegion::Iterator it(*region); 272 while (!it.done()) { 273 const SkIRect& r(it.rect()); 274 reg.addRectUnchecked(r.fLeft, r.fTop, r.fRight, r.fBottom); 275 it.next(); 276 } 277 } 278 279 status_t err = ctrl->setTransparentRegionHint(reg); 280 if (err < 0 && err != NO_INIT) { 281 doThrowIAE(env); 282 } 283} 284 285static void nativeSetAlpha(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat alpha) { 286 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 287 status_t err = ctrl->setAlpha(alpha); 288 if (err < 0 && err != NO_INIT) { 289 doThrowIAE(env); 290 } 291} 292 293static void nativeSetMatrix(JNIEnv* env, jclass clazz, jlong nativeObject, 294 jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy) { 295 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 296 status_t err = ctrl->setMatrix(dsdx, dtdx, dsdy, dtdy); 297 if (err < 0 && err != NO_INIT) { 298 doThrowIAE(env); 299 } 300} 301 302static void nativeSetWindowCrop(JNIEnv* env, jclass clazz, jlong nativeObject, 303 jint l, jint t, jint r, jint b) { 304 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 305 Rect crop(l, t, r, b); 306 status_t err = ctrl->setCrop(crop); 307 if (err < 0 && err != NO_INIT) { 308 doThrowIAE(env); 309 } 310} 311 312static void nativeSetLayerStack(JNIEnv* env, jclass clazz, jlong nativeObject, jint layerStack) { 313 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 314 status_t err = ctrl->setLayerStack(layerStack); 315 if (err < 0 && err != NO_INIT) { 316 doThrowIAE(env); 317 } 318} 319 320static jobject nativeGetBuiltInDisplay(JNIEnv* env, jclass clazz, jint id) { 321 sp<IBinder> token(SurfaceComposerClient::getBuiltInDisplay(id)); 322 return javaObjectForIBinder(env, token); 323} 324 325static jobject nativeCreateDisplay(JNIEnv* env, jclass clazz, jstring nameObj, 326 jboolean secure) { 327 ScopedUtfChars name(env, nameObj); 328 sp<IBinder> token(SurfaceComposerClient::createDisplay( 329 String8(name.c_str()), bool(secure))); 330 return javaObjectForIBinder(env, token); 331} 332 333static void nativeDestroyDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) { 334 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 335 if (token == NULL) return; 336 SurfaceComposerClient::destroyDisplay(token); 337} 338 339static void nativeSetDisplaySurface(JNIEnv* env, jclass clazz, 340 jobject tokenObj, jlong nativeSurfaceObject) { 341 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 342 if (token == NULL) return; 343 sp<IGraphicBufferProducer> bufferProducer; 344 sp<Surface> sur(reinterpret_cast<Surface *>(nativeSurfaceObject)); 345 if (sur != NULL) { 346 bufferProducer = sur->getIGraphicBufferProducer(); 347 } 348 SurfaceComposerClient::setDisplaySurface(token, bufferProducer); 349} 350 351static void nativeSetDisplayLayerStack(JNIEnv* env, jclass clazz, 352 jobject tokenObj, jint layerStack) { 353 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 354 if (token == NULL) return; 355 356 SurfaceComposerClient::setDisplayLayerStack(token, layerStack); 357} 358 359static void nativeSetDisplayProjection(JNIEnv* env, jclass clazz, 360 jobject tokenObj, jint orientation, 361 jint layerStackRect_left, jint layerStackRect_top, jint layerStackRect_right, jint layerStackRect_bottom, 362 jint displayRect_left, jint displayRect_top, jint displayRect_right, jint displayRect_bottom) { 363 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 364 if (token == NULL) return; 365 Rect layerStackRect(layerStackRect_left, layerStackRect_top, layerStackRect_right, layerStackRect_bottom); 366 Rect displayRect(displayRect_left, displayRect_top, displayRect_right, displayRect_bottom); 367 SurfaceComposerClient::setDisplayProjection(token, orientation, layerStackRect, displayRect); 368} 369 370static void nativeSetDisplaySize(JNIEnv* env, jclass clazz, 371 jobject tokenObj, jint width, jint height) { 372 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 373 if (token == NULL) return; 374 SurfaceComposerClient::setDisplaySize(token, width, height); 375} 376 377static jobjectArray nativeGetDisplayConfigs(JNIEnv* env, jclass clazz, 378 jobject tokenObj) { 379 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 380 if (token == NULL) return NULL; 381 382 Vector<DisplayInfo> configs; 383 if (SurfaceComposerClient::getDisplayConfigs(token, &configs) != NO_ERROR || 384 configs.size() == 0) { 385 return NULL; 386 } 387 388 jobjectArray configArray = env->NewObjectArray(configs.size(), 389 gPhysicalDisplayInfoClassInfo.clazz, NULL); 390 391 for (size_t c = 0; c < configs.size(); ++c) { 392 const DisplayInfo& info = configs[c]; 393 jobject infoObj = env->NewObject(gPhysicalDisplayInfoClassInfo.clazz, 394 gPhysicalDisplayInfoClassInfo.ctor); 395 env->SetIntField(infoObj, gPhysicalDisplayInfoClassInfo.width, info.w); 396 env->SetIntField(infoObj, gPhysicalDisplayInfoClassInfo.height, info.h); 397 env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.refreshRate, info.fps); 398 env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.density, info.density); 399 env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.xDpi, info.xdpi); 400 env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.yDpi, info.ydpi); 401 env->SetBooleanField(infoObj, gPhysicalDisplayInfoClassInfo.secure, info.secure); 402 env->SetLongField(infoObj, gPhysicalDisplayInfoClassInfo.appVsyncOffsetNanos, 403 info.appVsyncOffset); 404 env->SetLongField(infoObj, gPhysicalDisplayInfoClassInfo.presentationDeadlineNanos, 405 info.presentationDeadline); 406 env->SetObjectArrayElement(configArray, static_cast<jsize>(c), infoObj); 407 env->DeleteLocalRef(infoObj); 408 } 409 410 return configArray; 411} 412 413static jint nativeGetActiveConfig(JNIEnv* env, jclass clazz, jobject tokenObj) { 414 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 415 if (token == NULL) return -1; 416 return static_cast<jint>(SurfaceComposerClient::getActiveConfig(token)); 417} 418 419static jboolean nativeSetActiveConfig(JNIEnv* env, jclass clazz, jobject tokenObj, jint id) { 420 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 421 if (token == NULL) return JNI_FALSE; 422 status_t err = SurfaceComposerClient::setActiveConfig(token, static_cast<int>(id)); 423 return err == NO_ERROR ? JNI_TRUE : JNI_FALSE; 424} 425 426static void nativeSetDisplayPowerMode(JNIEnv* env, jclass clazz, jobject tokenObj, jint mode) { 427 sp<IBinder> token(ibinderForJavaObject(env, tokenObj)); 428 if (token == NULL) return; 429 430 ALOGD_IF_SLOW(100, "Excessive delay in setPowerMode()"); 431 SurfaceComposerClient::setDisplayPowerMode(token, mode); 432} 433 434static jboolean nativeClearContentFrameStats(JNIEnv* env, jclass clazz, jlong nativeObject) { 435 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 436 status_t err = ctrl->clearLayerFrameStats(); 437 438 if (err < 0 && err != NO_INIT) { 439 doThrowIAE(env); 440 } 441 442 // The other end is not ready, just report we failed. 443 if (err == NO_INIT) { 444 return JNI_FALSE; 445 } 446 447 return JNI_TRUE; 448} 449 450static jboolean nativeGetContentFrameStats(JNIEnv* env, jclass clazz, jlong nativeObject, 451 jobject outStats) { 452 FrameStats stats; 453 454 SurfaceControl* const ctrl = reinterpret_cast<SurfaceControl *>(nativeObject); 455 status_t err = ctrl->getLayerFrameStats(&stats); 456 if (err < 0 && err != NO_INIT) { 457 doThrowIAE(env); 458 } 459 460 // The other end is not ready, fine just return empty stats. 461 if (err == NO_INIT) { 462 return JNI_FALSE; 463 } 464 465 jlong refreshPeriodNano = static_cast<jlong>(stats.refreshPeriodNano); 466 size_t frameCount = stats.desiredPresentTimesNano.size(); 467 468 jlongArray postedTimesNanoDst = env->NewLongArray(frameCount); 469 if (postedTimesNanoDst == NULL) { 470 return JNI_FALSE; 471 } 472 473 jlongArray presentedTimesNanoDst = env->NewLongArray(frameCount); 474 if (presentedTimesNanoDst == NULL) { 475 return JNI_FALSE; 476 } 477 478 jlongArray readyTimesNanoDst = env->NewLongArray(frameCount); 479 if (readyTimesNanoDst == NULL) { 480 return JNI_FALSE; 481 } 482 483 nsecs_t postedTimesNanoSrc[frameCount]; 484 nsecs_t presentedTimesNanoSrc[frameCount]; 485 nsecs_t readyTimesNanoSrc[frameCount]; 486 487 for (size_t i = 0; i < frameCount; i++) { 488 nsecs_t postedTimeNano = stats.desiredPresentTimesNano[i]; 489 if (postedTimeNano == INT64_MAX) { 490 postedTimeNano = gWindowContentFrameStatsClassInfo.UNDEFINED_TIME_NANO; 491 } 492 postedTimesNanoSrc[i] = postedTimeNano; 493 494 nsecs_t presentedTimeNano = stats.actualPresentTimesNano[i]; 495 if (presentedTimeNano == INT64_MAX) { 496 presentedTimeNano = gWindowContentFrameStatsClassInfo.UNDEFINED_TIME_NANO; 497 } 498 presentedTimesNanoSrc[i] = presentedTimeNano; 499 500 nsecs_t readyTimeNano = stats.frameReadyTimesNano[i]; 501 if (readyTimeNano == INT64_MAX) { 502 readyTimeNano = gWindowContentFrameStatsClassInfo.UNDEFINED_TIME_NANO; 503 } 504 readyTimesNanoSrc[i] = readyTimeNano; 505 } 506 507 env->SetLongArrayRegion(postedTimesNanoDst, 0, frameCount, postedTimesNanoSrc); 508 env->SetLongArrayRegion(presentedTimesNanoDst, 0, frameCount, presentedTimesNanoSrc); 509 env->SetLongArrayRegion(readyTimesNanoDst, 0, frameCount, readyTimesNanoSrc); 510 511 env->CallVoidMethod(outStats, gWindowContentFrameStatsClassInfo.init, refreshPeriodNano, 512 postedTimesNanoDst, presentedTimesNanoDst, readyTimesNanoDst); 513 514 if (env->ExceptionCheck()) { 515 return JNI_FALSE; 516 } 517 518 return JNI_TRUE; 519} 520 521static jboolean nativeClearAnimationFrameStats(JNIEnv* env, jclass clazz) { 522 status_t err = SurfaceComposerClient::clearAnimationFrameStats(); 523 524 if (err < 0 && err != NO_INIT) { 525 doThrowIAE(env); 526 } 527 528 // The other end is not ready, just report we failed. 529 if (err == NO_INIT) { 530 return JNI_FALSE; 531 } 532 533 return JNI_TRUE; 534} 535 536static jboolean nativeGetAnimationFrameStats(JNIEnv* env, jclass clazz, jobject outStats) { 537 FrameStats stats; 538 539 status_t err = SurfaceComposerClient::getAnimationFrameStats(&stats); 540 if (err < 0 && err != NO_INIT) { 541 doThrowIAE(env); 542 } 543 544 // The other end is not ready, fine just return empty stats. 545 if (err == NO_INIT) { 546 return JNI_FALSE; 547 } 548 549 jlong refreshPeriodNano = static_cast<jlong>(stats.refreshPeriodNano); 550 size_t frameCount = stats.desiredPresentTimesNano.size(); 551 552 jlongArray presentedTimesNanoDst = env->NewLongArray(frameCount); 553 if (presentedTimesNanoDst == NULL) { 554 return JNI_FALSE; 555 } 556 557 nsecs_t presentedTimesNanoSrc[frameCount]; 558 559 for (size_t i = 0; i < frameCount; i++) { 560 nsecs_t presentedTimeNano = stats.actualPresentTimesNano[i]; 561 if (presentedTimeNano == INT64_MAX) { 562 presentedTimeNano = gWindowContentFrameStatsClassInfo.UNDEFINED_TIME_NANO; 563 } 564 presentedTimesNanoSrc[i] = presentedTimeNano; 565 } 566 567 env->SetLongArrayRegion(presentedTimesNanoDst, 0, frameCount, presentedTimesNanoSrc); 568 569 env->CallVoidMethod(outStats, gWindowAnimationFrameStatsClassInfo.init, refreshPeriodNano, 570 presentedTimesNanoDst); 571 572 if (env->ExceptionCheck()) { 573 return JNI_FALSE; 574 } 575 576 return JNI_TRUE; 577} 578 579// ---------------------------------------------------------------------------- 580 581static JNINativeMethod sSurfaceControlMethods[] = { 582 {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIII)J", 583 (void*)nativeCreate }, 584 {"nativeRelease", "(J)V", 585 (void*)nativeRelease }, 586 {"nativeDestroy", "(J)V", 587 (void*)nativeDestroy }, 588 {"nativeScreenshot", "(Landroid/os/IBinder;Landroid/graphics/Rect;IIIIZZI)Landroid/graphics/Bitmap;", 589 (void*)nativeScreenshotBitmap }, 590 {"nativeScreenshot", "(Landroid/os/IBinder;Landroid/view/Surface;Landroid/graphics/Rect;IIIIZZ)V", 591 (void*)nativeScreenshot }, 592 {"nativeOpenTransaction", "()V", 593 (void*)nativeOpenTransaction }, 594 {"nativeCloseTransaction", "()V", 595 (void*)nativeCloseTransaction }, 596 {"nativeSetAnimationTransaction", "()V", 597 (void*)nativeSetAnimationTransaction }, 598 {"nativeSetLayer", "(JI)V", 599 (void*)nativeSetLayer }, 600 {"nativeSetPosition", "(JFF)V", 601 (void*)nativeSetPosition }, 602 {"nativeSetSize", "(JII)V", 603 (void*)nativeSetSize }, 604 {"nativeSetTransparentRegionHint", "(JLandroid/graphics/Region;)V", 605 (void*)nativeSetTransparentRegionHint }, 606 {"nativeSetAlpha", "(JF)V", 607 (void*)nativeSetAlpha }, 608 {"nativeSetMatrix", "(JFFFF)V", 609 (void*)nativeSetMatrix }, 610 {"nativeSetFlags", "(JII)V", 611 (void*)nativeSetFlags }, 612 {"nativeSetWindowCrop", "(JIIII)V", 613 (void*)nativeSetWindowCrop }, 614 {"nativeSetLayerStack", "(JI)V", 615 (void*)nativeSetLayerStack }, 616 {"nativeGetBuiltInDisplay", "(I)Landroid/os/IBinder;", 617 (void*)nativeGetBuiltInDisplay }, 618 {"nativeCreateDisplay", "(Ljava/lang/String;Z)Landroid/os/IBinder;", 619 (void*)nativeCreateDisplay }, 620 {"nativeDestroyDisplay", "(Landroid/os/IBinder;)V", 621 (void*)nativeDestroyDisplay }, 622 {"nativeSetDisplaySurface", "(Landroid/os/IBinder;J)V", 623 (void*)nativeSetDisplaySurface }, 624 {"nativeSetDisplayLayerStack", "(Landroid/os/IBinder;I)V", 625 (void*)nativeSetDisplayLayerStack }, 626 {"nativeSetDisplayProjection", "(Landroid/os/IBinder;IIIIIIIII)V", 627 (void*)nativeSetDisplayProjection }, 628 {"nativeSetDisplaySize", "(Landroid/os/IBinder;II)V", 629 (void*)nativeSetDisplaySize }, 630 {"nativeGetDisplayConfigs", "(Landroid/os/IBinder;)[Landroid/view/SurfaceControl$PhysicalDisplayInfo;", 631 (void*)nativeGetDisplayConfigs }, 632 {"nativeGetActiveConfig", "(Landroid/os/IBinder;)I", 633 (void*)nativeGetActiveConfig }, 634 {"nativeSetActiveConfig", "(Landroid/os/IBinder;I)Z", 635 (void*)nativeSetActiveConfig }, 636 {"nativeClearContentFrameStats", "(J)Z", 637 (void*)nativeClearContentFrameStats }, 638 {"nativeGetContentFrameStats", "(JLandroid/view/WindowContentFrameStats;)Z", 639 (void*)nativeGetContentFrameStats }, 640 {"nativeClearAnimationFrameStats", "()Z", 641 (void*)nativeClearAnimationFrameStats }, 642 {"nativeGetAnimationFrameStats", "(Landroid/view/WindowAnimationFrameStats;)Z", 643 (void*)nativeGetAnimationFrameStats }, 644 {"nativeSetDisplayPowerMode", "(Landroid/os/IBinder;I)V", 645 (void*)nativeSetDisplayPowerMode }, 646}; 647 648int register_android_view_SurfaceControl(JNIEnv* env) 649{ 650 int err = RegisterMethodsOrDie(env, "android/view/SurfaceControl", 651 sSurfaceControlMethods, NELEM(sSurfaceControlMethods)); 652 653 jclass clazz = FindClassOrDie(env, "android/view/SurfaceControl$PhysicalDisplayInfo"); 654 gPhysicalDisplayInfoClassInfo.clazz = MakeGlobalRefOrDie(env, clazz); 655 gPhysicalDisplayInfoClassInfo.ctor = GetMethodIDOrDie(env, 656 gPhysicalDisplayInfoClassInfo.clazz, "<init>", "()V"); 657 gPhysicalDisplayInfoClassInfo.width = GetFieldIDOrDie(env, clazz, "width", "I"); 658 gPhysicalDisplayInfoClassInfo.height = GetFieldIDOrDie(env, clazz, "height", "I"); 659 gPhysicalDisplayInfoClassInfo.refreshRate = GetFieldIDOrDie(env, clazz, "refreshRate", "F"); 660 gPhysicalDisplayInfoClassInfo.density = GetFieldIDOrDie(env, clazz, "density", "F"); 661 gPhysicalDisplayInfoClassInfo.xDpi = GetFieldIDOrDie(env, clazz, "xDpi", "F"); 662 gPhysicalDisplayInfoClassInfo.yDpi = GetFieldIDOrDie(env, clazz, "yDpi", "F"); 663 gPhysicalDisplayInfoClassInfo.secure = GetFieldIDOrDie(env, clazz, "secure", "Z"); 664 gPhysicalDisplayInfoClassInfo.appVsyncOffsetNanos = GetFieldIDOrDie(env, 665 clazz, "appVsyncOffsetNanos", "J"); 666 gPhysicalDisplayInfoClassInfo.presentationDeadlineNanos = GetFieldIDOrDie(env, 667 clazz, "presentationDeadlineNanos", "J"); 668 669 jclass rectClazz = FindClassOrDie(env, "android/graphics/Rect"); 670 gRectClassInfo.bottom = GetFieldIDOrDie(env, rectClazz, "bottom", "I"); 671 gRectClassInfo.left = GetFieldIDOrDie(env, rectClazz, "left", "I"); 672 gRectClassInfo.right = GetFieldIDOrDie(env, rectClazz, "right", "I"); 673 gRectClassInfo.top = GetFieldIDOrDie(env, rectClazz, "top", "I"); 674 675 jclass frameStatsClazz = FindClassOrDie(env, "android/view/FrameStats"); 676 jfieldID undefined_time_nano_field = GetStaticFieldIDOrDie(env, 677 frameStatsClazz, "UNDEFINED_TIME_NANO", "J"); 678 nsecs_t undefined_time_nano = env->GetStaticLongField(frameStatsClazz, undefined_time_nano_field); 679 680 jclass contFrameStatsClazz = FindClassOrDie(env, "android/view/WindowContentFrameStats"); 681 gWindowContentFrameStatsClassInfo.init = GetMethodIDOrDie(env, 682 contFrameStatsClazz, "init", "(J[J[J[J)V"); 683 gWindowContentFrameStatsClassInfo.UNDEFINED_TIME_NANO = undefined_time_nano; 684 685 jclass animFrameStatsClazz = FindClassOrDie(env, "android/view/WindowAnimationFrameStats"); 686 gWindowAnimationFrameStatsClassInfo.init = GetMethodIDOrDie(env, 687 animFrameStatsClazz, "init", "(J[J)V"); 688 gWindowAnimationFrameStatsClassInfo.UNDEFINED_TIME_NANO = undefined_time_nano; 689 690 return err; 691} 692 693}; 694