Android Camera Preview Stretched

I'm using this method -> based on API Demos to get my Preview Size:

private Camera.Size getOptimalPreviewSize(List<Camera.Size> sizes, int w, int h) {
        final double ASPECT_TOLERANCE = 0.1;
        double targetRatio=(double)h / w;

        if (sizes == null) return null;

        Camera.Size optimalSize = null;
        double minDiff = Double.MAX_VALUE;

        int targetHeight = h;

        for (Camera.Size size : sizes) {
            double ratio = (double) size.width / size.height;
            if (Math.abs(ratio - targetRatio) > ASPECT_TOLERANCE) continue;
            if (Math.abs(size.height - targetHeight) < minDiff) {
                optimalSize = size;
                minDiff = Math.abs(size.height - targetHeight);
            }
        }

        if (optimalSize == null) {
            minDiff = Double.MAX_VALUE;
            for (Camera.Size size : sizes) {
                if (Math.abs(size.height - targetHeight) < minDiff) {
                    optimalSize = size;
                    minDiff = Math.abs(size.height - targetHeight);
                }
            }
        }
        return optimalSize;
    }

As you can see you have to input width and height of your screen. This method will calculate screen ratio based on those values and then from the list of supportedPreviewSizes it will choose the best for you from avaliable ones. Get your supportedPreviewSize list in place where Camera object isn't null by using

mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();

And then on in onMeasure you can get your optimal previewSize like that:

@Override
    protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
        final int width = resolveSize(getSuggestedMinimumWidth(), widthMeasureSpec);
        final int height = resolveSize(getSuggestedMinimumHeight(), heightMeasureSpec);
        setMeasuredDimension(width, height);

        if (mSupportedPreviewSizes != null) {
           mPreviewSize = getOptimalPreviewSize(mSupportedPreviewSizes, width, height);
        }
    }

