Android MediaScanner深入研究



http://www.apkbus.com/android-5376-1-1.html

MediaScanner分析

　　一 MediaScannerService

　　多媒体扫描是从MediaScannerService开始的。这是一个单独的package。位于packagesprovidersMediaProvider：含以下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代码：

1. if (action.equals(Intent.ACTION_BOOT_COMPLETED)) {
   
2. 
   
3. // 收到”启动完毕“广播后，扫描内部存储
   
4. scan(context, MediaProvider.INTERNAL_VOLUME);
   
5. } else {
   
6. if (action.equals(Intent.ACTION_MEDIA_MOUNTED) &&
   
7. externalStoragePath.equals(path)) {
   
8. /收到MOUNT信息后，扫描外部存储
   
9. scan(context, MediaProvider.EXTERNAL_VOLUME);
   
10. }
    
11. else if (action.equals(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE) &&
    
12. path != null && path.startsWith(externalStoragePath + "/")) {
    
13. //收到请求要求扫描某个文件，注意不会扫描内部存储上的文件
    
14. scanFile(context, path);
    
15. 
    
16. }

复制代码

下面是它调用的scan函数：

java代码：

1. scan(Context context, String volume)
   
2. 
   
3. Bundle args = new Bundle();
   
4. args.putString("volume", volume);
   
5. //直接启动MediaScannerService了，
   
6. context.startService(new Intent(context, MediaScannerService.class).putExtras(args));

复制代码

   总结：

　　MediaScannerReceiver是用来接收任务的，它收到广播后，会启动MediaService进行扫描工作。
　　下面看看MediaScannerService.

　　1.2 MediaScannerService

       MSS标准的从Service中派生下来，
　　MediaScannerService extends Service implements Runnable
　　//注意：是一个Runnable…，可能有线程之类的东西存在
　　下面从Service的生命周期的角度来看看它的工作。

       1. onCreate

java代码：

1. public void onCreate()
   
2. 
   
3. PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);
   
4. mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
   
5. //获得电源锁，防止在扫描过程中休眠
   
6. //单独搞一个线程去跑扫描工作，防止ANR
   
7. Thread thr = new Thread(null, this, "MediaScannerService");
   
8. thr.start();

复制代码

  2. onStartCommand

java代码：

1. @Override
   
2. public int onStartCommand(Intent intent, int flags, int startId){
   
3. 
   
4. //注意这个handler，是在另外一个线程中创建的，往这个handler里sendMessage
   
5. //都会在那个线程里边处理
   
6. //不明白的可以去查看handler和Looper机制
   
7. //这里就是同步机制，等待mServiceHandler在另外那个线程创建完毕
   
8. 
   
9. while (mServiceHandler == null) {
   
10. synchronized (this) {
    
11. try {
    
12. wait(100);
    
13. } catch (InterruptedException e) {
    
14. }
    
15. }
    
16. }
    
17. 
    
18. if (intent == null) {
    
19. Log.e(TAG, "Intent is null in onStartCommand: ",new NullPointerException());
    
20. return Service.START_NOT_STICKY;
    
21. }
    
22. Message msg = mServiceHandler.obtainMessage();
    
23. msg.arg1 = startId;
    
24. msg.obj = intent.getExtras();
    
25. //把MediaScannerReceiver发出的消息传递到另外那个线程去处理。
    
26. 
    
27. mServiceHandler.sendMessage(msg);

复制代码

　    3. run

java代码：

1. public void run(){
   
2. 
   
3. // reduce priority below other background threads to avoid interfering
   
4. // with other services at boot time.
   
5. 
   
6. Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +Process.THREAD_PRIORITY_LESS_FAVORABLE);
   
7. 
   
8. //不明白的去看看Looper和handler的实现
   
9. Looper.prepare();
   
10. //把这个looper对象设置到线程本地存储
    
11. mServiceLooper = Looper.myLooper();
    
12. mServiceHandler = new ServiceHandler();
    
13. //创建handler，默认会把这个looper
    
14. //的消息队列赋值给handler的消息队列，这样往handler中发送消息就是往这个线程的looper发
    
15. Looper.loop();
    
16. //消息循环，内部会处理消息队列中的消息
    
17. //也就是handleMessage函数
    
18. }

复制代码

    上面handler中加入了一个扫描请求(假设是外部存储的)，所以要分析handleMessage函数。

　    4. handleMessage

java代码：

