Merge "global ref HardwareBufferRenderer's jclass" into udc-dev am: 2c6640b608 (bf30bbec) · Commits · e / os / android_frameworks_base

libs/hwui/jni/GraphicsJNI.h

+17 −3

Original line number	Original line	Diff line number	Diff line
	@@ -46,10 +46,16 @@ public:

	static void setJavaVM(JavaVM* javaVM);		static void setJavaVM(JavaVM* javaVM);

	/** returns a pointer to the JavaVM provided when we initialized the module */		/**
			* returns a pointer to the JavaVM provided when we initialized the module
			* DEPRECATED: Objects should know the JavaVM that created them
			*/
	static JavaVM* getJavaVM() { return mJavaVM; }		static JavaVM* getJavaVM() { return mJavaVM; }

	/** return a pointer to the JNIEnv for this thread */		/**
			* return a pointer to the JNIEnv for this thread
			* DEPRECATED: Objects should know the JavaVM that created them
			*/
	static JNIEnv* getJNIEnv();		static JNIEnv* getJNIEnv();

	/** create a JNIEnv* for this thread or assert if one already exists */		/** create a JNIEnv* for this thread or assert if one already exists */
	@@ -337,13 +343,21 @@ public:
	JGlobalRefHolder(JavaVM* vm, jobject object) : mVm(vm), mObject(object) {}		JGlobalRefHolder(JavaVM* vm, jobject object) : mVm(vm), mObject(object) {}

	virtual ~JGlobalRefHolder() {		virtual ~JGlobalRefHolder() {
	GraphicsJNI::getJNIEnv()->DeleteGlobalRef(mObject);		env()->DeleteGlobalRef(mObject);
	mObject = nullptr;		mObject = nullptr;
	}		}

	jobject object() { return mObject; }		jobject object() { return mObject; }
	JavaVM* vm() { return mVm; }		JavaVM* vm() { return mVm; }

			JNIEnv* env() {
			JNIEnv* env;
			if (mVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
			LOG_ALWAYS_FATAL("Failed to get JNIEnv for JavaVM: %p", mVm);
			}
			return env;
			}

	private:		private:
	JGlobalRefHolder(const JGlobalRefHolder&) = delete;		JGlobalRefHolder(const JGlobalRefHolder&) = delete;
	void operator=(const JGlobalRefHolder&) = delete;		void operator=(const JGlobalRefHolder&) = delete;

libs/hwui/jni/JvmErrorReporter.h

+4 −1

Original line number	Original line	Diff line number	Diff line
	@@ -30,7 +30,10 @@ public:
	JvmErrorReporter(JNIEnv* env) { env->GetJavaVM(&mVm); }		JvmErrorReporter(JNIEnv* env) { env->GetJavaVM(&mVm); }

	virtual void onError(const std::string& message) override {		virtual void onError(const std::string& message) override {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		JNIEnv* env;
			if (mVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
			LOG_ALWAYS_FATAL("Failed to get JNIEnv for JavaVM: %p", mVm);
			}
	jniThrowException(env, "java/lang/IllegalStateException", message.c_str());		jniThrowException(env, "java/lang/IllegalStateException", message.c_str());
	}		}

libs/hwui/jni/android_graphics_HardwareBufferRenderer.cpp

+3 −2

libs/hwui/jni/android_graphics_HardwareRenderer.cpp

+31 −28

