разрешение на разрешение прошивки Android?

Question

В настоящее время я работаю над приложением, которое требует нескольких «опасных» разрешений. Поэтому я попробовал добавить «спросить разрешения», как это требуется в Android Marshmallow (API-уровень 23), но не смог найти, как это сделать.

Как я могу попросить разрешения с использованием новой модели разрешения в моем приложении?

Answer 1

Открыть диалог, используя код ниже:

ActivityCompat.requestPermissions(MainActivity.this, 
        new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 
        1); 

Получить результат активности, как показано ниже:

@Override 
public void onRequestPermissionsResult(int requestCode, 
             String permissions[], int[] grantResults) { 
    switch (requestCode) { 
     case 1: { 

      // If request is cancelled, the result arrays are empty. 
      if (grantResults.length > 0 
        && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

       // permission was granted, yay! Do the 
       // contacts-related task you need to do.   
      } else { 

       // permission denied, boo! Disable the 
       // functionality that depends on this permission. 
       Toast.makeText(MainActivity.this, "Permission denied to read your External storage", Toast.LENGTH_SHORT).show(); 
      } 
      return; 
     } 

     // other 'case' lines to check for other 
     // permissions this app might request 
    } 
} 

Подробнее: https://developer.android.com/training/permissions/requesting.html

Answer 2

Android-M, т. Е. API 23 представил Runtime Permissions для устранения недостатков безопасности в устройстве Android, где теперь пользователи могут напрямую управлять разрешениями приложений в runtime.so, если пользователь отказывается от конкретного разрешения вашего приложения, вы должны его получить, запросив диалоговое окно разрешений, указанное в вашем запросе.

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

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

       // permission was granted, yay! Do the 
       // contacts-related task you need to do. 

       } else { 

       // permission denied, boo! Disable the 
       // functionality that depends on this permission. 
      } 
      return; 
     } 

     // other 'case' lines to check for other 
     // permissions this app might request 
    } 
} 

Итак, наконец, это хорошая практика, чтобы пройти через behavior changes, если вы планируете работать с новыми версиями, чтобы избежать сила закрывает :)

Permissions Best Practices.

Вы можете пройти через официальный пример приложения here.

Answer 3

Я использовал эту обертку (рекомендуется) написано разработчиками Google. Его супер проста в использовании.

https://github.com/googlesamples/easypermissions

Функция работа с проверкой и спрашивать разрешения, если требуется

public void locationAndContactsTask() { 
    String[] perms = { Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.READ_CONTACTS }; 
    if (EasyPermissions.hasPermissions(this, perms)) { 
     // Have permissions, do the thing! 
     Toast.makeText(this, "TODO: Location and Contacts things", Toast.LENGTH_LONG).show(); 
    } else { 
     // Ask for both permissions 
     EasyPermissions.requestPermissions(this, getString(R.string.rationale_location_contacts), 
       RC_LOCATION_CONTACTS_PERM, perms); 
    } 
} 

Дня кодирования :)

Answer 4

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

public class BaseFragment extends Fragment { 

    private static final int PERMISSION_REQUEST_BLOCK_INTERNAL = 555; 
    private static final String PERMISSION_SHARED_PREFERENCES = "permissions"; 

    @Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { 
     if (requestCode == PERMISSION_REQUEST_BLOCK_INTERNAL) { 
      boolean allPermissionsGranted = true; 

      for (int iGranting : grantResults) { 
       if (iGranting != PermissionChecker.PERMISSION_GRANTED) { 
        allPermissionsGranted = false; 
        break; 
       } 
      } 

      if (allPermissionsGranted && permissionBlock != null) { 
       permissionBlock.run(); 
      } 

      permissionBlock = null; 
     } 
    } 

    public void runNowOrAskForPermissionsFirst(String permission, Runnable block) { 
     if (hasPermission(permission)) { 
      block.run(); 
     } else if (!hasPermissionOrWillAsk(permission)) { 
      permissionBlock = block; 
      askForPermission(permission, PERMISSION_REQUEST_BLOCK_INTERNAL); 
     } 
    } 

