1
2
3
4
5
6
7
8
9
1 MediaPlayer mediaPlayer = new MediaPlayer（）;

2 mediaPlayer.setDataSource（"/sdcard/test.mp3"）;

3 mediaPlayer.prepare（）;

4 mediaPlayer.start（）;

5 mediaPlayer.stop（）;

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
 1     public MediaPlayer（） {

 2 

 3         Looper looper;

 4         if （（looper = Looper.myLooper（）） != null） {

 5             mEventHandler = new EventHandler（this， looper）;

 6         } else if （（looper = Looper.getMainLooper（）） != null） {

 7             mEventHandler = new EventHandler（this， looper）;

 8         } else {

 9             mEventHandler = null;

10         }

11 

12         /* Native setup requires a weak reference to our object.

13          * It""s easier to create it here than in C++.

14          */

15         native_setup（new WeakReference<MediaPlayer>（this））;

16     }

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
75
76
77
78
79
80
81
82
83
84
85
 1 static JNINativeMethod gMethods[] = {

 2     {

 3         "_setDataSource"，

 4         "（Ljava/lang/String;[Ljava/lang/String;[Ljava/lang/String;）V"，

 5         （void *）android_media_MediaPlayer_setDataSourceAndHeaders

 6     }，

 7 

 8     {"setDataSource"，       "（Ljava/io/FileDescriptor;JJ）V"，    （void *）android_media_MediaPlayer_setDataSourceFD}，

 9     {"_setVideoSurface"，    "（Landroid/view/Surface;）V"，        （void *）android_media_MediaPlayer_setVideoSurface}，

10     {"prepare"，             "（）V"，                              （void *）android_media_MediaPlayer_prepare}，

11     {"prepareAsync"，        "（）V"，                              （void *）android_media_MediaPlayer_prepareAsync}，

12     {"_start"，              "（）V"，                              （void *）android_media_MediaPlayer_start}，

13     {"_stop"，               "（）V"，                              （void *）android_media_MediaPlayer_stop}，

14     {"getVideoWidth"，       "（）I"，                              （void *）android_media_MediaPlayer_getVideoWidth}，

15     {"getVideoHeight"，      "（）I"，                              （void *）android_media_MediaPlayer_getVideoHeight}，

16     {"seekTo"，              "（I）V"，                             （void *）android_media_MediaPlayer_seekTo}，

17     {"_pause"，              "（）V"，                              （void *）android_media_MediaPlayer_pause}，

18     {"isPlaying"，           "（）Z"，                              （void *）android_media_MediaPlayer_isPlaying}，

19     {"getCurrentPosition"，  "（）I"，                              （void *）android_media_MediaPlayer_getCurrentPosition}，

20     {"getDuration"，         "（）I"，                              （void *）android_media_MediaPlayer_getDuration}，

21     {"_release"，            "（）V"，                              （void *）android_media_MediaPlayer_release}，

22     {"_reset"，              "（）V"，                              （void *）android_media_MediaPlayer_reset}，

23     {"setAudioStreamType"，  "（I）V"，                             （void *）android_media_MediaPlayer_setAudioStreamType}，

24     {"setLooping"，          "（Z）V"，                             （void *）android_media_MediaPlayer_setLooping}，

25     {"isLooping"，           "（）Z"，                              （void *）android_media_MediaPlayer_isLooping}，

26     {"setVolume"，           "（FF）V"，                            （void *）android_media_MediaPlayer_setVolume}，

27     {"getFrameAt"，          "（I）Landroid/graphics/Bitmap;"，     （void *）android_media_MediaPlayer_getFrameAt}，

28     {"native_invoke"，       "（Landroid/os/Parcel;Landroid/os/Parcel;）I"，（void *）android_media_MediaPlayer_invoke}，

29     {"native_setMetadataFilter"， "（Landroid/os/Parcel;）I"，      （void *）android_media_MediaPlayer_setMetadataFilter}，

30     {"native_getMetadata"， "（ZZLandroid/os/Parcel;）Z"，          （void *）android_media_MediaPlayer_getMetadata}，

31     {"native_init"，         "（）V"，                              （void *）android_media_MediaPlayer_native_init}，

32     {"native_setup"，        "（Ljava/lang/Object;）V"，            （void *）android_media_MediaPlayer_native_setup}，

33     {"native_finalize"，     "（）V"，                              （void *）android_media_MediaPlayer_native_finalize}，

34     {"getAudioSessionId"，   "（）I"，                              （void *）android_media_MediaPlayer_get_audio_session_id}，

35     {"setAudioSessionId"，   "（I）V"，                             （void *）android_media_MediaPlayer_set_audio_session_id}，

36     {"setAuxEffectSendLevel"， "（F）V"，                           （void *）android_media_MediaPlayer_setAuxEffectSendLevel}，

37     {"attachAuxEffect"，     "（I）V"，                             （void *）android_media_MediaPlayer_attachAuxEffect}，

38     {"native_pullBatteryData"， "（Landroid/os/Parcel;）I"，        （void *）android_media_MediaPlayer_pullBatteryData}，

39     {"setParameter"，        "（ILandroid/os/Parcel;）Z"，          （void *）android_media_MediaPlayer_setParameter}，

40     {"getParameter"，        "（ILandroid/os/Parcel;）V"，          （void *）android_media_MediaPlayer_getParameter}，

41     {"native_setRetransmitEndpoint"， "（Ljava/lang/String;I）I"，  （void *）android_media_MediaPlayer_setRetransmitEndpoint}，

42     {"setNextMediaPlayer"，  "（Landroid/media/MediaPlayer;）V"，   （void *）android_media_MediaPlayer_setNextMediaPlayer}，

43 };

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
 1 static void

 2 android_media_MediaPlayer_native_setup（JNIEnv *env， jobject thiz， jobject weak_this）

 3 {

 4     ALOGV（"native_setup"）;

 5     sp<MediaPlayer> mp = new MediaPlayer（）;

 6     if （mp == NULL） {

 7         jniThrowException（env， "java/lang/RuntimeException"， "Out of memory"）;

 8         return;

 9     }

10 

11     // create new listener and give it to MediaPlayer

12     sp<JNIMediaPlayerListener> listener = new JNIMediaPlayerListener（env， thiz， weak_this）;

13     mp->setListener（listener）;

14 

15     // Stow our new C++ MediaPlayer in an opaque field in the Java object.

16     setMediaPlayer（env， thiz， mp）;

17 }

