drm/jni/android_drm_DrmManagerClient.cpp

   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 <JNIHelp.h>
  23 #include <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
  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
  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
  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
 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
 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
 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
 160 JNIOnInfoListener::~JNIOnInfoListener() {
 161     JNIEnv *env = AndroidRuntime::getJNIEnv();
 162     env->DeleteGlobalRef(mObject);
 163     env->DeleteGlobalRef(mClass);
 164 }
 165
 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().string());
 171     ALOGV("JNIOnInfoListener::onInfo => %d | %d | %s", uniqueId, type, event.getMessage().string());
 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
 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
 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
 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
 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
 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
 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.string()));
 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.string()));
 284                 ScopedLocalRef<jstring> valueString(env, env->NewStringUTF(value.string()));
 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
 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.string()));
 324                     ScopedLocalRef<jstring> valueString(env, env->NewStringUTF(value.string()));
 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
 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().string()));
 361
 362         DrmSupportInfo::MimeTypeIterator iterator = info.getMimeTypeIterator();
 363         while (iterator.hasNext()) {
 364             String8  value = iterator.next();
 365             env->CallVoidMethod(drmSupportInfo, addMimeTypeId, env->NewStringUTF(value.string()));
 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.string()));
 373         }
 374
 375         env->SetObjectArrayElement(array, i, drmSupportInfo);
 376     }
 377
 378     delete [] drmSupportInfoArray; drmSupportInfoArray = NULL;
 379     ALOGV("GetAllSupportInfo - Exit");
 380     return array;
 381 }
 382
 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
 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
 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
 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.string(), valueString.string());
 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)).string()),
 492                     env->NewStringUTF((drmInfo.get(DrmInfoRequest::SUBSCRIPTION_ID)).string()));
 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.string()));
 500     }
 501
 502     delete[] mData; mData = NULL;
 503     delete pDrmInfoStatus; pDrmInfoStatus = NULL;
 504
 505     ALOGV("processDrmInfo - Exit");
 506     return drmInfoStatus;
 507 }
 508
 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.string(), valueString.string());
 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().string()));
 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.string()));
 567                 ScopedLocalRef<jstring> valueString(env, env->NewStringUTF(value.string()));
 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
 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
 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.string());
 606 }
 607
 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
 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
 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
 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
 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
 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
 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
 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
 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