    public boolean hasPermissionOrWillAsk(String permission) { 
     boolean hasPermission = hasPermission(permission); 
     boolean hasAsked = hasPreviouslyAskedForPermission(permission); 
     boolean shouldExplain = shouldShowRequestPermissionRationale(permission); 

     return hasPermission || (hasAsked && !shouldExplain); 
    } 

    private boolean hasPermission(String permission) { 
     return (ContextCompat.checkSelfPermission(getContext(), permission) == PackageManager.PERMISSION_GRANTED); 
    } 

    private boolean hasPreviouslyAskedForPermission(String permission) { 
     SharedPreferences prefs = getContext().getSharedPreferences(PERMISSION_SHARED_PREFERENCES, Context.MODE_PRIVATE); 
     return prefs.getBoolean(permission, false); 
    } 

    private void askForPermission(String permission, int requestCode) { 
     SharedPreferences.Editor editor = getContext().getSharedPreferences(PERMISSION_SHARED_PREFERENCES, Context.MODE_PRIVATE).edit(); 

     editor.putBoolean(permission, true); 
     editor.apply(); 

     requestPermissions(new String[] { permission }, requestCode); 
    } 
} 

Есть два основных метода вы должны использовать:

• hasPermissionOrWillAsk - Используйте это, чтобы увидеть, если разрешение было предложено для и отрицает пользователь, который не хочет быть снова спросил , Это полезно для отключения пользовательского интерфейса, когда пользователь дал свой окончательный ответ о НЕ желании функции.

• runNowOrAskForPermissionsFirst - использовать это для запуска кода, требующего разрешений. Если пользователь уже предоставил разрешение, код будет запущен немедленно. В противном случае код будет запущен позже, если пользователь предоставит разрешение. Или совсем нет. Это хорошо, потому что вы указываете код в одном месте.

Вот пример:

mFragment.runNowOrAskForPermissionsFirst(Manifest.permission.ACCESS_FINE_LOCATION, new Runnable() { 
    @Override 
    public void run() { 
     ...do something if we have permission... 
    } 
}); 

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

Answer 5

Эта структура, которую я использую, чтобы проверить, имеет ли мое приложение разрешение, и запрос, если у него нет разрешения. Так что в моей основной код, из которого я хочу, чтобы проверить запись следующее:

int MyVersion = Build.VERSION.SDK_INT; 
if (MyVersion > Build.VERSION_CODES.LOLLIPOP_MR1) { 
       if (!checkIfAlreadyhavePermission()) { 
        requestForSpecificPermission(); 
       } 
} 

Модуль checkIfAlreadyhavePermission() реализован в виде:

private boolean checkIfAlreadyhavePermission() { 
    int result = ContextCompat.checkSelfPermission(this, Manifest.permission.GET_ACCOUNTS); 
    if (result == PackageManager.PERMISSION_GRANTED) { 
     return true; 
    } else { 
     return false; 
    } 
} 

Модуль requestForSpecificPermission() реализован в виде:

private void requestForSpecificPermission() { 
     ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.GET_ACCOUNTS, Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_SMS, Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 101); 
} 

и переопределения в деятельности:

@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    switch (requestCode) { 
     case 101: 
      if (grantResults[0] == PackageManager.PERMISSION_GRANTED) { 
       //granted 
      } else { 
       //not granted 
      } 
      break; 
     default: 
      super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    } 
} 

Ссылка на эту ссылку для получения более подробной информации: http://revisitingandroid.blogspot.in/2017/01/how-to-check-and-request-for-run-time.html

Answer 6

Для получения нескольких разрешений одновременно вы можете использовать это. Эта работа для меня .. У меня есть другое решение. если вы дадите свой целевой уровеньSdkVersion 22, это сработает для меня. и это поведение похоже на получение разрешения от manifest.xml. Протестировано и работает для меня.