And then (in my code in surfaceChanged method, like I said I'm using API Demos structure of CameraActivity code, you can generate it in Eclipse):

Camera.Parameters parameters = mCamera.getParameters();
parameters.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
mCamera.setParameters(parameters);
mCamera.startPreview();

And one hint for you, because I did almost the same app like you. Good practice for Camera Activity is to hide StatusBar. Applications like Instagram are doing it. It reduces your screen height value and change your ratio value. It is possible to get strange Preview Sizes on some devices (your SurfaceView will be cut a little)

And to answer your question, how to check if your preview ratio is correct? Then get height and width of parameters that you set in:

mCamera.setParameters(parameters);

your set ratio is equal to height/width. If you want camera to look good on your screen then height/width ratio of parameters that you set to camera must be the same as height(minus status bar)/width ratio of your screen.

Android Camera Preview is stretched on Full screen

In the surface changed block, you have to choose the optimal size according to your device programmatically.

List<Camera.Size> previewSizes = parameters.getSupportedPreviewSizes();

this will give you total supported camera sizes. you have to choose appropriate size from this. I have use the function called "chooseOptimalSize".

Size aspectRatio = new Size(matrix.widthPixels, matrix.heightPixels);

Camera.Size previewSize = chooseOptimalSize(previewSizes, PREFERRED_PREVIEW_WIDTH, PREFERRED_PREVIEW_HEIGHT, aspectRatio, this);

This is the function "chooseOptimalSize":-

public static Camera.Size chooseOptimalSize(List<Camera.Size> choices, int width, int height, Size aspectRatio, Context c) {
        // Collect the supported resolutions that are at least as big as the preview Surface
        List<Size> bigEnough = new ArrayList<>();
        int w = aspectRatio.getWidth();
        int h = aspectRatio.getHeight();
        double ratio = (double) h / w;
        int loopCounter=0;
        for (Camera.Size size : choices) {
            int orientation = c.getResources().getConfiguration().orientation;
            if (orientation == Configuration.ORIENTATION_LANDSCAPE) {
                //if((size.getWidth()/16) == (size.getHeight()/9) && size.getWidth() <=720) {
                //if((size.getWidth()/16) == (size.getHeight()/9) && size.getWidth() <=3840 ) {
                //if((size.getWidth()/16) == (size.getHeight()/9) && size.getWidth() <=5120 ) {//Retina 5K
                if((size.width/16) == (size.height/9) && size.width <=7680 ) {//8K UHDTV Super Hi-Vision
                    Log.e(TAG, "chooseOptimalSize:"+size+"--LoopPosition---==>"+loopCounter);
                    return size;
                }
            } else {
                Log.e(TAG, "chooseOptimalSize:--given--"+size);
                if((size.width/16) == (size.height/9) && ((size.width <=1280)||(size.height<=1920))) {
                    //if((size.getWidth()/16) == (size.getHeight()/9) && (size.getWidth() <=4320 ) ) {//8K UHDTV Super Hi-Vision
                    //if((size.getWidth()/16) == (size.getHeight()/9) && (size.getWidth() <=2880 ) ) {//Retina 5K
                    //if((size.getWidth()/16) == (size.getHeight()/9) && (size.getWidth() <=2160 ) ) {
                    //if((size.getWidth()/16) == (size.getHeight()/9) && (size.getWidth() <=1280 ) ) {
                    //if((size.getWidth()/16) == (size.getHeight()/9) && (size.getWidth() <=4480 && size.getWidth() >=1280) ) {
                    Log.e(TAG, "chooseOptimalSize:"+size+"-16:9"+"--LoopPosition---==>"+loopCounter);
                    return size;
                }else if((size.width/18) == (size.height/9) && ((size.width <=3840)||(size.height<=2160))) {
                    Log.e(TAG, "chooseOptimalSize:"+size+"-18:9"+"--LoopPosition---==>"+loopCounter);
                    return size;
                }else if((size.width/18.5) == (size.height/9) && ((size.width <=3840)||(size.height<=2160))) {
                    Log.e(TAG, "chooseOptimalSize:"+size+"-18.5:9"+"--LoopPosition---==>"+loopCounter);
                    return size;
                }else if((width/19) == (height/9) && ((width <=3840)||(height<=2160))) {
                    /*if((size.getWidth()/19) == (size.getHeight()/9) && ((size.getWidth() <=3840)||(size.getHeight()<=2160))) {*/
                    Log.e(TAG, "chooseOptimalSize:"+size+"-19:9"+"--LoopPosition---==>"+loopCounter);
                    return size;
                }else if((size.width/19.5) == (size.height/9) && ((size.width<=3840)||(size.height<=2160))) {
                    Log.e(TAG, "chooseOptimalSize:"+size+"-19.5:9"+"--LoopPosition---==>"+loopCounter);
                    return size;
                }else{
                    Log.e(TAG, "chooseOptimalSize"+" not proper aspect resolution");
                }
                //2340
            }

//            if(screenWidth==size.getWidth()){
//                Log.e(TAG1, loopCounter+".choose:width Matched:"+screenWidth+"="+size.getWidth());
//            }else{
//                Log.e(TAG1, loopCounter+".choose:width Not Matched:"+screenWidth+"="+size.getWidth());
//            }
//
//            if(screenHeight==size.getHeight()){
//                Log.e(TAG1, loopCounter+".choose:height Matched:"+screenHeight+"="+size.getHeight());
//            }else{
//                Log.e(TAG1, loopCounter+".choose:height Not Matched:"+screenHeight+"="+size.getHeight());
//            }
            loopCounter++;
        }
        // Pick the smallest of those, assuming we found any
//        if (bigEnough.size() > 0) {
//            return Collections.min(bigEnough, new CompareSizesByArea());
//        } else {
//            Log.e(TAG, "Couldn't find any suitable preview size");
            return choices.get(0);
//        }
    }


    /*
     * Compares two {@code Size}s based on their areas.
     */
    static class CompareSizesByArea implements Comparator<Size> {
        @Override
        public int compare(Size lhs, Size rhs) {
            // We cast here to ensure the multiplications won't overflow
            return Long.signum((long) lhs.getWidth() * lhs.getHeight() -
                    (long) rhs.getWidth() * rhs.getHeight());
        }
    }

you can uncomment the code if you want in my case there is no need of that code.

This function will give you optimal size of the device's camera. you can set that using :

parameters.setPreviewSize(previewSize.width,previewSize.height);

and you are done !!!

Stretched camera preview on SurfaceView on Android Studio

This has been bothering me for a month. I finally figured out the answer here:

https://stackoverflow.com/a/22758359/5273230

Here's the final result:

http://imgur.com/jkrHkSV

Android Camera2 preview is stretched

Camera2 is very hard to learn as a beginner. Consider using camera libraries that does the most parts. Here is one which is the best that I have found : https://camerakit.io/docs. It's really easy and it will take care all of the problems that you are facing right now.

(Note that I do not own this project and I am not promoting it in anyway. I have tried camera2 API and it really is hard, which is why I suggested an easier solution.

My camera preview is stretched and squashed. How can I solve this problem?

You should take a look at the official Android Camera2 sample from Google: https://github.com/googlesamples/android-Camera2Basic

Specifically, what you are trying to achieve is mostly accomplished by the AutoFitTextureView class and the chooseOptimalSize method in the Camera2BasicFragment file, here's a snippet:

private static Size chooseOptimalSize(Size[] choices, int textureViewWidth,
        int textureViewHeight, int maxWidth, int maxHeight, Size aspectRatio) {

    // Collect the supported resolutions that are at least as big as the preview Surface
    List<Size> bigEnough = new ArrayList<>();
    // Collect the supported resolutions that are smaller than the preview Surface
    List<Size> notBigEnough = new ArrayList<>();
    int w = aspectRatio.getWidth();
    int h = aspectRatio.getHeight();
    for (Size option : choices) {
        if (option.getWidth() <= maxWidth && option.getHeight() <= maxHeight &&
                option.getHeight() == option.getWidth() * h / w) {
            if (option.getWidth() >= textureViewWidth &&
                option.getHeight() >= textureViewHeight) {
                bigEnough.add(option);
            } else {
                notBigEnough.add(option);
            }
        }
    }

    // Pick the smallest of those big enough. If there is no one big enough, pick the
    // largest of those not big enough.
    if (bigEnough.size() > 0) {
        return Collections.min(bigEnough, new CompareSizesByArea());
    } else if (notBigEnough.size() > 0) {
        return Collections.max(notBigEnough, new CompareSizesByArea());
    } else {
        Log.e(TAG, "Couldn't find any suitable preview size");
        return choices[0];
    }
}

Getting started with Android Camera2 API can be pretty daunting. Besides the official documentation and the aforementioned official sample, there are also a few (hopefully) helpful blog posts like:

https://medium.com/androiddevelopers/camera-enumeration-on-android-9a053b910cb5
https://medium.com/androiddevelopers/understanding-android-camera-capture-sessions-and-requests-4e54d9150295

Custom camera preview stretched

I resolved above problem by creating custom activity file without xml,

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Requires RelativeLayout.
    mLayout = new RelativeLayout(this);
    setContentView(mLayout);
}

@Override
protected void onResume() {
    super.onResume();
    //Outter layout
    // Set the second argument by your choice.
    // Usually, 0 for back-facing camera, 1 for front-facing camera.
    // If the OS is pre-gingerbreak, this does not have any effect.
    mPreview = new CameraPreview(this, 0, CameraPreview.LayoutMode.FitToParent);
    RelativeLayout.LayoutParams previewLayoutParams = new RelativeLayout.LayoutParams(
            ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT);
    mLayout.addView(mPreview, 0, previewLayoutParams);

    //Capture button
    captureButton = new Button(this);
    RelativeLayout.LayoutParams bParams = new RelativeLayout.LayoutParams(
            ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT);
    bParams.addRule(RelativeLayout.ALIGN_PARENT_BOTTOM, RelativeLayout.TRUE);
    bParams.addRule(RelativeLayout.ALIGN_PARENT_RIGHT, RelativeLayout.TRUE);
    captureButton.setText("Capture");
    mLayout.addView(captureButton, bParams);

    captureButton.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {
            mPreview.takePhoto();
        }
    });
}

