Android M Camera Intent + ошибка разрешения?

Ответ 1

У меня была такая же проблема, и я нашел этот документ из google: https://developer.android.com/reference/android/provider/MediaStore.html#ACTION_IMAGE_CAPTURE

"Примечание. Если вы используете приложение M и выше и объявляете с использованием разрешения CAMERA, которое не предоставляется, то попытка использовать это действие приведет к исключению SecurityException."

Это действительно странно. Не имеешь смысла. Приложение объявляет разрешение камеры, используя намерение с действием IMAGE_CAPTURE, просто запускается в SecurityException. Но если ваше приложение не объявляет разрешение камеры, используя намерение с действием, IMAGE_CAPTURE может запускать приложение для камеры без проблем.

Обходным решением будет проверка, что приложение имеет разрешение камеры, включенное в манифест, если оно запрашивает разрешение камеры до запуска намерения.

Вот способ проверить, включено ли разрешение в манифест, не имеет значения, предоставлено разрешение или нет.

public boolean hasPermissionInManifest(Context context, String permissionName) {
    final String packageName = context.getPackageName();
    try {
        final PackageInfo packageInfo = context.getPackageManager()
                .getPackageInfo(packageName, PackageManager.GET_PERMISSIONS);
        final String[] declaredPermisisons = packageInfo.requestedPermissions;
        if (declaredPermisisons != null && declaredPermisisons.length > 0) {
            for (String p : declaredPermisisons) {
                if (p.equals(permissionName)) {
                    return true;
                }
            }
        }
    } catch (NameNotFoundException e) {

    }
    return false;
}

Ответ 2

Если вы используете модель разрешения Android M, сначала вам нужно проверить, имеет ли приложение это разрешение во время выполнения, и пригласить пользователя на это разрешение во время выполнения. Разрешение, которое вы определяете в своем манифесте, автоматически не будет предоставлено во время установки.

if (checkSelfPermission(Manifest.permission.CAMERA)
        != PackageManager.PERMISSION_GRANTED) {

    requestPermissions(new String[]{Manifest.permission.CAMERA},
            MY_REQUEST_CODE);
}

MY_REQUEST_CODE - это статическая константа, которую вы можете определить, которая будет использоваться снова для обратного вызова диалога requestPermission.

Вам понадобится обратный вызов для результата диалога:

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == MY_REQUEST_CODE) {
        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
        }
    }
}

изменить

Чтение из трассировки стека, похоже, что у камеры Google не разрешено разрешение CAMERA. В конце концов, это может выглядеть как обратная совместимость.

Предположим, что для камеры Google (или любого другого приложения, обрабатывающего ваши намерения ACTION) требуется определенное разрешение.

Когда ваше приложение не имеет разрешения CAMERA, оно просто позволяет Google Camera делать это со старой моделью разрешений.

Однако, с разрешением CAMERA, объявленным в вашем манифесте, он также обеспечивает разрешение CAMERA в Google Camera (на котором отсутствует модель разрешений Android M), чтобы использовать модель разрешений Android M (я думаю.)

Таким образом, это означает использование вышеописанного метода, вам нужно будет предоставить разрешение вашего приложения во время выполнения, что означает, что его дочерняя задача (в данном случае камера Google) также получит это разрешение.

Ответ 3

Что касается вашего вопроса "Это известная проблема в M?" Google-разработчик ответил, что кто-то сообщил об этой проблеме как ошибке.

Смотрите здесь: https://code.google.com/p/android/issues/detail?id=188073&q=label%3APriority-Medium&colspec=ID%20Type%20Status%20Owner%20Summary%20Stars&start=100

Вот слово от парня Google: "Это предполагаемое поведение, чтобы избежать разочарования пользователя, когда они отозвали разрешение камеры от приложения, и приложение все еще может фотографировать с помощью намерения. Пользователи не знают, что фотография после того, как аннулирование разрешения происходит с помощью другого механизма и будет подвергать сомнению правильность модели разрешения. Это относится к MediaStore.ACTION_IMAGE_CAPTURE, MediaStore.ACTION_VIDEO_CAPTURE и Intent.ACTION_CALL документам, для которых документ изменяет поведение для приложений, ориентированных на M."

