Android Opening Front Camera by default
<p>I am very new to android and for some reason I have to implement a code that would let open the front camera by default instead of rear camera. My minimum SDK is API 9 and Target SDK is API 21. I have a PicturePlugin.Java file and the code is:</p>

<pre><code>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());
    CameraManager manager;
    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");
            if(object.has("mode")){
                if(object.getString("mode").equals("FRONT")){
                    mode = "FRONT";
                    openFrontFacingCamera();
                    Intent intent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
                    intent.putExtra("android.intent.extras.CAMERA_FACING", android.hardware.Camera.CameraInfo.CAMERA_FACING_FRONT);
                }
            }else{
                mode = "BACK";
            }
            Intent camera=new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

            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;
    }


    private Camera openFrontFacingCamera()
    {
        int cameraCount = 0;
        Camera cam = null;
        Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
        cameraCount = Camera.getNumberOfCameras();
        for ( int camId = 0; camId &lt; cameraCount; camId++ ) {
            Camera.getCameraInfo( camId, cameraInfo );
            if ( cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT  ) {
                try {
                    cam = Camera.open( camId );
                } catch (RuntimeException e) {
                    Log.e(TAG1, "Camera failed to open: " + e.getLocalizedMessage());
                }
            }
        }

        return cam;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent intent)
    {
        if (requestCode == IMAGE_TAKEN &amp;&amp; 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() &amp;&amp; !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 &amp;&amp; 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;
    }

}
</code></pre>

<p>Please help me. This is my first plugin handling.</p>