android Media原理学习

思考Android安装的app如何快速辨别磁盘上的文件哪些是多媒体文件，并且存放在哪个位置？

通常情况下，我们是使用Android系统自带的音乐或者视频播放器，它里面就包含了磁盘上所有的音乐视频文件，它是怎么快速获取到这些文件的呢？不可能每次打开都去扫描一次系统存储的文件，这样是很慢，原理上分析，应该在打开之前系统就已经为它扫描好并且把这些媒体文件的位置存储好了，音乐播放器只需要去存储的地方去取就好了；事实上Android也是这样去做的，如何去做的呢？本文将从源码的角度去分析运作流程，以及Android sdk自带的媒体API的使用方法；

Android 接口类关键字

MediaPlayer MediaStore MediaScannerService MediaScannerReciver MediaProvider

Android系统扫描文件的时机

什么情况下，系统决定要去扫描文件，统计媒体数据？Android系统提供了三种方式：

String flag_a = Intent.ACTION_MEDIA_MOUNTED;    //插拔sdk后触发
String flag_b = Intent.ACTION_BOOT_COMPLETED;   //系统完成后触发
String flag_c = Intent.ACTION_MEDIA_SCANNER_SCAN_FILE;  //磁盘文件发生变化时触发
sendBroadcast(new Intent(Intent.ACTION_MEDIA_MOUNTED, Uri.parse("file://"+ Environment.getExternalStorageDirectory())));

由上代码可以发现，触发相应的事件后是通过一个广播把消息发送出去的，那么肯定存在对应的广播接收，接收代码就在MediaScannerReciver里面，收到消息后它会启动一个Service，由Service完成文件扫描，MediaScannerReciver源码：

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);
            scan(context, MediaProvider.EXTERNAL_VOLUME);
        } else { 
            if (uri.getScheme().equals("file")) {
                // handle intents related to external storage
                String path = uri.getPath();
                String externalStoragePath = Environment.getExternalStorageDirectory().getPath();
                String legacyPath = Environment.getLegacyExternalStorageDirectory().getPath();
                try {
                    path = new File(path).getCanonicalPath();
                } catch (IOException e) {
                    Log.e(TAG, "couldn't canonicalize " + path);
                    return;
                }
                if (path.startsWith(legacyPath)) {
                    path = externalStoragePath + path.substring(legacyPath.length());
                }
                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);  //插拔卡扫描sdk路径
                } else if (Intent.ACTION_MEDIA_SCANNER_SCAN_FILE.equals(action) &&
                        path != null && path.startsWith(externalStoragePath + "/")) {
                    scanFile(context, path);   //扫描自定义路径
                }
            }
        }
    }

    private void scan(Context context, String volume) {
        Bundle args = new Bundle();
        args.putString("volume", volume);
        //开启扫描服务Service
        context.startService(
                new Intent(context, MediaScannerService.class).putExtras(args));

    }    
    private void scanFile(Context context, String path) {
        Bundle args = new Bundle();
        args.putString("filepath", path);
        //开启扫描服务Service
        context.startService(
                new Intent(context, MediaScannerService.class).putExtras(args));
    }    

上面代码，在ACTION_BOOT_COMPLETED方式内，INTERNAL_VOLUME指的是$(ANDROID_ROOT)/media位置，EXTERNAL_VOLUME是外部sdk路径；从上面代码可以看到开启了一个MediaScannerService的服务，那这个服务是如何扫描的呢？看源码：

public int onStartCommand(Intent intent, int flags, int startId) {
        ............
        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.sendMessage(msg);
        // Try again later if we are killed before we can finish scanning.
        return Service.START_REDELIVER_INTENT;
    }

从上面代码可以看出，startCommand的时候会发送一个handler消息，在收到消息后，如何处理的呢？

public void handleMessage(Message msg) {
            Bundle arguments = (Bundle) msg.obj;
            if (arguments == null) {
                Log.e(TAG, "null intent, b/20953950");
                return;
            }
            String filePath = arguments.getString("filepath");

            try {
                if (filePath != null) {
                    IBinder binder = arguments.getIBinder("listener");
                    IMediaScannerListener listener = 
                            (binder == null ? null : IMediaScannerListener.Stub.asInterface(binder));
                    Uri uri = null;
                    try {
                        uri = scanFile(filePath, arguments.getString("mimetype"));
                    } catch (Exception e) {
                        Log.e(TAG, "Exception scanning file", e);
                    }
                    if (listener != null) {
                        listener.scanCompleted(filePath, uri);
                    }
                } else {
                    String volume = arguments.getString("volume");
                    String[] directories = null;

                    if (MediaProvider.INTERNAL_VOLUME.equals(volume)) {
                        // scan internal media storage
                        directories = new String[] {
                                Environment.getRootDirectory() + "/media",
                                Environment.getOemDirectory() + "/media",
                        };
                    }
                    else if (MediaProvider.EXTERNAL_VOLUME.equals(volume)) {
                        // scan external storage volumes
                        directories = mExternalStoragePaths;
                    }
                    if (directories != null) {
                        if (false) Log.d(TAG, "start scanning volume " + volume + ": "
                                + Arrays.toString(directories));
                        scan(directories, volume);
                        if (false) Log.d(TAG, "done scanning volume " + volume);
                    }
                }
            } catch (Exception e) {
                Log.e(TAG, "Exception in handleMessage", e);
            }

上面代码主要是拿到你需要扫描的位置参数，然后在调用scan()和scanFiles()这两个方法去扫描，而且真正执行的扫描操作就在这里面

 private void scan(String[] directories, String volumeName) {
        Uri uri = Uri.parse("file://" + directories[0]);
        // don't sleep while scanning
        mWakeLock.acquire();
        try {
            ContentValues values = new ContentValues();
            values.put(MediaStore.MEDIA_SCANNER_VOLUME, volumeName);
            Uri scanUri = getContentResolver().insert(MediaStore.getMediaScannerUri(), values);
            sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_STARTED, uri));
            try {
                if (volumeName.equals(MediaProvider.EXTERNAL_VOLUME)) {
                    openDatabase(volumeName);
                }
                try (MediaScanner scanner = new MediaScanner(this, volumeName)) {
                    scanner.scanDirectories(directories);
                }
            } catch (Exception e) {
                Log.e(TAG, "exception in MediaScanner.scan()", e);
            }
            getContentResolver().delete(scanUri, null, null);
        } finally {
            sendBroadcast(new Intent(Intent.ACTION_MEDIA_SCANNER_FINISHED, uri));
            mWakeLock.release();
        }
    }

