详记Android打开相机拍照流程-CSDN博客

写在前面

本文并不是基于Camera2的，所以想要了解Camera2的同学可以先散了。文题加了详记二字，因为相机整个打开的流程的确是比较复杂的，稍有疏忽可能就会引发一系列问题。我也是看了一下Android的文档才整理了这篇文章，想看原文的戳这。不得不说，文档还是详细啊~

本文主要会涉及以下内容：

相机的使用流程
拍照及拍照期间的聚焦
保存图片

先放一下最终效果图吧，做的比较简单，各位不用担心：

主要功能就是拍照保存，多的也没啥了，项目地址在文末有。

使用流程

在详细的研究相机之前，首先熟悉一下使用相机的整个流程：

检测和访问相机：创建代码检测相机的存在和请求访问
创建预览类：创建继承自SurfaceView和实现SurfaceHolder接口的预览类。这个类展示来自相机的实时图片
创建一个预览布局：如果你有相机预览类，你就需要创建一个和用户交互的界面布局
为拍照或者录像设置监听：对用户的行为作出响应，你要为你的控件设置监听去开始拍照或者录像，比如你设置了一个拍照的按钮，用户点击之后就要开始拍照。监听用户行为只是其一，还有就是拍照的监听，这个放到后文讨论
捕获和保存文件：无论是拍照还是录像，都需要有保存的功能
释放相机：在不使用相机时候，你的应用一定要释放相机。

那么为什么一定要释放相机资源呢？因为相机硬件是一个共享临界资源，不仅你的应用会使用，其他的应用也会使用相机。所以在不用相机的时候，一定要释放相机，不然你自己的应用和后续其他要使用相机的应用都无法使用相机。

流程大致就是这样，接下来一步一步的跟进，看看这个相机到底特么的是怎么用的。

申请权限

Android 6.0之前 & targetSdkVersion < 23 只需要在清单文件中声明一下权限就行

<uses-permission android:name="android.permission.CAMERA" />
<uses-feature android:name="android.hardware.camera" />
复制代码

上面那个uses-feature，文档中说如果声明了这个，在Google Play中会阻止没有相机的设备下载你的应用。国内的应用商店就不知道了= =。在Android 6.0之后且targetSdkVersion >= 23就需要申请相机权限了。我们可以在Activity的onResume中检测是否拥有相机权限，如果拥有权限就进行下一步的操作，如果没有就申请权限，并在回调中检测是否申请成功，成功的话就进行下一步操作。代码如下：

    @Override
    protected void onResume() {
        super.onResume();
        // 检查权限
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) !=
                PackageManager.PERMISSION_GRANTED) {
            // 申请权限
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, 1);
        } else {
            // 已有权限
            startCameraPre();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // 如果权限申请成功
            startCameraPre();
        } else {
            Toast.makeText(this, "您已拒绝打开相机，想要使用此功能请手动打开相机权限", Toast.LENGTH_SHORT).show();
        }
    }
复制代码

检测相机是否存在

在使用之前需要先检测一下设备是否有相机：

    /**
     * 检查是否拥有相机
     *
     * @return 如果有返回true，没有返回false
     */
    public static boolean checkCameraHardware(Context context) {
        if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
            // 有相机
            Log.i(TAG, "有相机");
            return true;
        } else {
            // 没有相机
            Log.i(TAG, "没有相机");
            return false;
        }
    }
复制代码

代码比较简单，比较坑爹的是什么呢？有一些嵌入式设备的Android系统通过这个方法是无法获取到到底特么的是有没有相机的。获取的可能是错误的信息，我在我们的设备上用这个代码检测，明明没有相机也判断成有相机了。如果一定要判断……还是有办法的，直接Camera.open试一试，成功就说明有，失败就……就失败了呗。

访问相机

访问相机的代码比较简单，就是通过Camera.open方法拿到一个Camera的实例，需要注意的是这个open方法可能会引发异常，最好还是要try catch一下的。

    /**
     * 获取前置相机实例，注意6.0以上的系统需要动态申请权限（如果
     * target >= 23）则必须动态申请，否则无法打开相机
     *
     * @return 打开成功则返回相机实例，失败则返回null
     */
    public static Camera getCameraInstance() {
        Camera c;
        try {
            c = Camera.open(Camera.CameraInfo.CAMERA_FACING_BACK);
        } catch (Exception e) {
            e.printStackTrace();
            // 相机正在使用或者不存在
            Log.e(TAG, "相机打开失败，正在使用或者不存在，或者，没有权限？");
            return null;
        }
        return c;
    }
复制代码

Android 2.3版本以后可以通过Camera.open(int)来打开指定的相机，我这里打开了后置摄像头。

