多媒体文件管理，资源的扫描MediaScanner（二）

た入场券 2022-06-05 01:44 211阅读 0赞

多媒体文件的扫描MediaScanner

主要由两部分组成，一是MediaScannerReceiver，一是MediaScannerService，扫描的执行由广播触发。MediaScannerReceiver接收4中类型的广播：

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>

看下执行扫描的具体代码：

Packages/providers/mediaprovider/…/MediaScannerReceiver.java
    public class MediaScannerReceiver extends BroadcastReceiver {
    	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(context, MediaProvider.INTERNAL_VOLUME);
    		scan(context, MediaProvider.EXTERNAL_VOLUME);
    }else{
    	if (uri.getScheme().equals("file")) {
    //获取外部存储设备的路径。
    		String path = uri.getPath();
    		String externalStoragePath = 
    Environment.getExternalStorageDirectory().getPath();
    			String legacyPath = Environment.getLegacyExternalStorageDirectory().getPath();
    			path = new File(path).getCanonicalPath();
    			if (path.startsWith(legacyPath)) {
    				path = externalStoragePath + path.substring(legacyPath.length());
    			}
    }
    //外部存储设备挂载的广播，
    	if (Intent.ACTION_MEDIA_MOUNTED.equals(action)) {
    		scan(context, MediaProvider.EXTERNAL_VOLUME);
    }else if(Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) &&
    path != null && path.startsWith(externalStoragePath + "/")) {
    //扫描特定的文件路径。
    	scanFile(context, path);
    }
    }
    }

不管是调用scan还是scanfile方法，都是调用MediaScannerService来接着处理。

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

接着看MediaScannerService的代码：

MediaScannerService.java

public class MediaScannerService extends Service implements Runnable {
    //首先创建一个唤醒锁，级别是PARTIAL_WAKE_LOCK，确保cpu一直在运行，屏幕和键盘背光都可以被关闭，在扫描开始会通过mWakeLock.acquire();获取唤醒锁，这样扫描的过程中不会sleep，如果用户按了power键，屏幕会关掉，但是cpu会保持运行，知道调用mWakeLock.release();
    	PowerManager pm = (PowerManager)getSystemService(Context.POWER_SERVICE);
    	mWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, TAG);
    //这里新启了一个线程，因为service默认是运行在主线程的，所以要在单独的线程处理扫描，不然会block主线程。
    	Thread thr = new Thread(null, this, "MediaScannerService");
    	thr.start();
    }

顺带看下他的run()方法，这里展示启动一个独立线程的示例：

public void run() {
    	Process.setThreadPriority(Process.THREAD_PRIORITY_BACKGROUND +
    		Process.THREAD_PRIORITY_LESS_FAVORABLE);
    //prepare()这个方法是一定要调用的，因为这个方法会去创建属于这个新线程的Looper，同时创建属于这个线程的消息队列，也即是Looper实例中的MessageQueue变量。
    	Looper.prepare();
    //获取属于这个新线程的Looper，也即是上一步prepare中创建的。
    	mServiceLooper = Looper.myLooper();
    	mServiceHandler = new ServiceHandler();
    //调用loop()方法，让线程循环起来。
    	Looper.loop();
    }

我们知道service的onCreate方法之后，会调用其onStartCommand，在onStartCommand方法中会通过mServiceHandler发送消息，同时携带Intent中的扫描信息，直接看其handleMessage方法实现：

private final class ServiceHandler extends Handler {
    	public void handleMessage(Message msg) {
    		Bundle arguments = (Bundle) msg.obj;
    		String filePath = arguments.getString("filepath");
    		if (filePath != null) {
    //这里处理扫描指定文件路径的请求，ACTION_MEDIA_SCANNER_SCAN_FILE。
    			IBinder binder = arguments.getIBinder("listener");
    			IMediaScannerListener listener =
    				(binder == null ? null : IMediaScannerListener.Stub.asInterface(binder));
    			uri = scanFile(filePath, arguments.getString("mimetype"));
    			listener.scanCompleted(filePath, uri);
    }else {
    //下面是扫描存储设备，
    	String volume = arguments.getString("volume");
    	String[] directories = null;
    	if (MediaProvider.INTERNAL_VOLUME.equals(volume)) {
    //这里是扫描内部存储设备，只考虑了media目录，
    		directories = new String[] {
    			Environment.getRootDirectory() + "/media",
    			Environment.getOemDirectory() + "/media",};
    	} else if (MediaProvider.EXTERNAL_VOLUME.equals(volume)) {
    //这里扫描外部存储设备，考虑了是不是多用户。
    		if (getSystemService(UserManager.class).isDemoUser()) {
    			directories = ArrayUtils.appendElement(String.class,
    			mExternalStoragePaths,
    			Environment.getDataPreloadsMediaDirectory().getAbsolutePath());
    }else{
    	directories = mExternalStoragePaths;
    }
    scan(directories, volume);
    }
    }
    }
    }

