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