Android多媒体编程

最新推荐文章于 2021-08-05 09:30:40 发布

Jack-Chan

最新推荐文章于 2021-08-05 09:30:40 发布

阅读量1.5k

点赞数 1

分类专栏： Android基础文章标签：多媒体编程 Bitmap Paint Canvas SurfaceVie

本文链接：https://blog.youkuaiyun.com/axi295309066/article/details/50330521

版权

Android基础专栏收录该内容

94 篇文章

订阅专栏

本文介绍了Android多媒体编程，涵盖图片、音频、视频处理。讨论了如何计算图片大小，加载大图片并避免内存溢出，使用SurfaceView进行视频播放，以及实现画画板和‘撕衣服’效果。此外，还讲解了音乐播放器的实现，包括播放服务、进度控制和摄像头的使用。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

多媒体概念

文字、图片、音频、视频

计算机图片大小的计算

图片大小 = 图片的总像素 * 每个像素占用的大小

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

加载大图片到内存

Android系统以ARGB表示每个像素，所以每个像素占用4个字节，很容易内存溢出

对图片进行缩放

获取屏幕宽高

Display dp = getWindowManager().getDefaultDisplay();
int screenWidth = dp.getWidth();
int screenHeight = dp.getHeight();

获取图片宽高

Options opts = new Options();
//请求图片属性但不申请内存
opts.inJustDecodeBounds = true;
BitmapFactory.decodeFile("sdcard/dog.jpg", opts);
int imageWidth = opts.outWidth;
int imageHeight = opts.outHeight;

图片的宽高除以屏幕宽高，算出宽和高的缩放比例，取较大值作为图片的缩放比例

int scale = 1;
int scaleX = imageWidth / screenWidth;
int scaleY = imageHeight / screenHeight;
if(scaleX >= scaleY && scaleX > 1){
    scale = scaleX;
}
else if(scaleY > scaleX && scaleY > 1){
    scale = scaleY;
}

按缩放比例加载图片

 //设置缩放比例
 opts.inSampleSize = scale;
 //为图片申请内存
 opts.inJustDecodeBounds = false;
 Bitmap bm = BitmapFactory.decodeFile("sdcard/dog.jpg", opts);
 iv.setImageBitmap(bm);

在内存中创建图片的副本

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

 //加载原图
 Bitmap srcBm = BitmapFactory.decodeFile("sdcard/photo3.jpg");
 iv_src.setImageBitmap(srcBm);

 //创建与原图大小一致的空白bitmap
 Bitmap copyBm = Bitmap.createBitmap(srcBm.getWidth(), srcBm.getHeight(), srcBm.getConfig());
 //定义画笔
 Paint paint = new Paint();
 //把纸铺在画版上
 Canvas canvas = new Canvas(copyBm);
 //把srcBm的内容绘制在copyBm上
 canvas.drawBitmap(srcBm, new Matrix(), paint);

 iv_copy.setImageBitmap(copyBm);

对图片进行特效处理

首先定义一个矩阵对象
Matrix mt = new Matrix();
缩放效果

 //x轴缩放1倍，y轴缩放0.5倍
 mt.setScale(1, 0.5f);

旋转效果

//以copyBm.getWidth() / 2, copyBm.getHeight() / 2点为轴点，顺时旋转30度
mt.setRotate(30, copyBm.getWidth() / 2, copyBm.getHeight() / 2);

平移

//x轴坐标+10，y轴坐标+20
mt.setTranslate(10, 20);

镜面

//把X坐标都变成负数
mt.setScale(-1, 1);
//图片整体向右移
mt.postTranslate(copyBm.getWidth(), 0);

倒影

//把Y坐标都变成负数
mt.setScale(1, -1);
//图片整体向下移
mt.postTranslate(0, copyBm.getHeight());

画画板

在Android 中可以给View 控件设置触摸事件监听，这些触摸事件包括用户点击下去
（ACTION_DOWN），移动(ACTION_MOVE)和抬起(ACTION_UP)。随手涂鸦就是给ImageView（所有的控件都是View 的子类，都具备触摸监听功能）设置触摸监听事件，然后在ImageView 控件上进行绘制线条操作。

当用户ACTION_DOWN 的时候获取当前的x 和y 坐标作为要绘制线条的起始坐标，当
ACTION_MOVE（该事件只要用户在滑动就不断的被调用）的时候不断的获取新的x 和y 坐标，将新的坐标作为要绘制线条的结束坐标就可以绘制一条直线，然后将结束坐标再作为新线条的起始坐标，依次类推，就能绘制出无限多个小直线，这些直线最终看起来就像是曲线的效果了。