1
sp<MediaPlayer> mp = new MediaPlayer（）;

1
16     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
 1 MediaPlayer::MediaPlayer（）

 2 {

 3     ALOGV（"constructor"）;

 4     mListener = NULL;

 5     mCookie = NULL;

 6     mStreamType = AUDIO_STREAM_MUSIC;

 7     mCurrentPosition = -1;

 8     mSeekPosition = -1;

 9     mCurrentState = MEDIA_PLAYER_IDLE;

10     mPrepareSync = false;

11     mPrepareStatus = NO_ERROR;

12     mLoop = false;

13     mLeftVolume = mRightVolume = 1.0;

14     mVideoWidth = mVideoHeight = 0;

15     mLockThreadId = 0;

16     mAudioSessionId = AudioSystem::newAudioSessionId（）;

17     AudioSystem::acquireAudioSessionId（mAudioSessionId）;

18     mSendLevel = 0;

19     mRetransmitEndpointValid = false;

20 }

1
mediaPlayer.setDataSource（"/sdcard/test.mp3"）;

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 1     public void setDataSource（String path）

 2             throws IOException， IllegalArgumentException， SecurityException， IllegalStateException {

 3         setDataSource（path， null， null）;

 4     }

 5 调用setDataSource（）的重载办法，之后的重载调用过程我们就略过，终极会调用到如下办法：

 6     public void setDataSource（FileDescriptor fd）

 7             throws IOException， IllegalArgumentException， IllegalStateException {

 8         // intentionally less than LONG_MAX

 9         setDataSource（fd， 0， 0 x7ffffffffffffffL）;

10     }

11     public native void setDataSource（FileDescriptor fd， long offset， long length）

