MediaScannerService研究

MediaScannerService研究

侯 亮

（本文以Android 5.1为准）

1 概述

MediaScannerService是Android平台提供的一个用于扫描手机中多媒体文件的应用级service。它并不是系统服务。MediaScannerService和MediaProvider有着非常紧密的关系，因为扫描出的结果总需要存储到某个地方来展现给用户。那么它们具体是如何结合的呢？本文将逐步加以阐述。

我们先来初步了解一下MediaScannerService，它在AndroidManifest.xml文件里的相关信息如下：

【packages/providers/mediaprovider/AndroidManifest.xml】

<service android:name="MediaScannerService" android:exported="true">    <intent-filter>        <action android:name="android.media.IMediaScannerService" />    </intent-filter></service>

MediaScannerService本身继承于Service，而且还实现了Runnable接口。其定义截选如下：【packages/providers/mediaprovider/src/com/android/providers/media/MediaScannerService.java】

public class MediaScannerService extends Service implements Runnable{    private static final String TAG = "MediaScannerService";    private volatile Looper mServiceLooper;    private volatile ServiceHandler         mServiceHandler;    private PowerManager.WakeLock mWakeLock;    private String[]                            mExternalStoragePaths;    . . . . . .    private final IMediaScannerService.Stub mBinder = new IMediaScannerService.Stub()             . . . . . .    . . . . . .}

1.1 在onCreate()中启动工作线程

MediaScannerService的onCreate()函数如下：
【packages/providers/mediaprovider/src/com/android/providers/media/MediaScannerService.java】

@Overridepublic void onCreate(){    PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);    mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);    StorageManager storageManager = (StorageManager)getSystemService(Context.STORAGE_SERVICE);    mExternalStoragePaths = storageManager.getVolumePaths();    // 启动最重要的工作线程，该线程也是个消息泵线程    Thread thr = new Thread(null, this, "MediaScannerService");    thr.start();}

可以看到，onCreate()里会启动最重要的工作线程，该线程也是个消息泵线程。每当用户需要扫描媒体文件时，基本上都是在向这个消息泵里发送Message，并在处理Message时完成真正的scan动作。请注意，创建Thread时传入的第二个参数就是MediaScannerService自身，也就是说线程的主要行为其实就是MediaScannerService的run()函数，该函数的代码如下：

public void run(){    Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +                              Process.THREAD_PRIORITY_LESS_FAVORABLE);    Looper.prepare();    mServiceLooper   = Looper.myLooper();               // 消息looper    mServiceHandler  = new ServiceHandler();            // 发送消息的handler    Looper.loop();}

后续就是通过上面那个mServiceHandler向消息队列发送Message的。

1.2 向工作线程发送Message

比较常见的向消息泵发送Message的做法是调用startService()，并在MediaScannerService的onStartCommand()函数里sendMessage()。比如，和MediaScannerService配套提供的MediaScannerReceiver，当它收到类似ACTION_BOOT_COMPLETED这样的系统广播时，就会调用自己的scan()或scanFile()函数。而scan()函数的代码如下：
【packages/providers/mediaprovider/src/com/android/providers/media/MediaScannerReceiver.java】

private void scan(Context context, String volume) {    Bundle args = new Bundle();    args.putString("volume", volume);    context.startService( new Intent(context, MediaScannerService.class).putExtras(args));}

startService()动作会导致走到service的onStartCommand()，并进一步发送消息，其函数截选如下：

