Lines Matching defs: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); \
157 JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
166 JNIDrmListener::JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
170 jclass clazz = env->GetObjectClass(thiz);
173 jniThrowException(env, "java/lang/Exception",
177 mClass = (jclass)env->NewGlobalRef(clazz);
181 mObject = env->NewGlobalRef(weak_thiz);
187 JNIEnv *env = AndroidRuntime::getJNIEnv();
188 env->DeleteGlobalRef(mObject);
189 env->DeleteGlobalRef(mClass);
231 JNIEnv *env = AndroidRuntime::getJNIEnv();
233 jobject jParcel = createJavaParcelObject(env);
235 Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
237 env->CallStaticVoidMethod(mClass, gFields.post_event, mObject,
239 env->DeleteLocalRef(jParcel);
243 if (env->ExceptionCheck()) {
245 LOGW_EX(env);
246 env->ExceptionClear();
250 static void throwStateException(JNIEnv *env, const char *msg, status_t err) {
253 jobject exception = env->NewObject(gFields.stateException.classId,
255 env->NewStringUTF(msg));
256 env->Throw(static_cast<jthrowable>(exception));
260 JNIEnv *env, status_t err, const char *msg = NULL) {
300 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
303 jniThrowException(env, "android/media/NotProvisionedException", msg);
306 jniThrowException(env, "android/media/ResourceBusyException", msg);
309 jniThrowException(env, "android/media/DeniedByServerException", msg);
312 jniThrowException(env, "android/media/MediaDrmResetException",
325 throwStateException(env, msg, err);
331 static sp<IDrm> GetDrm(JNIEnv *env, jobject thiz) {
332 JDrm *jdrm = (JDrm *)env->GetLongField(thiz, gFields.context);
337 JNIEnv *env, jobject thiz, const uint8_t uuid[16]) {
338 mObject = env->NewWeakGlobalRef(thiz);
346 JNIEnv *env = AndroidRuntime::getJNIEnv();
348 env->DeleteWeakGlobalRef(mObject);
434 static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
436 size_t length = env->GetArrayLength(byteArray);
438 env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
442 static jbyteArray VectorToJByteArray(JNIEnv *env, Vector<uint8_t> const &vector) {
444 jbyteArray result = env->NewByteArray(length);
446 env->SetByteArrayRegion(result, 0, length, (jbyte *)vector.array());
451 static String8 JStringToString8(JNIEnv *env, jstring const &jstr) {
454 const char *s = env->GetStringUTFChars(jstr, NULL);
457 env->ReleaseStringUTFChars(jstr, s);
475 JNIEnv *env, jobject &hashMap, bool* pIsOK) {
480 jobject entrySet = env->CallObjectMethod(hashMap, gFields.hashmap.entrySet);
482 jobject iterator = env->CallObjectMethod(entrySet, gFields.set.iterator);
484 jboolean hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
486 jobject entry = env->CallObjectMethod(iterator, gFields.iterator.next);
488 jobject obj = env->CallObjectMethod(entry, gFields.entry.getKey);
489 if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
490 jniThrowException(env, "java/lang/IllegalArgumentException",
492 env->DeleteLocalRef(entry);
498 obj = env->CallObjectMethod(entry, gFields.entry.getValue);
499 if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
500 jniThrowException(env, "java/lang/IllegalArgumentException",
502 env->DeleteLocalRef(entry);
508 String8 key = JStringToString8(env, jkey);
509 String8 value = JStringToString8(env, jvalue);
512 env->DeleteLocalRef(jkey);
513 env->DeleteLocalRef(jvalue);
514 hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
516 env->DeleteLocalRef(entry);
518 env->DeleteLocalRef(iterator);
520 env->DeleteLocalRef(entrySet);
525 static jobject KeyedVectorToHashMap (JNIEnv *env, KeyedVector<String8, String8> const &map) {
527 jobject hashMap = env->NewObject(clazz, gFields.hashmap.init);
529 jstring jkey = env->NewStringUTF(map.keyAt(i).string());
530 jstring jvalue = env->NewStringUTF(map.valueAt(i).string());
531 env->CallObjectMethod(hashMap, gFields.hashmap.put, jkey, jvalue);
532 env->DeleteLocalRef(jkey);
533 env->DeleteLocalRef(jvalue);
538 static jobject ListOfVectorsToArrayListOfByteArray(JNIEnv *env,
541 jobject arrayList = env
544 jbyteArray byteArray = VectorToJByteArray(env, *iter);
545 env->CallBooleanMethod(arrayList, gFields.arraylist.add, byteArray);
546 env->DeleteLocalRef(byteArray);
558 JNIEnv *env, jobject thiz, const sp<JDrm> &drm) {
559 sp<JDrm> old = (JDrm *)env->GetLongField(thiz, gFields.context);
566 env->SetLongField(thiz, gFields.context, reinterpret_cast<jlong>(drm.get()));
571 static bool CheckSession(JNIEnv *env, const sp<IDrm> &drm, jbyteArray const &jsessionId)
574 jniThrowException(env, "java/lang/IllegalStateException", "MediaDrm obj is null");
579 jniThrowException(env, "java/lang/IllegalArgumentException", "sessionId is null");
585 static void android_media_MediaDrm_release(JNIEnv *env, jobject thiz) {
586 sp<JDrm> drm = setDrm(env, thiz, NULL);
593 static void android_media_MediaDrm_native_init(JNIEnv *env) {
602 gEventTypes.kEventProvisionRequired = env->GetStaticIntField(clazz, field);
604 gEventTypes.kEventKeyRequired = env->GetStaticIntField(clazz, field);
606 gEventTypes.kEventKeyExpired = env->GetStaticIntField(clazz, field);
608 gEventTypes.kEventVendorDefined = env->GetStaticIntField(clazz, field);
610 gEventTypes.kEventSessionReclaimed = env->GetStaticIntField(clazz, field);
613 gEventWhat.kWhatDrmEvent = env->GetStaticIntField(clazz, field);
615 gEventWhat.kWhatExpirationUpdate = env->GetStaticIntField(clazz, field);
617 gEventWhat.kWhatKeyStatusChange = env->GetStaticIntField(clazz, field);
620 gKeyTypes.kKeyTypeStreaming = env->GetStaticIntField(clazz, field);
622 gKeyTypes.kKeyTypeOffline = env->GetStaticIntField(clazz, field);
624 gKeyTypes.kKeyTypeRelease = env->GetStaticIntField(clazz, field);
627 gCertificateTypes.kCertificateTypeNone = env->GetStaticIntField(clazz, field);
629 gCertificateTypes.kCertificateTypeX509 = env->GetStaticIntField(clazz, field);
637 gKeyRequestTypes.kKeyRequestTypeInitial = env->GetStaticIntField(clazz, field);
639 gKeyRequestTypes.kKeyRequestTypeRenewal = env->GetStaticIntField(clazz, field);
641 gKeyRequestTypes.kKeyRequestTypeRelease = env->GetStaticIntField(clazz, field);
650 gFields.certificateClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
675 gFields.hashmapClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
678 gFields.stringClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
681 gFields.arraylistClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
685 gFields.stateException.classId = static_cast<jclass>(env->NewGlobalRef(clazz));
689 JNIEnv *env, jobject thiz,
693 jniThrowException(env, "java/lang/IllegalArgumentException", "uuid is null");
697 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
700 jniThrowException(env, "java/lang/IllegalArgumentException",
705 sp<JDrm> drm = new JDrm(env, thiz, uuid.array());
711 env,
717 sp<JNIDrmListener> listener = new JNIDrmListener(env, thiz, weak_this);
719 setDrm(env, thiz, drm);
723 JNIEnv *env, jobject thiz) {
724 android_media_MediaDrm_release(env, thiz);
728 JNIEnv *env, jobject /* thiz */, jbyteArray uuidObj, jstring jmimeType) {
731 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
735 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
739 env,
747 mimeType = JStringToString8(env, jmimeType);
754 JNIEnv *env, jobject thiz) {
755 sp<IDrm> drm = GetDrm(env, thiz);
758 jniThrowException(env, "java/lang/IllegalStateException",
766 if (throwExceptionAsNecessary(env, err, "Failed to open session")) {
770 return VectorToJByteArray(env, sessionId);
774 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
775 sp<IDrm> drm = GetDrm(env, thiz);
777 if (!CheckSession(env, drm, jsessionId)) {
781 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
785 throwExceptionAsNecessary(env, err, "Failed to close session");
789 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jinitData,
791 sp<IDrm> drm = GetDrm(env, thiz);
793 if (!CheckSession(env, drm, jsessionId)) {
797 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
801 initData = JByteArrayToVector(env, jinitData);
806 mimeType = JStringToString8(env, jmimeType);
817 jniThrowException(env, "java/lang/IllegalArgumentException",
825 optParams = HashMapToKeyedVector(env, joptParams, &isOK);
838 if (throwExceptionAsNecessary(env, err, "Failed to get key request")) {
849 keyObj = env->AllocObject(clazz);
850 jbyteArray jrequest = VectorToJByteArray(env, request);
851 env->SetObjectField(keyObj, gFields.keyRequest.data, jrequest);
853 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
854 env->SetObjectField(keyObj, gFields.keyRequest.defaultUrl, jdefaultUrl);
858 env->SetIntField(keyObj, gFields.keyRequest.requestType,
862 env->SetIntField(keyObj, gFields.keyRequest.requestType,
866 env->SetIntField(keyObj, gFields.keyRequest.requestType,
870 throwStateException(env, "DRM plugin failure: unknown key request type",
880 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jresponse) {
881 sp<IDrm> drm = GetDrm(env, thiz);
883 if (!CheckSession(env, drm, jsessionId)) {
887 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
890 jniThrowException(env, "java/lang/IllegalArgumentException",
894 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
899 if (throwExceptionAsNecessary(env, err, "Failed to handle key response")) {
902 return VectorToJByteArray(env, keySetId);
906 JNIEnv *env, jobject thiz, jbyteArray jkeysetId) {
907 sp<IDrm> drm = GetDrm(env, thiz);
910 jniThrowException(env, "java/lang/IllegalArgumentException",
915 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
919 throwExceptionAsNecessary(env, err, "Failed to remove keys");
923 JNIEnv *env, jobject thiz, jbyteArray jsessionId,
926 sp<IDrm> drm = GetDrm(env, thiz);
928 if (!CheckSession(env, drm, jsessionId)) {
933 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
937 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
938 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
942 throwExceptionAsNecessary(env, err, "Failed to restore keys");
946 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
947 sp<IDrm> drm = GetDrm(env, thiz);
949 if (!CheckSession(env, drm, jsessionId)) {
952 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
958 if (throwExceptionAsNecessary(env, err, "Failed to query key status")) {
962 return KeyedVectorToHashMap(env, infoMap);
966 JNIEnv *env, jobject thiz, jint jcertType, jstring jcertAuthority) {
967 sp<IDrm> drm = GetDrm(env, thiz);
970 jniThrowException(env, "java/lang/IllegalStateException",
987 String8 certAuthority = JStringToString8(env, jcertAuthority);
990 if (throwExceptionAsNecessary(env, err, "Failed to get provision request")) {
1001 provisionObj = env->AllocObject(clazz);
1002 jbyteArray jrequest = VectorToJByteArray(env, request);
1003 env->SetObjectField(provisionObj, gFields.provisionRequest.data, jrequest);
1005 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
1006 env
1013 JNIEnv *env, jobject thiz, jbyteArray jresponse) {
1014 sp<IDrm> drm = GetDrm(env, thiz);
1017 jniThrowException(env, "java/lang/IllegalStateException",
1023 jniThrowException(env, "java/lang/IllegalArgumentException",
1028 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
1039 certificateObj = env->AllocObject(clazz);
1040 jbyteArray jcertificate = VectorToJByteArray(env, certificate);
1041 env->SetObjectField(certificateObj, gFields.certificate.certificateData, jcertificate);
1043 jbyteArray jwrappedKey = VectorToJByteArray(env, wrappedKey);
1044 env->SetObjectField(certificateObj, gFields.certificate.wrappedPrivateKey, jwrappedKey);
1047 throwExceptionAsNecessary(env, err, "Failed to handle provision response");
1052 JNIEnv *env, jobject thiz) {
1053 sp<IDrm> drm = GetDrm(env, thiz);
1056 jniThrowException(env, "java/lang/IllegalStateException",
1063 throwExceptionAsNecessary(env, err, "Failed to handle provision response");
1068 JNIEnv *env, jobject thiz) {
1069 sp<IDrm> drm = GetDrm(env, thiz);
1072 jniThrowException(env, "java/lang/IllegalStateException",
1081 if (throwExceptionAsNecessary(env, err, "Failed to get secure stops")) {
1085 return ListOfVectorsToArrayListOfByteArray(env, secureStops);
1089 JNIEnv *env, jobject thiz, jbyteArray ssid) {
1090 sp<IDrm> drm = GetDrm(env, thiz);
1093 jniThrowException(env, "java/lang/IllegalStateException",
1100 status_t err = drm->getSecureStop(JByteArrayToVector(env, ssid), secureStop);
1102 if (throwExceptionAsNecessary(env, err, "Failed to get secure stop")) {
1106 return VectorToJByteArray(env, secureStop);
1110 JNIEnv *env, jobject thiz, jbyteArray jssRelease) {
1111 sp<IDrm> drm = GetDrm(env, thiz);
1114 jniThrowException(env, "java/lang/IllegalStateException",
1119 Vector<uint8_t> ssRelease(JByteArrayToVector(env, jssRelease));
1123 throwExceptionAsNecessary(env, err, "Failed to release secure stops");
1127 JNIEnv *env, jobject thiz) {
1128 sp<IDrm> drm = GetDrm(env, thiz);
1131 jniThrowException(env, "java/lang/IllegalStateException",
1138 throwExceptionAsNecessary(env, err, "Failed to release all secure stops");
1142 JNIEnv *env, jobject thiz, jstring jname) {
1143 sp<IDrm> drm = GetDrm(env, thiz);
1146 jniThrowException(env, "java/lang/IllegalStateException",
1152 jniThrowException(env, "java/lang/IllegalArgumentException",
1157 String8 name = JStringToString8(env, jname);
1162 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1166 return env->NewStringUTF(value.string());
1170 JNIEnv *env, jobject thiz, jstring jname) {
1171 sp<IDrm> drm = GetDrm(env, thiz);
1174 jniThrowException(env, "java/lang/IllegalStateException",
1180 jniThrowException(env, "java/lang/IllegalArgumentException",
1185 String8 name = JStringToString8(env, jname);
1190 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1194 return VectorToJByteArray(env, value);
1198 JNIEnv *env, jobject thiz, jstring jname, jstring jvalue) {
1199 sp<IDrm> drm = GetDrm(env, thiz);
1202 jniThrowException(env, "java/lang/IllegalStateException",
1208 jniThrowException(env, "java/lang/IllegalArgumentException",
1214 jniThrowException(env, "java/lang/IllegalArgumentException",
1219 String8 name = JStringToString8(env, jname);
1220 String8 value = JStringToString8(env, jvalue);
1224 throwExceptionAsNecessary(env, err, "Failed to set property");
1228 JNIEnv *env, jobject thiz, jstring jname, jbyteArray jvalue) {
1229 sp<IDrm> drm = GetDrm(env, thiz);
1232 jniThrowException(env, "java/lang/IllegalStateException",
1238 jniThrowException(env, "java/lang/IllegalArgumentException",
1244 jniThrowException(env, "java/lang/IllegalArgumentException",
1249 String8 name = JStringToString8(env, jname);
1250 Vector<uint8_t> value = JByteArrayToVector(env, jvalue);
1254 throwExceptionAsNecessary(env, err, "Failed to set property");
1258 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1261 sp<IDrm> drm = GetDrm(env, jdrm);
1263 if (!CheckSession(env, drm, jsessionId)) {
1268 jniThrowException(env, "java/lang/IllegalArgumentException",
1273 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1274 String8 algorithm = JStringToString8(env, jalgorithm);
1278 throwExceptionAsNecessary(env, err, "Failed to set cipher algorithm");
1282 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1285 sp<IDrm> drm = GetDrm(env, jdrm);
1287 if (!CheckSession(env, drm, jsessionId)) {
1292 jniThrowException(env, "java/lang/IllegalArgumentException",
1297 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1298 String8 algorithm = JStringToString8(env, jalgorithm);
1302 throwExceptionAsNecessary(env, err, "Failed to set mac algorithm");
1307 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1310 sp<IDrm> drm = GetDrm(env, jdrm);
1312 if (!CheckSession(env, drm, jsessionId)) {
1317 jniThrowException(env, "java/lang/IllegalArgumentException",
1322 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1323 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1324 Vector<uint8_t> input(JByteArrayToVector(env, jinput));
1325 Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
1330 if (throwExceptionAsNecessary(env, err, "Failed to encrypt")) {
1334 return VectorToJByteArray(env, output);
1338 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1341 sp<IDrm> drm = GetDrm(env, jdrm);
1343 if (!CheckSession(env, drm, jsessionId)) {
1348 jniThrowException(env, "java/lang/IllegalArgumentException",
1353 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1354 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1355 Vector<uint8_t> input(JByteArrayToVector(env, jinput));
1356 Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
1360 if (throwExceptionAsNecessary(env, err, "Failed to decrypt")) {
1364 return VectorToJByteArray(env, output);
1368 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1371 sp<IDrm> drm = GetDrm(env, jdrm);
1373 if (!CheckSession(env, drm, jsessionId)) {
1378 jniThrowException(env, "java/lang/IllegalArgumentException",
1383 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1384 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1385 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1390 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1394 return VectorToJByteArray(env, signature);
1398 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1401 sp<IDrm> drm = GetDrm(env, jdrm);
1403 if (!CheckSession(env, drm, jsessionId)) {
1408 jniThrowException(env, "java/lang/IllegalArgumentException",
1413 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1414 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1415 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1416 Vector<uint8_t> signature(JByteArrayToVector(env, jsignature));
1421 throwExceptionAsNecessary(env, err, "Failed to verify");
1427 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1430 sp<IDrm> drm = GetDrm(env, jdrm);
1432 if (!CheckSession(env, drm, jsessionId)) {
1437 jniThrowException(env, "java/lang/IllegalArgumentException",
1442 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1443 String8 algorithm = JStringToString8(env, jalgorithm);
1444 Vector<uint8_t> wrappedKey(JByteArrayToVector(env, jwrappedKey));
1445 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1450 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1454 return VectorToJByteArray(env, signature);
1550 int register_android_media_Drm(JNIEnv *env) {
1551 return AndroidRuntime::registerNativeMethods(env,
