Android4.0中MediaPlayer 和 MediaPlayerService

　　前段时间接到任务，探究一下MediaPlayer在Android系统中是如何实现的。到现在为止终于有些眉目了，在调查代码时候虽然有些吃力，但是还算是有所得的。今天把自己对MediaPlayer的粗浅理解拿出来，一来作为笔记备份；一来和大家分享。以下代码都是以Android4.2代码为基础的，欢迎大家指正，共同学习。

　　为了有一个完整的阅读代码的脉络和思路，我是以一个非常简单的Java应用程序开始。程序非常简单，代码如下：

1 MediaPlayer mediaPlayer = new MediaPlayer();
2 mediaPlayer.setDataSource("/sdcard/test.mp3");
3 mediaPlayer.prepare();
4 mediaPlayer.start();
5 mediaPlayer.stop();

创建MediaPlayer对象

从第一行代码开始看：

MediaPlayer mediaPlayer = new MediaPlayer();
这行代码是在Java应用程序中，功能是新建一个对象。既然如此，我们就看看MediaPlayer这个类在Java层的构造函数，如下：

[/frameworks/base/media/java/android/media/MediaPlayer.java]

 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     }

在这个构造函数中，较为重要的就是native_setup(). 这个函数在之前的声明中包含native，说明这是一个native函数。也就是说native_setup()函数实在native层实现的。接下来我们要做的就是根据JNI找到这个函数是如何实现的。native函数实现所在的文件的文件名都是如下命名的，把包名中的"."替换为"_"+类名。所以我们要找文件就是android_media_MediaPlayer.cpp.在这个文件中我们有个重要的数组，如下：

【/frameworks/base/media/jni/android_media_MediaPlayer.cpp】

 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 };

在这个数组中，第一列表示的是Java层中函数名，第二列是Java层函数对应的参数以及返回值类型，第三列就是对应在Native层的函数名。从这个数组中，我们可以找到native_setup()，对应的函数名是android_media_MediaPlayer_native_setup，接下来我们就看看这个函数的实现：

【/frameworks/base/media/jni/android_media_MediaPlayer.cpp】

 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 }

在本文中，对于分析MediaPlayer流程较为重要的函数，我都会用红色字体标识出来。这不是说没有标红的就不重要，在程序里没有无用的代码，只是对于我们这次的流程分析不太重要而已。先看第5行

sp<MediaPlayer> mp = new MediaPlayer();

这行代码的功能就是创建一个MediaPlayer类的对象，不过这个对象是Native层的对象，也就是说这个Native层的MediaPlayer类是使用C++代码实现的。我们先往下看下面一句较为重要的代码，然后在后头分析Native层MediaPlayer对象的构造函数。

16     setMediaPlayer(env, thiz, mp);

这行代码的功能就是把我们新创建的Native层的MediaPlayer对象保存到Java层。也就是说将来我们通过getMediaplayer()的时候获取到的就是这个对象。接下来，我就开始分析Native层的MediaPlayer的构造函数，代码如下：

 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 }

在构造Native层的MediaPlayer对象的时候，也会构造父类的对象。只不过在这些对象构造过程中，对于我们分析MediaPlayer流程并没有特别重要的东西。但是我们要了解的一点就是在MediaPlayer的父类IMediaDeathNotifier中有个很重要的方法getMediaPlayerService(),对于这个方法我们在之后的分析过程中还会用到，到时候在详细介绍。

到这里为止，这一小节基本结束。总结一下，在MediaPlayer的初始化过程中，就是创建了MediaPlayer的对象。

重要的函数setDataSource()

在写这篇blog之前，已经对MediaPlayer的流程有了大概的了解。现在回头再看，发现这个函数真的非常重要。在这个函数中，MediaPlayer和MediaPlayerService建立了联系，MediaPlayerService和Stagefright或者OpenCore也建立了联系。我们继续RFCD，在Java层，我们使用的方法如下：

mediaPlayer.setDataSource("/sdcard/test.mp3");

在Java层这个函数代码如下：

【/frameworks/base/media/java/android/media/MediaPlayer.java】

 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, 0x7ffffffffffffffL);
10     }
11     public native void setDataSource(FileDescriptor fd, long offset, long length)
12             throws IOException, IllegalArgumentException, IllegalStateException;

所以这个函数最终还是调用到类Native层。在之后的过程中，我们都会跳过对于JNI层的寻找过程，直接进入Native层的MediaPlayer对象寻找相应的方法。在Native层中setDataSource()对应的代码如下：

【/frameworks/av/media/libmedia/mediaplayer.cpp】

 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 }

上面这段代码重点地方有三个，都已经标示出来。先看第一个，getMediaPlayerService()，这个函数从其名字上看是获取MediaPlayerService。因此

 5     const sp<IMediaPlayerService>& service(getMediaPlayerService());