1. private final class ServiceHandler extends Handler{
   
2. 
   
3. @Override
   
4. public void handleMessage(Message msg){
   
5. 
   
6. Bundle arguments = (Bundle) msg.obj;
   
7. String filePath = arguments.getString("filepath");
   
8. try {
   
9. 
   
10. 这里不讲了
    
11. } else {
    
12. String volume = arguments.getString("volume");
    
13. String[] directories = null;
    
14. if (MediaProvider.INTERNAL_VOLUME.equals(volume)) {
    
15. //是扫描内部存储的请求?
    
16. // scan internal media storage
    
17. directories = new String[] {
    
18. 
    
19. Environment.getRootDirectory() + "/media",
    
20. };
    
21. }
    
22. 
    
23. else if (MediaProvider.EXTERNAL_VOLUME.equals(volume)) {
    
24. //是扫描外部存储的请求?获取外部存储的路径
    
25. directories = new String[] {
    
26. Environment.getExternalStorageDirectory().getPath(),
    
27. };
    
28. }
    
29. if (directories != null) {
    
30. //真正的扫描开始了，上面只不过是把存储路径取出来罢了.
    
31. scan(directories, volume);
    
32. //扫描完了，就把service停止了
    
33. stopSelf(msg.arg1);
    
34. }
    
35. 
    
36. };

复制代码

    5. scan函数

java代码：

1. private void scan(String[] directories, String volumeName) {
   
2. mWakeLock.acquire();
   
3. //下面这三句话很深奥…
   
4. //从 getContentResolver获得一个ContentResover，然后直接插入
   
5. //根据AIDL，这个ContentResover的另一端是MediaProvider。只要去看看它的
   
6. //insert函数就可以了
   
7. //反正这里知道获得了一个扫描URI即可。
   
8. ContentValues values = new ContentValues();
   
9. values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);
   
10. Uri scanUri = getContentResolver().insert(MediaStore.getMediaScannerUri(), values);
    
11. Uri uri = Uri.parse("file://" + directories[0]);
    
12. //发送广播，通知扫描开始了
    
13. sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_STARTED, uri));
    
14. 
    
15. try {
    
16. if (volumeName.equals(MediaProvider.EXTERNAL_VOLUME)) {
    
17. openDatabase(volumeName);
    
18. }
    
19. //创建真正的扫描器
    
20. MediaScanner scanner = createMediaScanner();
    
21. //交给扫描器去扫描文件夹 scanDirectories
    
22. scanner.scanDirectories(directories, volumeName);
    
23. } catch (Exception e) {
    
24. Log.e(TAG, "exception in MediaScanner.scan()", e);
    
25. }
    
26. //删除扫描路径
    
27. getContentResolver().delete(scanUri, null, null);
    
28. //通知扫描完毕
    
29. sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_FINISHED, uri));
    
30. mWakeLock.release();
    
31. }

复制代码

  说说上面那个深奥的地方，在MediaProvider中重载了insert函数，insert函数会调用insertInternal函数。
　　如下：

java代码：

