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