Home | History | Annotate | Download | only in jni 
      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.
    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 
    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 
    265 JNIDrmListener::~JNIDrmListener()
    266 {
    267     // remove global references
    268     JNIEnv *env = AndroidRuntime::getJNIEnv();
    269     env->DeleteGlobalRef(mObject);
    270     env->DeleteGlobalRef(mClass);
    271 }
    272 
    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 
    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 
    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 
    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 
    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 
    427 JDrm::~JDrm() {
    428     JNIEnv *env = AndroidRuntime::getJNIEnv();
    429 
    430     env->DeleteWeakGlobalRef(mObject);
    431     mObject = NULL;
    432 }
    433 
    434 // static
    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
    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 
    469 status_t JDrm::setListener(const sp<DrmListener>& listener) {
    470     Mutex::Autolock lock(mLock);
    471     mListener = listener;
    472     return OK;
    473 }
    474 
    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 
    487 void JDrm::disconnect() {
    488     if (mDrm != NULL) {
    489         mDrm->destroyPlugin();
    490         mDrm.clear();
    491     }
    492 }
    493 
    494 
    495 // static
    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 
    506 status_t JDrm::initCheck() const {
    507     return mDrm == NULL ? NO_INIT : OK;
    508 }
    509 
    510 // JNI conversion utilities
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
    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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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 
   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
   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 
   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 
   1881 int register_android_media_Drm(JNIEnv *env) {
   1882     return AndroidRuntime::registerNativeMethods(env,
   1883                 "android/media/MediaDrm", gMethods, NELEM(gMethods));
   1884 }
   1885