Trouble in opening front camera in android 6.0

Question

See i have permissions for camera.Opening front camera returns null, Even though i have permissions for using camera, searched a lot of answers but nothing helped This is how i am trying to open front camera

Camera cam = null;
try{
cam = Camera.open(1);
}catch (Exception e){
Log.e("Manojjjj", "Camera failed to open: " + e.getMessage());       
e.printStackTrace();
}
return cam;

The code is working fine in android 5,But in android 6,it is returning null for front camera(Back camera is working fine), and when i change the id to 0(cam = Camera.open(0)), it opens back camera without any problem. Thanks in advance.

the exception is:

09-01 16:52:29.228 24480-24480/com.magostech.dualcamera E/Manojjjj: Camera failed to open: Fail to connect to camera service

Every question that i have searched is saying to add run time permission, but i am already giving run time permission, So i am doing it right, i think my problem is not to add run time permission.

Full Code:

 private Camera mCamera = null;
private Camera mCamera1 = null;
private Handler mBackgroundHandler;
private CameraActivity mPreview;
private CameraPreview mPreview1;
FrameLayout preview;
FrameLayout preview1;
private static final int REQUEST_CAMERA_PERMISSION = 1;

public boolean safeToTakePicture = false;
String front,back;
Bitmap bitmap1;
Bitmap bitmap2;

private static final int PERMISSION_CALLBACK_CONSTANT = 100;
private static final int REQUEST_PERMISSION_SETTING = 101;
String[] permissionsRequired = new String[]{Manifest.permission.CAMERA,
        Manifest.permission.WRITE_EXTERNAL_STORAGE

        };
private SharedPreferences permissionStatus;
private boolean sentToSettings = false;

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

    setContentView(R.layout.activity_main);
    permissionStatus = getSharedPreferences("permissionStatus",MODE_PRIVATE);
    checkForPermissions();
    // Create an instance of Camera


}

public void checkForPermissions(){
    if(ActivityCompat.checkSelfPermission(Main2Activity.this,permissionsRequired[0]) != PackageManager.PERMISSION_GRANTED
            ||ActivityCompat.checkSelfPermission(Main2Activity.this,permissionsRequired[1]) != PackageManager.PERMISSION_GRANTED){
        if(ActivityCompat.shouldShowRequestPermissionRationale(Main2Activity.this,permissionsRequired[0])
                ||ActivityCompat.shouldShowRequestPermissionRationale(Main2Activity.this,permissionsRequired[1])){
            AlertDialog.Builder builder = new AlertDialog.Builder(Main2Activity.this);
            builder.setTitle("Need Multiple Permissions");
            builder.setMessage("This app needs Camera and Location permissions.");
            builder.setPositiveButton("Grant", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                    ActivityCompat.requestPermissions(Main2Activity.this,permissionsRequired,PERMISSION_CALLBACK_CONSTANT);
                }
            });
            builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });
            builder.show();
        }
        else if (permissionStatus.getBoolean(permissionsRequired[0],false)) {
            //Previously Permission Request was cancelled with 'Dont Ask Again',
            // Redirect to Settings after showing Information about why you need the permission
            AlertDialog.Builder builder = new AlertDialog.Builder(Main2Activity.this);
            builder.setTitle("Need Multiple Permissions");
            builder.setMessage("This app needs Camera and Location permissions.");
            builder.setPositiveButton("Grant", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                    sentToSettings = true;
                    Intent intent = new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                    Uri uri = Uri.fromParts("package", getPackageName(), null);
                    intent.setData(uri);
                    startActivityForResult(intent, REQUEST_PERMISSION_SETTING);
                    Toast.makeText(getBaseContext(), "Go to Permissions to Grant  Camera and Location", Toast.LENGTH_LONG).show();
                }
            });
            builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });
            builder.show();
        }  else {
            //just request the permission
            ActivityCompat.requestPermissions(Main2Activity.this,permissionsRequired,PERMISSION_CALLBACK_CONSTANT);
        }



        SharedPreferences.Editor editor = permissionStatus.edit();
        editor.putBoolean(permissionsRequired[0],true);
        editor.commit();
    } else {
        //You already have the permission, just go ahead.
        proceedAfterPermission();
    }


}