12             throws IOException， IllegalArgumentException， IllegalStateException;

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
 1 status_t MediaPlayer::setDataSource（int fd， int64_t offset， int64_t length）

 2 {

 3     ALOGV（"setDataSource（％d， ％lld， ％lld）"， fd， offset， length）;

 4     status_t err = UNKNOWN_ERROR;

 5     const sp<IMediaPlayerService>& service（getMediaPlayerService（））;

 6     if （service != 0） {

 7         sp<IMediaPlayer> player（service->create（getpid（）， this， mAudioSessionId））;

 8         if （（NO_ERROR != doSetRetransmitEndpoint（player）） ||

 9             （NO_ERROR != player->setDataSource（fd， offset， length））） {

10             player.clear（）;

11         }

12         err = attachNewPlayer（player）;

13     }

14     return err;

15 }

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
 1 // establish binder interface to MediaPlayerService

 2 /*static*/const sp<IMediaPlayerService>&

 3 IMediaDeathNotifier::getMediaPlayerService（）

 4 {

 5     ALOGV（"getMediaPlayerService"）;

 6     Mutex::Autolock _l（sServiceLock）;

 7     if （sMediaPlayerService == 0） {

 8         sp<IServiceManager> sm = defaultServiceManager（）;

 9         sp<IBinder> binder;

10         do {

11             binder = sm->getService（String16（"media.player"））;

12             if （binder != 0） {

13                 break;

14             }

15             ALOGW（"Media player service not published， waiting..."）;

16             usleep（500000）; // 0.5 s

17         } while （true）;

18 

19         if （sDeathNotifier == NULL） {

20         sDeathNotifier = new DeathNotifier（）;

21     }

22     binder->linkToDeath（sDeathNotifier）;

23     sMediaPlayerService = interface_cast<IMediaPlayerService>（binder）;

24     }

25     ALOGE_IF（sMediaPlayerService == 0， "no media player service!？"）;

26     return sMediaPlayerService;

27 }

1
7         sp<IMediaPlayer> player（service->create（getpid（）， this， mAudioSessionId））;