final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124; 

    private void insertDummyContactWrapper() { 
     List<String> permissionsNeeded = new ArrayList<String>(); 

     final List<String> permissionsList = new ArrayList<String>(); 
     if (!addPermission(permissionsList, Manifest.permission.ACCESS_FINE_LOCATION)) 
      permissionsNeeded.add("GPS"); 
     if (!addPermission(permissionsList, Manifest.permission.READ_CONTACTS)) 
      permissionsNeeded.add("Read Contacts"); 
     if (!addPermission(permissionsList, Manifest.permission.WRITE_CONTACTS)) 
      permissionsNeeded.add("Write Contacts"); 

     if (permissionsList.size() > 0) { 
      if (permissionsNeeded.size() > 0) { 
       // Need Rationale 
       String message = "You need to grant access to " + permissionsNeeded.get(0); 
       for (int i = 1; i < permissionsNeeded.size(); i++) 
        message = message + ", " + permissionsNeeded.get(i); 
       showMessageOKCancel(message, 
         new DialogInterface.OnClickListener() { 
          @Override 
          public void onClick(DialogInterface dialog, int which) { 
           requestPermissions(permissionsList.toArray(new String[permissionsList.size()]), 
             REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS); 
          } 
         }); 
       return; 
      } 
      requestPermissions(permissionsList.toArray(new String[permissionsList.size()]), 
        REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS); 
      return; 
     } 

     insertDummyContact(); 
    } 

    private boolean addPermission(List<String> permissionsList, String permission) { 
     if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) { 
      permissionsList.add(permission); 
      // Check for Rationale Option 
      if (!shouldShowRequestPermissionRationale(permission)) 
       return false; 
     } 
     return true; 
    } 






@Override 
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
     switch (requestCode) { 
      case REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS: 
       { 
       Map<String, Integer> perms = new HashMap<String, Integer>(); 
       // Initial 
       perms.put(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.PERMISSION_GRANTED); 
       perms.put(Manifest.permission.READ_CONTACTS, PackageManager.PERMISSION_GRANTED); 
       perms.put(Manifest.permission.WRITE_CONTACTS, PackageManager.PERMISSION_GRANTED); 
       // Fill with results 
       for (int i = 0; i < permissions.length; i++) 
        perms.put(permissions[i], grantResults[i]); 
       // Check for ACCESS_FINE_LOCATION 
       if (perms.get(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED 
         && perms.get(Manifest.permission.READ_CONTACTS) == PackageManager.PERMISSION_GRANTED 
         && perms.get(Manifest.permission.WRITE_CONTACTS) == PackageManager.PERMISSION_GRANTED) { 
        // All Permissions Granted 
        insertDummyContact(); 
       } else { 
        // Permission Denied 
        Toast.makeText(MainActivity.this, "Some Permission is Denied", Toast.LENGTH_SHORT) 
          .show(); 
       } 
       } 
       break; 
      default: 
       super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
     } 
    } 

Для получения более подробной информации. Проверьте сильфон ссылку

https://inthecheesefactory.com/blog/things-you-need-to-know-about-android-m-permission-developer-edition/en

Answer 7

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

android.permission-group.CALENDAR android.permission.READ_CALENDAR android.permission.WRITE_CALENDAR

android.permission-группы. CAMERA android.permission.CAMERA

android.permission-group.CONTACTS android.permission.READ_CONTACTS android.perm ission.WRITE_CONTACTS android.permission.GET_ACCOUNTS

android.permission-group.LOCATION android.permission.ACCESS_FINE_LOCATION android.permission.ACCESS_COARSE_LOCATION

android.permission-group.MICROPHONE android.permission.RECORD_AUDIO

android.permission-group.PHONE android.permission.READ_PHONE_STATE android.permission.CALL_PHONE android.permission.READ_CALL_LOG android.permission.WRITE_CALL_LOG android.permission.ADD_VOICEMAIL android.permission.USE_SIP android.permission .PROCESS_OUTGOING_CALLS

android.permission-group.SENSORS android.permission.BODY_SENSORS