Original line number	Original line	Diff line number	Diff line
	@@ -94,12 +94,21 @@ struct {
	jmethodID getDestinationBitmap;		jmethodID getDestinationBitmap;
	} gCopyRequest;		} gCopyRequest;

			static JNIEnv* getenv(JavaVM* vm) {
			JNIEnv* env;
			if (vm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6) != JNI_OK) {
			LOG_ALWAYS_FATAL("Failed to get JNIEnv for JavaVM: %p", vm);
			}
			return env;
			}

	typedef ANativeWindow* (ANW_fromSurface)(JNIEnv env, jobject surface);		typedef ANativeWindow* (ANW_fromSurface)(JNIEnv env, jobject surface);
	ANW_fromSurface fromSurface;		ANW_fromSurface fromSurface;

	class FrameCommitWrapper : public LightRefBase<FrameCommitWrapper> {		class FrameCommitWrapper : public LightRefBase<FrameCommitWrapper> {
	public:		public:
	explicit FrameCommitWrapper(JNIEnv* env, jobject jobject) {		explicit FrameCommitWrapper(JNIEnv* env, jobject jobject) {
			env->GetJavaVM(&mVm);
	mObject = env->NewGlobalRef(jobject);		mObject = env->NewGlobalRef(jobject);
	LOG_ALWAYS_FATAL_IF(!mObject, "Failed to make global ref");		LOG_ALWAYS_FATAL_IF(!mObject, "Failed to make global ref");
	}		}
	@@ -109,18 +118,19 @@ public:
	void onFrameCommit(bool didProduceBuffer) {		void onFrameCommit(bool didProduceBuffer) {
	if (mObject) {		if (mObject) {
	ATRACE_FORMAT("frameCommit success=%d", didProduceBuffer);		ATRACE_FORMAT("frameCommit success=%d", didProduceBuffer);
	GraphicsJNI::getJNIEnv()->CallVoidMethod(mObject, gFrameCommitCallback.onFrameCommit,		getenv(mVm)->CallVoidMethod(mObject, gFrameCommitCallback.onFrameCommit,
	didProduceBuffer);		didProduceBuffer);
	releaseObject();		releaseObject();
	}		}
	}		}

	private:		private:
			JavaVM* mVm;
	jobject mObject;		jobject mObject;

	void releaseObject() {		void releaseObject() {
	if (mObject) {		if (mObject) {
	GraphicsJNI::getJNIEnv()->DeleteGlobalRef(mObject);		getenv(mVm)->DeleteGlobalRef(mObject);
	mObject = nullptr;		mObject = nullptr;
	}		}
	}		}
	@@ -541,10 +551,9 @@ static void android_view_ThreadedRenderer_setPictureCapturedCallbackJNI(JNIEnv*
	auto pictureState = std::make_shared<PictureCaptureState>();		auto pictureState = std::make_shared<PictureCaptureState>();
	proxy->setPictureCapturedCallback([globalCallbackRef,		proxy->setPictureCapturedCallback([globalCallbackRef,
	pictureState](sk_sp<SkPicture>&& picture) {		pictureState](sk_sp<SkPicture>&& picture) {
	JNIEnv* env = GraphicsJNI::getJNIEnv();
	Picture* wrapper = new PictureWrapper{std::move(picture), pictureState};		Picture* wrapper = new PictureWrapper{std::move(picture), pictureState};
	env->CallStaticVoidMethod(gHardwareRenderer.clazz,		globalCallbackRef->env()->CallStaticVoidMethod(
	gHardwareRenderer.invokePictureCapturedCallback,		gHardwareRenderer.clazz, gHardwareRenderer.invokePictureCapturedCallback,
	static_cast<jlong>(reinterpret_cast<intptr_t>(wrapper)),		static_cast<jlong>(reinterpret_cast<intptr_t>(wrapper)),
	globalCallbackRef->object());		globalCallbackRef->object());
	});		});
	@@ -561,12 +570,10 @@ static void android_view_ThreadedRenderer_setASurfaceTransactionCallback(
	LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&vm) != JNI_OK, "Unable to get Java VM");		LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&vm) != JNI_OK, "Unable to get Java VM");
	auto globalCallbackRef = std::make_shared<JGlobalRefHolder>(		auto globalCallbackRef = std::make_shared<JGlobalRefHolder>(
	vm, env->NewGlobalRef(aSurfaceTransactionCallback));		vm, env->NewGlobalRef(aSurfaceTransactionCallback));
	proxy->setASurfaceTransactionCallback(		proxy->setASurfaceTransactionCallback([globalCallbackRef](int64_t transObj, int64_t scObj,
	[globalCallbackRef](int64_t transObj, int64_t scObj, int64_t frameNr) -> bool {		int64_t frameNr) -> bool {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		jboolean ret = globalCallbackRef->env()->CallBooleanMethod(
	jboolean ret = env->CallBooleanMethod(		globalCallbackRef->object(), gASurfaceTransactionCallback.onMergeTransaction,
	globalCallbackRef->object(),
	gASurfaceTransactionCallback.onMergeTransaction,
	static_cast<jlong>(transObj), static_cast<jlong>(scObj),		static_cast<jlong>(transObj), static_cast<jlong>(scObj),
	static_cast<jlong>(frameNr));		static_cast<jlong>(frameNr));
	return ret;		return ret;
	@@ -585,9 +592,8 @@ static void android_view_ThreadedRenderer_setPrepareSurfaceControlForWebviewCall
	auto globalCallbackRef =		auto globalCallbackRef =
	std::make_shared<JGlobalRefHolder>(vm, env->NewGlobalRef(callback));		std::make_shared<JGlobalRefHolder>(vm, env->NewGlobalRef(callback));
	proxy->setPrepareSurfaceControlForWebviewCallback([globalCallbackRef]() {		proxy->setPrepareSurfaceControlForWebviewCallback([globalCallbackRef]() {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		globalCallbackRef->env()->CallVoidMethod(
	env->CallVoidMethod(globalCallbackRef->object(),		globalCallbackRef->object(), gPrepareSurfaceControlForWebviewCallback.prepare);
	gPrepareSurfaceControlForWebviewCallback.prepare);
	});		});
	}		}
	}		}
	@@ -604,7 +610,7 @@ static void android_view_ThreadedRenderer_setFrameCallback(JNIEnv* env,
	env->NewGlobalRef(frameCallback));		env->NewGlobalRef(frameCallback));
	proxy->setFrameCallback([globalCallbackRef](int32_t syncResult,		proxy->setFrameCallback([globalCallbackRef](int32_t syncResult,
	int64_t frameNr) -> std::function<void(bool)> {		int64_t frameNr) -> std::function<void(bool)> {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		JNIEnv* env = globalCallbackRef->env();
	ScopedLocalRef<jobject> frameCommitCallback(		ScopedLocalRef<jobject> frameCommitCallback(
	env, env->CallObjectMethod(		env, env->CallObjectMethod(
	globalCallbackRef->object(), gFrameDrawingCallback.onFrameDraw,		globalCallbackRef->object(), gFrameDrawingCallback.onFrameDraw,
	@@ -643,8 +649,7 @@ static void android_view_ThreadedRenderer_setFrameCompleteCallback(JNIEnv* env,
	auto globalCallbackRef =		auto globalCallbackRef =
	std::make_shared<JGlobalRefHolder>(vm, env->NewGlobalRef(callback));		std::make_shared<JGlobalRefHolder>(vm, env->NewGlobalRef(callback));
	proxy->setFrameCompleteCallback([globalCallbackRef]() {		proxy->setFrameCompleteCallback([globalCallbackRef]() {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		globalCallbackRef->env()->CallVoidMethod(globalCallbackRef->object(),
	env->CallVoidMethod(globalCallbackRef->object(),
	gFrameCompleteCallback.onFrameComplete);		gFrameCompleteCallback.onFrameComplete);
	});		});
	}		}
	@@ -656,8 +661,7 @@ public:
	: CopyRequest(srcRect), mRefHolder(vm, jCopyRequest) {}		: CopyRequest(srcRect), mRefHolder(vm, jCopyRequest) {}

	virtual SkBitmap getDestinationBitmap(int srcWidth, int srcHeight) override {		virtual SkBitmap getDestinationBitmap(int srcWidth, int srcHeight) override {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		jlong bitmapPtr = mRefHolder.env()->CallLongMethod(
	jlong bitmapPtr = env->CallLongMethod(
	mRefHolder.object(), gCopyRequest.getDestinationBitmap, srcWidth, srcHeight);		mRefHolder.object(), gCopyRequest.getDestinationBitmap, srcWidth, srcHeight);
	SkBitmap bitmap;		SkBitmap bitmap;
	bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);		bitmap::toBitmap(bitmapPtr).getSkBitmap(&bitmap);
	@@ -665,8 +669,7 @@ public:
	}		}

	virtual void onCopyFinished(CopyResult result) override {		virtual void onCopyFinished(CopyResult result) override {
	JNIEnv* env = GraphicsJNI::getJNIEnv();		mRefHolder.env()->CallVoidMethod(mRefHolder.object(), gCopyRequest.onCopyFinished,
	env->CallVoidMethod(mRefHolder.object(), gCopyRequest.onCopyFinished,
	static_cast<jint>(result));		static_cast<jint>(result));
	}		}

Original line number	Original line	Diff line number	Diff line
	@@ -49,7 +49,7 @@ static RenderCallback createRenderCallback(JNIEnv* env, jobject releaseCallback)
	auto globalCallbackRef =		auto globalCallbackRef =
	std::make_shared<JGlobalRefHolder>(vm, env->NewGlobalRef(releaseCallback));		std::make_shared<JGlobalRefHolder>(vm, env->NewGlobalRef(releaseCallback));
	return [globalCallbackRef](android::base::unique_fd&& fd, int status) {		return [globalCallbackRef](android::base::unique_fd&& fd, int status) {
	GraphicsJNI::getJNIEnv()->CallStaticVoidMethod(		globalCallbackRef->env()->CallStaticVoidMethod(
	gHardwareBufferRendererClassInfo.clazz,		gHardwareBufferRendererClassInfo.clazz,
	gHardwareBufferRendererClassInfo.invokeRenderCallback, globalCallbackRef->object(),		gHardwareBufferRendererClassInfo.invokeRenderCallback, globalCallbackRef->object(),
	reinterpret_cast<jint>(fd.release()), reinterpret_cast<jint>(status));		reinterpret_cast<jint>(fd.release()), reinterpret_cast<jint>(status));
	@@ -172,7 +172,8 @@ static const JNINativeMethod gMethods[] = {
	int register_android_graphics_HardwareBufferRenderer(JNIEnv* env) {		int register_android_graphics_HardwareBufferRenderer(JNIEnv* env) {
	jclass hardwareBufferRendererClazz =		jclass hardwareBufferRendererClazz =
	FindClassOrDie(env, "android/graphics/HardwareBufferRenderer");		FindClassOrDie(env, "android/graphics/HardwareBufferRenderer");
	gHardwareBufferRendererClassInfo.clazz = hardwareBufferRendererClazz;		gHardwareBufferRendererClassInfo.clazz =
			reinterpret_cast<jclass>(env->NewGlobalRef(hardwareBufferRendererClazz));
	gHardwareBufferRendererClassInfo.invokeRenderCallback =		gHardwareBufferRendererClassInfo.invokeRenderCallback =
	GetStaticMethodIDOrDie(env, hardwareBufferRendererClazz, "invokeRenderCallback",		GetStaticMethodIDOrDie(env, hardwareBufferRendererClazz, "invokeRenderCallback",
	"(Ljava/util/function/Consumer;II)V");		"(Ljava/util/function/Consumer;II)V");