@Overridepublic int onStartCommand(Intent intent, int flags, int startId){    . . . . . .    . . . . . .    Message msg = mServiceHandler.obtainMessage();    msg.arg1 = startId;    msg.obj = intent.getExtras();    mServiceHandler.sendMessage(msg);// 发送消息！    // Try again later if we are killed before we can finish scanning.    return Service.START_REDELIVER_INTENT;}

另外一种比较常见的发送Message的做法是先直接或间接bindService()，绑定成功后会得到一个IMediaScannerService接口，而后外界再通过该接口向MediaScannerService发起命令，请求其扫描特定文件或目录。


IMediaScannerService接口只提供了两个接口函数：

• void requestScanFile(String path, String mimeType, in IMediaScannerListener listener);
• void scanFile(String path, String mimeType);

处理这两种请求的实体是服务内部的mBinder对象，参考代码如下：
【packages/providers/mediaprovider/src/com/android/providers/media/MediaScannerService.java】

private final IMediaScannerService.Stub mBinder = new IMediaScannerService.Stub() {    public void requestScanFile(String path, String mimeType, IMediaScannerListener listener)    {        Bundle args = new Bundle();        args.putString("filepath", path);        args.putString("mimetype", mimeType);        if (listener != null) {            args.putIBinder("listener", listener.asBinder());        }        startService(new Intent(MediaScannerService.this,                                MediaScannerService.class).putExtras(args));    }    public void scanFile(String path, String mimeType) {        requestScanFile(path, mimeType, null);    }};

说到底还是在调用startService()。

具体处理消息泵线程里的消息时，执行的是ServiceHandler的handleMessage()函数：

private final class ServiceHandler extends Handler{    @Override    public void handleMessage(Message msg)    {        Bundle arguments = (Bundle) msg.obj;        String filePath = arguments.getString("filepath");        . . . . . .        if (filePath != null) {            . . . . . .                uri = scanFile(filePath, arguments.getString("mimetype"));            . . . . . .        } else {            . . . . . .                scan(directories, volume);            . . . . . .        }        . . . . . .        stopSelf(msg.arg1);    }};

此时调用的scanFile()或scan()函数才是实际进行扫描动作的地方。扫描动作中主要借助的是辅助类MediaScanner，这个类非常重要，它是打通Java层和C++层的关键，扫描动作最终会调用到MediaScanner的某个native函数，于是程序流程开始走到C++层。

现在，我们可以画一张示意图：

2 运作细节

2.1 发起扫描动作

现在我们已经了解了，要发起扫描动作，大体上只有两种方式：
1）用广播来发起扫描动作；
2）绑定服务来发起扫描动作；
下面我们细说一下这两种方式。

2.1.1 用广播来发起扫描动作

扫描服务的配套receiver是MediaScannerReceiver，它在AndroidManifest.xml里的描述如下：

<receiver android:name="MediaScannerReceiver">    <intent-filter>        <action android:name="android.intent.action.BOOT_COMPLETED" />    </intent-filter>    <intent-filter>        <action android:name="android.intent.action.MEDIA_MOUNTED" />        <data android:scheme="file" />    </intent-filter>    <intent-filter>        <action android:name="android.intent.action.MEDIA_UNMOUNTED" />        <data android:scheme="file" />    </intent-filter>    <intent-filter>        <action android:name="android.intent.action.MEDIA_SCANNER_SCAN_FILE" />        <data android:scheme="file" />    </intent-filter></receiver>

MediaScannerReceiver的onReceive()代码如下：

public void onReceive(Context context, Intent intent) {    final String action = intent.getAction();    final Uri uri = intent.getData();        if (Intent.ACTION_BOOT_COMPLETED.equals(action)) {        // Scan both internal and external storage        scan(context, MediaProvider.INTERNAL_VOLUME);  // INTERNAL_VOLUME = "internal"        scan(context, MediaProvider.EXTERNAL_VOLUME);  // EXTERNAL_VOLUME = "external"    } else {        if (uri.getScheme().equals("file")) {            // handle intents related to external storage            . . . . . .            Log.d(TAG, "action: " + action + " path: " + path);            if (Intent.ACTION_MEDIA_MOUNTED.equals(action)) {                // scan whenever any volume is mounted                scan(context, MediaProvider.EXTERNAL_VOLUME);            } else if (Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) &&                    path != null && path.startsWith(externalStoragePath + "/")) {                scanFile(context, path);            }        }    }}

• 当系统刚刚启动时，收到ACTION_BOOT_COMPLETED广播，此时会把内部卷标（“internal”）和外部卷标（“external”）都扫描一下；
• 如果收到ACTION_MEDIA_MOUNTED广播，则只扫描外部卷标；
• 如果收到的是ACTION_MEDIA_SCANNER_SCAN_FILE广播，则扫描具体的文件路径。

当用户插入了扩展介质（一般指SD卡），并且该介质已经被系统正确识别、安装，系统就会发出ACTION_MEDIA_MOUNTED广播。从Android 4.4开始，ACTION_MEDIA_MOUNTED广播只能由系统（系统服务MountService）发出，普通用户是无权发送的。

另外，我们可以通过发送ACTION_MEDIA_SCANNER_SCAN_FILE广播，要求MediaScannerService扫描一下具体的文件。比如说在ExternalStorageProvider的openDocument()函数里，就会设置监听器监听用户是不是在读写模式下close了某个文件，因为close一般表示写入动作已经完成了，那么此时就需要“踢一下”MediaScannerService，让它更新一下自己的数据。这段代码截选如下：
【frameworks/base/packages/externalstorageprovider/src/com/android/externalstorage/ExternalStorageProvider.java】

@Overridepublic ParcelFileDescriptor openDocument(String documentId, String mode,                                                  CancellationSignal signal)                                                 throws FileNotFoundException {    . . . . . .            // When finished writing, kick off media scanner            return ParcelFileDescriptor.open(file, pfdMode, mHandler,                                                     new OnCloseListener() {                @Override                public void onClose(IOException e) {                    final Intent intent = new Intent(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE);                    intent.setData(Uri.fromFile(file));                    getContext().sendBroadcast(intent);// 用广播来发起扫描动作                }            });    . . . . . .}

2.1.2 用MediaScannerConnection来发起扫描动作

除了利用类似ACTION_MEDIA_SCANNER_SCAN_FILE这样的广播，系统中还有一种办法可以发起扫描动作，那就是先利用bindService机制得到的IMediaScannerService代理接口，而后再通过调用该接口的requestScanFile()或scanFile()，同样可以向MediaScannerService发出扫描语义。

不过，我们一般并不直白地去bindService，而是通过一种封装好的辅助类：MediaScannerConnection。该类的定义截选如下：
【frameworks/base/media/java/android/media/MediaScannerConnection.java】

public class MediaScannerConnection implements ServiceConnection {    private static final String TAG = "MediaScannerConnection";    private Context mContext;    private MediaScannerConnectionClient mClient;    private IMediaScannerService mService;    private boolean mConnected; // true if connect() has been called since last disconnect()    private final IMediaScannerListener.Stub mListener = new IMediaScannerListener.Stub()    . . . . . .

请注意那个mService成员，它就是为了绑定service而设计的。

MediaScannerConnection里设计了两个scanFile()函数，一个动态的，一个静态的。大家不要搞混了。

2.1.2.1 动态形式scanFile()

动态形式scanFile()的代码截选：

public void scanFile(String path, String mimeType) {    . . . . . .            mService.requestScanFile(path, mimeType, mListener);    . . . . . .}

对于动态形式的scanFile()而言，它只能在MediaScannerConnection成功绑定到MediaScannerService之后调用，此时它简单地调用mService.requestScanFile()将语义传递给MediaScannerService，再由MediaScannerService通过startService()向自己的消息泵线程打入消息。

mService.requestScanFile()的最后一个参数mListener的定义如下：

private final IMediaScannerListener.Stub mListener = new IMediaScannerListener.Stub() {    public void scanCompleted(String path, Uri uri) {        MediaScannerConnectionClient client = mClient;        if (client != null) {            client.onScanCompleted(path, uri);        }    }};

它是个简单的binder实体。每当MediaScannerService扫描完所指定的一个文件后，就会回调到该实体的scanCompleted()。此时一般会经由client.onScanCompleted()一句间接调用下一次scanFile()的动作，从而使扫描多个文件的动作连贯起来。

2.1.2.2 静态形式scanFile()

静态形式scanFile()的代码截选：

public static void scanFile(Context context, String[] paths, String[] mimeTypes,                            OnScanCompletedListener callback) {    ClientProxy client = new ClientProxy(paths, mimeTypes, callback);    MediaScannerConnection connection = new MediaScannerConnection(context, client);    client.mConnection = connection;    connection.connect();  // 内部主要是bindService动作}

对于静态形式的scanFile()而言，会重新创建一个MediaScannerConnection对象，并通过connect()动作和MediaScannerService联系起来。

请大家注意创建MediaScannerConnection时传入的第二个参数client，它必须实现MediaScannerConnectionClient接口。说穿了是为了监听两种事情：
1）和MediaScannerService之间的连接是否建立好了；
2）MediaScannerService中扫描某文件的动作是否执行完了；
     
MediaScannerConnectionClient接口的定义如下：
【frameworks/base/media/java/android/media/MediaScannerConnection.java】

public interface MediaScannerConnectionClient extends OnScanCompletedListener {    public void onMediaScannerConnected();    public void onScanCompleted(String path, Uri uri);}

在静态形式的scanFile()中，实现MediaScannerConnectionClient接口的类是ClientProxy，它是这样实现onMediaScannerConnected()和onScanCompleted()的：
【frameworks/base/media/java/android/media/MediaScannerConnection.java】

public void onMediaScannerConnected() {    scanNextPath();}public void onScanCompleted(String path, Uri uri) {    if (mClient != null) {        mClient.onScanCompleted(path, uri);    }    scanNextPath();}

可以看到一旦连接建立成功或者某个文件扫描完毕，就会调用scanNextPath()，进一步扫描接下来的内容，直到把调用静态scanFile()时传入的paths数组遍历完毕。

void scanNextPath() {    if (mNextPath >= mPaths.length) {        mConnection.disconnect();        return;    }    String mimeType = mMimeTypes != null ? mMimeTypes[mNextPath] : null;    mConnection.scanFile(mPaths[mNextPath], mimeType);    mNextPath++;}

实际上，MediaScannerConnection的connect()动作就是在bindService()，它的代码如下：
【frameworks/base/media/java/android/media/MediaScannerConnection.java】

public void connect() {    synchronized (this) {        if (!mConnected) {            Intent intent = new Intent(IMediaScannerService.class.getName());            intent.setComponent( new ComponentName("com.android.providers.media",                                        "com.android.providers.media.MediaScannerService"));            mContext.bindService(intent, this, Context.BIND_AUTO_CREATE);            mConnected = true;        }    }}

因为bindService()动作本身是异步的，初始时mService的值还是null，所以我们不能直接在这里执行类似mService.requestScanFile()这样的操作。我们必须等到bind动作成功完成，系统回调到MediaScannerConnection的onServiceConnected()，才会给mService赋值：

public void onServiceConnected(ComponentName className, IBinder service) {    . . . . . .    synchronized (this) {        mService = IMediaScannerService.Stub.asInterface(service);        if (mService != null && mClient != null) {            mClient.onMediaScannerConnected();        }    }}

如果bind动作是成功的，而且用户在构造MediaScannerConnection对象时传入了client参数。那么此时就会回调mClient的onMediaScannerConnected()函数。

请注意，静态的scanFile()方法最终并没有直接执行requestScanFile()，它先建立了和MediaScannerService的绑定关系，然后在onServiceConnected()中感知到绑定已经成功之后，才会经由ClientProxy间接转过头调用到自己的scanFile()函数，从而执行到requestScanFile()。

ClientProxy、MediaScannerConnection、MediaScannerService三者之间的关系如下图所示：

以MediaScannerConnection对象为桥梁：
1）其mService“指向”MediaScannerService的mBinder；
2）其mClient指向ClientProxy对象；

当然，在看懂上图后，我们也可以不使用默认的ClientProxy，而添加我们自定义的client对象，只要这个client对象实现了MediaScannerConnectionClient接口即可。比如在MediaProvider中，就定义了另一个类ScannerClient类，代码截选如下：
【packages/providers/mediaprovider/src/com/android/providers/media/MediaProvider.java】

private static final class ScannerClient implements MediaScannerConnectionClient {    String mPath = null;    MediaScannerConnection mScannerConnection;    SQLiteDatabase mDb;    public ScannerClient(Context context, SQLiteDatabase db, String path) {        mDb = db;        mPath = path;        mScannerConnection = new MediaScannerConnection(context, this);        mScannerConnection.connect();    }    @Override    public void onMediaScannerConnected() {        . . . . . .    }    @Override    public void onScanCompleted(String path, Uri uri) {    }}

这么看来，MediaScannerConnection还真是起连接作用的“connection”，它将发起扫描请求的client和最终执行扫描动作的MediaScannerService连接起来了。我们把上面那张图简化一下，可以看到如下示意图：

以上介绍的就是发起scan动作的方法，接下来我们来看看到底有哪些地方在使用这些方法。

2.2 谁会发起扫描动作

2.2.1 发起者列表

发出ACTION_MEDIA_SCANNER_SCAN_FILE广播的地方：

发起方
相关代码位置
说明ExternalStorageProvideropenDocument()注册OnCloseListener的地方 ComposeMessageActivityMMS里copyPart()函数中saveRingtone()、
copyMedia()中都会调用copyPart()。DownloadProvideropenFile()注册OnCloseListener的地方 EmlAttachmentProvidercopyAttachment()，将附件拷到外部下载目录（一般是SD卡）时provider在update()中处理ATTACHMENT的地方SoundRecorderaddToMediaDB()录制sample后，要添加进多媒体数据库

利用MediaScannerConnection的地方：

发起方
相关代码位置
说明AttachmentUtilitiessaveAttachment()代码截选见下文BeamTransferManager     processFiles()NFC方面，
finishTransfer()、handleMessage()处理MSG_NEXT_TRANSFER_TIMER时，都会调用processFiles()。BluetoothOppServiceMediaScannerNotifier   没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的MediaScannerNotifierCalendarDebugActivity                                   doInBackground()DumpDbTask的doInBackground()，将数据库文件存成calendar.db.zip之后，调用MediaScannerConnection.scanFile()DownloadScannerDownloadScanner没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的DownloadScannerFmRecorderaddRecordingToDatabase()                             MediaScannerConnection.scanFile(context, 
new String[] { mRecordFile.getPath() },
                null, null);IngestServiceScannerClient没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的ScannerClientMediaProviderScannerClient没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的ScannerClientVCardServiceCustomeMediaScannerConnectionClient                                           没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的CustomeMediaScannerConnectionClient

2.2.2 saveAttachment()中的示例代码

我们举一个实际的例子。在Email模块中，如果附件存入了外部存储器，那么就有必要扫描一次媒体文件了，这样才能够立即将相关文件体现到Gallery、Music中。所以在saveAttachment()函数里，就会调用MediaScannerConnection.scanFile()：
【packages/apps/email/emailcommon/src/com/android/emailcommon/utility/AttachmentUtilities.java】

public static void saveAttachment(Context context, InputStream in, Attachment attachment) {    . . . . . .        ContentResolver resolver = context.getContentResolver();        if (attachment.mUiDestination == UIProvider.AttachmentDestination.CACHE) {            . . . . . .        } else if (Utility.isExternalStorageMounted()) {            . . . . . .            File file = Utility.createUniqueFile(downloads, attachment.mFileName);            size = copyFile(in, new FileOutputStream(file));            String absolutePath = file.getAbsolutePath();            // 尽管下载管理器会扫描媒体文件，但只会在用户运行download APP并点击相关按钮后，            // 才会进行扫描。所以，我们自己运行一下media scanner，以便把附件立即添加进gallery / music。            MediaScannerConnection.scanFile(context, new String[] {absolutePath},                                                   null, null);            . . . . . .                DownloadManager dm = (DownloadManager)                                       context.getSystemService(Context.DOWNLOAD_SERVICE);                long id = dm.addCompletedDownload(attachment.mFileName,                         attachment.mFileName,                        false /* do not use media scanner */,                        mimeType, absolutePath, size,                        true /* show notification */);                contentUri = dm.getUriForDownloadedFile(id).toString();            . . . . . .        } else {            . . . . . .            throw new IOException();        }    . . . . . .    context.getContentResolver().update(uri, cv, null, null);}

2.3 说说实际的扫描动作

前文介绍MediaScannerService的消息泵线程时已经说过，最终ServiceHandler的handleMessage()会调用scanFile()或scan()来完成扫描。现在我们来看看scanFile()、scan()的细节。

2.3.1 scanFile()动作

MediaScannerService的scanFile()定义如下：
【packages/providers/mediaprovider/src/com/android/providers/media/MediaScannerService.java】

private Uri scanFile(String path, String mimeType) {    String volumeName = MediaProvider.EXTERNAL_VOLUME;    openDatabase(volumeName);    MediaScanner scanner = createMediaScanner();    try {        String canonicalPath = new File(path).getCanonicalPath();        return scanner.scanSingleFile(canonicalPath, volumeName, mimeType);    } catch (Exception e) {        Log.e(TAG, "bad path " + path + " in scanFile()", e);        return null;    }}

可以看到，scanFile()函数内部借助了辅助类MediaScanner，调用了该类的scanSingleFile()。这个MediaScanner才是重头戏，它的scanSingleFile()代码截选如下： 
【frameworks/base/media/java/android/media/MediaScanner.java】

public Uri scanSingleFile(String path, String volumeName, String mimeType) {    . . . . . .        initialize(volumeName);        prescan(path, true);        File file = new File(path);        . . . . . .        // always scan the file, so we can return the content://media Uri for existing files        return mClient.doScanFile(path, mimeType, lastModifiedSeconds, file.length(),                false, true, MediaScanner.isNoMediaPath(path));    . . . . . .}

借助了mClient.doScanFile()。

此处的mClient类型为MyMediaScannerClient，mClient的定义是：

private final MyMediaScannerClient mClient = new MyMediaScannerClient();

MyMediaScannerClient类的doScanFile()的代码截选如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

public Uri doScanFile(String path, String mimeType, long lastModified,        long fileSize, boolean isDirectory, boolean scanAlways, boolean noMedia) {    . . . . . .        FileEntry entry = beginFile(path, mimeType, lastModified,                fileSize, isDirectory, noMedia);        . . . . . .        if (entry != null && (entry.mLastModifiedChanged || scanAlways)) {            if (noMedia) {                result = endFile(entry, false, false, false, false, false);            } else {                . . . . . .                . . . . . .                // we only extract metadata for audio and video files                if (isaudio || isvideo) {                    processFile(path, mimeType, this);                }                if (isimage) {                    processImageFile(path);                }                result = endFile(entry, ringtones, notifications, alarms, music, podcasts);            }        }    . . . . . .    return result;}

因为MyMediaScannerClient是MediaScanner的内嵌类，所以它可以直接调用MediaScanner的processFile()。

现在我们画一张scanFile()的调用关系图：

2.3.2 scan()动作

与scanFile()动作类似，MediaScannerService中扫描目录的动作是scan()：
【packages/providers/mediaprovider/src/com/android/providers/media/MediaScannerService.java】

private void scan(String[] directories, String volumeName) {    . . . . . .    values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);    Uri scanUri = getContentResolver().insert(MediaStore.getMediaScannerUri(), values);    . . . . . .            MediaScanner scanner = createMediaScanner();            scanner.scanDirectories(directories, volumeName);    . . . . . .        sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_FINISHED, uri));    . . . . . .}

同样是借助了辅助类MediaScanner，调用了该类的scanDirectories()。

scanDirectories()的代码截选如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

public void scanDirectories(String[] directories, String volumeName) {    . . . . . .         for (int i = 0; i < directories.length; i++) {            processDirectory(directories[i], mClient);        }    . . . . . .}

我们画一张scan()的调用关系图：

2.3.3 MediaScanner

顾名思义，MediaScanner就是个“媒体文件扫描器”。它必须打通java层次和C++层次。请大家注意它的两个native函数：native_init()和native_setup()，以及两个重要成员变量：一个是上文刚刚提到的mClient成员，另一个是mNativeContext。

MediaScanner的相关代码截选如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

public class MediaScanner{    static {        System.loadLibrary("media_jni");        native_init(); // 将java层和c++层联系起来    }    . . . . . .    private long mNativeContext;    . . . . . .    public MediaScanner(Context c) {        native_setup();        . . . . . .    }. . . . . .    // 一开始就具有明确的mClient对象    private final MyMediaScannerClient mClient = new MyMediaScannerClient();    . . . . . .}

MediaScanner类加载之时，就会同时加载动态链接库“media_jni”，并调用native_init()将java层和c++层联系起来。而且MediaScanner对象一开始就具有明确的mClient对象，类型为MyMediaScannerClient。

经过分析代码，我们发现在C++层会有个与MediaScanner相对应的类，叫作StagefrightMediaScanner。当java层创建MediaScanner对象时，MediaScanner的构造函数就调用了native_setup()，该函数对应到C++层就是android_media_MediaScanner_native_setup()，其代码如下：
【frameworks/base/media/jni/android_media_MediaScanner.cpp】

static voidandroid_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz){    ALOGV("native_setup");    MediaScanner *mp = new StagefrightMediaScanner;    if (mp == NULL) {        jniThrowException(env, kRunTimeException, "Out of memory");        return;    }    env->SetLongField(thiz, fields.context, (jlong)mp);}

最后一句env->SetLongField()其实就是在为java层MediaScanner的mNativeContext域赋值。

后续我们会看到，每当C++层执行扫描动作时，还会再创建一个MyMediaScannerClient对象，这个对象和Java层的同名类对应。我们画一张图来说明：

2.3.4 调用到C++层次

不管是扫描文件，还是扫描目录，总之MediaScannerService已经把工作委托给MediaScanner的scanSingleFile()和scanDirectories()了，而这两个函数到头来都是调用MediaScanner自己的native函数，即processFile()和processDirectory()。其声明如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

private native void processDirectory(String path, MediaScannerClient client);private native void processFile(String path, String mimeType, MediaScannerClient client);

MediaScanner中调用的processFile()对应于C++层的android_media_MediaScanner_processFile()。代码截选如下：
【frameworks/base/media/jni/android_media_MediaScanner.cpp】

static void android_media_MediaScanner_processFile(                JNIEnv *env, jobject thiz, jstring path,                jstring mimeType, jobject client){    . . . . . .    MediaScanner *mp = getNativeScanner_l(env, thiz);    . . . . . .    const char *mimeTypeStr =        (mimeType ? env->GetStringUTFChars(mimeType, NULL) : NULL);    if (mimeType && mimeTypeStr == NULL) {  // Out of memory        // ReleaseStringUTFChars can be called with an exception pending.        env->ReleaseStringUTFChars(path, pathStr);        return;    }    MyMediaScannerClient myClient(env, client); // 构造一个临时的myClient    MediaScanResult result = mp->processFile(pathStr, mimeTypeStr, myClient);    if (result == MEDIA_SCAN_RESULT_ERROR) {        ALOGE("An error occurred while scanning file '%s'.", pathStr);    }    . . . . . .}

注意这里构造了一个局部的（C++层次）MyMediaScannerClient对象，构造myClient时传入的client参数来自于Java层调用processFile()时传入的那个（Java层次）MyMediaScannerClient对象。这个对象会记录在C++层MyMediaScannerClient的mClient域中，这个在前面的示意图中已有表示。

相应的，processDirectory()对应于C++层的android_media_MediaScanner_processDirectory()。代码截选如下：
【frameworks/base/media/jni/android_media_MediaScanner.cpp】

static void android_media_MediaScanner_processDirectory(        JNIEnv *env, jobject thiz, jstring path, jobject client){    . . . . . .    MediaScanner *mp = getNativeScanner_l(env, thiz);    . . . . . .    MyMediaScannerClient myClient(env, client);    MediaScanResult result = mp->processDirectory(pathStr, myClient);    . . . . . .}

2.3.4.1 processFile()

android_media_MediaScanner_processFile()函数中的那个mp是经由下面这句得到的：

MediaScanner *mp = getNativeScanner_l(env, thiz);

它指向的其实就是StagefrightMediaScanner，所以这里调用的processFile就是：
【frameworks/av/media/libstagefright/StagefrightMediaScanner.cpp】

MediaScanResult StagefrightMediaScanner::processFile(        const char *path, const char *mimeType,        MediaScannerClient &client) {    ALOGV("processFile '%s'.", path);    client.setLocale(locale());    client.beginFile();    MediaScanResult result = processFileInternal(path, mimeType, client);    client.endFile();    return result;}

主要行为在processFileInternal()里：
【frameworks/av/media/libstagefright/StagefrightMediaScanner.cpp】

MediaScanResult StagefrightMediaScanner::processFileInternal(        const char *path, const char * /* mimeType */,        MediaScannerClient &client) {    const char *extension = strrchr(path, '.');    . . . . . .    if (!FileHasAcceptableExtension(extension)) {        return MEDIA_SCAN_RESULT_SKIPPED;    }    if (!strcasecmp(extension, ".mid")            || !strcasecmp(extension, ".smf")            || !strcasecmp(extension, ".imy")            . . . . . .        return HandleMIDI(path, &client);    }    sp<MediaMetadataRetriever> mRetriever(new MediaMetadataRetriever);    int fd = open(path, O_RDONLY | O_LARGEFILE);    . . . . . .        status = mRetriever->setDataSource(fd, 0, 0x7ffffffffffffffL);        close(fd);    . . . . . .    const char *value;    if ((value = mRetriever->extractMetadata(                    METADATA_KEY_MIMETYPE)) != NULL) {        status = client.setMimeType(value);        . . . . . .    }    struct KeyMap {        const char *tag;        int key;    };    static const KeyMap kKeyMap[] = {        { "tracknumber", METADATA_KEY_CD_TRACK_NUMBER },        { "discnumber", METADATA_KEY_DISC_NUMBER },        { "album", METADATA_KEY_ALBUM },        { "artist", METADATA_KEY_ARTIST },        . . . . . .    };    static const size_t kNumEntries = sizeof(kKeyMap) / sizeof(kKeyMap[0]);    for (size_t i = 0; i < kNumEntries; ++i) {        const char *value;        if ((value = mRetriever->extractMetadata(kKeyMap[i].key)) != NULL) {            status = client.addStringTag(kKeyMap[i].tag, value);            . . . . . .        }    }    return MEDIA_SCAN_RESULT_OK;}

可以看到，processFileInternal()里扫描具体文件的大体流程，无非是先获取多媒体文件的元数据，然后再通过MyMediaScannerClient将元数据信息从C++层传递到Java层。

processFileInternal()里的主要细节有：

调用FileHasAcceptableExtension()函数，看看文件的扩展名是不是属于多媒体文件扩展名，合适的扩展名有：
【frameworks/av/media/libstagefright/StagefrightMediaScanner.cpp】

static bool FileHasAcceptableExtension(const char *extension) {    static const char *kValidExtensions[] = {        ".mp3", ".mp4", ".m4a", ".3gp", ".3gpp", ".3g2", ".3gpp2",        ".mpeg", ".ogg", ".mid", ".smf", ".imy", ".wma", ".aac",        ".wav", ".amr", ".midi", ".xmf", ".rtttl", ".rtx", ".ota",        ".mkv", ".mka", ".webm", ".ts", ".fl", ".flac", ".mxmf",        ".avi", ".mpeg", ".mpg", ".awb", ".mpga"    };    . . . . . .}

如果扩展名不合适，则直接return MEDIA_SCAN_RESULT_SKIPPED。

看看文件是不是midi文件，如果是midi文件，则以HandleMIDI()来处理。
【frameworks/av/media/libstagefright/StagefrightMediaScanner.cpp】

    if (!strcasecmp(extension, ".mid")            || !strcasecmp(extension, ".smf")            || !strcasecmp(extension, ".imy")            || !strcasecmp(extension, ".midi")            || !strcasecmp(extension, ".xmf")            || !strcasecmp(extension, ".rtttl")            || !strcasecmp(extension, ".rtx")            || !strcasecmp(extension, ".ota")            || !strcasecmp(extension, ".mxmf")) {        return HandleMIDI(path, &client);    }

从HandleMIDI()的代码看，要解析并提取midi文件的元数据，需要用到一种EAS引擎，利用EAS_ParseMetaData()解析出时长信息。并调用MyMediaScannerClient的addStringTag()。

如果是其他支持的多媒体文件，则利用工具类MediaMetadataRetriever来获取文件的元数据，并将得到的元数据传递给MyMediaScannerClient。其实MediaMetadataRetriever内部是利用系统服务“media.player”来解析多媒体文件的，这个系统服务对应的代理接口是IMediaPlayerService，它有个成员函数createMetadataRetriever()可以用于获取IMediaMetadataRetriever接口，而后就可以调用该接口的setDataSource()和extractMetadata()了。


processFileInternal()里主要通过两个函数，向Java层的MyMediaScannerClient传递数据，一个是setMimeType()，另一个是addStringTag()。以C++层的setMimeType()为例，其代码如下：
【frameworks/base/media/jni/android_media_MediaScanner.cpp】

virtual status_t setMimeType(const char* mimeType){    ALOGV("setMimeType: %s", mimeType);    jstring mimeTypeStr;    if ((mimeTypeStr = mEnv->NewStringUTF(mimeType)) == NULL) {        mEnv->ExceptionClear();        return NO_MEMORY;    }    mEnv->CallVoidMethod(mClient, mSetMimeTypeMethodID, mimeTypeStr);    mEnv->DeleteLocalRef(mimeTypeStr);    return checkAndClearExceptionFromCallback(mEnv, "setMimeType");}

基本上只是通过JNI技术，调用到Java层的setMimeType()而已。

现在我们画一张关于扫描文件的简单示意图，来整理一下思路。大家顺着箭头看图就可以了。

2.3.4.2 processDirectory()

按理说，和processFile()类似，processDirectory()最终对应的代码也应该在StagefrightMediaScanner里，但是StagefrightMediaScanner并没有编写这个函数，又因为StagefrightMediaScanner继承于MediaScanner（C++层次），所以实际上使用的是MediaScanner的ProcessDirectory()
【frameworks/av/media/libmedia/MediaScanner.cpp】

MediaScanResult MediaScanner::processDirectory(        const char *path, MediaScannerClient &client) {    int pathLength = strlen(path);    . . . . . .    char* pathBuffer = (char *)malloc(PATH_MAX + 1);    . . . . . .    strcpy(pathBuffer, path);    . . . . . .    client.setLocale(locale());    MediaScanResult result = doProcessDirectory(pathBuffer, pathRemaining, client, false);    free(pathBuffer);    return result;}

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

MediaScanResult MediaScanner::doProcessDirectory(char *path, int pathRemaining,                                                  MediaScannerClient &client, bool noMedia) {    char* fileSpot = path + strlen(path);    struct dirent* entry;    if (shouldSkipDirectory(path)) {        . . . . . .        return MEDIA_SCAN_RESULT_OK;    }    // Treat all files as non-media in directories that contain a  ".nomedia" file    if (pathRemaining >= 8 /* strlen(".nomedia") */ ) {        strcpy(fileSpot, ".nomedia");        if (access(path, F_OK) == 0) {            ALOGV("found .nomedia, setting noMedia flag");            noMedia = true;        }        . . . . . .    }    DIR* dir = opendir(path);    . . . . . .    MediaScanResult result = MEDIA_SCAN_RESULT_OK;    while ((entry = readdir(dir))) {        if (doProcessDirectoryEntry(path, pathRemaining, client, noMedia, entry, fileSpot)                == MEDIA_SCAN_RESULT_ERROR) {            result = MEDIA_SCAN_RESULT_ERROR;            break;        }    }    closedir(dir);    return result;}

doProcessDirectory()先判断需要扫描的目录是不是应该“跳过”的目录，如果是的话，则直接return MEDIA_SCAN_RESULT_OK。判断函数shouldSkipDirectory()的代码如下：
【frameworks/av/media/libmedia/MediaScanner.cpp】

bool MediaScanner::shouldSkipDirectory(char *path) {    if (path && mSkipList && mSkipIndex) {        int len = strlen(path);        int idx = 0;        int startPos = 0;        while (mSkipIndex[idx] != -1) {            if ((len == mSkipIndex[idx])                && (strncmp(path, &mSkipList[startPos], len) == 0)) {                return true;            }            startPos += mSkipIndex[idx] + 1; // extra char for the delimiter            idx++;        }    }    return false;}

其实就是比对一下“需要扫描的目录”是否存在于mSkipList列表中。这个列表的内容其实来自于“testing.mediascanner.skiplist”属性，该属性可以记录若干目录名，目录名之间以逗号分隔。在C++层的MediaScanner构造函数中，会调用loadSkipList()来读取这个属性，解析属性中记录的所有目录名并写入mSkipList列表。

接着doProcessDirectory()用一个while循环多次调用doProcessDirectoryEntry()，其内部在必要时候，会再次调用doProcessDirectory()分析子目录。while语句的循环判断部分用到了readdir()函数，readdir()是linux上返回所指目录中“下一个进入点”（next entry）的函数，我们常常在一个while循环中调用它，以便遍历出目录中的所有内容。

doProcessDirectoryEntry()函数的定义截选如下：
【frameworks/av/media/libmedia/MediaScanner.cpp】

MediaScanResult MediaScanner::doProcessDirectoryEntry(        char *path, int pathRemaining, MediaScannerClient &client, bool noMedia,        struct dirent* entry, char* fileSpot) {    struct stat statbuf;    const char* name = entry->d_name;    . . . . . .    int type = entry->d_type;    . . . . . .    if (type == DT_DIR) {   // 普通目录        . . . . . .        if (stat(path, &statbuf) == 0) {            status_t status = client.scanFile(path, statbuf.st_mtime, 0,                    true /*isDirectory*/, childNoMedia);            . . . . . .        }        // and now process its contents        strcat(fileSpot, "/");        MediaScanResult result = doProcessDirectory(path, pathRemaining - nameLength - 1,                client, childNoMedia);        . . . . . .    } else if (type == DT_REG) {    // 普通文件        stat(path, &statbuf);        status_t status = client.scanFile(path, statbuf.st_mtime, statbuf.st_size,                false /*isDirectory*/, noMedia);        . . . . . .    }    return MEDIA_SCAN_RESULT_OK;}

不管当前处理的入口类型是“目录”还是“文件”，最终都是依靠client的scanFile()来处理，只不过前者倒数第二个参数（isDirectory）为true，后者为false而已。

client.scanFile()最终也是要调回到Java层的，MyMediaScannerClient的scanFile()代码截选如下：
【frameworks/base/media/jni/android_media_MediaScanner.cpp】

virtual status_t scanFile(const char* path, long long lastModified,        long long fileSize, bool isDirectory, bool noMedia){    . . . . . .    jstring pathStr;    if ((pathStr = mEnv->NewStringUTF(path)) == NULL) {        mEnv->ExceptionClear();        return NO_MEMORY;    }    mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified,            fileSize, isDirectory, noMedia);    mEnv->DeleteLocalRef(pathStr);    return checkAndClearExceptionFromCallback(mEnv, "scanFile");}

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

@Overridepublic void scanFile(String path, long lastModified, long fileSize,        boolean isDirectory, boolean noMedia) {    doScanFile(path, null, lastModified, fileSize, isDirectory, false, noMedia);}

调用到doScanFile()函数。

现在我们再画一张关于扫描目录的简单示意图：

2.3.4.3 doScanFile()和MediaProvider

站在Java层次来看，不管是扫描具体的文件，还是扫描一个目录，最终都会走到Java层MyMediaScannerClient的doScanFile()。在前文我们已经列出过这个函数的代码，为了说明问题，这里再列一下其中的重要句子：
【frameworks/base/media/java/android/media/MediaScanner.java】

public Uri doScanFile(String path, String mimeType, long lastModified,        long fileSize, boolean isDirectory, boolean scanAlways, boolean noMedia) {    . . . . . .        FileEntry entry = beginFile(path, mimeType, lastModified,                fileSize, isDirectory, noMedia);        . . . . . .                if (isaudio || isvideo) {                    processFile(path, mimeType, this);                }                if (isimage) {                    processImageFile(path);                }                result = endFile(entry, ringtones, notifications, alarms, music, podcasts);    . . . . . .    return result;}

本小节着重看一下其中和MediaProvider相关的beginFile()和endFile()。

beginFile()是为了后续和MediaProvider打交道，准备一个FileEntry。FileEntry的定义如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

private static class FileEntry {    long mRowId;    String mPath;    long mLastModified;    int mFormat;    boolean mLastModifiedChanged;    FileEntry(long rowId, String path, long lastModified, int format) {        mRowId = rowId;        mPath = path;        mLastModified = lastModified;        mFormat = format;        mLastModifiedChanged = false;    }    . . . . . .}

FileEntry的几个成员变量，其实体现了查表时的若干列的值。

beginFile()的代码截选如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

public FileEntry beginFile(String path, String mimeType, long lastModified,        long fileSize, boolean isDirectory, boolean noMedia) {    . . . . . .    FileEntry entry = makeEntryFor(path);   // 从MediaProvider中查出该文件或目录对应的入口    . . . . . .    if (entry == null || wasModified) {        if (wasModified) {            entry.mLastModified = lastModified;        } else {            // 如果前面没查到FileEntry，就在这里new一个新的FileEntry            entry = new FileEntry(0, path, lastModified,                    (isDirectory ? MtpConstants.FORMAT_ASSOCIATION : 0));        }        entry.mLastModifiedChanged = true;    }    . . . . . .    return entry;}

其中调用的makeEntryFor()内部就会查询MediaProvider：

FileEntry makeEntryFor(String path) {    String where;    String[] selectionArgs;    Cursor c = null;    try {        where = Files.FileColumns.DATA + "=?";        selectionArgs = new String[] { path };        c = mMediaProvider.query(mPackageName, mFilesUriNoNotify,                                       FILES_PRESCAN_PROJECTION,                                      where, selectionArgs, null, null);        if (c.moveToFirst()) {            long rowId = c.getLong(FILES_PRESCAN_ID_COLUMN_INDEX);            int format = c.getInt(FILES_PRESCAN_FORMAT_COLUMN_INDEX);            long lastModified = c.getLong(FILES_PRESCAN_DATE_MODIFIED_COLUMN_INDEX);            return new FileEntry(rowId, path, lastModified, format);        }    } catch (RemoteException e) {    } finally {        if (c != null) {            c.close();        }    }    return null;}

查询语句中用的FILES_PRESCAN_PROJECTION的定义如下：

    private static final String[] FILES_PRESCAN_PROJECTION = new String[] {            Files.FileColumns._ID, // 0            Files.FileColumns.DATA, // 1            Files.FileColumns.FORMAT, // 2            Files.FileColumns.DATE_MODIFIED, // 3    };

看到了吗，特意要去查一下MediaProvider中记录的待查文件的最后修改日期。能查到就返回一个FileEntry，如果查询时出现异常就返回null。beginFile()的lastModified参数可以理解为是从文件系统里拿到的待查文件的最后修改日期，它应该是最准确的。而MediaProvider里记录的信息则有可能“较老”。beginFile()内部通过比对这两个“最后修改日期”，就可以知道该文件是不是真的改动了。如果的确改动了，就要把FileEntry里的mLastModified调整成最新数据。

基本上而言，beginFile()会返回一个FileEntry。如果该阶段没能在MediaProvider里找到文件对应的记录，那么FileEntry对象的mRowId会为0，而如果找到了，则为非0值。

与beginFile()相对的，就是endFile()了。endFile()是真正向MediaProvider数据库插入数据或更新数据的地方。当FileEntry的mRowId为0时，会考虑调用：

result = mMediaProvider.insert(mPackageName, tableUri, values);

而当mRowId为非0值时，则会考虑调用：

mMediaProvider.update(mPackageName, result, values, null, null);

这就是改变MediaProvider中相关信息的最核心句子啦。

endFile()的代码截选如下：
【frameworks/base/media/java/android/media/MediaScanner.java】

private Uri endFile(FileEntry entry, boolean ringtones, boolean notifications,        boolean alarms, boolean music, boolean podcasts)        throws RemoteException {    . . . . . .    ContentValues values = toValues();    String title = values.getAsString(MediaStore.MediaColumns.TITLE);    if (title == null || TextUtils.isEmpty(title.trim())) {        title = MediaFile.getFileTitle(values.getAsString(MediaStore.MediaColumns.DATA));        values.put(MediaStore.MediaColumns.TITLE, title);    }    . . . . . .    long rowId = entry.mRowId;    if (MediaFile.isAudioFileType(mFileType) && (rowId == 0 || mMtpObjectHandle != 0)) {        . . . . . .        values.put(Audio.Media.IS_ALARM, alarms);        values.put(Audio.Media.IS_MUSIC, music);        values.put(Audio.Media.IS_PODCAST, podcasts);    } else if (mFileType == MediaFile.FILE_TYPE_JPEG && !mNoMedia) {        . . . . . .    }    . . . . . .    if (rowId == 0) {        . . . . . .        // 扫描的是新文件，insert记录。如果是目录的话，必须比它所含有的所有文件更早插入记录，        // 所以在批量插入时，就需要有更高的优先权。如果是文件的话，而且我们现在就需要其对应        // 的rowId，那么应该立即进行插入，此时不过多考虑批量插入。        if (inserter == null || needToSetSettings) {            if (inserter != null) {                inserter.flushAll();            }            result = mMediaProvider.insert(mPackageName, tableUri, values);        } else if (entry.mFormat == MtpConstants.FORMAT_ASSOCIATION) {            inserter.insertwithPriority(tableUri, values);        } else {            inserter.insert(tableUri, values);        }        if (result != null) {            rowId = ContentUris.parseId(result);            entry.mRowId = rowId;        }    } else {        . . . . . .        mMediaProvider.update(mPackageName, result, values, null, null);    }    . . . . . .    return result;}

除了直接调用mMediaProvider.insert()向MediaProvider中写入数据，函数中还有一种方式是经由inserter对象，其类型为MediaInserter。

MediaInserter也是向MediaProvider中写入数据，最终大体上会走到其flush()函数，该函数的代码如下：
【frameworks/base/media/java/android/media/MediaInserter.java】

    private void flush(Uri tableUri, List<ContentValues> list) throws RemoteException {        if (!list.isEmpty()) {            ContentValues[] valuesArray = new ContentValues[list.size()];            valuesArray = list.toArray(valuesArray);            mProvider.bulkInsert(mPackageName, tableUri, valuesArray);            list.clear();        }    }

3 小节

写了这么多，终于看到MediaScannerService是如何更新MediaProvider的了。当然，里面还有大量的细节，本文就不展开来讲了，要不然相信大家头壳都得炸掉。那么就先写这么多了。