1 /*
2 * Copyright 2013, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 //#define LOG_NDEBUG 0
18 #define LOG_TAG "MediaDrm-JNI"
19 #include <utils/Log.h>
20
21 #include "android_media_MediaDrm.h"
22 #include "android_media_MediaMetricsJNI.h"
23 #include "android_os_Parcel.h"
24 #include "android_runtime/AndroidRuntime.h"
25 #include "android_runtime/Log.h"
26 #include "android_os_Parcel.h"
27 #include "jni.h"
28 #include <nativehelper/JNIHelp.h>
29
30 #include <binder/IServiceManager.h>
31 #include <binder/Parcel.h>
32 #include <binder/PersistableBundle.h>
33 #include <cutils/properties.h>
34 #include <media/stagefright/foundation/ADebug.h>
35 #include <media/stagefright/MediaErrors.h>
36 #include <mediadrm/IDrm.h>
37 #include <mediadrm/IMediaDrmService.h>
38
39 using ::android::os::PersistableBundle;
40
41
42 namespace android {
43
44 #define FIND_CLASS(var, className) \
45 var = env->FindClass(className); \
46 LOG_FATAL_IF(! (var), "Unable to find class " className);
47
48 #define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
49 var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
50 LOG_FATAL_IF(! (var), "Unable to find field " fieldName);
51
52 #define GET_METHOD_ID(var, clazz, fieldName, fieldDescriptor) \
53 var = env->GetMethodID(clazz, fieldName, fieldDescriptor); \
54 LOG_FATAL_IF(! (var), "Unable to find method " fieldName);
55
56 #define GET_STATIC_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
57 var = env->GetStaticFieldID(clazz, fieldName, fieldDescriptor); \
58 LOG_FATAL_IF(! (var), "Unable to find field " fieldName);
59
60 #define GET_STATIC_METHOD_ID(var, clazz, fieldName, fieldDescriptor) \
61 var = env->GetStaticMethodID(clazz, fieldName, fieldDescriptor); \
62 LOG_FATAL_IF(! (var), "Unable to find static method " fieldName);
63
64 #define GET_STATIC_OBJECT_FIELD(var, clazz, fieldName) \
65 var = env->GetStaticObjectField(clazz, fieldName); \
66 LOG_FATAL_IF(! (var), "Unable to find static object field " fieldName);
67
68
69 struct RequestFields {
70 jfieldID data;
71 jfieldID defaultUrl;
72 jfieldID requestType;
73 };
74
75 struct ArrayListFields {
76 jmethodID init;
77 jmethodID add;
78 };
79
80 struct HashmapFields {
81 jmethodID init;
82 jmethodID get;
83 jmethodID put;
84 jmethodID entrySet;
85 };
86
87 struct SetFields {
88 jmethodID iterator;
89 };
90
91 struct IteratorFields {
92 jmethodID next;
93 jmethodID hasNext;
94 };
95
96 struct EntryFields {
97 jmethodID getKey;
98 jmethodID getValue;
99 };
100
101 struct EventTypes {
102 jint kEventProvisionRequired;
103 jint kEventKeyRequired;
104 jint kEventKeyExpired;
105 jint kEventVendorDefined;
106 jint kEventSessionReclaimed;
107 } gEventTypes;
108
109 struct EventWhat {
110 jint kWhatDrmEvent;
111 jint kWhatExpirationUpdate;
112 jint kWhatKeyStatusChange;
113 } gEventWhat;
114
115 struct KeyTypes {
116 jint kKeyTypeStreaming;
117 jint kKeyTypeOffline;
118 jint kKeyTypeRelease;
119 } gKeyTypes;
120
121 struct KeyRequestTypes {
122 jint kKeyRequestTypeInitial;
123 jint kKeyRequestTypeRenewal;
124 jint kKeyRequestTypeRelease;
125 jint kKeyRequestTypeNone;
126 jint kKeyRequestTypeUpdate;
127 } gKeyRequestTypes;
128
129 struct CertificateTypes {
130 jint kCertificateTypeNone;
131 jint kCertificateTypeX509;
132 } gCertificateTypes;
133
134 struct CertificateFields {
135 jfieldID wrappedPrivateKey;
136 jfieldID certificateData;
137 };
138
139 struct StateExceptionFields {
140 jmethodID init;
141 jclass classId;
142 };
143
144 struct HDCPLevels {
145 jint kHdcpLevelUnknown;
146 jint kHdcpNone;
147 jint kHdcpV1;
148 jint kHdcpV2;
149 jint kHdcpV2_1;
150 jint kHdcpV2_2;
151 jint kHdcpNoOutput;
152 } gHdcpLevels;
153
154 struct SecurityLevels {
155 jint kSecurityLevelUnknown;
156 jint kSecurityLevelMax;
157 jint kSecurityLevelSwSecureCrypto;
158 jint kSecurityLevelSwSecureDecode;
159 jint kSecurityLevelHwSecureCrypto;
160 jint kSecurityLevelHwSecureDecode;
161 jint kSecurityLevelHwSecureAll;
162 } gSecurityLevels;
163
164
165 struct fields_t {
166 jfieldID context;
167 jmethodID post_event;
168 RequestFields keyRequest;
169 RequestFields provisionRequest;
170 ArrayListFields arraylist;
171 HashmapFields hashmap;
172 SetFields set;
173 IteratorFields iterator;
174 EntryFields entry;
175 CertificateFields certificate;
176 StateExceptionFields stateException;
177 jclass certificateClassId;
178 jclass hashmapClassId;
179 jclass arraylistClassId;
180 jclass stringClassId;
181 jobject bundleCreator;
182 jmethodID createFromParcelId;
183 jclass parcelCreatorClassId;
184 };
185
186 static fields_t gFields;
187
188 namespace {
189
190 // Helper function to convert a native PersistableBundle to a Java
191 // PersistableBundle.
nativeToJavaPersistableBundle(JNIEnv * env,jobject thiz,PersistableBundle * nativeBundle)192 jobject nativeToJavaPersistableBundle(JNIEnv *env, jobject thiz,
193 PersistableBundle* nativeBundle) {
194 if (env == NULL || thiz == NULL || nativeBundle == NULL) {
195 ALOGE("Unexpected NULL parmeter");
196 return NULL;
197 }
198
199 // Create a Java parcel with the native parcel data.
200 // Then create a new PersistableBundle with that parcel as a parameter.
201 jobject jParcel = android::createJavaParcelObject(env);
202 if (jParcel == NULL) {
203 ALOGE("Failed to create a Java Parcel.");
204 return NULL;
205 }
206
207 android::Parcel* nativeParcel = android::parcelForJavaObject(env, jParcel);
208 if (nativeParcel == NULL) {
209 ALOGE("Failed to get the native Parcel.");
210 return NULL;
211 }
212
213 android::status_t result = nativeBundle->writeToParcel(nativeParcel);
214 nativeParcel->setDataPosition(0);
215 if (result != android::OK) {
216 ALOGE("Failed to write nativeBundle to Parcel: %d.", result);
217 return NULL;
218 }
219
220 jobject newBundle = env->CallObjectMethod(gFields.bundleCreator,
221 gFields.createFromParcelId,
222 jParcel);
223 if (newBundle == NULL) {
224 ALOGE("Failed to create a new PersistableBundle "
225 "from the createFromParcel call.");
226 }
227
228 return newBundle;
229 }
230
231 } // namespace anonymous
232
233 // ----------------------------------------------------------------------------
234 // ref-counted object for callbacks
235 class JNIDrmListener: public DrmListener
236 {
237 public:
238 JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
239 ~JNIDrmListener();
240 virtual void notify(DrmPlugin::EventType eventType, int extra, const Parcel *obj = NULL);
241 private:
242 JNIDrmListener();
243 jclass mClass; // Reference to MediaDrm class
244 jobject mObject; // Weak ref to MediaDrm Java object to call on
245 };
246
JNIDrmListener(JNIEnv * env,jobject thiz,jobject weak_thiz)247 JNIDrmListener::JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
248 {
249 // Hold onto the MediaDrm class for use in calling the static method
250 // that posts events to the application thread.
251 jclass clazz = env->GetObjectClass(thiz);
252 if (clazz == NULL) {
253 ALOGE("Can't find android/media/MediaDrm");
254 jniThrowException(env, "java/lang/Exception",
255 "Can't find android/media/MediaDrm");
256 return;
257 }
258 mClass = (jclass)env->NewGlobalRef(clazz);
259
260 // We use a weak reference so the MediaDrm object can be garbage collected.
261 // The reference is only used as a proxy for callbacks.
262 mObject = env->NewGlobalRef(weak_thiz);
263 }
264
~JNIDrmListener()265 JNIDrmListener::~JNIDrmListener()
266 {
267 // remove global references
268 JNIEnv *env = AndroidRuntime::getJNIEnv();
269 env->DeleteGlobalRef(mObject);
270 env->DeleteGlobalRef(mClass);
271 }
272
notify(DrmPlugin::EventType eventType,int extra,const Parcel * obj)273 void JNIDrmListener::notify(DrmPlugin::EventType eventType, int extra,
274 const Parcel *obj)
275 {
276 jint jwhat;
277 jint jeventType = 0;
278
279 // translate DrmPlugin event types into their java equivalents
280 switch (eventType) {
281 case DrmPlugin::kDrmPluginEventProvisionRequired:
282 jwhat = gEventWhat.kWhatDrmEvent;
283 jeventType = gEventTypes.kEventProvisionRequired;
284 break;
285 case DrmPlugin::kDrmPluginEventKeyNeeded:
286 jwhat = gEventWhat.kWhatDrmEvent;
287 jeventType = gEventTypes.kEventKeyRequired;
288 break;
289 case DrmPlugin::kDrmPluginEventKeyExpired:
290 jwhat = gEventWhat.kWhatDrmEvent;
291 jeventType = gEventTypes.kEventKeyExpired;
292 break;
293 case DrmPlugin::kDrmPluginEventVendorDefined:
294 jwhat = gEventWhat.kWhatDrmEvent;
295 jeventType = gEventTypes.kEventVendorDefined;
296 break;
297 case DrmPlugin::kDrmPluginEventSessionReclaimed:
298 jwhat = gEventWhat.kWhatDrmEvent;
299 jeventType = gEventTypes.kEventSessionReclaimed;
300 break;
301 case DrmPlugin::kDrmPluginEventExpirationUpdate:
302 jwhat = gEventWhat.kWhatExpirationUpdate;
303 break;
304 case DrmPlugin::kDrmPluginEventKeysChange:
305 jwhat = gEventWhat.kWhatKeyStatusChange;
306 break;
307 default:
308 ALOGE("Invalid event DrmPlugin::EventType %d, ignored", (int)eventType);
309 return;
310 }
311
312 JNIEnv *env = AndroidRuntime::getJNIEnv();
313 if (obj && obj->dataSize() > 0) {
314 jobject jParcel = createJavaParcelObject(env);
315 if (jParcel != NULL) {
316 Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
317 nativeParcel->setData(obj->data(), obj->dataSize());
318 env->CallStaticVoidMethod(mClass, gFields.post_event, mObject,
319 jwhat, jeventType, extra, jParcel);
320 env->DeleteLocalRef(jParcel);
321 }
322 }
323
324 if (env->ExceptionCheck()) {
325 ALOGW("An exception occurred while notifying an event.");
326 LOGW_EX(env);
327 env->ExceptionClear();
328 }
329 }
330
throwStateException(JNIEnv * env,const char * msg,status_t err)331 static void throwStateException(JNIEnv *env, const char *msg, status_t err) {
332 ALOGE("Illegal state exception: %s (%d)", msg, err);
333
334 jobject exception = env->NewObject(gFields.stateException.classId,
335 gFields.stateException.init, static_cast<int>(err),
336 env->NewStringUTF(msg));
337 env->Throw(static_cast<jthrowable>(exception));
338 }
339
throwExceptionAsNecessary(JNIEnv * env,status_t err,const char * msg=NULL)340 static bool throwExceptionAsNecessary(
341 JNIEnv *env, status_t err, const char *msg = NULL) {
342
343 const char *drmMessage = NULL;
344
345 switch (err) {
346 case ERROR_DRM_UNKNOWN:
347 drmMessage = "General DRM error";
348 break;
349 case ERROR_DRM_NO_LICENSE:
350 drmMessage = "No license";
351 break;
352 case ERROR_DRM_LICENSE_EXPIRED:
353 drmMessage = "License expired";
354 break;
355 case ERROR_DRM_SESSION_NOT_OPENED:
356 drmMessage = "Session not opened";
357 break;
358 case ERROR_DRM_DECRYPT_UNIT_NOT_INITIALIZED:
359 drmMessage = "Not initialized";
360 break;
361 case ERROR_DRM_DECRYPT:
362 drmMessage = "Decrypt error";
363 break;
364 case ERROR_DRM_CANNOT_HANDLE:
365 drmMessage = "Invalid parameter or data format";
366 break;
367 case ERROR_DRM_TAMPER_DETECTED:
368 drmMessage = "Invalid state";
369 break;
370 default:
371 break;
372 }
373
374 String8 vendorMessage;
375 if (err >= ERROR_DRM_VENDOR_MIN && err <= ERROR_DRM_VENDOR_MAX) {
376 vendorMessage = String8::format("DRM vendor-defined error: %d", err);
377 drmMessage = vendorMessage.string();
378 }
379
380 if (err == BAD_VALUE || err == ERROR_DRM_CANNOT_HANDLE) {
381 jniThrowException(env, "java/lang/IllegalArgumentException", msg);
382 return true;
383 } else if (err == ERROR_DRM_NOT_PROVISIONED) {
384 jniThrowException(env, "android/media/NotProvisionedException", msg);
385 return true;
386 } else if (err == ERROR_DRM_RESOURCE_BUSY) {
387 jniThrowException(env, "android/media/ResourceBusyException", msg);
388 return true;
389 } else if (err == ERROR_DRM_DEVICE_REVOKED) {
390 jniThrowException(env, "android/media/DeniedByServerException", msg);
391 return true;
392 } else if (err == DEAD_OBJECT) {
393 jniThrowException(env, "android/media/MediaDrmResetException",
394 "mediaserver died");
395 return true;
396 } else if (err != OK) {
397 String8 errbuf;
398 if (drmMessage != NULL) {
399 if (msg == NULL) {
400 msg = drmMessage;
401 } else {
402 errbuf = String8::format("%s: %s", msg, drmMessage);
403 msg = errbuf.string();
404 }
405 }
406 throwStateException(env, msg, err);
407 return true;
408 }
409 return false;
410 }
411
GetDrm(JNIEnv * env,jobject thiz)412 static sp<IDrm> GetDrm(JNIEnv *env, jobject thiz) {
413 JDrm *jdrm = (JDrm *)env->GetLongField(thiz, gFields.context);
414 return jdrm ? jdrm->getDrm() : NULL;
415 }
416
JDrm(JNIEnv * env,jobject thiz,const uint8_t uuid[16],const String8 & appPackageName)417 JDrm::JDrm(
418 JNIEnv *env, jobject thiz, const uint8_t uuid[16],
419 const String8 &appPackageName) {
420 mObject = env->NewWeakGlobalRef(thiz);
421 mDrm = MakeDrm(uuid, appPackageName);
422 if (mDrm != NULL) {
423 mDrm->setListener(this);
424 }
425 }
426
~JDrm()427 JDrm::~JDrm() {
428 JNIEnv *env = AndroidRuntime::getJNIEnv();
429
430 env->DeleteWeakGlobalRef(mObject);
431 mObject = NULL;
432 }
433
434 // static
MakeDrm()435 sp<IDrm> JDrm::MakeDrm() {
436 sp<IServiceManager> sm = defaultServiceManager();
437
438 sp<IBinder> binder = sm->getService(String16("media.drm"));
439 sp<IMediaDrmService> service = interface_cast<IMediaDrmService>(binder);
440 if (service == NULL) {
441 return NULL;
442 }
443
444 sp<IDrm> drm = service->makeDrm();
445 if (drm == NULL || (drm->initCheck() != OK && drm->initCheck() != NO_INIT)) {
446 return NULL;
447 }
448
449 return drm;
450 }
451
452 // static
MakeDrm(const uint8_t uuid[16],const String8 & appPackageName)453 sp<IDrm> JDrm::MakeDrm(const uint8_t uuid[16], const String8 &appPackageName) {
454 sp<IDrm> drm = MakeDrm();
455
456 if (drm == NULL) {
457 return NULL;
458 }
459
460 status_t err = drm->createPlugin(uuid, appPackageName);
461
462 if (err != OK) {
463 return NULL;
464 }
465
466 return drm;
467 }
468
setListener(const sp<DrmListener> & listener)469 status_t JDrm::setListener(const sp<DrmListener>& listener) {
470 Mutex::Autolock lock(mLock);
471 mListener = listener;
472 return OK;
473 }
474
notify(DrmPlugin::EventType eventType,int extra,const Parcel * obj)475 void JDrm::notify(DrmPlugin::EventType eventType, int extra, const Parcel *obj) {
476 sp<DrmListener> listener;
477 mLock.lock();
478 listener = mListener;
479 mLock.unlock();
480
481 if (listener != NULL) {
482 Mutex::Autolock lock(mNotifyLock);
483 listener->notify(eventType, extra, obj);
484 }
485 }
486
disconnect()487 void JDrm::disconnect() {
488 if (mDrm != NULL) {
489 mDrm->destroyPlugin();
490 mDrm.clear();
491 }
492 }
493
494
495 // static
IsCryptoSchemeSupported(const uint8_t uuid[16],const String8 & mimeType)496 bool JDrm::IsCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType) {
497 sp<IDrm> drm = MakeDrm();
498
499 if (drm == NULL) {
500 return false;
501 }
502
503 return drm->isCryptoSchemeSupported(uuid, mimeType);
504 }
505
initCheck() const506 status_t JDrm::initCheck() const {
507 return mDrm == NULL ? NO_INIT : OK;
508 }
509
510 // JNI conversion utilities
JByteArrayToVector(JNIEnv * env,jbyteArray const & byteArray)511 static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
512 Vector<uint8_t> vector;
513 size_t length = env->GetArrayLength(byteArray);
514 vector.insertAt((size_t)0, length);
515 env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
516 return vector;
517 }
518
VectorToJByteArray(JNIEnv * env,Vector<uint8_t> const & vector)519 static jbyteArray VectorToJByteArray(JNIEnv *env, Vector<uint8_t> const &vector) {
520 size_t length = vector.size();
521 jbyteArray result = env->NewByteArray(length);
522 if (result != NULL) {
523 env->SetByteArrayRegion(result, 0, length, (jbyte *)vector.array());
524 }
525 return result;
526 }
527
JStringToString8(JNIEnv * env,jstring const & jstr)528 static String8 JStringToString8(JNIEnv *env, jstring const &jstr) {
529 String8 result;
530
531 const char *s = env->GetStringUTFChars(jstr, NULL);
532 if (s) {
533 result = s;
534 env->ReleaseStringUTFChars(jstr, s);
535 }
536 return result;
537 }
538
539 /*
540 import java.util.HashMap;
541 import java.util.Set;
542 import java.Map.Entry;
543 import jav.util.Iterator;
544
545 HashMap<k, v> hm;
546 Set<Entry<k, v> > s = hm.entrySet();
547 Iterator i = s.iterator();
548 Entry e = s.next();
549 */
550
HashMapToKeyedVector(JNIEnv * env,jobject & hashMap,bool * pIsOK)551 static KeyedVector<String8, String8> HashMapToKeyedVector(
552 JNIEnv *env, jobject &hashMap, bool* pIsOK) {
553 jclass clazz = gFields.stringClassId;
554 KeyedVector<String8, String8> keyedVector;
555 *pIsOK = true;
556
557 jobject entrySet = env->CallObjectMethod(hashMap, gFields.hashmap.entrySet);
558 if (entrySet) {
559 jobject iterator = env->CallObjectMethod(entrySet, gFields.set.iterator);
560 if (iterator) {
561 jboolean hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
562 while (hasNext) {
563 jobject entry = env->CallObjectMethod(iterator, gFields.iterator.next);
564 if (entry) {
565 jobject obj = env->CallObjectMethod(entry, gFields.entry.getKey);
566 if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
567 jniThrowException(env, "java/lang/IllegalArgumentException",
568 "HashMap key is not a String");
569 env->DeleteLocalRef(entry);
570 *pIsOK = false;
571 break;
572 }
573 jstring jkey = static_cast<jstring>(obj);
574
575 obj = env->CallObjectMethod(entry, gFields.entry.getValue);
576 if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
577 jniThrowException(env, "java/lang/IllegalArgumentException",
578 "HashMap value is not a String");
579 env->DeleteLocalRef(entry);
580 *pIsOK = false;
581 break;
582 }
583 jstring jvalue = static_cast<jstring>(obj);
584
585 String8 key = JStringToString8(env, jkey);
586 String8 value = JStringToString8(env, jvalue);
587 keyedVector.add(key, value);
588
589 env->DeleteLocalRef(jkey);
590 env->DeleteLocalRef(jvalue);
591 hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
592 }
593 env->DeleteLocalRef(entry);
594 }
595 env->DeleteLocalRef(iterator);
596 }
597 env->DeleteLocalRef(entrySet);
598 }
599 return keyedVector;
600 }
601
KeyedVectorToHashMap(JNIEnv * env,KeyedVector<String8,String8> const & map)602 static jobject KeyedVectorToHashMap (JNIEnv *env, KeyedVector<String8, String8> const &map) {
603 jclass clazz = gFields.hashmapClassId;
604 jobject hashMap = env->NewObject(clazz, gFields.hashmap.init);
605 for (size_t i = 0; i < map.size(); ++i) {
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);
611 }
612 return hashMap;
613 }
614
ListOfVectorsToArrayListOfByteArray(JNIEnv * env,List<Vector<uint8_t>> list)615 static jobject ListOfVectorsToArrayListOfByteArray(JNIEnv *env,
616 List<Vector<uint8_t> > list) {
617 jclass clazz = gFields.arraylistClassId;
618 jobject arrayList = env->NewObject(clazz, gFields.arraylist.init);
619 List<Vector<uint8_t> >::iterator iter = list.begin();
620 while (iter != list.end()) {
621 jbyteArray byteArray = VectorToJByteArray(env, *iter);
622 env->CallBooleanMethod(arrayList, gFields.arraylist.add, byteArray);
623 env->DeleteLocalRef(byteArray);
624 iter++;
625 }
626
627 return arrayList;
628 }
629
630 } // namespace android
631
632 using namespace android;
633
setDrm(JNIEnv * env,jobject thiz,const sp<JDrm> & drm)634 static sp<JDrm> setDrm(
635 JNIEnv *env, jobject thiz, const sp<JDrm> &drm) {
636 sp<JDrm> old = (JDrm *)env->GetLongField(thiz, gFields.context);
637 if (drm != NULL) {
638 drm->incStrong(thiz);
639 }
640 if (old != NULL) {
641 old->decStrong(thiz);
642 }
643 env->SetLongField(thiz, gFields.context, reinterpret_cast<jlong>(drm.get()));
644
645 return old;
646 }
647
CheckDrm(JNIEnv * env,const sp<IDrm> & drm)648 static bool CheckDrm(JNIEnv *env, const sp<IDrm> &drm) {
649 if (drm == NULL) {
650 jniThrowException(env, "java/lang/IllegalStateException", "MediaDrm obj is null");
651 return false;
652 }
653 return true;
654 }
655
CheckSession(JNIEnv * env,const sp<IDrm> & drm,jbyteArray const & jsessionId)656 static bool CheckSession(JNIEnv *env, const sp<IDrm> &drm, jbyteArray const &jsessionId)
657 {
658 if (!CheckDrm(env, drm)) {
659 return false;
660 }
661
662 if (jsessionId == NULL) {
663 jniThrowException(env, "java/lang/IllegalArgumentException", "sessionId is null");
664 return false;
665 }
666 return true;
667 }
668
android_media_MediaDrm_native_release(JNIEnv * env,jobject thiz)669 static void android_media_MediaDrm_native_release(JNIEnv *env, jobject thiz) {
670 sp<JDrm> drm = setDrm(env, thiz, NULL);
671 if (drm != NULL) {
672 drm->setListener(NULL);
673 drm->disconnect();
674 }
675 }
676
android_media_MediaDrm_native_init(JNIEnv * env)677 static void android_media_MediaDrm_native_init(JNIEnv *env) {
678 jclass clazz;
679 FIND_CLASS(clazz, "android/media/MediaDrm");
680 GET_FIELD_ID(gFields.context, clazz, "mNativeContext", "J");
681 GET_STATIC_METHOD_ID(gFields.post_event, clazz, "postEventFromNative",
682 "(Ljava/lang/Object;IIILjava/lang/Object;)V");
683
684 jfieldID field;
685 GET_STATIC_FIELD_ID(field, clazz, "EVENT_PROVISION_REQUIRED", "I");
686 gEventTypes.kEventProvisionRequired = env->GetStaticIntField(clazz, field);
687 GET_STATIC_FIELD_ID(field, clazz, "EVENT_KEY_REQUIRED", "I");
688 gEventTypes.kEventKeyRequired = env->GetStaticIntField(clazz, field);
689 GET_STATIC_FIELD_ID(field, clazz, "EVENT_KEY_EXPIRED", "I");
690 gEventTypes.kEventKeyExpired = env->GetStaticIntField(clazz, field);
691 GET_STATIC_FIELD_ID(field, clazz, "EVENT_VENDOR_DEFINED", "I");
692 gEventTypes.kEventVendorDefined = env->GetStaticIntField(clazz, field);
693 GET_STATIC_FIELD_ID(field, clazz, "EVENT_SESSION_RECLAIMED", "I");
694 gEventTypes.kEventSessionReclaimed = env->GetStaticIntField(clazz, field);
695
696 GET_STATIC_FIELD_ID(field, clazz, "DRM_EVENT", "I");
697 gEventWhat.kWhatDrmEvent = env->GetStaticIntField(clazz, field);
698 GET_STATIC_FIELD_ID(field, clazz, "EXPIRATION_UPDATE", "I");
699 gEventWhat.kWhatExpirationUpdate = env->GetStaticIntField(clazz, field);
700 GET_STATIC_FIELD_ID(field, clazz, "KEY_STATUS_CHANGE", "I");
701 gEventWhat.kWhatKeyStatusChange = env->GetStaticIntField(clazz, field);
702
703 GET_STATIC_FIELD_ID(field, clazz, "KEY_TYPE_STREAMING", "I");
704 gKeyTypes.kKeyTypeStreaming = env->GetStaticIntField(clazz, field);
705 GET_STATIC_FIELD_ID(field, clazz, "KEY_TYPE_OFFLINE", "I");
706 gKeyTypes.kKeyTypeOffline = env->GetStaticIntField(clazz, field);
707 GET_STATIC_FIELD_ID(field, clazz, "KEY_TYPE_RELEASE", "I");
708 gKeyTypes.kKeyTypeRelease = env->GetStaticIntField(clazz, field);
709
710 GET_STATIC_FIELD_ID(field, clazz, "CERTIFICATE_TYPE_NONE", "I");
711 gCertificateTypes.kCertificateTypeNone = env->GetStaticIntField(clazz, field);
712 GET_STATIC_FIELD_ID(field, clazz, "CERTIFICATE_TYPE_X509", "I");
713 gCertificateTypes.kCertificateTypeX509 = env->GetStaticIntField(clazz, field);
714
715 GET_STATIC_FIELD_ID(field, clazz, "HDCP_LEVEL_UNKNOWN", "I");
716 gHdcpLevels.kHdcpLevelUnknown = env->GetStaticIntField(clazz, field);
717 GET_STATIC_FIELD_ID(field, clazz, "HDCP_NONE", "I");
718 gHdcpLevels.kHdcpNone = env->GetStaticIntField(clazz, field);
719 GET_STATIC_FIELD_ID(field, clazz, "HDCP_V1", "I");
720 gHdcpLevels.kHdcpV1 = env->GetStaticIntField(clazz, field);
721 GET_STATIC_FIELD_ID(field, clazz, "HDCP_V2", "I");
722 gHdcpLevels.kHdcpV2 = env->GetStaticIntField(clazz, field);
723 GET_STATIC_FIELD_ID(field, clazz, "HDCP_V2_1", "I");
724 gHdcpLevels.kHdcpV2_1 = env->GetStaticIntField(clazz, field);
725 GET_STATIC_FIELD_ID(field, clazz, "HDCP_V2_2", "I");
726 gHdcpLevels.kHdcpV2_2 = env->GetStaticIntField(clazz, field);
727 GET_STATIC_FIELD_ID(field, clazz, "HDCP_NO_DIGITAL_OUTPUT", "I");
728 gHdcpLevels.kHdcpNoOutput = env->GetStaticIntField(clazz, field);
729
730 GET_STATIC_FIELD_ID(field, clazz, "SECURITY_LEVEL_UNKNOWN", "I");
731 gSecurityLevels.kSecurityLevelUnknown = env->GetStaticIntField(clazz, field);
732 GET_STATIC_FIELD_ID(field, clazz, "SECURITY_LEVEL_SW_SECURE_CRYPTO", "I");
733 gSecurityLevels.kSecurityLevelSwSecureCrypto = env->GetStaticIntField(clazz, field);
734 GET_STATIC_FIELD_ID(field, clazz, "SECURITY_LEVEL_SW_SECURE_DECODE", "I");
735 gSecurityLevels.kSecurityLevelSwSecureDecode = env->GetStaticIntField(clazz, field);
736 GET_STATIC_FIELD_ID(field, clazz, "SECURITY_LEVEL_HW_SECURE_CRYPTO", "I");
737 gSecurityLevels.kSecurityLevelHwSecureCrypto = env->GetStaticIntField(clazz, field);
738 GET_STATIC_FIELD_ID(field, clazz, "SECURITY_LEVEL_HW_SECURE_DECODE", "I");
739 gSecurityLevels.kSecurityLevelHwSecureDecode = env->GetStaticIntField(clazz, field);
740 GET_STATIC_FIELD_ID(field, clazz, "SECURITY_LEVEL_HW_SECURE_ALL", "I");
741 gSecurityLevels.kSecurityLevelHwSecureAll = env->GetStaticIntField(clazz, field);
742
743 jmethodID getMaxSecurityLevel;
744 GET_STATIC_METHOD_ID(getMaxSecurityLevel, clazz, "getMaxSecurityLevel", "()I");
745 gSecurityLevels.kSecurityLevelMax = env->CallStaticIntMethod(clazz, getMaxSecurityLevel);
746
747 FIND_CLASS(clazz, "android/media/MediaDrm$KeyRequest");
748 GET_FIELD_ID(gFields.keyRequest.data, clazz, "mData", "[B");
749 GET_FIELD_ID(gFields.keyRequest.defaultUrl, clazz, "mDefaultUrl", "Ljava/lang/String;");
750 GET_FIELD_ID(gFields.keyRequest.requestType, clazz, "mRequestType", "I");
751
752 GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_INITIAL", "I");
753 gKeyRequestTypes.kKeyRequestTypeInitial = env->GetStaticIntField(clazz, field);
754 GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_RENEWAL", "I");
755 gKeyRequestTypes.kKeyRequestTypeRenewal = env->GetStaticIntField(clazz, field);
756 GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_RELEASE", "I");
757 gKeyRequestTypes.kKeyRequestTypeRelease = env->GetStaticIntField(clazz, field);
758 GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_NONE", "I");
759 gKeyRequestTypes.kKeyRequestTypeNone = env->GetStaticIntField(clazz, field);
760 GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_UPDATE", "I");
761 gKeyRequestTypes.kKeyRequestTypeUpdate = env->GetStaticIntField(clazz, field);
762
763 FIND_CLASS(clazz, "android/media/MediaDrm$ProvisionRequest");
764 GET_FIELD_ID(gFields.provisionRequest.data, clazz, "mData", "[B");
765 GET_FIELD_ID(gFields.provisionRequest.defaultUrl, clazz, "mDefaultUrl", "Ljava/lang/String;");
766
767 FIND_CLASS(clazz, "android/media/MediaDrm$Certificate");
768 GET_FIELD_ID(gFields.certificate.wrappedPrivateKey, clazz, "mWrappedKey", "[B");
769 GET_FIELD_ID(gFields.certificate.certificateData, clazz, "mCertificateData", "[B");
770 gFields.certificateClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
771
772 // Metrics-related fields and classes.
773 FIND_CLASS(clazz, "android/os/PersistableBundle");
774 jfieldID bundleCreatorId;
775 GET_STATIC_FIELD_ID(bundleCreatorId, clazz, "CREATOR",
776 "Landroid/os/Parcelable$Creator;");
777 jobject bundleCreator;
778 GET_STATIC_OBJECT_FIELD(bundleCreator, clazz, bundleCreatorId);
779 gFields.bundleCreator = static_cast<jobject>(env->NewGlobalRef(bundleCreator));
780 FIND_CLASS(clazz, "android/os/Parcelable$Creator");
781 GET_METHOD_ID(gFields.createFromParcelId, clazz, "createFromParcel",
782 "(Landroid/os/Parcel;)Ljava/lang/Object;");
783 gFields.parcelCreatorClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
784
785 FIND_CLASS(clazz, "java/util/ArrayList");
786 GET_METHOD_ID(gFields.arraylist.init, clazz, "<init>", "()V");
787 GET_METHOD_ID(gFields.arraylist.add, clazz, "add", "(Ljava/lang/Object;)Z");
788
789 FIND_CLASS(clazz, "java/util/HashMap");
790 GET_METHOD_ID(gFields.hashmap.init, clazz, "<init>", "()V");
791 GET_METHOD_ID(gFields.hashmap.get, clazz, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
792 GET_METHOD_ID(gFields.hashmap.put, clazz, "put",
793 "(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
794 GET_METHOD_ID(gFields.hashmap.entrySet, clazz, "entrySet", "()Ljava/util/Set;");
795
796 FIND_CLASS(clazz, "java/util/Set");
797 GET_METHOD_ID(gFields.set.iterator, clazz, "iterator", "()Ljava/util/Iterator;");
798
799 FIND_CLASS(clazz, "java/util/Iterator");
800 GET_METHOD_ID(gFields.iterator.next, clazz, "next", "()Ljava/lang/Object;");
801 GET_METHOD_ID(gFields.iterator.hasNext, clazz, "hasNext", "()Z");
802
803 FIND_CLASS(clazz, "java/util/Map$Entry");
804 GET_METHOD_ID(gFields.entry.getKey, clazz, "getKey", "()Ljava/lang/Object;");
805 GET_METHOD_ID(gFields.entry.getValue, clazz, "getValue", "()Ljava/lang/Object;");
806
807 FIND_CLASS(clazz, "java/util/HashMap");
808 gFields.hashmapClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
809
810 FIND_CLASS(clazz, "java/lang/String");
811 gFields.stringClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
812
813 FIND_CLASS(clazz, "java/util/ArrayList");
814 gFields.arraylistClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
815
816 FIND_CLASS(clazz, "android/media/MediaDrm$MediaDrmStateException");
817 GET_METHOD_ID(gFields.stateException.init, clazz, "<init>", "(ILjava/lang/String;)V");
818 gFields.stateException.classId = static_cast<jclass>(env->NewGlobalRef(clazz));
819 }
820
android_media_MediaDrm_native_setup(JNIEnv * env,jobject thiz,jobject weak_this,jbyteArray uuidObj,jstring jappPackageName)821 static void android_media_MediaDrm_native_setup(
822 JNIEnv *env, jobject thiz,
823 jobject weak_this, jbyteArray uuidObj, jstring jappPackageName) {
824
825 if (uuidObj == NULL) {
826 jniThrowException(env, "java/lang/IllegalArgumentException", "uuid is null");
827 return;
828 }
829
830 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
831
832 if (uuid.size() != 16) {
833 jniThrowException(env, "java/lang/IllegalArgumentException",
834 "invalid UUID size, expected 16 bytes");
835 return;
836 }
837
838 String8 packageName;
839 if (jappPackageName == NULL) {
840 jniThrowException(env, "java/lang/IllegalArgumentException",
841 "application package name cannot be null");
842 return;
843 }
844
845 packageName = JStringToString8(env, jappPackageName);
846 sp<JDrm> drm = new JDrm(env, thiz, uuid.array(), packageName);
847
848 status_t err = drm->initCheck();
849
850 if (err != OK) {
851 jniThrowException(
852 env,
853 "android/media/UnsupportedSchemeException",
854 "Failed to instantiate drm object.");
855 return;
856 }
857
858 sp<JNIDrmListener> listener = new JNIDrmListener(env, thiz, weak_this);
859 drm->setListener(listener);
860 setDrm(env, thiz, drm);
861 }
862
android_media_MediaDrm_isCryptoSchemeSupportedNative(JNIEnv * env,jobject,jbyteArray uuidObj,jstring jmimeType)863 static jboolean android_media_MediaDrm_isCryptoSchemeSupportedNative(
864 JNIEnv *env, jobject /* thiz */, jbyteArray uuidObj, jstring jmimeType) {
865
866 if (uuidObj == NULL) {
867 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
868 return false;
869 }
870
871 Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
872
873 if (uuid.size() != 16) {
874 jniThrowException(
875 env,
876 "java/lang/IllegalArgumentException",
877 "invalid UUID size, expected 16 bytes");
878 return false;
879 }
880
881 String8 mimeType;
882 if (jmimeType != NULL) {
883 mimeType = JStringToString8(env, jmimeType);
884 }
885
886 return JDrm::IsCryptoSchemeSupported(uuid.array(), mimeType);
887 }
888
android_media_MediaDrm_openSession(JNIEnv * env,jobject thiz,jint jlevel)889 static jbyteArray android_media_MediaDrm_openSession(
890 JNIEnv *env, jobject thiz, jint jlevel) {
891 sp<IDrm> drm = GetDrm(env, thiz);
892
893 if (drm == NULL) {
894 jniThrowException(env, "java/lang/IllegalStateException",
895 "MediaDrm obj is null");
896 return NULL;
897 }
898
899 Vector<uint8_t> sessionId;
900 DrmPlugin::SecurityLevel level;
901
902 if (jlevel == gSecurityLevels.kSecurityLevelMax) {
903 level = DrmPlugin::kSecurityLevelMax;
904 } else if (jlevel == gSecurityLevels.kSecurityLevelSwSecureCrypto) {
905 level = DrmPlugin::kSecurityLevelSwSecureCrypto;
906 } else if (jlevel == gSecurityLevels.kSecurityLevelSwSecureDecode) {
907 level = DrmPlugin::kSecurityLevelSwSecureDecode;
908 } else if (jlevel == gSecurityLevels.kSecurityLevelHwSecureCrypto) {
909 level = DrmPlugin::kSecurityLevelHwSecureCrypto;
910 } else if (jlevel == gSecurityLevels.kSecurityLevelHwSecureDecode) {
911 level = DrmPlugin::kSecurityLevelHwSecureDecode;
912 } else if (jlevel == gSecurityLevels.kSecurityLevelHwSecureAll) {
913 level = DrmPlugin::kSecurityLevelHwSecureAll;
914 } else {
915 jniThrowException(env, "java/lang/IllegalArgumentException", "Invalid security level");
916 return NULL;
917 }
918
919 status_t err = drm->openSession(level, sessionId);
920
921 if (throwExceptionAsNecessary(env, err, "Failed to open session")) {
922 return NULL;
923 }
924
925 return VectorToJByteArray(env, sessionId);
926 }
927
android_media_MediaDrm_closeSession(JNIEnv * env,jobject thiz,jbyteArray jsessionId)928 static void android_media_MediaDrm_closeSession(
929 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
930 sp<IDrm> drm = GetDrm(env, thiz);
931
932 if (!CheckSession(env, drm, jsessionId)) {
933 return;
934 }
935
936 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
937
938 status_t err = drm->closeSession(sessionId);
939
940 throwExceptionAsNecessary(env, err, "Failed to close session");
941 }
942
android_media_MediaDrm_getKeyRequest(JNIEnv * env,jobject thiz,jbyteArray jsessionId,jbyteArray jinitData,jstring jmimeType,jint jkeyType,jobject joptParams)943 static jobject android_media_MediaDrm_getKeyRequest(
944 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jinitData,
945 jstring jmimeType, jint jkeyType, jobject joptParams) {
946 sp<IDrm> drm = GetDrm(env, thiz);
947
948 if (!CheckSession(env, drm, jsessionId)) {
949 return NULL;
950 }
951
952 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
953
954 Vector<uint8_t> initData;
955 if (jinitData != NULL) {
956 initData = JByteArrayToVector(env, jinitData);
957 }
958
959 String8 mimeType;
960 if (jmimeType != NULL) {
961 mimeType = JStringToString8(env, jmimeType);
962 }
963
964 DrmPlugin::KeyType keyType;
965 if (jkeyType == gKeyTypes.kKeyTypeStreaming) {
966 keyType = DrmPlugin::kKeyType_Streaming;
967 } else if (jkeyType == gKeyTypes.kKeyTypeOffline) {
968 keyType = DrmPlugin::kKeyType_Offline;
969 } else if (jkeyType == gKeyTypes.kKeyTypeRelease) {
970 keyType = DrmPlugin::kKeyType_Release;
971 } else {
972 jniThrowException(env, "java/lang/IllegalArgumentException",
973 "invalid keyType");
974 return NULL;
975 }
976
977 KeyedVector<String8, String8> optParams;
978 if (joptParams != NULL) {
979 bool isOK;
980 optParams = HashMapToKeyedVector(env, joptParams, &isOK);
981 if (!isOK) {
982 return NULL;
983 }
984 }
985
986 Vector<uint8_t> request;
987 String8 defaultUrl;
988 DrmPlugin::KeyRequestType keyRequestType;
989
990 status_t err = drm->getKeyRequest(sessionId, initData, mimeType,
991 keyType, optParams, request, defaultUrl, &keyRequestType);
992
993 if (throwExceptionAsNecessary(env, err, "Failed to get key request")) {
994 return NULL;
995 }
996
997 // Fill out return obj
998 jclass clazz;
999 FIND_CLASS(clazz, "android/media/MediaDrm$KeyRequest");
1000
1001 jobject keyObj = NULL;
1002
1003 if (clazz) {
1004 keyObj = env->AllocObject(clazz);
1005 jbyteArray jrequest = VectorToJByteArray(env, request);
1006 env->SetObjectField(keyObj, gFields.keyRequest.data, jrequest);
1007
1008 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
1009 env->SetObjectField(keyObj, gFields.keyRequest.defaultUrl, jdefaultUrl);
1010
1011 switch (keyRequestType) {
1012 case DrmPlugin::kKeyRequestType_Initial:
1013 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1014 gKeyRequestTypes.kKeyRequestTypeInitial);
1015 break;
1016 case DrmPlugin::kKeyRequestType_Renewal:
1017 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1018 gKeyRequestTypes.kKeyRequestTypeRenewal);
1019 break;
1020 case DrmPlugin::kKeyRequestType_Release:
1021 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1022 gKeyRequestTypes.kKeyRequestTypeRelease);
1023 break;
1024 case DrmPlugin::kKeyRequestType_None:
1025 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1026 gKeyRequestTypes.kKeyRequestTypeNone);
1027 break;
1028 case DrmPlugin::kKeyRequestType_Update:
1029 env->SetIntField(keyObj, gFields.keyRequest.requestType,
1030 gKeyRequestTypes.kKeyRequestTypeUpdate);
1031 break;
1032
1033 default:
1034 throwStateException(env, "DRM plugin failure: unknown key request type",
1035 ERROR_DRM_UNKNOWN);
1036 break;
1037 }
1038 }
1039
1040 return keyObj;
1041 }
1042
android_media_MediaDrm_provideKeyResponse(JNIEnv * env,jobject thiz,jbyteArray jsessionId,jbyteArray jresponse)1043 static jbyteArray android_media_MediaDrm_provideKeyResponse(
1044 JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jresponse) {
1045 sp<IDrm> drm = GetDrm(env, thiz);
1046
1047 if (!CheckSession(env, drm, jsessionId)) {
1048 return NULL;
1049 }
1050
1051 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1052
1053 if (jresponse == NULL) {
1054 jniThrowException(env, "java/lang/IllegalArgumentException",
1055 "key response is null");
1056 return NULL;
1057 }
1058 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
1059 Vector<uint8_t> keySetId;
1060
1061 status_t err = drm->provideKeyResponse(sessionId, response, keySetId);
1062
1063 if (throwExceptionAsNecessary(env, err, "Failed to handle key response")) {
1064 return NULL;
1065 }
1066 return VectorToJByteArray(env, keySetId);
1067 }
1068
android_media_MediaDrm_removeKeys(JNIEnv * env,jobject thiz,jbyteArray jkeysetId)1069 static void android_media_MediaDrm_removeKeys(
1070 JNIEnv *env, jobject thiz, jbyteArray jkeysetId) {
1071 sp<IDrm> drm = GetDrm(env, thiz);
1072
1073 if (jkeysetId == NULL) {
1074 jniThrowException(env, "java/lang/IllegalArgumentException",
1075 "keySetId is null");
1076 return;
1077 }
1078
1079 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
1080
1081 status_t err = drm->removeKeys(keySetId);
1082
1083 throwExceptionAsNecessary(env, err, "Failed to remove keys");
1084 }
1085
android_media_MediaDrm_restoreKeys(JNIEnv * env,jobject thiz,jbyteArray jsessionId,jbyteArray jkeysetId)1086 static void android_media_MediaDrm_restoreKeys(
1087 JNIEnv *env, jobject thiz, jbyteArray jsessionId,
1088 jbyteArray jkeysetId) {
1089
1090 sp<IDrm> drm = GetDrm(env, thiz);
1091
1092 if (!CheckSession(env, drm, jsessionId)) {
1093 return;
1094 }
1095
1096 if (jkeysetId == NULL) {
1097 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
1098 return;
1099 }
1100
1101 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1102 Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
1103
1104 status_t err = drm->restoreKeys(sessionId, keySetId);
1105
1106 throwExceptionAsNecessary(env, err, "Failed to restore keys");
1107 }
1108
android_media_MediaDrm_queryKeyStatus(JNIEnv * env,jobject thiz,jbyteArray jsessionId)1109 static jobject android_media_MediaDrm_queryKeyStatus(
1110 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
1111 sp<IDrm> drm = GetDrm(env, thiz);
1112
1113 if (!CheckSession(env, drm, jsessionId)) {
1114 return NULL;
1115 }
1116 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1117
1118 KeyedVector<String8, String8> infoMap;
1119
1120 status_t err = drm->queryKeyStatus(sessionId, infoMap);
1121
1122 if (throwExceptionAsNecessary(env, err, "Failed to query key status")) {
1123 return NULL;
1124 }
1125
1126 return KeyedVectorToHashMap(env, infoMap);
1127 }
1128
android_media_MediaDrm_getProvisionRequestNative(JNIEnv * env,jobject thiz,jint jcertType,jstring jcertAuthority)1129 static jobject android_media_MediaDrm_getProvisionRequestNative(
1130 JNIEnv *env, jobject thiz, jint jcertType, jstring jcertAuthority) {
1131 sp<IDrm> drm = GetDrm(env, thiz);
1132
1133 if (!CheckDrm(env, drm)) {
1134 return NULL;
1135 }
1136
1137 Vector<uint8_t> request;
1138 String8 defaultUrl;
1139
1140 String8 certType;
1141 if (jcertType == gCertificateTypes.kCertificateTypeX509) {
1142 certType = "X.509";
1143 } else if (jcertType == gCertificateTypes.kCertificateTypeNone) {
1144 certType = "none";
1145 } else {
1146 certType = "invalid";
1147 }
1148
1149 String8 certAuthority = JStringToString8(env, jcertAuthority);
1150 status_t err = drm->getProvisionRequest(certType, certAuthority, request, defaultUrl);
1151
1152 if (throwExceptionAsNecessary(env, err, "Failed to get provision request")) {
1153 return NULL;
1154 }
1155
1156 // Fill out return obj
1157 jclass clazz;
1158 FIND_CLASS(clazz, "android/media/MediaDrm$ProvisionRequest");
1159
1160 jobject provisionObj = NULL;
1161
1162 if (clazz) {
1163 provisionObj = env->AllocObject(clazz);
1164 jbyteArray jrequest = VectorToJByteArray(env, request);
1165 env->SetObjectField(provisionObj, gFields.provisionRequest.data, jrequest);
1166
1167 jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
1168 env->SetObjectField(provisionObj, gFields.provisionRequest.defaultUrl, jdefaultUrl);
1169 }
1170
1171 return provisionObj;
1172 }
1173
android_media_MediaDrm_provideProvisionResponseNative(JNIEnv * env,jobject thiz,jbyteArray jresponse)1174 static jobject android_media_MediaDrm_provideProvisionResponseNative(
1175 JNIEnv *env, jobject thiz, jbyteArray jresponse) {
1176 sp<IDrm> drm = GetDrm(env, thiz);
1177
1178 if (!CheckDrm(env, drm)) {
1179 return NULL;
1180 }
1181
1182 if (jresponse == NULL) {
1183 jniThrowException(env, "java/lang/IllegalArgumentException",
1184 "provision response is null");
1185 return NULL;
1186 }
1187
1188 Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
1189 Vector<uint8_t> certificate, wrappedKey;
1190
1191 status_t err = drm->provideProvisionResponse(response, certificate, wrappedKey);
1192
1193 // Fill out return obj
1194 jclass clazz = gFields.certificateClassId;
1195
1196 jobject certificateObj = NULL;
1197
1198 if (clazz && certificate.size() && wrappedKey.size()) {
1199 certificateObj = env->AllocObject(clazz);
1200 jbyteArray jcertificate = VectorToJByteArray(env, certificate);
1201 env->SetObjectField(certificateObj, gFields.certificate.certificateData, jcertificate);
1202
1203 jbyteArray jwrappedKey = VectorToJByteArray(env, wrappedKey);
1204 env->SetObjectField(certificateObj, gFields.certificate.wrappedPrivateKey, jwrappedKey);
1205 }
1206
1207 throwExceptionAsNecessary(env, err, "Failed to handle provision response");
1208 return certificateObj;
1209 }
1210
android_media_MediaDrm_getSecureStops(JNIEnv * env,jobject thiz)1211 static jobject android_media_MediaDrm_getSecureStops(
1212 JNIEnv *env, jobject thiz) {
1213 sp<IDrm> drm = GetDrm(env, thiz);
1214
1215 if (!CheckDrm(env, drm)) {
1216 return NULL;
1217 }
1218
1219 List<Vector<uint8_t> > secureStops;
1220
1221 status_t err = drm->getSecureStops(secureStops);
1222
1223 if (throwExceptionAsNecessary(env, err, "Failed to get secure stops")) {
1224 return NULL;
1225 }
1226
1227 return ListOfVectorsToArrayListOfByteArray(env, secureStops);
1228 }
1229
android_media_MediaDrm_getSecureStopIds(JNIEnv * env,jobject thiz)1230 static jobject android_media_MediaDrm_getSecureStopIds(
1231 JNIEnv *env, jobject thiz) {
1232 sp<IDrm> drm = GetDrm(env, thiz);
1233
1234 if (drm == NULL) {
1235 jniThrowException(env, "java/lang/IllegalStateException",
1236 "MediaDrm obj is null");
1237 return NULL;
1238 }
1239
1240 List<Vector<uint8_t> > secureStopIds;
1241
1242 status_t err = drm->getSecureStopIds(secureStopIds);
1243
1244 if (throwExceptionAsNecessary(env, err, "Failed to get secure stop Ids")) {
1245 return NULL;
1246 }
1247
1248 return ListOfVectorsToArrayListOfByteArray(env, secureStopIds);
1249 }
1250
android_media_MediaDrm_getSecureStop(JNIEnv * env,jobject thiz,jbyteArray ssid)1251 static jbyteArray android_media_MediaDrm_getSecureStop(
1252 JNIEnv *env, jobject thiz, jbyteArray ssid) {
1253 sp<IDrm> drm = GetDrm(env, thiz);
1254
1255 if (!CheckDrm(env, drm)) {
1256 return NULL;
1257 }
1258
1259 Vector<uint8_t> secureStop;
1260
1261 status_t err = drm->getSecureStop(JByteArrayToVector(env, ssid), secureStop);
1262
1263 if (throwExceptionAsNecessary(env, err, "Failed to get secure stop")) {
1264 return NULL;
1265 }
1266
1267 return VectorToJByteArray(env, secureStop);
1268 }
1269
android_media_MediaDrm_releaseSecureStops(JNIEnv * env,jobject thiz,jbyteArray jssRelease)1270 static void android_media_MediaDrm_releaseSecureStops(
1271 JNIEnv *env, jobject thiz, jbyteArray jssRelease) {
1272 sp<IDrm> drm = GetDrm(env, thiz);
1273
1274 if (!CheckDrm(env, drm)) {
1275 return;
1276 }
1277
1278 Vector<uint8_t> ssRelease(JByteArrayToVector(env, jssRelease));
1279
1280 status_t err = drm->releaseSecureStops(ssRelease);
1281
1282 throwExceptionAsNecessary(env, err, "Failed to release secure stops");
1283 }
1284
android_media_MediaDrm_removeSecureStop(JNIEnv * env,jobject thiz,jbyteArray ssid)1285 static void android_media_MediaDrm_removeSecureStop(
1286 JNIEnv *env, jobject thiz, jbyteArray ssid) {
1287 sp<IDrm> drm = GetDrm(env, thiz);
1288
1289 if (drm == NULL) {
1290 jniThrowException(env, "java/lang/IllegalStateException",
1291 "MediaDrm obj is null");
1292 return;
1293 }
1294
1295 status_t err = drm->removeSecureStop(JByteArrayToVector(env, ssid));
1296
1297 throwExceptionAsNecessary(env, err, "Failed to remove secure stop");
1298 }
1299
android_media_MediaDrm_removeAllSecureStops(JNIEnv * env,jobject thiz)1300 static void android_media_MediaDrm_removeAllSecureStops(
1301 JNIEnv *env, jobject thiz) {
1302 sp<IDrm> drm = GetDrm(env, thiz);
1303
1304 if (!CheckDrm(env, drm)) {
1305 return;
1306 }
1307
1308 status_t err = drm->removeAllSecureStops();
1309
1310 throwExceptionAsNecessary(env, err, "Failed to remove all secure stops");
1311 }
1312
1313
HdcpLevelTojint(DrmPlugin::HdcpLevel level)1314 static jint HdcpLevelTojint(DrmPlugin::HdcpLevel level) {
1315 switch(level) {
1316 case DrmPlugin::kHdcpLevelUnknown:
1317 return gHdcpLevels.kHdcpLevelUnknown;
1318 case DrmPlugin::kHdcpNone:
1319 return gHdcpLevels.kHdcpNone;
1320 case DrmPlugin::kHdcpV1:
1321 return gHdcpLevels.kHdcpV1;
1322 case DrmPlugin::kHdcpV2:
1323 return gHdcpLevels.kHdcpV2;
1324 case DrmPlugin::kHdcpV2_1:
1325 return gHdcpLevels.kHdcpV2_1;
1326 case DrmPlugin::kHdcpV2_2:
1327 return gHdcpLevels.kHdcpV2_2;
1328 case DrmPlugin::kHdcpNoOutput:
1329 return gHdcpLevels.kHdcpNoOutput;
1330 }
1331 return gHdcpLevels.kHdcpNone;
1332 }
1333
android_media_MediaDrm_getConnectedHdcpLevel(JNIEnv * env,jobject thiz)1334 static jint android_media_MediaDrm_getConnectedHdcpLevel(JNIEnv *env,
1335 jobject thiz) {
1336 sp<IDrm> drm = GetDrm(env, thiz);
1337
1338 if (!CheckDrm(env, drm)) {
1339 return gHdcpLevels.kHdcpNone;
1340 }
1341
1342 DrmPlugin::HdcpLevel connected = DrmPlugin::kHdcpNone;
1343 DrmPlugin::HdcpLevel max = DrmPlugin::kHdcpNone;
1344
1345 status_t err = drm->getHdcpLevels(&connected, &max);
1346
1347 if (throwExceptionAsNecessary(env, err, "Failed to get HDCP levels")) {
1348 return gHdcpLevels.kHdcpLevelUnknown;
1349 }
1350 return HdcpLevelTojint(connected);
1351 }
1352
android_media_MediaDrm_getMaxHdcpLevel(JNIEnv * env,jobject thiz)1353 static jint android_media_MediaDrm_getMaxHdcpLevel(JNIEnv *env,
1354 jobject thiz) {
1355 sp<IDrm> drm = GetDrm(env, thiz);
1356
1357 if (!CheckDrm(env, drm)) {
1358 return gHdcpLevels.kHdcpLevelUnknown;
1359 }
1360
1361 DrmPlugin::HdcpLevel connected = DrmPlugin::kHdcpLevelUnknown;
1362 DrmPlugin::HdcpLevel max = DrmPlugin::kHdcpLevelUnknown;
1363
1364 status_t err = drm->getHdcpLevels(&connected, &max);
1365
1366 if (throwExceptionAsNecessary(env, err, "Failed to get HDCP levels")) {
1367 return gHdcpLevels.kHdcpLevelUnknown;
1368 }
1369 return HdcpLevelTojint(max);
1370 }
1371
android_media_MediaDrm_getOpenSessionCount(JNIEnv * env,jobject thiz)1372 static jint android_media_MediaDrm_getOpenSessionCount(JNIEnv *env,
1373 jobject thiz) {
1374 sp<IDrm> drm = GetDrm(env, thiz);
1375
1376 if (!CheckDrm(env, drm)) {
1377 return 0;
1378 }
1379
1380 uint32_t open = 0, max = 0;
1381 status_t err = drm->getNumberOfSessions(&open, &max);
1382
1383 if (throwExceptionAsNecessary(env, err, "Failed to get number of sessions")) {
1384 return 0;
1385 }
1386 return open;
1387 }
1388
android_media_MediaDrm_getMaxSessionCount(JNIEnv * env,jobject thiz)1389 static jint android_media_MediaDrm_getMaxSessionCount(JNIEnv *env,
1390 jobject thiz) {
1391 sp<IDrm> drm = GetDrm(env, thiz);
1392
1393 if (!CheckDrm(env, drm)) {
1394 return 0;
1395 }
1396
1397 uint32_t open = 0, max = 0;
1398 status_t err = drm->getNumberOfSessions(&open, &max);
1399
1400 if (throwExceptionAsNecessary(env, err, "Failed to get number of sessions")) {
1401 return 0;
1402 }
1403 return max;
1404 }
1405
android_media_MediaDrm_getSecurityLevel(JNIEnv * env,jobject thiz,jbyteArray jsessionId)1406 static jint android_media_MediaDrm_getSecurityLevel(JNIEnv *env,
1407 jobject thiz, jbyteArray jsessionId) {
1408 sp<IDrm> drm = GetDrm(env, thiz);
1409
1410 if (!CheckSession(env, drm, jsessionId)) {
1411 return gSecurityLevels.kSecurityLevelUnknown;
1412 }
1413
1414 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1415
1416 DrmPlugin::SecurityLevel level = DrmPlugin::kSecurityLevelUnknown;
1417
1418 status_t err = drm->getSecurityLevel(sessionId, &level);
1419
1420 if (throwExceptionAsNecessary(env, err, "Failed to get security level")) {
1421 return gSecurityLevels.kSecurityLevelUnknown;
1422 }
1423
1424 switch(level) {
1425 case DrmPlugin::kSecurityLevelSwSecureCrypto:
1426 return gSecurityLevels.kSecurityLevelSwSecureCrypto;
1427 case DrmPlugin::kSecurityLevelSwSecureDecode:
1428 return gSecurityLevels.kSecurityLevelSwSecureDecode;
1429 case DrmPlugin::kSecurityLevelHwSecureCrypto:
1430 return gSecurityLevels.kSecurityLevelHwSecureCrypto;
1431 case DrmPlugin::kSecurityLevelHwSecureDecode:
1432 return gSecurityLevels.kSecurityLevelHwSecureDecode;
1433 case DrmPlugin::kSecurityLevelHwSecureAll:
1434 return gSecurityLevels.kSecurityLevelHwSecureAll;
1435 default:
1436 return gSecurityLevels.kSecurityLevelUnknown;
1437 }
1438 }
1439
1440
android_media_MediaDrm_getPropertyString(JNIEnv * env,jobject thiz,jstring jname)1441 static jstring android_media_MediaDrm_getPropertyString(
1442 JNIEnv *env, jobject thiz, jstring jname) {
1443 sp<IDrm> drm = GetDrm(env, thiz);
1444
1445 if (!CheckDrm(env, drm)) {
1446 return NULL;
1447 }
1448
1449 if (jname == NULL) {
1450 jniThrowException(env, "java/lang/IllegalArgumentException",
1451 "property name String is null");
1452 return NULL;
1453 }
1454
1455 String8 name = JStringToString8(env, jname);
1456 String8 value;
1457
1458 status_t err = drm->getPropertyString(name, value);
1459
1460 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1461 return NULL;
1462 }
1463
1464 return env->NewStringUTF(value.string());
1465 }
1466
android_media_MediaDrm_getPropertyByteArray(JNIEnv * env,jobject thiz,jstring jname)1467 static jbyteArray android_media_MediaDrm_getPropertyByteArray(
1468 JNIEnv *env, jobject thiz, jstring jname) {
1469 sp<IDrm> drm = GetDrm(env, thiz);
1470
1471 if (!CheckDrm(env, drm)) {
1472 return NULL;
1473 }
1474
1475 if (jname == NULL) {
1476 jniThrowException(env, "java/lang/IllegalArgumentException",
1477 "property name String is null");
1478 return NULL;
1479 }
1480
1481 String8 name = JStringToString8(env, jname);
1482 Vector<uint8_t> value;
1483
1484 status_t err = drm->getPropertyByteArray(name, value);
1485
1486 if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
1487 return NULL;
1488 }
1489
1490 return VectorToJByteArray(env, value);
1491 }
1492
android_media_MediaDrm_setPropertyString(JNIEnv * env,jobject thiz,jstring jname,jstring jvalue)1493 static void android_media_MediaDrm_setPropertyString(
1494 JNIEnv *env, jobject thiz, jstring jname, jstring jvalue) {
1495 sp<IDrm> drm = GetDrm(env, thiz);
1496
1497 if (!CheckDrm(env, drm)) {
1498 return;
1499 }
1500
1501 if (jname == NULL) {
1502 jniThrowException(env, "java/lang/IllegalArgumentException",
1503 "property name String is null");
1504 return;
1505 }
1506
1507 if (jvalue == NULL) {
1508 jniThrowException(env, "java/lang/IllegalArgumentException",
1509 "property value String is null");
1510 return;
1511 }
1512
1513 String8 name = JStringToString8(env, jname);
1514 String8 value = JStringToString8(env, jvalue);
1515
1516 status_t err = drm->setPropertyString(name, value);
1517
1518 throwExceptionAsNecessary(env, err, "Failed to set property");
1519 }
1520
android_media_MediaDrm_setPropertyByteArray(JNIEnv * env,jobject thiz,jstring jname,jbyteArray jvalue)1521 static void android_media_MediaDrm_setPropertyByteArray(
1522 JNIEnv *env, jobject thiz, jstring jname, jbyteArray jvalue) {
1523 sp<IDrm> drm = GetDrm(env, thiz);
1524
1525 if (!CheckDrm(env, drm)) {
1526 return;
1527 }
1528
1529 if (jname == NULL) {
1530 jniThrowException(env, "java/lang/IllegalArgumentException",
1531 "property name String is null");
1532 return;
1533 }
1534
1535 if (jvalue == NULL) {
1536 jniThrowException(env, "java/lang/IllegalArgumentException",
1537 "property value byte array is null");
1538 return;
1539 }
1540
1541 String8 name = JStringToString8(env, jname);
1542 Vector<uint8_t> value = JByteArrayToVector(env, jvalue);
1543
1544 status_t err = drm->setPropertyByteArray(name, value);
1545
1546 throwExceptionAsNecessary(env, err, "Failed to set property");
1547 }
1548
android_media_MediaDrm_setCipherAlgorithmNative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jstring jalgorithm)1549 static void android_media_MediaDrm_setCipherAlgorithmNative(
1550 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1551 jstring jalgorithm) {
1552
1553 sp<IDrm> drm = GetDrm(env, jdrm);
1554
1555 if (!CheckSession(env, drm, jsessionId)) {
1556 return;
1557 }
1558
1559 if (jalgorithm == NULL) {
1560 jniThrowException(env, "java/lang/IllegalArgumentException",
1561 "algorithm String is null");
1562 return;
1563 }
1564
1565 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1566 String8 algorithm = JStringToString8(env, jalgorithm);
1567
1568 status_t err = drm->setCipherAlgorithm(sessionId, algorithm);
1569
1570 throwExceptionAsNecessary(env, err, "Failed to set cipher algorithm");
1571 }
1572
android_media_MediaDrm_setMacAlgorithmNative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jstring jalgorithm)1573 static void android_media_MediaDrm_setMacAlgorithmNative(
1574 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1575 jstring jalgorithm) {
1576
1577 sp<IDrm> drm = GetDrm(env, jdrm);
1578
1579 if (!CheckSession(env, drm, jsessionId)) {
1580 return;
1581 }
1582
1583 if (jalgorithm == NULL) {
1584 jniThrowException(env, "java/lang/IllegalArgumentException",
1585 "algorithm String is null");
1586 return;
1587 }
1588
1589 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1590 String8 algorithm = JStringToString8(env, jalgorithm);
1591
1592 status_t err = drm->setMacAlgorithm(sessionId, algorithm);
1593
1594 throwExceptionAsNecessary(env, err, "Failed to set mac algorithm");
1595 }
1596
1597
android_media_MediaDrm_encryptNative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jbyteArray jkeyId,jbyteArray jinput,jbyteArray jiv)1598 static jbyteArray android_media_MediaDrm_encryptNative(
1599 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1600 jbyteArray jkeyId, jbyteArray jinput, jbyteArray jiv) {
1601
1602 sp<IDrm> drm = GetDrm(env, jdrm);
1603
1604 if (!CheckSession(env, drm, jsessionId)) {
1605 return NULL;
1606 }
1607
1608 if (jkeyId == NULL || jinput == NULL || jiv == NULL) {
1609 jniThrowException(env, "java/lang/IllegalArgumentException",
1610 "required argument is null");
1611 return NULL;
1612 }
1613
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));
1618 Vector<uint8_t> output;
1619
1620 status_t err = drm->encrypt(sessionId, keyId, input, iv, output);
1621
1622 if (throwExceptionAsNecessary(env, err, "Failed to encrypt")) {
1623 return NULL;
1624 }
1625
1626 return VectorToJByteArray(env, output);
1627 }
1628
android_media_MediaDrm_decryptNative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jbyteArray jkeyId,jbyteArray jinput,jbyteArray jiv)1629 static jbyteArray android_media_MediaDrm_decryptNative(
1630 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1631 jbyteArray jkeyId, jbyteArray jinput, jbyteArray jiv) {
1632
1633 sp<IDrm> drm = GetDrm(env, jdrm);
1634
1635 if (!CheckSession(env, drm, jsessionId)) {
1636 return NULL;
1637 }
1638
1639 if (jkeyId == NULL || jinput == NULL || jiv == NULL) {
1640 jniThrowException(env, "java/lang/IllegalArgumentException",
1641 "required argument is null");
1642 return NULL;
1643 }
1644
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));
1649 Vector<uint8_t> output;
1650
1651 status_t err = drm->decrypt(sessionId, keyId, input, iv, output);
1652 if (throwExceptionAsNecessary(env, err, "Failed to decrypt")) {
1653 return NULL;
1654 }
1655
1656 return VectorToJByteArray(env, output);
1657 }
1658
android_media_MediaDrm_signNative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jbyteArray jkeyId,jbyteArray jmessage)1659 static jbyteArray android_media_MediaDrm_signNative(
1660 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1661 jbyteArray jkeyId, jbyteArray jmessage) {
1662
1663 sp<IDrm> drm = GetDrm(env, jdrm);
1664
1665 if (!CheckSession(env, drm, jsessionId)) {
1666 return NULL;
1667 }
1668
1669 if (jkeyId == NULL || jmessage == NULL) {
1670 jniThrowException(env, "java/lang/IllegalArgumentException",
1671 "required argument is null");
1672 return NULL;
1673 }
1674
1675 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
1676 Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
1677 Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
1678 Vector<uint8_t> signature;
1679
1680 status_t err = drm->sign(sessionId, keyId, message, signature);
1681
1682 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1683 return NULL;
1684 }
1685
1686 return VectorToJByteArray(env, signature);
1687 }
1688
android_media_MediaDrm_verifyNative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jbyteArray jkeyId,jbyteArray jmessage,jbyteArray jsignature)1689 static jboolean android_media_MediaDrm_verifyNative(
1690 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1691 jbyteArray jkeyId, jbyteArray jmessage, jbyteArray jsignature) {
1692
1693 sp<IDrm> drm = GetDrm(env, jdrm);
1694
1695 if (!CheckSession(env, drm, jsessionId)) {
1696 return false;
1697 }
1698
1699 if (jkeyId == NULL || jmessage == NULL || jsignature == NULL) {
1700 jniThrowException(env, "java/lang/IllegalArgumentException",
1701 "required argument is null");
1702 return false;
1703 }
1704
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));
1709 bool match;
1710
1711 status_t err = drm->verify(sessionId, keyId, message, signature, match);
1712
1713 throwExceptionAsNecessary(env, err, "Failed to verify");
1714 return match;
1715 }
1716
1717 static jobject
android_media_MediaDrm_native_getMetrics(JNIEnv * env,jobject thiz)1718 android_media_MediaDrm_native_getMetrics(JNIEnv *env, jobject thiz)
1719 {
1720 sp<IDrm> drm = GetDrm(env, thiz);
1721 if (drm == NULL ) {
1722 jniThrowException(env, "java/lang/IllegalStateException",
1723 "MediaDrm obj is null");
1724 return NULL;
1725 }
1726
1727 // Retrieve current metrics snapshot from drm.
1728 PersistableBundle metrics;
1729 status_t err = drm->getMetrics(&metrics);
1730 if (err != OK) {
1731 ALOGE("getMetrics failed: %d", (int)err);
1732 return (jobject) NULL;
1733 }
1734
1735 return nativeToJavaPersistableBundle(env, thiz, &metrics);
1736 }
1737
android_media_MediaDrm_signRSANative(JNIEnv * env,jobject,jobject jdrm,jbyteArray jsessionId,jstring jalgorithm,jbyteArray jwrappedKey,jbyteArray jmessage)1738 static jbyteArray android_media_MediaDrm_signRSANative(
1739 JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
1740 jstring jalgorithm, jbyteArray jwrappedKey, jbyteArray jmessage) {
1741
1742 sp<IDrm> drm = GetDrm(env, jdrm);
1743
1744 if (!CheckSession(env, drm, jsessionId)) {
1745 return NULL;
1746 }
1747
1748 if (jalgorithm == NULL || jwrappedKey == NULL || jmessage == NULL) {
1749 jniThrowException(env, "java/lang/IllegalArgumentException",
1750 "required argument is null");
1751 return NULL;
1752 }
1753
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));
1758 Vector<uint8_t> signature;
1759
1760 status_t err = drm->signRSA(sessionId, algorithm, message, wrappedKey, signature);
1761
1762 if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
1763 return NULL;
1764 }
1765
1766 return VectorToJByteArray(env, signature);
1767 }
1768
1769
1770 static const JNINativeMethod gMethods[] = {
1771 { "native_release", "()V", (void *)android_media_MediaDrm_native_release },
1772
1773 { "native_init", "()V", (void *)android_media_MediaDrm_native_init },
1774
1775 { "native_setup", "(Ljava/lang/Object;[BLjava/lang/String;)V",
1776 (void *)android_media_MediaDrm_native_setup },
1777
1778 { "isCryptoSchemeSupportedNative", "([BLjava/lang/String;)Z",
1779 (void *)android_media_MediaDrm_isCryptoSchemeSupportedNative },
1780
1781 { "openSession", "(I)[B",
1782 (void *)android_media_MediaDrm_openSession },
1783
1784 { "closeSession", "([B)V",
1785 (void *)android_media_MediaDrm_closeSession },
1786
1787 { "getKeyRequest", "([B[BLjava/lang/String;ILjava/util/HashMap;)"
1788 "Landroid/media/MediaDrm$KeyRequest;",
1789 (void *)android_media_MediaDrm_getKeyRequest },
1790
1791 { "provideKeyResponse", "([B[B)[B",
1792 (void *)android_media_MediaDrm_provideKeyResponse },
1793
1794 { "removeKeys", "([B)V",
1795 (void *)android_media_MediaDrm_removeKeys },
1796
1797 { "restoreKeys", "([B[B)V",
1798 (void *)android_media_MediaDrm_restoreKeys },
1799
1800 { "queryKeyStatus", "([B)Ljava/util/HashMap;",
1801 (void *)android_media_MediaDrm_queryKeyStatus },
1802
1803 { "getProvisionRequestNative", "(ILjava/lang/String;)Landroid/media/MediaDrm$ProvisionRequest;",
1804 (void *)android_media_MediaDrm_getProvisionRequestNative },
1805
1806 { "provideProvisionResponseNative", "([B)Landroid/media/MediaDrm$Certificate;",
1807 (void *)android_media_MediaDrm_provideProvisionResponseNative },
1808
1809 { "getSecureStops", "()Ljava/util/List;",
1810 (void *)android_media_MediaDrm_getSecureStops },
1811
1812 { "getSecureStopIds", "()Ljava/util/List;",
1813 (void *)android_media_MediaDrm_getSecureStopIds },
1814
1815 { "getSecureStop", "([B)[B",
1816 (void *)android_media_MediaDrm_getSecureStop },
1817
1818 { "releaseSecureStops", "([B)V",
1819 (void *)android_media_MediaDrm_releaseSecureStops },
1820
1821 { "removeSecureStop", "([B)V",
1822 (void *)android_media_MediaDrm_removeSecureStop },
1823
1824 { "removeAllSecureStops", "()V",
1825 (void *)android_media_MediaDrm_removeAllSecureStops },
1826
1827 { "getConnectedHdcpLevel", "()I",
1828 (void *)android_media_MediaDrm_getConnectedHdcpLevel },
1829
1830 { "getMaxHdcpLevel", "()I",
1831 (void *)android_media_MediaDrm_getMaxHdcpLevel },
1832
1833 { "getOpenSessionCount", "()I",
1834 (void *)android_media_MediaDrm_getOpenSessionCount },
1835
1836 { "getMaxSessionCount", "()I",
1837 (void *)android_media_MediaDrm_getMaxSessionCount },
1838
1839 { "getSecurityLevel", "([B)I",
1840 (void *)android_media_MediaDrm_getSecurityLevel },
1841
1842 { "getPropertyString", "(Ljava/lang/String;)Ljava/lang/String;",
1843 (void *)android_media_MediaDrm_getPropertyString },
1844
1845 { "getPropertyByteArray", "(Ljava/lang/String;)[B",
1846 (void *)android_media_MediaDrm_getPropertyByteArray },
1847
1848 { "setPropertyString", "(Ljava/lang/String;Ljava/lang/String;)V",
1849 (void *)android_media_MediaDrm_setPropertyString },
1850
1851 { "setPropertyByteArray", "(Ljava/lang/String;[B)V",
1852 (void *)android_media_MediaDrm_setPropertyByteArray },
1853
1854 { "setCipherAlgorithmNative",
1855 "(Landroid/media/MediaDrm;[BLjava/lang/String;)V",
1856 (void *)android_media_MediaDrm_setCipherAlgorithmNative },
1857
1858 { "setMacAlgorithmNative",
1859 "(Landroid/media/MediaDrm;[BLjava/lang/String;)V",
1860 (void *)android_media_MediaDrm_setMacAlgorithmNative },
1861
1862 { "encryptNative", "(Landroid/media/MediaDrm;[B[B[B[B)[B",
1863 (void *)android_media_MediaDrm_encryptNative },
1864
1865 { "decryptNative", "(Landroid/media/MediaDrm;[B[B[B[B)[B",
1866 (void *)android_media_MediaDrm_decryptNative },
1867
1868 { "signNative", "(Landroid/media/MediaDrm;[B[B[B)[B",
1869 (void *)android_media_MediaDrm_signNative },
1870
1871 { "verifyNative", "(Landroid/media/MediaDrm;[B[B[B[B)Z",
1872 (void *)android_media_MediaDrm_verifyNative },
1873
1874 { "signRSANative", "(Landroid/media/MediaDrm;[BLjava/lang/String;[B[B)[B",
1875 (void *)android_media_MediaDrm_signRSANative },
1876
1877 { "getMetricsNative", "()Landroid/os/PersistableBundle;",
1878 (void *)android_media_MediaDrm_native_getMetrics },
1879 };
1880
register_android_media_Drm(JNIEnv * env)1881 int register_android_media_Drm(JNIEnv *env) {
1882 return AndroidRuntime::registerNativeMethods(env,
1883 "android/media/MediaDrm", gMethods, NELEM(gMethods));
1884 }
1885