安卓day33多媒体编程 加载大图 创建图片副本 图片特效 画板 撕衣服 音乐播放器 视频播放器 SurfaceView vitamio 摄像头

一、排坑

 扫描SD卡Permission Denial: not allowed to send broadcast android.intent.action.MEDIA_MOUNTED 

Android4.4中限制了系统应用才有权限使用广播通知系统扫描SD卡。

使用MediaScannerConnection执行具体文件或文件夹进行扫描。

MediaPlayer，Prepare failed.: status=0x1

player.setDataSource(MainActivity.this,Uri.parse(Environment.getExternalStorageDirectory()+"/ahmk/desktop.mp4"));

vitamio闪退

最低支持版本为21

targetSdkVersion 21

相机崩溃，exposed beyond app through ClipData.Item.getUri

在onCreate()方法中添加以下代码：

        StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder();
        StrictMode.setVmPolicy(builder.build());
        builder.detectFileUriExposure();

二、加载大图片

• 单色图：每个像素占用1/8个字节

• 16色图：每个像素占用1/2个字节
• 256色图：每个像素占用1个字节
• 24位图：每个像素占用3个字节

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

    }
    public void click(View v){
        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            readPic();
        }
    }


    public void readPic(){
        //解析图片时需要使用到的参数都封装在这个对象里了
        Options opt = new Options();
        //不为像素申请内存，只获取图片宽高
        opt.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(Environment.getExternalStorageDirectory()+"/ahmk/dog.jpg", opt);
        //拿到图片宽高
        int imageWidth = opt.outWidth;
        int imageHeight = opt.outHeight;
        
        Display dp = getWindowManager().getDefaultDisplay();
        //拿到屏幕宽高
        int screenWidth = dp.getWidth();
        int screenHeight = dp.getHeight();
        
        //计算缩放比例
        int scale = 1;
        int scaleWidth = imageWidth / screenWidth;
        int scaleHeight = imageHeight / screenHeight;
        if(scaleWidth >= scaleHeight && scaleWidth >= 1){
            scale = scaleWidth;
        }
        else if(scaleWidth < scaleHeight && scaleHeight >= 1){
            scale = scaleHeight;
        }
        //设置缩放比例
        opt.inSampleSize = scale;
        opt.inJustDecodeBounds = false;
        Bitmap bm = BitmapFactory.decodeFile(Environment.getExternalStorageDirectory()+"/ahmk/dog.jpg", opt);
        
        ImageView iv = (ImageView) findViewById(R.id.iv);
        iv.setImageBitmap(bm);
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED){
                    readPic();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;
        }
    }
}

 三、在内存中创建图片的副本

直接加载的bitmap对象是只读的，无法修改，要修改图片只能在内存中创建出一个一模一样的bitmap副本，然后修改副本

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            copyPic();
        }
    }
    public void copyPic(){
        //这个对象是只读的
        Bitmap bmSrc = BitmapFactory.decodeFile(Environment.getExternalStorageDirectory()+"/ahmk/dog.jpg");//创建图片副本
        //1.在内存中创建一个与原图一模一样大小的bitmap对象，创建与原图大小一致的白纸
        Bitmap bmCopy = Bitmap.createBitmap(bmSrc.getWidth(), bmSrc.getHeight(), bmSrc.getConfig());//2.创建画笔对象
        Paint paint = new Paint();

        //3.创建画板对象，把白纸铺在画板上
        Canvas canvas = new Canvas(bmCopy);//4.开始作画，把原图的内容绘制在白纸上
        canvas.drawBitmap(bmSrc, new Matrix(), paint);
        ImageView iv_src = (ImageView) findViewById(R.id.iv_src);
        ImageView iv_copy = (ImageView) findViewById(R.id.iv_copy);
        iv_src.setImageBitmap(bmSrc);
        iv_copy.setImageBitmap(bmCopy);
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED&&grantResults[1]==PackageManager.PERMISSION_GRANTED){
                    copyPic();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;
        }
    }
}