Now create CameraPreview class

public class CameraPreview extends SurfaceView implements SurfaceHolder.Callback {
private static boolean DEBUGGING = true;
private static final String LOG_TAG = "CameraPreviewSample";
private static final String CAMERA_PARAM_ORIENTATION = "orientation";
private static final String CAMERA_PARAM_LANDSCAPE = "landscape";
private static final String CAMERA_PARAM_PORTRAIT = "portrait";
protected Activity mActivity;
private SurfaceHolder mHolder;
protected Camera mCamera;
protected List<Camera.Size> mPreviewSizeList;
protected List<Camera.Size> mPictureSizeList;
protected Camera.Size mPreviewSize;
protected Camera.Size mPictureSize;
private int mSurfaceChangedCallDepth = 0;
private int mCameraId;
private LayoutMode mLayoutMode;
private int mCenterPosX = -1;
private int mCenterPosY;
private CameraApp cameraApp;
private ImageCallback imageCallback;
private List<Camera.Size> mSupportedPreviewSizes;
PreviewReadyCallback mPreviewReadyCallback = null;

public static enum LayoutMode {
    FitToParent, // Scale to the size that no side is larger than the parent
    NoBlank // Scale to the size that no side is smaller than the parent
};

public interface PreviewReadyCallback {
    public void onPreviewReady();
}

/**
 * State flag: true when surface's layout size is set and surfaceChanged()
 * process has not been completed.
 */
protected boolean mSurfaceConfiguring = false;

public CameraPreview(Activity activity, int cameraId, LayoutMode mode) {
    super(activity); // Always necessary
    mActivity = activity;
    mLayoutMode = mode;
    mHolder = getHolder();
    mHolder.addCallback(this);
    mHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
        if (Camera.getNumberOfCameras() > cameraId) {
            mCameraId = cameraId;
        } else {
            mCameraId = 0;
        }
    } else {
        mCameraId = 0;
    }

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
        mCamera = Camera.open(mCameraId);
    } else {
        mCamera = Camera.open();
    }
    mSupportedPreviewSizes = mCamera.getParameters().getSupportedPreviewSizes();
    Camera.Parameters cameraParams = mCamera.getParameters();
    mPreviewSizeList = cameraParams.getSupportedPreviewSizes();
    mPictureSizeList = cameraParams.getSupportedPictureSizes();
}

