media/jni/android_media_MediaCrypto.cpp - LeafOS-Project/android_frameworks_base - Gitiles

 /*
  * Copyright 2012, 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_NDEBUG 0
 #define LOG_TAG "MediaCrypto-JNI"
 #include <utils/Log.h>

 #include "android_media_MediaCrypto.h"

 #include "android_runtime/AndroidRuntime.h"
 #include "jni.h"
 #include <nativehelper/JNIHelp.h>

 #include <cutils/properties.h>
 #include <media/stagefright/foundation/ADebug.h>
 #include <mediadrm/DrmUtils.h>
 #include <mediadrm/ICrypto.h>

 namespace android {

 struct fields_t {
     jfieldID context;
 };

 static fields_t gFields;

 static sp<JCrypto> getCrypto(JNIEnv *env, jobject thiz) {
     return (JCrypto *)env->GetLongField(thiz, gFields.context);
 }

 JCrypto::JCrypto(
         JNIEnv *env, jobject thiz,
         const uint8_t uuid[16], const void *initData, size_t initSize) {
     mObject = env->NewWeakGlobalRef(thiz);

     mCrypto = MakeCrypto(uuid, initData, initSize);
 }

 JCrypto::~JCrypto() {
     if (mCrypto != NULL) {
         mCrypto->destroyPlugin();
     }
     mCrypto.clear();

     JNIEnv *env = AndroidRuntime::getJNIEnv();

     env->DeleteWeakGlobalRef(mObject);
     mObject = NULL;
 }

 // static
 sp<ICrypto> JCrypto::MakeCrypto() {
     return DrmUtils::MakeCrypto();
 }

 // static
 sp<ICrypto> JCrypto::MakeCrypto(
         const uint8_t uuid[16], const void *initData, size_t initSize) {
     sp<ICrypto> crypto = MakeCrypto();

     if (crypto == NULL) {
         return NULL;
     }

     status_t err = crypto->createPlugin(uuid, initData, initSize);

     if (err != OK) {
         return NULL;
     }

     return crypto;
 }

 bool JCrypto::requiresSecureDecoderComponent(const char *mime) const {
     if (mCrypto == NULL) {
         return false;
     }

     return mCrypto->requiresSecureDecoderComponent(mime);
 }

 // static
 bool JCrypto::IsCryptoSchemeSupported(const uint8_t uuid[16]) {
     sp<ICrypto> crypto = MakeCrypto();

     if (crypto == NULL) {
         return false;
     }

     return crypto->isCryptoSchemeSupported(uuid);
 }

 status_t JCrypto::initCheck() const {
     return mCrypto == NULL ? NO_INIT : OK;
 }

 // static
 sp<ICrypto> JCrypto::GetCrypto(JNIEnv *env, jobject obj) {
     jclass clazz = env->FindClass("android/media/MediaCrypto");
     CHECK(clazz != NULL);

     if (!env->IsInstanceOf(obj, clazz)) {
         return NULL;
     }

     sp<JCrypto> jcrypto = getCrypto(env, obj);

     if (jcrypto == NULL) {
         return NULL;
     }

     return jcrypto->mCrypto;
 }

 // JNI conversion utilities
 static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
     Vector<uint8_t> vector;
     size_t length = env->GetArrayLength(byteArray);
     vector.insertAt((size_t)0, length);
     env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
     return vector;
 }

 }  // namespace android

 using namespace android;

 static sp<JCrypto> setCrypto(
         JNIEnv *env, jobject thiz, const sp<JCrypto> &crypto) {
     sp<JCrypto> old = (JCrypto *)env->GetLongField(thiz, gFields.context);
     if (crypto != NULL) {
         crypto->incStrong(thiz);
     }
     if (old != NULL) {
         old->decStrong(thiz);
     }
     env->SetLongField(thiz, gFields.context, (jlong)crypto.get());

     return old;
 }

 static void android_media_MediaCrypto_release(JNIEnv *env, jobject thiz) {
     setCrypto(env, thiz, NULL);
 }

 static void android_media_MediaCrypto_native_init(JNIEnv *env) {
     jclass clazz = env->FindClass("android/media/MediaCrypto");
     CHECK(clazz != NULL);

     gFields.context = env->GetFieldID(clazz, "mNativeContext", "J");
     CHECK(gFields.context != NULL);
 }

 static void android_media_MediaCrypto_native_setup(
         JNIEnv *env, jobject thiz,
         jbyteArray uuidObj, jbyteArray initDataObj) {
     jsize uuidLength = env->GetArrayLength(uuidObj);

     if (uuidLength != 16) {
         jniThrowException(
                 env,
                 "java/lang/IllegalArgumentException",
                 NULL);
         return;
     }

     jboolean isCopy;
     jbyte *uuid = env->GetByteArrayElements(uuidObj, &isCopy);

     jsize initDataLength = 0;
     jbyte *initData = NULL;

     if (initDataObj != NULL) {
         initDataLength = env->GetArrayLength(initDataObj);
         initData = env->GetByteArrayElements(initDataObj, &isCopy);
     }

     sp<JCrypto> crypto = new JCrypto(
             env, thiz, (const uint8_t *)uuid, initData, initDataLength);

     status_t err = crypto->initCheck();

     if (initDataObj != NULL) {
         env->ReleaseByteArrayElements(initDataObj, initData, 0);
         initData = NULL;
     }

     env->ReleaseByteArrayElements(uuidObj, uuid, 0);
     uuid = NULL;

     if (err != OK) {
         std::string strerr(StrCryptoError(err));
         jniThrowExceptionFmt(
                 env,
                 "android/media/MediaCryptoException",
                 "Failed to instantiate crypto object: %s", strerr.c_str());
         return;
     }

     setCrypto(env,thiz, crypto);
 }

 static void android_media_MediaCrypto_native_finalize(
         JNIEnv *env, jobject thiz) {
     android_media_MediaCrypto_release(env, thiz);
 }

 static jboolean android_media_MediaCrypto_isCryptoSchemeSupportedNative(
         JNIEnv *env, jobject /* thiz */, jbyteArray uuidObj) {
     jsize uuidLength = env->GetArrayLength(uuidObj);

     if (uuidLength != 16) {
         jniThrowException(
                 env,
                 "java/lang/IllegalArgumentException",
                 NULL);
         return JNI_FALSE;
     }

     jboolean isCopy;
     jbyte *uuid = env->GetByteArrayElements(uuidObj, &isCopy);

     bool result = JCrypto::IsCryptoSchemeSupported((const uint8_t *)uuid);

     env->ReleaseByteArrayElements(uuidObj, uuid, 0);
     uuid = NULL;

     return result ? JNI_TRUE : JNI_FALSE;
 }

 static jboolean android_media_MediaCrypto_requiresSecureDecoderComponent(
         JNIEnv *env, jobject thiz, jstring mimeObj) {
     if (mimeObj == NULL) {
         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
         return JNI_FALSE;
     }

     sp<JCrypto> crypto = getCrypto(env, thiz);

     if (crypto == NULL) {
         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
         return JNI_FALSE;
     }

     const char *mime = env->GetStringUTFChars(mimeObj, NULL);

     if (mime == NULL) {
         return JNI_FALSE;
     }

     bool result = crypto->requiresSecureDecoderComponent(mime);

     env->ReleaseStringUTFChars(mimeObj, mime);
     mime = NULL;

     return result ? JNI_TRUE : JNI_FALSE;
 }

 static void android_media_MediaCrypto_setMediaDrmSession(
         JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
     if (jsessionId == NULL) {
         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
         return;
     }

     sp<ICrypto> crypto = JCrypto::GetCrypto(env, thiz);

     if (crypto == NULL) {
         jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
         return;
     }

     Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));

     status_t err = crypto->setMediaDrmSession(sessionId);

     if (err != OK) {
         String8 msg("setMediaDrmSession failed");
         if (err == ERROR_DRM_SESSION_NOT_OPENED) {
             msg += ": session not opened";
         } else if (err == ERROR_UNSUPPORTED) {
             msg += ": not supported by this crypto scheme";
         } else if (err == NO_INIT) {
             msg += ": crypto plugin not initialized";
         } else {
             std::string strerr(StrCryptoError(err));
             msg.appendFormat(": general failure (%s)", strerr.c_str());
         }
         jniThrowException(env, "android/media/MediaCryptoException", msg.string());
     }
 }

 static const JNINativeMethod gMethods[] = {
     { "release", "()V", (void *)android_media_MediaCrypto_release },
     { "native_init", "()V", (void *)android_media_MediaCrypto_native_init },

     { "native_setup", "([B[B)V",
       (void *)android_media_MediaCrypto_native_setup },

     { "native_finalize", "()V",
       (void *)android_media_MediaCrypto_native_finalize },

     { "isCryptoSchemeSupportedNative", "([B)Z",
       (void *)android_media_MediaCrypto_isCryptoSchemeSupportedNative },

     { "requiresSecureDecoderComponent", "(Ljava/lang/String;)Z",
       (void *)android_media_MediaCrypto_requiresSecureDecoderComponent },

     { "setMediaDrmSession", "([B)V",
       (void *)android_media_MediaCrypto_setMediaDrmSession },
 };

 int register_android_media_Crypto(JNIEnv *env) {
     return AndroidRuntime::registerNativeMethods(env,
                 "android/media/MediaCrypto", gMethods, NELEM(gMethods));
 }
	/*
	* Copyright 2012, 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_NDEBUG 0
	#define LOG_TAG "MediaCrypto-JNI"
	#include <utils/Log.h>

	#include "android_media_MediaCrypto.h"

	#include "android_runtime/AndroidRuntime.h"
	#include "jni.h"
	#include <nativehelper/JNIHelp.h>

	#include <cutils/properties.h>
	#include <media/stagefright/foundation/ADebug.h>
	#include <mediadrm/DrmUtils.h>
	#include <mediadrm/ICrypto.h>

	namespace android {

	struct fields_t {
	jfieldID context;
	};

	static fields_t gFields;

	static sp<JCrypto> getCrypto(JNIEnv *env, jobject thiz) {
	return (JCrypto *)env->GetLongField(thiz, gFields.context);
	}

	JCrypto::JCrypto(
	JNIEnv *env, jobject thiz,
	const uint8_t uuid[16], const void *initData, size_t initSize) {
	mObject = env->NewWeakGlobalRef(thiz);

	mCrypto = MakeCrypto(uuid, initData, initSize);
	}

	JCrypto::~JCrypto() {
	if (mCrypto != NULL) {
	mCrypto->destroyPlugin();
	}
	mCrypto.clear();

	JNIEnv *env = AndroidRuntime::getJNIEnv();

	env->DeleteWeakGlobalRef(mObject);
	mObject = NULL;
	}

	// static
	sp<ICrypto> JCrypto::MakeCrypto() {
	return DrmUtils::MakeCrypto();
	}

	// static
	sp<ICrypto> JCrypto::MakeCrypto(
	const uint8_t uuid[16], const void *initData, size_t initSize) {
	sp<ICrypto> crypto = MakeCrypto();

	if (crypto == NULL) {
	return NULL;
	}

	status_t err = crypto->createPlugin(uuid, initData, initSize);

	if (err != OK) {
	return NULL;
	}

	return crypto;
	}

	bool JCrypto::requiresSecureDecoderComponent(const char *mime) const {
	if (mCrypto == NULL) {
	return false;
	}

	return mCrypto->requiresSecureDecoderComponent(mime);
	}

	// static
	bool JCrypto::IsCryptoSchemeSupported(const uint8_t uuid[16]) {
	sp<ICrypto> crypto = MakeCrypto();

	if (crypto == NULL) {
	return false;
	}

	return crypto->isCryptoSchemeSupported(uuid);
	}

	status_t JCrypto::initCheck() const {
	return mCrypto == NULL ? NO_INIT : OK;
	}

	// static
	sp<ICrypto> JCrypto::GetCrypto(JNIEnv *env, jobject obj) {
	jclass clazz = env->FindClass("android/media/MediaCrypto");
	CHECK(clazz != NULL);

	if (!env->IsInstanceOf(obj, clazz)) {
	return NULL;
	}

	sp<JCrypto> jcrypto = getCrypto(env, obj);

	if (jcrypto == NULL) {
	return NULL;
	}

	return jcrypto->mCrypto;
	}

	// JNI conversion utilities
	static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
	Vector<uint8_t> vector;
	size_t length = env->GetArrayLength(byteArray);
	vector.insertAt((size_t)0, length);
	env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
	return vector;
	}

	} // namespace android

	using namespace android;

	static sp<JCrypto> setCrypto(
	JNIEnv *env, jobject thiz, const sp<JCrypto> &crypto) {
	sp<JCrypto> old = (JCrypto *)env->GetLongField(thiz, gFields.context);
	if (crypto != NULL) {
	crypto->incStrong(thiz);
	}
	if (old != NULL) {
	old->decStrong(thiz);
	}
	env->SetLongField(thiz, gFields.context, (jlong)crypto.get());

	return old;
	}

	static void android_media_MediaCrypto_release(JNIEnv *env, jobject thiz) {
	setCrypto(env, thiz, NULL);
	}

	static void android_media_MediaCrypto_native_init(JNIEnv *env) {
	jclass clazz = env->FindClass("android/media/MediaCrypto");
	CHECK(clazz != NULL);

	gFields.context = env->GetFieldID(clazz, "mNativeContext", "J");
	CHECK(gFields.context != NULL);
	}

	static void android_media_MediaCrypto_native_setup(
	JNIEnv *env, jobject thiz,
	jbyteArray uuidObj, jbyteArray initDataObj) {
	jsize uuidLength = env->GetArrayLength(uuidObj);

	if (uuidLength != 16) {
	jniThrowException(
	env,
	"java/lang/IllegalArgumentException",
	NULL);
	return;
	}

	jboolean isCopy;
	jbyte *uuid = env->GetByteArrayElements(uuidObj, &isCopy);

	jsize initDataLength = 0;
	jbyte *initData = NULL;

	if (initDataObj != NULL) {
	initDataLength = env->GetArrayLength(initDataObj);
	initData = env->GetByteArrayElements(initDataObj, &isCopy);
	}

	sp<JCrypto> crypto = new JCrypto(
	env, thiz, (const uint8_t *)uuid, initData, initDataLength);

	status_t err = crypto->initCheck();

	if (initDataObj != NULL) {
	env->ReleaseByteArrayElements(initDataObj, initData, 0);
	initData = NULL;
	}

	env->ReleaseByteArrayElements(uuidObj, uuid, 0);
	uuid = NULL;

	if (err != OK) {
	std::string strerr(StrCryptoError(err));
	jniThrowExceptionFmt(
	env,
	"android/media/MediaCryptoException",
	"Failed to instantiate crypto object: %s", strerr.c_str());
	return;
	}

	setCrypto(env,thiz, crypto);
	}

	static void android_media_MediaCrypto_native_finalize(
	JNIEnv *env, jobject thiz) {
	android_media_MediaCrypto_release(env, thiz);
	}

	static jboolean android_media_MediaCrypto_isCryptoSchemeSupportedNative(
	JNIEnv env, jobject / thiz */, jbyteArray uuidObj) {
	jsize uuidLength = env->GetArrayLength(uuidObj);

	if (uuidLength != 16) {
	jniThrowException(
	env,
	"java/lang/IllegalArgumentException",
	NULL);
	return JNI_FALSE;
	}

	jboolean isCopy;
	jbyte *uuid = env->GetByteArrayElements(uuidObj, &isCopy);

	bool result = JCrypto::IsCryptoSchemeSupported((const uint8_t *)uuid);

	env->ReleaseByteArrayElements(uuidObj, uuid, 0);
	uuid = NULL;

	return result ? JNI_TRUE : JNI_FALSE;
	}

	static jboolean android_media_MediaCrypto_requiresSecureDecoderComponent(
	JNIEnv *env, jobject thiz, jstring mimeObj) {
	if (mimeObj == NULL) {
	jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
	return JNI_FALSE;
	}

	sp<JCrypto> crypto = getCrypto(env, thiz);

	if (crypto == NULL) {
	jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
	return JNI_FALSE;
	}

	const char *mime = env->GetStringUTFChars(mimeObj, NULL);

	if (mime == NULL) {
	return JNI_FALSE;
	}

	bool result = crypto->requiresSecureDecoderComponent(mime);

	env->ReleaseStringUTFChars(mimeObj, mime);
	mime = NULL;

	return result ? JNI_TRUE : JNI_FALSE;
	}

	static void android_media_MediaCrypto_setMediaDrmSession(
	JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
	if (jsessionId == NULL) {
	jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
	return;
	}

	sp<ICrypto> crypto = JCrypto::GetCrypto(env, thiz);

	if (crypto == NULL) {
	jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
	return;
	}

	Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));

	status_t err = crypto->setMediaDrmSession(sessionId);

	if (err != OK) {
	String8 msg("setMediaDrmSession failed");
	if (err == ERROR_DRM_SESSION_NOT_OPENED) {
	msg += ": session not opened";
	} else if (err == ERROR_UNSUPPORTED) {
	msg += ": not supported by this crypto scheme";
	} else if (err == NO_INIT) {
	msg += ": crypto plugin not initialized";
	} else {
	std::string strerr(StrCryptoError(err));
	msg.appendFormat(": general failure (%s)", strerr.c_str());
	}
	jniThrowException(env, "android/media/MediaCryptoException", msg.string());
	}
	}

	static const JNINativeMethod gMethods[] = {
	{ "release", "()V", (void *)android_media_MediaCrypto_release },
	{ "native_init", "()V", (void *)android_media_MediaCrypto_native_init },

	{ "native_setup", "([B[B)V",
	(void *)android_media_MediaCrypto_native_setup },

	{ "native_finalize", "()V",
	(void *)android_media_MediaCrypto_native_finalize },

	{ "isCryptoSchemeSupportedNative", "([B)Z",
	(void *)android_media_MediaCrypto_isCryptoSchemeSupportedNative },

	{ "requiresSecureDecoderComponent", "(Ljava/lang/String;)Z",
	(void *)android_media_MediaCrypto_requiresSecureDecoderComponent },

	{ "setMediaDrmSession", "([B)V",
	(void *)android_media_MediaCrypto_setMediaDrmSession },
	};

	int register_android_media_Crypto(JNIEnv *env) {
	return AndroidRuntime::registerNativeMethods(env,
	"android/media/MediaCrypto", gMethods, NELEM(gMethods));
	}