core/jni/android_view_Surface.cpp - platform/frameworks/base - Git at Google

 /*
  * Copyright (C) 2007 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #define LOG_TAG "Surface"

 #include <stdio.h>

 #include "jni.h"
 #include <nativehelper/JNIHelp.h>
 #include "core_jni_helpers.h"

 #include <android/graphics/canvas.h>
 #include <android_runtime/android_graphics_GraphicBuffer.h>
 #include <android_runtime/android_graphics_SurfaceTexture.h>
 #include <android_runtime/android_view_Surface.h>
 #include <android_runtime/Log.h>
 #include <private/android/AHardwareBufferHelpers.h>

 #include "android_os_Parcel.h"
 #include <binder/Parcel.h>

 #include <gui/Surface.h>
 #include <gui/view/Surface.h>
 #include <gui/SurfaceControl.h>

 #include <ui/GraphicBuffer.h>
 #include <ui/Rect.h>
 #include <ui/Region.h>

 #include <utils/misc.h>
 #include <utils/Log.h>

 #include <nativehelper/ScopedUtfChars.h>

 // ----------------------------------------------------------------------------

 namespace android {

 static const char* const IllegalArgumentException = "java/lang/IllegalArgumentException";
 static const char* const OutOfResourcesException = "android/view/Surface$OutOfResourcesException";

 static struct {
     jclass clazz;
     jfieldID mNativeObject;
     jfieldID mLock;
     jmethodID ctor;
 } gSurfaceClassInfo;

 static struct {
     jfieldID left;
     jfieldID top;
     jfieldID right;
     jfieldID bottom;
 } gRectClassInfo;

 class JNamedColorSpace {
 public:
     // ColorSpace.Named.SRGB.ordinal() = 0;
     static constexpr jint SRGB = 0;

     // ColorSpace.Named.DISPLAY_P3.ordinal() = 7;
     static constexpr jint DISPLAY_P3 = 7;
 };

 constexpr ui::Dataspace fromNamedColorSpaceValueToDataspace(const jint colorSpace) {
     switch (colorSpace) {
         case JNamedColorSpace::DISPLAY_P3:
             return ui::Dataspace::DISPLAY_P3;
         default:
             return ui::Dataspace::V0_SRGB;
     }
 }

 // ----------------------------------------------------------------------------

 // this is just a pointer we use to pass to inc/decStrong
 static const void *sRefBaseOwner;

 bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) {
     return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz);
 }

 sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) {
     return android_view_Surface_getSurface(env, surfaceObj);
 }

 sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) {
     sp<Surface> sur;
     jobject lock = env->GetObjectField(surfaceObj,
             gSurfaceClassInfo.mLock);
     if (env->MonitorEnter(lock) == JNI_OK) {
         sur = reinterpret_cast<Surface *>(
                 env->GetLongField(surfaceObj, gSurfaceClassInfo.mNativeObject));
         env->MonitorExit(lock);
     }
     env->DeleteLocalRef(lock);
     return sur;
 }

 jobject android_view_Surface_createFromSurface(JNIEnv* env, const sp<Surface>& surface) {
     jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz,
             gSurfaceClassInfo.ctor, (jlong)surface.get());
     if (surfaceObj == NULL) {
         if (env->ExceptionCheck()) {
             ALOGE("Could not create instance of Surface from IGraphicBufferProducer.");
             LOGE_EX(env);
             env->ExceptionClear();
         }
         return NULL;
     }
     surface->incStrong(&sRefBaseOwner);
     return surfaceObj;
 }

 jobject android_view_Surface_createFromIGraphicBufferProducer(JNIEnv* env,
         const sp<IGraphicBufferProducer>& bufferProducer) {
     if (bufferProducer == NULL) {
         return NULL;
     }

     sp<Surface> surface(new Surface(bufferProducer, true));
     return android_view_Surface_createFromSurface(env, surface);
 }

 // ----------------------------------------------------------------------------

 static inline bool isSurfaceValid(const sp<Surface>& sur) {
     return Surface::isValid(sur);
 }

 // ----------------------------------------------------------------------------

 static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,
         jobject surfaceTextureObj) {
     sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj));
     if (producer == NULL) {
         jniThrowException(env, IllegalArgumentException,
                 "SurfaceTexture has already been released");
         return 0;
     }

     sp<Surface> surface(new Surface(producer, true));
     if (surface == NULL) {
         jniThrowException(env, OutOfResourcesException, NULL);
         return 0;
     }

     surface->incStrong(&sRefBaseOwner);
     return jlong(surface.get());
 }

 static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) {
     sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
     sur->decStrong(&sRefBaseOwner);
 }

 static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) {
     sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
     return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE;
 }

 static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) {
     sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
     if (!isSurfaceValid(sur)) {
         jniThrowException(env, IllegalArgumentException, NULL);
         return JNI_FALSE;
     }
     int value = 0;
     ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get());
     anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value);
     return value;
 }

 static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
         jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
     sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

     if (!isSurfaceValid(surface)) {
         jniThrowException(env, IllegalArgumentException, NULL);
         return 0;
     }

     if (!ACanvas_isSupportedPixelFormat(ANativeWindow_getFormat(surface.get()))) {
         native_window_set_buffers_format(surface.get(), PIXEL_FORMAT_RGBA_8888);
     }

     Rect dirtyRect(Rect::EMPTY_RECT);
     Rect* dirtyRectPtr = NULL;

     if (dirtyRectObj) {
         dirtyRect.left   = env->GetIntField(dirtyRectObj, gRectClassInfo.left);
         dirtyRect.top    = env->GetIntField(dirtyRectObj, gRectClassInfo.top);
         dirtyRect.right  = env->GetIntField(dirtyRectObj, gRectClassInfo.right);
         dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);
         dirtyRectPtr = &dirtyRect;
     }

     ANativeWindow_Buffer buffer;
     status_t err = surface->lock(&buffer, dirtyRectPtr);
     if (err < 0) {
         const char* const exception = (err == NO_MEMORY) ?
                 OutOfResourcesException : IllegalArgumentException;
         jniThrowException(env, exception, NULL);
         return 0;
     }

     graphics::Canvas canvas(env, canvasObj);
     canvas.setBuffer(&buffer, static_cast<int32_t>(surface->getBuffersDataSpace()));

     if (dirtyRectPtr) {
         canvas.clipRect({dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom});
     }

     if (dirtyRectObj) {
         env->SetIntField(dirtyRectObj, gRectClassInfo.left,   dirtyRect.left);
         env->SetIntField(dirtyRectObj, gRectClassInfo.top,    dirtyRect.top);
         env->SetIntField(dirtyRectObj, gRectClassInfo.right,  dirtyRect.right);
         env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom);
     }

     // Create another reference to the surface and return it.  This reference
     // should be passed to nativeUnlockCanvasAndPost in place of mNativeObject,
     // because the latter could be replaced while the surface is locked.
     sp<Surface> lockedSurface(surface);
     lockedSurface->incStrong(&sRefBaseOwner);
     return (jlong) lockedSurface.get();
 }

 static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
         jlong nativeObject, jobject canvasObj) {
     sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
     if (!isSurfaceValid(surface)) {
         return;
     }

     // detach the canvas from the surface
     graphics::Canvas canvas(env, canvasObj);
     canvas.setBuffer(nullptr, ADATASPACE_UNKNOWN);

     // unlock surface
     status_t err = surface->unlockAndPost();
     if (err < 0) {
         jniThrowException(env, IllegalArgumentException, NULL);
     }
 }

 static void nativeAllocateBuffers(JNIEnv* /* env */ , jclass /* clazz */,
         jlong nativeObject) {
     sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
     if (!isSurfaceValid(surface)) {
         return;
     }

     surface->allocateBuffers();
 }

 // ----------------------------------------------------------------------------

 static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,
         jlong surfaceControlNativeObj) {
     sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));
     sp<Surface> surface(ctrl->createSurface());
     if (surface != NULL) {
         surface->incStrong(&sRefBaseOwner);
     }
     return reinterpret_cast<jlong>(surface.get());
 }

 static jlong nativeGetFromSurfaceControl(JNIEnv* env, jclass clazz,
         jlong nativeObject,
         jlong surfaceControlNativeObj) {
     Surface* self(reinterpret_cast<Surface *>(nativeObject));
     sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));

     // If the underlying IGBP's are the same, we don't need to do anything.
     if (self != nullptr &&
             IInterface::asBinder(self->getIGraphicBufferProducer()) ==
             IInterface::asBinder(ctrl->getIGraphicBufferProducer())) {
         return nativeObject;
     }

     sp<Surface> surface(ctrl->getSurface());
     if (surface != NULL) {
         surface->incStrong(&sRefBaseOwner);
     }

     return reinterpret_cast<jlong>(surface.get());
 }

 static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz,
         jlong nativeObject, jobject parcelObj) {
     Parcel* parcel = parcelForJavaObject(env, parcelObj);
     if (parcel == NULL) {
         jniThrowNullPointerException(env, NULL);
         return 0;
     }

     android::view::Surface surfaceShim;

     // Calling code in Surface.java has already read the name of the Surface
     // from the Parcel
     surfaceShim.readFromParcel(parcel, /*nameAlreadyRead*/true);

     sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));

     // update the Surface only if the underlying IGraphicBufferProducer
     // has changed.
     if (self != nullptr
             && (IInterface::asBinder(self->getIGraphicBufferProducer()) ==
                     IInterface::asBinder(surfaceShim.graphicBufferProducer))) {
         // same IGraphicBufferProducer, return ourselves
         return jlong(self.get());
     }

     sp<Surface> sur;
     if (surfaceShim.graphicBufferProducer != nullptr) {
         // we have a new IGraphicBufferProducer, create a new Surface for it
         sur = new Surface(surfaceShim.graphicBufferProducer, true);
         // and keep a reference before passing to java
         sur->incStrong(&sRefBaseOwner);
     }

     if (self != NULL) {
         // and loose the java reference to ourselves
         self->decStrong(&sRefBaseOwner);
     }

     return jlong(sur.get());
 }

 static void nativeWriteToParcel(JNIEnv* env, jclass clazz,
         jlong nativeObject, jobject parcelObj) {
     Parcel* parcel = parcelForJavaObject(env, parcelObj);
     if (parcel == NULL) {
         jniThrowNullPointerException(env, NULL);
         return;
     }
     sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
     android::view::Surface surfaceShim;
     if (self != nullptr) {
         surfaceShim.graphicBufferProducer = self->getIGraphicBufferProducer();
     }
     // Calling code in Surface.java has already written the name of the Surface
     // to the Parcel
     surfaceShim.writeToParcel(parcel, /*nameAlreadyWritten*/true);
 }

 static jint nativeGetWidth(JNIEnv* env, jclass clazz, jlong nativeObject) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
     int value = 0;
     anw->query(anw, NATIVE_WINDOW_WIDTH, &value);
     return value;
 }

 static jint nativeGetHeight(JNIEnv* env, jclass clazz, jlong nativeObject) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
     int value = 0;
     anw->query(anw, NATIVE_WINDOW_HEIGHT, &value);
     return value;
 }

 static jlong nativeGetNextFrameNumber(JNIEnv *env, jclass clazz, jlong nativeObject) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     return surface->getNextFrameNumber();
 }

 static jint nativeSetScalingMode(JNIEnv *env, jclass clazz, jlong nativeObject, jint scalingMode) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     return surface->setScalingMode(scalingMode);
 }

 static jint nativeForceScopedDisconnect(JNIEnv *env, jclass clazz, jlong nativeObject) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     return surface->disconnect(-1, IGraphicBufferProducer::DisconnectMode::AllLocal);
 }

 static jint nativeAttachAndQueueBufferWithColorSpace(JNIEnv *env, jclass clazz, jlong nativeObject,
         jobject graphicBuffer, jint colorSpaceId) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     sp<GraphicBuffer> gb(android_graphics_GraphicBuffer_getNativeGraphicsBuffer(env,
                                                                                 graphicBuffer));
     int err = Surface::attachAndQueueBufferWithDataspace(surface, gb,
             fromNamedColorSpaceValueToDataspace(colorSpaceId));
     return err;
 }

 static jint nativeSetSharedBufferModeEnabled(JNIEnv* env, jclass clazz, jlong nativeObject,
         jboolean enabled) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
     return anw->perform(surface, NATIVE_WINDOW_SET_SHARED_BUFFER_MODE, int(enabled));
 }

 static jint nativeSetAutoRefreshEnabled(JNIEnv* env, jclass clazz, jlong nativeObject,
         jboolean enabled) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
     return anw->perform(surface, NATIVE_WINDOW_SET_AUTO_REFRESH, int(enabled));
 }

 static jint nativeSetFrameRate(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat frameRate,
                                jint compatibility) {
     Surface* surface = reinterpret_cast<Surface*>(nativeObject);
     ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
     // Our compatibility is a Surface.FRAME_RATE_COMPATIBILITY_* value, and
     // NATIVE_WINDOW_SET_FRAME_RATE takes an
     // ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* value. The values are identical
     // though, so no need to explicitly convert.
     return anw->perform(surface, NATIVE_WINDOW_SET_FRAME_RATE, float(frameRate), compatibility);
 }

 // ----------------------------------------------------------------------------

 static const JNINativeMethod gSurfaceMethods[] = {
     {"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J",
             (void*)nativeCreateFromSurfaceTexture },
     {"nativeRelease", "(J)V",
             (void*)nativeRelease },
     {"nativeIsValid", "(J)Z",
             (void*)nativeIsValid },
     {"nativeIsConsumerRunningBehind", "(J)Z",
             (void*)nativeIsConsumerRunningBehind },
     {"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J",
             (void*)nativeLockCanvas },
     {"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V",
             (void*)nativeUnlockCanvasAndPost },
     {"nativeAllocateBuffers", "(J)V",
             (void*)nativeAllocateBuffers },
     {"nativeCreateFromSurfaceControl", "(J)J",
             (void*)nativeCreateFromSurfaceControl },
     {"nativeGetFromSurfaceControl", "(JJ)J",
             (void*)nativeGetFromSurfaceControl },
     {"nativeReadFromParcel", "(JLandroid/os/Parcel;)J",
             (void*)nativeReadFromParcel },
     {"nativeWriteToParcel", "(JLandroid/os/Parcel;)V",
             (void*)nativeWriteToParcel },
     {"nativeGetWidth", "(J)I", (void*)nativeGetWidth },
     {"nativeGetHeight", "(J)I", (void*)nativeGetHeight },
     {"nativeGetNextFrameNumber", "(J)J", (void*)nativeGetNextFrameNumber },
     {"nativeSetScalingMode", "(JI)I", (void*)nativeSetScalingMode },
     {"nativeForceScopedDisconnect", "(J)I", (void*)nativeForceScopedDisconnect},
     {"nativeAttachAndQueueBufferWithColorSpace", "(JLandroid/graphics/GraphicBuffer;I)I",
             (void*)nativeAttachAndQueueBufferWithColorSpace},
     {"nativeSetSharedBufferModeEnabled", "(JZ)I", (void*)nativeSetSharedBufferModeEnabled},
     {"nativeSetAutoRefreshEnabled", "(JZ)I", (void*)nativeSetAutoRefreshEnabled},
     {"nativeSetFrameRate", "(JFI)I", (void*)nativeSetFrameRate},
 };

 int register_android_view_Surface(JNIEnv* env)
 {
     int err = RegisterMethodsOrDie(env, "android/view/Surface",
             gSurfaceMethods, NELEM(gSurfaceMethods));

     jclass clazz = FindClassOrDie(env, "android/view/Surface");
     gSurfaceClassInfo.clazz = MakeGlobalRefOrDie(env, clazz);
     gSurfaceClassInfo.mNativeObject = GetFieldIDOrDie(env,
             gSurfaceClassInfo.clazz, "mNativeObject", "J");
     gSurfaceClassInfo.mLock = GetFieldIDOrDie(env,
             gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;");
     gSurfaceClassInfo.ctor = GetMethodIDOrDie(env, gSurfaceClassInfo.clazz, "<init>", "(J)V");

     clazz = FindClassOrDie(env, "android/graphics/Rect");
     gRectClassInfo.left = GetFieldIDOrDie(env, clazz, "left", "I");
     gRectClassInfo.top = GetFieldIDOrDie(env, clazz, "top", "I");
     gRectClassInfo.right = GetFieldIDOrDie(env, clazz, "right", "I");
     gRectClassInfo.bottom = GetFieldIDOrDie(env, clazz, "bottom", "I");

     return err;
 }

 };
	/*
	* Copyright (C) 2007 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#define LOG_TAG "Surface"

	#include <stdio.h>

	#include "jni.h"
	#include <nativehelper/JNIHelp.h>
	#include "core_jni_helpers.h"

	#include <android/graphics/canvas.h>
	#include <android_runtime/android_graphics_GraphicBuffer.h>
	#include <android_runtime/android_graphics_SurfaceTexture.h>
	#include <android_runtime/android_view_Surface.h>
	#include <android_runtime/Log.h>
	#include <private/android/AHardwareBufferHelpers.h>

	#include "android_os_Parcel.h"
	#include <binder/Parcel.h>

	#include <gui/Surface.h>
	#include <gui/view/Surface.h>
	#include <gui/SurfaceControl.h>

	#include <ui/GraphicBuffer.h>
	#include <ui/Rect.h>
	#include <ui/Region.h>

	#include <utils/misc.h>
	#include <utils/Log.h>

	#include <nativehelper/ScopedUtfChars.h>

	// ----------------------------------------------------------------------------

	namespace android {

	static const char* const IllegalArgumentException = "java/lang/IllegalArgumentException";
	static const char* const OutOfResourcesException = "android/view/Surface$OutOfResourcesException";

	static struct {
	jclass clazz;
	jfieldID mNativeObject;
	jfieldID mLock;
	jmethodID ctor;
	} gSurfaceClassInfo;

	static struct {
	jfieldID left;
	jfieldID top;
	jfieldID right;
	jfieldID bottom;
	} gRectClassInfo;

	class JNamedColorSpace {
	public:
	// ColorSpace.Named.SRGB.ordinal() = 0;
	static constexpr jint SRGB = 0;

	// ColorSpace.Named.DISPLAY_P3.ordinal() = 7;
	static constexpr jint DISPLAY_P3 = 7;
	};

	constexpr ui::Dataspace fromNamedColorSpaceValueToDataspace(const jint colorSpace) {
	switch (colorSpace) {
	case JNamedColorSpace::DISPLAY_P3:
	return ui::Dataspace::DISPLAY_P3;
	default:
	return ui::Dataspace::V0_SRGB;
	}
	}

	// ----------------------------------------------------------------------------

	// this is just a pointer we use to pass to inc/decStrong
	static const void *sRefBaseOwner;

	bool android_view_Surface_isInstanceOf(JNIEnv* env, jobject obj) {
	return env->IsInstanceOf(obj, gSurfaceClassInfo.clazz);
	}

	sp<ANativeWindow> android_view_Surface_getNativeWindow(JNIEnv* env, jobject surfaceObj) {
	return android_view_Surface_getSurface(env, surfaceObj);
	}

	sp<Surface> android_view_Surface_getSurface(JNIEnv* env, jobject surfaceObj) {
	sp<Surface> sur;
	jobject lock = env->GetObjectField(surfaceObj,
	gSurfaceClassInfo.mLock);
	if (env->MonitorEnter(lock) == JNI_OK) {
	sur = reinterpret_cast<Surface *>(
	env->GetLongField(surfaceObj, gSurfaceClassInfo.mNativeObject));
	env->MonitorExit(lock);
	}
	env->DeleteLocalRef(lock);
	return sur;
	}

	jobject android_view_Surface_createFromSurface(JNIEnv* env, const sp<Surface>& surface) {
	jobject surfaceObj = env->NewObject(gSurfaceClassInfo.clazz,
	gSurfaceClassInfo.ctor, (jlong)surface.get());
	if (surfaceObj == NULL) {
	if (env->ExceptionCheck()) {
	ALOGE("Could not create instance of Surface from IGraphicBufferProducer.");
	LOGE_EX(env);
	env->ExceptionClear();
	}
	return NULL;
	}
	surface->incStrong(&sRefBaseOwner);
	return surfaceObj;
	}

	jobject android_view_Surface_createFromIGraphicBufferProducer(JNIEnv* env,
	const sp<IGraphicBufferProducer>& bufferProducer) {
	if (bufferProducer == NULL) {
	return NULL;
	}

	sp<Surface> surface(new Surface(bufferProducer, true));
	return android_view_Surface_createFromSurface(env, surface);
	}

	// ----------------------------------------------------------------------------

	static inline bool isSurfaceValid(const sp<Surface>& sur) {
	return Surface::isValid(sur);
	}

	// ----------------------------------------------------------------------------

	static jlong nativeCreateFromSurfaceTexture(JNIEnv* env, jclass clazz,
	jobject surfaceTextureObj) {
	sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, surfaceTextureObj));
	if (producer == NULL) {
	jniThrowException(env, IllegalArgumentException,
	"SurfaceTexture has already been released");
	return 0;
	}

	sp<Surface> surface(new Surface(producer, true));
	if (surface == NULL) {
	jniThrowException(env, OutOfResourcesException, NULL);
	return 0;
	}

	surface->incStrong(&sRefBaseOwner);
	return jlong(surface.get());
	}

	static void nativeRelease(JNIEnv* env, jclass clazz, jlong nativeObject) {
	sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
	sur->decStrong(&sRefBaseOwner);
	}

	static jboolean nativeIsValid(JNIEnv* env, jclass clazz, jlong nativeObject) {
	sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
	return isSurfaceValid(sur) ? JNI_TRUE : JNI_FALSE;
	}

	static jboolean nativeIsConsumerRunningBehind(JNIEnv* env, jclass clazz, jlong nativeObject) {
	sp<Surface> sur(reinterpret_cast<Surface *>(nativeObject));
	if (!isSurfaceValid(sur)) {
	jniThrowException(env, IllegalArgumentException, NULL);
	return JNI_FALSE;
	}
	int value = 0;
	ANativeWindow* anw = static_cast<ANativeWindow*>(sur.get());
	anw->query(anw, NATIVE_WINDOW_CONSUMER_RUNNING_BEHIND, &value);
	return value;
	}

	static jlong nativeLockCanvas(JNIEnv* env, jclass clazz,
	jlong nativeObject, jobject canvasObj, jobject dirtyRectObj) {
	sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));

	if (!isSurfaceValid(surface)) {
	jniThrowException(env, IllegalArgumentException, NULL);
	return 0;
	}

	if (!ACanvas_isSupportedPixelFormat(ANativeWindow_getFormat(surface.get()))) {
	native_window_set_buffers_format(surface.get(), PIXEL_FORMAT_RGBA_8888);
	}

	Rect dirtyRect(Rect::EMPTY_RECT);
	Rect* dirtyRectPtr = NULL;

	if (dirtyRectObj) {
	dirtyRect.left = env->GetIntField(dirtyRectObj, gRectClassInfo.left);
	dirtyRect.top = env->GetIntField(dirtyRectObj, gRectClassInfo.top);
	dirtyRect.right = env->GetIntField(dirtyRectObj, gRectClassInfo.right);
	dirtyRect.bottom = env->GetIntField(dirtyRectObj, gRectClassInfo.bottom);
	dirtyRectPtr = &dirtyRect;
	}

	ANativeWindow_Buffer buffer;
	status_t err = surface->lock(&buffer, dirtyRectPtr);
	if (err < 0) {
	const char* const exception = (err == NO_MEMORY) ?
	OutOfResourcesException : IllegalArgumentException;
	jniThrowException(env, exception, NULL);
	return 0;
	}

	graphics::Canvas canvas(env, canvasObj);
	canvas.setBuffer(&buffer, static_cast<int32_t>(surface->getBuffersDataSpace()));

	if (dirtyRectPtr) {
	canvas.clipRect({dirtyRect.left, dirtyRect.top, dirtyRect.right, dirtyRect.bottom});
	}

	if (dirtyRectObj) {
	env->SetIntField(dirtyRectObj, gRectClassInfo.left, dirtyRect.left);
	env->SetIntField(dirtyRectObj, gRectClassInfo.top, dirtyRect.top);
	env->SetIntField(dirtyRectObj, gRectClassInfo.right, dirtyRect.right);
	env->SetIntField(dirtyRectObj, gRectClassInfo.bottom, dirtyRect.bottom);
	}

	// Create another reference to the surface and return it. This reference
	// should be passed to nativeUnlockCanvasAndPost in place of mNativeObject,
	// because the latter could be replaced while the surface is locked.
	sp<Surface> lockedSurface(surface);
	lockedSurface->incStrong(&sRefBaseOwner);
	return (jlong) lockedSurface.get();
	}

	static void nativeUnlockCanvasAndPost(JNIEnv* env, jclass clazz,
	jlong nativeObject, jobject canvasObj) {
	sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
	if (!isSurfaceValid(surface)) {
	return;
	}

	// detach the canvas from the surface
	graphics::Canvas canvas(env, canvasObj);
	canvas.setBuffer(nullptr, ADATASPACE_UNKNOWN);

	// unlock surface
	status_t err = surface->unlockAndPost();
	if (err < 0) {
	jniThrowException(env, IllegalArgumentException, NULL);
	}
	}

	static void nativeAllocateBuffers(JNIEnv* /* env / , jclass / clazz */,
	jlong nativeObject) {
	sp<Surface> surface(reinterpret_cast<Surface *>(nativeObject));
	if (!isSurfaceValid(surface)) {
	return;
	}

	surface->allocateBuffers();
	}

	// ----------------------------------------------------------------------------

	static jlong nativeCreateFromSurfaceControl(JNIEnv* env, jclass clazz,
	jlong surfaceControlNativeObj) {
	sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));
	sp<Surface> surface(ctrl->createSurface());
	if (surface != NULL) {
	surface->incStrong(&sRefBaseOwner);
	}
	return reinterpret_cast<jlong>(surface.get());
	}

	static jlong nativeGetFromSurfaceControl(JNIEnv* env, jclass clazz,
	jlong nativeObject,
	jlong surfaceControlNativeObj) {
	Surface* self(reinterpret_cast<Surface *>(nativeObject));
	sp<SurfaceControl> ctrl(reinterpret_cast<SurfaceControl *>(surfaceControlNativeObj));

	// If the underlying IGBP's are the same, we don't need to do anything.
	if (self != nullptr &&
	IInterface::asBinder(self->getIGraphicBufferProducer()) ==
	IInterface::asBinder(ctrl->getIGraphicBufferProducer())) {
	return nativeObject;
	}

	sp<Surface> surface(ctrl->getSurface());
	if (surface != NULL) {
	surface->incStrong(&sRefBaseOwner);
	}

	return reinterpret_cast<jlong>(surface.get());
	}

	static jlong nativeReadFromParcel(JNIEnv* env, jclass clazz,
	jlong nativeObject, jobject parcelObj) {
	Parcel* parcel = parcelForJavaObject(env, parcelObj);
	if (parcel == NULL) {
	jniThrowNullPointerException(env, NULL);
	return 0;
	}

	android::view::Surface surfaceShim;

	// Calling code in Surface.java has already read the name of the Surface
	// from the Parcel
	surfaceShim.readFromParcel(parcel, /nameAlreadyRead/true);

	sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));

	// update the Surface only if the underlying IGraphicBufferProducer
	// has changed.
	if (self != nullptr
	&& (IInterface::asBinder(self->getIGraphicBufferProducer()) ==
	IInterface::asBinder(surfaceShim.graphicBufferProducer))) {
	// same IGraphicBufferProducer, return ourselves
	return jlong(self.get());
	}

	sp<Surface> sur;
	if (surfaceShim.graphicBufferProducer != nullptr) {
	// we have a new IGraphicBufferProducer, create a new Surface for it
	sur = new Surface(surfaceShim.graphicBufferProducer, true);
	// and keep a reference before passing to java
	sur->incStrong(&sRefBaseOwner);
	}

	if (self != NULL) {
	// and loose the java reference to ourselves
	self->decStrong(&sRefBaseOwner);
	}

	return jlong(sur.get());
	}

	static void nativeWriteToParcel(JNIEnv* env, jclass clazz,
	jlong nativeObject, jobject parcelObj) {
	Parcel* parcel = parcelForJavaObject(env, parcelObj);
	if (parcel == NULL) {
	jniThrowNullPointerException(env, NULL);
	return;
	}
	sp<Surface> self(reinterpret_cast<Surface *>(nativeObject));
	android::view::Surface surfaceShim;
	if (self != nullptr) {
	surfaceShim.graphicBufferProducer = self->getIGraphicBufferProducer();
	}
	// Calling code in Surface.java has already written the name of the Surface
	// to the Parcel
	surfaceShim.writeToParcel(parcel, /nameAlreadyWritten/true);
	}

	static jint nativeGetWidth(JNIEnv* env, jclass clazz, jlong nativeObject) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
	int value = 0;
	anw->query(anw, NATIVE_WINDOW_WIDTH, &value);
	return value;
	}

	static jint nativeGetHeight(JNIEnv* env, jclass clazz, jlong nativeObject) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
	int value = 0;
	anw->query(anw, NATIVE_WINDOW_HEIGHT, &value);
	return value;
	}

	static jlong nativeGetNextFrameNumber(JNIEnv *env, jclass clazz, jlong nativeObject) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	return surface->getNextFrameNumber();
	}

	static jint nativeSetScalingMode(JNIEnv *env, jclass clazz, jlong nativeObject, jint scalingMode) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	return surface->setScalingMode(scalingMode);
	}

	static jint nativeForceScopedDisconnect(JNIEnv *env, jclass clazz, jlong nativeObject) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	return surface->disconnect(-1, IGraphicBufferProducer::DisconnectMode::AllLocal);
	}

	static jint nativeAttachAndQueueBufferWithColorSpace(JNIEnv *env, jclass clazz, jlong nativeObject,
	jobject graphicBuffer, jint colorSpaceId) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	sp<GraphicBuffer> gb(android_graphics_GraphicBuffer_getNativeGraphicsBuffer(env,
	graphicBuffer));
	int err = Surface::attachAndQueueBufferWithDataspace(surface, gb,
	fromNamedColorSpaceValueToDataspace(colorSpaceId));
	return err;
	}

	static jint nativeSetSharedBufferModeEnabled(JNIEnv* env, jclass clazz, jlong nativeObject,
	jboolean enabled) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
	return anw->perform(surface, NATIVE_WINDOW_SET_SHARED_BUFFER_MODE, int(enabled));
	}

	static jint nativeSetAutoRefreshEnabled(JNIEnv* env, jclass clazz, jlong nativeObject,
	jboolean enabled) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
	return anw->perform(surface, NATIVE_WINDOW_SET_AUTO_REFRESH, int(enabled));
	}

	static jint nativeSetFrameRate(JNIEnv* env, jclass clazz, jlong nativeObject, jfloat frameRate,
	jint compatibility) {
	Surface* surface = reinterpret_cast<Surface*>(nativeObject);
	ANativeWindow* anw = static_cast<ANativeWindow*>(surface);
	// Our compatibility is a Surface.FRAME_RATE_COMPATIBILITY_* value, and
	// NATIVE_WINDOW_SET_FRAME_RATE takes an
	// ANATIVEWINDOW_FRAME_RATE_COMPATIBILITY_* value. The values are identical
	// though, so no need to explicitly convert.
	return anw->perform(surface, NATIVE_WINDOW_SET_FRAME_RATE, float(frameRate), compatibility);
	}

	// ----------------------------------------------------------------------------

	static const JNINativeMethod gSurfaceMethods[] = {
	{"nativeCreateFromSurfaceTexture", "(Landroid/graphics/SurfaceTexture;)J",
	(void*)nativeCreateFromSurfaceTexture },
	{"nativeRelease", "(J)V",
	(void*)nativeRelease },
	{"nativeIsValid", "(J)Z",
	(void*)nativeIsValid },
	{"nativeIsConsumerRunningBehind", "(J)Z",
	(void*)nativeIsConsumerRunningBehind },
	{"nativeLockCanvas", "(JLandroid/graphics/Canvas;Landroid/graphics/Rect;)J",
	(void*)nativeLockCanvas },
	{"nativeUnlockCanvasAndPost", "(JLandroid/graphics/Canvas;)V",
	(void*)nativeUnlockCanvasAndPost },
	{"nativeAllocateBuffers", "(J)V",
	(void*)nativeAllocateBuffers },
	{"nativeCreateFromSurfaceControl", "(J)J",
	(void*)nativeCreateFromSurfaceControl },
	{"nativeGetFromSurfaceControl", "(JJ)J",
	(void*)nativeGetFromSurfaceControl },
	{"nativeReadFromParcel", "(JLandroid/os/Parcel;)J",
	(void*)nativeReadFromParcel },
	{"nativeWriteToParcel", "(JLandroid/os/Parcel;)V",
	(void*)nativeWriteToParcel },
	{"nativeGetWidth", "(J)I", (void*)nativeGetWidth },
	{"nativeGetHeight", "(J)I", (void*)nativeGetHeight },
	{"nativeGetNextFrameNumber", "(J)J", (void*)nativeGetNextFrameNumber },
	{"nativeSetScalingMode", "(JI)I", (void*)nativeSetScalingMode },
	{"nativeForceScopedDisconnect", "(J)I", (void*)nativeForceScopedDisconnect},
	{"nativeAttachAndQueueBufferWithColorSpace", "(JLandroid/graphics/GraphicBuffer;I)I",
	(void*)nativeAttachAndQueueBufferWithColorSpace},
	{"nativeSetSharedBufferModeEnabled", "(JZ)I", (void*)nativeSetSharedBufferModeEnabled},
	{"nativeSetAutoRefreshEnabled", "(JZ)I", (void*)nativeSetAutoRefreshEnabled},
	{"nativeSetFrameRate", "(JFI)I", (void*)nativeSetFrameRate},
	};

	int register_android_view_Surface(JNIEnv* env)
	{
	int err = RegisterMethodsOrDie(env, "android/view/Surface",
	gSurfaceMethods, NELEM(gSurfaceMethods));

	jclass clazz = FindClassOrDie(env, "android/view/Surface");
	gSurfaceClassInfo.clazz = MakeGlobalRefOrDie(env, clazz);
	gSurfaceClassInfo.mNativeObject = GetFieldIDOrDie(env,
	gSurfaceClassInfo.clazz, "mNativeObject", "J");
	gSurfaceClassInfo.mLock = GetFieldIDOrDie(env,
	gSurfaceClassInfo.clazz, "mLock", "Ljava/lang/Object;");
	gSurfaceClassInfo.ctor = GetMethodIDOrDie(env, gSurfaceClassInfo.clazz, "<init>", "(J)V");

	clazz = FindClassOrDie(env, "android/graphics/Rect");
	gRectClassInfo.left = GetFieldIDOrDie(env, clazz, "left", "I");
	gRectClassInfo.top = GetFieldIDOrDie(env, clazz, "top", "I");
	gRectClassInfo.right = GetFieldIDOrDie(env, clazz, "right", "I");
	gRectClassInfo.bottom = GetFieldIDOrDie(env, clazz, "bottom", "I");

	return err;
	}

	};