伴随着Android的成长，多媒体系统也发生了非常大的变化。这对开发人员来说，一个非常好的消息。就是从Android 2.3開始那个令人极度郁闷的OpenCore，终于有被干掉的可能了。

从此。也迎来了Stagefright时代。

但Android 2.2在非常长一段时间内还会存在，所以希望以后能有机会深入地剖析这个OpenCore。

application android:process=android.process.media

除了支持通过广播发送扫描请求外。MediaScannerService也支持利用Binder机制跨进程调用扫描函数。

这部分内容。将在本章的拓展部分中介绍。

public class MediaScannerReceiver extendsBroadcastReceiver

{

private final static String TAG ="MediaScannerReceiver";

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

publicvoid onReceive(Context context, Intent intent) {

String action = intent.getAction();

Uri uri = intent.getData();

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

String externalStoragePath =

Environment.getExternalStorageDirectory().getPath();

//为了简化书写。全部Intent的ACTION_XXX_YYY字串都会简写为XXX_YYY。

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

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

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

scan(context, MediaProvider.INTERNAL_VOLUME);

}else {

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

String path = uri.getPath();

/*

注意以下这个推断，假设收到MEDIA_MOUNTED消息。而且外部存储挂载的路径

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

*/

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

externalStoragePath.equals(path)) {

scan(context,MediaProvider.EXTERNAL_VOLUME);

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

&& path != null

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

/*

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

的扫描工作。

注意这个文件必须位于SD卡上。

*/

scanFile(context, path);

}

}

}

}

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

private void scan(Context context, Stringvolume) {

//volume的值为/mnt/sdcard

Bundleargs = new Bundle();

args.putString("volume", volume);

//启动MSS。

context.startService(

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

}

MediaScannerService extends Service implementsRunnable

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

public void onCreate(){

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

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

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

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

//MSS实现的Run函数

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

thr.start();

|

publicvoid run()

{

/*

设置本线程的优先级，这个函数的调用有非常关键的数据，由于媒体扫描可能会耗费非常长

时间，假设不调低优先级的话。CPU将一直被MSS占用，导致用户感觉系统变得非常慢

*/

Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +

Process.THREAD_PRIORITY_LESS_FAVORABLE);

Looper.prepare();

mServiceLooper = Looper.myLooper();

/*

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

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

*/

mServiceHandler = new ServiceHandler();

Looper.loop();

}

context.startService(

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

@Override

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

{

/*

等待mServiceHandler被创建。

耕耘这段代码的码农难道不知道

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

*/

while(mServiceHandler == null) {

synchronized (this) {

try {

wait(100);

} catch (InterruptedException e) {

}

}

}

......

Message msg = mServiceHandler.obtainMessage();

msg.arg1 = startId;

msg.obj = intent.getExtras();

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

mServiceHandler.sendMessage(msg);

......

}

private final class ServiceHandler extendsHandler

{

@Override

public void handleMessage(Message msg)

{

Bundle arguments = (Bundle) msg.obj;

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

try {

......

} else {

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

String[] directories =null;

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

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

directories = newString[] {

Environment.getRootDirectory() + "/media",

};

}

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

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

directories = new String[]{

Environment.getExternalStorageDirectory().getPath()};

}

if (directories != null) {

/*

调用scan函数开展目录扫描工作。能够一次为这个函数设置多个目标目录，

只是这里仅仅有/mnt/sdcard一个目录

*/

scan(directories, volume);

......

stopSelf(msg.arg1);

}

}

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

mWakeLock.acquire();

ContentValuesvalues = new ContentValues();

values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);

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

UriscanUri = getContentResolver().insert(

MediaStore.getMediaScannerUri(), values);

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

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

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

try {

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

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

openDatabase(volumeName);

}

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

MediaScanner scanner = createMediaScanner();

scanner.scanDirectories(directories,volumeName);

}

......

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

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

//向系统发送MEDIA_SCANNER_FINISHED广播

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

mWakeLock.release();

}

本章不拟对MediaProvider做过多的讨论。这部分知识对那些读完前9章的读者来说，应该不是什么难题。

如有可能，请读者自己整理MediaProvider的工作流程，然后提供给大家一起学习，探讨。

private MediaScanner createMediaScanner() {

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

MediaScanner scanner = new MediaScanner(this);

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

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

if(locale != null) {

String language = locale.getLanguage();

String country = locale.getCountry();

String localeString = null;

if (language != null) {

if (country != null) {

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

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

} else {

scanner.setLocale(language);

}

}

}

return scanner;

}

public class MediaScanner