最后可以将绘制好的图片保存到本地文件中。

记录用户触摸事件的XY坐标，绘制直线。给ImageView设置触摸侦听，得到用户的触摸事件，并获知用户触摸ImageView的坐标

iv.setOnTouchListener(new OnTouchListener() {

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        // TODO Auto-generated method stub
        switch (event.getAction()) {
        //触摸屏幕
        case MotionEvent.ACTION_DOWN:
            //得到触摸屏幕时手指的坐标
            startX = (int) event.getX();
            startY = (int) event.getY();
            break;
        //在屏幕上滑动
        case MotionEvent.ACTION_MOVE:
            //用户滑动手指，坐标不断的改变，获取最新坐标
            int newX = (int) event.getX();
            int newY = (int) event.getY();
            //用上次onTouch方法得到的坐标和本次得到的坐标绘制直线
            canvas.drawLine(startX, startY, newX, newY, paint);
            iv.setImageBitmap(copyBm);
            startX = newX;
            startY = newY;
            break;

        }
        return true;
    }
});

刷子效果，加粗画笔

 paint.setStrokeWidth(8);

调色板，改变画笔颜色

paint.setColor(Color.GREEN);

保存图片至SD卡

FileOutputStream fos = null;
try {
    fos = new FileOutputStream(new File("sdcard/dazuo.png"));
} catch (FileNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
}
//保存图片
copyBm.compress(CompressFormat.PNG, 100, fos);

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

Intent intent = new Intent();
intent.setAction(Intent.ACTION_MEDIA_MOUNTED);
intent.setData(Uri.fromFile(Environment.getExternalStorageDirectory()));
sendBroadcast(intent);

案例4：画画板

public class MainActivity extends Activity {

    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);

        //加载画画板的背景图
        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("sdcard/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卡就绪广播
        Intent intent = new Intent();
        intent.setAction(Intent.ACTION_MEDIA_MOUNTED);
        intent.setData(Uri.fromFile(Environment.getExternalStorageDirectory()));
        sendBroadcast(intent);
    }
}

撕衣服

把穿内衣和穿外衣的照片重叠显示，内衣照在下面，用户滑动屏幕时，触摸的是外衣照，把手指经过的像素都置为透明，内衣照就显示出来了

使用帧布局叠加2 个ImageView，每个ImageView 负责显示一张图片，一张图片有衣服，一张图片没有衣服，没有衣服的图片放置在下面，有衣服的图片放置在上面。给上面的ImageView 设置触摸的事件，当手指触摸到图片上时，将手指触摸到的点周边的图片的像素点设置为透明的，这样下面的图片就一点一点显示出来了，从而有一种“撕衣服”的感觉。

在编写该案例的时候应该注意的事项如下：

1、触摸事件onTouch 的返回值必须设置为true，否则触摸的事件将不被处理
2、使用BitmapFactory 的decodeResouces 方法得到的图片是没有透明度的，即图片格式为RGB_565,所
以若想能够修改透明度，需要使用Canvas 对象对图片进行重绘，重新绘制的图片格式采用ARGB。
3、加载图片时需要对其进行一下压缩，防止图片与控件大小不匹配，导致触摸时点对不上，达不到触
摸哪里就设置哪里的像素点透明的效果。

 iv.setOnTouchListener(new OnTouchListener() {

    @Override
    public boolean onTouch(View v, MotionEvent event) {
        switch (event.getAction()) {
        case MotionEvent.ACTION_MOVE:
            int newX = (int) event.getX();
            int newY = (int) event.getY();
            //把指定的像素变成透明
            copyBm.setPixel(newX, newY, Color.TRANSPARENT);
            iv.setImageBitmap(copyBm);
            break;

        }
        return true;
    }
});

每次只设置一个像素点太慢，以触摸的像素为圆心，半径为5画圆，圆内的像素全部置为透明

for (int i = -5; i < 6; i++) {
    for (int j = -5; j < 6; j++) {
        if(Math.sqrt(i * i + j * j) <= 5)
            copyBm.setPixel(newX + i, newY + j, Color.TRANSPARENT);
    }
}