android.permission-group.SMS android.permission.SEND_SMS android.permission.RECEIVE_SMS android.permission.READ_SMS android.permission.RECEIVE_WAP_PUSH android.permission.RECEIVE_MMS android.permission.READ_CELL_BROADCASTS

android.permission-group.STORAGE андроид. permission.READ_EXTERNAL_STORAGE android.permission.WRITE_EXTERNAL_STORAGE

Вот пример, если нам нужно, чтобы проверить наличие разрешения

if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CALENDAR) != PackageManager.PERMISSION_GRANTED) { 
      if (ActivityCompat.shouldShowRequestPermissionRationale((Activity) context, Manifest.permission.WRITE_CALENDAR)) { 
       AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context); 
       alertBuilder.setCancelable(true); 
       alertBuilder.setMessage("Write calendar permission is necessary to write event!!!"); 
       alertBuilder.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() { 
        @TargetApi(Build.VERSION_CODES.JELLY_BEAN) 
        public void onClick(DialogInterface dialog, int which) { 
         ActivityCompat.requestPermissions((Activity)context, new String[]{Manifest.permission.WRITE_CALENDAR}, MY_PERMISSIONS_REQUEST_WRITE_CALENDAR); 
        } 
       });    
      } else { 
      ActivityCompat.requestPermissions((Activity)context, new String[]{Manifest.permission.WRITE_CALENDAR}, MY_PERMISSIONS_REQUEST_WRITE_CALENDAR); 
      }   
     } 

Answer 8

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

ли дать ему попробовать, как это делает жизнь проще: Android Permissions

Answer 9

Чтобы справиться с разрешения выполнения Google предоставил проект библиотеки. Вы можете проверить это здесь https://github.com/googlesamples/easypermissions

EasyPermissions устанавливается путем добавления следующей зависимости в файл build.gradle:

dependencies { 
compile 'pub.devrel:easypermissions:0.3.0' 
} 

Чтобы начать использовать EasyPermissions, иметь свою активность (или фрагмент) переопределить метод onRequestPermissionsResult:

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks { 

@Override 
protected void onCreate(Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 
} 

@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 

    // Forward results to EasyPermissions 
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this); 
} 

@Override 
public void onPermissionsGranted(int requestCode, List<String> list) { 
    // Some permissions have been granted 
    // ... 
} 

@Override 
public void onPermissionsDenied(int requestCode, List<String> list) { 
    // Some permissions have been denied 
    // ... 
} 
} 

Здесь вы получите рабочий пример того, как эта библиотека работает https://github.com/milon87/EasyPermission

Answer 10

Это может быть более чистый способ.Добавьте все ваши права в массиве как

private static final String[] INITIAL_PERMS={ 
      android.Manifest.permission.ACCESS_FINE_LOCATION, 
      android.Manifest.permission.ACCESS_COARSE_LOCATION 
    }; 
    private static final int INITIAL_REQUEST=1337; 

Независимо от permision является метод создания для каждого permision

@RequiresApi(api = Build.VERSION_CODES.M) 
private boolean canAccessFineLocation() { 
    return(hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)); 
} 

@RequiresApi(api = Build.VERSION_CODES.M) 
private boolean canAccessCoarseLocation() { 
    return(hasPermission(Manifest.permission.ACCESS_COARSE_LOCATION)); 
} 

@RequiresApi(api = Build.VERSION_CODES.M) 
private boolean hasPermission(String perm) { 
    return(PackageManager.PERMISSION_GRANTED == checkSelfPermission(perm)); 
} 

этот метод в OnCreate

if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.M){ 
     if(!canAccessCoarseLocation() || !canAccessFineLocation()){ 
      requestPermissions(INITIAL_PERMS, INITIAL_REQUEST); 
     } 
} 

вызов Теперь переопределить onRequestPermissionsResult

@Override 
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { 

    if(requestCode == INITIAL_REQUEST){ 
     if (canAccessFineLocation() && canAccessCoarseLocation()) { 
      //call your method 
     } 
     else { 
      //show Toast or alert that this permissions is neccessary 
     } 
    } 
} 

Answer 11

