Android 之MediaScanner流程解析

浏览数：270 / 时间：2015年06月11日

MediaScanner详解

OK, 我们现在开始来大概分析一下android framework中MediaScanner部分的流程，若大家发现分析过程中有错误，欢迎拍砖指正。

分析流程之前，我们先给自己定个要用MediaScanner解决的问题，这样我们才会有目标感，才知道我们要干什么。否则，干巴巴的分析流程，一般都会很容易的迷失在各种code的迷雾中。

我们这里要定的目标是：获取某个MP3文件的artist & album。

我们可以假定，现在有个媒体播放器，在播放music的时候，需要在UI上显示出来artist& album.

从UI的角度来说，android提供了两套可以获取mediaInfo的方法：

1. 通过MediaScanner Scan文件后，从DB中查询相关信息；

2. 直接通过android提供的MediaMetadataRetriever类来获取相关信息，基本用法如下：

public void getMetaData(String filePath) {

String title, album,artist, composer, genre, mime;

MediaMetadataRetriever retriever =newMediaMetadataRetriever();

retriever.setDataSource(filePath);

title =retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_TITLE);

album =retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ALBUM);

artist =retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_ARTIST);

composer =retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_COMPOSER);

genre =retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_GENRE);

mime =retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_MIMETYPE);

Log.i(TAG, “title=” +title + “,album=” + album + “,artist=” + artist + “,composer=” + composer +“,genre=” + genre + “,mime=” + mime);

}

既然我们现在要说的是MediaScanner，那自然我们要介绍的是通过第一种方法获取相关信息的流程了。

OverView

我们这里会分为3个层次来详细解读一下MediaScanner的工作流程：

1. UI APK调用的接口；

2. Java层调用flow；

3. Native层调用flow；

UI调用接口

现在我们的目标是获取某个MP3文件的artist& album，因此自然需要分为两步：

1. Scan media file

2. Query data

1. Scan Media File

public void scanfile(path)

{

String[] paths = new String[1];

//设置需要扫描的文件路径，这里path就是我们所要扫描的music file的路径

paths[0] = path;

// 调用MediaScannerConnection的scanFile，进行扫描。

//scanFile的第三个参数是mimeTypes,若为null，则会根据文件后缀来判断。

//scanCb是MediaScannerConnection.OnScanCompletedListener

MediaScannerConnection.scanFile(this.context, paths, null, scanCb);

}

2. Query data

Scan完成之后，就可以在DB中查询相关的audio信息。

private void getInfo()

