How to Enable Front Camera Instead of Rear Camera for Android Programmatically

How to enable front camera instead of rear camera for android programmatically?

Camera mCamera;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

   mCamera= Camera.open(1);
}

Note:

0 for CAMERA_FACING_BACK

1 for CAMERA_FACING_FRONT

switch back/front camera on fly

I restart Activity with cameraId = 2 and this is working.

Android Opening Front Camera by default

This code will work whenever the JSON object 'mode' will be found:

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Locale;
import java.util.UUID;

import org.apache.cordova.CallbackContext;
import org.apache.cordova.CordovaPlugin;
import org.json.JSONArray;
import org.json.JSONObject;
import org.maxmobility.util.Constants;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.database.Cursor;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Matrix;
import android.hardware.Camera;

import android.hardware.camera2.CameraManager;
import android.media.ExifInterface;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.MediaStore;
import android.provider.MediaStore.Images;
import android.util.Base64;
import android.util.Log;
import android.view.SurfaceHolder;


public class PicturePlugin extends CordovaPlugin
{
    private String callback="data";
    private int IMAGE_TAKEN=1;
    private CallbackContext callbackContext;    
    private String TAG="FilePlugin";
    private int imageWidth,imageHeight;
    private String imagePath;
    private File destImageFile;
    private String mode = "BACK";
    private static String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss",
            Locale.getDefault()).format(new Date());
    static Camera camera = null;
    private static final String TAG1 = null ;

    public boolean execute(String action, JSONArray args, CallbackContext callbackContext)
    {
        this.callbackContext = callbackContext;
        this.cordova.getActivity().getApplicationContext().getPackageName();        
        try
        {
            JSONObject object=(JSONObject) args.get(0);
            imageWidth=object.getInt("targetWidth");
            imageHeight=object.getInt("targetHeight");
            //checking whether json object has "mode" or not
            if(object.has("mode"))
            {
                //if json object has "mode" and that is "FRONT"
                if(object.getString("mode").equals("FRONT"))
                {
                    mode = "FRONT";
                    Intent camera=new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    camera.putExtra("android.intent.extras.CAMERA_FACING", 1); // used this line of code to start the intent of camera
                                                                                //The ID is 1 that opens FRONT CAMERA of a device
                    imagePath = getCapturedImageExternal();
                    destImageFile = new File(imagePath);
                    camera.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(destImageFile));

                    this.cordova.setActivityResultCallback(PicturePlugin.this);
                    cordova.getActivity().startActivityForResult(camera,IMAGE_TAKEN);


                }
                else
                {   
                    // if json object has "mode" and that is "BACK"
                    mode = "BACK";
                    Intent camera=new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    camera.putExtra("android.intent.extras.CAMERA_FACING", 0);  //ID is 0 that opens REAR CAMERA of a device
                    imagePath = getCapturedImageExternal();
                    destImageFile = new File(imagePath);
                    camera.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(destImageFile));

                    this.cordova.setActivityResultCallback(PicturePlugin.this);
                    cordova.getActivity().startActivityForResult(camera,IMAGE_TAKEN);
                }


            }
            else
            {

                //if no "mode" is found in json object then by default rear camera is opening
                Intent camera=new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                camera.putExtra("android.intent.extras.CAMERA_FACING", 0);
                imagePath = getCapturedImageExternal();
                destImageFile = new File(imagePath);
                camera.putExtra(MediaStore.EXTRA_OUTPUT, Uri.fromFile(destImageFile));

                this.cordova.setActivityResultCallback(PicturePlugin.this);
                cordova.getActivity().startActivityForResult(camera,IMAGE_TAKEN);
            }
        }       

        catch (Exception e)
        {
            Log.i(TAG, "Exception "+e.getMessage());
            callbackContext.error("failed");

        }
        return true;
    }


    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent intent)
    {
        if (requestCode == IMAGE_TAKEN && resultCode == Activity.RESULT_OK) {
            File finalFile = null;
            File fileTobeDeleted = null;
            Bitmap photo = null;
            File sd = new File(Environment.getExternalStorageDirectory(),
                    Constants.GOBIZMO_IMAGE_DIR);
            String destinationImagePath = File.separator 
                    + Constants.TEMP_CAMERA_IMAGE + ".JPEG";
            File destination = new File(sd, destinationImagePath);
            sd.setWritable(true);

            try {


                String encoded;
                imagePath = destImageFile.getAbsolutePath();


                finalFile = new File(imagePath);
                fileTobeDeleted = new File(imagePath);
                int angle = getAngle(finalFile.getAbsolutePath());








                    if (finalFile.exists()) {
                        photo = BitmapFactory.decodeFile(finalFile
                                .getAbsolutePath());
                        Matrix matrix = new Matrix();
                        matrix.postRotate(angle);
                        Bitmap scaledBitmap = Bitmap.createScaledBitmap(photo, imageWidth, imageHeight, true);
                        photo = Bitmap.createBitmap(scaledBitmap, 0, 0, imageWidth, imageHeight, matrix, true);
                        // //////New orientation fix for all
                        // devices///////////////////////

                        try {


                            ByteArrayOutputStream stream = new ByteArrayOutputStream();
                                photo.compress(Bitmap.CompressFormat.PNG, 100, stream);
                            byte[] byteArray = stream.toByteArray();
                            encoded = Base64.encodeToString(byteArray, Base64.DEFAULT);
                            Log.e("base 64 image", encoded);
                            JSONObject object = new JSONObject();
                            object.put(callback, encoded);
                            finalFile.delete();
                            fileTobeDeleted.delete();
                            //imagePath = destination.getPath();
                            if(new File(imagePath).exists()){
                                new File(imagePath).delete();
                            }
                            callbackContext.success(encoded);
                        } catch (Exception e) {
                            e.printStackTrace();
                            Log.i(TAG, "onActivityResult " + e.getMessage());
                            finalFile.delete();
                            fileTobeDeleted.delete();

                            if(new File(imagePath).exists()){
                                new File(imagePath).delete();
                            }
                            callbackContext.error("failed");

                        } 
                    }




            } catch (Exception exp) {
                exp.printStackTrace();
                Log.i(TAG, "onActivityResult " + exp.getMessage());
                try {
                    finalFile.delete();
                    fileTobeDeleted.delete();
                    imagePath = destination.getPath();
                    if(new File(imagePath).exists()){
                        new File(imagePath).delete();
                    }
                    callbackContext.error("failed");
                }catch(Exception innerexception){
                    innerexception.printStackTrace();
                }
            }
        }
    }

    public Uri getImageUri(Context inContext, Bitmap inImage)
    {
        ByteArrayOutputStream bytes = new ByteArrayOutputStream();
        inImage.compress(Bitmap.CompressFormat.JPEG, 100, bytes);
        String path = Images.Media.insertImage(inContext.getContentResolver(), inImage, "Title", null);
        return Uri.parse(path);
    }

    public String getRealPathFromURI(Uri uri)
    {
        Cursor cursor = cordova.getActivity().getContentResolver().query(uri, null, null, null, null); 
        cursor.moveToFirst(); 
        int idx = cursor.getColumnIndex(Images.ImageColumns.DATA);
        return cursor.getString(idx); 
    }


    public static String getCapturedImageExternal() {

        // External sdcard location
        File mediaStorageDir = new File(
                android.os.Environment.getExternalStorageDirectory(),
                "Gobizmo image");
        // Create the storage directory if it does not exist
        if (!mediaStorageDir.exists()){
            mediaStorageDir.mkdirs();
        }
        if (!mediaStorageDir.exists() && !mediaStorageDir.mkdirs()) {
            Log.d(Constants.GOBIZMO_IMAGE_DIR, "Oops! Failed create "
                    + Constants.GOBIZMO_IMAGE_DIR + " directory");
            return null;
        }
        // Create a timestamp


        return mediaStorageDir.getPath() + File.separator + Constants.TEMP_CAMERA_IMAGE
                + ".JPEG";
    }


    public static String getRealPathFromURI(Context context, Uri contentUri) {
        String filepath = "";
        String uriPath = contentUri.toString();
        // Handle local file and remove url encoding
        if (uriPath.startsWith("file://")) {
            filepath = uriPath.replace("file://", "");
            try {
                return URLDecoder.decode(filepath, "UTF-8");
            } catch (UnsupportedEncodingException e) {
                e.printStackTrace();
            }
        }
        try {
            String[] projection = { MediaStore.Images.Media.DATA };
            Cursor cursor = context.getContentResolver().query(contentUri,
                    projection, null, null, null);
            if (cursor != null && cursor.getCount() != 0) {
                int column_index = cursor
                        .getColumnIndex(MediaStore.Images.Media.DATA);
                cursor.moveToFirst();
                filepath = cursor.getString(column_index);
            }
        } catch (Exception e) {
            Log.e("Path Error", e.toString());
        }
        return filepath;
    }

    private int getAngle(String path)
    {
        int angle=0;
        try
        {       
            ExifInterface ei = new ExifInterface(path);
            int orientation = ei.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL);
            Log.i(TAG, "getAngle "+orientation);

            switch(orientation)
            {
                case ExifInterface.ORIENTATION_ROTATE_90:
                                                            angle=90;
                                                            break;
                case ExifInterface.ORIENTATION_ROTATE_180:
                                                            angle=180;
                                                            break;
                case ExifInterface.ORIENTATION_ROTATE_270 :
                                                            angle=270;
                default:
                                                            angle=0;
            }
        }
        catch(Exception ex)
        {
            Log.i("getAngle", "getAngle :: "+ex.getMessage());
        }
        return angle;
    }

}

Do not forget to add permission to use front camera in your manifest.xml.
it will be:

<uses-feature android:name="android.hardware.camera.front"   /> <!-- used this feature to open the front camera  -->

Switch To Front Camera and Back Camera Android SurfaceView

Try below code

mCamera= Camera.open(cameraId);

0 for CAMERA_FACING_BACK

1 for CAMERA_FACING_FRONT

Reference Camera.open(int)

Camera Info Constants

---

Related Topics