创建预览类

预览类就是用来播放相机画面的类，预览类是继承自SurfaceView的。普通的View以及其子类都是共享同一个surface的，所有的绘制都必须在UI线程进行。而SurfaceView是一种比较特殊的view，他并不与其他view共享surface，而是在内部持有了一个独立的surface，SurfaceView负责管理这个surface的格式、尺寸以及显示位置。由于UI线程还要同事处理其他交互逻辑，因此对View的更新速度和帧率无法保证，而surfaceview由于持有一个独立的surface，因而可以在独立的线程中进行绘制，因此可以提供更高的帧率。自定义相机的预览图像由于对更新速度和帧率要求比较高，所以比较适合用surfaceview来显示。(关于surfaceview的介绍摘自Android自定义相机详细讲解）

介绍了这么多，对SurfaceView大概有个了解就可以了，这个类和相机的声明周期息息相关，需要实现SurfaceHolder.Callback接口来接收View创建和销毁的事件。代码如下：

package com.xiasuhuei321.cameradieorme.camera;

/**
 * Created by xiasuhuei321 on 2017/8/22.
 * author:luo
 * e-mail:xiasuhuei321@163.com
 */

import android.content.Context;
import android.hardware.Camera;
import android.os.Environment;
import android.os.Handler;
import android.os.Looper;
import android.text.format.DateFormat;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;


public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback, Camera.AutoFocusCallback, Camera.PictureCallback {
    public static final String TAG = "CameraPreview";
    public static final String DIRNAME = "MyCamera";

    private SurfaceHolder mHolder;
    private Camera mCamera;
    private boolean canTake = false;
    private Context context;

    public CameraPreview(Context context) {
        super(context);
        this.context = context;
        // Install a SurfaceHolder.Callback so we get notified when the
        // underlying surface is created and destroyed.
        mHolder = getHolder();
        // deprecated setting, but required on Android versions prior to 3.0
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

        Log.i(TAG, "CameraPreview被创建 " + this.hashCode());
    }

    /**
     * surface在很多情况下都会被销毁，这个时候相机也会被释放。
     * 而这个类的camera就无法再使用了，所以需要外部再传入一个
     * 正确的Camera实例
     *
     * @param mCamera Camera实例
     */
    public void setCamera(Camera mCamera) {
        this.mCamera = mCamera;
        mHolder.addCallback(this);
        surfaceCreated(getHolder());
        Log.i(TAG, "serCamera" + " release = " + CameraUtil.getInstance().isRelease());
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        // surface创建完毕，camera设置预览
        Log.i(TAG, "surface view被创建");
        if (CameraUtil.getInstance().isRelease()) return;
        try {
            mCamera.setPreviewDisplay(holder);
            mCamera.startPreview();
        } catch (IOException e) {
            Log.d(TAG, "Error setting camera preview: " + e.getMessage());
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // 在这里可以释放相机资源
        // 也可以在Activity中释放
        Log.i(TAG, "surface 被销毁 ");
        holder.removeCallback(this);
        // 停止回调，以防释放的相机再被使用导致异常
        mCamera.setPreviewCallback(null);
        // 停止预览
        mCamera.stopPreview();
        mCamera.lock();
        // 释放相机资源
        CameraUtil.getInstance().releaseCamera();
        mCamera = null;

    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        // If your preview can change or rotate, take care of those events here.
        // Make sure to stop the preview before resizing or reformatting it.
        if (mHolder.getSurface() == null) {
            // preview surface does not exist
            return;
        }

        // stop preview before making changes
        try {
            mCamera.stopPreview();
        } catch (Exception e) {
            // ignore: tried to stop a non-existent preview
        }

        // set preview size and make any resize, rotate or
        // reformatting changes here

        // start preview with new settings
        try {
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();

        } catch (Exception e) {
            Log.d(TAG, "Error starting camera preview: " + e.getMessage());
        }

    }

    /**
     * 给外部调用，用来拍照的方法
     */
    public void takePhoto() {
        // 因为设置了聚焦，这里又设置了回调对象，所以重新开始预览之后
        // 需要一个标志判断是否是拍照的聚焦回调
        canTake = true;
        // 首先聚焦
        mCamera.autoFocus(this);
//        mCamera.takePicture(null, null, this);
    }

    @Override
    public void onAutoFocus(boolean success, final Camera camera) {
        Log.i(TAG, "聚焦： " + canTake);
        // 不管聚焦成功与否，都开始拍照
        if (canTake) {
            camera.takePicture(null, null, CameraPreview.this);
        }
        canTake = false;
        // 延时一秒，重新开始预览
        new Handler(Looper.getMainLooper()).postDelayed(new Runnable() {
            @Override
            public void run() {
                mCamera.startPreview();
            }
        }, 1000);
    }

    @Override
    public void onPictureTaken(final byte[] data, Camera camera) {
        Log.i(TAG, "onPictureTaken");
        // 在子线程中进行io操作
        new Thread(new Runnable() {
            @Override
            public void run() {
                saveToSd(data);
            }
        }).start();
    }


    /**
     * 将照片保存至sd卡
     */
    private void saveToSd(byte[] data) {
        // 创建位图，这一步在图片比较大的时候可能会抛oom异常，所以跳过这一步，直接将byte[]
        // 数据写入文件，而且如果有进行图片处理的需求，尽量不要另外再申请内存，不然很容易
        // oom。所以尽量避免在这里处理图片
//        Bitmap bitmap = BitmapFactory.decodeByteArray(data, 0, data.length);
        // 系统时间
        long dateTaken = System.currentTimeMillis();
        // 图像名称
        String fileName = DateFormat.format("yyyy-MM-dd kk.mm.ss", dateTaken).toString() + ".jpg";

        FileOutputStream fos = null;
        if (Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED)) {
            String filePath = Environment.getExternalStorageDirectory() + File.separator +
                    DIRNAME + File.separator + fileName;
            Log.i(TAG, "文件路径：" + filePath);
            File imgFile = new File(filePath);
            if (!imgFile.getParentFile().exists()) {
                imgFile.getParentFile().mkdirs();
            }
            try {
                if (!imgFile.exists()) {
                    imgFile.createNewFile();
                }

                fos = new FileOutputStream(imgFile);
//                bitmap.compress(Bitmap.CompressFormat.JPEG, 100, bos);
                fos.write(data);
                fos.flush();
                insertIntoMediaPic();
            } catch (Exception e) {

            } finally {
                try {
                    if (fos != null) {
                        fos.close();//关闭
                    }
                } catch (Exception e) {
                    e.printStackTrace();
                }

            }
        } else {
            // sd卡状态异常，直接插入系统相册
            // 暂时是空实现
            insertIntoMediaPic();
        }

    }

    private void insertIntoMediaPic() {

    }
}

复制代码

这个类可以说是字字血泪，各位看的时候可以结合注释看……每一个我被坑过的地方我都详细的注释了出来。真的是都在代码里了。关于图片处理那一块我是没什么比较好的办法，内存所限，在拿到byte[] data 这个图片数据数组，我直接在转成Bitmap那一步就OOM了，后来看了一下我这里选取的是4160 * 2340的分辨率，直接写入文件一张图也有4~5M，这个时候的问题就是生成一个Bitmap需要申请很大的内存，而原来的data数组因为这个方法还没结束也无法释放（Java参数传递是引用拷贝传递，所以这时候依然有引用指向内存中的data对象，GC无法回收这块内存），所以就算后续你不额外申请内存，有方法在原有的Bitmap对象上进行操作，也是不行的，因为在生成的时候就OOM了。

创建预览布局

这里Android文档中的建议是在布局中放置一个FrameLayout作为相机预览类的父容器，我采用了这种做法，布局如下：

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="horizontal">

    <FrameLayout
        android:id="@+id/camera_preview"
        android:layout_width="match_parent"
        android:layout_height="match_parent" />

    <ImageView
        android:id="@+id/iv_take"
        android:layout_width="80dp"
        android:layout_height="80dp"
        android:layout_alignParentBottom="true"
        android:layout_centerHorizontal="true"
        android:layout_marginBottom="16dp"
        android:src="@drawable/takephoto" />
</RelativeLayout>
复制代码

布局比较简单，就一个FrameLayout和一个ImageView，点击ImageView开始拍照。

接下来看一下Activity的代码：

package com.xiasuhuei321.cameradieorme.camera;

import android.Manifest;
import android.animation.ObjectAnimator;
import android.content.pm.PackageManager;
import android.hardware.Camera;
import android.os.Bundle;
import android.support.annotation.NonNull;
import android.support.annotation.Nullable;
import android.support.v4.app.ActivityCompat;
import android.support.v4.content.ContextCompat;
import android.support.v7.app.AppCompatActivity;
import android.view.MotionEvent;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;
import android.widget.FrameLayout;
import android.widget.Toast;

import com.xiasuhuei321.cameradieorme.R;

/**
 * Created by xiasuhuei321 on 2017/8/22.
 * author:luo
 * e-mail:xiasuhuei321@163.com
 */

public class CameraActivity extends AppCompatActivity {

    private Camera camera;
    private FrameLayout preview;
    private CameraPreview mPreview;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        supportRequestWindowFeature(Window.FEATURE_NO_TITLE);
        setContentView(R.layout.activity_camera);
        getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
                WindowManager.LayoutParams.FLAG_FULLSCREEN);
        View iv_take = findViewById(R.id.iv_take);

        final ObjectAnimator scaleX = ObjectAnimator.ofFloat(iv_take, "scaleX", 1f, 0.8f);
        final ObjectAnimator scaleY = ObjectAnimator.ofFloat(iv_take, "scaleY", 1f, 0.8f);


        iv_take.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View v, MotionEvent event) {
                switch (event.getAction()) {
                    case MotionEvent.ACTION_DOWN:
                        v.setScaleX(0.9f);
                        v.setScaleY(0.9f);
                        scaleX.start();
                        scaleY.start();
                        break;
                    case MotionEvent.ACTION_UP:
                        v.setScaleX(1f);
                        v.setScaleY(1f);
                        scaleX.reverse();
                        scaleY.reverse();
                        break;
                }
                return false;
            }
        });
        iv_take.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View v) {
                mPreview.takePhoto();
            }
        });

        mPreview = new CameraPreview(this);
        CameraUtil.getInstance().init(this);
    }

    @Override
    protected void onResume() {
        super.onResume();
        // 检查权限
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) !=
                PackageManager.PERMISSION_GRANTED) {
            // 申请权限
            ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, 1);
        } else {
            // 已有权限
            startCameraPre();
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (requestCode == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // 如果权限申请成功
            startCameraPre();
        } else {
            Toast.makeText(this, "您已拒绝打开相机，想要使用此功能请手动打开相机权限", Toast.LENGTH_SHORT).show();
        }
    }

    private void startCameraPre() {
        if (CameraUtil.checkCameraHardware(this)) {
            camera = CameraUtil.getInstance().getCameraInstance();
        }
        mPreview.setCamera(camera);
        preview = (FrameLayout) findViewById(R.id.camera_preview);
        if (preview.getChildCount() == 0)
            preview.addView(mPreview);
    }
}

