CameraPreview

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {

    static final String TAG="CameraPreview";

    Camera mCamera;
    SurfaceHolder mHolder;
    Context ctx;

    @SuppressWarnings("deprecation")
    public CameraPreview(Context context,Camera camera) {
        super(context);
        this.ctx=context;
        mCamera=camera;
        mHolder=this.getHolder();
        mHolder.addCallback(this);
        mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
        if(holder.getSurface()==null)
        {
            return;
        }
        try
        {
            mCamera.stopPreview();
        }
        catch(Exception e)
        {
            Log.e("CamTestActivity","Tried to shut down non existant preview",e);
        }
        //Set orientation and display size here:
        Parameters params=mCamera.getParameters();
        Size previewSize=getBestPreviewSize(params);
        Size desiredPictureSize=getDesiredPictureSize(params);
        if(holder!=null && hasMacroFocus(params))
            params.setFocusMode(Parameters.FOCUS_MODE_MACRO);//only added in API 14...
        else if(holder!=null && hasAutoFocus(params)){
            params.setFocusMode(Parameters.FOCUS_MODE_AUTO);
            }
        else
        {
            Log.d("CameraPreview", "The holder has not been created yet or there is no autofocus");
        }

        params.setWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO);
        setCameraDisplayOrientation(ctx,Camera.CameraInfo.CAMERA_FACING_BACK, mCamera);
        params.setPreviewSize(previewSize.width, previewSize.height);
        params.setPictureSize(desiredPictureSize.width, desiredPictureSize.height);
        mCamera.setParameters(params);
        try {
            mCamera.setPreviewDisplay(holder);
        } catch (IOException e) {
            Log.e("CameraPreview", "Camera preview displayed could not be changed to mHolder",e);
        }
        mCamera.startPreview();
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        try
        {
            if(mCamera==null)
            {
                Log.e(TAG,"Camera is null here");
            }
            if(holder==null)
            {
                Log.d(TAG,"Holder provided by surfaceCreated is null");
            }
            mCamera.setPreviewDisplay(mHolder);
            mCamera.startPreview();
        }
        catch(IOException e)
        {
            Log.e("CameraPreview","Error getting camera preview",e);
        }
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        // TODO Auto-generated method stub
        //empty method...take care of this in your Activity
    }

    private Size getDesiredPictureSize(Parameters params)
    {
        //Resolution is widthxheight
        Size result=null;
        //boolean isDesiredValue=false;
        final int minArea=500*500;
        final int maxArea=1000*1000;
        List<Size> supportedSizeList=params.getSupportedPictureSizes();
        for(Size size:supportedSizeList)
        {
            if(size.width*size.height>minArea && size.width*size.height<maxArea)
            {
                if(result==null)
                    result=size;
                else
                {
                    int resultArea=result.width*result.height;
                    int sizeArea=size.width*size.height;
                    if(resultArea<sizeArea)
                    {
                        result=size;
                    }
                }
            }
        }
        return result;
    }

    private Size getBestPreviewSize(Parameters params)
    {
        Size result=null;
        ArrayList<Size> mSupportedSizes=(ArrayList<Size>) params.getSupportedPreviewSizes();
        for(Size size:mSupportedSizes)
        {

            if(result==null)
                result=size;
            else
            {
                int resultArea=result.width*result.height;
                int sizeArea=size.width*size.height;
                if(resultArea<sizeArea)
                    result=size;
            }

        }
        Log.d("CameraPreview", "Camera Preview size set to "+result.width+"X"+result.height);
        return result;
    }

    public boolean hasMacroFocus(Parameters params)
    {
        List<String> supportedFocusModes=params.getSupportedFocusModes();
        if(supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_MACRO))
            return true;
        return false;
    }

    public boolean hasAutoFocus(Parameters params)
    {
        List<String> focusModes=params.getSupportedFocusModes();

        if(focusModes!=null && focusModes.contains(Parameters.FOCUS_MODE_AUTO)){
            return true;
        }
        else if(focusModes==null)
        {
            Log.d("CameraPreview", "Error getting autofocus mode list");
        }
        return false;
    }

    public boolean hasAutoFlash(Parameters params)
    {
        List<String> supportedFlashModes=params.getSupportedFlashModes();
        if(supportedFlashModes.contains(Parameters.FLASH_MODE_AUTO))
            return true;
        return false;
    }


    //I have set orientation to landscape...if orientation issues persist...use this
    //code from developer.android.com-javadoc
       @TargetApi(Build.VERSION_CODES.GINGERBREAD)
       public static void setCameraDisplayOrientation(Context context,
         int cameraId, android.hardware.Camera camera) {
     android.hardware.Camera.CameraInfo info =
             new android.hardware.Camera.CameraInfo();
     android.hardware.Camera.getCameraInfo(cameraId, info);
     int rotation = ((Activity) context).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;
     }
     camera.setDisplayOrientation(result);
     Camera.Parameters params=camera.getParameters();
     params.setRotation(result);
     camera.setParameters(params);
 }
}