{

String[] colume = { "_id", "album_id", "title", "artist", "album", "year", "duration", "_size", "_data" };

StringBuilder localStringBuilder = new StringBuilder();

localStringBuilder.append("_data");

localStringBuilder.append(" LIKE ‘%");

localStringBuilder.append(musicUtils.convertToQueryString(this.mPath));

localStringBuilder.append("%‘");

localStringBuilder.append(" ESCAPE ‘\\‘");

/*colume是要选择的列，localStringBuilder是选择的条件，MediaStore.Audio.Media.EXTERNAL_CONTENT_URI是要查询的URI*/

Cursor localCursor =query(this.context, MediaStore.Audio.Media.EXTERNAL_CONTENT_URI, colume, localStringBuilder.toString(), null, null);

if (localCursor != null);

try

{

//查询到的结果会存储在localCursor中，随后可从localCursor中获取相关信息

if (localCursor.moveToFirst())

{

mSongId = localCursor.getLong(0);

mAlbumId = localCursor.getLong(1);

mTitle = localCursor.getString(2);

mSonger = localCursor.getString(3);

mAlbum = localCursor.getString(4);

mReleaseYear = localCursor.getInt(5);

mDuration = localCursor.getLong(6);

mSize = localCursor.getLong(7);

mDataPath = localCursor.getString(8);

}

catch (RuntimeException localRuntimeException)

{

}

finally

{

if (localCursor != null)

localCursor.close();

}

这里查询的URI为MediaStore.Audio.Media.EXTERNAL_CONTENT_URI，对应的db存储的路径为/data/data/com.android.providers.media/external.db。可用SQLiteSpy查看此DB的内容。

至此从UI的角度来看，已经完成了获取mp3文件info的任务。

Java层MediaScanflow

我们这里主要分析Scanfile的流程，不再对查询信息的流程进行解析。

OK，先看java层的时序图：

MediaScannerClient主要用途是给app提供一个和MediaScannerService交互的桥梁。App可以通过MediaScannerClient给MediaScanenrService传递需要scan的文件。Mediascanner service会对传入的文件进行scan，读取metadata，并将文件添加进mediacontent provider。MediaScannerConnectionClient也为mediascanner service提供了一个返回最近被scan的文件的Uri。

MediaScannerService类其实起到的主要作用就是创建出来MediaScanner，之后调用MediaScanner的ScanFile接口进行工作，最终做具体工作的其实是MediaScanner和MyMediaScannerClient。

下面我们从头追一下code。

Scan动作的发起者是MediaScannerConnection.

Code位于\frameworks\base\media\java\android\media\MediaScannerConnection.java:

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;

//scanFile函数只是调用了一下MediaScannerConnection的connect()函数。

connection.connect();

}

MediaScannerConnection中有两个名叫scanFile的函数，不过一个是public static的，另外一个则是普通的private函数。Static修饰的scanFile是对UI的接口。通过上面的code可以看出，其实scanFile并未做任何scan的动作，只是new了一个MediaScannerConnection，调用了一下它的connect()函数。

我们再来看一下MediaScannerConnection的connect()函数：

public void connect() {

synchronized (this) {

if (!mConnected) {

Intent intent = new Intent(IMediaScannerService.class.getName());

mContext.bindService(intent, this, Context.BIND_AUTO_CREATE);

mConnected = true;

}

当Service绑定之后，会触发MediaScannerConnection的onServiceConnected函数，而在这个函数中，又调用了ClientProxy的onMediaScannerConnected函数（ClientProxy继承自MediaScannerConnectionClient，ClientProxy是在调用MediaScannerConnection的scanFile函数时new 出来的，大家可以回过头看看前面的scanFile函数）,在onMediaScannerConnected中，会调用ClientProxy的scanNextPath()，scanNextPath()中会调用MediaScannerConnection的scanFile()【注意，这里的scanFile就是我们之前提到过的privatescanFile】。scanFile()中会调用到IMediaScannerService的requestScanFile。在requestScanFile中则会启动MediaScannerService.这部分代码比较简单，就不一一列举出来了。

到现在为止，看看我们有什么了。从scanFile开始一直到requestScanFile，我们最终启动了MediaScannerService。那么下面的任务就交给MediaScannerService来完成了。

MediaScannerService

MediaScannerService.java在packages\providers\MediaProvider\src\com\android\providers\media目录下。

在MediaScannerService启动的时候会new一个Looper，在Looper中又new了一个ServiceHandler。

下来我们看一下MediaScannerService的onStartCommand

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

{

while (mServiceHandler == null) {

synchronized (this) {

try {

wait(100);

} catch (InterruptedException e) {

}

if (intent == null) {

Log.e(TAG, "Intent is null in onStartCommand: ",

new NullPointerException());

return Service.START_NOT_STICKY;

}

Message msg = mServiceHandler.obtainMessage();

msg.arg1 = startId;

msg.obj = intent.getExtras();

//此处给mServiceHandler发送了一个消息，其handlerMessage会收到这个消息。

mServiceHandler.sendMessage(msg);

// Try again later if we are killed before we can finish scanning.

return Service.START_REDELIVER_INTENT;

}

接着看下handlerMessage做了什么事情：

public void handleMessage(Message msg)

{

Bundle arguments = (Bundle) msg.obj;

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

try {

//我们传入了MP3文件路径，所以会走这个分支

if (filePath != null) {

IBinder binder = arguments.getIBinder("listener");

IMediaScannerListener listener =

(binder == null ? null : IMediaScannerListener.Stub.asInterface(binder));

Uri uri = null;

try {

//这里才开始了scanFile的流程。此时传入的mimetype为null.

uri = scanFile(filePath, arguments.getString("mimetype"));

} catch (Exception e) {

Log.e(TAG, "Exception scanning file", e);

}

if (listener != null) {

//scan 完成之后，通知listener

listener.scanCompleted(filePath, uri);

}

} else {

……

}

} catch (Exception e) {

Log.e(TAG, "Exception in handleMessage", e);

}

stopSelf(msg.arg1);

}

我们来看一下MediaScannerService的scanFile都干了什么。

private Uri scanFile(String path, String mimeType) {

String volumeName = MediaProvider.EXTERNAL_VOLUME;

//打开数据库。这个MediaProvider.EXTERNAL_VOLUME为external。

openDatabase(volumeName);

//创建MediaScanner，并设置其language&country

MediaScanner scanner = createMediaScanner();

try {

// make sure the file path is in canonical form

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;

}

MediaScanner被创建时，先会设置language & country，之后会调用到jni层的接口native_init()& native_setup()，这里最主要的其实是在native_setup中创建native层的MediaScanner。这里我们创建的其实是一个StagefrightMediaScanner。这个我们后面再说。

MediaScanner的scanSingleFile会调用到MyMediaScannerClient(位置也在MediaScaner.java中)doScanFile。

MyMediaScannerClient

几乎所有的事情都是在MyMediaScannerClient中完成的。

public Uri doScanFile(String path, String mimeType, long lastModified,

long fileSize, boolean isDirectory, boolean scanAlways, boolean noMedia) {

Uri result = null;

……

boolean isaudio = MediaFile.isAudioFileType(mFileType);

boolean isvideo = MediaFile.isVideoFileType(mFileType);

boolean isimage = MediaFile.isImageFileType(mFileType);

……

// we only extract metadata for audio and video files

if (isaudio || isvideo) {

/*processFile是一个native方法，最终实现的地方在native层的StagefrightMediaScanner中,获取media file的metadata，都是在这个函数中完成的*/

processFile(path, mimeType, this);

}

if (isimage) {

processImageFile(path);

}

/*获取到的Metadata存入db，是由endFile完成的。*/

result = endFile(entry, ringtones, notifications, alarms, music, podcasts);

……

return result;

}

获取到的metaData会被暂时保存在MyMediaScannerClient的成员变量中，之后通过endFile，将这些成员变量的值通过MediaProvider存入DB中。

这里还要提到一个函数：MyMediaScannerClient的handleStringTag():

public void handleStringTag(String name, String value) {

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

// Don‘t trim() here, to preserve the special \001 character

// used to force sorting. The media provider will trim() before

// inserting the title in to the database.

mTitle = value;

} else if (name.equalsIgnoreCase("artist") || name.startsWith("artist;")) {

mArtist = value.trim();

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

|| name.equalsIgnoreCase("band") || name.startsWith("band;")) {

mAlbumArtist = value.trim();

} else if (name.equalsIgnoreCase("album") || name.startsWith("album;")) {

mAlbum = value.trim();

} else if (name.equalsIgnoreCase("composer") || name.startsWith("composer;")) {

mComposer = value.trim();

} else if (mProcessGenres &&

(name.equalsIgnoreCase("genre") || name.startsWith("genre;"))) {

mGenre = getGenreName(value);

} else if (name.equalsIgnoreCase("year") || name.startsWith("year;")) {

mYear = parseSubstring(value, 0, 0);

} else if (name.equalsIgnoreCase("tracknumber") || name.startsWith("tracknumber;")) {

// track number might be of the form "2/12"

// we just read the number before the slash

int num = parseSubstring(value, 0, 0);

mTrack = (mTrack / 1000) * 1000 + num;

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

name.equals("set") || name.startsWith("set;")) {

// set number might be of the form "1/3"

// we just read the number before the slash

int num = parseSubstring(value, 0, 0);

mTrack = (num * 1000) + (mTrack % 1000);

} else if (name.equalsIgnoreCase("duration")) {

mDuration = parseSubstring(value, 0, 0);

} else if (name.equalsIgnoreCase("writer") || name.startsWith("writer;")) {

mWriter = value.trim();

} else if (name.equalsIgnoreCase("compilation")) {

mCompilation = parseSubstring(value, 0, 0);

} else if (name.equalsIgnoreCase("isdrm")) {

mIsDrm = (parseSubstring(value, 0, 0) == 1);

} else if (name.equalsIgnoreCase("width")) {

mWidth = parseSubstring(value, 0, 0);

} else if (name.equalsIgnoreCase("height")) {

mHeight = parseSubstring(value, 0, 0);

} else {

//Log.v(TAG, "unknown tag: " + name + " (" + mProcessGenres + ")");

}

此函数最终调用的地方，其实是通过JNI被native层的MediaScannerClient的endfile调用。用来将通过MediaMetadataRetriever获取到的metadata，送给java层MyMediaScannerClient的成员变量中。

至此，java层MediaScan的流程就算全部结束了。

Native 层MediaScanner flow

废话不多说，先上时序图:

在上一节我们提到过在MyMediaScannerClient的doScanFile中，会调用到一个native层的函数processFile.

这个processFile实现的地方在StagefrightMediaScanner类中。位置在：frameworks\av\media\libstagefright\StagefrightMediaScanner.cpp中。

MediaScanResult StagefrightMediaScanner::processFile(

const char *path, const char *mimeType,

MediaScannerClient &client) {

ALOGV("processFile ‘%s‘.", path);

//设置mLocaleEncoding，此变量用以在endfile中判断编码格式。

client.setLocale(locale());

//beginFile很简单，就是new了两个buffer，用以存放metadata的名称和值

client.beginFile();

/*processFileInternal中通过MediaMetadataRetriever，来获取到metadata，并将其一一对应的放入在beginFile中new出来的两个buffer(mNames&mValues)之中。*/

MediaScanResult result = processFileInternal(path, mimeType, client);

/*endFile中将得到的metadata，先转码成UTF8，之后通过JNI调用到java层handleStringTag函数，将metadata相关信息保存到MyMediaScannerClient的成员变量中，前面已经有提到过了*/

client.endFile();

return result;

}

我们来看一下processFileInternal：

MediaScanResult StagefrightMediaScanner::processFileInternal(

const char *path, const char *mimeType,

MediaScannerClient &client) {

……

sp<MediaMetadataRetriever> mRetriever(new MediaMetadataRetriever);

int fd = open(path, O_RDONLY | O_LARGEFILE);

status_t status;

//1. 通过MediaMetadataRetriever，setDataSource

if (fd < 0) {

// couldn‘t open it locally, maybe the media server can?

status = mRetriever->setDataSource(path);

} else {

status = mRetriever->setDataSource(fd, 0, 0x7ffffffffffffffL);

close(fd);

}

if (status) {

return MEDIA_SCAN_RESULT_ERROR;

}

const char *value;

if ((value = mRetriever->extractMetadata(

METADATA_KEY_MIMETYPE)) != NULL) {

status = client.setMimeType(value);

if (status) {

return MEDIA_SCAN_RESULT_ERROR;

}

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 },

{ "albumartist", METADATA_KEY_ALBUMARTIST },

{ "composer", METADATA_KEY_COMPOSER },

{ "genre", METADATA_KEY_GENRE },

{ "title", METADATA_KEY_TITLE },

{ "year", METADATA_KEY_YEAR },

{ "duration", METADATA_KEY_DURATION },

{ "writer", METADATA_KEY_WRITER },

{ "compilation", METADATA_KEY_COMPILATION },

{ "isdrm", METADATA_KEY_IS_DRM },

{ "width", METADATA_KEY_VIDEO_WIDTH },

{ "height", METADATA_KEY_VIDEO_HEIGHT },

};

static const size_t kNumEntries = sizeof(kKeyMap) / sizeof(kKeyMap[0]);

for (size_t i = 0; i < kNumEntries; ++i) {

const char *value;

//2. 通过extractMetadata获取相关key的值

if ((value = mRetriever->extractMetadata(kKeyMap[i].key)) != NULL) {

// 3. 存值。将获取到的值添加进在begin中new出来的buffer中

status = client.addStringTag(kKeyMap[i].tag, value);

if (status != OK) {

return MEDIA_SCAN_RESULT_ERROR;

}

return MEDIA_SCAN_RESULT_OK;

}

至此，metadata就已经保存在了native层MediaScannerClient的mNames和mValues中。

接下来我们看一下MediaScannerClient的endFile。

此endFile的主要作用有两个：

1. 将mValues中的值转成UTF8格式；

2. 将转码后的值，通过JNI保存到java层的MyMediaScannerClient中

void MediaScannerClient::endFile()

{

if (mLocaleEncoding != kEncodingNone) {

int size = mNames->size();

uint32_t encoding = kEncodingAll;

//获取mValues中各个值可能的编码格式

for (int i = 0; i < mNames->size(); i++) {

encoding &= possibleEncodings(mValues->getEntry(i));

}

// if the locale encoding matches, then assume we have a native encoding.

//转码成UTF8

if (encoding & mLocaleEncoding)

convertValues(mLocaleEncoding);

// finally, push all name/value pairs to the client

for (int i = 0; i < mNames->size(); i++) {

//将转码后的value值存放至java层的MyMediaScannerClient中。

/* handleStringTag函数是通过JNI调用到java层的。有兴趣追一下此函数的话，可以看一下android_media_MediaScanner.cpp文件。此函数最终实现的地方在MediaScaner.java的MyMediaScannerClient类中，前面已经将此函数code列出来了，此处不再做过多解释*/

status_t status = handleStringTag(mNames->getEntry(i), mValues->getEntry(i));

if (status) {

break;

}

// else addStringTag() has done all the work so we have nothing to do

delete mNames;

delete mValues;

mNames = NULL;

mValues = NULL;

}

OK,到这里，MediaScanner的所有流程就已经走完了。

我们再过来回过头整理一下scanfile的几个重要地方：