MediaPlayer JNI层介绍

frameworks\base\media\java\android\media\MediaPlayer.java
frameworks\base\media\jni\android_media_MediaPlayer.cpp
frameworks\base\core\jni\AndroidRuntime.cpp
frameworks\av\media\libmedia\mediaplayer.cpp
​
libnativehelper\include\nativehelper\JNIHelp.h
​
frameworks\av\media\libmedia\IMediaPlayer.cpp
frameworks\av\media\libmedia\IMediaDeathNotifier.cpp
frameworks\native\libs\binder\IServiceManager.cpp
frameworks\av\media\libmedia\IMediaPlayerService.cpp

 1. System.loadLibrary("media_jni");
 2. native_init();
 3. native_setup();
 4. _setDataSource();
 5. _prepare();
 6. _start();

static int register_android_media_MediaPlayer(JNIEnv *env){
    return AndroidRuntime::registerNativeMethods(env,
                "android/media/MediaPlayer", gMethods, NELEM(gMethods));
}

int AndroidRuntime::registerNativeMethods(JNIEnv* env,
 const char* className, const JNINativeMethod* gMethods, int numMethods){
    return jniRegisterNativeMethods(env, className, gMethods, numMethods);
}

libnativehelper\include\nativehelper\JNIHelp.h

//部分
static const JNINativeMethod gMethods[] = {
    {"_setDataSource",      "(Ljava/io/FileDescriptor;JJ)V",    (void *)android_media_MediaPlayer_setDataSourceFD},
    {"native_init",         "()V",                              (void *)android_media_MediaPlayer_native_init},
    {"native_setup",        "(Ljava/lang/Object;)V",            (void *)android_media_MediaPlayer_native_setup},
    {"native_finalize",     "()V",                              (void *)android_media_MediaPlayer_native_finalize},
};

static void android_media_MediaPlayer_native_init(JNIEnv *env){
    jclass clazz;
    //加载android.media.MediaPlayer
    clazz = env->FindClass("android/media/MediaPlayer");
    //略
    // postEventFromNative java方法ID，用于回调
    fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative","(Ljava/lang/Object;IIILjava/lang/Object;)V");
    if (fields.post_event == NULL) {
        return;
    }
    //释放
    env->DeleteLocalRef(clazz);
    //略
}

static void android_media_MediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this){
    //创建MediaPlayer对象
    sp<MediaPlayer> mp = new MediaPlayer();
    //回调监听，调用Java方法postEventFromNative回调
    sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener(env, thiz, weak_this);
    mp->setListener(listener);
    //把MediaPlayer对象保存起来了，后面会通过get获取
    setMediaPlayer(env, thiz, mp);
}

void JNIMediaPlayerListener::notify(int msg, int ext1, int ext2, const Parcel *obj){
    JNIEnv *env = AndroidRuntime::getJNIEnv();
    if (obj && obj->dataSize() > 0) {
        jobject jParcel = createJavaParcelObject(env);
        //数据封装
        if (jParcel != NULL) {
            Parcel* nativeParcel = parcelForJavaObject(env, jParcel);
            nativeParcel->setData(obj->data(), obj->dataSize());
            //重点
            env->CallStaticVoidMethod(mClass, fields.post_event, mObject,
                    msg, ext1, ext2, jParcel);
            env->DeleteLocalRef(jParcel);
        }
    } else {
        //重点
        env->CallStaticVoidMethod(mClass, fields.post_event, mObject,
                msg, ext1, ext2, NULL);
    }
}

CallStaticDoubleMethod()
CallStaticIntMethod()
CallStaticBooleanMethodA()

static sp<MediaPlayer> getMediaPlayer(JNIEnv* env, jobject thiz){
    Mutex::Autolock l(sLock);//锁
    //获取已经初始化过的MediaPlayer
    MediaPlayer* const p = (MediaPlayer*)env->GetLongField(thiz, fields.context);
    return sp<MediaPlayer>(p);
}
​
static sp<MediaPlayer> setMediaPlayer(JNIEnv* env, jobject thiz, const sp<MediaPlayer>& player){
    Mutex::Autolock l(sLock);
    sp<MediaPlayer> old = (MediaPlayer*)env->GetLongField(thiz, fields.context);
    if (player.get()) {
        player->incStrong((void*)setMediaPlayer);
    }
    if (old != 0) {
        old->decStrong((void*)setMediaPlayer);
    }
    //保存MediaPlayer,后面会获取
    env->SetLongField(thiz, fields.context, (jlong)player.get());
    return old;
}

private native void _setDataSource(FileDescriptor fd, long offset, long length);    
private native void _setDataSource(MediaDataSource dataSource);

static void android_media_MediaPlayer_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length){
    //获取MediaPlayer对象
    sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
    //也在上面nativehelper\JNIHelp.h定义，这里不关心
    int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
    //重点mp->setDataSource(fd, offset, length)
    //process_media_player_call只是处理状态码，后面很多方法都用这个。
    process_media_player_call( env, thiz, mp->setDataSource(fd, offset, length), "java/io/IOException", "setDataSourceFD failed." );
}

static void android_media_MediaPlayer_prepare(JNIEnv *env, jobject thiz){
    //获取MediaPlayer对象
    sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
    //mp->prepare()
    process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." );
}

static void android_media_MediaPlayer_start(JNIEnv *env, jobject thiz){
    sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
    //mp->start()
    process_media_player_call( env, thiz, mp->start(), NULL, NULL );
}

sp<MediaPlayer> mp = new MediaPlayer();

sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener(env, thiz, weak_this);
mp->setListener(listener);

