Lines Matching refs:env
39 var = env->FindClass(className); \
43 var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
47 var = env->GetMethodID(clazz, fieldName, fieldDescriptor); \
51 var = env->GetStaticFieldID(clazz, fieldName, fieldDescriptor); \
55 var = env->GetStaticMethodID(clazz, fieldName, fieldDescriptor); \
143 JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
152 JNIDrmListener::JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
156 jclass clazz = env->GetObjectClass(thiz);
159 jniThrowException(env, "java/lang/Exception",
163 mClass = (jclass)env->NewGlobalRef(clazz);
167 mObject = env->NewGlobalRef(weak_thiz);
173 JNIEnv *env = AndroidRuntime::getJNIEnv();
174 env->DeleteGlobalRef(mObject);
175 env->DeleteGlobalRef(mClass);
202 JNIEnv *env = AndroidRuntime::getJNIEnv();
204 jobject jParcel = createJavaParcelObject(env);
206 Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
208 env->CallStaticVoidMethod(mClass, gFields.post_event, mObject,
210 env->DeleteLocalRef(jParcel);
214 if (env->ExceptionCheck()) {
216 LOGW_EX(env);
217 env->ExceptionClear();
221 static void throwStateException(JNIEnv *env, const char *msg, status_t err) {
224 jobject exception = env->NewObject(gFields.stateException.classId,
226 env->NewStringUTF(msg));
227 env->Throw(static_cast<jthrowable>(exception));
231 JNIEnv *env, status_t err, const char *msg = NULL) {
271 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
274 jniThrowException(env, "android/media/NotProvisionedException", msg);
277 jniThrowException(env, "android/media/ResourceBusyException", msg);
280 jniThrowException(env, "android/media/DeniedByServerException", msg);
292 throwStateException(env, msg, err);
298 static sp<IDrm> GetDrm(JNIEnv *env, jobject thiz) {
299 JDrm *jdrm = (JDrm *)env->GetLongField(thiz, gFields.context);
304 JNIEnv *env, jobject thiz, const uint8_t uuid[16]) {
305 mObject = env->NewWeakGlobalRef(thiz);
313 JNIEnv *env = AndroidRuntime::getJNIEnv();
315 env->DeleteWeakGlobalRef(mObject);
401 static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
403 size_t length = env->GetArrayLength(byteArray);
405 env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
409 static jbyteArray VectorToJByteArray(JNIEnv *env, Vector<uint8_t> const &vector) {
411 jbyteArray result = env->NewByteArray(length);
413 env->SetByteArrayRegion(result, 0, length, (jbyte *)vector.array());
418 static String8 JStringToString8(JNIEnv *env, jstring const &jstr) {
421 const char *s = env->GetStringUTFChars(jstr, NULL);
424 env->ReleaseStringUTFChars(jstr, s);
441 static KeyedVector<String8, String8> HashMapToKeyedVector(JNIEnv *env, jobject &hashMap) {
445 jobject entrySet = env->CallObjectMethod(hashMap, gFields.hashmap.entrySet);
447 jobject iterator = env->CallObjectMethod(entrySet, gFields.set.iterator);
449 jboolean hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
451 jobject entry = env->CallObjectMethod(iterator, gFields.iterator.next);
453 jobject obj = env->CallObjectMethod(entry, gFields.entry.getKey);
454 if (!env->IsInstanceOf(obj, clazz)) {
455 jniThrowException(env, "java/lang/IllegalArgumentException",
460 obj = env->CallObjectMethod(entry, gFields.entry.getValue);
461 if (!env->IsInstanceOf(obj, clazz)) {
462 jniThrowException(env, "java/lang/IllegalArgumentException",
467 String8 key = JStringToString8(env, jkey);
468 String8 value = JStringToString8(env, jvalue);
471 env->DeleteLocalRef(jkey);
472 env->DeleteLocalRef(jvalue);
473 hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
475 env->DeleteLocalRef(entry);
477 env->DeleteLocalRef(iterator);
479 env->DeleteLocalRef(entrySet);
484 static jobject KeyedVectorToHashMap (JNIEnv *env, KeyedVector<String8, String8> const &map) {
486 jobject hashMap = env->NewObject(clazz, gFields.hashmap.init);
488 jstring jkey = env->NewStringUTF(map.keyAt(i).string());
489 jstring jvalue = env->NewStringUTF(map.valueAt(i).string());
490 env->CallObjectMethod(hashMap, gFields.hashmap.put, jkey, jvalue);
491 env->DeleteLocalRef(jkey);
492 env->DeleteLocalRef(jvalue);
497 static jobject ListOfVectorsToArrayListOfByteArray(JNIEnv *env,
500 jobject arrayList = env->NewObject(clazz, gFields.arraylist.init);
503 jbyteArray byteArray = VectorToJByteArray(env, *iter);
504 env->CallBooleanMethod(arrayList, gFields.arraylist.add, byteArray);
505 env->DeleteLocalRef(byteArray);
517 JNIEnv *env, jobject thiz, const sp<JDrm> &drm) {
518 sp<JDrm> old = (JDrm *)env->GetLongField(thiz, gFields.context);
525 env->SetLongField(thiz, gFields.context, reinterpret_cast<jlong>(drm.get()));
530 static bool CheckSession(JNIEnv *env, const sp<IDrm> &drm, jbyteArray const &jsessionId)
533 jniThrowException(env, "java/lang/IllegalStateException", "MediaDrm obj is null");
538 jniThrowException(env, "java/lang/IllegalArgumentException", "sessionId is null");
544 static void android_media_MediaDrm_release(JNIEnv *env, jobject thiz) {
545 sp<JDrm> drm = setDrm(env, thiz, NULL);
552 static void android_media_MediaDrm_native_init(JNIEnv *env) {
561 gEventTypes.kEventProvisionRequired = env->GetStaticIntField(clazz, field);
563 gEventTypes.kEventKeyRequired = env->GetStaticIntField(clazz, field);
565 gEventTypes.kEventKeyExpired = env->GetStaticIntField(clazz, field);
567 gEventTypes.kEventVendorDefined = env->GetStaticIntField(clazz, field);
570 gKeyTypes.kKeyTypeStreaming = env->GetStaticIntField(clazz, field);
572 gKeyTypes.kKeyTypeOffline = env->GetStaticIntField(clazz, field);
574 gKeyTypes.kKeyTypeRelease = env->GetStaticIntField(clazz, field);
577 gCertificateTypes.kCertificateTypeNone = env->GetStaticIntField(clazz, field);
579 gCertificateTypes.kCertificateTypeX509 = env->GetStaticIntField(clazz, field);
592 gFields.certificateClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
617 gFields.hashmapClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
620 gFields.stringClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
623 gFields.arraylistClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
627 gFields.stateException.classId = static_cast<jclass>(env->NewGlobalRef(clazz));
631 JNIEnv *env, jobject thiz,
635 jniThrowException(env, "java/lang/IllegalArgumentException", "uuid is null");
639 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
642 jniThrowException(env, "java/lang/IllegalArgumentException",
647 sp<JDrm> drm = new JDrm(env, thiz, uuid.array());
653 env,
659 sp<JNIDrmListener> listener = new JNIDrmListener(env, thiz, weak_this);
661 setDrm(env, thiz, drm);
665 JNIEnv *env, jobject thiz) {
666 android_media_MediaDrm_release(env, thiz);
670 JNIEnv *env, jobject thiz, jbyteArray uuidObj, jstring jmimeType) {
673 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
677 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
681 env,
689 mimeType = JStringToString8(env, jmimeType);
696 JNIEnv *env, jobject thiz) {
697 sp<IDrm> drm = GetDrm(env, thiz);
700 jniThrowException(env, "java/lang/IllegalStateException",
708 if (throwExceptionAsNecessary(env, err, "Failed to open session")) {
712 return VectorToJByteArray(env, sessionId);
716 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
717 sp<IDrm> drm = GetDrm(env, thiz);
719 if (!CheckSession(env, drm, jsessionId)) {
723 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
727 throwExceptionAsNecessary(env, err, "Failed to close session");
731 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jinitData,
733 sp<IDrm> drm = GetDrm(env, thiz);
735 if (!CheckSession(env, drm, jsessionId)) {
739 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
743 initData = JByteArrayToVector(env, jinitData);
748 mimeType = JStringToString8(env, jmimeType);
759 jniThrowException(env, "java/lang/IllegalArgumentException",
766 optParams = HashMapToKeyedVector(env, joptParams);
775 if (throwExceptionAsNecessary(env, err, "Failed to get key request")) {
786 keyObj = env->AllocObject(clazz);
787 jbyteArray jrequest = VectorToJByteArray(env, request);
788 env->SetObjectField(keyObj, gFields.keyRequest.data, jrequest);
790 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
791 env->SetObjectField(keyObj, gFields.keyRequest.defaultUrl, jdefaultUrl);
798 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jresponse) {
799 sp<IDrm> drm = GetDrm(env, thiz);
801 if (!CheckSession(env, drm, jsessionId)) {
805 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
808 jniThrowException(env, "java/lang/IllegalArgumentException",
812 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
817 if (throwExceptionAsNecessary(env, err, "Failed to handle key response")) {
820 return VectorToJByteArray(env, keySetId);
824 JNIEnv *env, jobject thiz, jbyteArray jkeysetId) {
825 sp<IDrm> drm = GetDrm(env, thiz);
828 jniThrowException(env, "java/lang/IllegalArgumentException",
833 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
837 throwExceptionAsNecessary(env, err, "Failed to remove keys");
841 JNIEnv *env, jobject thiz, jbyteArray jsessionId,
844 sp<IDrm> drm = GetDrm(env, thiz);
846 if (!CheckSession(env, drm, jsessionId)) {
851 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
855 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
856 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
860 throwExceptionAsNecessary(env, err, "Failed to restore keys");
864 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
865 sp<IDrm> drm = GetDrm(env, thiz);
867 if (!CheckSession(env, drm, jsessionId)) {
870 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
876 if (throwExceptionAsNecessary(env, err, "Failed to query key status")) {
880 return KeyedVectorToHashMap(env, infoMap);
884 JNIEnv *env, jobject thiz, jint jcertType, jstring jcertAuthority) {
885 sp<IDrm> drm = GetDrm(env, thiz);
888 jniThrowException(env, "java/lang/IllegalStateException",
905 String8 certAuthority = JStringToString8(env, jcertAuthority);
908 if (throwExceptionAsNecessary(env, err, "Failed to get provision request")) {
919 provisionObj = env->AllocObject(clazz);
920 jbyteArray jrequest = VectorToJByteArray(env, request);
921 env->SetObjectField(provisionObj, gFields.provisionRequest.data, jrequest);
923 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
924 env->SetObjectField(provisionObj, gFields.provisionRequest.defaultUrl, jdefaultUrl);
931 JNIEnv *env, jobject thiz, jbyteArray jresponse) {
932 sp<IDrm> drm = GetDrm(env, thiz);
935 jniThrowException(env, "java/lang/IllegalStateException",
941 jniThrowException(env, "java/lang/IllegalArgumentException",
946 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
957 certificateObj = env->AllocObject(clazz);
958 jbyteArray jcertificate = VectorToJByteArray(env, certificate);
959 env->SetObjectField(certificateObj, gFields.certificate.certificateData, jcertificate);
961 jbyteArray jwrappedKey = VectorToJByteArray(env, wrappedKey);
962 env->SetObjectField(certificateObj, gFields.certificate.wrappedPrivateKey, jwrappedKey);
965 throwExceptionAsNecessary(env, err, "Failed to handle provision response");
970 JNIEnv *env, jobject thiz) {
971 sp<IDrm> drm = GetDrm(env, thiz);
974 jniThrowException(env, "java/lang/IllegalStateException",
981 throwExceptionAsNecessary(env, err, "Failed to handle provision response");
986 JNIEnv *env, jobject thiz) {
987 sp<IDrm> drm = GetDrm(env, thiz);
990 jniThrowException(env, "java/lang/IllegalStateException",
999 if (throwExceptionAsNecessary(env, err, "Failed to get secure stops")) {
1003 return ListOfVectorsToArrayListOfByteArray(env, secureStops);
1007 JNIEnv *env, jobject thiz, jbyteArray jssRelease) {
1008 sp<IDrm> drm = GetDrm(env, thiz);
1011 jniThrowException(env, "java/lang/IllegalStateException",
1016 Vector<uint8_t> ssRelease(JByteArrayToVector(env, jssRelease));
1020 throwExceptionAsNecessary(env, err, "Failed to release secure stops");
1024 JNIEnv *env, jobject thiz, jstring jname) {
1025 sp<IDrm> drm = GetDrm(env, thiz);
1028 jniThrowException(env, "java/lang/IllegalStateException",
1034 jniThrowException(env, "java/lang/IllegalArgumentException",
1039 String8 name = JStringToString8(env, jname);
1044 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1048 return env->NewStringUTF(value.string());
1052 JNIEnv *env, jobject thiz, jstring jname) {
1053 sp<IDrm> drm = GetDrm(env, thiz);
1056 jniThrowException(env, "java/lang/IllegalStateException",
1062 jniThrowException(env, "java/lang/IllegalArgumentException",
1067 String8 name = JStringToString8(env, jname);
1072 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1076 return VectorToJByteArray(env, value);
1080 JNIEnv *env, jobject thiz, jstring jname, jstring jvalue) {
1081 sp<IDrm> drm = GetDrm(env, thiz);
1084 jniThrowException(env, "java/lang/IllegalStateException",
1090 jniThrowException(env, "java/lang/IllegalArgumentException",
1096 jniThrowException(env, "java/lang/IllegalArgumentException",
1101 String8 name = JStringToString8(env, jname);
1102 String8 value = JStringToString8(env, jvalue);
1106 throwExceptionAsNecessary(env, err, "Failed to set property");
1110 JNIEnv *env, jobject thiz, jstring jname, jbyteArray jvalue) {
1111 sp<IDrm> drm = GetDrm(env, thiz);
1114 jniThrowException(env, "java/lang/IllegalStateException",
1120 jniThrowException(env, "java/lang/IllegalArgumentException",
1126 jniThrowException(env, "java/lang/IllegalArgumentException",
1131 String8 name = JStringToString8(env, jname);
1132 Vector<uint8_t> value = JByteArrayToVector(env, jvalue);
1136 throwExceptionAsNecessary(env, err, "Failed to set property");
1140 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1143 sp<IDrm> drm = GetDrm(env, jdrm);
1145 if (!CheckSession(env, drm, jsessionId)) {
1150 jniThrowException(env, "java/lang/IllegalArgumentException",
1155 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1156 String8 algorithm = JStringToString8(env, jalgorithm);
1160 throwExceptionAsNecessary(env, err, "Failed to set cipher algorithm");
1164 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1167 sp<IDrm> drm = GetDrm(env, jdrm);
1169 if (!CheckSession(env, drm, jsessionId)) {
1174 jniThrowException(env, "java/lang/IllegalArgumentException",
1179 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1180 String8 algorithm = JStringToString8(env, jalgorithm);
1184 throwExceptionAsNecessary(env, err, "Failed to set mac algorithm");
1189 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1192 sp<IDrm> drm = GetDrm(env, jdrm);
1194 if (!CheckSession(env, drm, jsessionId)) {
1199 jniThrowException(env, "java/lang/IllegalArgumentException",
1204 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1205 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1206 Vector<uint8_t> input(JByteArrayToVector(env, jinput));
1207 Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
1212 if (throwExceptionAsNecessary(env, err, "Failed to encrypt")) {
1216 return VectorToJByteArray(env, output);
1220 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1223 sp<IDrm> drm = GetDrm(env, jdrm);
1225 if (!CheckSession(env, drm, jsessionId)) {
1230 jniThrowException(env, "java/lang/IllegalArgumentException",
1235 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1236 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1237 Vector<uint8_t> input(JByteArrayToVector(env, jinput));
1238 Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
1242 if (throwExceptionAsNecessary(env, err, "Failed to decrypt")) {
1246 return VectorToJByteArray(env, output);
1250 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1253 sp<IDrm> drm = GetDrm(env, jdrm);
1255 if (!CheckSession(env, drm, jsessionId)) {
1260 jniThrowException(env, "java/lang/IllegalArgumentException",
1265 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1266 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1267 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1272 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1276 return VectorToJByteArray(env, signature);
1280 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1283 sp<IDrm> drm = GetDrm(env, jdrm);
1285 if (!CheckSession(env, drm, jsessionId)) {
1290 jniThrowException(env, "java/lang/IllegalArgumentException",
1295 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1296 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1297 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1298 Vector<uint8_t> signature(JByteArrayToVector(env, jsignature));
1303 throwExceptionAsNecessary(env, err, "Failed to verify");
1309 JNIEnv *env, jobject thiz, jobject jdrm, jbyteArray jsessionId,
1312 sp<IDrm> drm = GetDrm(env, jdrm);
1314 if (!CheckSession(env, drm, jsessionId)) {
1319 jniThrowException(env, "java/lang/IllegalArgumentException",
1324 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1325 String8 algorithm = JStringToString8(env, jalgorithm);
1326 Vector<uint8_t> wrappedKey(JByteArrayToVector(env, jwrappedKey));
1327 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1332 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1336 return VectorToJByteArray(env, signature);
1426 int register_android_media_Drm(JNIEnv *env) {
1427 return AndroidRuntime::registerNativeMethods(env,