MediaScanner分析

1 MediaScannerService
　　多媒体扫描是从MediaScannerService开始的。这是一个单独的package。位于packages/providers/MediaProvider：含以下java文件
java代码：

1. MediaProvider.java
2. MediaScannerReceiver.java
3. MediaScannerService.java
4. MediaThumbRequest.java
   分析这个目录的Android.mk文件，发现它运行的进程名字就是android.process.media。
   application android:process=android.process.media
   1.1 MediaScannerReceiver
   这个类从BroadcastReceiver中派生，用来接收任务的。
   MediaScannerReceiver extends BroadcastReceiver
   在它重载的onRecieve函数内有以下几种走向：
   java代码：
5. if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {

6.          // Scan both internal storage
   

7.         收到”启动完毕“广播后，扫描内部存储
   

8.          scan(context, MediaProvider.INTERNAL_VOLUME);
   

9.      } 
   

10. } else {
11. …
12. if (Intent.ACTION_MEDIA_MOUNTED.equals(action))
13. {
14. …
15. /收到MOUNT信息后，扫描外部存储
16. scan(context, MediaProvider.EXTERNAL_VOLUME);
17. }
18. else if (Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) )
19. {
20. //收到请求要求扫描某个文件，注意不会扫描内部存储上的文件
21. scanFile(context, path);
22. …
23. }
    下面是它调用的scan函数：
    java代码：
24. scan(Context context, String volume)
26. Bundle args = new Bundle();
27. args.putString(“volume”, volume);
28. //直接启动MediaScannerService了，
29. context.startService(new Intent(context, MediaScannerService.class).putExtras(args));
    总结：
    　　MediaScannerReceiver是用来接收任务的，它收到广播后，会启动MediaService进行扫描工作。插拔SD卡的时候会启动媒体扫描。
    　　下面看看MediaScannerService.
    1.2 MediaScannerService
    MSS标准的从Service中派生下来，
    　　MediaScannerService extends Service implements Runnable
    　　//注意：是一个Runnable…，可能有线程之类的东西存在
    　　下面从Service的生命周期的角度来看看它的工作。
    1.2.1 onCreate
    java代码：
30. public void onCreate()
32. PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);
33. mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
34. //获得电源锁，防止在扫描过程中休眠
35. //单独搞一个线程去跑扫描工作，防止ANR
36. Thread thr = new Thread(null, this, “MediaScannerService”);
37. thr.start();
    1.2.2 onStartCommand
    java代码：
38. @Override
39. public int onStartCommand(Intent intent, int flags, int startId){
41. //注意这个handler，是在另外一个线程中创建的，往这个handler里sendMessage都会在那个线程里边处理
42. //不明白的可以去查看handler和Looper机制
43. //这里就是同步机制，等待mServiceHandler在另外那个线程创建完毕
45. while (mServiceHandler == null) {
46. synchronized (this) {
47. try {
48. wait(100);
49. } catch (InterruptedException e) {
50. }
51. }
52. }
54. if (intent == null) {
55. Log.e(TAG, "Intent is null in onStartCommand: ",new NullPointerException());
56. return Service.START_NOT_STICKY;
57. }
58. Message msg = mServiceHandler.obtainMessage();
59. msg.arg1 = startId;
60. msg.obj = intent.getExtras();
61. //把MediaScannerReceiver发出的消息传递到另外那个线程去处理。
63. mServiceHandler.sendMessage(msg);
    1.3 run
    java代码：
64. public void run(){
66. // reduce priority below other background threads to avoid interfering
67. // with other services at boot time.
69. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +Process.THREAD_PRIORITY_LESS_FAVORABLE);
71. //不明白的去看看Looper和handler的实现
72. Looper.prepare();
73. //把这个looper对象设置到线程本地存储
74. mServiceLooper = Looper.myLooper();
75. mServiceHandler = new ServiceHandler();
76. //创建handler，默认会把这个looper
77. //的消息队列赋值给handler的消息队列，这样往handler中发送消息就是往这个线程的looper发
78. Looper.loop();
79. //消息循环，内部会处理消息队列中的消息
80. //也就是handleMessage函数
81. }
    上面handler中加入了一个扫描请求(假设是外部存储的)，所以要分析handleMessage函数。
    1.4 handleMessage
    java代码：