status_t MediaPlayer::setDataSource(
        const sp<IMediaHTTPService> &httpService,
        const char *url, const KeyedVector<String8, String8> *headers){
    status_t err = BAD_VALUE;
    if (url != NULL) {
        //[重点]。BpMediaPlayerService的对象service
        const sp<IMediaPlayerService> service(getMediaPlayerService());
        if (service != 0) {
            //[重点]。创建BpMediaPlayer对象player
            sp<IMediaPlayer> player(service->create(this, mAudioSessionId));
            if ((NO_ERROR != doSetRetransmitEndpoint(player)) ||
                //BpMediaPlayer.setDataSource();
                (NO_ERROR != player->setDataSource(httpService, url, headers))) {
                player.clear();
            }
            err = attachNewPlayer(player);
        }
    }
    return err;
}

const sp<IMediaPlayerService>IMediaDeathNotifier::getMediaPlayerService()
{
    Mutex::Autolock _l(sServiceLock);
    //单例模式，如果是第一次，sMediaPlayerService==0
    if (sMediaPlayerService == 0) {
        //interface_cast获取BpMediaPlayerService的对象
        sMediaPlayerService = interface_cast<IMediaPlayerService>(binder);
    }
    return sMediaPlayerService;
}

virtual sp<IMediaPlayer> create(
        const sp<IMediaPlayerClient>& client, audio_session_t audioSessionId) {
    Parcel data, reply;
    data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());
    data.writeStrongBinder(IInterface::asBinder(client));
    data.writeInt32(audioSessionId);
    remote()->transact(CREATE, data, &reply);
    //interface_cast获取BpMediaPlayer
    return interface_cast<IMediaPlayer>(reply.readStrongBinder());
}

status_t setDataSource(int fd, int64_t offset, int64_t length) {
    Parcel data, reply;
    data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());
    data.writeFileDescriptor(fd);
    data.writeInt64(offset);
    data.writeInt64(length);
    //有点晕，BpBinder(0)
    remote()->transact(SET_DATA_SOURCE_FD, data, &reply);
    return reply.readInt32();
}

//prepare()
status_t MediaPlayer::prepare(){
    Mutex::Autolock _l(mLock);
    mLockThreadId = getThreadId();
    if (mPrepareSync) {
        mLockThreadId = 0;
        return -EALREADY;
    }
    mPrepareSync = true;
    //最终都是走了prepareAsync_l()
    status_t ret = prepareAsync_l();
    if (ret != NO_ERROR) {
        mLockThreadId = 0;
        return ret;
    }
    //[重点] 等待Prepare完成，也就是等mSignal释放锁，
    //这里跟prepareAsync()的区别
    if (mPrepareSync) {
        mSignal.wait(mLock);  
        mPrepareSync = false;
    }
    mLockThreadId = 0;
    return mPrepareStatus;
}
//prepareAsync()
status_t MediaPlayer::prepareAsync(){
    Mutex::Autolock _l(mLock);
    //最终都是走了prepareAsync_l()
    return prepareAsync_l();
}

void MediaPlayer::notify(int msg, int ext1, int ext2, const Parcel *obj){
    bool send = true;
    bool locked = false;
    if (mLockThreadId != getThreadId()) {
        mLock.lock();
        locked = true;
    }
    switch (msg) {
    case MEDIA_PREPARED:
        mCurrentState = MEDIA_PLAYER_PREPARED;
        if (mPrepareSync) {
            mPrepareSync = false;
            mPrepareStatus = NO_ERROR;
            mSignal.signal();
        }
        break;
    case MEDIA_ERROR:
        mCurrentState = MEDIA_PLAYER_STATE_ERROR;
        if (mPrepareSync){
            mPrepareSync = false;
            mPrepareStatus = ext1;
            mSignal.signal();
            send = false;
        }
        break;
    }
    sp<MediaPlayerListener> listener = mListener;
    if (locked) mLock.unlock();
    if ((listener != 0) && send) {
        Mutex::Autolock _l(mNotifyLock);
        // 这个就是我们传入的JNIMediaPlayerListener
        listener->notify(msg, ext1, ext2, obj);
    }
}

status_t MediaPlayer::prepareAsync_l(){
    if ( (mPlayer != 0) && ( mCurrentState & (MEDIA_PLAYER_INITIALIZED | MEDIA_PLAYER_STOPPED) ) ) {
        //执行BpMediaPlayer.prepareAsync()
        return mPlayer->prepareAsync();
    }
    //有个短暂的PREPARING状态
    mCurrentState = MEDIA_PLAYER_PREPARING;
    return INVALID_OPERATION;
}

status_t MediaPlayer::start(){
    status_t ret = NO_ERROR;
    Mutex::Autolock _l(mLock);
    mLockThreadId = getThreadId();
    if (mCurrentState & MEDIA_PLAYER_STARTED) {
        ret = NO_ERROR;
    } else if ( (mPlayer != 0) && ( mCurrentState & ( MEDIA_PLAYER_PREPARED |
                    MEDIA_PLAYER_PLAYBACK_COMPLETE | MEDIA_PLAYER_PAUSED ) ) ) {
        //设置是否循环mLoop
        mPlayer->setLooping(mLoop);
        //设置音量
        mPlayer->setVolume(mLeftVolume, mRightVolume);
        //这个不太懂。。。一般APP没设置过
        mPlayer->setAuxEffectSendLevel(mSendLevel);
        //改变播放状态
        mCurrentState = MEDIA_PLAYER_STARTED;
        //BpMediaPlayer.prepareAsync()
        ret = mPlayer->start();
        if (ret != NO_ERROR) {
            mCurrentState = MEDIA_PLAYER_STATE_ERROR;
        }
    } else {
        ret = INVALID_OPERATION;
    }
    mLockThreadId = 0;
    return ret;
}