复制代码

在开始的时候写了两个属性动画，用户在点击的时候有点交互的感觉（貌似并没有什么luan用）。在onResume中检查是否拥有权限打开相机，因为6.0以上需要动态申请啊，蛋疼。拥有权限或者用户给了权限就执行startCameraPre方法，这个方法通过我自己写的CameraUtil获取并初始化了一个Camera实例。并且最后判断FrameLayout中是否有子View，如果没有就将我们自己的相机预览类添加进去。这样打开相机和拍照的整个流程就完成了，当然了，最后还得贴一下CameraUtil代码：

package com.xiasuhuei321.cameradieorme.camera;

import android.content.Context;
import android.content.pm.PackageManager;
import android.graphics.PixelFormat;
import android.graphics.Point;
import android.hardware.Camera;
import android.util.Log;
import android.view.WindowManager;

import java.util.List;

/**
 * Created by xiasuhuei321 on 2017/8/21.
 * author:luo
 * e-mail:xiasuhuei321@163.com
 */

public class CameraUtil {
    public static final String TAG = "CameraUtil";

    private Camera camera;
    private int cameraId;

    private int mScreenWidth;
    private int mScreenHeight;


    //    private Callback callback;
    private boolean release = false;
    private Camera.Parameters params;

    private CameraUtil() {
    }