От Android Marshmallow (API 23) и выше по умолчанию все опасные разрешения (согласно официальному документу official doc) отключены. После установки, когда приложение открывается в первый раз, вам необходимо предоставить разрешение во время выполнения.

Я достиг этого следующим образом:

public class MarshMallowPermission { 

    public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_GALLERY = 0; 
    public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_CAMERA = 1; 
    public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE = 2; 
    public static final int CAMERA_PERMISSION_REQUEST_CODE = 3; 
    public static final int LOCATION_PERMISSION_REQUEST_CODE = 4; 
    Activity activity; 
    Context mContext; 

    public MarshMallowPermission(Activity activity) { 
     this.activity = activity; 
     this.mContext = activity; 
    } 

    public boolean checkPermissionForExternalStorage(){ 
     int result = ContextCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE); 
     if (result == PackageManager.PERMISSION_GRANTED){ 
      return true; 
     } else { 
      return false; 
     } 
    } 

    public boolean checkPermissionForCamera(){ 
     int result = ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA); 
     if (result == PackageManager.PERMISSION_GRANTED){ 
      return true; 
     } else { 
      return false; 
     } 
    } 

    public boolean checkLocationPermission(){ 

     int result = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION); 
     if (result == PackageManager.PERMISSION_GRANTED){ 
      return true; 
     } else { 
      return false; 
     } 
    } 

    public void requestPermissionForExternalStorage(int requestCode){ 
     if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)){ 
      Toast.makeText(mContext.getApplicationContext(), "External Storage permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show(); 
     } else { 
      ActivityCompat.requestPermissions(activity,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},requestCode); 
     } 
    } 

    public void requestPermissionForCamera(){ 
     if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA)){ 
      Toast.makeText(mContext.getApplicationContext(), "Camera permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show(); 
     } else { 
      ActivityCompat.requestPermissions(activity,new String[]{Manifest.permission.CAMERA},CAMERA_PERMISSION_REQUEST_CODE); 
     } 
    } 
    public void requestPermissionForLocation(){ 
     if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_FINE_LOCATION) && ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_COARSE_LOCATION)){ 
      Toast.makeText(mContext.getApplicationContext(), "Location permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show(); 
     } else { 
      ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.ACCESS_FINE_LOCATION,Manifest.permission.ACCESS_COARSE_LOCATION}, LOCATION_PERMISSION_REQUEST_CODE); 
     } 
    } 
} 

в классе деятельности:

public class MainActivity extends AppCompatActivity{ 

    private MarshMallowPermission marshMallowPermission; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     Log.d("NavHome", "Oncreate_nav"); 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 

     marshMallowPermission = new MarshMallowPermission(MainActivity.this); 



     if (!marshMallowPermission.checkPermissionForExternalStorage()) { 
      marshMallowPermission.requestPermissionForExternalStorage(MarshMallowPermission.EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE); 
     } 
    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
     super.onRequestPermissionsResult(requestCode, permissions, grantResults); 

     switch (requestCode) { 
      case MarshMallowPermission.EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE: 
       if (grantResults.length > 0 
         && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

        //permission granted successfully 

       } else { 

       //permission denied 

       } 
       break; 
    } 
    } 

} 

Answer 12

if (CommonMethod.isNetworkAvailable(MainActivity.this)) { 
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
         int permissionCheck = ContextCompat.checkSelfPermission(MainActivity.this, 
           android.Manifest.permission.CAMERA); 
         if (permissionCheck == PackageManager.PERMISSION_GRANTED) { 
          //showing dialog to select image 
          callFacebook(); 
          Log.e("permission", "granted MarshMallow"); 
         } else { 
          ActivityCompat.requestPermissions(MainActivity.this, 
            new String[]{android.Manifest.permission.READ_EXTERNAL_STORAGE, 
              android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.CAMERA}, 1); 
         } 
        } else { 
         Log.e("permission", "Not Required Less than MarshMallow Version"); 
         callFacebook(); 
        } 
       } else { 
        CommonMethod.showAlert("Internet Connectivity Failure", MainActivity.this); 
       } 