@Override
public void surfaceCreated(SurfaceHolder holder) {
    try {
        mCamera.setPreviewDisplay(mHolder);
    } catch (IOException e) {
        mCamera.release();
        mCamera = null;
    }
}

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

private void doSurfaceChanged(int width, int height) {
    mCamera.stopPreview();

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

    // The code in this if-statement is prevented from executed again when surfaceChanged is
    // called again due to the change of the layout size in this if-statement.
    if (!mSurfaceConfiguring) {
        Camera.Size previewSize = determinePreviewSize(portrait, width, height);
        Camera.Size pictureSize = determinePictureSize(previewSize);
        if (DEBUGGING) { Log.v(LOG_TAG, "Desired Preview Size - w: " + width + ", h: " + height); }
        mPreviewSize = previewSize;
        mPictureSize = pictureSize;
        mSurfaceConfiguring = adjustSurfaceLayoutSize(previewSize, portrait, width, height);
        // Continue executing this method if this method is called recursively.
        // Recursive call of surfaceChanged is very special case, which is a path from
        // the catch clause at the end of this method.
        // The later part of this method should be executed as well in the recursive
        // invocation of this method, because the layout change made in this recursive
        // call will not trigger another invocation of this method.
        if (mSurfaceConfiguring && (mSurfaceChangedCallDepth <= 1)) {
            return;
        }
    }

    configureCameraParameters(cameraParams, portrait);
    mSurfaceConfiguring = false;

    try {
        mCamera.startPreview();
    } catch (Exception e) {
        Log.w(LOG_TAG, "Failed to start preview: " + e.getMessage());

        // Remove failed size
        mPreviewSizeList.remove(mPreviewSize);
        mPreviewSize = null;

        // Reconfigure
        if (mPreviewSizeList.size() > 0) { // prevent infinite loop
            surfaceChanged(null, 0, width, height);
        } else {
            Toast.makeText(mActivity, "Can't start preview", Toast.LENGTH_LONG).show();
            Log.w(LOG_TAG, "Gave up starting preview");
        }
    }

    if (null != mPreviewReadyCallback) {
        mPreviewReadyCallback.onPreviewReady();
    }
}

