android 6 system warnung erlaubnis ..!

Question

Ich gebe mehrere Laufzeit-Laufzeit für Android 6, aber bei jedem Neustart des Geräts oder onclick um Service zu starten ein Dialogfeld erscheint System Alert und Lese-Kontakt-Berechtigung auf es. meine Anwendung arbeitet im Hintergrund (wie durch Broadcast nach dem Neustart genannten Service) dies die erste Erlaubnis, und ich bemerkte, dass es noch nie

auf es wieder Option stellen und dies ist die zweite System Alarm Sache dass ich sagte

JETZT , wie ich die Erlaubnis einmal geben kann und fragt nie wieder bin ich bereits die Erlaubnis Kontrolle, aber diese andere Sache ist, und es ist nur für die Lesekontakt Erlaubnis

Answer 1

Dies ist bereits auf der Dokumentation von Android android.developer.com

Die Art und Weise Android die Anfragen macht, hängt von der Systemversion und der Systemversion von Ihrer App gezielt:

Wenn das Gerät läuft Android 6.0 (API Level 23) oder höher, und die App targetSdkVersion ist 23 oder höher, die App fordert Berechtigungen vom Benutzer zur Laufzeit. Der Benutzer kann die Berechtigungen jederzeit widerrufen, sodass die App bei jedem Zugriff auf durch Berechtigungen geschützte APIs prüfen muss, ob sie über die erforderlichen Berechtigungen verfügt. Weitere Informationen zum Anfordern von Berechtigungen in Ihrer App finden Sie im Schulungsleitfaden zum Arbeiten mit Systemberechtigungen.

Es ist möglich, dass Sie die app's targetSdkVersion is 22 or lower

wie erwähnt eingestellt:

Wenn das Gerät läuft Android 5.1.1 (API-Ebene 22) oder niedriger ist, oder die App targetSdkVersion ist 22 oder niedriger fordert das System den Benutzer auf, die Berechtigungen zu erteilen, wenn der Benutzer die App installiert. Wenn Sie einer aktualisierten Version der App eine neue Berechtigung hinzufügen, fordert das System den Benutzer auf, diese Berechtigung zu erteilen, wenn der Benutzer die App aktualisiert. Sobald der Nutzer die App installiert hat, kann er sie nur durch Deinstallation der App widerrufen.

Sie könnten auch meine benutzerdefinierte Berechtigungsklasse

package ...; 

package admin4.techelm.com.techelmtechnologies.common.utility; 

import android.Manifest; 
import android.app.Activity; 
import android.content.Context; 
import android.content.DialogInterface; 
import android.content.pm.PackageManager; 
import android.os.Build; 
import android.os.StrictMode; 
import android.support.v4.app.ActivityCompat; 
import android.support.v7.app.AlertDialog; 
import android.util.Log; 

import java.lang.reflect.Method; 

public class PermissionUtil { 

    private static final String TAG = PermissionUtil.class.getSimpleName(); 

    public static final int REQUEST_EXTERNAL_STORAGE = 1; 
    private static final int WRITE_EXTERNAL_PERMISSION_REQUEST_CODE = 1; 
    public static final int READ_EXTERNAL_PERMISSION_REQUEST_CODE = 2; 
    public static final int RECORD_AUDIO_PERMISSION_REQUEST_CODE = 3; 
    public static final int CAMERA_PERMISSION_REQUEST_CODE = 4; 

    private static String[] PERMISSIONS_WRITE_STORAGE = {Manifest.permission.WRITE_EXTERNAL_STORAGE}; 
    private static String[] PERMISSIONS_READ_STORAGE = {Manifest.permission.READ_EXTERNAL_STORAGE}; 
    private static String[] PERMISSIONS_AUDIO = {Manifest.permission.RECORD_AUDIO}; 
    private static String[] PERMISSIONS_CAMERA = {Manifest.permission.CAMERA}; 

    PermissionUtil() { } 

    /** 
    * SAMPLER 
    * Checks if the app has permission to write to device storage 
    * <p/> 
    * If the app does not has permission then the user will be prompted to grant permissions 
    * 
    * @param activity the mContext from which permissions are checked 
    */ 
    public static void verifyStoragePermissions(Activity activity) { 
     // Check if we have write permission 
     int permission = ActivityCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE); 