Answer 13

Мой класс разрешений запроса во время выполнения

public class RequestPermissionHandler { 
    private Activity mActivity; 
    private RequestPermissionListener mRequestPermissionListener; 
    private int mRequestCode; 

    public void requestPermission(Activity activity, @NonNull String[] permissions, int requestCode, 
      RequestPermissionListener listener) { 
     mActivity = activity; 
     mRequestCode = requestCode; 
     mRequestPermissionListener = listener; 

     if (!needRequestRuntimePermissions()) { 
      mRequestPermissionListener.onSuccess(); 
      return; 
     } 
     requestUnGrantedPermissions(permissions, requestCode); 
    } 

    private boolean needRequestRuntimePermissions() { 
     return Build.VERSION.SDK_INT >= Build.VERSION_CODES.M; 
    } 

    private void requestUnGrantedPermissions(String[] permissions, int requestCode) { 
     String[] unGrantedPermissions = findUnGrantedPermissions(permissions); 
     if (unGrantedPermissions.length == 0) { 
      mRequestPermissionListener.onSuccess(); 
      return; 
     } 
     ActivityCompat.requestPermissions(mActivity, unGrantedPermissions, requestCode); 
    } 

    private boolean isPermissionGranted(String permission) { 
     return ActivityCompat.checkSelfPermission(mActivity, permission) 
       == PackageManager.PERMISSION_GRANTED; 
    } 

    private String[] findUnGrantedPermissions(String[] permissions) { 
     List<String> unGrantedPermissionList = new ArrayList<>(); 
     for (String permission : permissions) { 
      if (!isPermissionGranted(permission)) { 
       unGrantedPermissionList.add(permission); 
      } 
     } 
     return unGrantedPermissionList.toArray(new String[0]); 
    } 

    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, 
      @NonNull int[] grantResults) { 
     if (requestCode == mRequestCode) { 
      if (grantResults.length > 0) { 
       for (int grantResult : grantResults) { 
        if (grantResult != PackageManager.PERMISSION_GRANTED) { 
         mRequestPermissionListener.onFailed(); 
         return; 
        } 
       } 
       mRequestPermissionListener.onSuccess(); 
      } else { 
       mRequestPermissionListener.onFailed(); 
      } 
     } 
    } 

    public interface RequestPermissionListener { 
     void onSuccess(); 

     void onFailed(); 
    } 
} 

Использование в Activity как

public class MainActivity extends AppCompatActivity { 
    private RequestPermissionHandler mRequestPermissionHandler; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     mRequestPermissionHandler = new RequestPermissionHandler(); 

     findViewById(R.id.button).setOnClickListener(new View.OnClickListener() { 
      @Override 
      public void onClick(View v) { 
       handleButtonClicked(); 
      } 
     }); 
    } 

    private void handleButtonClicked(){ 
     mRequestPermissionHandler.requestPermission(this, new String[] { 
       Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_EXTERNAL_STORAGE 
     }, 123, new RequestPermissionHandler.RequestPermissionListener() { 
      @Override 
      public void onSuccess() { 
       Toast.makeText(MainActivity.this, "request permission success", Toast.LENGTH_SHORT).show(); 
      } 

      @Override 
      public void onFailed() { 
       Toast.makeText(MainActivity.this, "request permission failed", Toast.LENGTH_SHORT).show(); 
      } 
     }); 

    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, 
      @NonNull int[] grantResults) { 
     super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
     mRequestPermissionHandler.onRequestPermissionsResult(requestCode, permissions, 
       grantResults); 
    } 
} 

Demo project on Github

Answer 14

Попробуйте

Это самый простой способ, чтобы попросить разрешения в Зефир версии.

if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED&&ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED) 
    { 
     //TO do here if permission is granted by user 
    } 
    else 
    { 
     //ask for permission if user didnot given 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) 
     { 
      requestPermissions(new String[]{Manifest.permission.CAMERA,Manifest.permission.ACCESS_FINE_LOCATION}, 0); 
     } 
    } 

