Android相机:stopPreview vs releaseCamera

问题描述

我正在开发一个应用程序，其中在viewPager内有一个摄像头.我想知道什么最适合暂停"和恢复"相机，以使其在预加载时不会占用资源.我觉得stopPreview更适合此操作，因为它不会释放相机，但会保留它，但是不会显示相机，这是浪费资源的主要原因.

I am making an application where I have a camera inside of a viewPager. I am wondering what would best be suited to "pause" and "resume" the camera so it doesn't hog resources when it is pre-loaded. I have the feeling that stopPreview is better suited for this as it does not release the camera but keeps it however it doesn't display the camera which is the main reason it hogs resources.

• 输入&退出应用程序:startCamera()& releaseCamera()
• 标签可见&不可见:startPreview()&停止Preview()

这是一个好的经验法则吗?

Would this be a good rule of thumb?

推荐答案

这处理了大多数操作CameraPreview.java:

package com.example.fela;

import android.app.Activity;
import android.content.Context;
import android.graphics.PixelFormat;
import android.hardware.Camera;
import android.hardware.Camera.ErrorCallback;
import android.hardware.Camera.Parameters;
import android.hardware.Camera.Size;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.WindowManager;

import java.util.List;

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {

    private SurfaceHolder holder;
    private Camera camera;
    private int cameraId;
    private Activity activity;
    private CameraPreviewActivityInterface activityInterface;

    public CameraPreview(Activity activity, int cameraId) {
        super(activity);
        try {
            activityInterface = (CameraPreviewActivityInterface) activity;
        } catch (ClassCastException e) {
            throw new ClassCastException(activity.toString() + " must implement ExampleFragmentCallbackInterface ");
        }
        this.activity = activity;
        this.cameraId = cameraId;
        holder = getHolder();
        holder.addCallback(this);
        // deprecated setting, but required on Android versions prior to 3.0
        holder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    public void surfaceCreated(SurfaceHolder holder) {}

    /**
     * custom camera tweaks and startPreview()
     */
    public void refreshCamera() {
        if (holder.getSurface() == null || camera == null) {
            // preview surface does not exist, camera not opened created yet
            return;
        }
        Log.i(null, "CameraPreview refreshCamera()");
        // stop preview before making changes
        try {
            camera.stopPreview();
        } catch (Exception e) {
            // ignore: tried to stop a non-existent preview
        }
        int rotation = ((WindowManager) activity.getSystemService(Context.WINDOW_SERVICE)).getDefaultDisplay().getRotation();
        int degrees = 0;
        // specifically for back facing camera
        switch (rotation) {
            case Surface.ROTATION_0:
                degrees = 90;
                break;
            case Surface.ROTATION_90:
                degrees = 0;
                break;
            case Surface.ROTATION_180:
                degrees = 270;
                break;
            case Surface.ROTATION_270:
                degrees = 180;
                break;
        }
        camera.setDisplayOrientation(degrees);
        setCamera(camera);
        try {
            camera.setPreviewDisplay(holder);
            camera.startPreview();
        } catch (Exception e) {
            // this error is fixed in the camera Error Callback (Error 100)
            Log.d(VIEW_LOG_TAG, "Error starting camera preview: " + e.getMessage());
        }
    }



    public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
        Log.i(null, "CameraPreview surfaceChanged()");
        // if your preview can change or rotate, take care of those events here.
        // make sure to stop the preview before resizing or reformatting it.
        // do not start the camera if the tab isn't visible
        if(activityInterface.getCurrentPage() == 1)
            startCamera();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {}

    public Camera getCameraInstance() {
        Camera camera = Camera.open();
        // parameters for camera
        Parameters params = camera.getParameters();
        params.set("jpeg-quality", 100);
        params.set("iso", "auto");
        params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
        params.setPictureFormat(PixelFormat.JPEG);
        // set the image dimensions
        List<Size> sizes = params.getSupportedPictureSizes();
        int max = 0, width = 0, height = 0;
        for(Size size : sizes) {
            if(max < (size.width*size.height)) {
                max = (size.width*size.height);
                width = size.width;
                height = size.height;
            }
        }
        params.setPictureSize(width, height);
        camera.setParameters(params);
        // primarily used to fix Error 100
        camera.setErrorCallback(new ErrorCallback() {
            @Override
            public void onError(int error, Camera camera) {
                if(error == Camera.CAMERA_ERROR_SERVER_DIED) {
                    releaseCamera();
                    startCamera();
                }
            }
        });
        return camera;
    }

    /**
     * intitialize a new camera
     */
    protected void startCamera() {
        if(getCamera() == null)
            setCamera(getCameraInstance());
        refreshCamera();
    }

    /**
     * release camera so other applications can utilize the camera
     */
    protected void releaseCamera() {
        // if already null then the camera has already been released before
        if (getCamera() != null) {
            getCamera().release();
            setCamera(null);
        }
    }

    public Camera getCamera() {
        return camera;
    }

    public void setCamera(Camera camera) {
        this.camera = camera;
    }

    public void setCameraId(int cameraId) {
        this.cameraId = cameraId;
    }

    /**
     * get the current viewPager page
     */
    public interface CameraPreviewActivityInterface {
        public int getCurrentPage();
    }
}

在我的FragmentCamera.java文件中:

private CameraPreview cameraPreview;

// code...

public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
    // code...
    cameraPreview = new CameraPreview(getActivity(), cameraId);
    previewLayout.addView(cameraPreview);
    // code...
}

// code...

@Override
public void onPause() {
    super.onPause();
    cameraPreview.releaseCamera();
}

@Override
public void onResume() {
    super.onResume();
    cameraPreview.startCamera();
}

protected void fragmentVisible() {
    onResume();
}

protected void fragmentNotVisible() {
    onPause();
}

和MainActivity.java文件(实现CameraPreviewActivityInterface):

And the MainActivity.java file (implements CameraPreviewActivityInterface):

viewPager.setOnPageChangeListener(new OnPageChangeListener() {
    @Override
    public void onPageScrolled(int position, float positionOffset, int positionOffsetPixels) {
    }
    @Override
    public void onPageSelected(int position) {
        currentPage = position;
        if (currentPage == 1) {
            fragmentCamera.fragmentVisible();
        } else {
            fragmentCamera.fragmentNotVisible();
        }
    }
    @Override
    public void onPageScrollStateChanged(int state) {
    }
});

@Override
public int getCurrentPage() {
    return currentPage;
}

这篇关于Android相机:stopPreview vs releaseCamera的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持！