openkylin
/
android-platform-frameworks-base
mirror of https://gitee.com/openkylin/android-platform-frameworks-base.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity
android-platform-frameworks.../media/jni/android_media_MediaDrm.cpp

1540 lines
49 KiB
C++
Raw Blame History

/*
* Copyright 2013, The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaDrm-JNI"
#include <utils/Log.h>
#include "android_media_MediaDrm.h"
#include "android_runtime/AndroidRuntime.h"
#include "android_runtime/Log.h"
#include "android_os_Parcel.h"
#include "jni.h"
#include <nativehelper/JNIHelp.h>
#include <binder/IServiceManager.h>
#include <binder/Parcel.h>
#include <cutils/properties.h>
#include <media/IDrm.h>
#include <media/IMediaDrmService.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/MediaErrors.h>
namespace android {
#define FIND_CLASS(var, className) \
var = env->FindClass(className); \
LOG_FATAL_IF(! (var), "Unable to find class " className);
#define GET_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
var = env->GetFieldID(clazz, fieldName, fieldDescriptor); \
LOG_FATAL_IF(! (var), "Unable to find field " fieldName);
#define GET_METHOD_ID(var, clazz, fieldName, fieldDescriptor) \
var = env->GetMethodID(clazz, fieldName, fieldDescriptor); \
LOG_FATAL_IF(! (var), "Unable to find method " fieldName);
#define GET_STATIC_FIELD_ID(var, clazz, fieldName, fieldDescriptor) \
var = env->GetStaticFieldID(clazz, fieldName, fieldDescriptor); \
LOG_FATAL_IF(! (var), "Unable to find field " fieldName);
#define GET_STATIC_METHOD_ID(var, clazz, fieldName, fieldDescriptor) \
var = env->GetStaticMethodID(clazz, fieldName, fieldDescriptor); \
LOG_FATAL_IF(! (var), "Unable to find static method " fieldName);
struct RequestFields {
jfieldID data;
jfieldID defaultUrl;
jfieldID requestType;
};
struct ArrayListFields {
jmethodID init;
jmethodID add;
};
struct HashmapFields {
jmethodID init;
jmethodID get;
jmethodID put;
jmethodID entrySet;
};
struct SetFields {
jmethodID iterator;
};
struct IteratorFields {
jmethodID next;
jmethodID hasNext;
};
struct EntryFields {
jmethodID getKey;
jmethodID getValue;
};
struct EventTypes {
jint kEventProvisionRequired;
jint kEventKeyRequired;
jint kEventKeyExpired;
jint kEventVendorDefined;
jint kEventSessionReclaimed;
} gEventTypes;
struct EventWhat {
jint kWhatDrmEvent;
jint kWhatExpirationUpdate;
jint kWhatKeyStatusChange;
} gEventWhat;
struct KeyTypes {
jint kKeyTypeStreaming;
jint kKeyTypeOffline;
jint kKeyTypeRelease;
} gKeyTypes;
struct KeyRequestTypes {
jint kKeyRequestTypeInitial;
jint kKeyRequestTypeRenewal;
jint kKeyRequestTypeRelease;
} gKeyRequestTypes;
struct CertificateTypes {
jint kCertificateTypeNone;
jint kCertificateTypeX509;
} gCertificateTypes;
struct CertificateFields {
jfieldID wrappedPrivateKey;
jfieldID certificateData;
};
struct StateExceptionFields {
jmethodID init;
jclass classId;
};
struct fields_t {
jfieldID context;
jmethodID post_event;
RequestFields keyRequest;
RequestFields provisionRequest;
ArrayListFields arraylist;
HashmapFields hashmap;
SetFields set;
IteratorFields iterator;
EntryFields entry;
CertificateFields certificate;
StateExceptionFields stateException;
jclass certificateClassId;
jclass hashmapClassId;
jclass arraylistClassId;
jclass stringClassId;
};
static fields_t gFields;
// ----------------------------------------------------------------------------
// ref-counted object for callbacks
class JNIDrmListener: public DrmListener
{
public:
JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz);
~JNIDrmListener();
virtual void notify(DrmPlugin::EventType eventType, int extra, const Parcel *obj = NULL);
private:
JNIDrmListener();
jclass mClass; // Reference to MediaDrm class
jobject mObject; // Weak ref to MediaDrm Java object to call on
};
JNIDrmListener::JNIDrmListener(JNIEnv* env, jobject thiz, jobject weak_thiz)
{
// Hold onto the MediaDrm class for use in calling the static method
// that posts events to the application thread.
jclass clazz = env->GetObjectClass(thiz);
if (clazz == NULL) {
ALOGE("Can't find android/media/MediaDrm");
jniThrowException(env, "java/lang/Exception",
"Can't find android/media/MediaDrm");
return;
}
mClass = (jclass)env->NewGlobalRef(clazz);
// We use a weak reference so the MediaDrm object can be garbage collected.
// The reference is only used as a proxy for callbacks.
mObject = env->NewGlobalRef(weak_thiz);
}
JNIDrmListener::~JNIDrmListener()
{
// remove global references
JNIEnv *env = AndroidRuntime::getJNIEnv();
env->DeleteGlobalRef(mObject);
env->DeleteGlobalRef(mClass);
}
void JNIDrmListener::notify(DrmPlugin::EventType eventType, int extra,
const Parcel *obj)
{
jint jwhat;
jint jeventType = 0;
// translate DrmPlugin event types into their java equivalents
switch (eventType) {
case DrmPlugin::kDrmPluginEventProvisionRequired:
jwhat = gEventWhat.kWhatDrmEvent;
jeventType = gEventTypes.kEventProvisionRequired;
break;
case DrmPlugin::kDrmPluginEventKeyNeeded:
jwhat = gEventWhat.kWhatDrmEvent;
jeventType = gEventTypes.kEventKeyRequired;
break;
case DrmPlugin::kDrmPluginEventKeyExpired:
jwhat = gEventWhat.kWhatDrmEvent;
jeventType = gEventTypes.kEventKeyExpired;
break;
case DrmPlugin::kDrmPluginEventVendorDefined:
jwhat = gEventWhat.kWhatDrmEvent;
jeventType = gEventTypes.kEventVendorDefined;
break;
case DrmPlugin::kDrmPluginEventSessionReclaimed:
jwhat = gEventWhat.kWhatDrmEvent;
jeventType = gEventTypes.kEventSessionReclaimed;
break;
case DrmPlugin::kDrmPluginEventExpirationUpdate:
jwhat = gEventWhat.kWhatExpirationUpdate;
break;
case DrmPlugin::kDrmPluginEventKeysChange:
jwhat = gEventWhat.kWhatKeyStatusChange;
break;
default:
ALOGE("Invalid event DrmPlugin::EventType %d, ignored", (int)eventType);
return;
}
JNIEnv *env = AndroidRuntime::getJNIEnv();
if (obj && obj->dataSize() > 0) {
jobject jParcel = createJavaParcelObject(env);
if (jParcel != NULL) {
Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
nativeParcel->setData(obj->data(), obj->dataSize());
env->CallStaticVoidMethod(mClass, gFields.post_event, mObject,
jwhat, jeventType, extra, jParcel);
env->DeleteLocalRef(jParcel);
}
}
if (env->ExceptionCheck()) {
ALOGW("An exception occurred while notifying an event.");
LOGW_EX(env);
env->ExceptionClear();
}
}
static void throwStateException(JNIEnv *env, const char *msg, status_t err) {
ALOGE("Illegal state exception: %s (%d)", msg, err);
jobject exception = env->NewObject(gFields.stateException.classId,
gFields.stateException.init, static_cast<int>(err),
env->NewStringUTF(msg));
env->Throw(static_cast<jthrowable>(exception));
}
static bool throwExceptionAsNecessary(
JNIEnv *env, status_t err, const char *msg = NULL) {
const char *drmMessage = NULL;
switch (err) {
case ERROR_DRM_UNKNOWN:
drmMessage = "General DRM error";
break;
case ERROR_DRM_NO_LICENSE:
drmMessage = "No license";
break;
case ERROR_DRM_LICENSE_EXPIRED:
drmMessage = "License expired";
break;
case ERROR_DRM_SESSION_NOT_OPENED:
drmMessage = "Session not opened";
break;
case ERROR_DRM_DECRYPT_UNIT_NOT_INITIALIZED:
drmMessage = "Not initialized";
break;
case ERROR_DRM_DECRYPT:
drmMessage = "Decrypt error";
break;
case ERROR_DRM_CANNOT_HANDLE:
drmMessage = "Unsupported scheme or data format";
break;
case ERROR_DRM_TAMPER_DETECTED:
drmMessage = "Invalid state";
break;
default:
break;
}
String8 vendorMessage;
if (err >= ERROR_DRM_VENDOR_MIN && err <= ERROR_DRM_VENDOR_MAX) {
vendorMessage = String8::format("DRM vendor-defined error: %d", err);
drmMessage = vendorMessage.string();
}
if (err == BAD_VALUE) {
jniThrowException(env, "java/lang/IllegalArgumentException", msg);
return true;
} else if (err == ERROR_DRM_NOT_PROVISIONED) {
jniThrowException(env, "android/media/NotProvisionedException", msg);
return true;
} else if (err == ERROR_DRM_RESOURCE_BUSY) {
jniThrowException(env, "android/media/ResourceBusyException", msg);
return true;
} else if (err == ERROR_DRM_DEVICE_REVOKED) {
jniThrowException(env, "android/media/DeniedByServerException", msg);
return true;
} else if (err == DEAD_OBJECT) {
jniThrowException(env, "android/media/MediaDrmResetException",
"mediaserver died");
return true;
} else if (err != OK) {
String8 errbuf;
if (drmMessage != NULL) {
if (msg == NULL) {
msg = drmMessage;
} else {
errbuf = String8::format("%s: %s", msg, drmMessage);
msg = errbuf.string();
}
}
throwStateException(env, msg, err);
return true;
}
return false;
}
static sp<IDrm> GetDrm(JNIEnv *env, jobject thiz) {
JDrm *jdrm = (JDrm *)env->GetLongField(thiz, gFields.context);
return jdrm ? jdrm->getDrm() : NULL;
}
JDrm::JDrm(
JNIEnv *env, jobject thiz, const uint8_t uuid[16],
const String8 &appPackageName) {
mObject = env->NewWeakGlobalRef(thiz);
mDrm = MakeDrm(uuid, appPackageName);
if (mDrm != NULL) {
mDrm->setListener(this);
}
}
JDrm::~JDrm() {
JNIEnv *env = AndroidRuntime::getJNIEnv();
env->DeleteWeakGlobalRef(mObject);
mObject = NULL;
}
// static
sp<IDrm> JDrm::MakeDrm() {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("media.drm"));
sp<IMediaDrmService> service = interface_cast<IMediaDrmService>(binder);
if (service == NULL) {
return NULL;
}
sp<IDrm> drm = service->makeDrm();
if (drm == NULL || (drm->initCheck() != OK && drm->initCheck() != NO_INIT)) {
return NULL;
}
return drm;
}
// static
sp<IDrm> JDrm::MakeDrm(const uint8_t uuid[16], const String8 &appPackageName) {
sp<IDrm> drm = MakeDrm();
if (drm == NULL) {
return NULL;
}
status_t err = drm->createPlugin(uuid, appPackageName);
if (err != OK) {
return NULL;
}
return drm;
}
status_t JDrm::setListener(const sp<DrmListener>& listener) {
Mutex::Autolock lock(mLock);
mListener = listener;
return OK;
}
void JDrm::notify(DrmPlugin::EventType eventType, int extra, const Parcel *obj) {
sp<DrmListener> listener;
mLock.lock();
listener = mListener;
mLock.unlock();
if (listener != NULL) {
Mutex::Autolock lock(mNotifyLock);
listener->notify(eventType, extra, obj);
}
}
void JDrm::disconnect() {
if (mDrm != NULL) {
mDrm->destroyPlugin();
mDrm.clear();
}
}
// static
bool JDrm::IsCryptoSchemeSupported(const uint8_t uuid[16], const String8 &mimeType) {
sp<IDrm> drm = MakeDrm();
if (drm == NULL) {
return false;
}
return drm->isCryptoSchemeSupported(uuid, mimeType);
}
status_t JDrm::initCheck() const {
return mDrm == NULL ? NO_INIT : OK;
}
// JNI conversion utilities
static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
Vector<uint8_t> vector;
size_t length = env->GetArrayLength(byteArray);
vector.insertAt((size_t)0, length);
env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
return vector;
}
static jbyteArray VectorToJByteArray(JNIEnv *env, Vector<uint8_t> const &vector) {
size_t length = vector.size();
jbyteArray result = env->NewByteArray(length);
if (result != NULL) {
env->SetByteArrayRegion(result, 0, length, (jbyte *)vector.array());
}
return result;
}
static String8 JStringToString8(JNIEnv *env, jstring const &jstr) {
String8 result;
const char *s = env->GetStringUTFChars(jstr, NULL);
if (s) {
result = s;
env->ReleaseStringUTFChars(jstr, s);
}
return result;
}
/*
import java.util.HashMap;
import java.util.Set;
import java.Map.Entry;
import jav.util.Iterator;
HashMap<k, v> hm;
Set<Entry<k, v> > s = hm.entrySet();
Iterator i = s.iterator();
Entry e = s.next();
*/
static KeyedVector<String8, String8> HashMapToKeyedVector(
JNIEnv *env, jobject &hashMap, bool* pIsOK) {
jclass clazz = gFields.stringClassId;
KeyedVector<String8, String8> keyedVector;
*pIsOK = true;
jobject entrySet = env->CallObjectMethod(hashMap, gFields.hashmap.entrySet);
if (entrySet) {
jobject iterator = env->CallObjectMethod(entrySet, gFields.set.iterator);
if (iterator) {
jboolean hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
while (hasNext) {
jobject entry = env->CallObjectMethod(iterator, gFields.iterator.next);
if (entry) {
jobject obj = env->CallObjectMethod(entry, gFields.entry.getKey);
if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"HashMap key is not a String");
env->DeleteLocalRef(entry);
*pIsOK = false;
break;
}
jstring jkey = static_cast<jstring>(obj);
obj = env->CallObjectMethod(entry, gFields.entry.getValue);
if (obj == NULL || !env->IsInstanceOf(obj, clazz)) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"HashMap value is not a String");
env->DeleteLocalRef(entry);
*pIsOK = false;
break;
}
jstring jvalue = static_cast<jstring>(obj);
String8 key = JStringToString8(env, jkey);
String8 value = JStringToString8(env, jvalue);
keyedVector.add(key, value);
env->DeleteLocalRef(jkey);
env->DeleteLocalRef(jvalue);
hasNext = env->CallBooleanMethod(iterator, gFields.iterator.hasNext);
}
env->DeleteLocalRef(entry);
}
env->DeleteLocalRef(iterator);
}
env->DeleteLocalRef(entrySet);
}
return keyedVector;
}
static jobject KeyedVectorToHashMap (JNIEnv *env, KeyedVector<String8, String8> const &map) {
jclass clazz = gFields.hashmapClassId;
jobject hashMap = env->NewObject(clazz, gFields.hashmap.init);
for (size_t i = 0; i < map.size(); ++i) {
jstring jkey = env->NewStringUTF(map.keyAt(i).string());
jstring jvalue = env->NewStringUTF(map.valueAt(i).string());
env->CallObjectMethod(hashMap, gFields.hashmap.put, jkey, jvalue);
env->DeleteLocalRef(jkey);
env->DeleteLocalRef(jvalue);
}
return hashMap;
}
static jobject ListOfVectorsToArrayListOfByteArray(JNIEnv *env,
List<Vector<uint8_t> > list) {
jclass clazz = gFields.arraylistClassId;
jobject arrayList = env->NewObject(clazz, gFields.arraylist.init);
List<Vector<uint8_t> >::iterator iter = list.begin();
while (iter != list.end()) {
jbyteArray byteArray = VectorToJByteArray(env, *iter);
env->CallBooleanMethod(arrayList, gFields.arraylist.add, byteArray);
env->DeleteLocalRef(byteArray);
iter++;
}
return arrayList;
}
} // namespace android
using namespace android;
static sp<JDrm> setDrm(
JNIEnv *env, jobject thiz, const sp<JDrm> &drm) {
sp<JDrm> old = (JDrm *)env->GetLongField(thiz, gFields.context);
if (drm != NULL) {
drm->incStrong(thiz);
}
if (old != NULL) {
old->decStrong(thiz);
}
env->SetLongField(thiz, gFields.context, reinterpret_cast<jlong>(drm.get()));
return old;
}
static bool CheckSession(JNIEnv *env, const sp<IDrm> &drm, jbyteArray const &jsessionId)
{
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException", "MediaDrm obj is null");
return false;
}
if (jsessionId == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException", "sessionId is null");
return false;
}
return true;
}
static void android_media_MediaDrm_release(JNIEnv *env, jobject thiz) {
sp<JDrm> drm = setDrm(env, thiz, NULL);
if (drm != NULL) {
drm->setListener(NULL);
drm->disconnect();
}
}
static void android_media_MediaDrm_native_init(JNIEnv *env) {
jclass clazz;
FIND_CLASS(clazz, "android/media/MediaDrm");
GET_FIELD_ID(gFields.context, clazz, "mNativeContext", "J");
GET_STATIC_METHOD_ID(gFields.post_event, clazz, "postEventFromNative",
"(Ljava/lang/Object;IIILjava/lang/Object;)V");
jfieldID field;
GET_STATIC_FIELD_ID(field, clazz, "EVENT_PROVISION_REQUIRED", "I");
gEventTypes.kEventProvisionRequired = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "EVENT_KEY_REQUIRED", "I");
gEventTypes.kEventKeyRequired = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "EVENT_KEY_EXPIRED", "I");
gEventTypes.kEventKeyExpired = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "EVENT_VENDOR_DEFINED", "I");
gEventTypes.kEventVendorDefined = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "EVENT_SESSION_RECLAIMED", "I");
gEventTypes.kEventSessionReclaimed = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "DRM_EVENT", "I");
gEventWhat.kWhatDrmEvent = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "EXPIRATION_UPDATE", "I");
gEventWhat.kWhatExpirationUpdate = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "KEY_STATUS_CHANGE", "I");
gEventWhat.kWhatKeyStatusChange = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "KEY_TYPE_STREAMING", "I");
gKeyTypes.kKeyTypeStreaming = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "KEY_TYPE_OFFLINE", "I");
gKeyTypes.kKeyTypeOffline = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "KEY_TYPE_RELEASE", "I");
gKeyTypes.kKeyTypeRelease = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "CERTIFICATE_TYPE_NONE", "I");
gCertificateTypes.kCertificateTypeNone = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "CERTIFICATE_TYPE_X509", "I");
gCertificateTypes.kCertificateTypeX509 = env->GetStaticIntField(clazz, field);
FIND_CLASS(clazz, "android/media/MediaDrm$KeyRequest");
GET_FIELD_ID(gFields.keyRequest.data, clazz, "mData", "[B");
GET_FIELD_ID(gFields.keyRequest.defaultUrl, clazz, "mDefaultUrl", "Ljava/lang/String;");
GET_FIELD_ID(gFields.keyRequest.requestType, clazz, "mRequestType", "I");
GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_INITIAL", "I");
gKeyRequestTypes.kKeyRequestTypeInitial = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_RENEWAL", "I");
gKeyRequestTypes.kKeyRequestTypeRenewal = env->GetStaticIntField(clazz, field);
GET_STATIC_FIELD_ID(field, clazz, "REQUEST_TYPE_RELEASE", "I");
gKeyRequestTypes.kKeyRequestTypeRelease = env->GetStaticIntField(clazz, field);
FIND_CLASS(clazz, "android/media/MediaDrm$ProvisionRequest");
GET_FIELD_ID(gFields.provisionRequest.data, clazz, "mData", "[B");
GET_FIELD_ID(gFields.provisionRequest.defaultUrl, clazz, "mDefaultUrl", "Ljava/lang/String;");
FIND_CLASS(clazz, "android/media/MediaDrm$Certificate");
GET_FIELD_ID(gFields.certificate.wrappedPrivateKey, clazz, "mWrappedKey", "[B");
GET_FIELD_ID(gFields.certificate.certificateData, clazz, "mCertificateData", "[B");
gFields.certificateClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
FIND_CLASS(clazz, "java/util/ArrayList");
GET_METHOD_ID(gFields.arraylist.init, clazz, "<init>", "()V");
GET_METHOD_ID(gFields.arraylist.add, clazz, "add", "(Ljava/lang/Object;)Z");
FIND_CLASS(clazz, "java/util/HashMap");
GET_METHOD_ID(gFields.hashmap.init, clazz, "<init>", "()V");
GET_METHOD_ID(gFields.hashmap.get, clazz, "get", "(Ljava/lang/Object;)Ljava/lang/Object;");
GET_METHOD_ID(gFields.hashmap.put, clazz, "put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
GET_METHOD_ID(gFields.hashmap.entrySet, clazz, "entrySet", "()Ljava/util/Set;");
FIND_CLASS(clazz, "java/util/Set");
GET_METHOD_ID(gFields.set.iterator, clazz, "iterator", "()Ljava/util/Iterator;");
FIND_CLASS(clazz, "java/util/Iterator");
GET_METHOD_ID(gFields.iterator.next, clazz, "next", "()Ljava/lang/Object;");
GET_METHOD_ID(gFields.iterator.hasNext, clazz, "hasNext", "()Z");
FIND_CLASS(clazz, "java/util/Map$Entry");
GET_METHOD_ID(gFields.entry.getKey, clazz, "getKey", "()Ljava/lang/Object;");
GET_METHOD_ID(gFields.entry.getValue, clazz, "getValue", "()Ljava/lang/Object;");
FIND_CLASS(clazz, "java/util/HashMap");
gFields.hashmapClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
FIND_CLASS(clazz, "java/lang/String");
gFields.stringClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
FIND_CLASS(clazz, "java/util/ArrayList");
gFields.arraylistClassId = static_cast<jclass>(env->NewGlobalRef(clazz));
FIND_CLASS(clazz, "android/media/MediaDrm$MediaDrmStateException");
GET_METHOD_ID(gFields.stateException.init, clazz, "<init>", "(ILjava/lang/String;)V");
gFields.stateException.classId = static_cast<jclass>(env->NewGlobalRef(clazz));
}
static void android_media_MediaDrm_native_setup(
JNIEnv *env, jobject thiz,
jobject weak_this, jbyteArray uuidObj, jstring jappPackageName) {
if (uuidObj == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException", "uuid is null");
return;
}
Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
if (uuid.size() != 16) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"invalid UUID size, expected 16 bytes");
return;
}
String8 packageName;
if (jappPackageName == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"application package name cannot be null");
return;
}
packageName = JStringToString8(env, jappPackageName);
sp<JDrm> drm = new JDrm(env, thiz, uuid.array(), packageName);
status_t err = drm->initCheck();
if (err != OK) {
jniThrowException(
env,
"android/media/UnsupportedSchemeException",
"Failed to instantiate drm object.");
return;
}
sp<JNIDrmListener> listener = new JNIDrmListener(env, thiz, weak_this);
drm->setListener(listener);
setDrm(env, thiz, drm);
}
static void android_media_MediaDrm_native_finalize(
JNIEnv *env, jobject thiz) {
android_media_MediaDrm_release(env, thiz);
}
static jboolean android_media_MediaDrm_isCryptoSchemeSupportedNative(
JNIEnv *env, jobject /* thiz */, jbyteArray uuidObj, jstring jmimeType) {
if (uuidObj == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
return false;
}
Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
if (uuid.size() != 16) {
jniThrowException(
env,
"java/lang/IllegalArgumentException",
"invalid UUID size, expected 16 bytes");
return false;
}
String8 mimeType;
if (jmimeType != NULL) {
mimeType = JStringToString8(env, jmimeType);
}
return JDrm::IsCryptoSchemeSupported(uuid.array(), mimeType);
}
static jbyteArray android_media_MediaDrm_openSession(
JNIEnv *env, jobject thiz) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
Vector<uint8_t> sessionId;
status_t err = drm->openSession(sessionId);
if (throwExceptionAsNecessary(env, err, "Failed to open session")) {
return NULL;
}
return VectorToJByteArray(env, sessionId);
}
static void android_media_MediaDrm_closeSession(
JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
sp<IDrm> drm = GetDrm(env, thiz);
if (!CheckSession(env, drm, jsessionId)) {
return;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
status_t err = drm->closeSession(sessionId);
throwExceptionAsNecessary(env, err, "Failed to close session");
}
static jobject android_media_MediaDrm_getKeyRequest(
JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jinitData,
jstring jmimeType, jint jkeyType, jobject joptParams) {
sp<IDrm> drm = GetDrm(env, thiz);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
Vector<uint8_t> initData;
if (jinitData != NULL) {
initData = JByteArrayToVector(env, jinitData);
}
String8 mimeType;
if (jmimeType != NULL) {
mimeType = JStringToString8(env, jmimeType);
}
DrmPlugin::KeyType keyType;
if (jkeyType == gKeyTypes.kKeyTypeStreaming) {
keyType = DrmPlugin::kKeyType_Streaming;
} else if (jkeyType == gKeyTypes.kKeyTypeOffline) {
keyType = DrmPlugin::kKeyType_Offline;
} else if (jkeyType == gKeyTypes.kKeyTypeRelease) {
keyType = DrmPlugin::kKeyType_Release;
} else {
jniThrowException(env, "java/lang/IllegalArgumentException",
"invalid keyType");
return NULL;
}
KeyedVector<String8, String8> optParams;
if (joptParams != NULL) {
bool isOK;
optParams = HashMapToKeyedVector(env, joptParams, &isOK);
if (!isOK) {
return NULL;
}
}
Vector<uint8_t> request;
String8 defaultUrl;
DrmPlugin::KeyRequestType keyRequestType;
status_t err = drm->getKeyRequest(sessionId, initData, mimeType,
keyType, optParams, request, defaultUrl, &keyRequestType);
if (throwExceptionAsNecessary(env, err, "Failed to get key request")) {
return NULL;
}
// Fill out return obj
jclass clazz;
FIND_CLASS(clazz, "android/media/MediaDrm$KeyRequest");
jobject keyObj = NULL;
if (clazz) {
keyObj = env->AllocObject(clazz);
jbyteArray jrequest = VectorToJByteArray(env, request);
env->SetObjectField(keyObj, gFields.keyRequest.data, jrequest);
jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
env->SetObjectField(keyObj, gFields.keyRequest.defaultUrl, jdefaultUrl);
switch (keyRequestType) {
case DrmPlugin::kKeyRequestType_Initial:
env->SetIntField(keyObj, gFields.keyRequest.requestType,
gKeyRequestTypes.kKeyRequestTypeInitial);
break;
case DrmPlugin::kKeyRequestType_Renewal:
env->SetIntField(keyObj, gFields.keyRequest.requestType,
gKeyRequestTypes.kKeyRequestTypeRenewal);
break;
case DrmPlugin::kKeyRequestType_Release:
env->SetIntField(keyObj, gFields.keyRequest.requestType,
gKeyRequestTypes.kKeyRequestTypeRelease);
break;
default:
throwStateException(env, "DRM plugin failure: unknown key request type",
ERROR_DRM_UNKNOWN);
break;
}
}
return keyObj;
}
static jbyteArray android_media_MediaDrm_provideKeyResponse(
JNIEnv *env, jobject thiz, jbyteArray jsessionId, jbyteArray jresponse) {
sp<IDrm> drm = GetDrm(env, thiz);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
if (jresponse == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"key response is null");
return NULL;
}
Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
Vector<uint8_t> keySetId;
status_t err = drm->provideKeyResponse(sessionId, response, keySetId);
if (throwExceptionAsNecessary(env, err, "Failed to handle key response")) {
return NULL;
}
return VectorToJByteArray(env, keySetId);
}
static void android_media_MediaDrm_removeKeys(
JNIEnv *env, jobject thiz, jbyteArray jkeysetId) {
sp<IDrm> drm = GetDrm(env, thiz);
if (jkeysetId == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"keySetId is null");
return;
}
Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
status_t err = drm->removeKeys(keySetId);
throwExceptionAsNecessary(env, err, "Failed to remove keys");
}
static void android_media_MediaDrm_restoreKeys(
JNIEnv *env, jobject thiz, jbyteArray jsessionId,
jbyteArray jkeysetId) {
sp<IDrm> drm = GetDrm(env, thiz);
if (!CheckSession(env, drm, jsessionId)) {
return;
}
if (jkeysetId == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
return;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
Vector<uint8_t> keySetId(JByteArrayToVector(env, jkeysetId));
status_t err = drm->restoreKeys(sessionId, keySetId);
throwExceptionAsNecessary(env, err, "Failed to restore keys");
}
static jobject android_media_MediaDrm_queryKeyStatus(
JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
sp<IDrm> drm = GetDrm(env, thiz);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
KeyedVector<String8, String8> infoMap;
status_t err = drm->queryKeyStatus(sessionId, infoMap);
if (throwExceptionAsNecessary(env, err, "Failed to query key status")) {
return NULL;
}
return KeyedVectorToHashMap(env, infoMap);
}
static jobject android_media_MediaDrm_getProvisionRequestNative(
JNIEnv *env, jobject thiz, jint jcertType, jstring jcertAuthority) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
Vector<uint8_t> request;
String8 defaultUrl;
String8 certType;
if (jcertType == gCertificateTypes.kCertificateTypeX509) {
certType = "X.509";
} else if (jcertType == gCertificateTypes.kCertificateTypeNone) {
certType = "none";
} else {
certType = "invalid";
}
String8 certAuthority = JStringToString8(env, jcertAuthority);
status_t err = drm->getProvisionRequest(certType, certAuthority, request, defaultUrl);
if (throwExceptionAsNecessary(env, err, "Failed to get provision request")) {
return NULL;
}
// Fill out return obj
jclass clazz;
FIND_CLASS(clazz, "android/media/MediaDrm$ProvisionRequest");
jobject provisionObj = NULL;
if (clazz) {
provisionObj = env->AllocObject(clazz);
jbyteArray jrequest = VectorToJByteArray(env, request);
env->SetObjectField(provisionObj, gFields.provisionRequest.data, jrequest);
jstring jdefaultUrl = env->NewStringUTF(defaultUrl.string());
env->SetObjectField(provisionObj, gFields.provisionRequest.defaultUrl, jdefaultUrl);
}
return provisionObj;
}
static jobject android_media_MediaDrm_provideProvisionResponseNative(
JNIEnv *env, jobject thiz, jbyteArray jresponse) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
if (jresponse == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"provision response is null");
return NULL;
}
Vector<uint8_t> response(JByteArrayToVector(env, jresponse));
Vector<uint8_t> certificate, wrappedKey;
status_t err = drm->provideProvisionResponse(response, certificate, wrappedKey);
// Fill out return obj
jclass clazz = gFields.certificateClassId;
jobject certificateObj = NULL;
if (clazz && certificate.size() && wrappedKey.size()) {
certificateObj = env->AllocObject(clazz);
jbyteArray jcertificate = VectorToJByteArray(env, certificate);
env->SetObjectField(certificateObj, gFields.certificate.certificateData, jcertificate);
jbyteArray jwrappedKey = VectorToJByteArray(env, wrappedKey);
env->SetObjectField(certificateObj, gFields.certificate.wrappedPrivateKey, jwrappedKey);
}
throwExceptionAsNecessary(env, err, "Failed to handle provision response");
return certificateObj;
}
static jobject android_media_MediaDrm_getSecureStops(
JNIEnv *env, jobject thiz) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
List<Vector<uint8_t> > secureStops;
status_t err = drm->getSecureStops(secureStops);
if (throwExceptionAsNecessary(env, err, "Failed to get secure stops")) {
return NULL;
}
return ListOfVectorsToArrayListOfByteArray(env, secureStops);
}
static jbyteArray android_media_MediaDrm_getSecureStop(
JNIEnv *env, jobject thiz, jbyteArray ssid) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
Vector<uint8_t> secureStop;
status_t err = drm->getSecureStop(JByteArrayToVector(env, ssid), secureStop);
if (throwExceptionAsNecessary(env, err, "Failed to get secure stop")) {
return NULL;
}
return VectorToJByteArray(env, secureStop);
}
static void android_media_MediaDrm_releaseSecureStops(
JNIEnv *env, jobject thiz, jbyteArray jssRelease) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return;
}
Vector<uint8_t> ssRelease(JByteArrayToVector(env, jssRelease));
status_t err = drm->releaseSecureStops(ssRelease);
throwExceptionAsNecessary(env, err, "Failed to release secure stops");
}
static void android_media_MediaDrm_releaseAllSecureStops(
JNIEnv *env, jobject thiz) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return;
}
status_t err = drm->releaseAllSecureStops();
throwExceptionAsNecessary(env, err, "Failed to release all secure stops");
}
static jstring android_media_MediaDrm_getPropertyString(
JNIEnv *env, jobject thiz, jstring jname) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
if (jname == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"property name String is null");
return NULL;
}
String8 name = JStringToString8(env, jname);
String8 value;
status_t err = drm->getPropertyString(name, value);
if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
return NULL;
}
return env->NewStringUTF(value.string());
}
static jbyteArray android_media_MediaDrm_getPropertyByteArray(
JNIEnv *env, jobject thiz, jstring jname) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return NULL;
}
if (jname == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"property name String is null");
return NULL;
}
String8 name = JStringToString8(env, jname);
Vector<uint8_t> value;
status_t err = drm->getPropertyByteArray(name, value);
if (throwExceptionAsNecessary(env, err, "Failed to get property")) {
return NULL;
}
return VectorToJByteArray(env, value);
}
static void android_media_MediaDrm_setPropertyString(
JNIEnv *env, jobject thiz, jstring jname, jstring jvalue) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return;
}
if (jname == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"property name String is null");
return;
}
if (jvalue == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"property value String is null");
return;
}
String8 name = JStringToString8(env, jname);
String8 value = JStringToString8(env, jvalue);
status_t err = drm->setPropertyString(name, value);
throwExceptionAsNecessary(env, err, "Failed to set property");
}
static void android_media_MediaDrm_setPropertyByteArray(
JNIEnv *env, jobject thiz, jstring jname, jbyteArray jvalue) {
sp<IDrm> drm = GetDrm(env, thiz);
if (drm == NULL) {
jniThrowException(env, "java/lang/IllegalStateException",
"MediaDrm obj is null");
return;
}
if (jname == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"property name String is null");
return;
}
if (jvalue == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"property value byte array is null");
return;
}
String8 name = JStringToString8(env, jname);
Vector<uint8_t> value = JByteArrayToVector(env, jvalue);
status_t err = drm->setPropertyByteArray(name, value);
throwExceptionAsNecessary(env, err, "Failed to set property");
}
static void android_media_MediaDrm_setCipherAlgorithmNative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jstring jalgorithm) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return;
}
if (jalgorithm == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"algorithm String is null");
return;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
String8 algorithm = JStringToString8(env, jalgorithm);
status_t err = drm->setCipherAlgorithm(sessionId, algorithm);
throwExceptionAsNecessary(env, err, "Failed to set cipher algorithm");
}
static void android_media_MediaDrm_setMacAlgorithmNative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jstring jalgorithm) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return;
}
if (jalgorithm == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"algorithm String is null");
return;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
String8 algorithm = JStringToString8(env, jalgorithm);
status_t err = drm->setMacAlgorithm(sessionId, algorithm);
throwExceptionAsNecessary(env, err, "Failed to set mac algorithm");
}
static jbyteArray android_media_MediaDrm_encryptNative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jbyteArray jkeyId, jbyteArray jinput, jbyteArray jiv) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
if (jkeyId == NULL || jinput == NULL || jiv == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"required argument is null");
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
Vector<uint8_t> input(JByteArrayToVector(env, jinput));
Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
Vector<uint8_t> output;
status_t err = drm->encrypt(sessionId, keyId, input, iv, output);
if (throwExceptionAsNecessary(env, err, "Failed to encrypt")) {
return NULL;
}
return VectorToJByteArray(env, output);
}
static jbyteArray android_media_MediaDrm_decryptNative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jbyteArray jkeyId, jbyteArray jinput, jbyteArray jiv) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
if (jkeyId == NULL || jinput == NULL || jiv == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"required argument is null");
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
Vector<uint8_t> input(JByteArrayToVector(env, jinput));
Vector<uint8_t> iv(JByteArrayToVector(env, jiv));
Vector<uint8_t> output;
status_t err = drm->decrypt(sessionId, keyId, input, iv, output);
if (throwExceptionAsNecessary(env, err, "Failed to decrypt")) {
return NULL;
}
return VectorToJByteArray(env, output);
}
static jbyteArray android_media_MediaDrm_signNative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jbyteArray jkeyId, jbyteArray jmessage) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
if (jkeyId == NULL || jmessage == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"required argument is null");
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
Vector<uint8_t> signature;
status_t err = drm->sign(sessionId, keyId, message, signature);
if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
return NULL;
}
return VectorToJByteArray(env, signature);
}
static jboolean android_media_MediaDrm_verifyNative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jbyteArray jkeyId, jbyteArray jmessage, jbyteArray jsignature) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return false;
}
if (jkeyId == NULL || jmessage == NULL || jsignature == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"required argument is null");
return false;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
Vector<uint8_t> keyId(JByteArrayToVector(env, jkeyId));
Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
Vector<uint8_t> signature(JByteArrayToVector(env, jsignature));
bool match;
status_t err = drm->verify(sessionId, keyId, message, signature, match);
throwExceptionAsNecessary(env, err, "Failed to verify");
return match;
}
static jbyteArray android_media_MediaDrm_signRSANative(
JNIEnv *env, jobject /* thiz */, jobject jdrm, jbyteArray jsessionId,
jstring jalgorithm, jbyteArray jwrappedKey, jbyteArray jmessage) {
sp<IDrm> drm = GetDrm(env, jdrm);
if (!CheckSession(env, drm, jsessionId)) {
return NULL;
}
if (jalgorithm == NULL || jwrappedKey == NULL || jmessage == NULL) {
jniThrowException(env, "java/lang/IllegalArgumentException",
"required argument is null");
return NULL;
}
Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
String8 algorithm = JStringToString8(env, jalgorithm);
Vector<uint8_t> wrappedKey(JByteArrayToVector(env, jwrappedKey));
Vector<uint8_t> message(JByteArrayToVector(env, jmessage));
Vector<uint8_t> signature;
status_t err = drm->signRSA(sessionId, algorithm, message, wrappedKey, signature);
if (throwExceptionAsNecessary(env, err, "Failed to sign")) {
return NULL;
}
return VectorToJByteArray(env, signature);
}
static const JNINativeMethod gMethods[] = {
{ "release", "()V", (void *)android_media_MediaDrm_release },
{ "native_init", "()V", (void *)android_media_MediaDrm_native_init },
{ "native_setup", "(Ljava/lang/Object;[BLjava/lang/String;)V",
(void *)android_media_MediaDrm_native_setup },
{ "native_finalize", "()V",
(void *)android_media_MediaDrm_native_finalize },
{ "isCryptoSchemeSupportedNative", "([BLjava/lang/String;)Z",
(void *)android_media_MediaDrm_isCryptoSchemeSupportedNative },
{ "openSession", "()[B",
(void *)android_media_MediaDrm_openSession },
{ "closeSession", "([B)V",
(void *)android_media_MediaDrm_closeSession },
{ "getKeyRequest", "([B[BLjava/lang/String;ILjava/util/HashMap;)"
"Landroid/media/MediaDrm$KeyRequest;",
(void *)android_media_MediaDrm_getKeyRequest },
{ "provideKeyResponse", "([B[B)[B",
(void *)android_media_MediaDrm_provideKeyResponse },
{ "removeKeys", "([B)V",
(void *)android_media_MediaDrm_removeKeys },
{ "restoreKeys", "([B[B)V",
(void *)android_media_MediaDrm_restoreKeys },
{ "queryKeyStatus", "([B)Ljava/util/HashMap;",
(void *)android_media_MediaDrm_queryKeyStatus },
{ "getProvisionRequestNative", "(ILjava/lang/String;)Landroid/media/MediaDrm$ProvisionRequest;",
(void *)android_media_MediaDrm_getProvisionRequestNative },
{ "provideProvisionResponseNative", "([B)Landroid/media/MediaDrm$Certificate;",
(void *)android_media_MediaDrm_provideProvisionResponseNative },
{ "getSecureStops", "()Ljava/util/List;",
(void *)android_media_MediaDrm_getSecureStops },
{ "getSecureStop", "([B)[B",
(void *)android_media_MediaDrm_getSecureStop },
{ "releaseSecureStops", "([B)V",
(void *)android_media_MediaDrm_releaseSecureStops },
{ "releaseAllSecureStops", "()V",
(void *)android_media_MediaDrm_releaseAllSecureStops },
{ "getPropertyString", "(Ljava/lang/String;)Ljava/lang/String;",
(void *)android_media_MediaDrm_getPropertyString },
{ "getPropertyByteArray", "(Ljava/lang/String;)[B",
(void *)android_media_MediaDrm_getPropertyByteArray },
{ "setPropertyString", "(Ljava/lang/String;Ljava/lang/String;)V",
(void *)android_media_MediaDrm_setPropertyString },
{ "setPropertyByteArray", "(Ljava/lang/String;[B)V",
(void *)android_media_MediaDrm_setPropertyByteArray },
{ "setCipherAlgorithmNative",
"(Landroid/media/MediaDrm;[BLjava/lang/String;)V",
(void *)android_media_MediaDrm_setCipherAlgorithmNative },
{ "setMacAlgorithmNative",
"(Landroid/media/MediaDrm;[BLjava/lang/String;)V",
(void *)android_media_MediaDrm_setMacAlgorithmNative },
{ "encryptNative", "(Landroid/media/MediaDrm;[B[B[B[B)[B",
(void *)android_media_MediaDrm_encryptNative },
{ "decryptNative", "(Landroid/media/MediaDrm;[B[B[B[B)[B",
(void *)android_media_MediaDrm_decryptNative },
{ "signNative", "(Landroid/media/MediaDrm;[B[B[B)[B",
(void *)android_media_MediaDrm_signNative },
{ "verifyNative", "(Landroid/media/MediaDrm;[B[B[B[B)Z",
(void *)android_media_MediaDrm_verifyNative },
{ "signRSANative", "(Landroid/media/MediaDrm;[BLjava/lang/String;[B[B)[B",
(void *)android_media_MediaDrm_signRSANative },
};
int register_android_media_Drm(JNIEnv *env) {
return AndroidRuntime::registerNativeMethods(env,
"android/media/MediaDrm", gMethods, NELEM(gMethods));
}
Reference in New Issue View Git Blame Copy Permalink