1
2
 MediaPlayer.create(this, Uri.parse(" url") );

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
  //create源码
  public static MediaPlayer create(Context context, Uri uri, SurfaceHolder holder,
                                     AudioAttributes audioAttributes, int audioSessionId) {
        try {
            MediaPlayer mp = new MediaPlayer();
            //声音处理，如果为空就new一个
            final AudioAttributes aa = audioAttributes != null ? audioAttributes :
                    new AudioAttributes.Builder().build();
            //设置音频属性
            mp.setAudioAttributes(aa);
            //设置声音会话Id，视频和音频是分开渲染的
            mp.setAudioSessionId(audioSessionId);
            //从这里setDataSource，传入uri统一资源标志符
            mp.setDataSource(context, uri);
            //判断SurfaceHolder是否为空，这是一个控制器，用来操作Surface，处理它在Canvas上作画的效果和动画，控制表面、大小、像素
            if (holder != null) {
                //给Surface设置一个控制器
                mp.setDisplay(holder);
            }
            //开始准备
            mp.prepare();
            return mp;
        } catch (IOException ex) {
            Log.d(TAG, "create failed:", ex);
            // fall through
        } catch (IllegalArgumentException ex) {
            Log.d(TAG, "create failed:", ex);
            // fall through
        } catch (SecurityException ex) {
            Log.d(TAG, "create failed:", ex);
            // fall through
        }

        return null;
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
 public MediaPlayer() {
        super(new AudioAttributes.Builder().build(),
                AudioPlaybackConfiguration.PLAYER_TYPE_JAM_MEDIAPLAYER);

        //定义一个Looper
        Looper looper;
        if ((looper = Looper.myLooper()) != null) {
            //如果myLooper不为空就赋值给myLooper，并实例化一个EventHandler对象
            mEventHandler = new EventHandler(this, looper);
        } else if ((looper = Looper.getMainLooper()) != null) {
            //如果主线程Looper不为空，就赋值给looper，并实例化一个EventHandler对象
            mEventHandler = new EventHandler(this, looper);
        } else {
            mEventHandler = null;
        }

        //时间数据容器，一般provider都是和数据联系起来的，如ContentProvider、VideoProvider
        mTimeProvider = new TimeProvider(this);
        mOpenSubtitleSources = new Vector<InputStream>();

        //通过Binder机制获取到原生的OPS服务
        IBinder b = ServiceManager.getService(Context.APP_OPS_SERVICE);
        mAppOps = IAppOpsService.Stub.asInterface(b);

        //通过之后获取到的服务，就能使用native_setup方法开始创建MediaPlayer了，而且还是软引用，
        //接下来就是放在C++层去创建MediaPlayer了
        native_setup(new WeakReference<MediaPlayer>(this));
 }

1
2
3
4
5
static {
        System.loadLibrary("media_jni");
        native_init();
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
//android_media_MediaPlayer.cpp
    static void
    android_media_MediaPlayer_native_init(JNIEnv *env) {
        //类的句柄
        jclass clazz;
        //这里通过Native层调用Java层，获取MediaPlayer对象
        clazz = env -> FindClass("android/media/MediaPlayer");

        if (clazz == NULL) {
            //判空
            return;
        }

        //获取成员变量mNativeContext,它是一个long型，实际对应的是一个内存地址
        fields.context = env -> GetFieldID(clazz, "mNativeContext", "J");
        if (fields.context == NULL) {
            return;
        }

        fields.post_event = env -> GetStaticMethodID(clazz, "postEventFromNative",
                "(Ljava/lang/Object;IIILjava/lang/Object;)V");
        if (fields.post_event == NULL) {
            return;
        }
        ...
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
    private static void postEventFromNative(Object mediaplayer_ref,
                                            int what, int arg1, int arg2, Object obj)
    {
        //得到弱引用的MediaPlayer
        final MediaPlayer mp = (MediaPlayer)((WeakReference)mediaplayer_ref).get();
        if (mp == null) {
            return;
        }
        ...
        //如果handler不为空，则发送一条message
        if (mp.mEventHandler != null) {
            Message m = mp.mEventHandler.obtainMessage(what, arg1, arg2, obj);
            mp.mEventHandler.sendMessage(m);
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
//android_media_MediaPlayer.cpp
    static void
    android_media_MediaPlayer_native_setup(JNIEnv *env, jobject thiz, jobject weak_this)
    {
        ALOGV("native_setup");
        sp<MediaPlayer> mp = new MediaPlayer();
        ...

        // 给MediaPlayer创建一个Listener，便于我们在Java层设置的 setPrepareListener、setOnCompleteListener能产生回调
        sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener(env, thiz, weak_this);
        mp->setListener(listener);

        // 对于Java层来说，C++中的MediaPlayer是不透明的，也无需关心其对应的逻辑，各司其职就行了
        setMediaPlayer(env, thiz, mp);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
   private void setDataSource(String path, Map<String, String> headers, List<HttpCookie> cookies)
            throws IOException, IllegalArgumentException, SecurityException, IllegalStateException
    {
        String[] keys = null;
        String[] values = null;

        if (headers != null) {
            keys = new String[headers.size()];
            values = new String[headers.size()];

            int i = 0;
            //把HTPP/RTSP中包含的key、value分别装到两个数组中
            for (Map.Entry<String, String> entry: headers.entrySet()) {
                keys[i] = entry.getKey();
                values[i] = entry.getValue();
                ++i;
            }
        }
        setDataSource(path, keys, values, cookies);
    }

    private void setDataSource(String path, String[] keys, String[] values,
                               List<HttpCookie> cookies)
            throws IOException, IllegalArgumentException, SecurityException, IllegalStateException {
        //解析path
        final Uri uri = Uri.parse(path);
        final String scheme = uri.getScheme();
        if ("file".equals(scheme)) {
            path = uri.getPath();
        } else if (scheme != null) {
            // 处理非资源文件
            nativeSetDataSource(
                    MediaHTTPService.createHttpServiceBinderIfNecessary(path, cookies),
                    path,
                    keys,
                    values);
            return;
        }

        //处理文件类型
        final File file = new File(path);
        if (file.exists()) {
            FileInputStream is = new FileInputStream(file);
            //得到文件标识符
            FileDescriptor fd = is.getFD();
            //传入文件标志符
            setDataSource(fd);
            is.close();
        } else {
            throw new IOException("setDataSource failed.");
        }
    }

    public void setDataSource(FileDescriptor fd)
            throws IOException, IllegalArgumentException, IllegalStateException {
        setDataSource(fd, 0, 0x7ffffffffffffffL);
    }
    public void setDataSource(FileDescriptor fd, long offset, long length)
            throws IOException, IllegalArgumentException, IllegalStateException {
        //进入native层
        _setDataSource(fd, offset, length);
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
static void
    android_media_MediaPlayer_setDataSourceFD(JNIEnv *env, jobject thiz, jobject fileDescriptor, jlong offset, jlong length)
    {
        //获得MediaPlayer
        sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
        ...

        //在JNI中获取 java.io.FileDescription  这里开始调用JNIEnv*中的 GetIntField函数获取对应的变量
        int fd = jniGetFDFromFileDescriptor(env, fileDescriptor);
        ALOGV("setDataSourceFD: fd %d", fd);
        //进行 setDataSource
        process_media_player_call( env, thiz, mp->setDataSource(fd, offset, length), "java/io/IOException", "setDataSourceFD failed." );
    }

 static void process_media_player_call(JNIEnv *env, jobject thiz, status_t opStatus, const char* exception, const char *message)
    {
        if (exception == NULL) {  
            //如果没有异常
            if (opStatus != (status_t) OK) {
                //如果在 setDataSource过程中opStatus不Ok
                sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
                //则通知MEDIA_ERROR
                if (mp != 0) mp->notify(MEDIA_ERROR, opStatus, 0);
            }
        } else {  // Throw exception!
           ...
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
    static void
    android_media_MediaPlayer_setDataSourceAndHeaders(
            JNIEnv *env, jobject thiz, jobject httpServiceBinderObj, jstring path,
            jobjectArray keys, jobjectArray values) {

        sp<MediaPlayer> mp = getMediaPlayer(env, thiz);
        
        ...//解析网络路径、判空、判内存溢出
        
        
        //下面是通过Binder机制，将httpServiceBinderObj传给IPC返回给binder，然后强制转换成IMediaHTTPService
        sp<IMediaHTTPService> httpService;
        if (httpServiceBinderObj != NULL) {
            sp<IBinder> binder = ibinderForJavaObject(env, httpServiceBinderObj);
            httpService = interface_cast<IMediaHTTPService>(binder);
        }

        //开始判断状态，和上面的文件操作是一样的
        status_t opStatus =
                mp->setDataSource(
                        httpService,
                        pathStr,
                        headersVector.size() > 0? &headersVector : NULL);
        process_media_player_call(
                env, thiz, opStatus, "java/io/IOException",
                "setDataSource failed." );
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public void setDisplay(SurfaceHolder sh) {
        //给Surface设置一个控制器
        mSurfaceHolder = sh;
        Surface surface;
        if (sh != null) {
            surface = sh.getSurface();
        } else {
            surface = null;
        }
        //到native层，给视频设置Surface
        _setVideoSurface(surface);
        //更新Surface到屏幕上
        updateSurfaceScreenOn();
 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
    static void
    setVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface, jboolean mediaPlayerMustBeAlive) {
        ...

        decVideoSurfaceRef(env, thiz);
        sp<IGraphicBufferProducer> new_st;
        if (jsurface) {
            //得到Java层的Surface
            sp<Surface> surface (android_view_Surface_getSurface(env, jsurface));
            if (surface != NULL) {
                //如果Surface不为空，则获取 IGraphicBufferProducer
                new_st = surface -> getIGraphicBufferProducer();
                ...
                //调用 incStrong
                new_st -> incStrong(( void*)decVideoSurfaceRef);
            } else {
                ...
            }
        }

        env -> SetLongField(thiz, fields.surface_texture, (jlong) new_st.get());

        //如果MediaPlayer还没有被初始化，setDataSource将会失败，但setDataSource之前就setDisplay了
        //在prepare/prepareAsync中调用setVideoSurfaceTexture 可以覆盖该cas
        mp -> setVideoSurfaceTexture(new_st);
    }

    static void
    decVideoSurfaceRef(JNIEnv *env, jobject thiz)
    {
        ...
        sp<IGraphicBufferProducer> old_st = getVideoSurfaceTexture(env, thiz);
        if (old_st != NULL) {
            old_st->decStrong((void*)decVideoSurfaceRef);
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
 public void prepare() throws IOException, IllegalStateException {
        _prepare();
        scanInternalSubtitleTracks();
}

//native的 prepare如下：
    static void
    android_media_MediaPlayer_prepare(JNIEnv *env, jobject thiz)
    {
        ...
        
        //1
        sp<IGraphicBufferProducer> st = getVideoSurfaceTexture(env, thiz);
        //2
        mp->setVideoSurfaceTexture(st);
        //3
        process_media_player_call( env, thiz, mp->prepare(), "java/io/IOException", "Prepare failed." );
    }
    
    static sp<IGraphicBufferProducer>
    getVideoSurfaceTexture(JNIEnv* env, jobject thiz) {
    IGraphicBufferProducer * const p = (IGraphicBufferProducer*)env->GetLongField(thiz, fields.surface_texture);
    return sp<IGraphicBufferProducer>(p);
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
  public void startPlayUrl(String url) {
        Uri uri = Uri.parse(url);
        MediaPlayer mp = new MediaPlayer();
        try {
            mp.setDataSource(this, uri);
        } catch (IOException e) {
            e.printStackTrace();
        }
        mp.setOnPreparedListener(prepareListener);
        mp.setOnVideoSizeChangedListener(videoSizeChangedListener);
        mp.setOnErrorListener(errorListener);
        mp.prepareAsync();
    }
    
 public native void prepareAsync() throws IllegalStateException;

 static void
    android_media_MediaPlayer_prepareAsync(JNIEnv *env, jobject thiz)
    {
        sp<MediaPlayer>..in to make it stick.
        sp<IGraphicBufferProducer> st = getVideoSurfaceTexture(env, thiz);
        mp->setVideoSurfaceTexture(st);

        process_media_player_call( env, thiz, mp->prepareAsync(), "java/io/IOException", "Prepare Async failed." );
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
status_t MediaPlayer::prepareAsync()
{
    ALOGV("prepareAsync");
    //互斥锁头
    Mutex::Autolock _l(mLock);
    return prepareAsync_l();
}

 status_t MediaPlayer::prepareAsync_l()
    {
        if ( (mPlayer != 0) && ( mCurrentState & (MEDIA_PLAYER_INITIALIZED | MEDIA_PLAYER_STOPPED) ) ) {
            //设置音频流类型，在IMediaPlayer.cpp中对应的transact操作是SET_AUDIO_STREAM_TYPE
            if (mAudioAttributesParcel != NULL) {
                mPlayer->setParameter(KEY_PARAMETER_AUDIO_ATTRIBUTES, *mAudioAttributesParcel);
            } else {
                mPlayer->setAudioStreamType(mStreamType);
            }
            //将当前状态置为 MEDIA_PLAYER_PREPARING
            mCurrentState = MEDIA_PLAYER_PREPARING;
            return mPlayer->prepareAsync();
        }
        ALOGE("prepareAsync called in state %d, mPlayer(%p)", mCurrentState, mPlayer.get());
        return INVALID_OPERATION;
    }

1
2
3
4
5
6
 PREPARE_ASYNC: {
        CHECK_INTERFACE(IMediaPlayer, data, reply);
        reply->writeInt32(prepareAsync());
        return NO_ERROR;
    } 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
status_t MediaPlayerService::Client::prepareAsync()
    {
        ...
        status_t ret = p->prepareAsync();
        ...
    }
//serivce中调用了 AwesomePlayer的prepareAsync()
//注意 AwesomePlayer在Andorid6.0之后已经弃用
 status_t AwesomePlayer::prepareAsync() {
        ATRACE_CALL();
        Mutex::Autolock autoLock(mLock);

        if (mFlags & PREPARING) {
            return UNKNOWN_ERROR;  // async prepare already pending
        }

        mIsAsyncPrepare = true;
        //调用了 prepareAsync_l()
        return prepareAsync_l();
    }
    
status_t AwesomePlayer::prepareAsync_l() {
         if (mFlags & PREPARING) {
            //如果是Preparing状态，就返回    
            return UNKNOWN_ERROR;  
        }
        if (!mQueueStarted) {
            //队列不是开始状态时，设置成开始状态
            mQueue.start();
            mQueueStarted = true;
        }

        //修改状态为Preparing
        modifyFlags(PREPARING, SET);
        //这里AwesomeEvent接收到时间，进行回调
        mAsyncPrepareEvent = new AwesomeEvent(
                this, &AwesomePlayer::onPrepareAsyncEvent);

        //将回调时间通过队列通知出去
        mQueue.postEvent(mAsyncPrepareEvent);
        return OK;
    }

1
2
3
4
5
6
7
8
9
10
11
12
private void scanInternalSubtitleTracks() {
        //设置一个字幕控制锚点
        setSubtitleAnchor();
        
        populateInbandTracks();

        if (mSubtitleController != null) {
            //如果字幕控制器不为null，则设置为默认的字幕控制器
            mSubtitleController.selectDefaultTrack();
        }
    }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public void start() throws IllegalStateException {
        final int delay = getStartDelayMs();
        if (delay == 0) {
            //如果没有延时播放，则直接调用startImpl()
            startImpl();
        } else {
            //否则Thread延时，然后再调用startImpl()
            ...
        }
    }
 private void startImpl() {
        //这个方法里判断视频是否为受限制的，如果是，则设置声音为0
        baseStart();
        //设置唤醒为true
        stayAwake(true);
        _start();
    }

private void stayAwake(boolean awake) {
        if (mWakeLock != null) {
            if (awake && !mWakeLock.isHeld()) {
                //获取锁
                mWakeLock.acquire();
            } else if (!awake && mWakeLock.isHeld()) {
                //释放锁
                mWakeLock.release();
            }
        }
        mStayAwake = awake;
        //更新Surface
        updateSurfaceScreenOn();
    }

1
2
3
4
5
6
//首先获取PM实例
PowerManager pm = (PowerManager)context.getSystemService(Context.POWER_SERVICE);
//通过newWakeLock来生成一个 mWakeLock实例。mode表示视频的几个模式，比如保持屏幕常亮、屏幕可以变暗、键盘灯关闭等等。
//获取WakeLock后通过acquire获取相应的锁，然后进行别的
mWakeLock = pm.newWakeLock(mode|PowerManager.ON_AFTER_RELEASE, MediaPlayer.class.getName())

1
2
3
4
5
...start(){
    ...
    process_media_player_call(...,mp->start(),...)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
class MediaPlayer : public BnMediaPlayerClient,
                    public virtual IMediaDeathNotifier
{
public:
    MediaPlayer();
    ~MediaPlayer();
            void            died();
            void            disconnect();

            status_t        setDataSource(
                    const sp<IMediaHTTPService> &httpService,
                    const char *url,
                    const KeyedVector<String8, String8> *headers);

            status_t        setDataSource(int fd, int64_t offset, int64_t length);
            status_t        setDataSource(const sp<IDataSource> &source);
            status_t        setVideoSurfaceTexture(
                                    const sp<IGraphicBufferProducer>& bufferProducer);
            status_t        setListener(const sp<MediaPlayerListener>& listener);
            status_t        getBufferingSettings(BufferingSettings* buffering /* nonnull */);
            status_t        setBufferingSettings(const BufferingSettings& buffering);
            status_t        prepare();
            status_t        prepareAsync();
            status_t        start();
            status_t        stop();
            status_t        pause();
            bool            isPlaying();
            status_t        setPlaybackSettings(const AudioPlaybackRate& rate);
            status_t        getPlaybackSettings(AudioPlaybackRate* rate /* nonnull */);
            status_t        setSyncSettings(const AVSyncSettings& sync, float videoFpsHint);
            status_t        getSyncSettings(
                                    AVSyncSettings* sync /* nonnull */,
                                    float* videoFps /* nonnull */);
            status_t        getVideoWidth(int *w);
            status_t        getVideoHeight(int *h);
            status_t        seekTo(
                    int msec,
                    MediaPlayerSeekMode mode = MediaPlayerSeekMode::SEEK_PREVIOUS_SYNC);
            status_t        notifyAt(int64_t mediaTimeUs);
            status_t        getCurrentPosition(int *msec);
            status_t        getDuration(int *msec);
            status_t        reset();
            status_t        setAudioStreamType(audio_stream_type_t type);
            status_t        getAudioStreamType(audio_stream_type_t *type);
            status_t        setLooping(int loop);
            bool            isLooping();
            status_t        setVolume(float leftVolume, float rightVolume);
            void            notify(int msg, int ext1, int ext2, const Parcel *obj = NULL);
            status_t        invoke(const Parcel& request, Parcel *reply);
            status_t        setMetadataFilter(const Parcel& filter);
            status_t        getMetadata(bool update_only, bool apply_filter, Parcel *metadata);
            status_t        setAudioSessionId(audio_session_t sessionId);
            audio_session_t getAudioSessionId();
            status_t        setAuxEffectSendLevel(float level);
            status_t        attachAuxEffect(int effectId);
            status_t        setParameter(int key, const Parcel& request);
            status_t        getParameter(int key, Parcel* reply);
            status_t        setRetransmitEndpoint(const char* addrString, uint16_t port);
            status_t        setNextMediaPlayer(const sp<MediaPlayer>& player);

            media::VolumeShaper::Status applyVolumeShaper(
                                    const sp<media::VolumeShaper::Configuration>& configuration,
                                    const sp<media::VolumeShaper::Operation>& operation);
            sp<media::VolumeShaper::State> getVolumeShaperState(int id);
            // Modular DRM
            status_t        prepareDrm(const uint8_t uuid[16], const Vector<uint8_t>& drmSessionId);
            status_t        releaseDrm();
            // AudioRouting
            status_t        setOutputDevice(audio_port_handle_t deviceId);
            audio_port_handle_t getRoutedDeviceId();
            status_t        enableAudioDeviceCallback(bool enabled);
            ...
};