/**
 * @param portrait
 * @param reqWidth must be the value of the parameter passed in surfaceChanged
 * @param reqHeight must be the value of the parameter passed in surfaceChanged
 * @return Camera.Size object that is an element of the list returned from Camera.Parameters.getSupportedPreviewSizes.
 */
protected Camera.Size determinePreviewSize(boolean portrait, int reqWidth, int reqHeight) {
    // Meaning of width and height is switched for preview when portrait,
    // while it is the same as user's view for surface and metrics.
    // That is, width must always be larger than height for setPreviewSize.
    int reqPreviewWidth; // requested width in terms of camera hardware
    int reqPreviewHeight; // requested height in terms of camera hardware
    if (portrait) {
        reqPreviewWidth = reqHeight;
        reqPreviewHeight = reqWidth;
    } else {
        reqPreviewWidth = reqWidth;
        reqPreviewHeight = reqHeight;
    }

    if (DEBUGGING) {
        Log.v(LOG_TAG, "Listing all supported preview sizes");
        for (Camera.Size size : mPreviewSizeList) {
            Log.v(LOG_TAG, "  w: " + size.width + ", h: " + size.height);
        }
        Log.v(LOG_TAG, "Listing all supported picture sizes");
        for (Camera.Size size : mPictureSizeList) {
            Log.v(LOG_TAG, "  w: " + size.width + ", h: " + size.height);
        }
    }

    // Adjust surface size with the closest aspect-ratio
    float reqRatio = ((float) reqPreviewWidth) / reqPreviewHeight;
    float curRatio, deltaRatio;
    float deltaRatioMin = Float.MAX_VALUE;
    Camera.Size retSize = null;
    for (Camera.Size size : mPreviewSizeList) {
        curRatio = ((float) size.width) / size.height;
        deltaRatio = Math.abs(reqRatio - curRatio);
        if (deltaRatio < deltaRatioMin) {
            deltaRatioMin = deltaRatio;
            retSize = size;
        }
    }

    return retSize;
}

protected Camera.Size determinePictureSize(Camera.Size previewSize) {
    Camera.Size retSize = null;
    for (Camera.Size size : mPictureSizeList) {
        if (size.equals(previewSize)) {
            return size;
        }
    }

    if (DEBUGGING) { Log.v(LOG_TAG, "Same picture size not found."); }

    // if the preview size is not supported as a picture size
    float reqRatio = ((float) previewSize.width) / previewSize.height;
    float curRatio, deltaRatio;
    float deltaRatioMin = Float.MAX_VALUE;
    for (Camera.Size size : mPictureSizeList) {
        curRatio = ((float) size.width) / size.height;
        deltaRatio = Math.abs(reqRatio - curRatio);
        if (deltaRatio < deltaRatioMin) {
            deltaRatioMin = deltaRatio;
            retSize = size;
        }
    }

    return retSize;
}

protected boolean adjustSurfaceLayoutSize(Camera.Size previewSize, boolean portrait,
        int availableWidth, int availableHeight) {
    float tmpLayoutHeight, tmpLayoutWidth;
    if (portrait) {
        tmpLayoutHeight = previewSize.width;
        tmpLayoutWidth = previewSize.height;
    } else {
        tmpLayoutHeight = previewSize.height;
        tmpLayoutWidth = previewSize.width;
    }

    float factH, factW, fact;
    factH = availableHeight / tmpLayoutHeight;
    factW = availableWidth / tmpLayoutWidth;
    if (mLayoutMode == LayoutMode.FitToParent) {
        // Select smaller factor, because the surface cannot be set to the size larger than display metrics.
        if (factH < factW) {
            fact = factH;
        } else {
            fact = factW;
        }
    } else {
        if (factH < factW) {
            fact = factW;
        } else {
            fact = factH;
        }
    }

    RelativeLayout.LayoutParams layoutParams = (RelativeLayout.LayoutParams)this.getLayoutParams();

    int layoutHeight = (int) (tmpLayoutHeight * fact);
    int layoutWidth = (int) (tmpLayoutWidth * fact);
    if (DEBUGGING) {
        Log.v(LOG_TAG, "Preview Layout Size - w: " + layoutWidth + ", h: " + layoutHeight);
        Log.v(LOG_TAG, "Scale factor: " + fact);
    }

    boolean layoutChanged;
    if ((layoutWidth != this.getWidth()) || (layoutHeight != this.getHeight())) {
        layoutParams.height = layoutHeight;
        layoutParams.width = layoutWidth;
        if (mCenterPosX >= 0) {
            layoutParams.topMargin = mCenterPosY - (layoutHeight / 2);
            layoutParams.leftMargin = mCenterPosX - (layoutWidth / 2);
        }
        this.setLayoutParams(layoutParams); // this will trigger another surfaceChanged invocation.
        layoutChanged = true;
    } else {
        layoutChanged = false;
    }

    return layoutChanged;
}

