Portanto, essas novas permissões de tempo de execução do Android me deixaram confuso. No momento, meu aplicativo está compilando e direcionando a versão 23, o que significa que preciso usar permissões de tempo de execução. Meu aplicativo usa principalmente a API da câmera, que precisa da permissão da câmera, então eu adicionei as permissões de tempo de execução antes de abrir a câmera:

        if (ContextCompat.checkSelfPermission(this,
                Manifest.permission.CAMERA)
                != PackageManager.PERMISSION_GRANTED)
        {//ask permissions for camera
            ActivityCompat.requestPermissions(this,
                    new String[]{Manifest.permission.CAMERA},
                    CameraPermissions);
        }
        else
        {//permissions attained now you can open the camera
            camera=Camera.open(getCid());
            camera.setPreviewCallback(this);
            initPreview(width, height);
            startPreview();
            startTimer();
        }

Também verifico quando paro a câmera:

       if (ContextCompat.checkSelfPermission(this,
                Manifest.permission.CAMERA)
                == PackageManager.PERMISSION_GRANTED) {
            camera.setPreviewCallback(null);
            camera.release();
            faceProc.release();
            faceProc = null;
            camera = null;
            inPreview = false;
            cameraConfigured = false;
        }

A solicitação de permissão é tratada da seguinte maneira:

@Override
public void onRequestPermissionsResult(int requestCode,
                                       String permissions[], int[] grantResults) {
    switch (requestCode) {
        case CameraPermissions: {
            // If request is cancelled, the result arrays are empty.
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                StartUpCam();
            } else {

                // permission denied, boo! Disable the
                // functionality that depends on this permission.
                AlertDialog.Builder builder = new AlertDialog.Builder(this);
                builder.setMessage("How is this app going to work if you rejected the camera permission.... DUHHHH!!")
                        .setTitle("Rejected");
                builder.setPositiveButton("Exit App", new DialogInterface.OnClickListener() {
                    public void onClick(DialogInterface dialog, int id) {
                        //close application
                        closeApp();
                    }
                });
                AlertDialog dialog = builder.create();
                dialog.show();
            }
            return;
        }
    }
}

Portanto, quando a solicitação é feita, ele chama a StartUpCam, que tenta abrir a câmera se as permissões forem concedidas. Então, aqui estão minhas perguntas, se eu adicionar essa permissão de tempo de execução, como isso afeta os dispositivos Android inferiores a 6,0? Portanto, um telefone com a versão 5.0.1 também receberá uma solicitação para fornecer permissões de câmera? Se eu usar permissões de tempo de execução, preciso remover as permissões da câmera no arquivo de manifesto? Atualmente, mantenho as permissões da câmera no manifesto junto com as permissões de tempo de execução que não sei se estão corretas ou não. E se eu diminuir o destino e compilar o sdk para 22 em vez de 23, os dispositivos Android acima de 6.0 não poderão baixar meu aplicativo ??? Se eu abaixá-lo para a versão 22, evito toda essa dor de cabeça ...