MediaScannerService研究

Posted 2022-11-27 悠然红茶

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了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】

@Override
public 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()，并进一步发送消息，其函数截选如下：

@Override
public 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】

@Override
public 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广播的地方：

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

利用MediaScannerConnection的地方：

发起方	相关代码位置	说明
AttachmentUtilities	saveAttachment()	代码截选见下文
BeamTransferManager	processFiles()	NFC方面， finishTransfer()、handleMessage()处理MSG_NEXT_TRANSFER_TIMER时，都会调用processFiles()。
BluetoothOppService	MediaScannerNotifier	没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的MediaScannerNotifier
CalendarDebugActivity	doInBackground()	DumpDbTask的doInBackground()，将数据库文件存成calendar.db.zip之后，调用MediaScannerConnection.scanFile()
DownloadScanner	DownloadScanner	没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的DownloadScanner
FmRecorder	addRecordingToDatabase()	MediaScannerConnection.scanFile(context, new String[] mRecordFile.getPath() , null, null);
IngestService	ScannerClient	没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的ScannerClient
MediaProvider	ScannerClient	没有直接使用MediaScannerConnection.scanFile()，而是编写了自己的ScannerClient
VCardService	CustomeMediaScannerConnectionClient	没有直接使用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 void
android_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】

@Override
public 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的了。当然，里面还有大量的细节，本文就不展开来讲了，要不然相信大家头壳都得炸掉。那么就先写这么多了。

以上是关于MediaScannerService研究的主要内容，如果未能解决你的问题，请参考以下文章

转自：Android MediaScanner 详尽分析

买进最佳时间：开盘后15分钟与闭市前15分钟

艺术类的毕业答辩，老师都会问啥问题？

研究调查Masimo PVi(R)能否预测鼻高流量治疗患者的负荷前反应性

从大一到研二，研究生毕业前一年我们订婚了

CGCC2018丨章真教授解读PREACT研究：局部进展期胃癌术前放化疗vs术前化疗