/**
 * @param x X coordinate of center position on the screen. Set to negative value to unset.
 * @param y Y coordinate of center position on the screen.
 */
public void setCenterPosition(int x, int y) {
    mCenterPosX = x;
    mCenterPosY = y;
}

protected void configureCameraParameters(Camera.Parameters cameraParams, boolean portrait) {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.FROYO) { // for 2.1 and before
        if (portrait) {
            //cameraParams.set(CAMERA_PARAM_ORIENTATION, CAMERA_PARAM_PORTRAIT);
            cameraParams.set(CAMERA_PARAM_ORIENTATION, CAMERA_PARAM_LANDSCAPE);
        } else {
            cameraParams.set(CAMERA_PARAM_ORIENTATION, CAMERA_PARAM_LANDSCAPE);
        }
    } else { // for 2.2 and later
        int angle;
        Display display = mActivity.getWindowManager().getDefaultDisplay();
        switch (display.getRotation()) {
            case Surface.ROTATION_0: // This is display orientation
                angle = 90; // This is camera orientation
                break;
            case Surface.ROTATION_90:
                angle = 0;
                break;
            case Surface.ROTATION_180:
                angle = 270;
                break;
            case Surface.ROTATION_270:
                angle = 180;
                break;
            default:
                angle = 90;
                break;
        }
        Log.v(LOG_TAG, "angle: " + angle);
        mCamera.setDisplayOrientation(angle);
    }

    cameraParams.setPreviewSize(mPreviewSize.width, mPreviewSize.height);
    cameraParams.setPictureSize(mPictureSize.width, mPictureSize.height);
    if (DEBUGGING) {
        Log.v(LOG_TAG, "Preview Actual Size - w: " + mPreviewSize.width + ", h: " + mPreviewSize.height);
        Log.v(LOG_TAG, "Picture Actual Size - w: " + mPictureSize.width + ", h: " + mPictureSize.height);
    }

    if (cameraParams.getSupportedFocusModes().contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
        cameraParams.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
    }

    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 void setOneShotPreviewCallback(PreviewCallback callback) {
    if (null == mCamera) {
        return;
    }
    mCamera.setOneShotPreviewCallback(callback);
}

public void setPreviewCallback(PreviewCallback callback) {
    if (null == mCamera) {
        return;
    }
    mCamera.setPreviewCallback(callback);
}

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

public void setOnPreviewReady(PreviewReadyCallback cb) {
    mPreviewReadyCallback = cb;
}

public void takePhoto(){
    if(mCamera != null){
        mCamera.takePicture(null, null, new Camera.PictureCallback() {
            @Override
            public void onPictureTaken(byte[] bytes, Camera camera) {
                if(bytes.length > 0){
                    Log.d("CameraPreview","Yes!!! We got an Image");
                }
                Bitmap capturedBitmap = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);
                //capturedBitmap = Bitmap.createScaledBitmap(capturedBitmap,1196,527,true);
                imageCallback = (ImageCallback) mActivity;
                imageCallback.resultImage(capturedBitmap);
            }
        });
    }
}

Thats it !!, you are almost done
Just one more thing that you need to create, is interface for getting result in your main activity.
Pls. feel free to ask your query.