    private static class CameraUtilHolder {
        private static CameraUtil instance = new CameraUtil();
    }

    public static CameraUtil getInstance() {
        return CameraUtilHolder.instance;
    }

    public void init(Context context) {
        WindowManager wm = (WindowManager) context.getSystemService(Context.WINDOW_SERVICE);
        Point p = new Point();
        wm.getDefaultDisplay().getSize(p);
        mScreenWidth = p.x;
        mScreenHeight = p.y;
    }

    /**
     * 检查是否拥有相机
     *
     * @return 如果有返回true，没有返回false
     */
    public static boolean checkCameraHardware(Context context) {
        if (context.getPackageManager().hasSystemFeature(PackageManager.FEATURE_CAMERA)) {
            // 有相机
            return true;
        } else {
            // 没有相机
            return false;
        }
    }

    /**
     * 获取前置相机实例，注意6.0以上的系统需要动态申请权限（如果
     * target >= 23）则必须动态申请，否则无法打开相机
     *
     * @return 打开成功则返回相机实例，失败则返回null
     */
    public Camera getCameraInstance() {
        if (camera != null) {
            Log.i(TAG, "camera已经打开过，返回前一个值");
            return camera;
        }
        try {
            camera = Camera.open(Camera.CameraInfo.CAMERA_FACING_BACK);
            cameraId = Camera.CameraInfo.CAMERA_FACING_BACK;
        } catch (Exception e) {
            e.printStackTrace();
            // 相机正在使用或者不存在
            Log.i(TAG, "相机打开失败，正在使用或者不存在，或者，没有权限？");
            return null;
        }
        initParam();
        release = false;
        return camera;
    }