四、对图片进行特效处理

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            copyPic();
        }
    }
    public void copyPic(){
        //这个对象是只读的
        Bitmap bmSrc = BitmapFactory.decodeFile(Environment.getExternalStorageDirectory()+"/ahmk/dog.jpg");
        //创建图片副本
        //1.在内存中创建一个与原图一模一样大小的bitmap对象，创建与原图大小一致的白纸
        Bitmap bmCopy = Bitmap.createBitmap(bmSrc.getWidth(), bmSrc.getHeight(), bmSrc.getConfig());
        //2.创建画笔对象
        Paint paint = new Paint();

        //3.创建画板对象，把白纸铺在画板上
        Canvas canvas = new Canvas(bmCopy);

        Matrix mt = new Matrix();

        //平移
//        mt.setTranslate(20, 40);
        //缩放
        //sx：水平方向的缩放比例
        //sy：竖直方向的缩放比例
//        mt.setScale(0.5f, 0.5f);
//        mt.setScale(0.5f, 0.5f, bmCopy.getWidth() / 2, bmCopy.getHeight() / 2);
        //旋转
//        mt.setRotate(45, bmCopy.getWidth() / 2, bmCopy.getHeight() / 2);

        //镜面
//        mt.setScale(-1, 1);
//        mt.postTranslate(bmCopy.getWidth(), 0);
        //倒影
        mt.setScale(1, -1);
        mt.postTranslate(0, bmCopy.getHeight());
        //4.开始作画，把原图的内容绘制在白纸上
        canvas.drawBitmap(bmSrc, mt, paint);
        //canvas.drawBitmap(bmSrc, new Matrix(), paint);
        ImageView iv_src = (ImageView) findViewById(R.id.iv_src);
        ImageView iv_copy = (ImageView) findViewById(R.id.iv_copy);
        iv_src.setImageBitmap(bmSrc);
        iv_copy.setImageBitmap(bmCopy);
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED&&grantResults[1]==PackageManager.PERMISSION_GRANTED){
                    copyPic();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;
        }
    }
}

五、画画板

• 系统每次收到SD卡就绪广播时，都会去遍历sd卡的所有文件和文件夹，把遍历到的所有多媒体文件都在MediaStore数据库保存一个索引，这个索引包含多媒体文件的文件名、路径、大小
• 图库每次打开时，并不会去遍历sd卡获取图片，而是通过内容提供者从MediaStore数据库中获取图片的信息，然后读取该图片

• 系统开机或者点击加载sd卡按钮时，系统会发送sd卡就绪广播，我们也可以手动发送就绪广播

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    private ImageView iv;

    int startX;
    int startY;

    private Canvas canvas;

    private Paint paint;

    private Bitmap bmCopy;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.WRITE_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            paint();
        }

    }
    public void paint(){
        //加载画画板的背景图
        Bitmap bmSrc = BitmapFactory.decodeResource(getResources(), R.drawable.bg);

        bmCopy = Bitmap.createBitmap(bmSrc.getWidth(), bmSrc.getHeight(), bmSrc.getConfig());
        paint = new Paint();
        canvas = new Canvas(bmCopy);
        //绘制
        canvas.drawBitmap(bmSrc, new Matrix(), paint);

        iv = (ImageView) findViewById(R.id.iv);
        iv.setImageBitmap(bmCopy);

        //设置触摸侦听
        iv.setOnTouchListener(new OnTouchListener() {

            //触摸屏幕时，触摸事件产生时，此方法调用
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                int action = event.getAction();
                switch (action) {
                    //用户手指摸到屏幕
                    case MotionEvent.ACTION_DOWN:
                        startX = (int) event.getX();
                        startY = (int) event.getY();
                        break;
                    //用户手指正在滑动
                    case MotionEvent.ACTION_MOVE:
                        int x = (int) event.getX();
                        int y = (int) event.getY();
                        canvas.drawLine(startX, startY, x, y, paint);
                        //每次绘制完毕之后，本次绘制的结束坐标变成下一次绘制的初始坐标
                        startX = x;
                        startY = y;
                        iv.setImageBitmap(bmCopy);
                        break;
                    //用户手指离开屏幕
                    case MotionEvent.ACTION_UP:
                        break;

                }
                //true：告诉系统，这个触摸事件由我来处理
                //false：告诉系统，这个触摸事件我不处理，这时系统会把触摸事件传递给imageview的父节点
                return true;
            }
        });
    }

    public void red(View v){
        paint.setColor(Color.RED);
    }
    public void green(View v){
        paint.setColor(Color.GREEN);
    }
    public void brush(View v){
        paint.setStrokeWidth(7);
    }
    public void save(View v){
        File file = new File(Environment.getExternalStorageDirectory()+"/ahmk/dazuo.png");
        FileOutputStream fos = null;
        try {
            fos = new FileOutputStream(file);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
        bmCopy.compress(CompressFormat.PNG, 100, fos);
        //发送sd卡就绪广播
        MediaScannerConnection.scanFile(this, new String[]{Environment.getExternalStorageDirectory()+"/ahmk"}, null, null);
//        Intent intent = new Intent();
//        intent.setAction(Intent.ACTION_MEDIA_MOUNTED);
//        intent.setData(Uri.fromFile(Environment.getExternalStorageDirectory()));
//        sendBroadcast(intent);
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED){
                    paint();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;

        }
    }
}