82. private final class ServiceHandler extends Handler{
84. @Override
85. public void handleMessage(Message msg){
87. Bundle arguments = (Bundle) msg.obj;
88. String filePath = arguments.getString(“filepath”);
89. try {
91. 这里不讲了
92. } else {
93. String volume = arguments.getString(“volume”);
94. String[] directories = null;
95. if (MediaProvider.INTERNAL_VOLUME.equals(volume)) {
96. //是扫描内部存储的请求?
97. // scan internal media storage
98. directories = new String[] {
100. Environment.getRootDirectory() + “/media”,
101. };
102. }
104. else if (MediaProvider.EXTERNAL_VOLUME.equals(volume)) {
105. //是扫描外部存储的请求?获取外部存储的路径
106. directories = new String[] {
107. Environment.getExternalStorageDirectory().getPath(),
108. };
109. }
110. if (directories != null) {
111. //真正的扫描开始了，上面只不过是把存储路径取出来罢了.
112. scan(directories, volume);
113. //扫描完了，就把service停止了
114. stopSelf(msg.arg1);
115. }
117. };
     1.5 scan函数
     java代码：
118. private void scan(String[] directories, String volumeName) {
119. mWakeLock.acquire();
120. //下面这三句话很深奥…
121. //从 getContentResolver获得一个ContentResover，然后直接插入
122. //根据AIDL，这个ContentResover的另一端是MediaProvider。只要去看看它的insert函数就可以了
123. //反正这里知道获得了一个扫描URI即可。
124. ContentValues values = new ContentValues();
125. values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);
126. Uri scanUri = getContentResolver().insert(MediaStore.getMediaScannerUri(), values);
127. Uri uri = Uri.parse(“file://” + directories[0]);
128. //发送广播，通知扫描开始了
129. sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_STARTED, uri));
131. try {
132. if (volumeName.equals(MediaProvider.EXTERNAL_VOLUME)) {
133. openDatabase(volumeName);
134. }
135. //创建真正的扫描器
136. MediaScanner scanner = createMediaScanner();
137. //交给扫描器去扫描文件夹 scanDirectories
138. scanner.scanDirectories(directories, volumeName);
139. } catch (Exception e) {
140. Log.e(TAG, “exception in MediaScanner.scan()”, e);
141. }
142. //删除扫描路径
143. getContentResolver().delete(scanUri, null, null);
144. //通知扫描完毕
145. sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_FINISHED, uri));
146. mWakeLock.release();
147. }
     说说上面那个深奥的地方，在MediaProvider中重载了insert函数，insert函数会调用insertInternal函数。
     　　如下：
     java代码：