@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if(requestCode == PERMISSION_CALLBACK_CONSTANT){
        //check if all permissions are granted
        boolean allgranted = false;
        for(int i=0;i<grantResults.length;i++){
            if(grantResults[i]==PackageManager.PERMISSION_GRANTED){
                allgranted = true;
            } else {
                allgranted = false;
                break;
            }
        }

        if(allgranted){
            proceedAfterPermission();
        } else if(ActivityCompat.shouldShowRequestPermissionRationale(Main2Activity.this,permissionsRequired[0])
                || ActivityCompat.shouldShowRequestPermissionRationale(Main2Activity.this,permissionsRequired[1])
                || ActivityCompat.shouldShowRequestPermissionRationale(Main2Activity.this,permissionsRequired[2])){

            AlertDialog.Builder builder = new AlertDialog.Builder(Main2Activity.this);
            builder.setTitle("Need Multiple Permissions");
            builder.setMessage("This app needs Camera and Location permissions.");
            builder.setPositiveButton("Grant", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                    ActivityCompat.requestPermissions(Main2Activity.this,permissionsRequired,PERMISSION_CALLBACK_CONSTANT);
                }
            });
            builder.setNegativeButton("Cancel", new DialogInterface.OnClickListener() {
                @Override
                public void onClick(DialogInterface dialog, int which) {
                    dialog.cancel();
                }
            });
            builder.show();
        } else {
            Toast.makeText(getBaseContext(),"Unable to get Permission",Toast.LENGTH_LONG).show();
        }
    }
}

@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
    super.onActivityResult(requestCode, resultCode, data);
    if (requestCode == REQUEST_PERMISSION_SETTING) {
        if (ActivityCompat.checkSelfPermission(Main2Activity.this, permissionsRequired[0]) == PackageManager.PERMISSION_GRANTED) {
            //Got Permission
            proceedAfterPermission();
        }
    }
}

private void proceedAfterPermission() {
    mCamera = getCameraInstance();
    mCamera1 = openFrontFacingCamera();
    // Create our Preview view and set it as the content of our activity.

        mPreview = new CameraActivity(this, mCamera);
        mPreview1 = new CameraPreview(this,mCamera1);
        preview = (FrameLayout) findViewById(R.id.camera_preview);
        preview1 =(FrameLayout) findViewById(R.id.camera_preview1);
        preview.addView(mPreview);
        preview1.addView(mPreview1);

    FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.take_picture);
    fab.setOnClickListener(new View.OnClickListener() {
        @Override
        public void onClick(View v) {

            if (safeToTakePicture) {
                mCamera.takePicture(null,null,backCamera);
                mCamera1.takePicture(null, null, frontCamera);
                safeToTakePicture = false;
            }
        }
    });

}


public static Camera getCameraInstance(){
    Camera c = null;

    try {
        c = Camera.open(0); // attempt to get a Camera instance

    }
    catch (Exception e){
        // Camera is not available (in use or does not exist)
    }
    return c; // returns null if camera is unavailable
}


private Camera openFrontFacingCamera(){
    int cameraCount = 0;

    Camera cam = null;

    Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
    cameraCount = Camera.getNumberOfCameras();
    for ( int camIdx = 0; camIdx < cameraCount; camIdx++ ) {
        Camera.getCameraInfo( camIdx, cameraInfo );
        if ( cameraInfo.facing == Camera.CameraInfo.CAMERA_FACING_FRONT  ) {
            try {
                Log.e("Cam Id",String.valueOf(camIdx));
                cam = Camera.open( camIdx );
            } catch (RuntimeException e) {
                e.printStackTrace();
                Log.e("Manoj", "Camera failed to open: " );
            }
        }
    }

    return cam;
}



