Lines Matching defs:env
45 var = env->FindClass(className); \
49 var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
53 var = env->GetMethodID(clazz, fieldName, fieldDescriptor); \
57 var = env->GetStaticFieldID(clazz, fieldName, fieldDescriptor); \
61 var = env->GetStaticMethodID(clazz, fieldName, fieldDescriptor); \
65 var = env->GetStaticObjectField(clazz, fieldName); \
192 jobject nativeToJavaPersistableBundle(JNIEnv *env, jobject thiz,
194 if (env == NULL || thiz == NULL || nativeBundle == NULL) {
201 jobject jParcel = android::createJavaParcelObject(env);
207 android::Parcel* nativeParcel = android::parcelForJavaObject(env, jParcel);
220 jobject newBundle = env->CallObjectMethod(gFields.bundleCreator,
238 JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
247 JNIDrmListener::JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
251 jclass clazz = env->GetObjectClass(thiz);
254 jniThrowException(env, "java/lang/Exception",
258 mClass = (jclass)env->NewGlobalRef(clazz);
262 mObject = env->NewGlobalRef(weak_thiz);
268 JNIEnv *env = AndroidRuntime::getJNIEnv();
269 env->DeleteGlobalRef(mObject);
270 env->DeleteGlobalRef(mClass);
312 JNIEnv *env = AndroidRuntime::getJNIEnv();
314 jobject jParcel = createJavaParcelObject(env);
316 Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
318 env->CallStaticVoidMethod(mClass, gFields.post_event, mObject,
320 env->DeleteLocalRef(jParcel);
324 if (env->ExceptionCheck()) {
326 LOGW_EX(env);
327 env->ExceptionClear();
331 static void throwStateException(JNIEnv *env, const char *msg, status_t err) {
334 jobject exception = env->NewObject(gFields.stateException.classId,
336 env->NewStringUTF(msg));
337 env->Throw(static_cast<jthrowable>(exception));
341 JNIEnv *env, status_t err, const char *msg = NULL) {
381 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
384 jniThrowException(env, "android/media/NotProvisionedException", msg);
387 jniThrowException(env, "android/media/ResourceBusyException", msg);
390 jniThrowException(env, "android/media/DeniedByServerException", msg);
393 jniThrowException(env, "android/media/MediaDrmResetException",
406 throwStateException(env, msg, err);
412 static sp<IDrm> GetDrm(JNIEnv *env, jobject thiz) {
413 JDrm *jdrm = (JDrm *)env->GetLongField(thiz, gFields.context);
418 JNIEnv *env, jobject thiz, const uint8_t uuid[16],
420 mObject = env->NewWeakGlobalRef(thiz);
428 JNIEnv *env = AndroidRuntime::getJNIEnv();
430 env->DeleteWeakGlobalRef(mObject);
511 static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
513 size_t length = env->GetArrayLength(byteArray);
515 env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
519 static jbyteArray VectorToJByteArray(JNIEnv *env, Vector<uint8_t> const &vector) {
521 jbyteArray result = env->NewByteArray(length);
523 env->SetByteArrayRegion(result, 0, length, (jbyte *)vector.array());
528 static String8 JStringToString8(JNIEnv *env, jstring const &jstr) {
531 const char *s = env->GetStringUTFChars(jstr, NULL);
534 env->ReleaseStringUTFChars(jstr, s);
552 JNIEnv *env, jobject &hashMap, bool* pIsOK) {
557 jobject entrySet = env->CallObjectMethod(hashMap, gFields.hashmap.entrySet);
559 jobject iterator = env->CallObjectMethod(entrySet, gFields.set.iterator);
561 jboolean hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
563 jobject entry = env->CallObjectMethod(iterator, gFields.iterator.next);
565 jobject obj = env->CallObjectMethod(entry, gFields.entry.getKey);
566 if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
567 jniThrowException(env, "java/lang/IllegalArgumentException",
569 env->DeleteLocalRef(entry);
575 obj = env->CallObjectMethod(entry, gFields.entry.getValue);
576 if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
577 jniThrowException(env, "java/lang/IllegalArgumentException",
579 env->DeleteLocalRef(entry);
585 String8 key = JStringToString8(env, jkey);
586 String8 value = JStringToString8(env, jvalue);
589 env->DeleteLocalRef(jkey);
590 env->DeleteLocalRef(jvalue);
591 hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
593 env->DeleteLocalRef(entry);
595 env->DeleteLocalRef(iterator);
597 env->DeleteLocalRef(entrySet);
602 static jobject KeyedVectorToHashMap (JNIEnv *env, KeyedVector<String8, String8> const &map) {
604 jobject hashMap = env->NewObject(clazz, gFields.hashmap.init);
606 jstring jkey = env->NewStringUTF(map.keyAt(i).string());
607 jstring jvalue = env->NewStringUTF(map.valueAt(i).string());
608 env->CallObjectMethod(hashMap, gFields.hashmap.put, jkey, jvalue);
609 env->DeleteLocalRef(jkey);
610 env->DeleteLocalRef(jvalue);
615 static jobject ListOfVectorsToArrayListOfByteArray(JNIEnv *env,
618 jobject arrayList = env->NewObject(clazz, gFields.arraylist.init);
621 jbyteArray byteArray = VectorToJByteArray(env, *iter);
622 env->CallBooleanMethod(arrayList, gFields.arraylist.add, byteArray);
623 env->DeleteLocalRef(byteArray);
635 JNIEnv *env, jobject thiz, const sp<JDrm> &drm) {
636 sp<JDrm> old = (JDrm *)env->GetLongField(thiz, gFields.context);
643 env->SetLongField(thiz, gFields.context, reinterpret_cast<jlong>(drm.get()));
648 static bool CheckDrm(JNIEnv *env, const sp<IDrm> &drm) {
650 jniThrowException(env, "java/lang/IllegalStateException", "MediaDrm obj is null");
656 static bool CheckSession(JNIEnv *env, const sp<IDrm> &drm, jbyteArray const &jsessionId)
658 if (!CheckDrm(env, drm)) {
663 jniThrowException(env, "java/lang/IllegalArgumentException", "sessionId is null");
669 static void android_media_MediaDrm_native_release(JNIEnv *env, jobject thiz) {
670 sp<JDrm> drm = setDrm(env, thiz, NULL);
677 static void android_media_MediaDrm_native_init(JNIEnv *env) {
686 gEventTypes.kEventProvisionRequired = env->GetStaticIntField(clazz, field);
688 gEventTypes.kEventKeyRequired = env->GetStaticIntField(clazz, field);
690 gEventTypes.kEventKeyExpired = env->GetStaticIntField(clazz, field);
692 gEventTypes.kEventVendorDefined = env->GetStaticIntField(clazz, field);
694 gEventTypes.kEventSessionReclaimed = env->GetStaticIntField(clazz, field);
697 gEventWhat.kWhatDrmEvent = env->GetStaticIntField(clazz, field);
699 gEventWhat.kWhatExpirationUpdate = env->GetStaticIntField(clazz, field);
701 gEventWhat.kWhatKeyStatusChange = env->GetStaticIntField(clazz, field);
704 gKeyTypes.kKeyTypeStreaming = env->GetStaticIntField(clazz, field);
706 gKeyTypes.kKeyTypeOffline = env->GetStaticIntField(clazz, field);
708 gKeyTypes.kKeyTypeRelease = env->GetStaticIntField(clazz, field);
711 gCertificateTypes.kCertificateTypeNone = env->GetStaticIntField(clazz, field);
713 gCertificateTypes.kCertificateTypeX509 = env->GetStaticIntField(clazz, field);
716 gHdcpLevels.kHdcpLevelUnknown = env->GetStaticIntField(clazz, field);
718 gHdcpLevels.kHdcpNone = env->GetStaticIntField(clazz, field);
720 gHdcpLevels.kHdcpV1 = env->GetStaticIntField(clazz, field);
722 gHdcpLevels.kHdcpV2 = env->GetStaticIntField(clazz, field);
724 gHdcpLevels.kHdcpV2_1 = env->GetStaticIntField(clazz, field);
726 gHdcpLevels.kHdcpV2_2 = env->GetStaticIntField(clazz, field);
728 gHdcpLevels.kHdcpNoOutput = env->GetStaticIntField(clazz, field);
731 gSecurityLevels.kSecurityLevelUnknown = env->GetStaticIntField(clazz, field);
733 gSecurityLevels.kSecurityLevelSwSecureCrypto = env->GetStaticIntField(clazz, field);
735 gSecurityLevels.kSecurityLevelSwSecureDecode = env->GetStaticIntField(clazz, field);
737 gSecurityLevels.kSecurityLevelHwSecureCrypto = env->GetStaticIntField(clazz, field);
739 gSecurityLevels.kSecurityLevelHwSecureDecode = env->GetStaticIntField(clazz, field);
741 gSecurityLevels.kSecurityLevelHwSecureAll = env->GetStaticIntField(clazz, field);
745 gSecurityLevels.kSecurityLevelMax = env->CallStaticIntMethod(clazz, getMaxSecurityLevel);
753 gKeyRequestTypes.kKeyRequestTypeInitial = env->GetStaticIntField(clazz, field);
755 gKeyRequestTypes.kKeyRequestTypeRenewal = env->GetStaticIntField(clazz, field);
757 gKeyRequestTypes.kKeyRequestTypeRelease = env->GetStaticIntField(clazz, field);
759 gKeyRequestTypes.kKeyRequestTypeNone = env->GetStaticIntField(clazz, field);
761 gKeyRequestTypes.kKeyRequestTypeUpdate = env->GetStaticIntField(clazz, field);
770 gFields.certificateClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
779 gFields.bundleCreator = static_cast<jobject>(env->NewGlobalRef(bundleCreator));
783 gFields.parcelCreatorClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
808 gFields.hashmapClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
811 gFields.stringClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
814 gFields.arraylistClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
818 gFields.stateException.classId = static_cast<jclass>(env->NewGlobalRef(clazz));
822 JNIEnv *env, jobject thiz,
826 jniThrowException(env, "java/lang/IllegalArgumentException", "uuid is null");
830 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
833 jniThrowException(env, "java/lang/IllegalArgumentException",
840 jniThrowException(env, "java/lang/IllegalArgumentException",
845 packageName = JStringToString8(env, jappPackageName);
846 sp<JDrm> drm = new JDrm(env, thiz, uuid.array(), packageName);
852 env,
858 sp<JNIDrmListener> listener = new JNIDrmListener(env, thiz, weak_this);
860 setDrm(env, thiz, drm);
864 JNIEnv *env, jobject /* thiz */, jbyteArray uuidObj, jstring jmimeType) {
867 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
871 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
875 env,
883 mimeType = JStringToString8(env, jmimeType);
890 JNIEnv *env, jobject thiz, jint jlevel) {
891 sp<IDrm> drm = GetDrm(env, thiz);
894 jniThrowException(env, "java/lang/IllegalStateException",
915 jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid security level");
921 if (throwExceptionAsNecessary(env, err, "Failed to open session")) {
925 return VectorToJByteArray(env, sessionId);
929 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
930 sp<IDrm> drm = GetDrm(env, thiz);
932 if (!CheckSession(env, drm, jsessionId)) {
936 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
940 throwExceptionAsNecessary(env, err, "Failed to close session");
944 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jinitData,
946 sp<IDrm> drm = GetDrm(env, thiz);
948 if (!CheckSession(env, drm, jsessionId)) {
952 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
956 initData = JByteArrayToVector(env, jinitData);
961 mimeType = JStringToString8(env, jmimeType);
972 jniThrowException(env, "java/lang/IllegalArgumentException",
980 optParams = HashMapToKeyedVector(env, joptParams, &isOK);
993 if (throwExceptionAsNecessary(env, err, "Failed to get key request")) {
1004 keyObj = env->AllocObject(clazz);
1005 jbyteArray jrequest = VectorToJByteArray(env, request);
1006 env->SetObjectField(keyObj, gFields.keyRequest.data, jrequest);
1008 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
1009 env->SetObjectField(keyObj, gFields.keyRequest.defaultUrl, jdefaultUrl);
1013 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1017 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1021 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1025 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1029 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1034 throwStateException(env, "DRM plugin failure: unknown key request type",
1044 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jresponse) {
1045 sp<IDrm> drm = GetDrm(env, thiz);
1047 if (!CheckSession(env, drm, jsessionId)) {
1051 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1054 jniThrowException(env, "java/lang/IllegalArgumentException",
1058 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
1063 if (throwExceptionAsNecessary(env, err, "Failed to handle key response")) {
1066 return VectorToJByteArray(env, keySetId);
1070 JNIEnv *env, jobject thiz, jbyteArray jkeysetId) {
1071 sp<IDrm> drm = GetDrm(env, thiz);
1074 jniThrowException(env, "java/lang/IllegalArgumentException",
1079 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
1083 throwExceptionAsNecessary(env, err, "Failed to remove keys");
1087 JNIEnv *env, jobject thiz, jbyteArray jsessionId,
1090 sp<IDrm> drm = GetDrm(env, thiz);
1092 if (!CheckSession(env, drm, jsessionId)) {
1097 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
1101 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1102 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
1106 throwExceptionAsNecessary(env, err, "Failed to restore keys");
1110 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
1111 sp<IDrm> drm = GetDrm(env, thiz);
1113 if (!CheckSession(env, drm, jsessionId)) {
1116 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1122 if (throwExceptionAsNecessary(env, err, "Failed to query key status")) {
1126 return KeyedVectorToHashMap(env, infoMap);
1130 JNIEnv *env, jobject thiz, jint jcertType, jstring jcertAuthority) {
1131 sp<IDrm> drm = GetDrm(env, thiz);
1133 if (!CheckDrm(env, drm)) {
1149 String8 certAuthority = JStringToString8(env, jcertAuthority);
1152 if (throwExceptionAsNecessary(env, err, "Failed to get provision request")) {
1163 provisionObj = env->AllocObject(clazz);
1164 jbyteArray jrequest = VectorToJByteArray(env, request);
1165 env->SetObjectField(provisionObj, gFields.provisionRequest.data, jrequest);
1167 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
1168 env->SetObjectField(provisionObj, gFields.provisionRequest.defaultUrl, jdefaultUrl);
1175 JNIEnv *env, jobject thiz, jbyteArray jresponse) {
1176 sp<IDrm> drm = GetDrm(env, thiz);
1178 if (!CheckDrm(env, drm)) {
1183 jniThrowException(env, "java/lang/IllegalArgumentException",
1188 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
1199 certificateObj = env->AllocObject(clazz);
1200 jbyteArray jcertificate = VectorToJByteArray(env, certificate);
1201 env->SetObjectField(certificateObj, gFields.certificate.certificateData, jcertificate);
1203 jbyteArray jwrappedKey = VectorToJByteArray(env, wrappedKey);
1204 env->SetObjectField(certificateObj, gFields.certificate.wrappedPrivateKey, jwrappedKey);
1207 throwExceptionAsNecessary(env, err, "Failed to handle provision response");
1212 JNIEnv *env, jobject thiz) {
1213 sp<IDrm> drm = GetDrm(env, thiz);
1215 if (!CheckDrm(env, drm)) {
1223 if (throwExceptionAsNecessary(env, err, "Failed to get secure stops")) {
1227 return ListOfVectorsToArrayListOfByteArray(env, secureStops);
1231 JNIEnv *env, jobject thiz) {
1232 sp<IDrm> drm = GetDrm(env, thiz);
1235 jniThrowException(env, "java/lang/IllegalStateException",
1244 if (throwExceptionAsNecessary(env, err, "Failed to get secure stop Ids")) {
1248 return ListOfVectorsToArrayListOfByteArray(env, secureStopIds);
1252 JNIEnv *env, jobject thiz, jbyteArray ssid) {
1253 sp<IDrm> drm = GetDrm(env, thiz);
1255 if (!CheckDrm(env, drm)) {
1261 status_t err = drm->getSecureStop(JByteArrayToVector(env, ssid), secureStop);
1263 if (throwExceptionAsNecessary(env, err, "Failed to get secure stop")) {
1267 return VectorToJByteArray(env, secureStop);
1271 JNIEnv *env, jobject thiz, jbyteArray jssRelease) {
1272 sp<IDrm> drm = GetDrm(env, thiz);
1274 if (!CheckDrm(env, drm)) {
1278 Vector<uint8_t> ssRelease(JByteArrayToVector(env, jssRelease));
1282 throwExceptionAsNecessary(env, err, "Failed to release secure stops");
1286 JNIEnv *env, jobject thiz, jbyteArray ssid) {
1287 sp<IDrm> drm = GetDrm(env, thiz);
1290 jniThrowException(env, "java/lang/IllegalStateException",
1295 status_t err = drm->removeSecureStop(JByteArrayToVector(env, ssid));
1297 throwExceptionAsNecessary(env, err, "Failed to remove secure stop");
1301 JNIEnv *env, jobject thiz) {
1302 sp<IDrm> drm = GetDrm(env, thiz);
1304 if (!CheckDrm(env, drm)) {
1310 throwExceptionAsNecessary(env, err, "Failed to remove all secure stops");
1334 static jint android_media_MediaDrm_getConnectedHdcpLevel(JNIEnv *env,
1336 sp<IDrm> drm = GetDrm(env, thiz);
1338 if (!CheckDrm(env, drm)) {
1347 if (throwExceptionAsNecessary(env, err, "Failed to get HDCP levels")) {
1353 static jint android_media_MediaDrm_getMaxHdcpLevel(JNIEnv *env,
1355 sp<IDrm> drm = GetDrm(env, thiz);
1357 if (!CheckDrm(env, drm)) {
1366 if (throwExceptionAsNecessary(env, err, "Failed to get HDCP levels")) {
1372 static jint android_media_MediaDrm_getOpenSessionCount(JNIEnv *env,
1374 sp<IDrm> drm = GetDrm(env, thiz);
1376 if (!CheckDrm(env, drm)) {
1383 if (throwExceptionAsNecessary(env, err, "Failed to get number of sessions")) {
1389 static jint android_media_MediaDrm_getMaxSessionCount(JNIEnv *env,
1391 sp<IDrm> drm = GetDrm(env, thiz);
1393 if (!CheckDrm(env, drm)) {
1400 if (throwExceptionAsNecessary(env, err, "Failed to get number of sessions")) {
1406 static jint android_media_MediaDrm_getSecurityLevel(JNIEnv *env,
1408 sp<IDrm> drm = GetDrm(env, thiz);
1410 if (!CheckSession(env, drm, jsessionId)) {
1414 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1420 if (throwExceptionAsNecessary(env, err, "Failed to get security level")) {
1442 JNIEnv *env, jobject thiz, jstring jname) {
1443 sp<IDrm> drm = GetDrm(env, thiz);
1445 if (!CheckDrm(env, drm)) {
1450 jniThrowException(env, "java/lang/IllegalArgumentException",
1455 String8 name = JStringToString8(env, jname);
1460 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1464 return env->NewStringUTF(value.string());
1468 JNIEnv *env, jobject thiz, jstring jname) {
1469 sp<IDrm> drm = GetDrm(env, thiz);
1471 if (!CheckDrm(env, drm)) {
1476 jniThrowException(env, "java/lang/IllegalArgumentException",
1481 String8 name = JStringToString8(env, jname);
1486 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1490 return VectorToJByteArray(env, value);
1494 JNIEnv *env, jobject thiz, jstring jname, jstring jvalue) {
1495 sp<IDrm> drm = GetDrm(env, thiz);
1497 if (!CheckDrm(env, drm)) {
1502 jniThrowException(env, "java/lang/IllegalArgumentException",
1508 jniThrowException(env, "java/lang/IllegalArgumentException",
1513 String8 name = JStringToString8(env, jname);
1514 String8 value = JStringToString8(env, jvalue);
1518 throwExceptionAsNecessary(env, err, "Failed to set property");
1522 JNIEnv *env, jobject thiz, jstring jname, jbyteArray jvalue) {
1523 sp<IDrm> drm = GetDrm(env, thiz);
1525 if (!CheckDrm(env, drm)) {
1530 jniThrowException(env, "java/lang/IllegalArgumentException",
1536 jniThrowException(env, "java/lang/IllegalArgumentException",
1541 String8 name = JStringToString8(env, jname);
1542 Vector<uint8_t> value = JByteArrayToVector(env, jvalue);
1546 throwExceptionAsNecessary(env, err, "Failed to set property");
1550 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1553 sp<IDrm> drm = GetDrm(env, jdrm);
1555 if (!CheckSession(env, drm, jsessionId)) {
1560 jniThrowException(env, "java/lang/IllegalArgumentException",
1565 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1566 String8 algorithm = JStringToString8(env, jalgorithm);
1570 throwExceptionAsNecessary(env, err, "Failed to set cipher algorithm");
1574 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1577 sp<IDrm> drm = GetDrm(env, jdrm);
1579 if (!CheckSession(env, drm, jsessionId)) {
1584 jniThrowException(env, "java/lang/IllegalArgumentException",
1589 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1590 String8 algorithm = JStringToString8(env, jalgorithm);
1594 throwExceptionAsNecessary(env, err, "Failed to set mac algorithm");
1599 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1602 sp<IDrm> drm = GetDrm(env, jdrm);
1604 if (!CheckSession(env, drm, jsessionId)) {
1609 jniThrowException(env, "java/lang/IllegalArgumentException",
1614 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1615 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1616 Vector<uint8_t> input(JByteArrayToVector(env, jinput));
1617 Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
1622 if (throwExceptionAsNecessary(env, err, "Failed to encrypt")) {
1626 return VectorToJByteArray(env, output);
1630 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1633 sp<IDrm> drm = GetDrm(env, jdrm);
1635 if (!CheckSession(env, drm, jsessionId)) {
1640 jniThrowException(env, "java/lang/IllegalArgumentException",
1645 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1646 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1647 Vector<uint8_t> input(JByteArrayToVector(env, jinput));
1648 Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
1652 if (throwExceptionAsNecessary(env, err, "Failed to decrypt")) {
1656 return VectorToJByteArray(env, output);
1660 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1663 sp<IDrm> drm = GetDrm(env, jdrm);
1665 if (!CheckSession(env, drm, jsessionId)) {
1670 jniThrowException(env, "java/lang/IllegalArgumentException",
1675 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1676 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1677 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1682 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1686 return VectorToJByteArray(env, signature);
1690 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1693 sp<IDrm> drm = GetDrm(env, jdrm);
1695 if (!CheckSession(env, drm, jsessionId)) {
1700 jniThrowException(env, "java/lang/IllegalArgumentException",
1705 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1706 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1707 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1708 Vector<uint8_t> signature(JByteArrayToVector(env, jsignature));
1713 throwExceptionAsNecessary(env, err, "Failed to verify");
1718 android_media_MediaDrm_native_getMetrics(JNIEnv *env, jobject thiz)
1720 sp<IDrm> drm = GetDrm(env, thiz);
1722 jniThrowException(env, "java/lang/IllegalStateException",
1735 return nativeToJavaPersistableBundle(env, thiz, &metrics);
1739 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1742 sp<IDrm> drm = GetDrm(env, jdrm);
1744 if (!CheckSession(env, drm, jsessionId)) {
1749 jniThrowException(env, "java/lang/IllegalArgumentException",
1754 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1755 String8 algorithm = JStringToString8(env, jalgorithm);
1756 Vector<uint8_t> wrappedKey(JByteArrayToVector(env, jwrappedKey));
1757 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1762 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1766 return VectorToJByteArray(env, signature);
1881 int register_android_media_Drm(JNIEnv *env) {
1882 return AndroidRuntime::registerNativeMethods(env,