接着看下他的scan()函数：

private void scan(String[] directories, String volumeName) {
    	if (volumeName.equals(MediaProvider.EXTERNAL_VOLUME)) {
    		openDatabase(volumeName);
    	}
    //通过MediaScanner对象，进一步执行扫描操作，携带的参数是要扫描的目录。
    	try (MediaScanner scanner = new MediaScanner(this, volumeName)) {
    		scanner.scanDirectories(directories);
    }
    }

转到frameworks/base/media/java/…/MediaScanner.java。

private final MyMediaScannerClient mClient= new MyMediaScannerClient();

mClient对象，会作为processDirectory的参数传到native层，后续会在native层调用java层方法扫描单个文件目录，并在扫描结束时做出入数据库的处理。也就是说目录数组的扫描工作，最终还是拆分为单个文件目录，做扫描，插入数据库。

public void scanDirectories(String[] directories) @ MediaScanner.java {
    // mMediaInserter对象处理数据批量插入数据库的操作，
    	mMediaInserter = new MediaInserter(mMediaProvider, 500);
    	for (int i = 0; i < directories.length; i++) {
    //这是个jni方法，循环处理directories的目录。这里的mClient是MyMediaScannerClient类型的对象，它是MediaScanner.java的内部类。
    	processDirectory(directories[i], mClient);
    }
    //刷新剩余的插入记录。
    mMediaInserter.flushAll();
    mMediaInserter = null;
    }

还要继续看扫描的处理，转到jni层，

android_media_MediaScanner_processDirectory( )
    @android_media_MediaScanner.cpp{
    	MediaScanner *mp = getNativeScanner_l(env, thiz);
    	MyMediaScannerClient myClient(env, client);
    	MediaScanResult result = mp->processDirectory(pathStr, myClient);
    }

上面的函数中要搞清楚两个问题，mp具体是什么对象？myClient怎么调用的java层的client实例的方法。
    先看mp具体是什么对象？