的功能就是获取MediaPlayerService并且把返回值赋值给service。关于getMediaPlayerService函数，我们在前面说过一次，这个方法是MediaPlayer的父类IMediaDeathNotifier的一个方法，关系到MediaPlayer和MediaPlayerService之间的通信。下面我们就看看这个方法的代码：
[/frameworks/av/media/libmedia/IMediaDeathNotifier.cpp]

 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 }

在getMediaPlayerService()函数中，重点内容有三处，不过都是为了最后获取MediaPlayerService服务的。第8行是获取ServiceManager；第11行是从ServiceManager中获取到我们所需要的一个对象，这个对象是BpBinder类型，为我们最后取得MediaPlayerService作准备。第23行是获取MediaPlayerService，不过最终获得这个对象是BpMediaPlayerService类型。我们获取到得这个BpMediaPlayerService，这个对象的所有操作最终都会由真正的MediaPlayerService对象来完成，因此完全可以看做是MediaPlayerService。这个过程和Binder通信相关，不是我们这次探讨的重点，这里不再赘述。

　　到这里，我们分析完成了getMediaPlayerService方法，获得了返回值，并把它赋值给了service。接下来我们就要看看MediaPlayer使用这个service都做了些什么事情。从代码中看，总共有两件事情，分别是：

　　　　1)根据进程ID,对象本身，AudioSessionId这三个参数，在server端创建了一个Player对象并返回给MediaPlayer端的player。这个Player也是具有进程间通信能力的。

 7         sp<IMediaPlayer> player(service->create(getpid(), this, mAudioSessionId));

　　　　2)为server端的Player设置播放资源

player->setDataSource(fd, offset, length)

我们开始看看第一件事情时如何完成的，以及在Server段创建player的时候都做了那些工作。这个Create操作最终会在Server端执行，所以我们就去MediaPlayerService段在这个过程中都做了些什么，代码如下：

[/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp]

 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) from 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 }

从代码中，我们可以看出，在Server端，我们新建的对象是Client，是MediaPlayerService的内部类。但是这个Client执行了MediaPlayerService的绝大部分操作。同样我们将来传输过来的数据也都是会交给内部类Client进行处理的。到这里，在Server端的对象就创建完成了。

接下来就是要做第二件事情了，就是在MediaPlayer中调用player->setDataSource();，这件事还是要在Server完成的，代码如下：

[/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp]

 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 }

上面这段代码作用就是获取一个PlayerType,然后一这个PlayerType作为参数传递到setDataSource _pre(),在这个方法中根据playerType做一些事情。关于PlayerType是如何获取的，以及我们传入的文件test.mp3,对应什么类型的playerType，我就不再介绍了。之所以不介绍是因为牵涉到资源的一些特有的参数和属性判断的，我不太了解。不过我们可以从代码中找到在Android中一共又几种这样的Type，如下：

/frameworks/av/include/media/MediaPlayerInterface.h

 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 };

一种有五种type，但是PV_PLAYER好像是从Android2.3之后就取消了，因为PVPlayer是和Opencore相关的，自从OpenCore从Android2.3中移出之后，这个type对应的Player就没有了。所以在Android4.2中只剩下

四种type了。这些type和他们对应的player都会以键值对的形式放入一个数据结构中，以备后用。在后面我们在使用这些type的时候，就会发现这些键值对是存放在sFactoryMap中的，而sFactoryMap 是tFactoryMap型的，

也就是就是KeyVector。貌似KeyVector是android定义的数据结构吧，类似Hashmap。而把这些type和player键值对添加入sFactorymap中过程如下：

[/frameworks/av/media/libmediaplayerservice/MediaPlayerFactory.cpp]

 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 }

看看上面这两段代码还是有好处的，最起码让我们明白事情的来龙去脉。如果我们想要在Android中扩展，使用新的解码工具，可以直接继承MediaPlayerFactory类，然后在这里注册所需要的type就行了。

接着上面的说，假设我们mp3对应的时defaultType，也就是STAGEFRIGHT_PLAYER，那么这个数据就会作为setDataSource_pre()的参数使用。我们就看看这个函数是如何利用Type参数创建新的对象的，代码如下：

【/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp】

 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 }

先说明一下，上面的红色代码都是很重要的，不过13和14行代码在setDataSource()暂时还是用不上，要等到start()的时候，和AudioFlinger建立联系的时候才能用到。现在先标记下，有个印象。我们继续我们的工作，分析createPlayer()方法，代码如下：