1. private Uri insertInternal(Uri uri, ContentValues initialValues) {
   
2. long rowId;
   
3. 
   
4. int match = URI_MATCHER.match(uri);
   
5. // handle MEDIA_SCANNER before calling getDatabaseForUri()
   
6. //刚才那个insert只会走下面这个分支，其实就是获得一个地址….
   
7. //太绕了
   
8. 
   
9. if (match == MEDIA_SCANNER) {
   
10. mMediaScannerVolume = initialValues.getAsString(MediaStore.MEDIA_SCANNER_VOLUME);
    
11. return MediaStore.getMediaScannerUri();
    
12. }

复制代码

   再看看它创建了什么样的Scanner，这就是MSS中的createMediaScanner

java代码：

1. private MediaScanner createMediaScanner() {
   
2. 
   
3. //下面这个MediaScanner在framework/base/中，待会再分析
   
4. MediaScanner scanner = new MediaScanner(this);
   
5. //设置当前的区域，这个和字符编码有重大关系。
   
6. Locale locale = getResources().getConfiguration().locale;
   
7. 
   
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;
    
22. 
    
23. }

复制代码

至此，MSS的任务完成了。接下来是MediaScanner的工作了。
6. 总结

       MSS的工作流程如下：

　　1 单独启动一个带消息循环的工作线程。
　　2 主线程接收系统发来的任务，然后发送给工作线程去处理。
　　3 工作线程接收任务，创建一个MediaScanner去扫描。
　　4 MSS顺带广播一下扫描工作启动了，扫描工作完毕了。

       二 MediaScanner

　　MediaScanner位置在
　　frameworks asemedia下，包括jni和java文件。
　　先看看java实现。
　　这个类巨复杂，而且和MediaProvider交互频繁。在分析的时候要时刻回到MediaProvider去看看。
　　1. 初始化

java代码：

1. public class MediaScanner{
   
2. 
   
3. static {
   
4. //libmedia_jni.so的加载是在MediaScanner类中完成的
   
5. //这么重要的so为何放在如此不起眼的地方加载???
   
6. 
   
7. System.loadLibrary("media_jni");
   
8. native_init();
   
9. }
   
10. 
    
11. public MediaScanner(Context c) {
    
12. native_setup();//调用jni层的初始化，暂时不用看了，无非就是一些
    
13. //初始化工作，待会在再进去看看
    
14. 
    
15. }

复制代码

  刚才MSS中是调用scanDirectories函数，我们看看这个。

       2. scanDirectories

java代码：

1. public void scanDirectories(String[] directories, String volumeName) {
   
2. try {
   
3. long start = System.currentTimeMillis();
   
4. initialize(volumeName);//初始化
   
5. 
   
6. prescan(null);//扫描前的预处理
   
7. long prescan = System.currentTimeMillis();
   
8. for (int i = 0; i < directories.length; i++) {
   
9. 
   
10. //扫描文件夹，这里有一个很重要的参数 mClient
    
11. // processDirectory是一个native函数
    
12. processDirectory(directories[i], MediaFile.sFileExtensions, mClient);
    
13. }
    
14. 
    
15. long scan = System.currentTimeMillis();
    
16. postscan(directories);//扫描后处理
    
17. long end = System.currentTimeMillis();
    
18. 
    
19. 打印时间，异常处理没了
    
20. 下面简单讲讲initialize ，preScan和postScan都干嘛了。
    
21. 
    
22. private void initialize(String volumeName) {
    
23. 
    
24. //打开MediaProvider，获得它的一个实例
    
25. 
    
26. mMediaProvider = mContext.getContentResolver().acquireProvider("media");
    
27. //得到一些uri
    
28. mAudioUri = Audio.Media.getContentUri(volumeName);
    
29. mVideoUri = Video.Media.getContentUri(volumeName);
    
30. mImagesUri = Images.Media.getContentUri(volumeName);
    
31. mThumbsUri = Images.Thumbnails.getContentUri(volumeName);
    
32. //外部存储的话，可以支持播放列表之类的东西，搞了一些个缓存池之类的
    
33. //如mGenreCache等
    
34. if (!volumeName.equals("internal")) {
    
35. // we only support playlists on external media
    
36. mProcessPlaylists = true;
    
37. mGenreCache = new HashMap();

复制代码

  2. scanDirectories

java代码：

1. public void scanDirectories(String[] directories, String volumeName) {
   
2. 
   
3. try {
   
4. long start = System.currentTimeMillis();
   
5. initialize(volumeName);//初始化
   
6. 
   
7. prescan(null);//扫描前的预处理
   
8. long prescan = System.currentTimeMillis();
   
9. 
   
10. for (int i = 0; i < directories.length; i++) {
    
11. //扫描文件夹，这里有一个很重要的参数 mClient
    
12. // processDirectory是一个native函数
    
13. 
    
14. processDirectory(directories[i], MediaFile.sFileExtensions, mClient);
    
15. }
    
16. 
    
17. long scan = System.currentTimeMillis();
    
18. postscan(directories);//扫描后处理
    
19. long end = System.currentTimeMillis();
    
20. …..打印时间，异常处理…没了…
    
21. 
    
22. 下面简单讲讲initialize ，preScan和postScan都干嘛了。
    
23. 
    
24. private void initialize(String volumeName) {
    
25. //打开MediaProvider，获得它的一个实例
    
26. 
    
27. mMediaProvider = mContext.getContentResolver().acquireProvider("media");
    
28. //得到一些uri
    
29. mAudioUri = Audio.Media.getContentUri(volumeName);
    
30. mVideoUri = Video.Media.getContentUri(volumeName);
    
31. mImagesUri = Images.Media.getContentUri(volumeName);
    
32. mThumbsUri = Images.Thumbnails.getContentUri(volumeName);
    
33. 
    
34. //外部存储的话，可以支持播放列表之类的东西，搞了一些个缓存池之类的
    
35. //如mGenreCache等
    
36. if (!volumeName.equals("internal")) {
    
37. 
    
38. mProcessPlaylists = true;
    
39. mGenreCache = new HashMap();

复制代码

  preScan，这个函数很复杂：

　　大概就是创建一个FileCache，用来缓存扫描文件的一些信息，例如last_modified等。这个FileCache是从MediaProvider中已有信息构建出来的，也就是历史信息。后面根据扫描得到的新信息来对应更新历史信息。

　    postScan,这个函数做一些清除工作，例如以前有video生成了一些缩略图，现在video文件被干掉了，则对应的缩略图也要被干掉。

　　另外还有一个mClient，这个是从MediaScannerClient派生下来的一个东西，里边保存了一个文件的一些信息。后续再分析。

       在frameworks asemediajniandroid_media_MediaScanner.cpp中。

　　刚才说到，具体扫描工作是在processDirectory函数中完成的。这个是一个native函数。
     三 MediaScanner JNI层分析

　　MediaScanner JNI层内容比较多，单独搞一节分析吧。先看看android_media_MediaScanner这个文件。

　　1. native_init函数，jni对应的函数如下

java代码：

1. static void
   
2. 
   
3. android_media_MediaScanner_native_init(JNIEnv *env){
   
4. 
   
5. jclass clazz;
   
6. clazz = env->FindClass("android/media/MediaScanner");
   
7. //得都JAVA类中mNativeContext这个成员id
   
8. 
   
9. fields.context = env->GetFieldID(clazz, "mNativeContext", "I");
   
10. 
    
11. //不熟悉JNI的自己去学习下吧
    
12. }

复制代码

2. native_setup函数，jni对应函数如下：

java代码：

1. android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz){
   
2. 
   
3. //创建MediaScanner对象
   
4. MediaScanner *mp = createMediaScanner();
   
5. //太变态了，自己不保存这个对象指针.
   
6. //却把它设置到java对象的mNativeContext去保存
   
7. env->SetIntField(thiz, fields.context, (int)mp);
   
8. }
   
9. 
   
10. //创建MediaScanner函数
    
11. static MediaScanner *createMediaScanner() {
    
12. 
    
13. #if BUILD_WITH_FULL_STAGEFRIGHT
    
14. 
    
15. //使用google自己的
    
16. 
    
17. return new StagefrightMediaScanner;
    
18. 
    
19. #endif
    
20. #ifndef NO_OPENCORE
    
21. //使用opencore提供的.
    
22. return new PVMediaScanner();

复制代码

  3. processDirectories函数，jni对应如下：

java代码：

1. android_media_MediaScanner_processDirectory(JNIEnv *env, jobject thiz, jstring path, jstring extensions, jobject client){
   
2. 
   
3. MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
   
4. //每次都要回调到JAVA中去取这个Scanner!!
   
5. 
   
6. const char *pathStr = env->GetStringUTFChars(path, NULL);
   
7. const char *extensionsStr = env->GetStringUTFChars(extensions, NULL);
   
8. 
   
9. //又在C++这里搞一个client，然后把java的client放到C++Client中去保存
   
10. //而且还是栈上的临时变量..
    
11. MyMediaScannerClient myClient(env, client);
    
12. //scanner扫描文件夹，用得是C++的client
    
13. 
    
14. mp->processDirectory(pathStr, extensionsStr, myClient, ExceptionCheck, env);
    
15. env->ReleaseStringUTFChars(path, pathStr);
    
16. env->ReleaseStringUTFChars(extensions, extensionsStr);
    
17. }

复制代码

到这里似乎就没有了,那么扫描后的数据库是怎么更新的呢?为什么要传入一个client进去呢?看来必须得trace到scanner中去才知道了
四 PVMediaScanner

　　这个在externalopencoreandroidmediascanner.cpp中。

　　1. processDirectory

java代码：

1. status_t MediaScanner::processDirectory(const char *path, const char* extensions,
   
2. MediaScannerClient& client, ExceptionCheck exceptionCheck, void* exceptionEnv)
   
3. {
   
4. 
   
5. InitializeForThread();
   
6. int error = 0;
   
7. status_t result = PVMFSuccess;
   
8. //调用client的设置区域函数
   
9. client.setLocale(mLocale);
   
10. //扫描文件夹，咋还没开始??
    
11. result = doProcessDirectory(pathBuffer, pathRemaining, extensions, client, exceptionCheck, exceptionEnv);

复制代码

   2. doProcessDirectory

java代码：

1. status_t MediaScanner::doProcessDirectory(char *path, int pathRemaining, const char* extensions,
   
2. MediaScannerClient& client, ExceptionCheck exceptionCheck, void* exceptionEnv)
   
3. {
   
4. 
   
5. //终于看到点希望了
   
6. //打开这个文件夹，枚举其中的内容。
   
7. //题外话，这个时候FileManager肯定删不掉这个文件夹!!
   
8. 
   
9. DIR* dir = opendir(path);
   
10. 
    
11. while ((entry = readdir(dir))) {
    
12. const char* name = entry->d_name;
    
13. //不处理.和..文件夹
    
14. 
    
15. 
    
16. if (isDirectory) {
    
17. //不处理.开头的文件夹。如果是文件夹，递归调用doProcessDirectory
    
18. //深度优先啊!
    
19. int err = doProcessDirectory(path, pathRemaining - nameLength - 1, extensions, client, exceptionCheck, exceptionEnv);
    
20. 
    
21. if (err) {
    
22. LOGE("Error processing '%s' - skipping ", path);
    
23. continue;
    
24. }
    
25. 
    
26. } else if (fileMatchesExtension(path, extensions)) {
    
27. //是一个可以处理的文件，交给client处理
    
28. //彻底疯掉了….这是干嘛呢???
    
29. client.scanFile(path, statbuf.st_mtime, statbuf.st_size);

复制代码

这里要解释下，刚才createMediaScanner中，明明创建的是PVMediaScanner，为何这里看得是MediaScanner代码呢?
  因为PVMediaScanner从MediaScanner中派生下来的，而且没有重载processDirectory函数Eclaire没有PVMediaScanner这样的东西，估计是froyo又改了点啥吧。

       FT，processDirctory无非是列举一个目录内容，然后又反回去调用client的scanFile处理了。为何搞这么复杂?只有回去看看C++的client干什么了。

       MediaScannerClient---JNI层

　　JNI中的这个类是这样的:

java代码：

1. class MyMediaScannerClient : public MediaScannerClient
   
2. //这是它的scanFile实现
   
3. 
   
4. virtual bool scanFile(const char* path, long long lastModified, long long fileSize){
   
5. 
   
6. //再次崩溃了，C++的client调用了刚才传进去的java Client的
   
7. //scanFile函数…不过这次还传进去了该文件的路径,最后修改时间和文件大小。
   
8. 
   
9. mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified, fileSize);
   
10. //想死,,,
    
11. }

复制代码

  没办法了，只能再去看看MediaScanner.java传进去的那个client了。

         MediaScannerClient----JAVA层
         这个类在MediaScanner.java中实现。

java代码：

1. private class MyMediaScannerClient implements MediaScannerClient：
   
2. 
   
3. public void scanFile(String path, long lastModified, long fileSize) {
   
4. //调用doScanFile..很烦..
   
5. 
   
6. doScanFile(path, null, lastModified, fileSize, false);
   
7. //下面是doScanFile
   
8. 
   
9. public Uri doScanFile(String path, String mimeType, long lastModified, long fileSize, boolean scanAlways) {
   
10. 
    
11. //预处理，看看之前创建的文件缓存中有没有这个文件
    
12. FileCacheEntry entry = beginFile(path, mimeType, lastModified, fileSize);
    
13. 
    
14. // rescan for metadata if file was modified since last scan
    
15. if (entry != null && (entry.mLastModifiedChanged || scanAlways)) {
    
16. 
    
17. //如果事先有这个文件的信息，则需要修改一些信息，如长度，最后修改时间等
    
18. //真正的扫描文件
    
19. 
    
20. processFile(path, mimeType, this);
    
21. //扫描完了，做最后处理
    
22. endFile(entry, ringtones, notifications, alarms, music, podcasts);
    
23. //processFile又是jni层的。
    
24. //对应android_media_MediaScanner_processFile函数
    
25. 
    
26. android_media_MediaScanner_processFile(JNIEnv *env, jobject thiz, jstring path, jstring mimeType, jobject client){
    
27. 
    
28. MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz, fields.context);
    
29. //无语了，又搞一个 MyMediaScannerClient
    
30. MyMediaScannerClient myClient(env, client);
    
31. mp->processFile(pathStr, mimeTypeStr, myClient);
    
32. }