伴随着Android的成长，多媒体系统也发生了非常大的变化。这对开发者来说，一个非常好的消息，就是从Android 2.3开始那个令人极度郁闷的OpenCore，终于有被干掉的可能了。从此，也迎来了Stagefright时代。但Android 2.2在很长一段时间内还会存在，所以希望以后能有机会深入地剖析这个OpenCore。

application android:process=android.process.media

除了支持通过广播发送扫描请求外，MediaScannerService也支持利用Binder机制跨进程调用扫描函数。这部分内容，将在本章的拓展部分中介绍。

public class MediaScannerReceiver extendsBroadcastReceiver

private final static String TAG ="MediaScannerReceiver";

   @Override  //MSR在onReceive函数中处理广播

    publicvoid onReceive(Context context, Intent intent) {

       String action = intent.getAction();

       Uri uri = intent.getData();

        //一般手机外部存储的路径是/mnt/sdcard

       String externalStoragePath =

                      Environment.getExternalStorageDirectory().getPath();

        //为了简化书写，所有Intent的ACTION_XXX_YYY字串都会简写为XXX_YYY。

        if(action.equals(Intent.ACTION_BOOT_COMPLETED)) {

            //如果收到BOOT_COMPLETED广播，则启动内部存储区的扫描工作，内部存储区

           //实际上扫描的是/system/media目录，这里存储了系统自带的铃声等媒体文件。

            scan(context, MediaProvider.INTERNAL_VOLUME);

        }else {

           if (uri.getScheme().equals("file")) {

                String path = uri.getPath();

注意下面这个判断，如果收到MEDIA_MOUNTED消息，并且外部存储挂载的路径

               和“/mnt/sdcard“一样，则启动外部存储也就是SD卡的扫描工作

               if (action.equals(Intent.ACTION_MEDIA_MOUNTED) &&

                       externalStoragePath.equals(path)) {

                    scan(context,MediaProvider.EXTERNAL_VOLUME);

                } else if(action.equals(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE)

&& path != null

&& path.startsWith(externalStoragePath +"/")) {

外部应用可以发送MEDIA_SCANNER_SCAN_FILE广播让MSR启动单个文件

的扫描工作。注意这个文件必须位于SD卡上。

                    scanFile(context, path);

读者是否注意到，MSR和跨Binder调用的接口（在本章拓展内容中将介绍）都不支持对目录的扫描（除了SD卡的根目录外）。实现这个功能并不复杂，有兴趣的读者可自行完成该功能，如果方便，请将自己实现的代码与大家共享。

private void scan(Context context, Stringvolume) {

       //volume的值为/mnt/sdcard

        Bundleargs = new Bundle();

       args.putString("volume", volume);

        //启动MSS。

       context.startService(

               new Intent(context, MediaScannerService.class).putExtras(args));

MediaScannerService extends Service implementsRunnable

//MSS实现了Runnable接口，这表明它可能会创建工作线程

public void onCreate(){

   //获得电源锁，防止在扫描过程中休眠

  PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);

  mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);

//扫描工作是一个漫长的工程，所以这里单独创建一个工作线程，线程函数就是

//MSS实现的Run函数

    Threadthr = new Thread(null, this, "MediaScannerService");

   thr.start();

 publicvoid run()

设置本线程的优先级，这个函数的调用有很重要的作用，因为媒体扫描可能会耗费很长

          时间，如果不调低优先级的话，CPU将一直被MSS占用，导致用户感觉系统变得很慢

       Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +

                                Process.THREAD_PRIORITY_LESS_FAVORABLE);

        Looper.prepare();

       mServiceLooper = Looper.myLooper();

创建一个Handler，以后发送给这个Handler的消息都会由工作线程处理。

这一部分内容，已在第5章Handler中分析过了。

       mServiceHandler = new ServiceHandler();

       Looper.loop();

context.startService(

               new Intent(context, MediaScannerService.class).putExtras(args));

@Override

 publicint onStartCommand(Intent intent, int flags, int startId)

等待mServiceHandler被创建。耕耘这段代码的码农难道不知道

HandlerThread这个类吗？不熟悉它的读者请再阅读第5章的5.4节。

     while(mServiceHandler == null) {

           synchronized (this) {

                    wait(100);

               } catch (InterruptedException e) {

       ......

       Message msg = mServiceHandler.obtainMessage();

       msg.arg1 = startId;

       msg.obj = intent.getExtras();

//往这个Handler投递消息，最终由工作线程处理。

       mServiceHandler.sendMessage(msg);

         ......

private final class ServiceHandler extendsHandler

     @Override

    public void handleMessage(Message msg)

           Bundle arguments = (Bundle) msg.obj;

           String filePath = arguments.getString("filepath");

                 ......

               } else {

                    String volume =arguments.getString("volume");

                    String[] directories =null;

                    if(MediaProvider.INTERNAL_VOLUME.equals(volume)) {

                     //如果是扫描内部存储的话，实际上扫描的目录是/system/media  

                      directories = newString[] {

                               Environment.getRootDirectory() + "/media",

                    else if (MediaProvider.EXTERNAL_VOLUME.equals(volume)){

                      //扫描外部存储，设置扫描目标位/mnt/sdcard 

                       directories = new String[]{

 Environment.getExternalStorageDirectory().getPath()};

                    if (directories != null) {

调用scan函数开展文件夹扫描工作，可以一次为这个函数设置多个目标文件夹，

不过这里只有/mnt/sdcard一个目录

                    scan(directories, volume);

                     ......

                    stopSelf(msg.arg1);

private void scan(String[] directories, StringvolumeName) {

    mWakeLock.acquire();

  ContentValuesvalues = new ContentValues();

  values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);

   //MSS通过insert特殊Uri让MediaProvider做一些准备工作

   UriscanUri = getContentResolver().insert(

MediaStore.getMediaScannerUri(), values);

   Uri uri= Uri.parse("file://" + directories[0]);

   //向系统发送一个MEDIA_SCANNER_STARTED广播。

  sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_STARTED, uri));

          //openDatabase函数也是通过insert特殊Uri让MediaProvider打开数据库

           if (volumeName.equals(MediaProvider.EXTERNAL_VOLUME)) {

                openDatabase(volumeName);   

        //创建媒体扫描器，并调用它的scanDirectories函数扫描目标文件夹

       MediaScanner scanner = createMediaScanner();

          scanner.scanDirectories(directories,volumeName);

         ......

//通过特殊Uri让MediaProvider做一些清理工作

       getContentResolver().delete(scanUri, null, null);

//向系统发送MEDIA_SCANNER_FINISHED广播

       sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_FINISHED, uri));

       mWakeLock.release();

本章不拟对MediaProvider做过多的讨论，这部分知识对那些读完前9章的读者来说，应该不是什么难题。如有可能，请读者自己整理MediaProvider的工作流程，然后提供给大家一起学习，探讨。

private MediaScanner createMediaScanner() {

//下面这个MediaScanner是在framework/base/中，稍后再分析

       MediaScanner scanner = new MediaScanner(this);

//获取当前系统使用的区域信息，扫描的时候将把媒体文件中的信息转换成当前系统使用的语言

       Locale locale = getResources().getConfiguration().locale;

        if(locale != null) {

           String language = locale.getLanguage();

           String country = locale.getCountry();

           String localeString = null;

           if (language != null) {

               if (country != null) {

//为扫描器设置当前系统使用的国家和语言。

                    scanner.setLocale(language+ "_" + country);

               } else {

                   scanner.setLocale(language);

       return scanner;

public class MediaScanner

static {

加载libmedia_jni.so，这么重要的库竟然放在如此不起眼的MediaScanner类中加载。

个人觉得，可能是因为开机后多媒体系统中最先启动的就是媒体扫描工作吧。

       System.loadLibrary("media_jni");

       native_init();

//创建媒体扫描器

public MediaScanner(Context c) {

       native_setup();//调用JNI层的函数做一些初始化工作

       ......

public void scanDirectories(String[]directories, String volumeName) {

       long start = System.currentTimeMillis();

        initialize(volumeName);//①初始化

          prescan(null);//②扫描前的预处理

        long prescan = System.currentTimeMillis();

         for(int i = 0; i < directories.length; i++) {

③ processDirectory是一个native函数，调用它来对目标文件夹进行扫描，

  其中MediaFile.sFileExtensions是一个字符串，包含了当前多媒体系统所支持的

媒体文件的后缀名，例如.MP3、.MP4等。mClient为MyMediaScannerClient类型，

它是从MediaScannerClient类派生的。它的作用我们后面再做分析。

           processDirectory(directories[i], MediaFile.sFileExtensions,

 mClient);

           long scan = System.currentTimeMillis();

           postscan(directories);//④扫描后处理

           long end = System.currentTimeMillis();

          ......//统计扫描时间等

private void initialize(String volumeName) {

//得到IMediaProvider对象，通过这个对象可以对媒体数据库进行操作。

  mMediaProvider=

 mContext.getContentResolver().acquireProvider("media");

//初始化Uri，下面分别介绍一下。

//音频表的地址，也就是数据库中的audio_meta表。

      mAudioUri =Audio.Media.getContentUri(volumeName);

      //视频表地址，也就是数据库中的video表。

     mVideoUri = Video.Media.getContentUri(volumeName);

      //图片表地址，也就是数据库中的images表。

     mImagesUri = Images.Media.getContentUri(volumeName);

      //缩略图表地址，也就是数据库中的thumbs表。

     mThumbsUri = Images.Thumbnails.getContentUri(volumeName);

      //如果扫描的是外部存储，则支持播放列表、音乐的流派等内容。

       if(!volumeName.equals("internal")) {

           mProcessPlaylists = true;

           mProcessGenres = true;

           mGenreCache = new HashMap<String, Uri>();

           mGenresUri = Genres.getContentUri(volumeName);

           mPlaylistsUri = Playlists.getContentUri(volumeName);

           if ( Process.supportsProcesses()) {

               //SD卡存储区域一般使用FAT文件系统，所以文件名与大小写无关

               mCaseInsensitivePaths = true;

读者别小瞧这个问题。现在有很多文件管理器支持删除文件和文件夹，它们用起来很方便，却没有对应地更新数据库，这导致了查询数据库时还能得到这些媒体文件信息，但这个文件实际上已不存在了，而且后面所有和此文件有关的操作都会因此而失败。

 privatevoid prescan(String filePath) throws RemoteException {

       Cursor c = null;

       String where = null;

       String[] selectionArgs = null;

        //mFileCache保存从数据库中获取的文件信息。

        if(mFileCache == null) {

           mFileCache = new HashMap<String, FileCacheEntry>();

        }else {

           mFileCache.clear();

        ......

           //从Audio表中查询其中和音频文件相关的文件信息。

           if (filePath != null) {

               where = MediaStore.Audio.Media.DATA + "=?";

               selectionArgs = new String[] { filePath };

           //查询数据库的Audio表，获取对应的音频文件信息。

           c = mMediaProvider.query(mAudioUri, AUDIO_PROJECTION, where,

 selectionArgs,null);

            if (c != null) {

                    while (c.moveToNext()) {

                        long rowId =c.getLong(ID_AUDIO_COLUMN_INDEX);

                        //音频文件的路径

                        String path =c.getString(PATH_AUDIO_COLUMN_INDEX);

                        long lastModified =

 c.getLong(DATE_MODIFIED_AUDIO_COLUMN_INDEX);

                         if(path.startsWith("/")) {

                            String key = path;

                            if(mCaseInsensitivePaths) {

                                key =path.toLowerCase();

                           //把文件信息存到mFileCache中

                            mFileCache.put(key,

new FileCacheEntry(mAudioUri, rowId, path,

                                 lastModified));

               } finally {

                    c.close();

                    c = null;

         ......//查询其他表，取出数据中关于视频，图像等文件的信息并存入到mFileCache中。

       finally {

           if (c != null) {

               c.close();

private void postscan(String[] directories)throws RemoteException {

Iterator<FileCacheEntry> iterator =mFileCache.values().iterator();

  while(iterator.hasNext()) {

           FileCacheEntry entry = iterator.next();

           String path = entry.mPath;

           boolean fileMissing = false;

           if (!entry.mSeenInFileSystem) {

               if (inScanDirectory(path, directories)) {

                    fileMissing = true; //这个文件确实丢失了

               } else {

                    File testFile = newFile(path);

                    if (!testFile.exists()) {

                        fileMissing = true;

        //如果文件确实丢失，则需要把数据库中和它相关的信息删除。

        if(fileMissing) {

          MediaFile.MediaFileType mediaFileType = MediaFile.getFileType(path);

          int fileType = (mediaFileType == null ? 0 : mediaFileType.fileType);

          if(MediaFile.isPlayListFileType(fileType)) {

                     ......//处理丢失文件是播放列表的情况

            } else {

由于文件信息中还携带了它在数据库中的相关信息，所以从数据库中删除对应的信息会

              mMediaProvider.delete(ContentUris.withAppendedId(

entry.mTableUri, entry.mRowId), null, null);

            iterator.remove();

    ......//删除缩略图文件等工作

static void

android_media_MediaScanner_native_init(JNIEnv*env)

    jclass clazz;

clazz =env->FindClass("android/media/MediaScanner");

//取得Java中MS类的mNativeContext信息。待会创建Native对象的指针会保存

//到JavaMS对象的mNativeContext变量中。

     fields.context = env->GetFieldID(clazz,"mNativeContext", "I");

     ......

android_media_MediaScanner_native_setup(JNIEnv*env, jobject thiz)

//创建Native层的MediaScanner对象

MediaScanner*mp = createMediaScanner();

......

//把mp的指针保存到Java MS对象的mNativeContext中去

env->SetIntField(thiz,fields.context, (int)mp);

//下面的createMediaScanner这个函数将创建一个Native的MS对象

static MediaScanner *createMediaScanner() {

#if BUILD_WITH_FULL_STAGEFRIGHT

    charvalue[PROPERTY_VALUE_MAX];

    if(property_get("media.stagefright.enable-scan", value, NULL)

       && (!strcmp(value, "1") || !strcasecmp(value,"true"))) {

       return new StagefrightMediaScanner; //使用Stagefright的MS

#endif

#ifndef NO_OPENCORE

    returnnew PVMediaScanner(); //使用Opencore的MS，我们会分析这个

#endif

    returnNULL;

android_media_MediaScanner_processDirectory(JNIEnv*env, jobject thiz,

jstring path, jstring extensions, jobject client)

注意上面传入的参数,path为目标文件夹的路径，extensions为MS支持的媒体文件后缀名集合，

client为Java中的MediaScannerClient对象。

MediaScanner *mp = (MediaScanner*)env->GetIntField(thiz, fields.context);

    constchar *pathStr = env->GetStringUTFChars(path, NULL);

constchar *extensionsStr = env->GetStringUTFChars(extensions, NULL);

......

   //构造一个Native层的MyMediaScannerClient，并使用Java那个Client对象做参数。

   //这个Native层的Client简称为MyMSC。

MyMediaScannerClient myClient(env, client);

//调用Native的MS扫描文件夹，并且把Native的MyMSC传进去。

mp->processDirectory(pathStr,extensionsStr, myClient,

ExceptionCheck, env);

    ......

   env->ReleaseStringUTFChars(path, pathStr);

env->ReleaseStringUTFChars(extensions,extensionsStr);

......

status_t MediaScanner::processDirectory(constchar *path,

const char *extensions, MediaScannerClient&client,

                          ExceptionCheckexceptionCheck, void *exceptionEnv) {

   ......//做一些准备工作

   client.setLocale(locale()); //给Native的MyMSC设置locale信息

   //调用doProcessDirectory函数扫描文件夹

status_tresult =  doProcessDirectory(pathBuffer,pathRemaining,

extensions, client,exceptionCheck, exceptionEnv);

   free(pathBuffer);

    returnresult;

//下面直接看这个doProcessDirectory函数

status_t MediaScanner::doProcessDirectory(char*path, int pathRemaining,

const char *extensions,MediaScannerClient&client,

ExceptionCheck exceptionCheck,void *exceptionEnv) {

   ......//忽略.nomedia文件夹

    DIR*dir = opendir(path);

    ......

while((entry = readdir(dir))) {

    //枚举目录中的文件和子文件夹信息

       const char* name = entry->d_name;

        ......

       int type = entry->d_type;

         ......

        if(type == DT_REG || type == DT_DIR) {

           int nameLength = strlen(name);

           bool isDirectory = (type == DT_DIR);

          ......

           strcpy(fileSpot, name);

           if (isDirectory) {

               ......

                //如果是子文件夹，则递归调用doProcessDirectory

               int err = doProcessDirectory(path, pathRemaining - nameLength - 1,

extensions, client, exceptionCheck, exceptionEnv);

               ......

           } else if (fileMatchesExtension(path, extensions)) {

               //如果该文件是MS支持的类型（根据文件的后缀名来判断）

                struct stat statbuf;

               stat(path, &statbuf); //取出文件的修改时间和文件的大小

               if (statbuf.st_size > 0) {

                    //如果该文件大小非零，则调用MyMSC的scanFile函数！！？

                    client.scanFile(path,statbuf.st_mtime, statbuf.st_size);

               if (exceptionCheck && exceptionCheck(exceptionEnv)) gotofailure;

......

virtual bool scanFile(const char* path, longlong lastModified,

long long fileSize)

       jstring pathStr;

        if((pathStr = mEnv->NewStringUTF(path)) == NULL) return false;

       //mClient是Java层的那个MyMSC对象，这里调用它的scanFile函数

       mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr,

lastModified, fileSize);

       mEnv->DeleteLocalRef(pathStr);

       return (!mEnv->ExceptionCheck());

public void scanFile(String path, longlastModified, long fileSize) {

           ......

           //调用doScanFile函数

           doScanFile(path, null, lastModified, fileSize, false);

//直接来看doScanFile函数

 publicUri doScanFile(String path, String mimeType, long lastModified,

long fileSize, boolean scanAlways) {

上面参数中的scanAlways用于控制是否强制扫描，有时候一些文件在前后两次扫描过程中没有

发生变化，这时候MS可以不处理这些文件。如果scanAlways为true，则这些没有变化

的文件也要扫描。

   Uriresult = null;

long t1 = System.currentTimeMillis();

      beginFile的主要工作，就是将保存在mFileCache中的对应文件信息的

mSeenInFileSystem设为true。如果这个文件之前没有在mFileCache中保存，

则会创建一个新项添加到mFileCache中。另外它还会根据传入的lastModified值

做一些处理，以判断这个文件是否在前后两次扫描的这个时间段内被修改，如果有修改，则

需要重新扫描

          FileCacheEntryentry = beginFile(path, mimeType,

lastModified, fileSize);

         if(entry != null && (entry.mLastModifiedChanged || scanAlways)) {

             String lowpath = path.toLowerCase();

             ......

             if (!MediaFile.isImageFileType(mFileType)) {

//如果不是图片，则调用processFile进行扫描，而图片不需要扫描就可以处理

//注意在调用processFile时把这个Java的MyMSC对象又传了进去。

               processFile(path, mimeType, this);

//扫描完后，需要把新的信息插入数据库，或者要将原有的信息更新，而endFile就是做这项工作的。

            result = endFile(entry, ringtones, notifications,

alarms, music, podcasts);

           } ......

           return result;

上面代码中的beginFile和endFile函数比较简单，读者可以自行研究。

android_media_MediaScanner_processFile(JNIEnv*env, jobject thiz,

jstring path, jstring mimeType, jobject client)

   //Native的MS还是那个MS，其真实类型是PVMS。

   MediaScanner *mp = (MediaScanner *)env->GetIntField(thiz,fields.context);

  //又构造了一个新的Native的MyMSC，不过它指向的Java层的MyMSC没有变化。

MyMediaScannerClient myClient(env, client);

//调用PVMS的processFile处理这个文件。

mp->processFile(pathStr,mimeTypeStr, myClient);

status_t PVMediaScanner::processFile(const char*path, const char* mimeType,

 MediaScannerClient& client)

   status_t result;

   InitializeForThread();

    //调用Native MyMSC对象的函数做一些处理

client.setLocale(locale());

beginFile由基类MSC实现，这个函数将构造两个字符串数组，一个叫mNames，另一个叫mValues。

这两个变量的作用和字符编码有关，后面会碰到。

   client.beginFile();

    ......

    constchar* extension = strrchr(path, '.');

    //根据文件后缀名来做不同的扫描处理

    if(extension && strcasecmp(extension, ".mp3") == 0) {

       result = parseMP3(path, client);//client又传进去了,我们看看对MP3文件的处理

    ......

endFile会根据client设置的区域信息来对mValues中的字符串做语言转换，例如一首MP3

   中的媒体信息是韩文，而手机设置的语言为简体中文，endFile会尽量对这些韩文进行转换。

   不过语言转换向来是个大难题，不能保证所有语言的文字都能相互转换。转换后的每一个value都

会调用handleStringTag做后续处理。

client.endFile();

......

static PVMFStatus parseMP3(const char *filename,MediaScannerClient& client)

  //对MP3文件进行解析，得到诸如duration、流派、标题的TAG（标签）信息。在Windows平台上

//可通过千千静听软件查看MP3文件的所有TAG信息

   ......

//MP3文件已经扫描完了，下面将这些TAG信息添加到MyMSC中，一起看看

   if(!client.addStringTag("duration", buffer))

       ......

bool MediaScannerClient::addStringTag(constchar* name, const char* value)

    if(mLocaleEncoding != kEncodingNone) {

       bool nonAscii = false;

       const char* chp = value;

       char ch;

       while ((ch = *chp++)) {

           if (ch & 0x80) {

               nonAscii = true;

               break;

判断name和value的编码是不是ASCII，如果不是的话则保存到

mNames和mValues中，等到endFile函数的时候再集中做字符集转换。

        if(nonAscii) {

           mNames->push_back(name);

           mValues->push_back(value);

            return true;

//如果字符编码是ASCII的话，则调用handleStringTag函数，这个函数由子类MyMSC实现。

    returnhandleStringTag(name, value);

virtual bool handleStringTag(const char* name,const char* value)

......

//调用Java层MyMSC对象的handleStringTag进行处理

  mEnv->CallVoidMethod(mClient, mHandleStringTagMethodID, nameStr,valueStr);

  publicvoid handleStringTag(String name, String value) {

           //保存这些TAG信息到MyMSC对应的成员变量中去。

           if (name.equalsIgnoreCase("title") ||name.startsWith("title;")) {

               mTitle = value;

           } else if (name.equalsIgnoreCase("artist") ||

 name.startsWith("artist;")) {

               mArtist = value.trim();

           } else if (name.equalsIgnoreCase("albumartist") ||

 name.startsWith("albumartist;")) {

               mAlbumArtist = value.trim();

......

//前面还有一段话，读者可自行阅读。下面是流程的文件总结。

* In summary:

 * JavaMediaScannerService calls

 * JavaMediaScanner scanDirectories, which calls

 * JavaMediaScanner processDirectory (native method), which calls

 * nativeMediaScanner processDirectory, which calls

 * nativeMyMediaScannerClient scanFile, which calls

 * JavaMyMediaScannerClient scanFile, which calls

 * JavaMediaScannerClient doScanFile, which calls

 * JavaMediaScanner processFile (native method), which calls

 * nativeMediaScanner processFile, which calls

 * nativeparseMP3, parseMP4, parseMidi, parseOgg or parseWMA, which calls

 * nativeMyMediaScanner handleStringTag, which calls

 * JavaMyMediaScanner handleStringTag.

 * OnceMediaScanner processFile returns, an entry is inserted in to the database.

public class MediaScannerConnection implementsServiceConnection {

 //定义OnScanCompletedListener接口，当媒体文件扫描完后，MSS调用这个接口进行通知。

 publicinterface OnScanCompletedListener {

       public void onScanCompleted(String path, Uri uri);

//定义MediaScannerConnectionClient接口，派生自OnScanCompletedListener，

//它增加了MediaScannerConnection connect上MSS的通知。

public interface MediaScannerConnectionClient extends

 OnScanCompletedListener {

       public void onMediaScannerConnected();//连接MSS的回调通知。

       public void onScanCompleted(String path, Uri uri);

  //构造函数。

  publicMediaScannerConnection(Context context,

MediaScannerConnectionClient client);

  //封装了和MSS连接及断开连接的操作。

  publicvoid connect();

  publicvoid disconnect()

  //扫描单个文件。

  publicvoid scanFile(String path, String mimeType);

  //我更喜欢下面这个静态函数，它支持多个文件的扫描，实际上间接提供了文件夹的扫描功能。

  publicstatic void scanFile(Context context, String[] paths,

String[] mimeTypes,OnScanCompletedListener callback);

  ......