{

static {

/*

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

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

*/

System.loadLibrary("media_jni");

native_init();

}

//创建媒体扫描器

public MediaScanner(Context c) {

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

......

}

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

try {

long start = System.currentTimeMillis();

initialize(volumeName);//①初始化

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

long prescan = System.currentTimeMillis();

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

/*

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

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

媒体文件的后缀名。比如.MP3、.MP4等。

mClient为MyMediaScannerClient类型，

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

*/

processDirectory(directories[i], MediaFile.sFileExtensions,

mClient);

}

long scan = System.currentTimeMillis();

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

long end = System.currentTimeMillis();

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

}

private void initialize(String volumeName) {

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

mMediaProvider=

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

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

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

mAudioUri =Audio.Media.getContentUri(volumeName);

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

mVideoUri = Video.Media.getContentUri(volumeName);

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

mImagesUri = Images.Media.getContentUri(volumeName);

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

mThumbsUri = Images.Thumbnails.getContentUri(volumeName);

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

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

mProcessPlaylists = true;

mProcessGenres = true;

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

mGenresUri = Genres.getContentUri(volumeName);

mPlaylistsUri = Playlists.getContentUri(volumeName);

if ( Process.supportsProcesses()) {

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

mCaseInsensitivePaths = true;

}

}

}

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

privatevoid prescan(String filePath) throws RemoteException {

Cursor c = null;

String where = null;

String[] selectionArgs = null;

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

if(mFileCache == null) {

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

}else {

mFileCache.clear();

}

......

try {

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

if (filePath != null) {

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

selectionArgs = new String[] { filePath };

}

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

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

selectionArgs,null);

if (c != null) {

try {

while (c.moveToNext()) {

long rowId =c.getLong(ID_AUDIO_COLUMN_INDEX);

//音频文件的路径

String path =c.getString(PATH_AUDIO_COLUMN_INDEX);

long lastModified =

c.getLong(DATE_MODIFIED_AUDIO_COLUMN_INDEX);

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

String key = path;

if(mCaseInsensitivePaths) {

key =path.toLowerCase();

}

//把文件信息存到mFileCache中

mFileCache.put(key,

new FileCacheEntry(mAudioUri, rowId, path,

lastModified));

}

}

} finally {

c.close();

c = null;

}

}

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

finally {

if (c != null) {

c.close();

}

}

}

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

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

while(iterator.hasNext()) {

FileCacheEntry entry = iterator.next();

String path = entry.mPath;

boolean fileMissing = false;

if (!entry.mSeenInFileSystem) {

if (inScanDirectory(path, directories)) {

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

} else {

File testFile = newFile(path);

if (!testFile.exists()) {

fileMissing = true;

}

}

}

//假设文件确实丢失。则须要把数据库中和它相关的信息删除。

if(fileMissing) {

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

int fileType = (mediaFileType == null ?

0 : mediaFileType.fileType);

if(MediaFile.isPlayListFileType(fileType)) {

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

} else {

/*

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

非常快。

*/

mMediaProvider.delete(ContentUris.withAppendedId(

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

iterator.remove();

}

}

}

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

}

static void

android_media_MediaScanner_native_init(JNIEnv*env)

{

jclass clazz;

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

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

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

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

......

}

android_media_MediaScanner_native_setup(JNIEnv*env, jobject thiz)

{

//创建Native层的MediaScanner对象

MediaScanner*mp = createMediaScanner();

......

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

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

}

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

static MediaScanner *createMediaScanner() {

#if BUILD_WITH_FULL_STAGEFRIGHT

charvalue[PROPERTY_VALUE_MAX];

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

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

return new StagefrightMediaScanner; //使用Stagefright的MS

}

#endif

#ifndef NO_OPENCORE

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

#endif

returnNULL;

}

android_media_MediaScanner_processDirectory(JNIEnv*env, jobject thiz,

jstring path, jstring extensions, jobject client)

{

/*

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

client为Java中的MediaScannerClient对象。

*/

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

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

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

......

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

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

MyMediaScannerClient myClient(env, client);

//调用Native的MS扫描目录，而且把Native的MyMSC传进去。

mp->processDirectory(pathStr,extensionsStr, myClient,

ExceptionCheck, env);

......

env->ReleaseStringUTFChars(path, pathStr);

env->ReleaseStringUTFChars(extensions,extensionsStr);

......

}

status_t MediaScanner::processDirectory(constchar *path,

const char *extensions, MediaScannerClient&client,

ExceptionCheckexceptionCheck, void *exceptionEnv) {

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

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

//调用doProcessDirectory函数扫描目录

status_tresult =  doProcessDirectory(pathBuffer,pathRemaining,

extensions, client,exceptionCheck, exceptionEnv);

free(pathBuffer);

returnresult;

}

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

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

