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