六、撕衣服

public class MainActivity extends Activity {

    private Bitmap bmCopy;
    private ImageView iv;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Bitmap bmSrc = BitmapFactory.decodeResource(getResources(), R.drawable.awaiyi);
        bmCopy = Bitmap.createBitmap(bmSrc.getWidth(), bmSrc.getHeight(), bmSrc.getConfig());
        Paint paint = new Paint();
        Canvas canvas = new Canvas(bmCopy);
        canvas.drawBitmap(bmSrc, new Matrix(), paint);
        iv = (ImageView) findViewById(R.id.iv);
        iv.setOnTouchListener(new OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                case MotionEvent.ACTION_MOVE:
                    int x = (int) event.getX();
                    int y = (int) event.getY();
                    for(int i = -20; i <= 20; i++){
                        for(int j = -20; j <= 20; j++){
                            //把用户划过的坐标置为透明色
                            //改变指定的像素颜色
                            if(Math.sqrt(i*i + j*j) <= 20){
                                if(x + i < bmCopy.getWidth() && y + j < bmCopy.getHeight() && x + i >= 0 && y + j >= 0){
                                    bmCopy.setPixel(x + i, y + j, Color.TRANSPARENT);
                                    iv.setImageBitmap(bmCopy);
                                }
                            }
                        }
                    }
                    break;

                }
                return true;
            }
        });
    }
}

七、音乐播放器

• 播放音频的代码应该运行在服务中，定义一个播放服务MusicService

• 服务里定义play、stop、pause、continuePlay等方法

• 播放进度需要不停的获取，不停的刷新进度条，使用计时器每500毫秒获取一次播放进度

• 发消息至Handler，把播放进度放进Message对象中，在Handler中更新SeekBar的进度

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    static Handler handler = new Handler(){
        public void handleMessage(android.os.Message msg) {
            Bundle bundle = msg.getData();
            int duration = bundle.getInt("duration");
            int currentPostition = bundle.getInt("currentPosition");
            //刷新进度条的进度
            sb.setMax(duration);
            sb.setProgress(currentPostition);
        }
    };
    MusicInterface mi;
    private MyserviceConn conn;
    private Intent intent;
    private static SeekBar sb;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        sb = (SeekBar) findViewById(R.id.sb);
        sb.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
            @Override
            public void onStopTrackingTouch(SeekBar seekBar) {
                //根据拖动的进度改变音乐播放进度
                int progress = seekBar.getProgress();
                //改变播放进度
                mi.seekTo(progress);
            }
            @Override
            public void onStartTrackingTouch(SeekBar seekBar) {
            }
            @Override
            public void onProgressChanged(SeekBar seekBar, int progress,
                    boolean fromUser) {
            }
        });
        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            startService();
        }

    }
    public void startService(){
        intent = new Intent(this, MusicService.class);
        startService(intent);
        conn = new MyserviceConn();
        bindService(intent, conn, BIND_AUTO_CREATE);
    }
    class MyserviceConn implements ServiceConnection{

        @Override
        public void onServiceConnected(ComponentName name, IBinder service) {
            mi = (MusicInterface) service;
        }

        @Override
        public void onServiceDisconnected(ComponentName name) {
            // TODO Auto-generated method stub
        }
    }
    public void play(View v){
        mi.play();
    }
    public void continuePlay(View v){
        mi.continuePlay();
    }
    public void pause(View v){
        mi.pause();
    }
    public void exit(View v){
        unbindService(conn);
        stopService(intent);
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED){
                    startService();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;
        }
    }

}

public class MusicService extends Service {

    MediaPlayer player;
    private Timer timer;
    @Override
    public IBinder onBind(Intent intent) {
        // TODO Auto-generated method stub
        return new MusicController();
    }