     if (permission != PackageManager.PERMISSION_GRANTED) { 
      // We don't have permission so prompt the user 
      ActivityCompat.requestPermissions(
        activity, 
        PERMISSIONS_WRITE_STORAGE, 
        WRITE_EXTERNAL_PERMISSION_REQUEST_CODE 
      ); 
     } 
    } 

    public static void verrifyReadStoragePermissions(Activity activity) { 
     int permission = ActivityCompat.checkSelfPermission(activity, PERMISSIONS_READ_STORAGE[0]); 
     if (isPermissionDenied(permission)) { 
      processPermission(activity, PERMISSIONS_READ_STORAGE[0], PERMISSIONS_READ_STORAGE, READ_EXTERNAL_PERMISSION_REQUEST_CODE); 
     } 
    } 

    public static void verrifyWriteStoragePermissions(Activity activity) { 
     int permission = ActivityCompat.checkSelfPermission(activity, PERMISSIONS_WRITE_STORAGE[0]); 
     if (isPermissionDenied(permission)) { 
      processPermission(activity, PERMISSIONS_WRITE_STORAGE[0], PERMISSIONS_WRITE_STORAGE, WRITE_EXTERNAL_PERMISSION_REQUEST_CODE); 
     } 
    } 

    public static void verrifyRecordAudioPermissions(Activity activity) { 
     int permission = ActivityCompat.checkSelfPermission(activity, PERMISSIONS_AUDIO[0]); 
     if (isPermissionDenied(permission)) { 
      processPermission(activity, PERMISSIONS_AUDIO[0], PERMISSIONS_AUDIO, RECORD_AUDIO_PERMISSION_REQUEST_CODE); 
     } 
    } 

    public static void verrifyCameraPermissions(Activity activity) { 
     int permission = ActivityCompat.checkSelfPermission(activity, PERMISSIONS_CAMERA[0]); 
     if (isPermissionDenied(permission)) { 
      processPermission(activity, PERMISSIONS_CAMERA[0], PERMISSIONS_CAMERA, CAMERA_PERMISSION_REQUEST_CODE); 
     } 
    } 

    private static boolean isPermissionDenied(int permission) { 
     return permission != PackageManager.PERMISSION_GRANTED; 
    } 

    private static void processPermission(Activity activity, String permissionManifest, String[] permissions, int requestCode) { 
     if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permissionManifest)) { 
      Log.e(TAG, "shouldShowRequestPermissionRationale is invoked " + permissionManifest); 
     } else { 
      ActivityCompat.requestPermissions(activity, permissions, requestCode); 
      Log.e(TAG, "requestPermissions is invoked " + permissionManifest); 
     } 
    } 

    /** 
    * SAMPLER 
    * Request the permissions you need 
     If your app doesn't already have the permission it needs, the app must call one of the requestPermissions() methods to request the appropriate permissions. 
     Your app passes the permissions it wants, and also an integer request code that you specify to identify this permission request. 
     This method functions asynchronously: it returns right away, and after the user responds to the dialog box, 
     the system calls the app's callback method with the results, passing the same request code that the app passed to requestPermissions(). 
    * @param activity - you mContext 
    */ 
    public static void verifyShowRequestPrompt(Activity activity) { 
     // Should we show an explanation? 
     if (ActivityCompat.shouldShowRequestPermissionRationale(activity, 
       Manifest.permission.CAMERA)) { 

      // Show an explanation 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. 
      Log.e(TAG, "shouldShowRequestPermissionRationale is invoked"); 
     } else { 

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

      ActivityCompat.requestPermissions(activity, 
        new String[]{Manifest.permission.CAMERA}, 
        WRITE_EXTERNAL_PERMISSION_REQUEST_CODE); 

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

    /** 
    * ABOVE CODES is not used 
    * @param activity 
    */ 

    public static void initPermissions(final Activity activity) { 
     // The request code used in ActivityCompat.requestPermissions() 
     // and returned in the Activity's onRequestPermissionsResult() 
     // int PERMISSION_ALL = 1; 
     final String[] PERMISSIONS = { 
       Manifest.permission.READ_EXTERNAL_STORAGE, 
       Manifest.permission.WRITE_EXTERNAL_STORAGE, 
       Manifest.permission.RECORD_AUDIO, 
       Manifest.permission.CAMERA}; 
     if(!hasPermissions(activity, PERMISSIONS)) { 
      showMessageOKCancel(activity, "These permissions are mandatory for the application. Please allow access.", 
        new DialogInterface.OnClickListener() { 
         @Override 
         public void onClick(DialogInterface dialog, int which) { 
          if (!hasPermissions(activity, PERMISSIONS)) { 
           ActivityCompat.requestPermissions(activity, PERMISSIONS, REQUEST_EXTERNAL_STORAGE); 
          } 
         } 
        }); 
     } 

     setGAlleryPermissionIntent(); 
    } 

    public static void initPermissions(final Context context) { 
     // The request code used in ActivityCompat.requestPermissions() 
     // and returned in the Activity's onRequestPermissionsResult() 
     // int PERMISSION_ALL = 1; 
     final String[] PERMISSIONS = { 
       Manifest.permission.READ_EXTERNAL_STORAGE, 
       Manifest.permission.WRITE_EXTERNAL_STORAGE, 
       Manifest.permission.RECORD_AUDIO, 
       Manifest.permission.CAMERA}; 
     if(!hasPermissions(context, PERMISSIONS)) { 
      showMessageOKCancel(context, "These permissions are mandatory for the application. Please allow access.", 
        new DialogInterface.OnClickListener() { 
         @Override 
         public void onClick(DialogInterface dialog, int which) { 
          if (!hasPermissions(context, PERMISSIONS)) { 
           ActivityCompat.requestPermissions((Activity) context, PERMISSIONS, REQUEST_EXTERNAL_STORAGE); 
          } 
         } 
        }); 
     } 

     setGAlleryPermissionIntent(); 
    } 

    public static boolean hasPermissions(final Context context, final String... permissions) { 
     if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && context != null && permissions != null) { 
      for (String permission : permissions) { 
       if (ActivityCompat.checkSelfPermission(context, permission) != PackageManager.PERMISSION_GRANTED) { 
        return false; 
       } 
      } 
     } 
     return true; 
    } 

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

    public static void setGAlleryPermissionIntent() { 
     if(Build.VERSION.SDK_INT>=24){ 
      try{ 
       Method m = StrictMode.class.getMethod("disableDeathOnFileUriExposure"); 
       m.invoke(null); 
      }catch(Exception e){ 
       e.printStackTrace(); 
      } 
     } 
    } 
} 

Rufen Sie diese auf Ihrer Tätigkeit nutzen.