1
player->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
30
31
32
33
34
35
36
37
 1 sp<IMediaPlayer> MediaPlayerService::create（pid_t pid， const sp<IMediaPlayerClient>& client，

 2         int audioSessionId）

 3 {

 4     int32_t connId = android_atomic_inc（&mNextConnId）;

 5 

 6     sp<Client> c = new Client（

 7             this， pid， connId， client， audioSessionId，

 8             IPCThreadState::self（）->getCallingUid（））;

 9 

10     ALOGV（"Create new client（％d）  pid ％d， uid ％d， "， connId， pid，

11          IPCThreadState::self（）->getCallingUid（））;

12 

13     wp<Client> w = c;

14     {

15         Mutex::Autolock lock（mLock）;

16         mClients.add（w）;

17     }

18     return c;

19 }

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
75
76
77
 1 status_t MediaPlayerService::Client::setDataSource（int fd， int64_t offset， int64_t length）

 2 {

 3     ALOGV（"setDataSource fd=％d， offset=％lld， length=％lld"， fd， offset， length）;

 4     struct stat sb;

 5     int ret = fstat（fd， &sb）;

 6     if （ret != 0） {

 7         ALOGE（"fstat（％d） failed: ％d， ％s"， fd， ret， strerror（errno））;

 8         return UNKNOWN_ERROR;

 9     }

10 

11     ALOGV（"st_dev  = ％llu"， sb.st_dev）;

12     ALOGV（"st_mode = ％u"， sb.st_mode）;

13     ALOGV（"st_uid  = ％lu"， sb.st_uid）;

14     ALOGV（"st_gid  = ％lu"， sb.st_gid）;

15     ALOGV（"st_size = ％llu"， sb.st_size）;

16 

17     if （offset >= sb.st_size） {

18         ALOGE（"offset error"）;

19         ::close（fd）;

20         return UNKNOWN_ERROR;

21     }

22     if （offset + length > sb.st_size） {

23         length = sb.st_size - offset;

24         ALOGV（"calculated length = ％lld"， length）;

25     }

26 

27     player_type playerType = MediaPlayerFactory::getPlayerType（this，

28                                                                fd，

29                                                                offset，

30                                                                length）;

31     sp<MediaPlayerBase> p = setDataSource_pre（playerType）;

32     if （p == NULL） {

33         return NO_INIT;

34     }

35 

36     // now set data source

37     setDataSource_post（p， p->setDataSource（fd， offset， length））;

38     return mStatus;

39 }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 1 enum player_type {

 2     PV_PLAYER = 1，

 3     SONIVOX_PLAYER = 2，

 4     STAGEFRIGHT_PLAYER = 3，

 5     NU_PLAYER = 4，

 6     // Test players are available only in the ""test"" and ""eng"" builds.

 7     // The shared library with the test player is passed passed as an

 8     // argument to the ""test:"" url in the setDataSource call.

 9     TEST_PLAYER = 5，

10 };

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
 1 void MediaPlayerFactory::registerBuiltinFactories（） {

 2     Mutex::Autolock lock_（&sLock）;

 3 

 4     if （sInitComplete）

 5         return;

 6 

 7     registerFactory_l（new StagefrightPlayerFactory（）， STAGEFRIGHT_PLAYER）;

 8     registerFactory_l（new NuPlayerFactory（）， NU_PLAYER）;

 9     registerFactory_l（new SonivoxPlayerFactory（）， SONIVOX_PLAYER）;

10     registerFactory_l（new TestPlayerFactory（）， TEST_PLAYER）;

11 

12     sInitComplete = true;

13 }

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
 1 sp<MediaPlayerBase> MediaPlayerService::Client::setDataSource_pre（

 2         player_type playerType）

 3 {

 4     ALOGV（"player type = ％d"， playerType）;

 5 

 6     // create the right type of player

 7     sp<MediaPlayerBase> p = createPlayer（playerType）;

 8     if （p == NULL） {

 9         return p;

10     }

11 

12     if （!p->hardwareOutput（）） {

13         mAudioOutput = new AudioOutput（mAudioSessionId）;

14         static_cast<MediaPlayerInterface*>（p.get（））->setAudioSink（mAudioOutput）;

15     }

16 

17     return p;

18 }

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
 1 sp<MediaPlayerBase> MediaPlayerService::Client::createPlayer（player_type playerType）

 2 {

 3     // determine if we have the right player type

 4     sp<MediaPlayerBase> p = mPlayer;

 5     if （（p != NULL） && （p->playerType（） != playerType）） {

 6         ALOGV（" player"）;

 7         p.clear（）;

 8     }

 9     if （p == NULL） {

10         p = MediaPlayerFactory::createPlayer（playerType， this， notify）;

11     }

12 

13     if （p != NULL） {

14         p->setUID（mUID）;

15     }

16 

17     return p;

18 }

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
 1 sp<MediaPlayerBase> MediaPlayerFactory::createPlayer（

 2         player_type playerType，

 3         void* cookie，

 4         notify_callback_f notifyFunc） {

 5     sp<MediaPlayerBase> p;

 6     IFactory* factory;

 7     status_t init_result;

 8     Mutex::Autolock lock_（&sLock）;

 9 

10     if （sFactoryMap.indexOfKey（playerType） < 0） {

11         ALOGE（"Failed to create player object of type ％d， no registered"

12               " factory"， playerType）;

13         return p;

14     }

15 

16     factory = sFactoryMap.valueFor（playerType）;

17     CHECK（NULL != factory）;

18     p = factory->createPlayer（）;

19 

20     if （p == NULL） {

21         ALOGE（"Failed to create player object of type ％d， create failed"，

22                playerType）;

23         return p;

24     }

25 

26     init_result = p->initCheck（）;

27     if （init_result == NO_ERROR） {

28         p->setNotifyCallback（cookie， notifyFunc）;

29     } else {

30         ALOGE（"Failed to create player object of type ％d， initCheck failed"

31               " （res = ％d）"， playerType， init_result）;

32         p.clear（）;

33     }

34 

35     return p;

36 }

1
2
3
4
5
6
7
1     virtual sp<MediaPlayerBase> createPlayer（） {

2         ALOGV（" create StagefrightPlayer"）;

3         return new StagefrightPlayer（）;

4     }

1
2
3
4
5
6
7
8
9
10
11
1 StagefrightPlayer::StagefrightPlayer（）

2     : mPlayer（new AwesomePlayer） {

3     ALOGV（"StagefrightPlayer"）;

4 

5     mPlayer->setListener（this）;

6 }

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
 1 status_t MediaPlayerService::Client::setDataSource（int fd， int64_t offset， int64_t length）

 2 {

 3 ...

 4     player_type playerType = MediaPlayerFactory::getPlayerType（this，

 5                                                                fd，

 6                                                                offset，

 7                                                                length）;

 8     sp<MediaPlayerBase> p = setDataSource_pre（playerType）;

 9 ...

10     // now set data source

11     setDataSource_post（p， p->setDataSource（fd， offset， length））;

12     return mStatus;

13 }

1
2
3
4
5
6
7
1 status_t StagefrightPlayer::setDataSource（int fd， int64_t offset， int64_t length） {

2     ALOGV（"setDataSource（％d， ％lld， ％lld）"， fd， offset， length）;

3     return mPlayer->setDataSource（dup（fd）， offset， length）;

4 }