1 /*
2 * Copyright 2012, 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 "MediaCrypto-JNI"
19 #include <utils/Log.h>
20
21 #include "android_media_MediaCrypto.h"
22
23 #include "android_runtime/AndroidRuntime.h"
24 #include "jni.h"
25 #include <nativehelper/JNIHelp.h>
26
27 #include <binder/IServiceManager.h>
28 #include <cutils/properties.h>
29 #include <media/ICrypto.h>
30 #include <media/IMediaDrmService.h>
31 #include <media/stagefright/foundation/ADebug.h>
32
33 namespace android {
34
35 struct fields_t {
36 jfieldID context;
37 };
38
39 static fields_t gFields;
40
getCrypto(JNIEnv * env,jobject thiz)41 static sp<JCrypto> getCrypto(JNIEnv *env, jobject thiz) {
42 return (JCrypto *)env->GetLongField(thiz, gFields.context);
43 }
44
JCrypto(JNIEnv * env,jobject thiz,const uint8_t uuid[16],const void * initData,size_t initSize)45 JCrypto::JCrypto(
46 JNIEnv *env, jobject thiz,
47 const uint8_t uuid[16], const void *initData, size_t initSize) {
48 mObject = env->NewWeakGlobalRef(thiz);
49
50 mCrypto = MakeCrypto(uuid, initData, initSize);
51 }
52
~JCrypto()53 JCrypto::~JCrypto() {
54 if (mCrypto != NULL) {
55 mCrypto->destroyPlugin();
56 }
57 mCrypto.clear();
58
59 JNIEnv *env = AndroidRuntime::getJNIEnv();
60
61 env->DeleteWeakGlobalRef(mObject);
62 mObject = NULL;
63 }
64
65 // static
MakeCrypto()66 sp<ICrypto> JCrypto::MakeCrypto() {
67 sp<IServiceManager> sm = defaultServiceManager();
68
69 sp<IBinder> binder = sm->getService(String16("media.drm"));
70 sp<IMediaDrmService> service = interface_cast<IMediaDrmService>(binder);
71 if (service == NULL) {
72 return NULL;
73 }
74
75 sp<ICrypto> crypto = service->makeCrypto();
76 if (crypto == NULL || (crypto->initCheck() != OK && crypto->initCheck() != NO_INIT)) {
77 return NULL;
78 }
79
80 return crypto;
81 }
82
83 // static
MakeCrypto(const uint8_t uuid[16],const void * initData,size_t initSize)84 sp<ICrypto> JCrypto::MakeCrypto(
85 const uint8_t uuid[16], const void *initData, size_t initSize) {
86 sp<ICrypto> crypto = MakeCrypto();
87
88 if (crypto == NULL) {
89 return NULL;
90 }
91
92 status_t err = crypto->createPlugin(uuid, initData, initSize);
93
94 if (err != OK) {
95 return NULL;
96 }
97
98 return crypto;
99 }
100
requiresSecureDecoderComponent(const char * mime) const101 bool JCrypto::requiresSecureDecoderComponent(const char *mime) const {
102 if (mCrypto == NULL) {
103 return false;
104 }
105
106 return mCrypto->requiresSecureDecoderComponent(mime);
107 }
108
109 // static
IsCryptoSchemeSupported(const uint8_t uuid[16])110 bool JCrypto::IsCryptoSchemeSupported(const uint8_t uuid[16]) {
111 sp<ICrypto> crypto = MakeCrypto();
112
113 if (crypto == NULL) {
114 return false;
115 }
116
117 return crypto->isCryptoSchemeSupported(uuid);
118 }
119
initCheck() const120 status_t JCrypto::initCheck() const {
121 return mCrypto == NULL ? NO_INIT : OK;
122 }
123
124 // static
GetCrypto(JNIEnv * env,jobject obj)125 sp<ICrypto> JCrypto::GetCrypto(JNIEnv *env, jobject obj) {
126 jclass clazz = env->FindClass("android/media/MediaCrypto");
127 CHECK(clazz != NULL);
128
129 if (!env->IsInstanceOf(obj, clazz)) {
130 return NULL;
131 }
132
133 sp<JCrypto> jcrypto = getCrypto(env, obj);
134
135 if (jcrypto == NULL) {
136 return NULL;
137 }
138
139 return jcrypto->mCrypto;
140 }
141
142 // JNI conversion utilities
JByteArrayToVector(JNIEnv * env,jbyteArray const & byteArray)143 static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray) {
144 Vector<uint8_t> vector;
145 size_t length = env->GetArrayLength(byteArray);
146 vector.insertAt((size_t)0, length);
147 env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
148 return vector;
149 }
150
151 } // namespace android
152
153 using namespace android;
154
setCrypto(JNIEnv * env,jobject thiz,const sp<JCrypto> & crypto)155 static sp<JCrypto> setCrypto(
156 JNIEnv *env, jobject thiz, const sp<JCrypto> &crypto) {
157 sp<JCrypto> old = (JCrypto *)env->GetLongField(thiz, gFields.context);
158 if (crypto != NULL) {
159 crypto->incStrong(thiz);
160 }
161 if (old != NULL) {
162 old->decStrong(thiz);
163 }
164 env->SetLongField(thiz, gFields.context, (jlong)crypto.get());
165
166 return old;
167 }
168
android_media_MediaCrypto_release(JNIEnv * env,jobject thiz)169 static void android_media_MediaCrypto_release(JNIEnv *env, jobject thiz) {
170 setCrypto(env, thiz, NULL);
171 }
172
android_media_MediaCrypto_native_init(JNIEnv * env)173 static void android_media_MediaCrypto_native_init(JNIEnv *env) {
174 jclass clazz = env->FindClass("android/media/MediaCrypto");
175 CHECK(clazz != NULL);
176
177 gFields.context = env->GetFieldID(clazz, "mNativeContext", "J");
178 CHECK(gFields.context != NULL);
179 }
180
android_media_MediaCrypto_native_setup(JNIEnv * env,jobject thiz,jbyteArray uuidObj,jbyteArray initDataObj)181 static void android_media_MediaCrypto_native_setup(
182 JNIEnv *env, jobject thiz,
183 jbyteArray uuidObj, jbyteArray initDataObj) {
184 jsize uuidLength = env->GetArrayLength(uuidObj);
185
186 if (uuidLength != 16) {
187 jniThrowException(
188 env,
189 "java/lang/IllegalArgumentException",
190 NULL);
191 return;
192 }
193
194 jboolean isCopy;
195 jbyte *uuid = env->GetByteArrayElements(uuidObj, &isCopy);
196
197 jsize initDataLength = 0;
198 jbyte *initData = NULL;
199
200 if (initDataObj != NULL) {
201 initDataLength = env->GetArrayLength(initDataObj);
202 initData = env->GetByteArrayElements(initDataObj, &isCopy);
203 }
204
205 sp<JCrypto> crypto = new JCrypto(
206 env, thiz, (const uint8_t *)uuid, initData, initDataLength);
207
208 status_t err = crypto->initCheck();
209
210 if (initDataObj != NULL) {
211 env->ReleaseByteArrayElements(initDataObj, initData, 0);
212 initData = NULL;
213 }
214
215 env->ReleaseByteArrayElements(uuidObj, uuid, 0);
216 uuid = NULL;
217
218 if (err != OK) {
219 jniThrowException(
220 env,
221 "android/media/MediaCryptoException",
222 "Failed to instantiate crypto object.");
223 return;
224 }
225
226 setCrypto(env,thiz, crypto);
227 }
228
android_media_MediaCrypto_native_finalize(JNIEnv * env,jobject thiz)229 static void android_media_MediaCrypto_native_finalize(
230 JNIEnv *env, jobject thiz) {
231 android_media_MediaCrypto_release(env, thiz);
232 }
233
android_media_MediaCrypto_isCryptoSchemeSupportedNative(JNIEnv * env,jobject,jbyteArray uuidObj)234 static jboolean android_media_MediaCrypto_isCryptoSchemeSupportedNative(
235 JNIEnv *env, jobject /* thiz */, jbyteArray uuidObj) {
236 jsize uuidLength = env->GetArrayLength(uuidObj);
237
238 if (uuidLength != 16) {
239 jniThrowException(
240 env,
241 "java/lang/IllegalArgumentException",
242 NULL);
243 return JNI_FALSE;
244 }
245
246 jboolean isCopy;
247 jbyte *uuid = env->GetByteArrayElements(uuidObj, &isCopy);
248
249 bool result = JCrypto::IsCryptoSchemeSupported((const uint8_t *)uuid);
250
251 env->ReleaseByteArrayElements(uuidObj, uuid, 0);
252 uuid = NULL;
253
254 return result ? JNI_TRUE : JNI_FALSE;
255 }
256
android_media_MediaCrypto_requiresSecureDecoderComponent(JNIEnv * env,jobject thiz,jstring mimeObj)257 static jboolean android_media_MediaCrypto_requiresSecureDecoderComponent(
258 JNIEnv *env, jobject thiz, jstring mimeObj) {
259 if (mimeObj == NULL) {
260 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
261 return JNI_FALSE;
262 }
263
264 sp<JCrypto> crypto = getCrypto(env, thiz);
265
266 if (crypto == NULL) {
267 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
268 return JNI_FALSE;
269 }
270
271 const char *mime = env->GetStringUTFChars(mimeObj, NULL);
272
273 if (mime == NULL) {
274 return JNI_FALSE;
275 }
276
277 bool result = crypto->requiresSecureDecoderComponent(mime);
278
279 env->ReleaseStringUTFChars(mimeObj, mime);
280 mime = NULL;
281
282 return result ? JNI_TRUE : JNI_FALSE;
283 }
284
android_media_MediaCrypto_setMediaDrmSession(JNIEnv * env,jobject thiz,jbyteArray jsessionId)285 static void android_media_MediaCrypto_setMediaDrmSession(
286 JNIEnv *env, jobject thiz, jbyteArray jsessionId) {
287 if (jsessionId == NULL) {
288 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
289 return;
290 }
291
292 sp<ICrypto> crypto = JCrypto::GetCrypto(env, thiz);
293
294 if (crypto == NULL) {
295 jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
296 return;
297 }
298
299 Vector<uint8_t> sessionId(JByteArrayToVector(env, jsessionId));
300
301 status_t err = crypto->setMediaDrmSession(sessionId);
302
303 if (err != OK) {
304 String8 msg("setMediaDrmSession failed");
305 if (err == ERROR_DRM_SESSION_NOT_OPENED) {
306 msg += ": session not opened";
307 } else if (err == ERROR_UNSUPPORTED) {
308 msg += ": not supported by this crypto scheme";
309 } else if (err == NO_INIT) {
310 msg += ": crypto plugin not initialized";
311 } else {
312 msg.appendFormat(": general failure (%d)", err);
313 }
314 jniThrowException(env, "android/media/MediaCryptoException", msg.string());
315 }
316 }
317
318 static const JNINativeMethod gMethods[] = {
319 { "release", "()V", (void *)android_media_MediaCrypto_release },
320 { "native_init", "()V", (void *)android_media_MediaCrypto_native_init },
321
322 { "native_setup", "([B[B)V",
323 (void *)android_media_MediaCrypto_native_setup },
324
325 { "native_finalize", "()V",
326 (void *)android_media_MediaCrypto_native_finalize },
327
328 { "isCryptoSchemeSupportedNative", "([B)Z",
329 (void *)android_media_MediaCrypto_isCryptoSchemeSupportedNative },
330
331 { "requiresSecureDecoderComponent", "(Ljava/lang/String;)Z",
332 (void *)android_media_MediaCrypto_requiresSecureDecoderComponent },
333
334 { "setMediaDrmSession", "([B)V",
335 (void *)android_media_MediaCrypto_setMediaDrmSession },
336 };
337
register_android_media_Crypto(JNIEnv * env)338 int register_android_media_Crypto(JNIEnv *env) {
339 return AndroidRuntime::registerNativeMethods(env,
340 "android/media/MediaCrypto", gMethods, NELEM(gMethods));
341 }
342
343