const char *extensions,MediaScannerClient&client,

ExceptionCheck exceptionCheck,void *exceptionEnv) {

......//忽略.nomedia目录

DIR*dir = opendir(path);

......

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

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

const char* name = entry->d_name;

......

int type = entry->d_type;

......

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

int nameLength = strlen(name);

bool isDirectory = (type == DT_DIR);

......

strcpy(fileSpot, name);

if (isDirectory) {

......

//假设是子目录。则递归调用doProcessDirectory

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

extensions, client, exceptionCheck, exceptionEnv);

......

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

//假设该文件是MS支持的类型（依据文件的后缀名来推断）

struct stat statbuf;

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

if (statbuf.st_size > 0) {

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

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

}

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

}

}

}

......

}

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

long long fileSize)

{

jstring pathStr;

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

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

mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr,

lastModified, fileSize);

mEnv->DeleteLocalRef(pathStr);

return (!mEnv->ExceptionCheck());

}

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

......

//调用doScanFile函数

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

}

//直接来看doScanFile函数

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

long fileSize, boolean scanAlways) {

/*

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

发生变化，这时候MS能够不处理这些文件。

假设scanAlways为true，则这些没有变化

的文件也要扫描。

*/

Uriresult = null;

long t1 = System.currentTimeMillis();

try{

/*

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

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

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

做一些处理，以推断这个文件是否在前后两次扫描的这个时间段内被改动。假设有改动，则

须要又一次扫描

*/

FileCacheEntryentry = beginFile(path, mimeType,

lastModified, fileSize);

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

String lowpath = path.toLowerCase();

......

if (!MediaFile.isImageFileType(mFileType)) {

//假设不是图片。则调用processFile进行扫描。而图片不须要扫描就能够处理

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

processFile(path, mimeType, this);

}

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

result = endFile(entry, ringtones, notifications,

alarms, music, podcasts);

}

} ......

return result;

}

上面代码中的beginFile和endFile函数比較简单，读者能够自行研究。

android_media_MediaScanner_processFile(JNIEnv*env, jobject thiz,

jstring path, jstring mimeType, jobject client)

{

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

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

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

MyMediaScannerClient myClient(env, client);

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

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

}

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

MediaScannerClient& client)

{

status_t result;

InitializeForThread();

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

client.setLocale(locale());

/*

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

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

*/

client.beginFile();

......

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

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

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

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

......

}

/*

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

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

只是语言转换向来是个大难题，不能保证全部语言的文字都能相互转换。转换后的每个value都

会调用handleStringTag做兴许处理。

*/

client.endFile();

......

}

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

{

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

在Windows平台上

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

......

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

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

......

}

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

{

if(mLocaleEncoding != kEncodingNone) {

bool nonAscii = false;

const char* chp = value;

char ch;

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

if (ch & 0x80) {

nonAscii = true;

break;

}

}

/*

推断name和value的编码是不是ASCII，假设不是的话则保存到

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

*/

if(nonAscii) {

mNames->push_back(name);

mValues->push_back(value);

return true;

}

}

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

returnhandleStringTag(name, value);

}

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

{

......

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

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

}

publicvoid handleStringTag(String name, String value) {

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

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

mTitle = value;

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

name.startsWith("artist;")) {

mArtist = value.trim();

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

name.startsWith("albumartist;")) {

mAlbumArtist = value.trim();

}

......

}

//前面还有一段话，读者可自行阅读。

以下是流程的文件总结。

* In summary:

* JavaMediaScannerService calls

* JavaMediaScanner scanDirectories, which calls

* JavaMediaScanner processDirectory (native method), which calls

* nativeMediaScanner processDirectory, which calls

* nativeMyMediaScannerClient scanFile, which calls

* JavaMyMediaScannerClient scanFile, which calls

* JavaMediaScannerClient doScanFile, which calls

* JavaMediaScanner processFile (native method), which calls

* nativeMediaScanner processFile, which calls

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

* nativeMyMediaScanner handleStringTag, which calls

* JavaMyMediaScanner handleStringTag.

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

public class MediaScannerConnection implementsServiceConnection {

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

publicinterface OnScanCompletedListener {

public void onScanCompleted(String path, Uri uri);

}

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

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

public interface MediaScannerConnectionClient extends

OnScanCompletedListener {

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

public void onScanCompleted(String path, Uri uri);

}

//构造函数。

publicMediaScannerConnection(Context context,

MediaScannerConnectionClient client);

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

publicvoid connect();

publicvoid disconnect()

//扫描单个文件。

publicvoid scanFile(String path, String mimeType);

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

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

String[] mimeTypes,OnScanCompletedListener callback);

......

}