案例5：撕衣服

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 = -5; i <= 5; i++){
                        for(int j = -5; j <= 5; j++){
                            //把用户划过的坐标置为透明色
                            //改变指定的像素颜色
                            if(Math.sqrt(i*i + j*j) <= 5){
                                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等方法

private void play() {
    // TODO Auto-generated method stub
    player.reset();
    try {
        player.setDataSource("sdcard/bzj.mp3");
        player.prepare();
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } 
    player.start();

}
private void pause() {
    player.pause();
}
private void stop() {
    player.stop();
}
private void continuePlay() {
    player.start();
}

把这几个方法抽取成一个接口MusicInterface
定义一个中间人类，继承Binder，实现MusicInterface
先start启动MusicService，再bind

Intent intent = new Intent(this, MusicService.class);
startService(intent);
bindService(intent, conn, BIND_AUTO_CREATE);

根据播放进度设置进度条

获取当前的播放时间和当前音频的最长时间

int currentPosition = player.getCurrentPosition();
int duration = player.getDuration();

播放进度需要不停的获取，不停的刷新进度条，使用计时器每500毫秒获取一次播放进度
发消息至Handler，把播放进度放进Message对象中，在Handler中更新SeekBar的进度

Timer timer = new Timer();
timer.schedule(new TimerTask() {

    @Override
    public void run() {
        int currentPosition = player.getCurrentPosition();
        int duration = player.getDuration();
        Message msg = Message.obtain();
        //把播放进度存入Message中
        Bundle data = new Bundle();
        data.putInt("currentPosition", currentPosition);
        data.putInt("duration", duration);
        msg.setData(data);
        MainActivity.handler.sendMessage(msg);
    }
}, 5, 500);

在Activity中定义Handler

static Handler handler = new Handler(){
    public void handleMessage(android.os.Message msg) {
        //取出消息携带的数据
        Bundle data = msg.getData();
        int currentPosition = data.getInt("currentPosition");
        int duration = data.getInt("duration");

        //设置播放进度
        sb.setMax(duration);
        sb.setProgress(currentPosition);
    };
};

拖动进度条改变播放进度

 //给sb设置一个拖动侦听
 sb.setOnSeekBarChangeListener(new OnSeekBarChangeListener() {
    //停止拖动时调用
    @Override
    public void onStopTrackingTouch(SeekBar seekBar) {
        // TODO Auto-generated method stub
        int progress = seekBar.getProgress();
        mi.seekTo(progress);
    }
    //开始拖动时调用           
    @Override
    public void onStartTrackingTouch(SeekBar seekBar) {
        // TODO Auto-generated method stub

    }
    //拖动的时候不断调用         
    @Override
    public void onProgressChanged(SeekBar seekBar, int progress,
            boolean fromUser) {
        // TODO Auto-generated method stub

    }
});

视频播放器

SurfaceView

对画面的实时更新要求较高
双缓冲技术：内存中有两个画布，A画布显示至屏幕，B画布在内存中绘制下一帧画面，绘制完毕后B显示至屏幕，A在内存中继续绘制下一帧画面
播放视频也是用MediaPlayer，不过跟音频不同，要设置显示在哪个SurfaceView

SurfaceView sv = (SurfaceView) findViewById(R.id.sv);
 SurfaceHolder sh = sv.getHolder();

 MediaPlayer player = new MediaPlayer();
 player.reset();
 try {
     player.setDataSource("sdcard/2.3gp");
     player.setDisplay(sh);
     player.prepare();
 } catch (Exception e) {
     e.printStackTrace();
 }
 player.start();

SurfaceView是重量级组件，可见时才会创建
给SurfaceHolder设置CallBack，类似于侦听，可以知道SurfaceView的状态
SurfaceView一旦不可见，就会被销毁，一旦可见，就会被创建，销毁时停止播放，再次创建时再开始播放

sh.addCallback(new Callback() {
    //SurfaceView销毁时调用
    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // TODO Auto-generated method stub

    }
    //SurfaceView创建时调用
    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // TODO Auto-generated method stub

    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,
            int height) {
        // TODO Auto-generated method stub

    }
});

摄像头

启动系统提供的拍照程序

 //隐式启动系统提供的拍照Activity
 Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
 //设置照片的保存路径
 File file = new File(Environment.getExternalStorageDirectory(), "haha.jpg"); 
 intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file)); 
 startActivityForResult(intent, 0);

启动系统提供的摄像程序

 Intent intent = new Intent(MediaStore.ACTION_VIDEO_CAPTURE);

 File file = new File(Environment.getExternalStorageDirectory(), "haha.3gp"); 
 intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(file)); 
 //设置保存视频文件的质量
 intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
 startActivityForResult(intent, 0);

多媒体编程

文本、图片、音频、视频

图片