    public void initParam() {
        if (camera == null) {
            return;
        }
        if (params != null) {
            camera.setParameters(params);
        } else {
            camera.setParameters(generateDefaultParams(camera));
        }
    }

    /**
     * 允许从外部设置相机参数
     *
     * @param params 相机参数
     */
    public void setParams(Camera.Parameters params) {
        this.params = params;
    }

    /**
     * 生成默认的相机参数
     *
     * @param camera 使用该参数的相机
     * @return 生成的参数
     */
    public Camera.Parameters generateDefaultParams(Camera camera) {
        Camera.Parameters parameters = camera.getParameters();
        // 设置聚焦
        if (parameters.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
            parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);// 连续对焦模式
        }
        camera.cancelAutoFocus();//自动对焦。
        // 设置图片格式
        parameters.setPictureFormat(PixelFormat.JPEG);
        // 设置照片质量
        parameters.setJpegQuality(100);
        if (cameraId == Camera.CameraInfo.CAMERA_FACING_BACK) {
            // 默认打开前置摄像头，旋转90度即可
            camera.setDisplayOrientation(90);
            parameters.setRotation(90);
        } else if (cameraId == Camera.CameraInfo.CAMERA_FACING_FRONT) {
            // 打开后置摄像头，旋转270，这个待验证
            camera.setDisplayOrientation(270);
            parameters.setRotation(180);
        }

        // 获取摄像头支持的PictureSize列表
        List<Camera.Size> picSizeList = parameters.getSupportedPictureSizes();
        for (Camera.Size size : picSizeList) {
            Log.i(TAG, "pictureSizeList size.width=" + size.width + "  size.height=" + size.height);
        }
        Camera.Size picSize = getProperSize(picSizeList, ((float) mScreenHeight / mScreenWidth));
        parameters.setPictureSize(picSize.width, picSize.height);

        // 获取摄像头支持的PreviewSize列表
        List<Camera.Size> previewSizeList = parameters.getSupportedPreviewSizes();
        for (Camera.Size size : previewSizeList) {
            Log.i(TAG, "previewSizeList size.width=" + size.width + "  size.height=" + size.height);
        }
        Camera.Size preSize = getProperSize(previewSizeList, ((float) mScreenHeight) / mScreenWidth);
        Log.i(TAG, "final size is: " + picSize.width + " " + picSize.height);
        if (null != preSize) {
            Log.i(TAG, "preSize.width=" + preSize.width + "  preSize.height=" + preSize.height);
            parameters.setPreviewSize(preSize.width, preSize.height);
        }

        return parameters;
    }

    private Camera.Size getProperSize(List<Camera.Size> pictureSizeList, float screenRatio) {
        Log.i(TAG, "screenRatio=" + screenRatio);
        Camera.Size result = null;
        for (Camera.Size size : pictureSizeList) {
            float currentRatio = ((float) size.width) / size.height;
            if (currentRatio - screenRatio == 0) {
                result = size;
                break;
            }
        }

        if (null == result) {
            for (Camera.Size size : pictureSizeList) {
                float curRatio = ((float) size.width) / size.height;
                if (curRatio == 4f / 3) {// 默认w:h = 4:3
                    result = size;
                    break;
                }
            }
        }

        return result;
    }

    /**
     * 释放相机资源
     */
    public void releaseCamera() {
        if (camera != null) {
            camera.release();
        }
        camera = null;
        release = true;
    }

    /**
     * 现在是否处于释放状态
     *
     * @return true释放，false没释放
     */
    public boolean isRelease() {
        return release;
    }

}

复制代码

这里需要注意的就是生成相机参数那一块了，Android中的相机默认是横向的，我们平时用的时候肯定不是那么用的，所以通过 camera.setDisplayOrientation(90)旋转90度调整一下。不过设置了这个之后，如果不设置parameters.setRotation(90)那么保存的图片方向也不对，设置了这个之后就可以了。不过我看网上很多都是采用自己生成Bitmap然后自己旋转……如果parameters.setRotation(90)这种方式可以完成的话，最好不要采用自己处理的方式了，内存开销太大了。关于资源的释放啊什么的，都在预览类里面注释写好了= = ，这里就不再赘述了。