148. private Uri insertInternal(Uri uri, ContentValues initialValues) {
149. long rowId;
151. int match = URI_MATCHER.match(uri);
152. // handle MEDIA_SCANNER before calling getDatabaseForUri()
153. //刚才那个insert只会走下面这个分支，其实就是获得一个地址….
154. //太绕了
156. if (match == MEDIA_SCANNER) {
157. mMediaScannerVolume = initialValues.getAsString(MediaStore.MEDIA_SCANNER_VOLUME);
158. return MediaStore.getMediaScannerUri();
159. }
     再看看它创建了什么样的Scanner，这就是MSS中的createMediaScanner

java代码：

1. private MediaScanner createMediaScanner() {
3. //下面这个MediaScanner在framework/base/中，待会再分析
4. MediaScanner scanner = new MediaScanner(this);
5. //设置当前的区域，这个和字符编码有重大关系。
6. Locale locale = getResources().getConfiguration().locale;
8. if (locale != null) {
9. String language = locale.getLanguage();
10. String country = locale.getCountry();
11. String localeString = null;
12. if (language != null) {
13. if (country != null) {
14. //给扫描器设置当前国家和语言。
15. scanner.setLocale(language + “_” + country);
16. } else {
17. scanner.setLocale(language);
18. }
19. }
20. }
21. return scanner;
23. }
    至此，MSS的任务完成了。接下来是MediaScanner的工作了。
    1.6 总结
    MSS的工作流程如下：
    　　1 单独启动一个带消息循环的工作线程。
    　　2 主线程接收系统发来的任务，然后发送给工作线程去处理。
    　　3 工作线程接收任务，创建一个MediaScanner去扫描。
    　　4 MSS顺带广播一下扫描工作启动了，扫描工作完毕了。
    2 MediaScanner
    　　MediaScanner位置在Framework/base/media下，包括jni和java文件。
    　　先看看java实现。
    　　这个类巨复杂，而且和MediaProvider交互频繁。在分析的时候要时刻回到MediaProvider去看看。
    2.1 初始化
    java代码：
24. public class MediaScanner{
26. static {
27. //libmedia_jni.so的加载是在MediaScanner类中完成的
28. System.loadLibrary(“media_jni”);
29. native_init();
30. }
32. public MediaScanner(Context c) {
33. native_setup();//调用jni层的初始化，暂时不用看了，无非就是一些
34. //初始化工作，待会在再进去看看
36. }
    刚才MSS中是调用scanDirectories函数，我们看看这个。
    2.2 scanDirectories
    java代码：
37. public void scanDirectories(String[] directories, String volumeName) {
38. try {
39. long start = System.currentTimeMillis();
40. initialize(volumeName);//初始化
42. prescan(null);//扫描前的预处理
43. long prescan = System.currentTimeMillis();
44. for (int i = 0; i < directories.length; i++) {
46. //扫描文件夹，这里有一个很重要的参数 mClient
47. // processDirectory是一个native函数
48. processDirectory(directories[i], MediaFile.sFileExtensions, mClient);
49. }
51. long scan = System.currentTimeMillis();
52. postscan(directories);//扫描后处理
53. long end = System.currentTimeMillis();
55. 打印时间，异常处理没了
56. 下面简单讲讲initialize ，preScan和postScan都干嘛了。
58. private void initialize(String volumeName) {
60. //打开MediaProvider，获得它的一个实例
62. mMediaProvider = mContext.getContentResolver().acquireProvider(“media”);
63. //得到一些uri
64. mAudioUri = Audio.Media.getContentUri(volumeName);
65. mVideoUri = Video.Media.getContentUri(volumeName);
66. mImagesUri = Images.Media.getContentUri(volumeName);
67. mThumbsUri = Images.Thumbnails.getContentUri(volumeName);
68. //外部存储的话，可以支持播放列表之类的东西，搞了一些个缓存池之类的
69. //如mGenreCache等
70. if (!volumeName.equals(“internal”)) {
71. // we only support playlists on external media
72. mProcessPlaylists = true;
73. mGenreCache = new HashMap();
    preScan，这个函数很复杂：
    　　大概就是创建一个FileCache，用来缓存扫描文件的一些信息，例如last_modified等。这个FileCache是从MediaProvider中已有信息构建出来的，也就是历史信息。后面根据扫描得到的新信息来对应更新历史信息。
    　 postScan,这个函数做一些清除工作，例如以前有video生成了一些缩略图，现在video文件被干掉了，则对应的缩略图也要被干掉。
    　　另外还有一个mClient，这个是从MediaScannerClient派生下来的一个东西，里边保存了一个文件的一些信息。后续再分析。
    在frameworks/base/media/jni/android_media_MediaScanner.cpp中。
    　　刚才说到，具体扫描工作是在processDirectory函数中完成的。这个是一个native函数。
    3 MediaScanner JNI层分析
    　　MediaScanner JNI层内容比较多，单独搞一节分析吧。先看看android_media_MediaScanner这个文件。
    3.1 native_init函数
    java代码：
74. static void
76. android_media_MediaScanner_native_init(JNIEnv *env){
78. jclass clazz;
79. clazz = env->FindClass(“android/media/MediaScanner”);
80. //得都JAVA类中mNativeContext这个成员id
82. fields.context = env->GetFieldID(clazz, “mNativeContext”, “I”);
84. }
    3.2 native_setup函数
    java代码：
85. android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz){
87. //创建MediaScanner对象
88. MediaScanner *mp = createMediaScanner();
89. //太变态了，自己不保存这个对象指针.
90. //却把它设置到java对象的mNativeContext去保存
91. env->SetIntField(thiz, fields.context, (int)mp);
92. }
94. //创建MediaScanner函数
95. static MediaScanner *createMediaScanner() {
97. MediaScanner *mp = new StagefrightMediaScanner;
98. …
99. env->SetIntField(thiz, fields.context, (int)mp);
100. MediaScanner *mp1 = new HelixMediaScanner;
101. //android 4.4 upgrade can not use helixplayer #ifndef NO_OPENCORE
102. env->SetIntField(thiz, fields.context1, (int)mp1);
     3.3 processDirectories函数
     c++代码：
103. android_media_MediaScanner_processDirectory(JNIEnv *env, jobject thiz, jstring path, jstring extensions, jobject client){
105. MediaScanner *mp = getNativeScanner_l(env, thiz); //每次都要回调到JAVA中去取这个Scanner!!
106. const char *pathStr = env->GetStringUTFChars(path, NULL);
107. //又在C++这里搞一个client，然后把java的client放到C++Client中去保存
108. //而且还是栈上的临时变量…
109. MyMediaScannerClient myClient(env, client);
110. //scanner扫描文件夹，用得是C++的client
111. MediaScanResult result = mp->processDirectory(pathStr, myClient);
112. //然后这里调用StagefrightMediaScanner父类MediaScanner的processDirectory。
113. }
     1.processDirectory
     frameworks\av\media\libmedia\MediaScanner.cpp
     C++代码：
114. MediaScanResult MediaScanner::processDirectory(

115.      const char *path, MediaScannerClient &client) {
     

116.  int pathLength = strlen(path);
     

117.  if (pathLength >= PATH_MAX) {
     

118.      return MEDIA_SCAN_RESULT_SKIPPED;
     

119.  }
     

120.  char* pathBuffer = (char *)malloc(PATH_MAX + 1);
     

121.  if (!pathBuffer) {
     

122.      return MEDIA_SCAN_RESULT_ERROR;
     

123. }
     

125. int pathRemaining = PATH_MAX - pathLength;
     

126. strcpy(pathBuffer, path);
     

127. if (pathLength > 0 && pathBuffer[pathLength - 1] != '/') {
     

128.     pathBuffer[pathLength] = '/';
     

129.     pathBuffer[pathLength + 1] = 0;
     

130.     --pathRemaining;
     

131. }
     

133. client.setLocale(locale());
     

135. MediaScanResult result = doProcessDirectory(pathBuffer, pathRemaining, client, false);
     

137. free(pathBuffer);
     

139. return result;
     

140. }
141. doProcessDirectory
     C++代码：
142. status_t MediaScanner::doProcessDirectory(char path, int pathRemaining, const char extensions,
143. MediaScannerClient& client, ExceptionCheck exceptionCheck, void* exceptionEnv)
144. {
146. //终于看到点希望了
147. //打开这个文件夹，枚举其中的内容。
148. //题外话，这个时候FileManager肯定删不掉这个文件夹!!
150. DIR* dir = opendir(path);
152. while ((entry = readdir(dir))) {
153. const char* name = entry->d_name;
154. //不处理.和…文件夹
157. if (isDirectory) {
158. //不处理.开头的文件夹。如果是文件夹，递归调用doProcessDirectory
159. //深度优先啊!
160. int err = doProcessDirectory(path, pathRemaining - nameLength - 1, extensions, client, exceptionCheck, exceptionEnv);
162. if (err) {
163. LOGE("Error processing ‘%s’ - skipping ", path);
164. continue;
165. }
167. } else if (fileMatchesExtension(path, extensions)) {
168. //是一个可以处理的文件，交给client处理
169. client.scanFile(path, statbuf.st_mtime, statbuf.st_size);
170. //最终调到了MediaScanner.java中MyMediaScannerClient的scanFile实现。
     这里要解释下，刚才createMediaScanner中，明明创建的是StagefrightMediaScanner，为何这里看得是MediaScanner代码呢?
     因为StagefrightMediaScanner从MediaScanner中派生下来的，而且没有重载processDirectory函数。
     processDirctory无非是列举一个目录内容，然后又反回去调用client的scanFile处理了。为何搞这么复杂?只有回去看看C++的client干什么了。
     到这里似乎就没有了,那么扫描后的数据库是怎么更新的呢?为什么要传入一个client进去呢?看来必须得trace到scanner中去才知道了
     3.4 MediaScannerClient—JNI层
     　　JNI中的这个类是这样的:
     java代码：
171. class MyMediaScannerClient : public MediaScannerClient
173. mScanFileMethodID = env->GetMethodID(

174.                                  mediaScannerClientInterface,
     

175.                                  "scanFile",
     

176.                                  "(Ljava/lang/String;JJZZ)V");
     

178. mHandleStringTagMethodID = env->GetMethodID(

179.                                  mediaScannerClientInterface,
     

180.                                 "handleStringTag",                                    "(Ljava/lang/String;Ljava/lang/String;)V");
     

182. mSetMimeTypeMethodID = env->GetMethodID(

183.                                 mediaScannerClientInterface,
     

184.                                 "setMimeType",
     

185.                                 "(Ljava/lang/String;)V");
     

186. //这三个接口最终是调用的MediaScanner.java中MyMediaScannerClient的实现。
188. //这是它的scanFile实现
189. virtual bool scanFile(const char* path, long long lastModified, long long fileSize){
191. //再次崩溃了，C++的client调用了刚才传进去的java Client的
192. //scanFile函数…不过这次还传进去了该文件的路径,最后修改时间和文件大小。
194. mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified, fileSize);
195. }
     没办法了，只能再去看看MediaScanner.java传进去的那个client了。
     3.5 MediaScannerClient----JAVA层
     这个类在MediaScanner.java中实现。
     java代码：
196. private class MyMediaScannerClient implements MediaScannerClient：
198. public void scanFile(String path, long lastModified, long fileSize) {
199. //调用doScanFile…很烦…
201. doScanFile(path, null, lastModified, fileSize, false);
202. //下面是doScanFile
204. public Uri doScanFile(String path, String mimeType, long lastModified, long fileSize, boolean scanAlways) {
206. //预处理，看看之前创建的文件缓存中有没有这个文件
207. FileCacheEntry entry = beginFile(path, mimeType, lastModified, fileSize);
209. // rescan for metadata if file was modified since last scan
210. if (entry != null && (entry.mLastModifiedChanged || scanAlways)) {
212. //如果事先有这个文件的信息，则需要修改一些信息，如长度，最后修改时间等
213. //真正的扫描文件
214. //processFile又是jni层的。
215. processFile(path, mimeType, this);
216. //扫描完了，做最后处理，保存数据到媒体数据库
217. endFile(entry, ringtones, notifications, alarms, music, podcasts);
219. //对应android_media_MediaScanner_processFile函数
220. android_media_MediaScanner_processFile(JNIEnv *env, jobject thiz, jstring path, jstring mimeType, jobject client){
222. MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
223. //无语了，又搞一个 MyMediaScannerClient
224. MyMediaScannerClient myClient(env, client);
225. mp->processFile(pathStr, mimeTypeStr, myClient);
226. }
     关于endFile这里涉及到数据的处理策略,如：
     1.如果没有解析到Artist，则AlbumArtist作为其值
     2.如果没有解析到title（歌曲名），则以文件名（从data字段获取）作为歌曲名，这类文件修改文件名歌曲名也会跟着刷新。有时候在文件管理中改变文件名，music列表中歌曲名没有更新。这是因为绝大部分的音乐文件都能解析到title这个字段。
     3.如果没有解析到album字段，则会以文件所在的文件夹名作为这个字段的值。这里就是为什么在同一路径下的音乐文件如果文件信息中没有album信息，其专辑封面可能一样的原因。因为album_id是根据album和albumartist或是文件所在路径来决定的。album_id是封面信息的唯一标识符，而封面数据的生成是从音频文件解析到的。但如果音乐文件不含封面信息，android会根据一定的策略来生成封面。在MediaProvider.java中的getCompressedAlbumArt()可以看到相关的处理。
     4.还有其他处理可以看endFile()及其最后的MediaProvider.java中的insertFile()的实现代码。
     4 StagefrightMediaScanner
     在frameworks\av\media\libstagefright中
     　　1. processFile
     C++代码：
227. MediaScanResult StagefrightMediaScanner::processFile(

228.      const char *path, const char *mimeType,
     

229.      MediaScannerClient &client) {
     

230.  ALOGV("processFile '%s'.", path);
     

231.  client.setLocale(locale());//涉及到字符编码，
     

232.  client.beginFile();//MyMediaScannerClient再调用MediaScannerClient.cpp的实现
     

233. MediaScanResult result = processFileInternal(path, mimeType, client);

234.  client.endFile();//MyMediaScannerClient再调用MediaScannerClient.cpp的实现
     

235.  return result;
     

236. }
237. processFileInternal
     C++代码：
238. MediaScanResult StagefrightMediaScanner::processFileInternal(

239.      const char *path, const char *mimeType,
     

240.      MediaScannerClient &client) {
     

241.  const char *extension = strrchr(path, '.');
     

243.  if (!extension) {
     

244.      return MEDIA_SCAN_RESULT_SKIPPED;
     

245.  }
     

247. if (!FileHasAcceptableExtension(extension)) {
     

248.     return MEDIA_SCAN_RESULT_SKIPPED;//看文件后缀名是否符合要求，原始的只支持几中格式，新增的需要在table中增加，否则不会解析文件获取不到文件的时长等信息。Size和type在MediaScanner.java的begin file中就赋值了。Title在endFile中会判断如果在解析文件的时候没有获取到会重新获取。也就是问题单中DTS2014041707410中qcp的音频文件时长获取不到的原因。
     

249. }
     

250. 。。。。
251. for (size_t i = 0; i < kNumEntries; ++i) {

252.     const char *value;
     

253. if ((value = mRetriever->extractMetadata(kKeyMap[i].key)) != NULL) {

254.         status = client.addStringTag(kKeyMap[i].tag, value);
     

255. //保存解析到的数据，addStringTag最终会调到MediaScanner.java的handleStringTag接口保存数据。

256.         if (status != OK) {
     

257.             return MEDIA_SCAN_RESULT_ERROR;
     

258.         }
     

259.     }
     

260. }
     

因为mtp拷贝中文歌曲的时候老出现乱码，关于字符编码这里说两句：
StagefrightMediaScanner::processFile()是对扫描到的文件中的多媒体文件里的字串数据进行转换处理的过程：

1. client.setLocale(locale());
   这个函数会根据设置的语言来设置mLocaleEncoding的值，mLocaleEncoding默认值是kEncodingNone，如果语言用户设置了英文，那么中文字串就会因为这个函数导致mLocaleEncoding的值没有变成kEncodingGBK，进而产生乱码。2.从for循环中的client.addStringTag(kKeyMap.tag, value); 可以看到，只有mLocaleEncoding != kEncodingNone才会去对文件中读到的字串进行判断，然后如果不是ascii码才会压进client.beginFile();中创建的名值对(名：如"Aritist"，值：如"李宗盛")的栈，否则直接调用handleStringTag()扔给Client，结束处理。
   3.client.endFile();首先对栈里的所有的“值”字串的值进行区间判断，得到这些字串的可能编码，并取“与”，就是不断缩小可能编码范围：
   encoding &= possibleEncodings(mValues->getEntry(i));
   然后判断如果得到的可能编码范围中有mLocaleEncoding的，就以mLocaleEncoding为栈中所有“值”字串的编码进行转换：
   if (encoding & mLocaleEncoding)
   convertValues(mLocaleEncoding);