图片在计算机中的大小
图片的总大小 = 图片的总像素 * 每个像素占用的大小
单色位图：只能表示2种颜色
- 使用两个数字：0和1
- 使用一个长度为1的二进制数字就可以表示了
- 每个像素占用1/8个字节
16色位图：能表示16种颜色
- 需要16个数字：0-15，0000 - 1111
- 使用一个长度为4的二进制数组就可以表示了
- 每个像素占用1/2个字节
256色位图：能表示256种颜色
- 需要256个数字：0 - 255,0000 0000 - 1111 1111
- 使用一个长度为8的二进制数字
- 每个像素占用1个字节
24位位图：
- 每个像素占用24位，也就是3个字节，所在叫24位位图
- R：0-255,需要一个长度为8的二进制数字，占用1个字节
- G：0-255,需要一个长度为8的二进制数字，占用1个字节
- B：0-255,需要一个长度为8的二进制数字，占用1个字节

加载大图片

计算机把图片所有像素信息全部解析出来，保存至内存
Android保存图片像素信息，是用ARGB保存
手机屏幕320*480，总像素：153600
图片宽高2400*3200，总像素7680000
2400 / 320 = 7
3200 / 480 = 6

创建图片副本

在内存中创建一个图片的拷贝

保存图片

SD每次准备的时候，系统其实是遍历sd卡所有文件，系统会把所有的多媒体文件，都在MediaStore数据库中生成一个索引，数据库中保存了文件的文件名、路径、大小、长度和艺术家
图库、音乐、视频程序每次启动时，其实不会去遍历sd卡寻找多媒体文件，而是直接从MediaStore数据库中读取多媒体文件，通过库中的索引找到对应的多媒体文件后，把文件显示在界面

SurfaceView

双缓冲技术
重量级组件
只要不可见，就不会创建，可见时，才会创建
只要不可见，就会销毁

FFMPEG

开源免费的音视频编解码器

Vitamio

封装了FFMPEG的视频播放框架
对外提供的api全部都是javaApi

案例1：加载大图片

public class MainActivity extends Activity {

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


    public void click(View v){
        //解析图片时需要使用到的参数都封装在这个对象里了
        Options opt = new Options();
        //不为像素申请内存，只获取图片宽高
        opt.inJustDecodeBounds = true;
        BitmapFactory.decodeFile("sdcard/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("sdcard/dog.jpg", opt);

        ImageView iv = (ImageView) findViewById(R.id.iv);
        iv.setImageBitmap(bm);
    }

}

案例2：创建图片的副本

public class MainActivity extends Activity {

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

        //这个对象是只读的
        Bitmap bmSrc = BitmapFactory.decodeFile("sdcard/photo3.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);
    }    
}

案例3：图片的简单特效

public class MainActivity extends Activity {

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

        //这个对象是只读的
        Bitmap bmSrc = BitmapFactory.decodeFile("sdcard/photo3.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.开始作画，把原图的内容绘制在白纸上
        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());
        canvas.drawBitmap(bmSrc, mt, 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);
    }
}

案例6：播放音乐

package com.itheima.musicplayer;

public interface MusicInterface {

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

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("sdcard/zxmzf.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 class MainActivity extends Activity {

    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) {
            }
        });


        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);
    }

}

案例7：播放视频

public class MainActivity extends Activity {
    private MediaPlayer player;
    static int currentPosition;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        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("sdcard/2.3gp");
//                          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("sdcard/2.3gp");
                        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

            }
        });

    }


}

案例8：VideoView

public class MainActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        //检测是否支持vitamio
        if (!LibsChecker.checkVitamioLibs(this)) {return;}

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

        vv.setVideoPath("sdcard/4.rmvb");
        vv.start();

        vv.setMediaController(new MediaController(this));
    }
}

案例9：摄像头

public class MainActivity extends Activity {

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

    public void image(View v){
        //启动系统提供的拍照activity
        Intent intent = new Intent();
        intent.setAction(MediaStore.ACTION_IMAGE_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(Environment.getExternalStorageDirectory(), "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){
            Toast.makeText(this, "拍照成功", 0).show();
        }
        else if(requestCode == 20){
            Toast.makeText(this, "摄像成功", 0).show();
        }
    }

    public void video(View v){
        //启动系统提供的摄像activity
        Intent intent = new Intent();
        intent.setAction(MediaStore.ACTION_VIDEO_CAPTURE);
        intent.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(new File(Environment.getExternalStorageDirectory(), "haha.3gp")));
        intent.putExtra(MediaStore.EXTRA_VIDEO_QUALITY, 1);
        startActivityForResult(intent, 20);
    }

}