Android 6.0 Runtime Erlaubnis + Intent-Filter

Question

muß ich Lagerung in meiner Absicht Filter zugreifen, um eine PDF-Datei oder ein Bild in Android 6.0-Anwendung zu greifen.

[IntentFilter(new[] { Intent.ActionOpenDocument, Intent.ActionView }, Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable }, DataMimeType = "application/pdf")] 
[IntentFilter(new[] { Intent.ActionOpenDocument, Intent.ActionView }, Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable }, DataMimeType = "image/jpeg")] 
[IntentFilter(new[] { Intent.ActionOpenDocument, Intent.ActionView }, Categories = new[] { Intent.CategoryDefault, Intent.CategoryBrowsable }, DataMimeType = "image/png")] 

Allerdings erfordert es von Benutzer gewähren Speicherberechtigung für App.

Die Frage ist es eine richtige POC für einen solchen Fall, dass ich Absicht blockieren kann, Anzeige Alarm und danach meine Absicht auf Erteilung/Widerruf der Erlaubnis stützen beenden?

Derzeit gehe ich davon aus ich nur etwas Toast anzeigen kann, die keine Erlaubnis gibt und Anwender sanft fragen in App zu gehen und die Erlaubnis manuell aktivieren (von einigen benutzerdefinierte App-Einstellungen, oder was auch immer).

Answer 1

private static final int REQUEST_RUNTIME_PERMISSION = 1; 

    void checkPremission() { 
      //Desired permission you want 
      final String permission = Manifest.permission.CAMERA; 
       // if in fragment use getActivity() 

      if (ContextCompat.checkSelfPermission(ActivityName.this, permission) 
        != PackageManager.PERMISSION_GRANTED) { 
       if (ActivityCompat.shouldShowRequestPermissionRationale(ActivityName.this, permission)) { 

       } else { 
        ActivityCompat.requestPermissions(ActivityName.this, new String[]{permission}, REQUEST_CAMERA_PERMISSION); 
       } 
      } else { 
       // you have permission go ahead 

      } 
     } 

     @Override 
     public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { 
      switch (requestCode) { 
       case REQUEST_RUNTIME_PERMISSION: 
        final int numOfRequest = grantResults.length; 
        final boolean isGranted = numOfRequest == 1 
          && PackageManager.PERMISSION_GRANTED == grantResults[numOfRequest - 1]; 
        if (isGranted) { 
         // you have permission go ahead 
        }else{ 
         // you dont have permission show toast 
        } 
        break; 
       default: 
        super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
      } 
     } 

Answer 2

private void requestPermission() { 

    int writePermission = ContextCompat.checkSelfPermission(
      MyActivity.this, 
      Manifest.permission.WRITE_EXTERNAL_STORAGE); 
    if (writePermission != PackageManager.PERMISSION_GRANTED) { 

     // Should we show an explanation? 
     // if (ActivityCompat.shouldShowRequestPermissionRationale(
     // MyActivity.this, 
     // Manifest.permission.WRITE_EXTERNAL_STORAGE)) { 
     // 
     // // Show an expanation to the user *asynchronously* -- don't 
     // // block 
     // // this thread waiting for the user's response! After the user 
     // // sees the explanation, try again to request the permission. 
     // 
     // } else { 

     // No explanation needed, we can request the permission. 

     ActivityCompat 
       .requestPermissions(
         MyActivity.this, 
         new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 
         MY_PERMISSIONS_WRITE_TO_EXTERNAL_STORAGE); 

     // MY_PERMISSIONS_WRITE_TO_EXTERNAL_STORAGE is an 
     // app-defined int constant. The callback method gets the 
     // result of the request. 
     // } 
    } 
} 

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

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

      } else { 

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

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

Ich habe die WRITE_EXTERNAL_STORAGE Erlaubnis hier verwendet, weil es die Erlaubnis erteilt, beides zu tun, lesen und schreiben.

Rufen Sie die requestPermission() Verfahren, bei dem u erfordern, und dann PDF-Dateien oder Bilder aus Ihrem Gerät.

Hoffe, das hilft.

Answer 3

Vielen Dank für Ihre Antworten, aber vielleicht habe ich vergessen, es in der Frage zu erwähnen, aber ich getaggt es -, dass ich für Xamarin Technologie auf eine Antwort suchen.

Die Zeit verging, aber diese Zeit vor, schließlich fanden wir Lösung. Es ist mehr weniger so ein Stück Code:

 private bool HandlAndroidRuntimePermissions(Intent intent) 
     { 
      const int toastTimeout = 5; 
      const string permissionName = "File Drop"; 

      try 
      { 
       PermissionStatus status; 
       using (var checkPermissionStatusAsync = CrossPermissions.Current.CheckPermissionStatusAsync(Permission.Storage)) 
       { 
        status = checkPermissionStatusAsync.Result; 
       } 

       if (status != PermissionStatus.Granted) 
       { 
        using (var shouldShowRequestPermissionRationaleAsync = CrossPermissions.Current.ShouldShowRequestPermissionRationaleAsync(Permission.Storage)) 
        { 
         if (shouldShowRequestPermissionRationaleAsync.Result) 
         { 
          UserDialogs.Instance.Toast(
           string.Format(Core.Resources.Resource.DocumentPickerModalViewModel_AndroidPermissionWrapper_RequestPermissionRationale, Permission.Storage, permissionName), 
           TimeSpan.FromSeconds (toastTimeout)); 
         } 
        } 

        using (var requestPermissionsAsync = CrossPermissions.Current.RequestPermissionsAsync(Permission.Storage)) 
        { 
         requestPermissionsAsync.ContinueWith(task => 
         { 
          var permissionStatuses = task.Result; 
          status = permissionStatuses[Permission.Storage]; 
          if (status == PermissionStatus.Granted) 
          { 
           CopyDocumentFromDeviceToMyLibrary(intent); 
          } 
          UserDialogs.Instance.Toast(string.Format(Core.Resources.Resource.DocumentPickerModalViewModel_AndroidPermissionWrapper_PermissionNotGrant, Permission.Storage, permissionName), 
           TimeSpan.FromSeconds (toastTimeout)); 
         }); 
        } 
        return true; 
       } 
      } 
      catch (Exception) 
      { 
       UserDialogs.Instance.Toast(string.Format(Core.Resources.Resource.DocumentPickerModalViewModel_AndroidPermissionWrapper_ErrorOccured, Permission.Storage), 
        TimeSpan.FromSeconds (toastTimeout)); 
       return true; 
      } 

      return false; 
     }