@Override
protected void onPostResume() {
    super.onPostResume();
    if (sentToSettings) {
        if (ActivityCompat.checkSelfPermission(Main2Activity.this, permissionsRequired[0]) == PackageManager.PERMISSION_GRANTED) {
            //Got Permission
            proceedAfterPermission();
        }
    }
}


private Camera.PictureCallback frontCamera = new Camera.PictureCallback() {


    @Override
    public void onPictureTaken(final byte[] data, Camera camera) {

        camera.startPreview();
        String root = Environment.getExternalStorageDirectory().toString();
        File myDir = new File(root + "/Dual Camera");

        if (myDir.exists()) {
            myDir.delete();
        }
        myDir.mkdirs();

        String fname = "Image" + new Date().getTime() + ".jpg";

        File file = new File(myDir, fname);


        try{
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(data);
            fos.close();

            MediaScannerConnection.scanFile(Main2Activity.this, new String[]{file.getPath()}, new String[]{"image/jpeg"}, null);

            front = String.valueOf(file);
            bitmap1 = BitmapFactory.decodeFile(front);
            Log.e("Front",front);


            if(bitmap1!=null&&bitmap2!=null){
                mergeBitmap(bitmap1,bitmap2);
            }

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        safeToTakePicture = true;
    }



};


public Bitmap mergeBitmap(Bitmap bitmap1, Bitmap bitmap2) {
    Bitmap mergedBitmap = null;

    int w, h = 0;

    h = bitmap1.getHeight() + bitmap2.getHeight();
    if (bitmap1.getWidth() > bitmap2.getWidth()) {
        w = bitmap1.getWidth();
    } else {
        w = bitmap2.getWidth();
    }

    mergedBitmap = Bitmap.createBitmap(w, h, Bitmap.Config.ARGB_8888);

    Canvas canvas = new Canvas(mergedBitmap);

    canvas.drawBitmap(bitmap1, 0f, 0f, null);
    canvas.drawBitmap(bitmap2, 0f, bitmap1.getHeight(), null);

    saveBitmap(mergedBitmap);
    return mergedBitmap;
}

private Camera.PictureCallback backCamera = new Camera.PictureCallback() {


    @Override
    public void onPictureTaken(final byte[] data, Camera camera) {

        camera.startPreview();
        String root = Environment.getExternalStorageDirectory().toString();
        File myDir = new File(root + "/Dual Camera");

        if (myDir.exists()) {
            myDir.delete();
        }
        myDir.mkdirs();

        String fname = "Image" + new Date().getTime() + ".jpg";

        File file = new File(myDir, fname);



        try{
            FileOutputStream fos = new FileOutputStream(file);
            fos.write(data);
            fos.close();

            MediaScannerConnection.scanFile(Main2Activity.this, new String[]{file.getPath()}, new String[]{"image/jpeg"}, null);

            back = String.valueOf(file);
            bitmap2 = BitmapFactory.decodeFile(String.valueOf(file));
            Log.e("Back",back);


        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }

        safeToTakePicture = true;
    }



};

private void saveBitmap(Bitmap finalBitmap){
    String root = Environment.getExternalStorageDirectory().toString();
    File myDir = new File(root + "/Dual Camera");

    if (myDir.exists()) {
        myDir.delete();
    }
    myDir.mkdirs();

    String fname = "Merged" + new Date().getTime() + ".jpg";

    File file = new File(myDir, fname);

    try{
        FileOutputStream fos = new FileOutputStream(file);
        finalBitmap.compress(Bitmap.CompressFormat.JPEG, 90, fos);
        fos.flush();
        fos.close();

        MediaScannerConnection.scanFile(Main2Activity.this, new String[]{file.getPath()}, new String[]{"image/jpeg"}, null);
        Toast.makeText(getApplicationContext(),
                "Image Saved to:" + file, Toast.LENGTH_LONG).show();


    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }

}

@Override
protected void onResume() {
    super.onResume();
    if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA)
            == PackageManager.PERMISSION_GRANTED) {
        try {
            mCamera = Camera.open(0);
            mCamera.setPreviewCallback(null);
            mPreview = new CameraActivity(Main2Activity.this, mCamera);
            preview.addView(mPreview);
            mCamera.startPreview();

        }catch (Exception e) {
            Log.d("Manoj", "Error starting camera preview: " + e.getMessage());
        }try{
            if (mCamera1 == null){
                mCamera1 = openFrontFacingCamera();
                //mCamera1 = Camera.open(1);
                mCamera1.setPreviewCallback(null);
                mPreview1 = new CameraPreview(Main2Activity.this,mCamera1);
                preview1.addView(mPreview1);
                mCamera1.startPreview();
            }
        }catch (Exception e){
            Log.d("Manoj", "Error starting camera preview: " + e.getMessage());
        }
        safeToTakePicture = true;
    }
     else {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA},
                REQUEST_CAMERA_PERMISSION);
    }
}
@Override
protected void onPause() {

    try {
        // release the camera immediately on pause event
        // releaseCamera();
        mCamera1.stopPreview();
        mCamera1.setPreviewCallback(null);
        mPreview1.getHolder().removeCallback(mPreview1);
        mCamera1.release();
        mCamera1 = null;

    } catch (Exception e) {
        e.printStackTrace();
    }

    try{
        mCamera.stopPreview();
        mCamera.setPreviewCallback(null);
        mPreview.getHolder().removeCallback(mPreview);
        mCamera.release();
        mCamera = null;
    }catch (Exception e){
        e.printStackTrace();
    }
    super.onPause();
}
@Override
protected void onDestroy() {
    super.onDestroy();
    if (mBackgroundHandler != null) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2) {
            mBackgroundHandler.getLooper().quitSafely();
        } else {
            mBackgroundHandler.getLooper().quit();
        }
        mBackgroundHandler = null;
    }
}