    class MusicController extends Binder implements MusicInterface{

        @Override
        public void play() {
            MusicService.this.play();
        }

        @Override
        public void pause() {
            MusicService.this.pause();
        }

        @Override
        public void continuePlay() {
            MusicService.this.continuePlay();
        }

        @Override
        public void seekTo(int progress) {
            MusicService.this.seekTo(progress);
        }
    }
    @Override
    public void onCreate() {
        // TODO Auto-generated method stub
        super.onCreate();
        player = new MediaPlayer();
    }
    @Override
    public void onDestroy() {
        // TODO Auto-generated method stub
        super.onDestroy();
        //停止播放
        player.stop();
        //释放占用的资源，此时player对象已经废掉了
        player.release();
        player = null;
        if(timer != null){
            timer.cancel();
            timer = null;
        }
    }
    //播放音乐
    public void play(){
        //重置
        player.reset();
        try {
            //加载多媒体文件
            player.setDataSource(Environment.getExternalStorageDirectory()+"/ahmk/test1.mp3");
//            player.setDataSource("http://192.168.13.119:8080/bzj.mp3");
//            player.prepare();
            player.prepareAsync();
//            player.start();
            player.setOnPreparedListener(new OnPreparedListener() {
                //准备完毕时，此方法调用
                @Override
                public void onPrepared(MediaPlayer mp) {
                    player.start();
                    addTimer();
                }
            });
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } 
    }
    //继续播放
    public void continuePlay(){
        player.start();
    }
    //暂停播放
    public void pause(){
        player.pause();
    }
    public void seekTo(int progress){
        player.seekTo(progress);
    }
    public void addTimer(){
        if(timer == null){
            timer = new Timer();
            timer.schedule(new TimerTask() {
                @Override
                public void run() {
                    //获取歌曲总时长
                    int duration = player.getDuration();
                    //获取歌曲当前播放进度
                    int currentPosition= player.getCurrentPosition();
                    Message msg = MainActivity.handler.obtainMessage();
                    //把进度封装至消息对象中
                    Bundle bundle = new Bundle();
                    bundle.putInt("duration", duration);
                    bundle.putInt("currentPosition", currentPosition);
                    msg.setData(bundle);
                    MainActivity.handler.sendMessage(msg);
                }
                //开始计时任务后的5毫秒，第一次执行run方法，以后每500毫秒执行一次
            }, 5, 500);
        }
    }
}

public interface MusicInterface {

    void play();
    void pause();
    void continuePlay();
    void seekTo(int progress);
}

 八、视频播放器

SurfaceView

• 对画面的实时更新要求较高
• 双缓冲技术：内存中有两个画布，A画布显示至屏幕，B画布在内存中绘制下一帧画面，绘制完毕后B显示至屏幕，A在内存中继续绘制下一帧画面

• 播放视频也是用MediaPlayer，不过跟音频不同，要设置显示在哪个SurfaceView

• SurfaceView是重量级组件，可见时才会创建

• 给SurfaceHolder设置CallBack，类似于侦听，可以知道SurfaceView的状态

• SurfaceView一旦不可见，就会被销毁，一旦可见，就会被创建，销毁时停止播放，再次创建时再开始播放

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    private MediaPlayer player;
    static int currentPosition;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.READ_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            showVideo();
        }

    }
    public void showVideo(){
        SurfaceView sv = (SurfaceView) findViewById(R.id.sv);
        //拿到surfaceview的控制器
        final SurfaceHolder sh = sv.getHolder();
//        Thread t = new Thread(){
//            @Override
//            public void run() {
//                // TODO Auto-generated method stub
//                try {
//                    sleep(200);
//                } catch (InterruptedException e) {
//                    // TODO Auto-generated catch block
//                    e.printStackTrace();
//                }
//                runOnUiThread(new Runnable() {
//                    @Override
//                    public void run() {
//                        MediaPlayer player = new MediaPlayer();
//                        player.reset();
//                        try {
//                            player.setDataSource(Environment.getExternalStorageDirectory()+"/ahmk/deaktop.mp4");
//                            player.setDisplay(sh);
//                            player.prepare();
//                            player.start();
//                        } catch (Exception e) {
//                            // TODO Auto-generated catch block
//                            e.printStackTrace();
//                        }
//
//                    }
//                });
//
//            }
//        };
//        t.start();
        sh.addCallback(new Callback() {
            //surfaceView销毁时调用
            @Override
            public void surfaceDestroyed(SurfaceHolder holder) {
                //每次surfaceview销毁时，同时停止播放视频
                if(player != null){
                    currentPosition = player.getCurrentPosition();
                    player.stop();
                    player.release();
                    player = null;
                }
            }
            //surfaceView创建时调用
            @Override
            public void surfaceCreated(SurfaceHolder holder) {
                //每次surfaceView创建时才去播放视频
                if(player == null){
                    player = new MediaPlayer();
                    player.reset();
                    try {
                        player.setDataSource(MainActivity.this,Uri.parse(Environment.getExternalStorageDirectory()+"/ahmk/desktop.mp4"));
                        player.setDisplay(sh);
                        player.prepare();
                        player.start();
                        player.seekTo(currentPosition);
                    } catch (Exception e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
            }
            //surfaceView结构改变时调用
            @Override
            public void surfaceChanged(SurfaceHolder holder, int format, int width,
                                       int height) {
                // TODO Auto-generated method stub
            }
        });
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED&&grantResults[1]==PackageManager.PERMISSION_GRANTED){
                    showVideo();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;

        }
    }


}

 vitamio