scan方法内部，首先在扫描过程中不允许休眠，然后把扫描路径参数交给MediaScanner去扫描，完成后在广播消息扫描完成，MediaScanner已经在JNI层了，就不继续分析了；在最后扫描完成后，系统受到结果会把它存储在sqlite数据库中，在由MediaProvider提供查询接口，我们开发的时候就可使用ContentProvider去提取我们的东西了

    private Uri scanFile(String path, String mimeType) {
        String volumeName = MediaProvider.EXTERNAL_VOLUME;
        try (MediaScanner scanner = new MediaScanner(this, volumeName)) {
            // make sure the file path is in canonical form
            String canonicalPath = new File(path).getCanonicalPath();
            return scanner.scanSingleFile(canonicalPath, mimeType);
        } catch (Exception e) {
            Log.e(TAG, "bad path " + path + " in scanFile()", e);
            return null;
        }
    }

scannFile方法和Scan类似，只是最后会返回一个uri，你查看上面的handler获取消息部分可以看到，还有一个回调监听，通过那个监听可以把查询的结果返回回去

总结

将以上过程规划成一个流程图如下：

android媒体开发

MediaPlayer和VideoView

Android上的视频播放可以用MediaPlayer、VideView和WebView提供的JS播放器，他们各有异同，具体参考下面；
视频或者音频播放时，一般步骤是:
- 创建相关播放类
- 初始化并设置播放源
- 开始播放
- 结束释放资源
将视频流显示到界面上去时，有一个绘制过程，而媒体流数据都是异步来绘制的，需要在子线程完成，如果放到主线程去回出现ANR，从类的结构上看VideoView继承了SurfaceView所以它可以直接设置播放源进行播放，MediaPlayer则不行，需要自己创建一个视图表面SurfaceView并与之绑定，进行播放；以MediaPlayer为例进行视频播放：
1 创建相关类

public static MediaPlayer create (Context context, Uri uri, SurfaceHolder holder);//绑定holder
public static MediaPlayer create (Context context, int resid);//resid是你要播放的流R.raw
public static MediaPlayer create (Context context, Uri uri)

2 设置视频/音频播放流，同时可以设置一些监听如错误、启动或者缓冲监听，当出现这些动作后会执行相应的回调函数，如启动监听：

OnPreparedListener mPreParedListener = new MediaPlayer.OnPreparedListener() {
            @Override
            public void onPrepared(MediaPlayer mediaPlayer) {

            };
mPlayer.setOnPreparedListener(mPreParedListener);         

上面的监听，当我们mplayer调用启动函数prepareAsync()或者prepare()，mPlayer启动完成处于Prepared状态下就会执行相应的动作，其他的监听用法和这个类似；

Android视频支持格式需要特别说明一下： setDataSource（）这个方法你可以设置网上在线视频或者本地文件路径等，具体的方法参考Android sdk API，值得注意的是Android的播放器支持视频：本地MP4和3gp，在线视频支持http协议的和RTSP协议的视频流播放，http点播用的多，而RTSP用于实时直播用的多，还有一种直播协议是RTMP；所以从上可知Android自带的多媒体框架并不是支持多种格式的视频播放和在线播放，如果想要做一套全视频系统的话，可以找一些开源的库进行二次开发，这里稍稍讲下直播系统：

推流端 – 将本地录制的视频以流的方式推到服务端
可以用ffmpeg自己写一个推流器，博主有一篇博客写了一个简单的推流器可做参考；
AnyRTMP推流框架,支持nginx+RTMP的直播协议

服务端 – 收集推流上来的视频流并转发到其他接收端，服务端可以做格式的转换、数据压缩转码等
可以用nginx做，服务端搭建并配置RTMP服务可参考这篇文档：

客户端接收直播流
典型的bilibili的ijkplayer、还有七牛的直播框架等
楼主前段时间仿照bilibili的直播，做了一个简易的直播demo，有需要的可以参考我的github

3 开始播放,一般来说当你的MediaPlayer处于Prepared状态，你就可以start开始播放了，开始播放后你可以控制视频的播放、暂停、定位等功能；如果只是简单的操作的话，你就使用Android自带的媒体控制器就可以了,如果嫌Android原生控制界面太丑了，可以自定义控制界面，自己操作，楼主自己做了一个，可以参考我的github
效果图：

4 结束释放资源

public void release ();

MediaPlayer生命周期

了解它的生命周期才能更好的使用MediaPlayer，以及在遇到问题更好的解决问题，话不多说，看图：