@Override
public void onBackPressed(){
    super.onBackPressed();
}

Possible duplicate of [Android runtime permissions- how to implement](https://stackoverflow.com/questions/35163953/android-runtime-permissions-how-to-implement) — Pavneet_Singh, Sep 01 '17 at 11:34
With Android 6, you need to implement runtime permissions. Are you doing that? — Kartik Shandilya, Sep 01 '17 at 11:35
unless there are special permissions for opening front camera.. — Manoj Kumar, Sep 01 '17 at 11:45

score 0 · Answer 1 · edited Sep 01 '17 at 12:01

Try this:

 if( ContextCompat.checkSelfPermission(this, android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        requestPermissions(new String[]{android.Manifest.permission.CAMERA}, 5);
    }
}

And override the following method using Ctrl + O copying, pasting would might result in an error

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == 5) {
        if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            // Now user should be able to use camera
        }
        else {
            // Your app will not have this permission. Turn off all functions
            // that require this permission or it will force close like your
            // original question
        }
    }
}

i have already added run time permission, just to be sure i tried your code. It din't work. — Manoj Kumar, Sep 01 '17 at 11:54

score 0 · Answer 2 · answered Sep 01 '17 at 11:57

As per the Android Doc, Android app operates in a process sandbox. For Android 6.0 or above OS, user can not access the additional capabilities not provided by the basic sandbox. You need to request for that PERMISSION first. Here are those critical PERMISSIONS

If the device is running Android 5.1 (API level 22) or lower, or the app's targetSdkVersion is 22 or lower, the system asks the user to grant the permissions at install time and you can access any sensitive tool.

Check the DOC for more detail.

Trouble in opening front camera in android 6.0

2 Answers2