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