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