//这个native_init方法，是有MediaScanner.java的static block调用的。 
    
    static void android_media_MediaScanner_native_init(JNIEnv *env){//显示找到java层"android/media/MediaScanner";这个类。jclass clazz = env->FindClass(kClassMediaScanner);//然后取出java层的变量mNativeContext，转成native层的变量fields.context，用来存取值使用。fields.context = env->GetFieldID(clazz,
     "mNativeContext", "J");}
     
    
     //这个native_setup是在MediaScanner.java的构造函数中调用的。 
     
     static void android_media_MediaScanner_native_setup(JNIEnv *env, jobject thiz){
    //把StagefrightMediaScanner实例存入到了fields.context中。
    	MediaScanner *mp = new StagefrightMediaScanner;
    	env->SetLongField(thiz, fields.context, (jlong)mp);
    }
    
    
    
     
     所以上面的processDirectory(…)方法就转到了StagefrightMediaScanner.cpp中，实质上调用的是其父类MediaScanner.cpp中的processDirectory方法。 
     MediaScanner.cpp 
     MediaScanResult MediaScanner::doProcessDirectory(
    	char *path, int pathRemaining, MediaScannerClient &client, bool noMedia) {
    //先做一些处理，是不是要跳过某个目录，找出所有非多媒体.nomedia，打开目录，跳过一些不存在的目录，调用doProcessDirectoryEntry。
    	DIR* dir = opendir(path);
    	while ((entry = readdir(dir))) {
    		if (doProcessDirectoryEntry(path, pathRemaining, client, noMedia, entry, fileSpot)
    			== MEDIA_SCAN_RESULT_ERROR){
    			result = MEDIA_SCAN_RESULT_ERROR;
    			break;
    }
    }	
    closedir(dir);
    }
    MediaScanResult MediaScanner::doProcessDirectoryEntry(
    	char *path, int pathRemaining, MediaScannerClient &client, bool noMedia,
    	struct dirent* entry, char* fileSpot) {
    	const char* name = entry->d_name;
    //忽略“.”和“..”
    	if (name[0] == '.' && (name[1] == 0 || (name[1] == '.' && name[2] == 0))) {…}
    //获取文件类型。
    	int type = entry->d_type;
    //接下来如果是目录，继续调用doProcessDirectory，类似一个递归。如果是文件，调用client.scanFile方法。
    	if (type == DT_DIR) {
    		MediaScanResult result = doProcessDirectory(path, pathRemaining - nameLength - 1,
    			client, childNoMedia);
    } else if (type == DT_REG) {
    	status_t status = client.scanFile(path, statbuf.st_mtime, statbuf.st_size,
    		false /*isDirectory*/, noMedia);
    }
    }
     
     还记得上面提到的client，是android_media_MediaScanner_processDirector()@android_media_MediaScanner.cpp中传过来的，实质是MyMediaScannerClient类型的对象。MyMediaScannerClient是android_media_MediaScanner.cp的子类，继承自MediaScannerClient.cpp 
     接着看下他的scanFile()方法： 
     class MyMediaScannerClient : public MediaScannerClient
    virtual status_t scanFile(const char* path, long long lastModified,
    	long long fileSize, bool isDirectory, bool noMedia){
    //这个函数是调用java层的类MyMediaScannerClient（MediaScanner.java的内部类）中的方法scanFile方法。
    	mEnv->CallVoidMethod(mClient, mScanFileMethodID, pathStr, lastModified,
    		fileSize, isDirectory, noMedia);
    }
    
    
    
     
     以上面的代码为例，插播native层如何调用java层代码的： 
     mEnv指针变量的类型是JNIEnv，而JNIEnv又是JNINativeInterface结构类型的，代表了jni的本地接口，里面包含了很多的函数。 
     jobject类型，代表了调用native方法的，那个java类实例，当从java层调用native方法时，前两个参数(JNIEnv *env, jobject thiz)都是自动带入的，后面的才是函数的真正入参。 
     解释下mEnv->CallVoidMethod()中参数： 
     mClient是jobject类型的对象，代表了java层的类MyMediaScannerClient的类实例，具体是在MyMediaScannerClient(cpp)的构造函数中的初始化列表中赋值的：mClient(env->NewGlobalRef(client))。 
     mScanFileMethodID是jmethodID类型的变量，它的赋值语句： 
     mScanFileMethodID = env->GetMethodID( 
     mediaScannerClientInterface,"scanFile","(Ljava/lang/String;JJZZ)V"); 
     在这条赋值语句中mediaScannerClientInterface是jclass 类型的java层类（MediaScannerClient.java）实例（注意不是对象实例）： 
     static const char* constkClassMediaScannerClient ="android/media/MediaScannerClient"; 
     jclass mediaScannerClientInterface = env->FindClass(kClassMediaScannerClient); 
     "scanFile"是java层类MediaScannerClient.java中方法名。 
     "(Ljava/lang/String;JJZZ)V"是scanFile这个方法的类型签名，括号中是参数，最后是返回值。 
    接着说mEnv->CallVoidMethod()这个函数中的参数，除了前两个mClient, mScanFileMethodID，后面的值是实际传给调用函数的参数值，是真正的入参。
    
    
     
    
     
     
     JNI对所有的数据类型做了类型定义： 
     JNI基础类型对照表 
    
     
      
       
        
         
     Java类型 
     
         
     本地类型 
     
         
     占位说明 
     
        
        
         
     boolean 
     
         
     jboolean 
     
         
     Unsigned 8 bits 
     
        
        
         
     byte 
     
         
     jbyte 
     
         
     Signed 8 bits 
     
        
        
         
     char 
     
         
     jchar 
     
         
     Unsigned 16 bits 
     
        
        
         
     short 
     
         
     jshort 
     
         
     Signed 16 bits 
     
        
        
         
     int 
     
         
     jint 
     
         
     Signed 32 bits 
     
        
        
         
     long 
     
         
     jlong 
     
         
     Signed 64 bits 
     
        
        
         
     float 
     
         
     jfloat 
     
         
     32bits 
     
        
        
         
     double 
     
         
     jdouble 
     
         
     64bits 
     
        
        
         
     void 
     
         
     void 
     
         
     void 
     
        
       
      
     JNI引用数据类型对照表 
    
     
      
       
        
         
     Java类型 
     
         
     本地类型 
     
         
     Java类型 
     
         
     本地类型 
     
        
        
         
     All objects 
     
         
     jobject 
     
         
     Char[] 
     
         
     jcharArray 
     
        
        
         
     Java.lang.Class instances 
     
         
     jclass 
     
         
     Short[] 
     
         
     jshortArray 
     
        
        
         
     Java.lang.String instances 
     
         
     jstring 
     
         
     Int[] 
     
         
     jintArray 
     
        
        
         
     arrays 
     
         
     jarray 
     
         
     Long[] 
     
         
     jlongArray 
     
        
        
         
     Object[] 
     
         
     jobjectArray 
     
         
     Float[] 
     
         
     jfloatArray 
     
        
        
         
     Boolean [] 
     
         
     JbooleanArray 
     
         
     Double[] 
     
         
     jdoubleArray 
     
        
        
         
     Byte[] 
     
         
     jbyteArray 
     
         
     Java.lang.Throwable objects 
     
         
     jthrowable 
     
        
       
      
     JNI中类型签名，注意boolean，long 
    
     
      
       
        
         
     Java type 
     
         
     Type Sinature 
     
         
     Java type 
     
         
     Type signature 
     
        
        
         
     boolean 
     
         
     Z 
     
         
     float 
     
         
     F 
     
        
        
         
     byte 
     
         
     B 
     
         
     Double 
     
         
     D 
     
        
        
         
     char 
     
         
     C 
     
         
     Full-qualified-class 
     (如：java/lang/String) 
     
         
     L full-qualified-class(全限定类 
     如：Ljava/lang/String) 
     
        
        
         
     short 
     
         
     S 
     
         
     Type[] （数组,如：int[]） 
     
         
     [type (如：[I) 
     
        
        
         
     int 
     
         
     I 
     
         
     Method type (方法类型) 
     
         
     (arg-types)ret-type 
     (参数类型)返回值类型 
     
        
        
         
     long 
     
         
     J 
     
         
     
     
         
     
     
        
       
      
    
    
    
     
    
     
     
     接着前面扫描流程分析： 
     scanFile又直接调用了doScanFile方法： 
     MediaScanner.java 
     public Uri doScanFile(String path, String mimeType, long lastModified, long fileSize,
    	boolean isDirectory, boolean scanAlways, boolean noMedia)@ MyMediaScannerClient {
    //获取文件类型，生成FileEntry对象。
    	FileEntry entry = beginFile(path, mimeType, lastModified,
    		fileSize, isDirectory, noMedia);
    //接下来区分多媒体文件，非多媒体文件。
    	if (noMedia) {
    //非多媒体文件，直接调用endFile。
    		result = endFile(entry, false, false, false, false, false);
    }else{
    //根据beginFile中获取的文件类型mFileType，判断是音频，视频，图片。
    	boolean isaudio = MediaFile.isAudioFileType(mFileType);
    	boolean isvideo = MediaFile.isVideoFileType(mFileType);
    	boolean isimage = MediaFile.isImageFileType(mFileType);
    //做路径转化，这里的模拟外部存储设备，应该是指手机内存中除PRIVATE外的部分？
    	if (isaudio || isvideo || isimage) {
    		path = Environment.maybeTranslateEmulatedPathToInternal(new File(path))
    			.getAbsolutePath();
    }
    //如果是音视频文件，只提取元数据，ID3信息，比如：宽高，日期，专辑名，艺术家等。
    if (isaudio || isvideo) {
    	processFile(path, mimeType, this);
    }
    //如果是图片，执行解码。
    if (isimage) {
    	processImageFile(path);
    }
    // endFile，做的一个主要工作就是往数据库插入数据。
    result = endFile(entry, ringtones, notifications, alarms, music, podcasts);
    }
    }
    
     private Uri endFile(FileEntry entry, boolean ringtones, boolean notifications,
    	boolean alarms, boolean music, boolean podcasts){
    //生成一个存入数据库的数据对象
    	ContentValues values = toValues();
    //对jpg的对象，处理下其ExifInterface信息，主要角度调整。
    	if((mFileType == MediaFile.FILE_TYPE_JPEG
                        || MediaFile.isRawImageFileType(mFileType)) && !mNoMedia){
    		ExifInterface exif = new ExifInterface(entry.mPath);
    		int orientation = exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, -1);
    		if (orientation != -1) {
    			int degree;
    			switch(orientation) {
    				case ExifInterface.ORIENTATION_ROTATE_90:
    				degree = 90;
    }
    values.put(Images.Media.ORIENTATION, degree);
    }
    }
    //处理数据插入的对象，
    MediaInserter inserter = mMediaInserter;
    //根据不同的类型，设置相应的uri，这些uri来自MediaStore.java。
    if (MediaFile.isVideoFileType(mFileType)) {
    	tableUri = mVideoUri;
    } else if (MediaFile.isImageFileType(mFileType)) {
    	tableUri = mImagesUri;
    }
    //有了uri，有了要插入的数据values，调用MediaInserter插入数据库。一个新的文件插入时，要先插入其目录，然后在插入文件，记得调用flushAll，或者flush清空缓冲区。
    inserter.insert(tableUri, values);
    }