• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2010 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 "android_drm_DrmManagerClient"
19 #include <utils/Log.h>
20 
21 #include <jni.h>
22 #include <nativehelper/JNIPlatformHelp.h>
23 #include <nativehelper/ScopedLocalRef.h>
24 #include <android_runtime/AndroidRuntime.h>
25 
26 #include <drm/DrmInfo.h>
27 #include <drm/DrmRights.h>
28 #include <drm/DrmInfoEvent.h>
29 #include <drm/DrmInfoStatus.h>
30 #include <drm/DrmInfoRequest.h>
31 #include <drm/DrmSupportInfo.h>
32 #include <drm/DrmConstraints.h>
33 #include <drm/DrmMetadata.h>
34 #include <drm/DrmConvertedStatus.h>
35 #include <drm/drm_framework_common.h>
36 
37 #include <DrmManagerClientImpl.h>
38 
39 using namespace android;
40 
41 /**
42  * Utility class used to extract the value from the provided java object.
43  * May need to add some utility function to create java object.
44  */
45 class Utility {
46 public:
47     static String8 getStringValue(JNIEnv* env, jobject object, const char* fieldName);
48 
49     static char* getByteArrayValue(
50             JNIEnv* env, jobject object, const char* fieldName, int* dataLength);
51 
52     static char* getByteArrayValue(
53             JNIEnv* env, jbyteArray byteArray, int* dataLength);
54 
55     static String8 getStringValue(JNIEnv* env, jstring string);
56 
57     static int getIntValue(JNIEnv* env, jobject object, const char* fieldName);
58 };
59 
getStringValue(JNIEnv * env,jobject object,const char * fieldName)60 String8 Utility::getStringValue(JNIEnv* env, jobject object, const char* fieldName) {
61     /* Look for the instance field with the name fieldName */
62     jfieldID fieldID
63         = env->GetFieldID(env->GetObjectClass(object), fieldName , "Ljava/lang/String;");
64 
65     if (NULL != fieldID) {
66         jstring valueString = (jstring) env->GetObjectField(object, fieldID);
67         return Utility::getStringValue(env, valueString);
68     }
69 
70     String8 dataString("");
71     return dataString;
72 }
73 
getStringValue(JNIEnv * env,jstring string)74 String8 Utility::getStringValue(JNIEnv* env, jstring string) {
75     String8 dataString("");
76 
77     if (NULL != string && string != env->NewStringUTF("")) {
78         char* bytes = const_cast< char* > (env->GetStringUTFChars(string, NULL));
79 
80         const int length = strlen(bytes) + 1;
81         char *data = new char[length];
82         strncpy(data, bytes, length);
83         dataString = String8(data);
84 
85         env->ReleaseStringUTFChars(string, bytes);
86         delete [] data; data = NULL;
87     }
88     return dataString;
89 }
90 
getByteArrayValue(JNIEnv * env,jobject object,const char * fieldName,int * dataLength)91 char* Utility::getByteArrayValue(
92             JNIEnv* env, jobject object, const char* fieldName, int* dataLength) {
93 
94     *dataLength = 0;
95 
96     jfieldID fieldID = env->GetFieldID(env->GetObjectClass(object), fieldName , "[B");
97 
98     if (NULL != fieldID) {
99         jbyteArray byteArray = (jbyteArray) env->GetObjectField(object, fieldID);
100         return Utility::getByteArrayValue(env, byteArray, dataLength);
101     }
102     return NULL;
103 }
104 
getByteArrayValue(JNIEnv * env,jbyteArray byteArray,int * dataLength)105 char* Utility::getByteArrayValue(JNIEnv* env, jbyteArray byteArray, int* dataLength) {
106     char* data = NULL;
107     if (NULL != byteArray) {
108         jint length = env->GetArrayLength(byteArray);
109 
110         *dataLength = length;
111         if (0 < *dataLength) {
112             data = new char[length];
113             env->GetByteArrayRegion(byteArray, (jint)0, length, (jbyte *) data);
114         }
115     }
116     return data;
117 }
118 
getIntValue(JNIEnv * env,jobject object,const char * fieldName)119 int Utility::getIntValue(JNIEnv* env, jobject object, const char* fieldName) {
120     jfieldID fieldID;
121     int intValue = -1;
122 
123     /* Get a reference to obj’s class */
124     jclass clazz = env->GetObjectClass(object);
125     /* Look for the instance field with the name fieldName */
126     fieldID = env->GetFieldID(clazz, fieldName , "I");
127 
128     if (NULL != fieldID) {
129         intValue = (int) env->GetIntField(object, fieldID);
130     }
131 
132     return intValue;
133 }
134 
135 class JNIOnInfoListener : public DrmManagerClient::OnInfoListener {
136 public:
137     JNIOnInfoListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
138 
139     virtual ~JNIOnInfoListener();
140     void onInfo(const DrmInfoEvent& event);
141 
142 private:
143     JNIOnInfoListener();
144     jclass mClass;
145     jobject mObject;
146 };
147 
JNIOnInfoListener(JNIEnv * env,jobject thiz,jobject weak_thiz)148 JNIOnInfoListener::JNIOnInfoListener(JNIEnv* env, jobject thiz, jobject weak_thiz) {
149     jclass clazz = env->GetObjectClass(thiz);
150 
151     if (clazz == NULL) {
152         ALOGE("Can't find android/drm/DrmManagerClient");
153         jniThrowException(env, "java/lang/Exception", NULL);
154         return;
155     }
156     mClass = (jclass)env->NewGlobalRef(clazz);
157     mObject  = env->NewGlobalRef(weak_thiz);
158 }
159 
~JNIOnInfoListener()160 JNIOnInfoListener::~JNIOnInfoListener() {
161     JNIEnv *env = AndroidRuntime::getJNIEnv();
162     env->DeleteGlobalRef(mObject);
163     env->DeleteGlobalRef(mClass);
164 }
165 
onInfo(const DrmInfoEvent & event)166 void JNIOnInfoListener::onInfo(const DrmInfoEvent& event) {
167     jint uniqueId = event.getUniqueId();
168     jint type = event.getType();
169     JNIEnv *env = AndroidRuntime::getJNIEnv();
170     jstring message = env->NewStringUTF(event.getMessage().c_str());
171     ALOGV("JNIOnInfoListener::onInfo => %d | %d | %s", uniqueId, type, event.getMessage().c_str());
172 
173     env->CallStaticVoidMethod(
174             mClass,
175             env->GetStaticMethodID(mClass, "notify", "(Ljava/lang/Object;IILjava/lang/String;)V"),
176             mObject, uniqueId, type, message);
177 }
178 
179 static Mutex sLock;
180 
setDrmManagerClientImpl(JNIEnv * env,jobject thiz,const sp<DrmManagerClientImpl> & client)181 static sp<DrmManagerClientImpl> setDrmManagerClientImpl(
182             JNIEnv* env, jobject thiz, const sp<DrmManagerClientImpl>& client) {
183     Mutex::Autolock l(sLock);
184     jclass clazz = env->FindClass("android/drm/DrmManagerClient");
185     jfieldID fieldId = env->GetFieldID(clazz, "mNativeContext", "J");
186 
187     jlong oldHandle = env->GetLongField(thiz, fieldId);
188     sp<DrmManagerClientImpl> old = reinterpret_cast<DrmManagerClientImpl*>(oldHandle);
189     if (client.get()) {
190         client->incStrong(thiz);
191     }
192     if (old != 0) {
193         old->decStrong(thiz);
194     }
195     env->SetLongField(thiz, fieldId, reinterpret_cast<jlong>(client.get()));
196     return old;
197 }
198 
getDrmManagerClientImpl(JNIEnv * env,jobject thiz)199 static sp<DrmManagerClientImpl> getDrmManagerClientImpl(JNIEnv* env, jobject thiz) {
200     Mutex::Autolock l(sLock);
201     jclass clazz = env->FindClass("android/drm/DrmManagerClient");
202     jfieldID fieldId = env->GetFieldID(clazz, "mNativeContext", "J");
203 
204     jlong clientHandle = env->GetLongField(thiz, fieldId);
205     DrmManagerClientImpl* const client = reinterpret_cast<DrmManagerClientImpl*>(clientHandle);
206     return sp<DrmManagerClientImpl>(client);
207 }
208 
android_drm_DrmManagerClient_initialize(JNIEnv * env,jobject thiz)209 static jint android_drm_DrmManagerClient_initialize(
210         JNIEnv* env, jobject thiz) {
211     ALOGV("initialize - Enter");
212 
213     int uniqueId = 0;
214     sp<DrmManagerClientImpl> drmManager = DrmManagerClientImpl::create(&uniqueId, false);
215     drmManager->addClient(uniqueId);
216 
217     setDrmManagerClientImpl(env, thiz, drmManager);
218     ALOGV("initialize - Exit");
219     return static_cast<jint>(uniqueId);
220 }
221 
android_drm_DrmManagerClient_setListeners(JNIEnv * env,jobject thiz,jint uniqueId,jobject weak_thiz)222 static void android_drm_DrmManagerClient_setListeners(
223         JNIEnv* env, jobject thiz, jint uniqueId, jobject weak_thiz) {
224     ALOGV("setListeners - Enter");
225 
226     // Set the listener to DrmManager
227     sp<DrmManagerClient::OnInfoListener> listener = new JNIOnInfoListener(env, thiz, weak_thiz);
228     getDrmManagerClientImpl(env, thiz)->setOnInfoListener(uniqueId, listener);
229 
230     ALOGV("setListeners - Exit");
231 }
232 
android_drm_DrmManagerClient_release(JNIEnv * env,jobject thiz,jint uniqueId)233 static void android_drm_DrmManagerClient_release(
234         JNIEnv* env, jobject thiz, jint uniqueId) {
235     ALOGV("release - Enter");
236     getDrmManagerClientImpl(env, thiz)->remove(uniqueId);
237     getDrmManagerClientImpl(env, thiz)->setOnInfoListener(uniqueId, NULL);
238 
239     sp<DrmManagerClientImpl> oldClient = setDrmManagerClientImpl(env, thiz, NULL);
240     if (oldClient != NULL) {
241         oldClient->setOnInfoListener(uniqueId, NULL);
242         oldClient->removeClient(uniqueId);
243     }
244     ALOGV("release - Exit");
245 }
246 
android_drm_DrmManagerClient_getConstraintsFromContent(JNIEnv * env,jobject thiz,jint uniqueId,jstring jpath,jint usage)247 static jobject android_drm_DrmManagerClient_getConstraintsFromContent(
248             JNIEnv* env, jobject thiz, jint uniqueId, jstring jpath, jint usage) {
249     ALOGV("GetConstraints - Enter");
250 
251     const String8 pathString = Utility::getStringValue(env, jpath);
252     DrmConstraints* pConstraints
253         = getDrmManagerClientImpl(env, thiz)->getConstraints(uniqueId, &pathString, usage);
254 
255     jclass localRef = env->FindClass("android/content/ContentValues");
256     jmethodID ContentValues_putByteArray =
257             env->GetMethodID(localRef, "put", "(Ljava/lang/String;[B)V");
258     jmethodID ContentValues_putString =
259             env->GetMethodID(localRef, "put", "(Ljava/lang/String;Ljava/lang/String;)V");
260     jmethodID ContentValues_constructor = env->GetMethodID(localRef, "<init>", "()V");
261     jobject constraints = NULL;
262 
263     if (NULL != localRef && NULL != pConstraints) {
264         // create the java DrmConstraints object
265         constraints = env->NewObject(localRef, ContentValues_constructor);
266 
267         DrmConstraints::KeyIterator keyIt = pConstraints->keyIterator();
268         while (keyIt.hasNext()) {
269             String8 key = keyIt.next();
270 
271             // insert the entry<constraintKey, constraintValue> to newly created java object
272             if (DrmConstraints::EXTENDED_METADATA == key) {
273                 const char* value = pConstraints->getAsByteArray(&key);
274                 if (NULL != value) {
275                     ScopedLocalRef<jbyteArray> dataArray(env, env->NewByteArray(strlen(value)));
276                     ScopedLocalRef<jstring> keyString(env, env->NewStringUTF(key.c_str()));
277                     env->SetByteArrayRegion(dataArray.get(), 0, strlen(value), (jbyte*)value);
278                     env->CallVoidMethod(constraints, ContentValues_putByteArray,
279                                         keyString.get(), dataArray.get());
280                 }
281             } else {
282                 String8 value = pConstraints->get(key);
283                 ScopedLocalRef<jstring> keyString(env, env->NewStringUTF(key.c_str()));
284                 ScopedLocalRef<jstring> valueString(env, env->NewStringUTF(value.c_str()));
285                 env->CallVoidMethod(constraints, ContentValues_putString,
286                                     keyString.get(), valueString.get());
287             }
288         }
289     }
290 
291     delete pConstraints; pConstraints = NULL;
292     ALOGV("GetConstraints - Exit");
293     return constraints;
294 }
295 
android_drm_DrmManagerClient_getMetadataFromContent(JNIEnv * env,jobject thiz,jint uniqueId,jstring jpath)296 static jobject android_drm_DrmManagerClient_getMetadataFromContent(
297             JNIEnv* env, jobject thiz, jint uniqueId, jstring jpath) {
298     ALOGV("GetMetadata - Enter");
299     const String8 pathString = Utility::getStringValue(env, jpath);
300     DrmMetadata* pMetadata =
301             getDrmManagerClientImpl(env, thiz)->getMetadata(uniqueId, &pathString);
302 
303     jobject metadata = NULL;
304 
305     jclass localRef = env->FindClass("android/content/ContentValues");
306     jmethodID ContentValues_putString =
307             env->GetMethodID(localRef, "put", "(Ljava/lang/String;Ljava/lang/String;)V");
308 
309     if (NULL != localRef && NULL != pMetadata) {
310         // Get the constructor id
311         jmethodID constructorId = NULL;
312         constructorId = env->GetMethodID(localRef, "<init>", "()V");
313         if (NULL != constructorId) {
314             // create the java DrmMetadata object
315             metadata = env->NewObject(localRef, constructorId);
316             if (NULL != metadata) {
317                 DrmMetadata::KeyIterator keyIt = pMetadata->keyIterator();
318                 while (keyIt.hasNext()) {
319                     String8 key = keyIt.next();
320                     // insert the entry<constraintKey, constraintValue>
321                     // to newly created java object
322                     String8 value = pMetadata->get(key);
323                     ScopedLocalRef<jstring> keyString(env, env->NewStringUTF(key.c_str()));
324                     ScopedLocalRef<jstring> valueString(env, env->NewStringUTF(value.c_str()));
325                     env->CallVoidMethod(metadata, ContentValues_putString,
326                                         keyString.get(), valueString.get());
327                 }
328             }
329         }
330     }
331     delete pMetadata; pMetadata = NULL;
332     ALOGV("GetMetadata - Exit");
333     return metadata;
334 }
335 
android_drm_DrmManagerClient_getAllSupportInfo(JNIEnv * env,jobject thiz,jint uniqueId)336 static jobjectArray android_drm_DrmManagerClient_getAllSupportInfo(
337             JNIEnv* env, jobject thiz, jint uniqueId) {
338     ALOGV("GetAllSupportInfo - Enter");
339     DrmSupportInfo* drmSupportInfoArray = NULL;
340 
341     int length = 0;
342     getDrmManagerClientImpl(env, thiz)->getAllSupportInfo(uniqueId, &length, &drmSupportInfoArray);
343 
344     jclass clazz = env->FindClass("android/drm/DrmSupportInfo");
345 
346     jobjectArray array = (jobjectArray)env->NewObjectArray(length, clazz, NULL);
347 
348     for (int i = 0; i < length; i++) {
349         DrmSupportInfo info = drmSupportInfoArray[i];
350 
351         jobject drmSupportInfo = env->NewObject(clazz, env->GetMethodID(clazz, "<init>", "()V"));
352 
353         jmethodID addMimeTypeId
354             = env->GetMethodID(clazz, "addMimeType", "(Ljava/lang/String;)V");
355         jmethodID addFileSuffixId
356             = env->GetMethodID(clazz, "addFileSuffix", "(Ljava/lang/String;)V");
357 
358         env->CallVoidMethod(
359             drmSupportInfo, env->GetMethodID(clazz, "setDescription", "(Ljava/lang/String;)V"),
360             env->NewStringUTF(info.getDescription().c_str()));
361 
362         DrmSupportInfo::MimeTypeIterator iterator = info.getMimeTypeIterator();
363         while (iterator.hasNext()) {
364             String8  value = iterator.next();
365             env->CallVoidMethod(drmSupportInfo, addMimeTypeId, env->NewStringUTF(value.c_str()));
366         }
367 
368         DrmSupportInfo::FileSuffixIterator it = info.getFileSuffixIterator();
369         while (it.hasNext()) {
370             String8 value = it.next();
371             env->CallVoidMethod(
372                 drmSupportInfo, addFileSuffixId, env->NewStringUTF(value.c_str()));
373         }
374 
375         env->SetObjectArrayElement(array, i, drmSupportInfo);
376     }
377 
378     delete [] drmSupportInfoArray; drmSupportInfoArray = NULL;
379     ALOGV("GetAllSupportInfo - Exit");
380     return array;
381 }
382 
android_drm_DrmManagerClient_installDrmEngine(JNIEnv *,jobject,jint,jstring)383 static void android_drm_DrmManagerClient_installDrmEngine(
384             JNIEnv* /* env */, jobject /* thiz */, jint /* uniqueId */,
385             jstring /* engineFilePath */) {
386     ALOGV("installDrmEngine - Enter");
387     //getDrmManagerClient(env, thiz)
388     //  ->installDrmEngine(uniqueId, Utility::getStringValue(env, engineFilePath));
389     ALOGV("installDrmEngine - Exit");
390 }
391 
android_drm_DrmManagerClient_saveRights(JNIEnv * env,jobject thiz,jint uniqueId,jobject drmRights,jstring rightsPath,jstring contentPath)392 static jint android_drm_DrmManagerClient_saveRights(
393             JNIEnv* env, jobject thiz, jint uniqueId,
394             jobject drmRights, jstring rightsPath, jstring contentPath) {
395     ALOGV("saveRights - Enter");
396     int result = DRM_ERROR_UNKNOWN;
397     int dataLength = 0;
398     char* mData =  Utility::getByteArrayValue(env, drmRights, "mData", &dataLength);
399 
400     if (NULL != mData) {
401         DrmRights rights(DrmBuffer(mData, dataLength),
402                 Utility::getStringValue(env, drmRights, "mMimeType"),
403                 Utility::getStringValue(env, drmRights, "mAccountId"),
404                 Utility::getStringValue(env, drmRights, "mSubscriptionId"));
405         result = getDrmManagerClientImpl(env, thiz)
406             ->saveRights(uniqueId, rights, Utility::getStringValue(env, rightsPath),
407                                 Utility::getStringValue(env, contentPath));
408     }
409 
410     delete[] mData; mData = NULL;
411     ALOGV("saveRights - Exit");
412     return static_cast<jint>(result);
413 }
414 
android_drm_DrmManagerClient_canHandle(JNIEnv * env,jobject thiz,jint uniqueId,jstring path,jstring mimeType)415 static jboolean android_drm_DrmManagerClient_canHandle(
416             JNIEnv* env, jobject thiz, jint uniqueId, jstring path, jstring mimeType) {
417     ALOGV("canHandle - Enter");
418     jboolean result
419         = getDrmManagerClientImpl(env, thiz)
420             ->canHandle(uniqueId, Utility::getStringValue(env, path),
421                     Utility::getStringValue(env, mimeType));
422     ALOGV("canHandle - Exit");
423     return result;
424 }
425 
android_drm_DrmManagerClient_processDrmInfo(JNIEnv * env,jobject thiz,jint uniqueId,jobject drmInfoObject)426 static jobject android_drm_DrmManagerClient_processDrmInfo(
427             JNIEnv* env, jobject thiz, jint uniqueId, jobject drmInfoObject) {
428     ALOGV("processDrmInfo - Enter");
429     int dataLength = 0;
430     const String8 mMimeType =  Utility::getStringValue(env, drmInfoObject, "mMimeType");
431     char* mData =  Utility::getByteArrayValue(env, drmInfoObject, "mData", &dataLength);
432     int mInfoType = Utility::getIntValue(env, drmInfoObject, "mInfoType");
433 
434     const DrmBuffer buffer(mData, dataLength);
435     DrmInfo drmInfo(mInfoType, buffer, mMimeType);
436 
437     jclass clazz = env->FindClass("android/drm/DrmInfo");
438     jmethodID DrmInfo_get = env->GetMethodID(clazz, "get", "(Ljava/lang/String;)Ljava/lang/Object;");
439     jobject keyIterator
440         = env->CallObjectMethod(drmInfoObject,
441                 env->GetMethodID(clazz, "keyIterator", "()Ljava/util/Iterator;"));
442 
443     jclass Iterator_class = env->FindClass("java/util/Iterator");
444     jmethodID Iterator_hasNext = env->GetMethodID(Iterator_class, "hasNext", "()Z");
445     jmethodID Iterator_next = env->GetMethodID(Iterator_class, "next", "()Ljava/lang/Object;");
446 
447     jclass Object_class = env->FindClass("java/lang/Object");
448     jmethodID Object_toString = env->GetMethodID(Object_class, "toString", "()Ljava/lang/String;");
449 
450     while (env->CallBooleanMethod(keyIterator, Iterator_hasNext)) {
451         ScopedLocalRef<jstring> key(env,
452                 (jstring) env->CallObjectMethod(keyIterator, Iterator_next));
453         ScopedLocalRef<jobject> valueObject(env,
454                 env->CallObjectMethod(drmInfoObject, DrmInfo_get, key.get()));
455         ScopedLocalRef<jstring> valString(env, NULL);
456         if (NULL != valueObject.get()) {
457             valString.reset((jstring) env->CallObjectMethod(valueObject.get(), Object_toString));
458         }
459 
460         String8 keyString = Utility::getStringValue(env, key.get());
461         String8 valueString = Utility::getStringValue(env, valString.get());
462         ALOGV("Key: %s | Value: %s", keyString.c_str(), valueString.c_str());
463 
464         drmInfo.put(keyString, valueString);
465     }
466 
467     DrmInfoStatus* pDrmInfoStatus
468         = getDrmManagerClientImpl(env, thiz)->processDrmInfo(uniqueId, &drmInfo);
469 
470     jclass localRef = env->FindClass("android/drm/DrmInfoStatus");
471     jobject drmInfoStatus = NULL;
472 
473     if (NULL != localRef && NULL != pDrmInfoStatus) {
474         int statusCode = pDrmInfoStatus->statusCode;
475         int infoType = pDrmInfoStatus->infoType;
476 
477         jbyteArray dataArray = NULL;
478         if (NULL != pDrmInfoStatus->drmBuffer) {
479             int length = pDrmInfoStatus->drmBuffer->length;
480             dataArray = env->NewByteArray(length);
481             env->SetByteArrayRegion(
482                 dataArray, 0, length, (jbyte*) pDrmInfoStatus->drmBuffer->data);
483 
484             delete [] pDrmInfoStatus->drmBuffer->data;
485             delete pDrmInfoStatus->drmBuffer; pDrmInfoStatus->drmBuffer = NULL;
486         }
487         jclass clazz = env->FindClass("android/drm/ProcessedData");
488         jmethodID constructorId
489             = env->GetMethodID(clazz, "<init>", "([BLjava/lang/String;Ljava/lang/String;)V");
490         jobject processedData = env->NewObject(clazz, constructorId, dataArray,
491                     env->NewStringUTF((drmInfo.get(DrmInfoRequest::ACCOUNT_ID)).c_str()),
492                     env->NewStringUTF((drmInfo.get(DrmInfoRequest::SUBSCRIPTION_ID)).c_str()));
493 
494         constructorId
495             = env->GetMethodID(localRef,
496                 "<init>", "(IILandroid/drm/ProcessedData;Ljava/lang/String;)V");
497 
498         drmInfoStatus = env->NewObject(localRef, constructorId, statusCode, infoType,
499                 processedData, env->NewStringUTF(pDrmInfoStatus->mimeType.c_str()));
500     }
501 
502     delete[] mData; mData = NULL;
503     delete pDrmInfoStatus; pDrmInfoStatus = NULL;
504 
505     ALOGV("processDrmInfo - Exit");
506     return drmInfoStatus;
507 }
508 
android_drm_DrmManagerClient_acquireDrmInfo(JNIEnv * env,jobject thiz,jint uniqueId,jobject drmInfoRequest)509 static jobject android_drm_DrmManagerClient_acquireDrmInfo(
510             JNIEnv* env, jobject thiz, jint uniqueId, jobject drmInfoRequest) {
511     ALOGV("acquireDrmInfo Enter");
512     const String8 mMimeType =  Utility::getStringValue(env, drmInfoRequest, "mMimeType");
513     int mInfoType = Utility::getIntValue(env, drmInfoRequest, "mInfoType");
514 
515     DrmInfoRequest drmInfoReq(mInfoType, mMimeType);
516 
517     jclass clazz = env->FindClass("android/drm/DrmInfoRequest");
518     jobject keyIterator
519         = env->CallObjectMethod(drmInfoRequest,
520                 env->GetMethodID(clazz, "keyIterator", "()Ljava/util/Iterator;"));
521     jmethodID DrmInfoRequest_get = env->GetMethodID(clazz,
522             "get", "(Ljava/lang/String;)Ljava/lang/Object;");
523 
524     jclass Iterator_class = env->FindClass("java/util/Iterator");
525     jmethodID Iterator_hasNext = env->GetMethodID(Iterator_class, "hasNext", "()Z");
526     jmethodID Iterator_next = env->GetMethodID(Iterator_class, "next", "()Ljava/lang/Object;");
527 
528     while (env->CallBooleanMethod(keyIterator, Iterator_hasNext)) {
529         ScopedLocalRef<jstring> key(env,
530                 (jstring) env->CallObjectMethod(keyIterator, Iterator_next));
531         ScopedLocalRef<jstring> value(env,
532                 (jstring) env->CallObjectMethod(drmInfoRequest, DrmInfoRequest_get, key.get()));
533 
534         String8 keyString = Utility::getStringValue(env, key.get());
535         String8 valueString = Utility::getStringValue(env, value.get());
536         ALOGV("Key: %s | Value: %s", keyString.c_str(), valueString.c_str());
537 
538         drmInfoReq.put(keyString, valueString);
539     }
540 
541     DrmInfo* pDrmInfo = getDrmManagerClientImpl(env, thiz)->acquireDrmInfo(uniqueId, &drmInfoReq);
542 
543     jobject drmInfoObject = NULL;
544 
545     if (NULL != pDrmInfo) {
546         jclass localRef = env->FindClass("android/drm/DrmInfo");
547 
548         if (NULL != localRef) {
549             int length = pDrmInfo->getData().length;
550 
551             jbyteArray dataArray = env->NewByteArray(length);
552             env->SetByteArrayRegion(dataArray, 0, length, (jbyte*)pDrmInfo->getData().data);
553 
554             drmInfoObject
555                 = env->NewObject(localRef,
556                     env->GetMethodID(localRef, "<init>", "(I[BLjava/lang/String;)V"),
557                     mInfoType, dataArray, env->NewStringUTF(pDrmInfo->getMimeType().c_str()));
558 
559             DrmInfo::KeyIterator it = pDrmInfo->keyIterator();
560             jmethodID putMethodId
561                 = env->GetMethodID(localRef, "put", "(Ljava/lang/String;Ljava/lang/Object;)V");
562 
563             while (it.hasNext()) {
564                 String8 key = it.next();
565                 String8 value = pDrmInfo->get(key);
566                 ScopedLocalRef<jstring> keyString(env, env->NewStringUTF(key.c_str()));
567                 ScopedLocalRef<jstring> valueString(env, env->NewStringUTF(value.c_str()));
568                 env->CallVoidMethod(drmInfoObject, putMethodId,
569                     keyString.get(), valueString.get());
570             }
571         }
572         delete [] pDrmInfo->getData().data;
573     }
574 
575     delete pDrmInfo; pDrmInfo = NULL;
576 
577     ALOGV("acquireDrmInfo Exit");
578     return drmInfoObject;
579 }
580 
android_drm_DrmManagerClient_getDrmObjectType(JNIEnv * env,jobject thiz,jint uniqueId,jstring path,jstring mimeType)581 static jint android_drm_DrmManagerClient_getDrmObjectType(
582             JNIEnv* env, jobject thiz, jint uniqueId, jstring path, jstring mimeType) {
583     ALOGV("getDrmObjectType Enter");
584     int drmObjectType
585         = getDrmManagerClientImpl(env, thiz)
586             ->getDrmObjectType(uniqueId, Utility::getStringValue(env, path),
587                                 Utility::getStringValue(env, mimeType));
588     ALOGV("getDrmObjectType Exit");
589     return static_cast<jint>(drmObjectType);
590 }
591 
android_drm_DrmManagerClient_getOriginalMimeType(JNIEnv * env,jobject thiz,jint uniqueId,jstring path,jobject fileDescriptor)592 static jstring android_drm_DrmManagerClient_getOriginalMimeType(
593             JNIEnv* env, jobject thiz, jint uniqueId, jstring path, jobject fileDescriptor) {
594     ALOGV("getOriginalMimeType Enter");
595 
596     int fd = (fileDescriptor == NULL)
597                 ? -1
598                 : jniGetFDFromFileDescriptor(env, fileDescriptor);
599 
600     String8 mimeType
601         = getDrmManagerClientImpl(env, thiz)
602             ->getOriginalMimeType(uniqueId,
603                                   Utility::getStringValue(env, path), fd);
604     ALOGV("getOriginalMimeType Exit");
605     return env->NewStringUTF(mimeType.c_str());
606 }
607 
android_drm_DrmManagerClient_checkRightsStatus(JNIEnv * env,jobject thiz,jint uniqueId,jstring path,int action)608 static jint android_drm_DrmManagerClient_checkRightsStatus(
609             JNIEnv* env, jobject thiz, jint uniqueId, jstring path, int action) {
610     ALOGV("checkRightsStatus Enter");
611     int rightsStatus
612         = getDrmManagerClientImpl(env, thiz)
613             ->checkRightsStatus(uniqueId, Utility::getStringValue(env, path), action);
614     ALOGV("checkRightsStatus Exit");
615     return static_cast<jint>(rightsStatus);
616 }
617 
android_drm_DrmManagerClient_removeRights(JNIEnv * env,jobject thiz,jint uniqueId,jstring path)618 static jint android_drm_DrmManagerClient_removeRights(
619             JNIEnv* env, jobject thiz, jint uniqueId, jstring path) {
620     ALOGV("removeRights");
621     return static_cast<jint>(getDrmManagerClientImpl(env, thiz)
622                ->removeRights(uniqueId, Utility::getStringValue(env, path)));
623 }
624 
android_drm_DrmManagerClient_removeAllRights(JNIEnv * env,jobject thiz,jint uniqueId)625 static jint android_drm_DrmManagerClient_removeAllRights(
626             JNIEnv* env, jobject thiz, jint uniqueId) {
627     ALOGV("removeAllRights");
628     return static_cast<jint>(getDrmManagerClientImpl(env, thiz)
629                 ->removeAllRights(uniqueId));
630 }
631 
android_drm_DrmManagerClient_openConvertSession(JNIEnv * env,jobject thiz,jint uniqueId,jstring mimeType)632 static jint android_drm_DrmManagerClient_openConvertSession(
633             JNIEnv* env, jobject thiz, jint uniqueId, jstring mimeType) {
634     ALOGV("openConvertSession Enter");
635     int convertId
636         = getDrmManagerClientImpl(env, thiz)
637             ->openConvertSession(uniqueId, Utility::getStringValue(env, mimeType));
638     ALOGV("openConvertSession Exit");
639     return static_cast<jint>(convertId);
640 }
641 
GetConvertedStatus(JNIEnv * env,DrmConvertedStatus * pDrmConvertedStatus)642 static jobject GetConvertedStatus(JNIEnv* env, DrmConvertedStatus* pDrmConvertedStatus) {
643     ALOGV("GetConvertedStatus - Enter");
644     jclass localRef = env->FindClass("android/drm/DrmConvertedStatus");
645 
646     jobject drmConvertedStatus = NULL;
647 
648     if (NULL != localRef && NULL != pDrmConvertedStatus) {
649         int statusCode = pDrmConvertedStatus->statusCode;
650 
651         jbyteArray dataArray = NULL;
652         if (NULL != pDrmConvertedStatus->convertedData) {
653             int length = pDrmConvertedStatus->convertedData->length;
654             dataArray = env->NewByteArray(length);
655             env->SetByteArrayRegion(
656                 dataArray, 0, length, (jbyte*) pDrmConvertedStatus->convertedData->data);
657 
658             delete [] pDrmConvertedStatus->convertedData->data;
659             delete pDrmConvertedStatus->convertedData; pDrmConvertedStatus->convertedData = NULL;
660         }
661         jmethodID constructorId = env->GetMethodID(localRef, "<init>", "(I[BI)V");
662         drmConvertedStatus
663             = env->NewObject(localRef, constructorId,
664                              statusCode, dataArray, pDrmConvertedStatus->offset);
665     }
666 
667     delete pDrmConvertedStatus; pDrmConvertedStatus = NULL;
668 
669     ALOGV("GetConvertedStatus - Exit");
670     return drmConvertedStatus;
671 }
672 
android_drm_DrmManagerClient_convertData(JNIEnv * env,jobject thiz,jint uniqueId,jint convertId,jbyteArray inputData)673 static jobject android_drm_DrmManagerClient_convertData(
674             JNIEnv* env, jobject thiz, jint uniqueId, jint convertId, jbyteArray inputData) {
675     ALOGV("convertData Enter");
676 
677     int dataLength = 0;
678     char* mData = Utility::getByteArrayValue(env, inputData, &dataLength);
679     const DrmBuffer buffer(mData, dataLength);
680 
681     DrmConvertedStatus* pDrmConvertedStatus
682             = getDrmManagerClientImpl(env, thiz)->convertData(uniqueId, convertId, &buffer);
683     jobject status = GetConvertedStatus(env, pDrmConvertedStatus);
684 
685     delete[] mData;
686     mData = NULL;
687 
688     ALOGV("convertData - Exit");
689     return status;
690 }
691 
android_drm_DrmManagerClient_closeConvertSession(JNIEnv * env,jobject thiz,jint uniqueId,jint convertId)692 static jobject android_drm_DrmManagerClient_closeConvertSession(
693             JNIEnv* env, jobject thiz, jint uniqueId, jint convertId) {
694 
695     ALOGV("closeConvertSession Enter");
696 
697     DrmConvertedStatus* pDrmConvertedStatus
698                 = getDrmManagerClientImpl(env, thiz)->closeConvertSession(uniqueId, convertId);
699     jobject status = GetConvertedStatus(env, pDrmConvertedStatus);
700 
701     ALOGV("closeConvertSession - Exit");
702     return status;
703 }
704 
705 static const JNINativeMethod nativeMethods[] = {
706 
707     {"_initialize", "()I",
708                                     (void*)android_drm_DrmManagerClient_initialize},
709 
710     {"_setListeners", "(ILjava/lang/Object;)V",
711                                     (void*)android_drm_DrmManagerClient_setListeners},
712 
713     {"_release", "(I)V",
714                                     (void*)android_drm_DrmManagerClient_release},
715 
716     {"_getConstraints", "(ILjava/lang/String;I)Landroid/content/ContentValues;",
717                                     (void*)android_drm_DrmManagerClient_getConstraintsFromContent},
718 
719     {"_getMetadata", "(ILjava/lang/String;)Landroid/content/ContentValues;",
720                                     (void*)android_drm_DrmManagerClient_getMetadataFromContent},
721 
722     {"_getAllSupportInfo", "(I)[Landroid/drm/DrmSupportInfo;",
723                                     (void*)android_drm_DrmManagerClient_getAllSupportInfo},
724 
725     {"_installDrmEngine", "(ILjava/lang/String;)V",
726                                     (void*)android_drm_DrmManagerClient_installDrmEngine},
727 
728     {"_canHandle", "(ILjava/lang/String;Ljava/lang/String;)Z",
729                                     (void*)android_drm_DrmManagerClient_canHandle},
730 
731     {"_processDrmInfo", "(ILandroid/drm/DrmInfo;)Landroid/drm/DrmInfoStatus;",
732                                     (void*)android_drm_DrmManagerClient_processDrmInfo},
733 
734     {"_acquireDrmInfo", "(ILandroid/drm/DrmInfoRequest;)Landroid/drm/DrmInfo;",
735                                     (void*)android_drm_DrmManagerClient_acquireDrmInfo},
736 
737     {"_saveRights", "(ILandroid/drm/DrmRights;Ljava/lang/String;Ljava/lang/String;)I",
738                                     (void*)android_drm_DrmManagerClient_saveRights},
739 
740     {"_getDrmObjectType", "(ILjava/lang/String;Ljava/lang/String;)I",
741                                     (void*)android_drm_DrmManagerClient_getDrmObjectType},
742 
743     {"_getOriginalMimeType", "(ILjava/lang/String;Ljava/io/FileDescriptor;)Ljava/lang/String;",
744                                     (void*)android_drm_DrmManagerClient_getOriginalMimeType},
745 
746     {"_checkRightsStatus", "(ILjava/lang/String;I)I",
747                                     (void*)android_drm_DrmManagerClient_checkRightsStatus},
748 
749     {"_removeRights", "(ILjava/lang/String;)I",
750                                     (void*)android_drm_DrmManagerClient_removeRights},
751 
752     {"_removeAllRights", "(I)I",
753                                     (void*)android_drm_DrmManagerClient_removeAllRights},
754 
755     {"_openConvertSession", "(ILjava/lang/String;)I",
756                                     (void*)android_drm_DrmManagerClient_openConvertSession},
757 
758     {"_convertData", "(II[B)Landroid/drm/DrmConvertedStatus;",
759                                     (void*)android_drm_DrmManagerClient_convertData},
760 
761     {"_closeConvertSession", "(II)Landroid/drm/DrmConvertedStatus;",
762                                     (void*)android_drm_DrmManagerClient_closeConvertSession},
763 };
764 
registerNativeMethods(JNIEnv * env)765 static int registerNativeMethods(JNIEnv* env) {
766     int result = -1;
767 
768     /* look up the class */
769     jclass clazz = env->FindClass("android/drm/DrmManagerClient");
770 
771     if (NULL != clazz) {
772         if (env->RegisterNatives(clazz, nativeMethods, sizeof(nativeMethods)
773                 / sizeof(nativeMethods[0])) == JNI_OK) {
774             result = 0;
775         }
776     }
777     return result;
778 }
779 
JNI_OnLoad(JavaVM * vm,void *)780 jint JNI_OnLoad(JavaVM* vm, void* /* reserved */) {
781     JNIEnv* env = NULL;
782     jint result = -1;
783 
784     if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) == JNI_OK) {
785         if (NULL != env && registerNativeMethods(env) == 0) {
786             result = JNI_VERSION_1_4;
787         }
788     }
789     return result;
790 }
791 
792