Поскольку Google не возражает против абстрагирования механики использования камеры от вашего пользователя, вы можете стратегически инициировать первый запрос на разрешение камеры и ссылаться на функциональность Activity, которая использует камеру в качестве аргумента для запроса. Если вы разрешите своему приложению сначала сделать этот запрос на разрешение, когда пользователь просто пытается сделать снимок, пользователь может подумать, что ваше приложение ведет себя странно, поскольку получение фотографии обычно не требует разрешения.

Ответ 4

Если вы используете Google M, перейдите в Настройки → Приложения → ваше приложение → и укажите соответствующие разрешения.

Ответ 5

Я застрял в этой проблеме, и я уже использовал JTY-ответ. Проблема в том, что в какой-то момент в диалоговом окне разрешения запроса была отмечена опция "Никогда не спрашивать снова". Я разрабатываю SDK 24.

Мой полный код для обработки разрешений (камера в моем случае):

public void checksCameraPermission(View view) {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        Log.d("MyApp", "SDK >= 23");
        if (this.checkSelfPermission(Manifest.permission.CAMERA)
                != PackageManager.PERMISSION_GRANTED) {
                Log.d("MyApp", "Request permission");
                ActivityCompat.requestPermissions(this,
                        new String[]{Manifest.permission.CAMERA},
                        MY_REQUEST_CODE);

                if (! shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
                    showMessageOKCancel("You need to allow camera usage",
                            new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                    ActivityCompat.requestPermissions(FotoPerfil.this, new String[] {Manifest.permission.CAMERA},
                                            MY_REQUEST_CODE);
                                }
                            });
                }
        }
        else {
            Log.d("MyApp", "Permission granted: taking pic");
            takePicture();
        }
    }
    else {
        Log.d("MyApp", "Android < 6.0");
    }
}

затем

private void showMessageOKCancel(String message, DialogInterface.OnClickListener okListener) {
    new AlertDialog.Builder(this)
            .setMessage(message)
            .setPositiveButton("OK", okListener)
            .setNegativeButton("Cancel", null)
            .create()
            .show();
}

а затем

@Override
public void onRequestPermissionsResult(int requestCode,
                                       String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MY_REQUEST_CODE: {
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                criarFoto();
            } else {
                Toast.makeText(this, "You did not allow camera usage :(", Toast.LENGTH_SHORT).show();
                noFotoTaken();
            }
            return;
        }
    }
}

Предполагаемое поведение заключается в том, что если пользователь по ошибке проверил "Никогда не спрашивать снова", ваше приложение застревает (диалоговое окно запроса не отображается), и пользователь может почувствовать разочарование. Таким образом, сообщение сообщает ему, что ему нужно это разрешение.

Ответ 6

Я удалил:

uses-permission android:name="android.permission.CAMERA"

и полагался только на:

uses-feature android:name="android.hardware.camera" android:required="true"

в файле манифеста.

Ответ 7