Примечание: - Не забудьте добавить этот же разрешение в файле манифеста также

<uses-permission android:name="android.permission.CAMERA" /> 
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" /> 

Второй метод код для проверки разрешение выдается или нет?

ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.CAMERA}, 1); 

и переопределить метод

@Override 
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) { 
    switch (requestCode) { 
     case 1: { 
      if (grantResults.length > 0 && grantResults[1] == PackageManager.PERMISSION_GRANTED) { 
     //     grantResult[0] means it will check for the first postion permission which is READ_EXTERNAL_STORAGE 
     //     grantResult[1] means it will check for the Second postion permission which is CAMERA 
       Toast.makeText(this, "Permission Granted", Toast.LENGTH_SHORT).show(); 
      } 
      else 
       Toast.makeText(this, "Permission not Granted", Toast.LENGTH_SHORT).show(); 
      return; 
     } 
    } 
} 

Answer 15

Вы можете использовать мою библиотеку - NoPermission (Это всего лишь один класс)

compile 'ru.alexbykov:nopermission:1.1.1'

Образец

PermissionHelper permissionHelper = new PermissionHelper(this); //don't use getActivity in fragment! 

permissionHelper.check(Manifest.permission.READ_CONTACTS) 
       .onSuccess(this::onSuccess) 
       .onDenied(this::onDenied) 
       .onNeverAskAgain(this::onNeverAskAgain) 
       .run(); 

onRequestPermissionResult:

@Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) 
     permissionHelper.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    } 

Я думаю, что апи удобнее EasyPermissions по Google.

Answer 16

Этот код ниже работает отлично. Я объясняю с помощью примера.

В моем случае я поместил проверки полномочий отдельно в класс утилиты и передал конкретные разрешения, которые мне нужно проверить из соответствующих классов. Это позволило повторно использовать файл утилиты проверки разрешений во всем приложении.

В приведенной ниже части кода показан вызов функции. В этом случае я запрашиваю разрешение android.Manifest.permission.READ_EXTERNAL_STORAGE.

//the below call is from a fragment 
    @OnClick(R.id.button)//butterknife implementation 
     public void attachPressed() { 
      if (PermissionUtils.hasThisPermission(getContext(), android.Manifest.permission.READ_EXTERNAL_STORAGE)) { 
       onAttachPressed(); 
      } else { 
       PermissionUtils.isPermissionRequestNeeded(getActivity(), this, android.Manifest.permission.READ_EXTERNAL_STORAGE, PermissionUtils.REQUEST_GROUP_STORAGE); 
      } 
     } 

В приведенном выше случае разрешения проверяется, если это разрешено функция onAttachPressed(); называется еще мы проверяем разрешение запроса.

Ниже приведен код, присутствующий в классе UTIL в моем случае PermissionUtils

public final class PermissionUtils { 

    public static final int REQUEST_GROUP_STORAGE = 1508; 

    private PermissionUtils() { 
    } 

    public static boolean hasThisPermission(Context context, String permission) { 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
      return ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED; 
     } else { 
      return true; 
     } 
    } 

    public static boolean isPermissionRequestNeeded(Activity activity, Fragment fragment, String permission, int requestCode) { 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !hasThisPermission(activity, permission)) { 
      final String[] permissions = new String[]{permission}; 
      if (fragment == null) { 
       activity.requestPermissions(permissions, requestCode); 
      } else { 
       fragment.requestPermissions(permissions, requestCode); 
      } 
      return true; 
     } 
     return false; 
    } 
} 

И после запроса, если вы можете вызвать функцию из onRequestPermissionsResult или иначе вам нужно будет нажать на кнопку еще раз для вызов функции.

Так просто называют его от onRequestPermissionsResult

//the below call is from a fragment 
    @Override 
     public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
      if (requestCode == PermissionUtils.REQUEST_GROUP_STORAGE && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 
       onAttachPressed(); 
      } else { 
       Log.e("value", "Permission Denied, You cannot use local drive ."); 
      } 
     }