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_V0_JFIF;
148 case PublicFormat::DEPTH_POINT_CLOUD:
149 case PublicFormat::DEPTH16:
150 return HAL_DATASPACE_DEPTH;
151 case PublicFormat::RAW_SENSOR:
152 case PublicFormat::RAW_PRIVATE:
153 case PublicFormat::RAW10:
154 case PublicFormat::RAW12:
155 return HAL_DATASPACE_ARBITRARY;
156 case PublicFormat::YUV_420_888:
157 case PublicFormat::NV21:
158 case PublicFormat::YV12:
159 return HAL_DATASPACE_V0_JFIF;
160 default:
161 // Most formats map to UNKNOWN
162 return HAL_DATASPACE_UNKNOWN;
163 }
164 }
165
android_view_Surface_mapHalFormatDataspaceToPublicFormat(int format,android_dataspace dataSpace)166 PublicFormat android_view_Surface_mapHalFormatDataspaceToPublicFormat(
167 int format, android_dataspace dataSpace) {
168 switch(format) {
169 case HAL_PIXEL_FORMAT_RGBA_8888:
170 case HAL_PIXEL_FORMAT_RGBX_8888:
171 case HAL_PIXEL_FORMAT_RGB_888:
172 case HAL_PIXEL_FORMAT_RGB_565:
173 case HAL_PIXEL_FORMAT_Y8:
174 case HAL_PIXEL_FORMAT_RAW10:
175 case HAL_PIXEL_FORMAT_RAW12:
176 case HAL_PIXEL_FORMAT_YCbCr_420_888:
177 case HAL_PIXEL_FORMAT_YV12:
178 // Enums overlap in both name and value
179 return static_cast<PublicFormat>(format);
180 case HAL_PIXEL_FORMAT_RAW16:
181 // Name differs, though value is the same
182 return PublicFormat::RAW_SENSOR;
183 case HAL_PIXEL_FORMAT_RAW_OPAQUE:
184 // Name differs, though value is the same
185 return PublicFormat::RAW_PRIVATE;
186 case HAL_PIXEL_FORMAT_YCbCr_422_SP:
187 // Name differs, though the value is the same
188 return PublicFormat::NV16;
189 case HAL_PIXEL_FORMAT_YCrCb_420_SP:
190 // Name differs, though the value is the same
191 return PublicFormat::NV21;
192 case HAL_PIXEL_FORMAT_YCbCr_422_I:
193 // Name differs, though the value is the same
194 return PublicFormat::YUY2;
195 case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
196 // Name differs, though the value is the same
197 return PublicFormat::PRIVATE;
198 case HAL_PIXEL_FORMAT_Y16:
199 // Dataspace-dependent
200 switch (dataSpace) {
201 case HAL_DATASPACE_DEPTH:
202 return PublicFormat::DEPTH16;
203 default:
204 // Assume non-depth Y16 is just Y16.
205 return PublicFormat::Y16;
206 }
207 break;
208 case HAL_PIXEL_FORMAT_BLOB:
209 // Dataspace-dependent
210 switch (dataSpace) {
211 case HAL_DATASPACE_DEPTH:
212 return PublicFormat::DEPTH_POINT_CLOUD;
213 case HAL_DATASPACE_V0_JFIF:
214 return PublicFormat::JPEG;
215 default:
216 // Assume otherwise-marked blobs are also JPEG
217 return PublicFormat::JPEG;
218 }
219 break;
220 case HAL_PIXEL_FORMAT_BGRA_8888:
221 // Not defined in public API
222 return PublicFormat::UNKNOWN;
223
224 default:
225 return PublicFormat::UNKNOWN;
226 }
227 }
228 // ----------------------------------------------------------------------------
229
isSurfaceValid(const sp<Surface> & sur)230 static inline bool isSurfaceValid(const sp<Surface>& sur) {
231 return Surface::isValid(sur);
232 }
233
234 // ----------------------------------------------------------------------------
235
nativeCreateFromSurfaceTexture(JNIEnv * env,jclass clazz,jobject surfaceTextureObj)236 static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,
237 jobject surfaceTextureObj) {
238 sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj));
239 if (producer == NULL) {
240 jniThrowException(env, "java/lang/IllegalArgumentException",
241 "SurfaceTexture has already been released");
242 return 0;
243 }
244
245 sp<Surface> surface(new Surface(producer, true));
246 if (surface == NULL) {
247 jniThrowException(env, OutOfResourcesException, NULL);
248 return 0;
249 }
250
251 surface->incStrong(&sRefBaseOwner);
252 return jlong(surface.get());
253 }
254
nativeRelease(JNIEnv * env,jclass clazz,jlong nativeObject)255 static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) {
256 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
257 sur->decStrong(&sRefBaseOwner);
258 }
259
nativeIsValid(JNIEnv * env,jclass clazz,jlong nativeObject)260 static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) {
261 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
262 return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE;
263 }
264
nativeIsConsumerRunningBehind(JNIEnv * env,jclass clazz,jlong nativeObject)265 static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) {
266 sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
267 if (!isSurfaceValid(sur)) {
268 doThrowIAE(env);
269 return JNI_FALSE;
270 }
271 int value = 0;
272 ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get());
273 anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value);
274 return value;
275 }
276
convertPixelFormat(PixelFormat format)277 static inline SkColorType convertPixelFormat(PixelFormat format) {
278 /* note: if PIXEL_FORMAT_RGBX_8888 means that all alpha bytes are 0xFF, then
279 we can map to kN32_SkColorType, and optionally call
280 bitmap.setAlphaType(kOpaque_SkAlphaType) on the resulting SkBitmap
281 (as an accelerator)
282 */
283 switch (format) {
284 case PIXEL_FORMAT_RGBX_8888: return kN32_SkColorType;
285 case PIXEL_FORMAT_RGBA_8888: return kN32_SkColorType;
286 case PIXEL_FORMAT_RGB_565: return kRGB_565_SkColorType;
287 default: return kUnknown_SkColorType;
288 }
289 }
290
nativeLockCanvas(JNIEnv * env,jclass clazz,jlong nativeObject,jobject canvasObj,jobject dirtyRectObj)291 static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
292 jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
293 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
294
295 if (!isSurfaceValid(surface)) {
296 doThrowIAE(env);
297 return 0;
298 }
299
300 Rect dirtyRect(Rect::EMPTY_RECT);
301 Rect* dirtyRectPtr = NULL;
302
303 if (dirtyRectObj) {
304 dirtyRect.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left);
305 dirtyRect.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top);
306 dirtyRect.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right);
307 dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);
308 dirtyRectPtr = &dirtyRect;
309 }
310
311 ANativeWindow_Buffer outBuffer;
312 status_t err = surface->lock(&outBuffer, dirtyRectPtr);
313 if (err < 0) {
314 const char* const exception = (err == NO_MEMORY) ?
315 OutOfResourcesException :
316 "java/lang/IllegalArgumentException";
317 jniThrowException(env, exception, NULL);
318 return 0;
319 }
320
321
322 SkImageInfo info = SkImageInfo::Make(outBuffer.width, outBuffer.height,
323 convertPixelFormat(outBuffer.format),
324 outBuffer.format == PIXEL_FORMAT_RGBX_8888 ?
325 kOpaque_SkAlphaType : kPremul_SkAlphaType);
326
327 SkBitmap bitmap;
328 ssize_t bpr = outBuffer.stride * bytesPerPixel(outBuffer.format);
329 bitmap.setInfo(info, bpr);
330 if (outBuffer.width > 0 && outBuffer.height > 0) {
331 bitmap.setPixels(outBuffer.bits);
332 } else {
333 // be safe with an empty bitmap.
334 bitmap.setPixels(NULL);
335 }
336
337 Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);
338 nativeCanvas->setBitmap(bitmap);
339
340 if (dirtyRectPtr) {
341 nativeCanvas->clipRect(dirtyRect.left, dirtyRect.top,
342 dirtyRect.right, dirtyRect.bottom);
343 }
344
345 if (dirtyRectObj) {
346 env->SetIntField(dirtyRectObj, gRectClassInfo.left, dirtyRect.left);
347 env->SetIntField(dirtyRectObj, gRectClassInfo.top, dirtyRect.top);
348 env->SetIntField(dirtyRectObj, gRectClassInfo.right, dirtyRect.right);
349 env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom);
350 }
351
352 // Create another reference to the surface and return it. This reference
353 // should be passed to nativeUnlockCanvasAndPost in place of mNativeObject,
354 // because the latter could be replaced while the surface is locked.
355 sp<Surface> lockedSurface(surface);
356 lockedSurface->incStrong(&sRefBaseOwner);
357 return (jlong) lockedSurface.get();
358 }
359
nativeUnlockCanvasAndPost(JNIEnv * env,jclass clazz,jlong nativeObject,jobject canvasObj)360 static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
361 jlong nativeObject, jobject canvasObj) {
362 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
363 if (!isSurfaceValid(surface)) {
364 return;
365 }
366
367 // detach the canvas from the surface
368 Canvas* nativeCanvas = GraphicsJNI::getNativeCanvas(env, canvasObj);
369 nativeCanvas->setBitmap(SkBitmap());
370
371 // unlock surface
372 status_t err = surface->unlockAndPost();
373 if (err < 0) {
374 doThrowIAE(env);
375 }
376 }
377
nativeAllocateBuffers(JNIEnv *,jclass,jlong nativeObject)378 static void nativeAllocateBuffers(JNIEnv* /* env */ , jclass /* clazz */,
379 jlong nativeObject) {
380 sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
381 if (!isSurfaceValid(surface)) {
382 return;
383 }
384
385 surface->allocateBuffers();
386 }
387
388 // ----------------------------------------------------------------------------
389
nativeCreateFromSurfaceControl(JNIEnv * env,jclass clazz,jlong surfaceControlNativeObj)390 static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,
391 jlong surfaceControlNativeObj) {
392 /*
393 * This is used by the WindowManagerService just after constructing
394 * a Surface and is necessary for returning the Surface reference to
395 * the caller. At this point, we should only have a SurfaceControl.
396 */
397
398 sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));
399 sp<Surface> surface(ctrl->getSurface());
400 if (surface != NULL) {
401 surface->incStrong(&sRefBaseOwner);
402 }
403 return reinterpret_cast<jlong>(surface.get());
404 }
405
nativeReadFromParcel(JNIEnv * env,jclass clazz,jlong nativeObject,jobject parcelObj)406 static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz,
407 jlong nativeObject, jobject parcelObj) {
408 Parcel* parcel = parcelForJavaObject(env, parcelObj);
409 if (parcel == NULL) {
410 doThrowNPE(env);
411 return 0;
412 }
413
414 android::view::Surface surfaceShim;
415
416 // Calling code in Surface.java has already read the name of the Surface
417 // from the Parcel
418 surfaceShim.readFromParcel(parcel, /*nameAlreadyRead*/true);
419
420 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
421
422 // update the Surface only if the underlying IGraphicBufferProducer
423 // has changed.
424 if (self != nullptr
425 && (IInterface::asBinder(self->getIGraphicBufferProducer()) ==
426 IInterface::asBinder(surfaceShim.graphicBufferProducer))) {
427 // same IGraphicBufferProducer, return ourselves
428 return jlong(self.get());
429 }
430
431 sp<Surface> sur;
432 if (surfaceShim.graphicBufferProducer != nullptr) {
433 // we have a new IGraphicBufferProducer, create a new Surface for it
434 sur = new Surface(surfaceShim.graphicBufferProducer, true);
435 // and keep a reference before passing to java
436 sur->incStrong(&sRefBaseOwner);
437 }
438
439 if (self != NULL) {
440 // and loose the java reference to ourselves
441 self->decStrong(&sRefBaseOwner);
442 }
443
444 return jlong(sur.get());
445 }
446
nativeWriteToParcel(JNIEnv * env,jclass clazz,jlong nativeObject,jobject parcelObj)447 static void nativeWriteToParcel(JNIEnv* env, jclass clazz,
448 jlong nativeObject, jobject parcelObj) {
449 Parcel* parcel = parcelForJavaObject(env, parcelObj);
450 if (parcel == NULL) {
451 doThrowNPE(env);
452 return;
453 }
454 sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
455 android::view::Surface surfaceShim;
456 if (self != nullptr) {
457 surfaceShim.graphicBufferProducer = self->getIGraphicBufferProducer();
458 }
459 // Calling code in Surface.java has already written the name of the Surface
460 // to the Parcel
461 surfaceShim.writeToParcel(parcel, /*nameAlreadyWritten*/true);
462 }
463
nativeGetWidth(JNIEnv * env,jclass clazz,jlong nativeObject)464 static jint nativeGetWidth(JNIEnv* env, jclass clazz, jlong nativeObject) {
465 Surface* surface = reinterpret_cast<Surface*>(nativeObject);
466 ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
467 int value = 0;
468 anw->query(anw, NATIVE_WINDOW_WIDTH, &value);
469 return value;
470 }
471
nativeGetHeight(JNIEnv * env,jclass clazz,jlong nativeObject)472 static jint nativeGetHeight(JNIEnv* env, jclass clazz, jlong nativeObject) {
473 Surface* surface = reinterpret_cast<Surface*>(nativeObject);
474 ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
475 int value = 0;
476 anw->query(anw, NATIVE_WINDOW_HEIGHT, &value);
477 return value;
478 }
479
nativeGetNextFrameNumber(JNIEnv * env,jclass clazz,jlong nativeObject)480 static jlong nativeGetNextFrameNumber(JNIEnv *env, jclass clazz, jlong nativeObject) {
481 Surface* surface = reinterpret_cast<Surface*>(nativeObject);
482 return surface->getNextFrameNumber();
483 }
484
nativeSetScalingMode(JNIEnv * env,jclass clazz,jlong nativeObject,jint scalingMode)485 static jint nativeSetScalingMode(JNIEnv *env, jclass clazz, jlong nativeObject, jint scalingMode) {
486 Surface* surface = reinterpret_cast<Surface*>(nativeObject);
487 return surface->setScalingMode(scalingMode);
488 }
489
nativeForceScopedDisconnect(JNIEnv * env,jclass clazz,jlong nativeObject)490 static jint nativeForceScopedDisconnect(JNIEnv *env, jclass clazz, jlong nativeObject) {
491 Surface* surface = reinterpret_cast<Surface*>(nativeObject);
492 return surface->disconnect(-1, IGraphicBufferProducer::DisconnectMode::AllLocal);
493 }
494
495 namespace uirenderer {
496
497 using namespace android::uirenderer::renderthread;
498
499 class ContextFactory : public IContextFactory {
500 public:
createAnimationContext(renderthread::TimeLord & clock)501 virtual AnimationContext* createAnimationContext(renderthread::TimeLord& clock) {
502 return new AnimationContext(clock);
503 }
504 };
505
create(JNIEnv * env,jclass clazz,jlong rootNodePtr,jlong surfacePtr)506 static jlong create(JNIEnv* env, jclass clazz, jlong rootNodePtr, jlong surfacePtr) {
507 RenderNode* rootNode = reinterpret_cast<RenderNode*>(rootNodePtr);
508 sp<Surface> surface(reinterpret_cast<Surface*>(surfacePtr));
509 ContextFactory factory;
510 RenderProxy* proxy = new RenderProxy(false, rootNode, &factory);
511 proxy->loadSystemProperties();
512 proxy->setSwapBehavior(kSwap_discardBuffer);
513 proxy->initialize(surface);
514 // Shadows can't be used via this interface, so just set the light source
515 // to all 0s. (and width & height are unused, TODO remove them)
516 proxy->setup(0, 0, 0, 0, 0);
517 proxy->setLightCenter((Vector3){0, 0, 0});
518 return (jlong) proxy;
519 }
520
setSurface(JNIEnv * env,jclass clazz,jlong rendererPtr,jlong surfacePtr)521 static void setSurface(JNIEnv* env, jclass clazz, jlong rendererPtr, jlong surfacePtr) {
522 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr);
523 sp<Surface> surface(reinterpret_cast<Surface*>(surfacePtr));
524 proxy->updateSurface(surface);
525 }
526
draw(JNIEnv * env,jclass clazz,jlong rendererPtr)527 static void draw(JNIEnv* env, jclass clazz, jlong rendererPtr) {
528 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr);
529 nsecs_t vsync = systemTime(CLOCK_MONOTONIC);
530 UiFrameInfoBuilder(proxy->frameInfo())
531 .setVsync(vsync, vsync)
532 .addFlag(FrameInfoFlags::SurfaceCanvas);
533 proxy->syncAndDrawFrame(nullptr);
534 }
535
destroy(JNIEnv * env,jclass clazz,jlong rendererPtr)536 static void destroy(JNIEnv* env, jclass clazz, jlong rendererPtr) {
537 RenderProxy* proxy = reinterpret_cast<RenderProxy*>(rendererPtr);
538 delete proxy;
539 }
540
541 } // uirenderer
542
543 // ----------------------------------------------------------------------------
544
545 namespace hwui = android::uirenderer;
546
547 static const JNINativeMethod gSurfaceMethods[] = {
548 {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J",
549 (void*)nativeCreateFromSurfaceTexture },
550 {"nativeRelease", "(J)V",
551 (void*)nativeRelease },
552 {"nativeIsValid", "(J)Z",
553 (void*)nativeIsValid },
554 {"nativeIsConsumerRunningBehind", "(J)Z",
555 (void*)nativeIsConsumerRunningBehind },
556 {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J",
557 (void*)nativeLockCanvas },
558 {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V",
559 (void*)nativeUnlockCanvasAndPost },
560 {"nativeAllocateBuffers", "(J)V",
561 (void*)nativeAllocateBuffers },
562 {"nativeCreateFromSurfaceControl", "(J)J",
563 (void*)nativeCreateFromSurfaceControl },
564 {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J",
565 (void*)nativeReadFromParcel },
566 {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V",
567 (void*)nativeWriteToParcel },
568 {"nativeGetWidth", "(J)I", (void*)nativeGetWidth },
569 {"nativeGetHeight", "(J)I", (void*)nativeGetHeight },
570 {"nativeGetNextFrameNumber", "(J)J", (void*)nativeGetNextFrameNumber },
571 {"nativeSetScalingMode", "(JI)I", (void*)nativeSetScalingMode },
572 {"nativeForceScopedDisconnect", "(J)I", (void*)nativeForceScopedDisconnect},
573
574 // HWUI context
575 {"nHwuiCreate", "(JJ)J", (void*) hwui::create },
576 {"nHwuiSetSurface", "(JJ)V", (void*) hwui::setSurface },
577 {"nHwuiDraw", "(J)V", (void*) hwui::draw },
578 {"nHwuiDestroy", "(J)V", (void*) hwui::destroy },
579 };
580
register_android_view_Surface(JNIEnv * env)581 int register_android_view_Surface(JNIEnv* env)
582 {
583 int err = RegisterMethodsOrDie(env, "android/view/Surface",
584 gSurfaceMethods, NELEM(gSurfaceMethods));
585
586 jclass clazz = FindClassOrDie(env, "android/view/Surface");
587 gSurfaceClassInfo.clazz = MakeGlobalRefOrDie(env, clazz);
588 gSurfaceClassInfo.mNativeObject = GetFieldIDOrDie(env,
589 gSurfaceClassInfo.clazz, "mNativeObject", "J");
590 gSurfaceClassInfo.mLock = GetFieldIDOrDie(env,
591 gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;");
592 gSurfaceClassInfo.ctor = GetMethodIDOrDie(env, gSurfaceClassInfo.clazz, "<init>", "(J)V");
593
594 clazz = FindClassOrDie(env, "android/graphics/Rect");
595 gRectClassInfo.left = GetFieldIDOrDie(env, clazz, "left", "I");
596 gRectClassInfo.top = GetFieldIDOrDie(env, clazz, "top", "I");
597 gRectClassInfo.right = GetFieldIDOrDie(env, clazz, "right", "I");
598 gRectClassInfo.bottom = GetFieldIDOrDie(env, clazz, "bottom", "I");
599
600 return err;
601 }
602
603 };
604