android_view_Surface.cpp revision ab31d3574997eb3a628e80929e13c4d8d7d9c2cc 
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 "android_os_Parcel.h"
22#include "android_util_Binder.h"
23#include "android/graphics/GraphicsJNI.h"
24#include "android/graphics/Region.h"
25
26#include <binder/IMemory.h>
27
28#include <gui/ISurfaceComposer.h>
29#include <gui/Surface.h>
30#include <gui/SurfaceComposerClient.h>
31#include <gui/GLConsumer.h>
32
33#include <ui/DisplayInfo.h>
34#include <ui/Rect.h>
35#include <ui/Region.h>
36
37#include <EGL/egl.h>
38
39#include <SkCanvas.h>
40#include <SkBitmap.h>
41#include <SkRegion.h>
42#include <SkPixelRef.h>
43
44#include "jni.h"
45#include "JNIHelp.h"
46#include <android_runtime/AndroidRuntime.h>
47#include <android_runtime/android_view_Surface.h>
48#include <android_runtime/android_view_SurfaceSession.h>
49#include <android_runtime/android_graphics_SurfaceTexture.h>
50#include <utils/misc.h>
51#include <utils/Log.h>
52
53#include <ScopedUtfChars.h>
54
55
56// ----------------------------------------------------------------------------
57
58namespace android {
59
60static const char* const OutOfResourcesException =
61    "android/view/Surface$OutOfResourcesException";
62
63static struct {
64    jclass clazz;
65    jfieldID mNativeSurface;
66    jfieldID mNativeSurfaceControl;
67    jfieldID mGenerationId;
68    jfieldID mCanvas;
69    jmethodID ctor;
70} gSurfaceClassInfo;
71
72static struct {
73    jfieldID left;
74    jfieldID top;
75    jfieldID right;
76    jfieldID bottom;
77} gRectClassInfo;
78
79static struct {
80    jfieldID mFinalizer;
81    jfieldID mNativeCanvas;
82    jfieldID mSurfaceFormat;
83} gCanvasClassInfo;
84
85static struct {
86    jfieldID mNativeCanvas;
87} gCanvasFinalizerClassInfo;
88
89static struct {
90    jfieldID width;
91    jfieldID height;
92    jfieldID refreshRate;
93    jfieldID density;
94    jfieldID xDpi;
95    jfieldID yDpi;
96    jfieldID secure;
97} gPhysicalDisplayInfoClassInfo;
98
99
100class ScreenshotPixelRef : public SkPixelRef {
101public:
102    ScreenshotPixelRef(SkColorTable* ctable) {
103        fCTable = ctable;
104        SkSafeRef(ctable);
105        setImmutable();
106    }
107
108    virtual ~ScreenshotPixelRef() {
109        SkSafeUnref(fCTable);
110    }
111
112    status_t update(const sp<IBinder>& display, int width, int height,
113            int minLayer, int maxLayer, bool allLayers) {
114        status_t res = (width > 0 && height > 0)
115                ? (allLayers
116                        ? mScreenshot.update(display, width, height)
117                        : mScreenshot.update(display, width, height, minLayer, maxLayer))
118                : mScreenshot.update(display);
119        if (res != NO_ERROR) {
120            return res;
121        }
122
123        return NO_ERROR;
124    }
125
126    uint32_t getWidth() const {
127        return mScreenshot.getWidth();
128    }
129
130    uint32_t getHeight() const {
131        return mScreenshot.getHeight();
132    }
133
134    uint32_t getStride() const {
135        return mScreenshot.getStride();
136    }
137
138    uint32_t getFormat() const {
139        return mScreenshot.getFormat();
140    }
141
142    SK_DECLARE_UNFLATTENABLE_OBJECT()
143protected:
144    // overrides from SkPixelRef
145    virtual void* onLockPixels(SkColorTable** ct) {
146        *ct = fCTable;
147        return (void*)mScreenshot.getPixels();
148    }
149
150    virtual void onUnlockPixels() {
151    }
152
153private:
154    ScreenshotClient mScreenshot;
155    SkColorTable*    fCTable;
156
157    typedef SkPixelRef INHERITED;
158};
159
160
161// ----------------------------------------------------------------------------
162
163static sp<SurfaceControl> getSurfaceControl(JNIEnv* env, jobject surfaceObj) {
164    return reinterpret_cast<SurfaceControl*>(
165            env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurfaceControl));
166}
167
168static void setSurfaceControl(JNIEnv* env, jobject surfaceObj,
169        const sp<SurfaceControl>& surface) {
170    SurfaceControl* const p = reinterpret_cast<SurfaceControl*>(
171            env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurfaceControl));
172    if (surface.get()) {
173        surface->incStrong(surfaceObj);
174    }
175    if (p) {
176        p->decStrong(surfaceObj);
177    }
178    env->SetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurfaceControl,
179            reinterpret_cast<jint>(surface.get()));
180}
181
182static sp<Surface> getSurface(JNIEnv* env, jobject surfaceObj) {
183    sp<Surface> result(android_view_Surface_getSurface(env, surfaceObj));
184    if (result == NULL) {
185        /*
186         * if this method is called from the WindowManager's process, it means
187         * the client is is not remote, and therefore is allowed to have
188         * a Surface (data), so we create it here.
189         * If we don't have a SurfaceControl, it means we're in a different
190         * process.
191         */
192
193        SurfaceControl* const control = reinterpret_cast<SurfaceControl*>(
194                env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurfaceControl));
195        if (control) {
196            result = control->getSurface();
197            if (result != NULL) {
198                result->incStrong(surfaceObj);
199                env->SetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurface,
200                        reinterpret_cast<jint>(result.get()));
201            }
202        }
203    }
204    return result;
205}
206
207sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) {
208    return getSurface(env, surfaceObj);
209}
210
211bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) {
212    return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz);
213}
214
215sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) {
216    return reinterpret_cast<Surface*>(
217            env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurface));
218}
219
220static void setSurface(JNIEnv* env, jobject surfaceObj, const sp<Surface>& surface) {
221    Surface* const p = reinterpret_cast<Surface*>(
222            env->GetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurface));
223    if (surface.get()) {
224        surface->incStrong(surfaceObj);
225    }
226    if (p) {
227        p->decStrong(surfaceObj);
228    }
229    env->SetIntField(surfaceObj, gSurfaceClassInfo.mNativeSurface,
230            reinterpret_cast<jint>(surface.get()));
231
232    // This test is conservative and it would be better to compare the ISurfaces
233    if (p && p != surface.get()) {
234        jint generationId = env->GetIntField(surfaceObj,
235                gSurfaceClassInfo.mGenerationId);
236        generationId++;
237        env->SetIntField(surfaceObj,
238                gSurfaceClassInfo.mGenerationId, generationId);
239    }
240}
241
242static sp<IGraphicBufferProducer> getISurfaceTexture(JNIEnv* env, jobject surfaceObj) {
243    if (surfaceObj) {
244        sp<Surface> surface(getSurface(env, surfaceObj));
245        if (surface != NULL) {
246            return surface->getSurfaceTexture();
247        }
248    }
249    return NULL;
250}
251
252jobject android_view_Surface_createFromISurfaceTexture(JNIEnv* env,
253        const sp<IGraphicBufferProducer>& bufferProducer) {
254    if (bufferProducer == NULL) {
255        return NULL;
256    }
257
258    sp<Surface> surface(new Surface(bufferProducer));
259    if (surface == NULL) {
260        return NULL;
261    }
262
263    jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz, gSurfaceClassInfo.ctor);
264    if (surfaceObj == NULL) {
265        if (env->ExceptionCheck()) {
266            ALOGE("Could not create instance of Surface from IGraphicBufferProducer.");
267            LOGE_EX(env);
268            env->ExceptionClear();
269        }
270        return NULL;
271    }
272
273    setSurface(env, surfaceObj, surface);
274    return surfaceObj;
275}
276
277
278// ----------------------------------------------------------------------------
279
280static void nativeCreate(JNIEnv* env, jobject surfaceObj, jobject sessionObj,
281        jstring nameStr, jint w, jint h, jint format, jint flags) {
282    ScopedUtfChars name(env, nameStr);
283    sp<SurfaceComposerClient> client(android_view_SurfaceSession_getClient(env, sessionObj));
284
285    sp<SurfaceControl> surface = client->createSurface(
286            String8(name.c_str()), w, h, format, flags);
287    if (surface == NULL) {
288        jniThrowException(env, OutOfResourcesException, NULL);
289        return;
290    }
291
292    setSurfaceControl(env, surfaceObj, surface);
293}
294
295static void nativeCreateFromSurfaceTexture(JNIEnv* env, jobject surfaceObj,
296        jobject surfaceTextureObj) {
297    sp<GLConsumer> st(SurfaceTexture_getSurfaceTexture(env, surfaceTextureObj));
298    if (st == NULL) {
299        jniThrowException(env, "java/lang/IllegalArgumentException",
300                "SurfaceTexture has already been released");
301        return;
302    }
303
304    sp<IGraphicBufferProducer> bq = st->getBufferQueue();
305
306    sp<Surface> surface(new Surface(bq));
307    if (surface == NULL) {
308        jniThrowException(env, OutOfResourcesException, NULL);
309        return;
310    }
311
312    setSurface(env, surfaceObj, surface);
313}
314
315static void nativeRelease(JNIEnv* env, jobject surfaceObj) {
316    setSurfaceControl(env, surfaceObj, NULL);
317    setSurface(env, surfaceObj, NULL);
318}
319
320static void nativeDestroy(JNIEnv* env, jobject surfaceObj) {
321    sp<SurfaceControl> surfaceControl(getSurfaceControl(env, surfaceObj));
322    if (SurfaceControl::isValid(surfaceControl)) {
323        surfaceControl->clear();
324    }
325    setSurfaceControl(env, surfaceObj, NULL);
326    setSurface(env, surfaceObj, NULL);
327}
328
329static jboolean nativeIsValid(JNIEnv* env, jobject surfaceObj) {
330    sp<SurfaceControl> surfaceControl(getSurfaceControl(env, surfaceObj));
331    if (surfaceControl != NULL) {
332        return SurfaceControl::isValid(surfaceControl) ? JNI_TRUE : JNI_FALSE;
333    }
334
335    sp<Surface> surface(getSurface(env, surfaceObj));
336    return Surface::isValid(surface) ? JNI_TRUE : JNI_FALSE;
337}
338
339static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jobject surfaceObj) {
340    sp<Surface> surface(getSurface(env, surfaceObj));
341    if (!Surface::isValid(surface)) {
342        doThrowIAE(env);
343        return JNI_FALSE;
344    }
345
346    int value = 0;
347    ANativeWindow* anw = static_cast<ANativeWindow*>(surface.get());
348    anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value);
349    return value;
350}
351
352static inline SkBitmap::Config convertPixelFormat(PixelFormat format) {
353    /* note: if PIXEL_FORMAT_RGBX_8888 means that all alpha bytes are 0xFF, then
354        we can map to SkBitmap::kARGB_8888_Config, and optionally call
355        bitmap.setIsOpaque(true) on the resulting SkBitmap (as an accelerator)
356    */
357    switch (format) {
358    case PIXEL_FORMAT_RGBX_8888:    return SkBitmap::kARGB_8888_Config;
359    case PIXEL_FORMAT_RGBA_8888:    return SkBitmap::kARGB_8888_Config;
360    case PIXEL_FORMAT_RGBA_4444:    return SkBitmap::kARGB_4444_Config;
361    case PIXEL_FORMAT_RGB_565:      return SkBitmap::kRGB_565_Config;
362    case PIXEL_FORMAT_A_8:          return SkBitmap::kA8_Config;
363    default:                        return SkBitmap::kNo_Config;
364    }
365}
366
367static inline void swapCanvasPtr(JNIEnv* env, jobject canvasObj, SkCanvas* newCanvas) {
368  jobject canvasFinalizerObj = env->GetObjectField(canvasObj, gCanvasClassInfo.mFinalizer);
369  SkCanvas* previousCanvas = reinterpret_cast<SkCanvas*>(
370          env->GetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas));
371  env->SetIntField(canvasObj, gCanvasClassInfo.mNativeCanvas, (int)newCanvas);
372  env->SetIntField(canvasFinalizerObj, gCanvasFinalizerClassInfo.mNativeCanvas, (int)newCanvas);
373  SkSafeUnref(previousCanvas);
374}
375
376static jobject nativeLockCanvas(JNIEnv* env, jobject surfaceObj, jobject dirtyRectObj) {
377    sp<Surface> surface(getSurface(env, surfaceObj));
378    if (!Surface::isValid(surface)) {
379        doThrowIAE(env);
380        return NULL;
381    }
382
383    // get dirty region
384    Region dirtyRegion;
385    if (dirtyRectObj) {
386        Rect dirty;
387        dirty.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left);
388        dirty.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top);
389        dirty.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right);
390        dirty.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);
391        if (!dirty.isEmpty()) {
392            dirtyRegion.set(dirty);
393        }
394    } else {
395        dirtyRegion.set(Rect(0x3FFF, 0x3FFF));
396    }
397
398    Surface::SurfaceInfo info;
399    status_t err = surface->lock(&info, &dirtyRegion);
400    if (err < 0) {
401        const char* const exception = (err == NO_MEMORY) ?
402                OutOfResourcesException :
403                "java/lang/IllegalArgumentException";
404        jniThrowException(env, exception, NULL);
405        return NULL;
406    }
407
408    // Associate a SkCanvas object to this surface
409    jobject canvasObj = env->GetObjectField(surfaceObj, gSurfaceClassInfo.mCanvas);
410    env->SetIntField(canvasObj, gCanvasClassInfo.mSurfaceFormat, info.format);
411
412    SkBitmap bitmap;
413    ssize_t bpr = info.s * bytesPerPixel(info.format);
414    bitmap.setConfig(convertPixelFormat(info.format), info.w, info.h, bpr);
415    if (info.format == PIXEL_FORMAT_RGBX_8888) {
416        bitmap.setIsOpaque(true);
417    }
418    if (info.w > 0 && info.h > 0) {
419        bitmap.setPixels(info.bits);
420    } else {
421        // be safe with an empty bitmap.
422        bitmap.setPixels(NULL);
423    }
424
425    SkCanvas* nativeCanvas = SkNEW_ARGS(SkCanvas, (bitmap));
426    swapCanvasPtr(env, canvasObj, nativeCanvas);
427
428    SkRegion clipReg;
429    if (dirtyRegion.isRect()) { // very common case
430        const Rect b(dirtyRegion.getBounds());
431        clipReg.setRect(b.left, b.top, b.right, b.bottom);
432    } else {
433        size_t count;
434        Rect const* r = dirtyRegion.getArray(&count);
435        while (count) {
436            clipReg.op(r->left, r->top, r->right, r->bottom, SkRegion::kUnion_Op);
437            r++, count--;
438        }
439    }
440
441    nativeCanvas->clipRegion(clipReg);
442
443    if (dirtyRectObj) {
444        const Rect& bounds(dirtyRegion.getBounds());
445        env->SetIntField(dirtyRectObj, gRectClassInfo.left, bounds.left);
446        env->SetIntField(dirtyRectObj, gRectClassInfo.top, bounds.top);
447        env->SetIntField(dirtyRectObj, gRectClassInfo.right, bounds.right);
448        env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, bounds.bottom);
449    }
450
451    return canvasObj;
452}
453
454static void nativeUnlockCanvasAndPost(JNIEnv* env, jobject surfaceObj, jobject canvasObj) {
455    jobject ownCanvasObj = env->GetObjectField(surfaceObj, gSurfaceClassInfo.mCanvas);
456    if (!env->IsSameObject(ownCanvasObj, canvasObj)) {
457        doThrowIAE(env);
458        return;
459    }
460
461    sp<Surface> surface(getSurface(env, surfaceObj));
462    if (!Surface::isValid(surface)) {
463        return;
464    }
465
466    // detach the canvas from the surface
467    SkCanvas* nativeCanvas = SkNEW(SkCanvas);
468    swapCanvasPtr(env, canvasObj, nativeCanvas);
469
470    // unlock surface
471    status_t err = surface->unlockAndPost();
472    if (err < 0) {
473        doThrowIAE(env);
474    }
475}
476
477static jobject nativeScreenshot(JNIEnv* env, jclass clazz, jobject displayTokenObj,
478        jint width, jint height, jint minLayer, jint maxLayer, bool allLayers) {
479    sp<IBinder> displayToken = ibinderForJavaObject(env, displayTokenObj);
480    if (displayToken == NULL) {
481        return NULL;
482    }
483
484    ScreenshotPixelRef* pixels = new ScreenshotPixelRef(NULL);
485    if (pixels->update(displayToken, width, height,
486            minLayer, maxLayer, allLayers) != NO_ERROR) {
487        delete pixels;
488        return NULL;
489    }
490
491    uint32_t w = pixels->getWidth();
492    uint32_t h = pixels->getHeight();
493    uint32_t s = pixels->getStride();
494    uint32_t f = pixels->getFormat();
495    ssize_t bpr = s * android::bytesPerPixel(f);
496
497    SkBitmap* bitmap = new SkBitmap();
498    bitmap->setConfig(convertPixelFormat(f), w, h, bpr);
499    if (f == PIXEL_FORMAT_RGBX_8888) {
500        bitmap->setIsOpaque(true);
501    }
502
503    if (w > 0 && h > 0) {
504        bitmap->setPixelRef(pixels)->unref();
505        bitmap->lockPixels();
506    } else {
507        // be safe with an empty bitmap.
508        delete pixels;
509        bitmap->setPixels(NULL);
510    }
511
512    return GraphicsJNI::createBitmap(env, bitmap, false, NULL);
513}
514
515static void nativeOpenTransaction(JNIEnv* env, jclass clazz) {
516    SurfaceComposerClient::openGlobalTransaction();
517}
518
519static void nativeCloseTransaction(JNIEnv* env, jclass clazz) {
520    SurfaceComposerClient::closeGlobalTransaction();
521}
522
523static void nativeSetAnimationTransaction(JNIEnv* env, jclass clazz) {
524    SurfaceComposerClient::setAnimationTransaction();
525}
526
527static void nativeSetLayer(JNIEnv* env, jobject surfaceObj, jint zorder) {
528    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
529    if (surface == NULL) return;
530
531    status_t err = surface->setLayer(zorder);
532    if (err < 0 && err != NO_INIT) {
533        doThrowIAE(env);
534    }
535}
536
537static void nativeSetPosition(JNIEnv* env, jobject surfaceObj, jfloat x, jfloat y) {
538    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
539    if (surface == NULL) return;
540
541    status_t err = surface->setPosition(x, y);
542    if (err < 0 && err != NO_INIT) {
543        doThrowIAE(env);
544    }
545}
546
547static void nativeSetSize(JNIEnv* env, jobject surfaceObj, jint w, jint h) {
548    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
549    if (surface == NULL) return;
550
551    status_t err = surface->setSize(w, h);
552    if (err < 0 && err != NO_INIT) {
553        doThrowIAE(env);
554    }
555}
556
557static void nativeSetFlags(JNIEnv* env, jobject surfaceObj, jint flags, jint mask) {
558    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
559    if (surface == NULL) return;
560
561    status_t err = surface->setFlags(flags, mask);
562    if (err < 0 && err != NO_INIT) {
563        doThrowIAE(env);
564    }
565}
566
567static void nativeSetTransparentRegionHint(JNIEnv* env, jobject surfaceObj, jobject regionObj) {
568    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
569    if (surface == NULL) return;
570
571    SkRegion* region = android_graphics_Region_getSkRegion(env, regionObj);
572    if (!region) {
573        doThrowIAE(env);
574        return;
575    }
576
577    const SkIRect& b(region->getBounds());
578    Region reg(Rect(b.fLeft, b.fTop, b.fRight, b.fBottom));
579    if (region->isComplex()) {
580        SkRegion::Iterator it(*region);
581        while (!it.done()) {
582            const SkIRect& r(it.rect());
583            reg.addRectUnchecked(r.fLeft, r.fTop, r.fRight, r.fBottom);
584            it.next();
585        }
586    }
587
588    status_t err = surface->setTransparentRegionHint(reg);
589    if (err < 0 && err != NO_INIT) {
590        doThrowIAE(env);
591    }
592}
593
594static void nativeSetAlpha(JNIEnv* env, jobject surfaceObj, jfloat alpha) {
595    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
596    if (surface == NULL) return;
597
598    status_t err = surface->setAlpha(alpha);
599    if (err < 0 && err != NO_INIT) {
600        doThrowIAE(env);
601    }
602}
603
604static void nativeSetMatrix(JNIEnv* env, jobject surfaceObj,
605        jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy) {
606    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
607    if (surface == NULL) return;
608
609    status_t err = surface->setMatrix(dsdx, dtdx, dsdy, dtdy);
610    if (err < 0 && err != NO_INIT) {
611        doThrowIAE(env);
612    }
613}
614
615static void nativeSetWindowCrop(JNIEnv* env, jobject surfaceObj, jobject cropObj) {
616    const sp<SurfaceControl>& surface(getSurfaceControl(env, surfaceObj));
617    if (surface == NULL) return;
618
619    Rect crop;
620    if (cropObj) {
621        crop.left = env->GetIntField(cropObj, gRectClassInfo.left);
622        crop.top = env->GetIntField(cropObj, gRectClassInfo.top);
623        crop.right = env->GetIntField(cropObj, gRectClassInfo.right);
624        crop.bottom = env->GetIntField(cropObj, gRectClassInfo.bottom);
625    } else {
626        crop.left = crop.top = crop.right = crop.bottom = 0;
627    }
628
629    status_t err = surface->setCrop(crop);
630    if (err < 0 && err != NO_INIT) {
631        doThrowIAE(env);
632    }
633}
634
635static void nativeSetLayerStack(JNIEnv* env, jobject surfaceObj, jint layerStack) {
636    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
637    if (surface == NULL) return;
638
639    status_t err = surface->setLayerStack(layerStack);
640    if (err < 0 && err != NO_INIT) {
641        doThrowIAE(env);
642    }
643}
644
645static jobject nativeGetBuiltInDisplay(JNIEnv* env, jclass clazz, jint id) {
646    sp<IBinder> token(SurfaceComposerClient::getBuiltInDisplay(id));
647    return javaObjectForIBinder(env, token);
648}
649
650static jobject nativeCreateDisplay(JNIEnv* env, jclass clazz, jstring nameObj,
651        jboolean secure) {
652    ScopedUtfChars name(env, nameObj);
653    sp<IBinder> token(SurfaceComposerClient::createDisplay(
654            String8(name.c_str()), bool(secure)));
655    return javaObjectForIBinder(env, token);
656}
657
658static void nativeSetDisplaySurface(JNIEnv* env, jclass clazz,
659        jobject tokenObj, jobject surfaceObj) {
660    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
661    if (token == NULL) return;
662
663    sp<IGraphicBufferProducer> bufferProducer(getISurfaceTexture(env, surfaceObj));
664    SurfaceComposerClient::setDisplaySurface(token, bufferProducer);
665}
666
667static void nativeSetDisplayLayerStack(JNIEnv* env, jclass clazz,
668        jobject tokenObj, jint layerStack) {
669    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
670    if (token == NULL) return;
671
672    SurfaceComposerClient::setDisplayLayerStack(token, layerStack);
673}
674
675static void nativeSetDisplayProjection(JNIEnv* env, jclass clazz,
676        jobject tokenObj, jint orientation, jobject layerStackRectObj, jobject displayRectObj) {
677    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
678    if (token == NULL) return;
679
680    Rect layerStackRect;
681    layerStackRect.left = env->GetIntField(layerStackRectObj, gRectClassInfo.left);
682    layerStackRect.top = env->GetIntField(layerStackRectObj, gRectClassInfo.top);
683    layerStackRect.right = env->GetIntField(layerStackRectObj, gRectClassInfo.right);
684    layerStackRect.bottom = env->GetIntField(layerStackRectObj, gRectClassInfo.bottom);
685
686    Rect displayRect;
687    displayRect.left = env->GetIntField(displayRectObj, gRectClassInfo.left);
688    displayRect.top = env->GetIntField(displayRectObj, gRectClassInfo.top);
689    displayRect.right = env->GetIntField(displayRectObj, gRectClassInfo.right);
690    displayRect.bottom = env->GetIntField(displayRectObj, gRectClassInfo.bottom);
691
692    SurfaceComposerClient::setDisplayProjection(token, orientation, layerStackRect, displayRect);
693}
694
695static jboolean nativeGetDisplayInfo(JNIEnv* env, jclass clazz,
696        jobject tokenObj, jobject infoObj) {
697    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
698    if (token == NULL) return JNI_FALSE;
699
700    DisplayInfo info;
701    if (SurfaceComposerClient::getDisplayInfo(token, &info)) {
702        return JNI_FALSE;
703    }
704
705    env->SetIntField(infoObj, gPhysicalDisplayInfoClassInfo.width, info.w);
706    env->SetIntField(infoObj, gPhysicalDisplayInfoClassInfo.height, info.h);
707    env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.refreshRate, info.fps);
708    env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.density, info.density);
709    env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.xDpi, info.xdpi);
710    env->SetFloatField(infoObj, gPhysicalDisplayInfoClassInfo.yDpi, info.ydpi);
711    env->SetBooleanField(infoObj, gPhysicalDisplayInfoClassInfo.secure, info.secure);
712    return JNI_TRUE;
713}
714
715static void nativeBlankDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) {
716    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
717    if (token == NULL) return;
718
719    ALOGD_IF_SLOW(100, "Excessive delay in blankDisplay() while turning screen off");
720    SurfaceComposerClient::blankDisplay(token);
721}
722
723static void nativeUnblankDisplay(JNIEnv* env, jclass clazz, jobject tokenObj) {
724    sp<IBinder> token(ibinderForJavaObject(env, tokenObj));
725    if (token == NULL) return;
726
727    ALOGD_IF_SLOW(100, "Excessive delay in unblankDisplay() while turning screen on");
728    SurfaceComposerClient::unblankDisplay(token);
729}
730
731// ----------------------------------------------------------------------------
732
733static void nativeCopyFrom(JNIEnv* env, jobject surfaceObj, jobject otherObj) {
734    /*
735     * This is used by the WindowManagerService just after constructing
736     * a Surface and is necessary for returning the Surface reference to
737     * the caller. At this point, we should only have a SurfaceControl.
738     */
739
740    sp<SurfaceControl> surface(getSurfaceControl(env, surfaceObj));
741    sp<SurfaceControl> other(getSurfaceControl(env, otherObj));
742    if (!SurfaceControl::isSameSurface(surface, other)) {
743        // we reassign the surface only if it's a different one
744        // otherwise we would loose our client-side state.
745        setSurfaceControl(env, surfaceObj, other);
746    }
747}
748
749static void nativeTransferFrom(JNIEnv* env, jobject surfaceObj, jobject otherObj) {
750    sp<SurfaceControl> control(getSurfaceControl(env, otherObj));
751    sp<Surface> surface(android_view_Surface_getSurface(env, otherObj));
752    setSurfaceControl(env, surfaceObj, control);
753    setSurface(env, surfaceObj, surface);
754    setSurfaceControl(env, otherObj, NULL);
755    setSurface(env, otherObj, NULL);
756}
757
758static void nativeReadFromParcel(JNIEnv* env, jobject surfaceObj, jobject parcelObj) {
759    Parcel* parcel = parcelForJavaObject(env, parcelObj);
760    if (parcel == NULL) {
761        doThrowNPE(env);
762        return;
763    }
764
765    sp<Surface> surface(Surface::readFromParcel(*parcel));
766    setSurfaceControl(env, surfaceObj, NULL);
767    setSurface(env, surfaceObj, surface);
768}
769
770static void nativeWriteToParcel(JNIEnv* env, jobject surfaceObj, jobject parcelObj) {
771    Parcel* parcel = parcelForJavaObject(env, parcelObj);
772    if (parcel == NULL) {
773        doThrowNPE(env);
774        return;
775    }
776
777    // The Java instance may have a SurfaceControl (in the case of the
778    // WindowManager or a system app). In that case, we defer to the
779    // SurfaceControl to send its ISurface. Otherwise, if the Surface is
780    // available we let it parcel itself. Finally, if the Surface is also
781    // NULL we fall back to using the SurfaceControl path which sends an
782    // empty surface; this matches legacy behavior.
783    sp<SurfaceControl> control(getSurfaceControl(env, surfaceObj));
784    if (control != NULL) {
785        SurfaceControl::writeSurfaceToParcel(control, parcel);
786    } else {
787        sp<Surface> surface(android_view_Surface_getSurface(env, surfaceObj));
788        if (surface != NULL) {
789            Surface::writeToParcel(surface, parcel);
790        } else {
791            SurfaceControl::writeSurfaceToParcel(NULL, parcel);
792        }
793    }
794}
795
796// ----------------------------------------------------------------------------
797
798static JNINativeMethod gSurfaceMethods[] = {
799    {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIII)V",
800            (void*)nativeCreate },
801    {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)V",
802            (void*)nativeCreateFromSurfaceTexture },
803    {"nativeRelease", "()V",
804            (void*)nativeRelease },
805    {"nativeDestroy", "()V",
806            (void*)nativeDestroy },
807    {"nativeIsValid", "()Z",
808            (void*)nativeIsValid },
809    {"nativeIsConsumerRunningBehind", "()Z",
810            (void*)nativeIsConsumerRunningBehind },
811    {"nativeLockCanvas", "(Landroid/graphics/Rect;)Landroid/graphics/Canvas;",
812            (void*)nativeLockCanvas },
813    {"nativeUnlockCanvasAndPost", "(Landroid/graphics/Canvas;)V",
814            (void*)nativeUnlockCanvasAndPost },
815    {"nativeScreenshot", "(Landroid/os/IBinder;IIIIZ)Landroid/graphics/Bitmap;",
816            (void*)nativeScreenshot },
817    {"nativeOpenTransaction", "()V",
818            (void*)nativeOpenTransaction },
819    {"nativeCloseTransaction", "()V",
820            (void*)nativeCloseTransaction },
821    {"nativeSetAnimationTransaction", "()V",
822            (void*)nativeSetAnimationTransaction },
823    {"nativeSetLayer", "(I)V",
824            (void*)nativeSetLayer },
825    {"nativeSetPosition", "(FF)V",
826            (void*)nativeSetPosition },
827    {"nativeSetSize", "(II)V",
828            (void*)nativeSetSize },
829    {"nativeSetTransparentRegionHint", "(Landroid/graphics/Region;)V",
830            (void*)nativeSetTransparentRegionHint },
831    {"nativeSetAlpha", "(F)V",
832            (void*)nativeSetAlpha },
833    {"nativeSetMatrix", "(FFFF)V",
834            (void*)nativeSetMatrix },
835    {"nativeSetFlags", "(II)V",
836            (void*)nativeSetFlags },
837    {"nativeSetWindowCrop", "(Landroid/graphics/Rect;)V",
838            (void*)nativeSetWindowCrop },
839    {"nativeSetLayerStack", "(I)V",
840            (void*)nativeSetLayerStack },
841    {"nativeGetBuiltInDisplay", "(I)Landroid/os/IBinder;",
842            (void*)nativeGetBuiltInDisplay },
843    {"nativeCreateDisplay", "(Ljava/lang/String;Z)Landroid/os/IBinder;",
844            (void*)nativeCreateDisplay },
845    {"nativeSetDisplaySurface", "(Landroid/os/IBinder;Landroid/view/Surface;)V",
846            (void*)nativeSetDisplaySurface },
847    {"nativeSetDisplayLayerStack", "(Landroid/os/IBinder;I)V",
848            (void*)nativeSetDisplayLayerStack },
849    {"nativeSetDisplayProjection", "(Landroid/os/IBinder;ILandroid/graphics/Rect;Landroid/graphics/Rect;)V",
850            (void*)nativeSetDisplayProjection },
851    {"nativeGetDisplayInfo", "(Landroid/os/IBinder;Landroid/view/Surface$PhysicalDisplayInfo;)Z",
852            (void*)nativeGetDisplayInfo },
853    {"nativeBlankDisplay", "(Landroid/os/IBinder;)V",
854            (void*)nativeBlankDisplay },
855    {"nativeUnblankDisplay", "(Landroid/os/IBinder;)V",
856            (void*)nativeUnblankDisplay },
857    {"nativeCopyFrom", "(Landroid/view/Surface;)V",
858            (void*)nativeCopyFrom },
859    {"nativeTransferFrom", "(Landroid/view/Surface;)V",
860            (void*)nativeTransferFrom },
861    {"nativeReadFromParcel", "(Landroid/os/Parcel;)V",
862            (void*)nativeReadFromParcel },
863    {"nativeWriteToParcel", "(Landroid/os/Parcel;)V",
864            (void*)nativeWriteToParcel },
865};
866
867int register_android_view_Surface(JNIEnv* env)
868{
869    int err = AndroidRuntime::registerNativeMethods(env, "android/view/Surface",
870            gSurfaceMethods, NELEM(gSurfaceMethods));
871
872    jclass clazz = env->FindClass("android/view/Surface");
873    gSurfaceClassInfo.clazz = jclass(env->NewGlobalRef(clazz));
874    gSurfaceClassInfo.mNativeSurface =
875            env->GetFieldID(gSurfaceClassInfo.clazz, ANDROID_VIEW_SURFACE_JNI_ID, "I");
876    gSurfaceClassInfo.mNativeSurfaceControl =
877            env->GetFieldID(gSurfaceClassInfo.clazz, "mNativeSurfaceControl", "I");
878    gSurfaceClassInfo.mGenerationId =
879            env->GetFieldID(gSurfaceClassInfo.clazz, "mGenerationId", "I");
880    gSurfaceClassInfo.mCanvas =
881            env->GetFieldID(gSurfaceClassInfo.clazz, "mCanvas", "Landroid/graphics/Canvas;");
882    gSurfaceClassInfo.ctor = env->GetMethodID(gSurfaceClassInfo.clazz, "<init>", "()V");
883
884    clazz = env->FindClass("android/graphics/Canvas");
885    gCanvasClassInfo.mFinalizer = env->GetFieldID(clazz, "mFinalizer", "Landroid/graphics/Canvas$CanvasFinalizer;");
886    gCanvasClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I");
887    gCanvasClassInfo.mSurfaceFormat = env->GetFieldID(clazz, "mSurfaceFormat", "I");
888
889    clazz = env->FindClass("android/graphics/Canvas$CanvasFinalizer");
890    gCanvasFinalizerClassInfo.mNativeCanvas = env->GetFieldID(clazz, "mNativeCanvas", "I");
891
892    clazz = env->FindClass("android/graphics/Rect");
893    gRectClassInfo.left = env->GetFieldID(clazz, "left", "I");
894    gRectClassInfo.top = env->GetFieldID(clazz, "top", "I");
895    gRectClassInfo.right = env->GetFieldID(clazz, "right", "I");
896    gRectClassInfo.bottom = env->GetFieldID(clazz, "bottom", "I");
897
898    clazz = env->FindClass("android/view/Surface$PhysicalDisplayInfo");
899    gPhysicalDisplayInfoClassInfo.width = env->GetFieldID(clazz, "width", "I");
900    gPhysicalDisplayInfoClassInfo.height = env->GetFieldID(clazz, "height", "I");
901    gPhysicalDisplayInfoClassInfo.refreshRate = env->GetFieldID(clazz, "refreshRate", "F");
902    gPhysicalDisplayInfoClassInfo.density = env->GetFieldID(clazz, "density", "F");
903    gPhysicalDisplayInfoClassInfo.xDpi = env->GetFieldID(clazz, "xDpi", "F");
904    gPhysicalDisplayInfoClassInfo.yDpi = env->GetFieldID(clazz, "yDpi", "F");
905    gPhysicalDisplayInfoClassInfo.secure = env->GetFieldID(clazz, "secure", "Z");
906    return err;
907}
908
909};
910