/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp

 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("delete 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 }

看红色代码标识的第10行代码，这里使用的设计模式中的--Factory模式，大家可以参考学习下。Android系统时一个如此庞大复杂的系统，为了良好的扩展性使用了很多设计模式。无论是学习计算机哪方面内容，Android源码都是一份不错的教材。还是继续看我们的任务，接着看代码，在MediaPlayerFactory::createPlayer()的代码如下：

[/frameworks/av/media/libmediaplayerservice/MediaPlayerFactory.cpp]

 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 }

 
我们通过playerType获取到得是IFactory对象，然后使用这个对象进行createPlayer。对于这一点的理解和Factory模式有关，如果不明白的话，抽出一点点时间看看Factory模式肯定是会有好处的。根据

playerType，我们这里的factory应该是StageFrightPlayerFactory的对象，然后调用它的的createPlayer函数。createPlayer()的实现如下：
[/frameworks/av/media/libmediaplayerservice/MediaPlayerFactory.cpp]

1     virtual sp<MediaPlayerBase> createPlayer() {
2         ALOGV(" create StagefrightPlayer");
3         return new StagefrightPlayer();
4     }

从这里StageFrightPlayerFactory的createPlayer中我们获得的返回值是一个新的对象--StagefrightPlayer的实例。到这里，我们就算是进入stagefright了，我们代码调查到这儿也基本快要结束了。
我们还是接着看看这个新的对象的构造方法，代码如下：
[/frameworks/av/media/libmediaplayerservice/StagefrightPlayer.cpp]

1 StagefrightPlayer::StagefrightPlayer()
2     : mPlayer(new AwesomePlayer) {
3     ALOGV("StagefrightPlayer");
4 
5     mPlayer->setListener(this);
6 }

在这个构造函数中，有个很容易忽视的地方，就是构造函数的属性赋值的方式，在C++中经常使用，叫做构造函数的初始化列表。乍一看，这个构造函数什么也没有，其实重点内容就在构造函数的初始化列表中，在这里我们又
创建了一个对象AwesomPlayer. 我觉得我们进行到这儿，也可以告一段落了，因为我们已经接触到了Stagefright，再向下调查代码的话就应该是单独研究stagefright的工作了。以后，在调查过stagefrigh后，我会
再补上一篇博客说说stagefright的。
　　好了，骚年们，让我们像函数调用结束时一样，一步一步return吧，直到能够继续向下执行的地方。我们一直调查到这儿，是在分析MediaPlayerService中要做的两件事中的第二件事情：setDataSource()。我们刚刚结束
分析的地方是：sp<MediaPlayerBase> p = setDataSource_pre(playerType);让我们先总结一下我们刚刚都做了哪些事情，其实挺简单的就是创建了一个对象StagefrightPlayer，并把这个对象保存到p中。StagefrightPlayer
对象在创建的过程中，我们也设置了一些参数，比如p->setAudioSink()，还创建了AwesomePlayer对象，保存在StagefrightPlayer对象中的mPlayer属性中。既然setDataSource_pre()已经调查结束，那么我们就要开始下一步
操作了，就是下面已经用红色代码标示出来的部分：
[/frameworks/av/media/libmediaplayerservice/MediaPlayerService.cpp]

 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 }

 其实函数setDataSource_post()对于我们分析MediaPlayer流程的作用不太大，可能是要设置MediaPlayer的一些功能的属性吧，我们这次重点关注的是这个方法中的第二个参数。由上面的分析，我们知道p指向的对象是一个StagefrightPlayer
对象，所以p->setDataSource()的实现，我们就应该去StagefrightPlayer类中寻找。找到相应的代码如下：
[/frameworks/av/media/libmediaplayerservice/StagefrightPlayer.cpp]

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 }

原来是使用StagefrightPlayer的属性mPlayer去实现的，前面我们也说到了stagefrightPlayer.mPlayer指向的是AwesomePlayer.到这儿我们到此为止吧。
　　到这里，在MediaPlayerService端的的setDataSource()的工作也结束了，总结一下就是：从Java应用程序中的MediaPlayer的setDataSource()会传递到Native层中的MediaPlayer的setDataSource()去执行，而MediaPlayer会把这个方法交给MediaPlayerservice去执行。MediaPlayerService的是使用stagefrightPlayer实现的，最后，最后，我们的setdataSource还是交给了AwesomePlayer去执行了。这个流程把MediaPlayer和MediaPlayerService之间的联系建立起来，同时又把MediaPlayerService是如何使用stagefright实现的关系建立了起来。到这里，我们的分析MediaPlayer的流程的目的也算是基本达到了。如果再继续分析MediaPlayer的话，我们可以分为两个方向了，一个是分析stagefright是如何解码的；一个是分析MediaPlayer与AudioTrack,AudioFlinger之间的关系了。由此看来，将来的任务和道路还是任重道远的。