Camerapreview

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {

	static final String TAG = "CameraPreview";
	private static final int PICTURE_SIZE_MAX_WIDTH = 640/*1280*/;
	private static final int PREVIEW_SIZE_MAX_WIDTH = 640;
	public static final double ASPECT_RATIO = (double)10.0 / 9.0;

	protected Activity mActivity;
	protected SurfaceHolder mHolder;
	protected Camera mCamera;
	protected Camera.Size mPreviewSize;
	protected Camera.Size mPictureSize;
	protected int mCameraId;
	private int mCameraCount;



	public CameraPreview(Context context) {
		super(context);
		init();
	}

	@SuppressWarnings("deprecation")
	private void init(){
		mActivity = (Activity) getContext();

		mHolder = getHolder();
		setKeepScreenOn(true);
		mHolder.addCallback(this);

		if(TlDevice.getSDKVersion() < VERSION_CODES.HONEYCOMB){
			mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
		}

		mCameraId = 0;

		if (TlDevice.getSDKVersion() >= Build.VERSION_CODES.GINGERBREAD) {
			mCamera = Camera.open(mCameraId);
		} else {
			mCamera = Camera.open();
		}

		mCameraCount = Camera.getNumberOfCameras();
		mPreviewSize = determineBestPreviewSize(mCamera.getParameters());

	}

	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		int width = getMeasuredWidth();
		int height = (int) (width * ASPECT_RATIO);
		setMeasuredDimension(width, height);
	}


	@Override
	public void surfaceCreated(SurfaceHolder holder) {
			initCameraPreiview();
	}

	private void initCameraPreiview(){
		try {
			Camera.Parameters params = mCamera.getParameters();
			Camera.Size previewSize = determineBestPreviewSize(params);
			Camera.Size pictureSize = determineBestPictureSize(params);

			params.setPreviewSize(previewSize.width, previewSize.height);
			params.setPictureSize(pictureSize.width, pictureSize.height);

			setFocustModes(params);

			configureCameraParameters(params, true);

			mCamera.setParameters(params);
			mCamera.setPreviewDisplay(mHolder);
			mCamera.startPreview();
		} catch (IOException e) {
			mCamera.release();
			mCamera = null;
		}
	}

	private void setFocustModes(Camera.Parameters params){
		try {

		List<String> focusModes = params.getSupportedFocusModes();
		if(focusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)){
			params.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
		}
		} catch (Exception e) {
			PrintLog.debug("CameraPreview","Error on focus mode set>"+ e);
		}
	}


	@Override
	public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
		doSurfaceChanged(width, height);
	}

	private void doSurfaceChanged(int width, int height) {
		if (mHolder.getSurface() == null){
	          return;
	        }
		mCamera.stopPreview();

		Camera.Parameters cameraParams = mCamera.getParameters();
		boolean portrait = isPortrait();

		Camera.Size previewSize = determineBestPreviewSize(cameraParams);
		Camera.Size pictureSize = determineBestPictureSize(cameraParams);
		mPreviewSize = previewSize;
		mPictureSize = pictureSize;
		configureCameraParameters(cameraParams, portrait);

		try {
			mCamera.startPreview();
		} catch (Exception e) {
		}
	}

	public void changeCamera(){
		if(mCameraCount > 1){
			mCameraId = (mCameraId == 0? 1 : 0);
			stop();
			mCamera = Camera.open(mCameraId);
			initCameraPreiview();
		}
	}

	private Size determineBestPreviewSize(Camera.Parameters parameters) {
		if(mPreviewSize != null){
			return mPreviewSize;
		}

		List<Size> sizes = parameters.getSupportedPreviewSizes();
		Camera.Size size = determineBestSize(sizes, PREVIEW_SIZE_MAX_WIDTH);
		mPreviewSize = size;
		return size;
	}

	private Size determineBestPictureSize(Camera.Parameters parameters) {
		if(mPictureSize != null){
			return mPictureSize;
		}

		List<Size> sizes = parameters.getSupportedPictureSizes();
		Camera.Size size = determineBestSize(sizes, PICTURE_SIZE_MAX_WIDTH);
		mPictureSize = size;
		return size;
	}

	protected Size determineBestSize(List<Size> sizes, int maxWidth){
		Size bestSize = null;
		float MIN = Float.MAX_VALUE;

		for (Size currentSize : sizes) {
			float scale = (float)currentSize.width / (float)currentSize.height;
			if(scale < MIN && currentSize.width <= maxWidth && currentSize.width > 352){
				MIN = scale;
				bestSize = currentSize;
			}
		}

		if(bestSize == null){
			bestSize = sizes.get(sizes.size() - 1);
		}
		return bestSize;
	}


	private void configureCameraParameters(Camera.Parameters cameraParams, boolean portrait) {

		android.hardware.Camera.CameraInfo info =
				new android.hardware.Camera.CameraInfo();
		android.hardware.Camera.getCameraInfo(mCameraId, info);
		int rotation = mActivity.getWindowManager().getDefaultDisplay().getRotation();
		int degrees = 0;

		switch (rotation) {
		case Surface.ROTATION_0: degrees = 0; break;
		case Surface.ROTATION_90: degrees = 90; break;
		case Surface.ROTATION_180: degrees = 180; break;
		case Surface.ROTATION_270: degrees = 270; break;
		}

		int result;


		if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
			result = (info.orientation + degrees) % 360;
			result = (360 - result) % 360;  // compensate the mirror
		} else {  // back-facing
			result = (info.orientation - degrees + 360) % 360;
		}


		mCamera.setDisplayOrientation(result);

		mCamera.setParameters(cameraParams);
	}

	@Override
	public void surfaceDestroyed(SurfaceHolder holder) {
		stop();
	}

	public void stop() {
		if (null == mCamera) {
			return;
		}
		mCamera.stopPreview();
		mCamera.release();
		mCamera = null;
	}

	public boolean isPortrait() {
		return (mActivity.getResources().getConfiguration().orientation == Configuration.ORIENTATION_PORTRAIT);
	}

	public Camera.Size getPreviewSize() {
		return mPreviewSize;
	}

}