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()里的主要细节有：
1）调用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。
2）看看文件是不是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()。
3）如果是其他支持的多媒体文件，则利用工具类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的了。当然，里面还有大量的细节，本文就不展开来讲了，要不然相信大家头壳都得炸掉。那么就先写这么多了。