Этот метод не проверяет только камеру, но все разрешения, необходимые моему приложению во время запуска... У меня есть это в моем файле Helper.java. Также обратите внимание, что для диалога я использую эту библиотеку: https://github.com/afollestad/material-dialogs

  ///check camera permission
    public static boolean hasPermissions(final Activity activity){

        //add your permissions here
        String[] AppPermissions = {
                Manifest.permission.CAMERA,
                Manifest.permission.READ_EXTERNAL_STORAGE,
                Manifest.permission.WRITE_EXTERNAL_STORAGE
        };

        //ungranted permissions
        ArrayList<String> ungrantedPerms = new ArrayList<String>();
        //loop

        //lets set a boolean of hasUngrantedPerm to false
        Boolean needsPermRequest = false;

        //permissionGranted
        int permGranted = PackageManager.PERMISSION_GRANTED;

        //permission required content
        String permRequestStr = activity.getString(R.string.the_following_perm_required);

        //loop
        for(String permission : AppPermissions){

            //check if perm is granted
            int checkPerm = ContextCompat.checkSelfPermission(activity,permission);

            //if the permission is not granted
            if(ContextCompat.checkSelfPermission(activity,permission) != permGranted){

                needsPermRequest = true;

                //add the permission to the ungranted permission list
                ungrantedPerms.add(permission);

                //permssion name
               String[] splitPerm = permission.split(Pattern.quote("."));

                String permName = splitPerm[splitPerm.length-1].concat("\n");

                permRequestStr = permRequestStr.concat(permName);
            }//end if

        }//end loop


        //if all permission is granted end exec
        //then continue code exec
        if(!needsPermRequest) {

            return true;
        }//end if

        //convert array list to array string
       final String[]  ungrantedPermsArray = ungrantedPerms.toArray(new String[ungrantedPerms.size()]);

            //show alert Dialog requesting permission
            new MaterialDialog.Builder(activity)
                    .title(R.string.permission_required)
                    .content(permRequestStr)
                    .positiveText(R.string.enable)
                    .negativeText(R.string.cancel)
                    .onPositive(new MaterialDialog.SingleButtonCallback(){
                        @Override
                        public void onClick(@NonNull MaterialDialog dialog,@NonNull DialogAction which){
                            //request the permission now
                            ActivityCompat.requestPermissions(activity,ungrantedPermsArray,0);
                        }
                    })
                    .show();

        //return false so that code exec in that script will not be allowed
        //to continue
        return false;

    }//end checkPermissions

поэтому вы добавите или удалите свои списки разрешений здесь:

//add your permissions here
            String[] AppPermissions = {
                    Manifest.permission.CAMERA,
                    Manifest.permission.READ_EXTERNAL_STORAGE,
                    Manifest.permission.WRITE_EXTERNAL_STORAGE
            };

В моем файле "Активность" я проверяю разрешение, подобное этому, класс "Помощник" - это место, где я сохранил метод hasPermissions

 if(Helper.hasPermissions(this) == false){
            return;
  }//end if

Это означает, что нам не нужно продолжать выполнение, если разрешение не предоставлено. Снова нам нужно будет послушать запрос разрешения после его завершения, чтобы сделать это, добавьте следующий код в свой файл активности (необязательно)

//Listen to Permission request completion
//put in your activity file
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults)
{
    int permGranted = PackageManager.PERMISSION_GRANTED;

    Boolean permissionRequired = false;

    for(int perm : grantResults){

        if(perm != permGranted){
            permissionRequired = true;
        }
    }

    //if permission is still required
    if(permissionRequired){

        //recheck and enforce permission again
        Helper.hasPermissions(this);
    }//end if

}//end method

Ответ 8

немного поздно. но я хочу добавить еще одну вещь. всякий раз, когда вы вызываете методы, которые содержат функции камеры, используйте его в блоке try catch. если приложение не будет работать на некоторых устройствах, таких как Moto G4 plus или один плюс.

private static final int CAMERA_REQUEST_CODE = 10;
//TODO add camera opening functionality here.
                try {
                    captureImage();
                    Intent intent = new Intent("android.media.action.IMAGE_CAPTURE");
                    startActivityForResult(intent,CAMERA_REQUEST_CODE);
                } catch (Exception e){
                    e.printStackTrace();
                }

private void captureImage(){
    if( ContextCompat.checkSelfPermission(getContext(), android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            requestPermissions(new String[]{android.Manifest.permission.CAMERA},
                    CAMERA_REQUEST_CODE);
        }
        else {
            // Open your camera here.
        }
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    if (requestCode == CAMERA_REQUEST_CODE) {
        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
        }
    }
}

P.S: убедитесь, что вы не скопировали вставку переопределенного метода.

Ответ 9

Вы должны включить разрешение приложения для использования камеры. Я предпочитаю добавлять этот метод добавить команду, которая активирует камеру:

    public static async Task<bool> HasPermission()
    {
        var status = await CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Camera);
        if (status == PermissionStatus.Granted) return true;

        if (await CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Permission.Camera))
        {
            ShowDialogOk("Error", "Please allow access to the camera.");//that is my custom method for allert
        }

        var results = await CrossPermissions.Current.RequestPermissionsAsync(Permission.Camera);
        status = results[Permission.Camera];

        return status == PermissionStatus.Granted;
    }