android_media_MediaPlayer2.cpp revision 2f711fec15b132b46e0d216d61b868aa27cb7064 
1/*
2**
3** Copyright 2017, The Android Open Source Project
4**
5** Licensed under the Apache License, Version 2.0 (the "License");
6** you may not use this file except in compliance with the License.
7** You may obtain a copy of the License at
8**
9**     http://www.apache.org/licenses/LICENSE-2.0
10**
11** Unless required by applicable law or agreed to in writing, software
12** distributed under the License is distributed on an "AS IS" BASIS,
13** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14** See the License for the specific language governing permissions and
15** limitations under the License.
16*/
17
18//#define LOG_NDEBUG 0
19#define LOG_TAG "MediaPlayer2-JNI"
20#include "utils/Log.h"
21
22#include <sys/stat.h>
23
24#include <media/AudioResamplerPublic.h>
25#include <media/DataSourceDesc.h>
26#include <media/MediaHTTPService.h>
27#include <media/MediaAnalyticsItem.h>
28#include <media/NdkWrapper.h>
29#include <media/stagefright/Utils.h>
30#include <media/stagefright/foundation/ByteUtils.h>  // for FOURCC definition
31#include <mediaplayer2/JAudioTrack.h>
32#include <mediaplayer2/mediaplayer2.h>
33#include <stdio.h>
34#include <assert.h>
35#include <limits.h>
36#include <unistd.h>
37#include <fcntl.h>
38#include <utils/threads.h>
39#include "jni.h"
40#include <nativehelper/JNIHelp.h>
41#include "android/native_window_jni.h"
42#include "android_runtime/Log.h"
43#include "utils/Errors.h"  // for status_t
44#include "utils/KeyedVector.h"
45#include "utils/String8.h"
46#include "android_media_BufferingParams.h"
47#include "android_media_Media2HTTPService.h"
48#include "android_media_Media2DataSource.h"
49#include "android_media_MediaMetricsJNI.h"
50#include "android_media_PlaybackParams.h"
51#include "android_media_SyncParams.h"
52#include "android_media_VolumeShaper.h"
53
54#include "android_os_Parcel.h"
55#include "android_util_Binder.h"
56#include <binder/Parcel.h>
57
58// Modular DRM begin
59#define FIND_CLASS(var, className) \
60var = env->FindClass(className); \
61LOG_FATAL_IF(! (var), "Unable to find class " className);
62
63#define GET_METHOD_ID(var, clazz, fieldName, fieldDescriptor) \
64var = env->GetMethodID(clazz, fieldName, fieldDescriptor); \
65LOG_FATAL_IF(! (var), "Unable to find method " fieldName);
66
67struct StateExceptionFields {
68    jmethodID init;
69    jclass classId;
70};
71
72static StateExceptionFields gStateExceptionFields;
73// Modular DRM end
74
75// ----------------------------------------------------------------------------
76
77using namespace android;
78
79using media::VolumeShaper;
80
81// ----------------------------------------------------------------------------
82
83struct fields_t {
84    jfieldID    context;
85    jfieldID    surface_texture;
86
87    jmethodID   post_event;
88
89    jmethodID   proxyConfigGetHost;
90    jmethodID   proxyConfigGetPort;
91    jmethodID   proxyConfigGetExclusionList;
92};
93static fields_t fields;
94
95static BufferingParams::fields_t gBufferingParamsFields;
96static PlaybackParams::fields_t gPlaybackParamsFields;
97static SyncParams::fields_t gSyncParamsFields;
98static VolumeShaperHelper::fields_t gVolumeShaperFields;
99
100static Mutex sLock;
101
102static bool ConvertKeyValueArraysToKeyedVector(
103        JNIEnv *env, jobjectArray keys, jobjectArray values,
104        KeyedVector<String8, String8>* keyedVector) {
105
106    int nKeyValuePairs = 0;
107    bool failed = false;
108    if (keys != NULL && values != NULL) {
109        nKeyValuePairs = env->GetArrayLength(keys);
110        failed = (nKeyValuePairs != env->GetArrayLength(values));
111    }
112
113    if (!failed) {
114        failed = ((keys != NULL && values == NULL) ||
115                  (keys == NULL && values != NULL));
116    }
117
118    if (failed) {
119        ALOGE("keys and values arrays have different length");
120        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
121        return false;
122    }
123
124    for (int i = 0; i < nKeyValuePairs; ++i) {
125        // No need to check on the ArrayIndexOutOfBoundsException, since
126        // it won't happen here.
127        jstring key = (jstring) env->GetObjectArrayElement(keys, i);
128        jstring value = (jstring) env->GetObjectArrayElement(values, i);
129
130        const char* keyStr = env->GetStringUTFChars(key, NULL);
131        if (!keyStr) {  // OutOfMemoryError
132            return false;
133        }
134
135        const char* valueStr = env->GetStringUTFChars(value, NULL);
136        if (!valueStr) {  // OutOfMemoryError
137            env->ReleaseStringUTFChars(key, keyStr);
138            return false;
139        }
140
141        keyedVector->add(String8(keyStr), String8(valueStr));
142
143        env->ReleaseStringUTFChars(key, keyStr);
144        env->ReleaseStringUTFChars(value, valueStr);
145        env->DeleteLocalRef(key);
146        env->DeleteLocalRef(value);
147    }
148    return true;
149}
150
151// ----------------------------------------------------------------------------
152// ref-counted object for callbacks
153class JNIMediaPlayer2Listener: public MediaPlayer2Listener
154{
155public:
156    JNIMediaPlayer2Listener(JNIEnv* env, jobject thiz, jobject weak_thiz);
157    ~JNIMediaPlayer2Listener();
158    virtual void notify(int64_t srcId, int msg, int ext1, int ext2,
159                        const Parcel *obj = NULL) override;
160private:
161    JNIMediaPlayer2Listener();
162    jclass      mClass;     // Reference to MediaPlayer2 class
163    jobject     mObject;    // Weak ref to MediaPlayer2 Java object to call on
164};
165
166JNIMediaPlayer2Listener::JNIMediaPlayer2Listener(JNIEnv* env, jobject thiz, jobject weak_thiz)
167{
168
169    // Hold onto the MediaPlayer2 class for use in calling the static method
170    // that posts events to the application thread.
171    jclass clazz = env->GetObjectClass(thiz);
172    if (clazz == NULL) {
173        ALOGE("Can't find android/media/MediaPlayer2Impl");
174        jniThrowException(env, "java/lang/Exception", NULL);
175        return;
176    }
177    mClass = (jclass)env->NewGlobalRef(clazz);
178
179    // We use a weak reference so the MediaPlayer2 object can be garbage collected.
180    // The reference is only used as a proxy for callbacks.
181    mObject  = env->NewGlobalRef(weak_thiz);
182}
183
184JNIMediaPlayer2Listener::~JNIMediaPlayer2Listener()
185{
186    // remove global references
187    JNIEnv *env = AndroidRuntime::getJNIEnv();
188    env->DeleteGlobalRef(mObject);
189    env->DeleteGlobalRef(mClass);
190}
191
192void JNIMediaPlayer2Listener::notify(int64_t srcId, int msg, int ext1, int ext2, const Parcel *obj)
193{
194    JNIEnv *env = AndroidRuntime::getJNIEnv();
195    if (obj && obj->dataSize() > 0) {
196        jobject jParcel = createJavaParcelObject(env);
197        if (jParcel != NULL) {
198            Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
199            nativeParcel->setData(obj->data(), obj->dataSize());
200            env->CallStaticVoidMethod(mClass, fields.post_event, mObject,
201                    srcId, msg, ext1, ext2, jParcel);
202            env->DeleteLocalRef(jParcel);
203        }
204    } else {
205        env->CallStaticVoidMethod(mClass, fields.post_event, mObject,
206                srcId, msg, ext1, ext2, NULL);
207    }
208    if (env->ExceptionCheck()) {
209        ALOGW("An exception occurred while notifying an event.");
210        LOGW_EX(env);
211        env->ExceptionClear();
212    }
213}
214
215// ----------------------------------------------------------------------------
216
217static sp<MediaPlayer2> getMediaPlayer(JNIEnv* env, jobject thiz)
218{
219    Mutex::Autolock l(sLock);
220    MediaPlayer2* const p = (MediaPlayer2*)env->GetLongField(thiz, fields.context);
221    return sp<MediaPlayer2>(p);
222}
223
224static sp<MediaPlayer2> setMediaPlayer(JNIEnv* env, jobject thiz, const sp<MediaPlayer2>& player)
225{
226    Mutex::Autolock l(sLock);
227    sp<MediaPlayer2> old = (MediaPlayer2*)env->GetLongField(thiz, fields.context);
228    if (player.get()) {
229        player->incStrong((void*)setMediaPlayer);
230    }
231    if (old != 0) {
232        old->decStrong((void*)setMediaPlayer);
233    }
234    env->SetLongField(thiz, fields.context, (jlong)player.get());
235    return old;
236}
237
238// If exception is NULL and opStatus is not OK, this method sends an error
239// event to the client application; otherwise, if exception is not NULL and
240// opStatus is not OK, this method throws the given exception to the client
241// application.
242static void process_media_player_call(
243    JNIEnv *env, jobject thiz, status_t opStatus, const char* exception, const char *message)
244{
245    if (exception == NULL) {  // Don't throw exception. Instead, send an event.
246        if (opStatus != (status_t) OK) {
247            sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
248            if (mp != 0) {
249                int64_t srcId = 0;
250                mp->getSrcId(&srcId);
251                mp->notify(srcId, MEDIA2_ERROR, opStatus, 0);
252            }
253        }
254    } else {  // Throw exception!
255        if ( opStatus == (status_t) INVALID_OPERATION ) {
256            jniThrowException(env, "java/lang/IllegalStateException", NULL);
257        } else if ( opStatus == (status_t) BAD_VALUE ) {
258            jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
259        } else if ( opStatus == (status_t) PERMISSION_DENIED ) {
260            jniThrowException(env, "java/lang/SecurityException", NULL);
261        } else if ( opStatus != (status_t) OK ) {
262            if (strlen(message) > 230) {
263               // if the message is too long, don't bother displaying the status code
264               jniThrowException( env, exception, message);
265            } else {
266               char msg[256];
267                // append the status code to the message
268               sprintf(msg, "%s: status=0x%X", message, opStatus);
269               jniThrowException( env, exception, msg);
270            }
271        }
272    }
273}
274
275static void
276android_media_MediaPlayer2_setDataSourceAndHeaders(
277        JNIEnv *env, jobject thiz, jlong srcId, jobject httpServiceObj, jstring path,
278        jobjectArray keys, jobjectArray values) {
279
280    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
281    if (mp == NULL) {
282        jniThrowException(env, "java/lang/IllegalStateException", NULL);
283        return;
284    }
285
286    if (path == NULL) {
287        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
288        return;
289    }
290
291    const char *tmp = env->GetStringUTFChars(path, NULL);
292    if (tmp == NULL) {  // Out of memory
293        return;
294    }
295    ALOGV("setDataSourceAndHeaders: path %s, srcId %lld", tmp, (long long)srcId);
296
297    if (strncmp(tmp, "content://", 10) == 0) {
298        ALOGE("setDataSourceAndHeaders: content scheme is not supported in native code");
299        jniThrowException(env, "java/io/IOException",
300                          "content scheme is not supported in native code");
301        return;
302    }
303
304    sp<DataSourceDesc> dsd = new DataSourceDesc();
305    dsd->mId = srcId;
306    dsd->mType = DataSourceDesc::TYPE_URL;
307    dsd->mUrl = tmp;
308
309    env->ReleaseStringUTFChars(path, tmp);
310    tmp = NULL;
311
312    // We build a KeyedVector out of the key and val arrays
313    if (!ConvertKeyValueArraysToKeyedVector(
314            env, keys, values, &dsd->mHeaders)) {
315        return;
316    }
317
318    sp<MediaHTTPService> httpService;
319    if (httpServiceObj != NULL) {
320        httpService = new JMedia2HTTPService(env, httpServiceObj);
321    }
322    dsd->mHttpService = httpService;
323
324    process_media_player_call(
325            env, thiz, mp->setDataSource(dsd), "java/io/IOException",
326            "setDataSourceAndHeaders failed." );
327}
328
329static void
330android_media_MediaPlayer2_setDataSourceFD(
331    JNIEnv *env, jobject thiz, jlong srcId, jobject fileDescriptor, jlong offset, jlong length)
332{
333    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
334    if (mp == NULL ) {
335        jniThrowException(env, "java/lang/IllegalStateException", NULL);
336        return;
337    }
338
339    if (fileDescriptor == NULL) {
340        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
341        return;
342    }
343    int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
344    ALOGV("setDataSourceFD: srcId=%lld, fd=%d (%s), offset=%lld, length=%lld",
345          (long long)srcId, fd, nameForFd(fd).c_str(), (long long)offset, (long long)length);
346
347    struct stat sb;
348    int ret = fstat(fd, &sb);
349    if (ret != 0) {
350        ALOGE("setDataSourceFD: fstat(%d) failed: %d, %s", fd, ret, strerror(errno));
351        jniThrowException(env, "java/io/IOException", "setDataSourceFD failed fstat");
352        return;
353    }
354
355    ALOGV("st_dev  = %llu", static_cast<unsigned long long>(sb.st_dev));
356    ALOGV("st_mode = %u", sb.st_mode);
357    ALOGV("st_uid  = %lu", static_cast<unsigned long>(sb.st_uid));
358    ALOGV("st_gid  = %lu", static_cast<unsigned long>(sb.st_gid));
359    ALOGV("st_size = %llu", static_cast<unsigned long long>(sb.st_size));
360
361    if (offset >= sb.st_size) {
362        ALOGE("setDataSourceFD: offset is out of range");
363        jniThrowException(env, "java/lang/IllegalArgumentException",
364                          "setDataSourceFD failed, offset is out of range.");
365        return;
366    }
367    if (offset + length > sb.st_size) {
368        length = sb.st_size - offset;
369        ALOGV("setDataSourceFD: adjusted length = %lld", (long long)length);
370    }
371
372    sp<DataSourceDesc> dsd = new DataSourceDesc();
373    dsd->mId = srcId;
374    dsd->mType = DataSourceDesc::TYPE_FD;
375    dsd->mFD = fd;
376    dsd->mFDOffset = offset;
377    dsd->mFDLength = length;
378    process_media_player_call(env, thiz, mp->setDataSource(dsd),
379                              "java/io/IOException", "setDataSourceFD failed." );
380}
381
382static void
383android_media_MediaPlayer2_setDataSourceCallback(
384    JNIEnv *env, jobject thiz, jlong srcId, jobject dataSource)
385{
386    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
387    if (mp == NULL ) {
388        jniThrowException(env, "java/lang/IllegalStateException", NULL);
389        return;
390    }
391
392    if (dataSource == NULL) {
393        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
394        return;
395    }
396    sp<DataSource> callbackDataSource = new JMedia2DataSource(env, dataSource);
397    sp<DataSourceDesc> dsd = new DataSourceDesc();
398    dsd->mId = srcId;
399    dsd->mType = DataSourceDesc::TYPE_CALLBACK;
400    dsd->mCallbackSource = callbackDataSource;
401    process_media_player_call(env, thiz, mp->setDataSource(dsd),
402                              "java/lang/RuntimeException", "setDataSourceCallback failed." );
403}
404
405static sp<ANativeWindowWrapper>
406getVideoSurfaceTexture(JNIEnv* env, jobject thiz) {
407    ANativeWindow * const p = (ANativeWindow*)env->GetLongField(thiz, fields.surface_texture);
408    return new ANativeWindowWrapper(p);
409}
410
411static void
412decVideoSurfaceRef(JNIEnv *env, jobject thiz)
413{
414    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
415    if (mp == NULL) {
416        return;
417    }
418
419    ANativeWindow * const old_anw = (ANativeWindow*)env->GetLongField(thiz, fields.surface_texture);
420    if (old_anw != NULL) {
421        ANativeWindow_release(old_anw);
422        env->SetLongField(thiz, fields.surface_texture, (jlong)NULL);
423    }
424}
425
426static void
427setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface, jboolean mediaPlayerMustBeAlive)
428{
429    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
430    if (mp == NULL) {
431        if (mediaPlayerMustBeAlive) {
432            jniThrowException(env, "java/lang/IllegalStateException", NULL);
433        }
434        return;
435    }
436
437    decVideoSurfaceRef(env, thiz);
438
439    ANativeWindow* anw = NULL;
440    if (jsurface) {
441        anw = ANativeWindow_fromSurface(env, jsurface);
442        if (anw == NULL) {
443            jniThrowException(env, "java/lang/IllegalArgumentException",
444                    "The surface has been released");
445            return;
446        }
447    }
448
449    env->SetLongField(thiz, fields.surface_texture, (jlong)anw);
450
451    // This will fail if the media player has not been initialized yet. This
452    // can be the case if setDisplay() on MediaPlayer2Impl.java has been called
453    // before setDataSource(). The redundant call to setVideoSurfaceTexture()
454    // in prepare/prepareAsync covers for this case.
455    mp->setVideoSurfaceTexture(new ANativeWindowWrapper(anw));
456}
457
458static void
459android_media_MediaPlayer2_setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface)
460{
461    setVideoSurface(env, thiz, jsurface, true /* mediaPlayerMustBeAlive */);
462}
463
464static jobject
465android_media_MediaPlayer2_getBufferingParams(JNIEnv *env, jobject thiz)
466{
467    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
468    if (mp == NULL) {
469        jniThrowException(env, "java/lang/IllegalStateException", NULL);
470        return NULL;
471    }
472
473    BufferingParams bp;
474    BufferingSettings &settings = bp.settings;
475    process_media_player_call(
476            env, thiz, mp->getBufferingSettings(&settings),
477            "java/lang/IllegalStateException", "unexpected error");
478    ALOGV("getBufferingSettings:{%s}", settings.toString().string());
479
480    return bp.asJobject(env, gBufferingParamsFields);
481}
482
483static void
484android_media_MediaPlayer2_setBufferingParams(JNIEnv *env, jobject thiz, jobject params)
485{
486    if (params == NULL) {
487        return;
488    }
489
490    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
491    if (mp == NULL) {
492        jniThrowException(env, "java/lang/IllegalStateException", NULL);
493        return;
494    }
495
496    BufferingParams bp;
497    bp.fillFromJobject(env, gBufferingParamsFields, params);
498    ALOGV("setBufferingParams:{%s}", bp.settings.toString().string());
499
500    process_media_player_call(
501            env, thiz, mp->setBufferingSettings(bp.settings),
502            "java/lang/IllegalStateException", "unexpected error");
503}
504
505static void
506android_media_MediaPlayer2_prepare(JNIEnv *env, jobject thiz)
507{
508    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
509    if (mp == NULL ) {
510        jniThrowException(env, "java/lang/IllegalStateException", NULL);
511        return;
512    }
513
514    // Handle the case where the display surface was set before the mp was
515    // initialized. We try again to make it stick.
516    sp<ANativeWindowWrapper> st = getVideoSurfaceTexture(env, thiz);
517    mp->setVideoSurfaceTexture(st);
518
519    process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." );
520}
521
522static void
523android_media_MediaPlayer2_prepareAsync(JNIEnv *env, jobject thiz)
524{
525    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
526    if (mp == NULL ) {
527        jniThrowException(env, "java/lang/IllegalStateException", NULL);
528        return;
529    }
530
531    // Handle the case where the display surface was set before the mp was
532    // initialized. We try again to make it stick.
533    sp<ANativeWindowWrapper> st = getVideoSurfaceTexture(env, thiz);
534    mp->setVideoSurfaceTexture(st);
535
536    process_media_player_call( env, thiz, mp->prepareAsync(), "java/io/IOException", "Prepare Async failed." );
537}
538
539static void
540android_media_MediaPlayer2_start(JNIEnv *env, jobject thiz)
541{
542    ALOGV("start");
543    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
544    if (mp == NULL ) {
545        jniThrowException(env, "java/lang/IllegalStateException", NULL);
546        return;
547    }
548    process_media_player_call( env, thiz, mp->start(), NULL, NULL );
549}
550
551static void
552android_media_MediaPlayer2_stop(JNIEnv *env, jobject thiz)
553{
554    ALOGV("stop");
555    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
556    if (mp == NULL ) {
557        jniThrowException(env, "java/lang/IllegalStateException", NULL);
558        return;
559    }
560    process_media_player_call( env, thiz, mp->stop(), NULL, NULL );
561}
562
563static void
564android_media_MediaPlayer2_pause(JNIEnv *env, jobject thiz)
565{
566    ALOGV("pause");
567    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
568    if (mp == NULL ) {
569        jniThrowException(env, "java/lang/IllegalStateException", NULL);
570        return;
571    }
572    process_media_player_call( env, thiz, mp->pause(), NULL, NULL );
573}
574
575static jboolean
576android_media_MediaPlayer2_isPlaying(JNIEnv *env, jobject thiz)
577{
578    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
579    if (mp == NULL ) {
580        jniThrowException(env, "java/lang/IllegalStateException", NULL);
581        return JNI_FALSE;
582    }
583    const jboolean is_playing = mp->isPlaying();
584
585    ALOGV("isPlaying: %d", is_playing);
586    return is_playing;
587}
588
589static void
590android_media_MediaPlayer2_setPlaybackParams(JNIEnv *env, jobject thiz, jobject params)
591{
592    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
593    if (mp == NULL) {
594        jniThrowException(env, "java/lang/IllegalStateException", NULL);
595        return;
596    }
597
598    PlaybackParams pbp;
599    pbp.fillFromJobject(env, gPlaybackParamsFields, params);
600    ALOGV("setPlaybackParams: %d:%f %d:%f %d:%u %d:%u",
601            pbp.speedSet, pbp.audioRate.mSpeed,
602            pbp.pitchSet, pbp.audioRate.mPitch,
603            pbp.audioFallbackModeSet, pbp.audioRate.mFallbackMode,
604            pbp.audioStretchModeSet, pbp.audioRate.mStretchMode);
605
606    AudioPlaybackRate rate;
607    status_t err = mp->getPlaybackSettings(&rate);
608    if (err == OK) {
609        bool updatedRate = false;
610        if (pbp.speedSet) {
611            rate.mSpeed = pbp.audioRate.mSpeed;
612            updatedRate = true;
613        }
614        if (pbp.pitchSet) {
615            rate.mPitch = pbp.audioRate.mPitch;
616            updatedRate = true;
617        }
618        if (pbp.audioFallbackModeSet) {
619            rate.mFallbackMode = pbp.audioRate.mFallbackMode;
620            updatedRate = true;
621        }
622        if (pbp.audioStretchModeSet) {
623            rate.mStretchMode = pbp.audioRate.mStretchMode;
624            updatedRate = true;
625        }
626        if (updatedRate) {
627            err = mp->setPlaybackSettings(rate);
628        }
629    }
630    process_media_player_call(
631            env, thiz, err,
632            "java/lang/IllegalStateException", "unexpected error");
633}
634
635static jobject
636android_media_MediaPlayer2_getPlaybackParams(JNIEnv *env, jobject thiz)
637{
638    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
639    if (mp == NULL) {
640        jniThrowException(env, "java/lang/IllegalStateException", NULL);
641        return NULL;
642    }
643
644    PlaybackParams pbp;
645    AudioPlaybackRate &audioRate = pbp.audioRate;
646    process_media_player_call(
647            env, thiz, mp->getPlaybackSettings(&audioRate),
648            "java/lang/IllegalStateException", "unexpected error");
649    ALOGV("getPlaybackSettings: %f %f %d %d",
650            audioRate.mSpeed, audioRate.mPitch, audioRate.mFallbackMode, audioRate.mStretchMode);
651
652    pbp.speedSet = true;
653    pbp.pitchSet = true;
654    pbp.audioFallbackModeSet = true;
655    pbp.audioStretchModeSet = true;
656
657    return pbp.asJobject(env, gPlaybackParamsFields);
658}
659
660static void
661android_media_MediaPlayer2_setSyncParams(JNIEnv *env, jobject thiz, jobject params)
662{
663    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
664    if (mp == NULL) {
665        jniThrowException(env, "java/lang/IllegalStateException", NULL);
666        return;
667    }
668
669    SyncParams scp;
670    scp.fillFromJobject(env, gSyncParamsFields, params);
671    ALOGV("setSyncParams: %d:%d %d:%d %d:%f %d:%f",
672          scp.syncSourceSet, scp.sync.mSource,
673          scp.audioAdjustModeSet, scp.sync.mAudioAdjustMode,
674          scp.toleranceSet, scp.sync.mTolerance,
675          scp.frameRateSet, scp.frameRate);
676
677    AVSyncSettings avsync;
678    float videoFrameRate;
679    status_t err = mp->getSyncSettings(&avsync, &videoFrameRate);
680    if (err == OK) {
681        bool updatedSync = scp.frameRateSet;
682        if (scp.syncSourceSet) {
683            avsync.mSource = scp.sync.mSource;
684            updatedSync = true;
685        }
686        if (scp.audioAdjustModeSet) {
687            avsync.mAudioAdjustMode = scp.sync.mAudioAdjustMode;
688            updatedSync = true;
689        }
690        if (scp.toleranceSet) {
691            avsync.mTolerance = scp.sync.mTolerance;
692            updatedSync = true;
693        }
694        if (updatedSync) {
695            err = mp->setSyncSettings(avsync, scp.frameRateSet ? scp.frameRate : -1.f);
696        }
697    }
698    process_media_player_call(
699            env, thiz, err,
700            "java/lang/IllegalStateException", "unexpected error");
701}
702
703static jobject
704android_media_MediaPlayer2_getSyncParams(JNIEnv *env, jobject thiz)
705{
706    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
707    if (mp == NULL) {
708        jniThrowException(env, "java/lang/IllegalStateException", NULL);
709        return NULL;
710    }
711
712    SyncParams scp;
713    scp.frameRate = -1.f;
714    process_media_player_call(
715            env, thiz, mp->getSyncSettings(&scp.sync, &scp.frameRate),
716            "java/lang/IllegalStateException", "unexpected error");
717
718    ALOGV("getSyncSettings: %d %d %f %f",
719            scp.sync.mSource, scp.sync.mAudioAdjustMode, scp.sync.mTolerance, scp.frameRate);
720
721    // sanity check params
722    if (scp.sync.mSource >= AVSYNC_SOURCE_MAX
723            || scp.sync.mAudioAdjustMode >= AVSYNC_AUDIO_ADJUST_MODE_MAX
724            || scp.sync.mTolerance < 0.f
725            || scp.sync.mTolerance >= AVSYNC_TOLERANCE_MAX) {
726        jniThrowException(env,  "java/lang/IllegalStateException", NULL);
727        return NULL;
728    }
729
730    scp.syncSourceSet = true;
731    scp.audioAdjustModeSet = true;
732    scp.toleranceSet = true;
733    scp.frameRateSet = scp.frameRate >= 0.f;
734
735    return scp.asJobject(env, gSyncParamsFields);
736}
737
738static void
739android_media_MediaPlayer2_seekTo(JNIEnv *env, jobject thiz, jlong msec, jint mode)
740{
741    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
742    if (mp == NULL ) {
743        jniThrowException(env, "java/lang/IllegalStateException", NULL);
744        return;
745    }
746    ALOGV("seekTo: %lld(msec), mode=%d", (long long)msec, mode);
747    process_media_player_call( env, thiz, mp->seekTo((int)msec, (MediaPlayer2SeekMode)mode), NULL, NULL );
748}
749
750static void
751android_media_MediaPlayer2_notifyAt(JNIEnv *env, jobject thiz, jlong mediaTimeUs)
752{
753    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
754    if (mp == NULL) {
755        jniThrowException(env, "java/lang/IllegalStateException", NULL);
756        return;
757    }
758    ALOGV("notifyAt: %lld", (long long)mediaTimeUs);
759    process_media_player_call( env, thiz, mp->notifyAt((int64_t)mediaTimeUs), NULL, NULL );
760}
761
762static jint
763android_media_MediaPlayer2_getVideoWidth(JNIEnv *env, jobject thiz)
764{
765    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
766    if (mp == NULL ) {
767        jniThrowException(env, "java/lang/IllegalStateException", NULL);
768        return 0;
769    }
770    int w;
771    if (0 != mp->getVideoWidth(&w)) {
772        ALOGE("getVideoWidth failed");
773        w = 0;
774    }
775    ALOGV("getVideoWidth: %d", w);
776    return (jint) w;
777}
778
779static jint
780android_media_MediaPlayer2_getVideoHeight(JNIEnv *env, jobject thiz)
781{
782    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
783    if (mp == NULL ) {
784        jniThrowException(env, "java/lang/IllegalStateException", NULL);
785        return 0;
786    }
787    int h;
788    if (0 != mp->getVideoHeight(&h)) {
789        ALOGE("getVideoHeight failed");
790        h = 0;
791    }
792    ALOGV("getVideoHeight: %d", h);
793    return (jint) h;
794}
795
796static jobject
797android_media_MediaPlayer2_native_getMetrics(JNIEnv *env, jobject thiz)
798{
799    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
800    if (mp == NULL ) {
801        jniThrowException(env, "java/lang/IllegalStateException", NULL);
802        return 0;
803    }
804
805    Parcel p;
806    int key = FOURCC('m','t','r','X');
807    status_t status = mp->getParameter(key, &p);
808    if (status != OK) {
809        ALOGD("getMetrics() failed: %d", status);
810        return (jobject) NULL;
811    }
812
813    p.setDataPosition(0);
814    MediaAnalyticsItem *item = new MediaAnalyticsItem;
815    item->readFromParcel(p);
816    jobject mybundle = MediaMetricsJNI::writeMetricsToBundle(env, item, NULL);
817
818    // housekeeping
819    delete item;
820    item = NULL;
821
822    return mybundle;
823}
824
825static jint
826android_media_MediaPlayer2_getCurrentPosition(JNIEnv *env, jobject thiz)
827{
828    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
829    if (mp == NULL ) {
830        jniThrowException(env, "java/lang/IllegalStateException", NULL);
831        return 0;
832    }
833    int msec;
834    process_media_player_call( env, thiz, mp->getCurrentPosition(&msec), NULL, NULL );
835    ALOGV("getCurrentPosition: %d (msec)", msec);
836    return (jint) msec;
837}
838
839static jint
840android_media_MediaPlayer2_getDuration(JNIEnv *env, jobject thiz)
841{
842    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
843    if (mp == NULL ) {
844        jniThrowException(env, "java/lang/IllegalStateException", NULL);
845        return 0;
846    }
847    int msec;
848    process_media_player_call( env, thiz, mp->getDuration(&msec), NULL, NULL );
849    ALOGV("getDuration: %d (msec)", msec);
850    return (jint) msec;
851}
852
853static void
854android_media_MediaPlayer2_reset(JNIEnv *env, jobject thiz)
855{
856    ALOGV("reset");
857    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
858    if (mp == NULL ) {
859        jniThrowException(env, "java/lang/IllegalStateException", NULL);
860        return;
861    }
862    process_media_player_call( env, thiz, mp->reset(), NULL, NULL );
863}
864
865static jint
866android_media_MediaPlayer2_getAudioStreamType(JNIEnv *env, jobject thiz)
867{
868    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
869    if (mp == NULL ) {
870        jniThrowException(env, "java/lang/IllegalStateException", NULL);
871        return 0;
872    }
873    audio_stream_type_t streamtype;
874    process_media_player_call( env, thiz, mp->getAudioStreamType(&streamtype), NULL, NULL );
875    ALOGV("getAudioStreamType: %d (streamtype)", streamtype);
876    return (jint) streamtype;
877}
878
879static jboolean
880android_media_MediaPlayer2_setParameter(JNIEnv *env, jobject thiz, jint key, jobject java_request)
881{
882    ALOGV("setParameter: key %d", key);
883    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
884    if (mp == NULL ) {
885        jniThrowException(env, "java/lang/IllegalStateException", NULL);
886        return false;
887    }
888
889    Parcel *request = parcelForJavaObject(env, java_request);
890    status_t err = mp->setParameter(key, *request);
891    if (err == OK) {
892        return true;
893    } else {
894        return false;
895    }
896}
897
898static void
899android_media_MediaPlayer2_setLooping(JNIEnv *env, jobject thiz, jboolean looping)
900{
901    ALOGV("setLooping: %d", looping);
902    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
903    if (mp == NULL ) {
904        jniThrowException(env, "java/lang/IllegalStateException", NULL);
905        return;
906    }
907    process_media_player_call( env, thiz, mp->setLooping(looping), NULL, NULL );
908}
909
910static jboolean
911android_media_MediaPlayer2_isLooping(JNIEnv *env, jobject thiz)
912{
913    ALOGV("isLooping");
914    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
915    if (mp == NULL ) {
916        jniThrowException(env, "java/lang/IllegalStateException", NULL);
917        return JNI_FALSE;
918    }
919    return mp->isLooping() ? JNI_TRUE : JNI_FALSE;
920}
921
922static void
923android_media_MediaPlayer2_setVolume(JNIEnv *env, jobject thiz, jfloat leftVolume, jfloat rightVolume)
924{
925    ALOGV("setVolume: left %f  right %f", (float) leftVolume, (float) rightVolume);
926    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
927    if (mp == NULL ) {
928        jniThrowException(env, "java/lang/IllegalStateException", NULL);
929        return;
930    }
931    process_media_player_call( env, thiz, mp->setVolume((float) leftVolume, (float) rightVolume), NULL, NULL );
932}
933
934// Sends the request and reply parcels to the media player via the
935// binder interface.
936static jint
937android_media_MediaPlayer2_invoke(JNIEnv *env, jobject thiz,
938                                 jobject java_request, jobject java_reply)
939{
940    sp<MediaPlayer2> media_player = getMediaPlayer(env, thiz);
941    if (media_player == NULL ) {
942        jniThrowException(env, "java/lang/IllegalStateException", NULL);
943        return UNKNOWN_ERROR;
944    }
945
946    Parcel *request = parcelForJavaObject(env, java_request);
947    Parcel *reply = parcelForJavaObject(env, java_reply);
948
949    request->setDataPosition(0);
950
951    // Don't use process_media_player_call which use the async loop to
952    // report errors, instead returns the status.
953    return (jint) media_player->invoke(*request, reply);
954}
955
956// Sends the new filter to the client.
957static jint
958android_media_MediaPlayer2_setMetadataFilter(JNIEnv *env, jobject thiz, jobject request)
959{
960    sp<MediaPlayer2> media_player = getMediaPlayer(env, thiz);
961    if (media_player == NULL ) {
962        jniThrowException(env, "java/lang/IllegalStateException", NULL);
963        return UNKNOWN_ERROR;
964    }
965
966    Parcel *filter = parcelForJavaObject(env, request);
967
968    if (filter == NULL ) {
969        jniThrowException(env, "java/lang/RuntimeException", "Filter is null");
970        return UNKNOWN_ERROR;
971    }
972
973    return (jint) media_player->setMetadataFilter(*filter);
974}
975
976static jboolean
977android_media_MediaPlayer2_getMetadata(JNIEnv *env, jobject thiz, jboolean update_only,
978                                      jboolean apply_filter, jobject reply)
979{
980    sp<MediaPlayer2> media_player = getMediaPlayer(env, thiz);
981    if (media_player == NULL ) {
982        jniThrowException(env, "java/lang/IllegalStateException", NULL);
983        return JNI_FALSE;
984    }
985
986    Parcel *metadata = parcelForJavaObject(env, reply);
987
988    if (metadata == NULL ) {
989        jniThrowException(env, "java/lang/RuntimeException", "Reply parcel is null");
990        return JNI_FALSE;
991    }
992
993    metadata->freeData();
994    // On return metadata is positioned at the beginning of the
995    // metadata. Note however that the parcel actually starts with the
996    // return code so you should not rewind the parcel using
997    // setDataPosition(0).
998    if (media_player->getMetadata(update_only, apply_filter, metadata) == OK) {
999        return JNI_TRUE;
1000    } else {
1001        return JNI_FALSE;
1002    }
1003}
1004
1005// This function gets some field IDs, which in turn causes class initialization.
1006// It is called from a static block in MediaPlayer2, which won't run until the
1007// first time an instance of this class is used.
1008static void
1009android_media_MediaPlayer2_native_init(JNIEnv *env)
1010{
1011    jclass clazz;
1012
1013    clazz = env->FindClass("android/media/MediaPlayer2Impl");
1014    if (clazz == NULL) {
1015        return;
1016    }
1017
1018    fields.context = env->GetFieldID(clazz, "mNativeContext", "J");
1019    if (fields.context == NULL) {
1020        return;
1021    }
1022
1023    fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative",
1024                                               "(Ljava/lang/Object;JIIILjava/lang/Object;)V");
1025    if (fields.post_event == NULL) {
1026        return;
1027    }
1028
1029    fields.surface_texture = env->GetFieldID(clazz, "mNativeSurfaceTexture", "J");
1030    if (fields.surface_texture == NULL) {
1031        return;
1032    }
1033
1034    env->DeleteLocalRef(clazz);
1035
1036    clazz = env->FindClass("android/net/ProxyInfo");
1037    if (clazz == NULL) {
1038        return;
1039    }
1040
1041    fields.proxyConfigGetHost =
1042        env->GetMethodID(clazz, "getHost", "()Ljava/lang/String;");
1043
1044    fields.proxyConfigGetPort =
1045        env->GetMethodID(clazz, "getPort", "()I");
1046
1047    fields.proxyConfigGetExclusionList =
1048        env->GetMethodID(clazz, "getExclusionListAsString", "()Ljava/lang/String;");
1049
1050    env->DeleteLocalRef(clazz);
1051
1052    gBufferingParamsFields.init(env);
1053
1054    // Modular DRM
1055    FIND_CLASS(clazz, "android/media/MediaDrm$MediaDrmStateException");
1056    if (clazz) {
1057        GET_METHOD_ID(gStateExceptionFields.init, clazz, "<init>", "(ILjava/lang/String;)V");
1058        gStateExceptionFields.classId = static_cast<jclass>(env->NewGlobalRef(clazz));
1059
1060        env->DeleteLocalRef(clazz);
1061    } else {
1062        ALOGE("JNI android_media_MediaPlayer2_native_init couldn't "
1063              "get clazz android/media/MediaDrm$MediaDrmStateException");
1064    }
1065
1066    gPlaybackParamsFields.init(env);
1067    gSyncParamsFields.init(env);
1068    gVolumeShaperFields.init(env);
1069}
1070
1071static void
1072android_media_MediaPlayer2_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
1073{
1074    ALOGV("native_setup");
1075    sp<MediaPlayer2> mp = new MediaPlayer2();
1076    if (mp == NULL) {
1077        jniThrowException(env, "java/lang/RuntimeException", "Out of memory");
1078        return;
1079    }
1080
1081    // create new listener and give it to MediaPlayer2
1082    sp<JNIMediaPlayer2Listener> listener = new JNIMediaPlayer2Listener(env, thiz, weak_this);
1083    mp->setListener(listener);
1084
1085    // Stow our new C++ MediaPlayer2 in an opaque field in the Java object.
1086    setMediaPlayer(env, thiz, mp);
1087}
1088
1089static void
1090android_media_MediaPlayer2_release(JNIEnv *env, jobject thiz)
1091{
1092    ALOGV("release");
1093    decVideoSurfaceRef(env, thiz);
1094    sp<MediaPlayer2> mp = setMediaPlayer(env, thiz, 0);
1095    if (mp != NULL) {
1096        // this prevents native callbacks after the object is released
1097        mp->setListener(0);
1098        mp->disconnect();
1099    }
1100}
1101
1102static void
1103android_media_MediaPlayer2_native_finalize(JNIEnv *env, jobject thiz)
1104{
1105    ALOGV("native_finalize");
1106    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1107    if (mp != NULL) {
1108        ALOGW("MediaPlayer2 finalized without being released");
1109    }
1110    android_media_MediaPlayer2_release(env, thiz);
1111}
1112
1113static void android_media_MediaPlayer2_set_audio_session_id(JNIEnv *env,  jobject thiz,
1114        jint sessionId) {
1115    ALOGV("set_session_id(): %d", sessionId);
1116    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1117    if (mp == NULL ) {
1118        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1119        return;
1120    }
1121    process_media_player_call( env, thiz, mp->setAudioSessionId((audio_session_t) sessionId), NULL,
1122            NULL);
1123}
1124
1125static jint android_media_MediaPlayer2_get_audio_session_id(JNIEnv *env,  jobject thiz) {
1126    ALOGV("get_session_id()");
1127    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1128    if (mp == NULL ) {
1129        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1130        return 0;
1131    }
1132
1133    return (jint) mp->getAudioSessionId();
1134}
1135
1136static void
1137android_media_MediaPlayer2_setAuxEffectSendLevel(JNIEnv *env, jobject thiz, jfloat level)
1138{
1139    ALOGV("setAuxEffectSendLevel: level %f", level);
1140    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1141    if (mp == NULL ) {
1142        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1143        return;
1144    }
1145    process_media_player_call( env, thiz, mp->setAuxEffectSendLevel(level), NULL, NULL );
1146}
1147
1148static void android_media_MediaPlayer2_attachAuxEffect(JNIEnv *env,  jobject thiz, jint effectId) {
1149    ALOGV("attachAuxEffect(): %d", effectId);
1150    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1151    if (mp == NULL ) {
1152        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1153        return;
1154    }
1155    process_media_player_call( env, thiz, mp->attachAuxEffect(effectId), NULL, NULL );
1156}
1157
1158static void
1159android_media_MediaPlayer2_setNextMediaPlayer(JNIEnv *env, jobject thiz, jobject java_player)
1160{
1161    ALOGV("setNextMediaPlayer");
1162    sp<MediaPlayer2> thisplayer = getMediaPlayer(env, thiz);
1163    if (thisplayer == NULL) {
1164        jniThrowException(env, "java/lang/IllegalStateException", "This player not initialized");
1165        return;
1166    }
1167    sp<MediaPlayer2> nextplayer = (java_player == NULL) ? NULL : getMediaPlayer(env, java_player);
1168    if (nextplayer == NULL && java_player != NULL) {
1169        jniThrowException(env, "java/lang/IllegalStateException", "That player not initialized");
1170        return;
1171    }
1172
1173    if (nextplayer == thisplayer) {
1174        jniThrowException(env, "java/lang/IllegalArgumentException", "Next player can't be self");
1175        return;
1176    }
1177    // tie the two players together
1178    process_media_player_call(
1179            env, thiz, thisplayer->setNextMediaPlayer(nextplayer),
1180            "java/lang/IllegalArgumentException",
1181            "setNextMediaPlayer failed." );
1182    ;
1183}
1184
1185/////////////////////////////////////////////////////////////////////////////////////
1186// Modular DRM begin
1187
1188// TODO: investigate if these can be shared with their MediaDrm counterparts
1189static void throwDrmStateException(JNIEnv *env, const char *msg, status_t err)
1190{
1191    ALOGE("Illegal DRM state exception: %s (%d)", msg, err);
1192
1193    jobject exception = env->NewObject(gStateExceptionFields.classId,
1194            gStateExceptionFields.init, static_cast<int>(err),
1195            env->NewStringUTF(msg));
1196    env->Throw(static_cast<jthrowable>(exception));
1197}
1198
1199// TODO: investigate if these can be shared with their MediaDrm counterparts
1200static bool throwDrmExceptionAsNecessary(JNIEnv *env, status_t err, const char *msg = NULL)
1201{
1202    const char *drmMessage = "Unknown DRM Msg";
1203
1204    switch (err) {
1205    case ERROR_DRM_UNKNOWN:
1206        drmMessage = "General DRM error";
1207        break;
1208    case ERROR_DRM_NO_LICENSE:
1209        drmMessage = "No license";
1210        break;
1211    case ERROR_DRM_LICENSE_EXPIRED:
1212        drmMessage = "License expired";
1213        break;
1214    case ERROR_DRM_SESSION_NOT_OPENED:
1215        drmMessage = "Session not opened";
1216        break;
1217    case ERROR_DRM_DECRYPT_UNIT_NOT_INITIALIZED:
1218        drmMessage = "Not initialized";
1219        break;
1220    case ERROR_DRM_DECRYPT:
1221        drmMessage = "Decrypt error";
1222        break;
1223    case ERROR_DRM_CANNOT_HANDLE:
1224        drmMessage = "Unsupported scheme or data format";
1225        break;
1226    case ERROR_DRM_TAMPER_DETECTED:
1227        drmMessage = "Invalid state";
1228        break;
1229    default:
1230        break;
1231    }
1232
1233    String8 vendorMessage;
1234    if (err >= ERROR_DRM_VENDOR_MIN && err <= ERROR_DRM_VENDOR_MAX) {
1235        vendorMessage = String8::format("DRM vendor-defined error: %d", err);
1236        drmMessage = vendorMessage.string();
1237    }
1238
1239    if (err == BAD_VALUE) {
1240        jniThrowException(env, "java/lang/IllegalArgumentException", msg);
1241        return true;
1242    } else if (err == ERROR_DRM_NOT_PROVISIONED) {
1243        jniThrowException(env, "android/media/NotProvisionedException", msg);
1244        return true;
1245    } else if (err == ERROR_DRM_RESOURCE_BUSY) {
1246        jniThrowException(env, "android/media/ResourceBusyException", msg);
1247        return true;
1248    } else if (err == ERROR_DRM_DEVICE_REVOKED) {
1249        jniThrowException(env, "android/media/DeniedByServerException", msg);
1250        return true;
1251    } else if (err == DEAD_OBJECT) {
1252        jniThrowException(env, "android/media/MediaDrmResetException",
1253                          "mediaserver died");
1254        return true;
1255    } else if (err != OK) {
1256        String8 errbuf;
1257        if (drmMessage != NULL) {
1258            if (msg == NULL) {
1259                msg = drmMessage;
1260            } else {
1261                errbuf = String8::format("%s: %s", msg, drmMessage);
1262                msg = errbuf.string();
1263            }
1264        }
1265        throwDrmStateException(env, msg, err);
1266        return true;
1267    }
1268    return false;
1269}
1270
1271static Vector<uint8_t> JByteArrayToVector(JNIEnv *env, jbyteArray const &byteArray)
1272{
1273    Vector<uint8_t> vector;
1274    size_t length = env->GetArrayLength(byteArray);
1275    vector.insertAt((size_t)0, length);
1276    env->GetByteArrayRegion(byteArray, 0, length, (jbyte *)vector.editArray());
1277    return vector;
1278}
1279
1280static void android_media_MediaPlayer2_prepareDrm(JNIEnv *env, jobject thiz,
1281                    jbyteArray uuidObj, jbyteArray drmSessionIdObj)
1282{
1283    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1284    if (mp == NULL) {
1285        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1286        return;
1287    }
1288
1289    if (uuidObj == NULL) {
1290        jniThrowException(env, "java/lang/IllegalArgumentException", NULL);
1291        return;
1292    }
1293
1294    Vector<uint8_t> uuid = JByteArrayToVector(env, uuidObj);
1295
1296    if (uuid.size() != 16) {
1297        jniThrowException(
1298                          env,
1299                          "java/lang/IllegalArgumentException",
1300                          "invalid UUID size, expected 16 bytes");
1301        return;
1302    }
1303
1304    Vector<uint8_t> drmSessionId = JByteArrayToVector(env, drmSessionIdObj);
1305
1306    if (drmSessionId.size() == 0) {
1307        jniThrowException(
1308                          env,
1309                          "java/lang/IllegalArgumentException",
1310                          "empty drmSessionId");
1311        return;
1312    }
1313
1314    status_t err = mp->prepareDrm(uuid.array(), drmSessionId);
1315    if (err != OK) {
1316        if (err == INVALID_OPERATION) {
1317            jniThrowException(
1318                              env,
1319                              "java/lang/IllegalStateException",
1320                              "The player must be in prepared state.");
1321        } else if (err == ERROR_DRM_CANNOT_HANDLE) {
1322            jniThrowException(
1323                              env,
1324                              "android/media/UnsupportedSchemeException",
1325                              "Failed to instantiate drm object.");
1326        } else {
1327            throwDrmExceptionAsNecessary(env, err, "Failed to prepare DRM scheme");
1328        }
1329    }
1330}
1331
1332static void android_media_MediaPlayer2_releaseDrm(JNIEnv *env, jobject thiz)
1333{
1334    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1335    if (mp == NULL ) {
1336        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1337        return;
1338    }
1339
1340    status_t err = mp->releaseDrm();
1341    if (err != OK) {
1342        if (err == INVALID_OPERATION) {
1343            jniThrowException(
1344                              env,
1345                              "java/lang/IllegalStateException",
1346                              "Can not release DRM in an active player state.");
1347        }
1348    }
1349}
1350// Modular DRM end
1351// ----------------------------------------------------------------------------
1352
1353/////////////////////////////////////////////////////////////////////////////////////
1354// AudioRouting begin
1355static jboolean android_media_MediaPlayer2_setOutputDevice(JNIEnv *env, jobject thiz, jint device_id)
1356{
1357    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1358    if (mp == NULL) {
1359        return false;
1360    }
1361    return mp->setOutputDevice(device_id) == NO_ERROR;
1362}
1363
1364static jint android_media_MediaPlayer2_getRoutedDeviceId(JNIEnv *env, jobject thiz)
1365{
1366    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1367    if (mp == NULL) {
1368        return AUDIO_PORT_HANDLE_NONE;
1369    }
1370    return mp->getRoutedDeviceId();
1371}
1372
1373static void android_media_MediaPlayer2_enableDeviceCallback(
1374        JNIEnv* env, jobject thiz, jboolean enabled)
1375{
1376    sp<MediaPlayer2> mp = getMediaPlayer(env, thiz);
1377    if (mp == NULL) {
1378        return;
1379    }
1380
1381    status_t status = mp->enableAudioDeviceCallback(enabled);
1382    if (status != NO_ERROR) {
1383        jniThrowException(env, "java/lang/IllegalStateException", NULL);
1384        ALOGE("enable device callback failed: %d", status);
1385    }
1386}
1387
1388// AudioRouting end
1389// ----------------------------------------------------------------------------
1390
1391/////////////////////////////////////////////////////////////////////////////////////
1392// AudioTrack.StreamEventCallback begin
1393static void android_media_MediaPlayer2_native_on_tear_down(JNIEnv *env __unused,
1394        jobject thiz __unused, jlong callbackPtr, jlong userDataPtr)
1395{
1396    JAudioTrack::callback_t callback = (JAudioTrack::callback_t) callbackPtr;
1397    if (callback != NULL) {
1398        callback(JAudioTrack::EVENT_NEW_IAUDIOTRACK, (void *) userDataPtr, NULL);
1399    }
1400}
1401
1402static void android_media_MediaPlayer2_native_on_stream_presentation_end(JNIEnv *env __unused,
1403        jobject thiz __unused, jlong callbackPtr, jlong userDataPtr)
1404{
1405    JAudioTrack::callback_t callback = (JAudioTrack::callback_t) callbackPtr;
1406    if (callback != NULL) {
1407        callback(JAudioTrack::EVENT_STREAM_END, (void *) userDataPtr, NULL);
1408    }
1409}
1410
1411static void android_media_MediaPlayer2_native_on_stream_data_request(JNIEnv *env __unused,
1412        jobject thiz __unused, jlong jAudioTrackPtr, jlong callbackPtr, jlong userDataPtr)
1413{
1414    JAudioTrack::callback_t callback = (JAudioTrack::callback_t) callbackPtr;
1415    JAudioTrack* track = (JAudioTrack *) jAudioTrackPtr;
1416    if (callback != NULL && track != NULL) {
1417        JAudioTrack::Buffer* buffer = new JAudioTrack::Buffer();
1418
1419        size_t bufferSizeInFrames = track->frameCount();
1420        audio_format_t format = track->format();
1421
1422        size_t bufferSizeInBytes;
1423        if (audio_has_proportional_frames(format)) {
1424            bufferSizeInBytes =
1425                    bufferSizeInFrames * audio_bytes_per_sample(format) * track->channelCount();
1426        } else {
1427            // See Javadoc of AudioTrack::getBufferSizeInFrames().
1428            bufferSizeInBytes = bufferSizeInFrames;
1429        }
1430
1431        uint8_t* byteBuffer = new uint8_t[bufferSizeInBytes];
1432        buffer->mSize = bufferSizeInBytes;
1433        buffer->mData = (void *) byteBuffer;
1434
1435        callback(JAudioTrack::EVENT_MORE_DATA, (void *) userDataPtr, buffer);
1436
1437        if (buffer->mSize > 0 && buffer->mData == byteBuffer) {
1438            track->write(buffer->mData, buffer->mSize, true /* Blocking */);
1439        }
1440
1441        delete[] byteBuffer;
1442        delete buffer;
1443    }
1444}
1445
1446
1447// AudioTrack.StreamEventCallback end
1448// ----------------------------------------------------------------------------
1449
1450static const JNINativeMethod gMethods[] = {
1451    {
1452        "nativeSetDataSource",
1453        "(JLandroid/media/Media2HTTPService;Ljava/lang/String;[Ljava/lang/String;"
1454        "[Ljava/lang/String;)V",
1455        (void *)android_media_MediaPlayer2_setDataSourceAndHeaders
1456    },
1457
1458    {"_setDataSource",      "(JLjava/io/FileDescriptor;JJ)V",    (void *)android_media_MediaPlayer2_setDataSourceFD},
1459    {"_setDataSource",      "(JLandroid/media/Media2DataSource;)V",(void *)android_media_MediaPlayer2_setDataSourceCallback },
1460    {"_setVideoSurface",    "(Landroid/view/Surface;)V",        (void *)android_media_MediaPlayer2_setVideoSurface},
1461    {"getBufferingParams", "()Landroid/media/BufferingParams;", (void *)android_media_MediaPlayer2_getBufferingParams},
1462    {"setBufferingParams", "(Landroid/media/BufferingParams;)V", (void *)android_media_MediaPlayer2_setBufferingParams},
1463    {"_prepare",            "()V",                              (void *)android_media_MediaPlayer2_prepare},
1464    {"prepareAsync",        "()V",                              (void *)android_media_MediaPlayer2_prepareAsync},
1465    {"_start",              "()V",                              (void *)android_media_MediaPlayer2_start},
1466    {"_stop",               "()V",                              (void *)android_media_MediaPlayer2_stop},
1467    {"getVideoWidth",       "()I",                              (void *)android_media_MediaPlayer2_getVideoWidth},
1468    {"getVideoHeight",      "()I",                              (void *)android_media_MediaPlayer2_getVideoHeight},
1469    {"native_getMetrics",   "()Landroid/os/PersistableBundle;", (void *)android_media_MediaPlayer2_native_getMetrics},
1470    {"setPlaybackParams", "(Landroid/media/PlaybackParams;)V", (void *)android_media_MediaPlayer2_setPlaybackParams},
1471    {"getPlaybackParams", "()Landroid/media/PlaybackParams;", (void *)android_media_MediaPlayer2_getPlaybackParams},
1472    {"setSyncParams",     "(Landroid/media/SyncParams;)V",  (void *)android_media_MediaPlayer2_setSyncParams},
1473    {"getSyncParams",     "()Landroid/media/SyncParams;",   (void *)android_media_MediaPlayer2_getSyncParams},
1474    {"_seekTo",             "(JI)V",                            (void *)android_media_MediaPlayer2_seekTo},
1475    {"_notifyAt",           "(J)V",                             (void *)android_media_MediaPlayer2_notifyAt},
1476    {"_pause",              "()V",                              (void *)android_media_MediaPlayer2_pause},
1477    {"isPlaying",           "()Z",                              (void *)android_media_MediaPlayer2_isPlaying},
1478    {"getCurrentPosition",  "()I",                              (void *)android_media_MediaPlayer2_getCurrentPosition},
1479    {"getDuration",         "()I",                              (void *)android_media_MediaPlayer2_getDuration},
1480    {"_release",            "()V",                              (void *)android_media_MediaPlayer2_release},
1481    {"_reset",              "()V",                              (void *)android_media_MediaPlayer2_reset},
1482    {"_getAudioStreamType", "()I",                              (void *)android_media_MediaPlayer2_getAudioStreamType},
1483    {"setParameter",        "(ILandroid/os/Parcel;)Z",          (void *)android_media_MediaPlayer2_setParameter},
1484    {"setLooping",          "(Z)V",                             (void *)android_media_MediaPlayer2_setLooping},
1485    {"isLooping",           "()Z",                              (void *)android_media_MediaPlayer2_isLooping},
1486    {"_setVolume",          "(FF)V",                            (void *)android_media_MediaPlayer2_setVolume},
1487    {"native_invoke",       "(Landroid/os/Parcel;Landroid/os/Parcel;)I",(void *)android_media_MediaPlayer2_invoke},
1488    {"native_setMetadataFilter", "(Landroid/os/Parcel;)I",      (void *)android_media_MediaPlayer2_setMetadataFilter},
1489    {"native_getMetadata", "(ZZLandroid/os/Parcel;)Z",          (void *)android_media_MediaPlayer2_getMetadata},
1490    {"native_init",         "()V",                              (void *)android_media_MediaPlayer2_native_init},
1491    {"native_setup",        "(Ljava/lang/Object;)V",            (void *)android_media_MediaPlayer2_native_setup},
1492    {"native_finalize",     "()V",                              (void *)android_media_MediaPlayer2_native_finalize},
1493    {"getAudioSessionId",   "()I",                              (void *)android_media_MediaPlayer2_get_audio_session_id},
1494    {"setAudioSessionId",   "(I)V",                             (void *)android_media_MediaPlayer2_set_audio_session_id},
1495    {"_setAuxEffectSendLevel", "(F)V",                          (void *)android_media_MediaPlayer2_setAuxEffectSendLevel},
1496    {"attachAuxEffect",     "(I)V",                             (void *)android_media_MediaPlayer2_attachAuxEffect},
1497    {"setNextMediaPlayer",  "(Landroid/media/MediaPlayer2;)V",  (void *)android_media_MediaPlayer2_setNextMediaPlayer},
1498    // Modular DRM
1499    { "_prepareDrm", "([B[B)V",                                 (void *)android_media_MediaPlayer2_prepareDrm },
1500    { "_releaseDrm", "()V",                                     (void *)android_media_MediaPlayer2_releaseDrm },
1501
1502    // AudioRouting
1503    {"native_setOutputDevice", "(I)Z",                          (void *)android_media_MediaPlayer2_setOutputDevice},
1504    {"native_getRoutedDeviceId", "()I",                         (void *)android_media_MediaPlayer2_getRoutedDeviceId},
1505    {"native_enableDeviceCallback", "(Z)V",                     (void *)android_media_MediaPlayer2_enableDeviceCallback},
1506
1507    // StreamEventCallback for JAudioTrack
1508    {"native_stream_event_onTearDown",                "(JJ)V",  (void *)android_media_MediaPlayer2_native_on_tear_down},
1509    {"native_stream_event_onStreamPresentationEnd",   "(JJ)V",  (void *)android_media_MediaPlayer2_native_on_stream_presentation_end},
1510    {"native_stream_event_onStreamDataRequest",       "(JJJ)V", (void *)android_media_MediaPlayer2_native_on_stream_data_request},
1511};
1512
1513// This function only registers the native methods
1514static int register_android_media_MediaPlayer2Impl(JNIEnv *env)
1515{
1516    return AndroidRuntime::registerNativeMethods(env,
1517                "android/media/MediaPlayer2Impl", gMethods, NELEM(gMethods));
1518}
1519
1520jint JNI_OnLoad(JavaVM* vm, void* /* reserved */)
1521{
1522    JNIEnv* env = NULL;
1523    jint result = -1;
1524
1525    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
1526        ALOGE("ERROR: GetEnv failed\n");
1527        goto bail;
1528    }
1529    assert(env != NULL);
1530
1531    if (register_android_media_MediaPlayer2Impl(env) < 0) {
1532        ALOGE("ERROR: MediaPlayer2 native registration failed\n");
1533        goto bail;
1534    }
1535
1536    /* success -- return valid version number */
1537    result = JNI_VERSION_1_4;
1538
1539bail:
1540    return result;
1541}
1542
1543// KTHXBYE
1544