源码：https://github.com/yixia/VitamioBundle

加入参考：https://www.cnblogs.com/happyhacking/p/5365192.html

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},1);
        }else {
            //把动作告诉系统
            play();
        }

    }
    public void play() {
        //检测是否支持vitamio
        if (!LibsChecker.checkVitamioLibs(this)) {return;}

        VideoView vv = (VideoView) findViewById(R.id.vv);

        vv.setVideoPath(Environment.getExternalStorageDirectory()+"/ahmk/desktop.mp4");
        vv.start();

        vv.setMediaController(new MediaController(this));
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED){
                    play();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;

        }
    }



}

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    tools:context=".MainActivity" >

    <io.vov.vitamio.widget.VideoView
        android:id="@+id/vv"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        />

</RelativeLayout>

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.index42.videoview">
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>
    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity android:name="io.vov.vitamio.activity.InitActivity"></activity>
    </application>

</manifest>

九、摄像头

public class MainActivity extends Activity {
    private static final String TAG = "MainActivity";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        StrictMode.VmPolicy.Builder builder = new StrictMode.VmPolicy.Builder();
        StrictMode.setVmPolicy(builder.build());
        builder.detectFileUriExposure();
    }
    public void click1(View v){
        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.READ_EXTERNAL_STORAGE},1);
        }else {
            image();
            //把动作告诉系统

        }
    }
    public void click2(View v){
        if (ContextCompat.checkSelfPermission(MainActivity.this,
                Manifest.permission.READ_EXTERNAL_STORAGE)!= PackageManager.PERMISSION_GRANTED  ){
            //申请权限
            ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE,Manifest.permission.READ_EXTERNAL_STORAGE},2);
        }else {
            video();
            //把动作告诉系统

        }
    }
    public void image(){
        //启动系统提供的拍照activity
        Intent intent = new Intent();
        intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(Environment.getExternalStorageDirectory(), "ahmk/haha.jpg")));
        startActivityForResult(intent, 10);
    }
    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // TODO Auto-generated method stub
        super.onActivityResult(requestCode, resultCode, data);
        if(requestCode == 10){
            Log.e(TAG, "拍照成功: " );
            Toast.makeText(this, "拍照成功", Toast.LENGTH_SHORT).show();
        }
        else if(requestCode == 20){
            Log.e(TAG, "摄像成功: " );
            Toast.makeText(this, "摄像成功", Toast.LENGTH_SHORT).show();
        }
    }
    public void video(){
        //启动系统提供的摄像activity
        Intent intent = new Intent();
        intent.setAction(MediaStore.ACTION_VIDEO_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(Environment.getExternalStorageDirectory(), "ahmk/haha.3gp")));
        intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
        startActivityForResult(intent, 20);
    }
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        switch (requestCode){
            case 1:
                //权限回调
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED&&grantResults[1]==PackageManager.PERMISSION_GRANTED){
                    image();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;
            case 2:
                if (grantResults[0]==PackageManager.PERMISSION_GRANTED&&grantResults[1]==PackageManager.PERMISSION_GRANTED){
                    video();
                }else {
                    //提示用户权限未被授予
                    Log.e("MainActivity","未授予权限");
                }
                break;

        }
    }

}