एंड्रॉइड 6 अनुमति विधि को समझना

Question

मैं गैलरी से एक छवि लेने और इसे एक छविदृश्य में सेट करने की कोशिश कर रहा हूं लेकिन एंड्रॉइड 6 में कुछ अनुमति समस्याएं हैं। अनुमति के लिए पूछने की विधि नीचे दी गई है। क्या मुझे बाहरी भंडारण पढ़ने या बाहरी भंडारण लिखने के लिए कहा जाना चाहिए? क्लिक श्रोता पर अब मेरी

private static final int READ_CONTACTS_PERMISSIONS_REQUEST = 1; 


    public void getPermissionToReadExternalStorage() { 

    if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.READ_EXTERNAL_STORAGE) 
      != PackageManager.PERMISSION_GRANTED) { 

     if (shouldShowRequestPermissionRationale(
       Manifest.permission.READ_EXTERNAL_STORAGE)) { 

      requestPermissions(new String[]{Manifest.permission.READ_EXTERNAL_STORAGE}, 
        READ_CONTACTS_PERMISSIONS_REQUEST); 
     }}} 
    @Override 
      public void onRequestPermissionsResult(int requestCode, 
                @NonNull String permissions[], 
                @NonNull int[] grantResults){ 
       // Make sure it's our original READ_CONTACTS request 
       if (requestCode == READ_CONTACTS_PERMISSIONS_REQUEST) { 
        if (grantResults.length == 1 && 
          grantResults[0] == PackageManager.PERMISSION_GRANTED) { 
         Toast.makeText(getActivity(), "Read Contacts permission granted", Toast.LENGTH_SHORT).show(); 

        } else { 
         Toast.makeText(getActivity(), "Read Contacts permission denied", Toast.LENGTH_SHORT).show(); 
        } 
       } else { 
        super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
       } 
      } 

गैलरी से डेटा लेने के लिए:

 pro.setOnClickListener(new View.OnClickListener() { 

     @Override 
     public void onClick(View v) { 
      Intent intent = new Intent(Intent.ACTION_PICK, android.provider.MediaStore.Images.Media.EXTERNAL_CONTENT_URI); 
      intent.setType("image/*"); 
      if (android.os.Build.VERSION.SDK_INT >= 23) { 
       getPermissionToReadExternalStorage(); 
       if (getPermissionToReadExternalStorage() this???? <==) 
       startActivityForResult(Intent.createChooser(intent, "Select Picture"), 0); 
      } else { 
       startActivityForResult(Intent.createChooser(intent, "Select Picture"), 0); 
     }} 

    }); 
    return v; 
} 

अब मैं विधि getPermissionToReadExternalStorage() इसलिए का परिणाम प्राप्त करना चाहते हैं

यहाँ मैं अब तक किया है मैं एंड्रॉइड 6 के लिए गैलरी चुनने के लिए गतिविधि शुरू कर सकता हूं। मैं शून्य वर्ग का परिणाम कैसे प्राप्त कर सकता हूं? और एक और बात यह है कि मुझे अपने ऐप के लिए हर अनुमति के लिए विधि लिखनी है?

Answer 1

इसलिए मैंने अनुमतियों का अनुरोध करने के लिए कोड को पूरी तरह से फिर से लिखा है। अब यह उचित अनुमति के साथ एकाधिक अनुमतियों और चलने वाले कोड के लिए अनुरोध करने का समर्थन करता है। यह प्रीमारशैलो उपकरणों के साथ भी काम करता है, इसलिए आपको उस मामले में कोड को जांचने और कॉपी करने की आवश्यकता नहीं है।

पहले, इस कोड के साथ एक गतिविधि वर्ग बनाने (आप गतिविधि के किसी भी राजा की जरूरत है, जैसे AppCompatActivity विस्तार कर सकते हैं):

:

public abstract class PermissionActivity extends AppCompatActivity { 

    private final ArrayList<PermissionListener> permissionListeners = new ArrayList<>(); 

    @SuppressWarnings("unused") 
    public void requestPermissions(int requestCode, String[] requestPermissions, PermissionListener permissionListener) { 
     requestPermissions(requestCode, requestPermissions, null, permissionListener); 
    } 

    @SuppressWarnings("unused") 
    public void requestPermissions(final int requestCode, String[] requestPermissions, String message, final PermissionListener permissionListener) { 
     final int[] grantResults = new int[requestPermissions.length]; 

     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
      ArrayList<String> list_notGranted = new ArrayList<>(); 

      for (String requestPermission : requestPermissions) 
       if (ContextCompat.checkSelfPermission(this, requestPermission) != PackageManager.PERMISSION_GRANTED) 
        list_notGranted.add(requestPermission); 

      if (list_notGranted.size() > 0) { 
       permissionListeners.add(permissionListener); 

       requestPermissions = list_notGranted.toArray(new String[list_notGranted.size()]); 

       if (message != null) { 
        boolean shouldShowRequestPermissionRationale = false; 

        for (String permission : requestPermissions) 
         if (ActivityCompat.shouldShowRequestPermissionRationale(this, permission)) { 
          shouldShowRequestPermissionRationale = true; 
          break; 
         } 

        if (shouldShowRequestPermissionRationale) { 
         final String[] f_requestPermissions = requestPermissions; 

         AlertDialog.Builder builder = new AlertDialog.Builder(this); 

         builder.setMessage(message); 

         DialogInterface.OnClickListener onClickListener = new DialogInterface.OnClickListener() { 

          @TargetApi(Build.VERSION_CODES.M) 
          @Override 
          public void onClick(DialogInterface dialog, int which) { 
           switch (which) { 
            case DialogInterface.BUTTON_POSITIVE: 
             PermissionActivity.super.requestPermissions(f_requestPermissions, requestCode); 
             break; 
            default: 
             for (int i = 0; i < grantResults.length; i++) 
              grantResults[i] = PackageManager.PERMISSION_DENIED; 

             if (permissionListener != null) 
              permissionListener.onResult(requestCode, f_requestPermissions, grantResults); 
             break; 
           } 
          } 
         }; 

         builder.setPositiveButton("OK", onClickListener); 
         builder.setNegativeButton("Cancel", onClickListener); 

         builder.show(); 
        } else { 
         super.requestPermissions(requestPermissions, requestCode); 
        } 
       } else { 
        super.requestPermissions(requestPermissions, requestCode); 
       } 
      } else { 
       for (int i = 0; i < grantResults.length; i++) 
        grantResults[i] = PackageManager.PERMISSION_GRANTED; 

       if (permissionListener != null) 
        permissionListener.onResult(requestCode, requestPermissions, grantResults); 
      } 
     } else { 
      if (permissionListener != null) { 
       for (int i = 0; i < grantResults.length; i++) 
        grantResults[i] = PackageManager.PERMISSION_GRANTED; 

       permissionListener.onResult(requestCode, requestPermissions, grantResults); 
      } 
     } 
    } 

    @Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) { 
     for (Iterator<PermissionListener> it = permissionListeners.iterator(); it.hasNext();) { 
      PermissionListener permissionListener = it.next(); 
      if (permissionListener.onResult(requestCode, permissions, grantResults)) { 
       it.remove(); 
      } 
     } 
    } 

    public interface PermissionListener { 

     boolean onResult(int requestCode, String[] requestPermissions, int[] grantResults); 

    } 
} 

आप टुकड़े से अनुमतियों का अनुरोध करने, इस वर्ग को जोड़ने चाहते हैं

public class PermissionFragment extends Fragment { 

    @SuppressWarnings("unused") 
    public void requestPermissions(int requestCode, String[] requestPermissions, PermissionActivity.PermissionListener permissionListener) { 
     requestPermissions(requestCode, requestPermissions, null, permissionListener); 
    } 

    @SuppressWarnings("unused") 
    public void requestPermissions(final int requestCode, String[] requestPermissions, String message, PermissionActivity.PermissionListener permissionListener) { 
     ((PermissionActivity) getActivity()).requestPermissions(requestCode, requestPermissions, message, permissionListener); 
    } 
} 

आपकी गतिविधियां और टुकड़े स्टैंडआउट वाले लोगों के बजाय इन वर्गों का विस्तार करना चाहिए।

अब तुम एक विधि को फोन करके अनुमतियों का अनुरोध करने के लिए तैयार हैं:

requestPermissions(int requestCode, String[] requestPermissions, PermissionListener permissionListener) 

अनुमति काम करने के लिए एप्लिकेशन के लिए आवश्यक है, तो आप इस विधि कॉल और क्यों अनुमति की आवश्यकता नहीं है कह संदेश निर्दिष्ट करना चाहिए ।

requestPermissions(int requestCode, String[] requestPermissions, String message, PermissionListener permissionListener) 

न Misscall डिफ़ॉल्ट विधि है, जो

// DON'T USE THIS ONE! 
requestPermissions(String[] requestPermissions, int requestCode) 
// DON'T USE THIS ONE! 

यहाँ का अनुरोध संपर्कों के उदाहरण है:

private void requestAndLoadContacts() { 
    String[] permissions = new String[]{Manifest.permission.READ_CONTACTS}; 

    requestPermissions(REQUEST_PERMISSIONS_CONTACTS, permissions, "Read contacts permission is required for the app to work!", new PermissionListener() { 

     @Override 
     public boolean onResult(int requestCode, String[] requestPermissions, int[] grantResults) { 
      // Check if the requestCode is ours 
      if (requestCode == REQUEST_PERMISSIONS_CONTACTS) { 
       // Check if the permission is correct and is granted 
       if (requestPermissions[0].equals(Manifest.permission.READ_CONTACTS) && grantResults[0] == PackageManager.PERMISSION_GRANTED) { 
        // Permission granted 
        // Calling a method to actually load the contacts 
        loadContacts(); 
       } else { 
        // Permission not granted 
        Toast.makeText(MainActivity.this, "Access denied!", Toast.LENGTH_SHORT).show(); 
       } 

       return true; 
      } 

      return false; 
     } 
    }); 
} 

नोट: जब आप PermissionListener लागू, मत भूलना पर वापस लौटें जब अनुरोध कोड सही एक है, ओथ Rwise PermissionListener को ArrayList से हटाया नहीं जाएगा और आपको सबसे छोटी स्मृति रिसाव मिल जाएगी।

Answer 2

संपादित

मैं कोड rewritted और एक अन्य जवाब में पोस्ट किया है।

पुराना जवाब:

हाँ, आप की जाँच करें और हर बार अनुमति के लिए पूछने के लिए है।

आमतौर पर मैं इस तरह कोड लिखने:

private int requestPermissionCode; 
private Runnable requestPermissionRunnable; 

private void runPermissionCode(String requestPermission, int requestCode, Runnable codeToRun) { 
    if (android.os.Build.VERSION.SDK_INT >= 23) { 
     if (ContextCompat.checkSelfPermission(getActivity(), Manifest.permission.READ_EXTERNAL_STORAGE) 
       != PackageManager.PERMISSION_GRANTED) { 

      requestPermissionCode = requestCode; 
      requestPermissionRunnable = codeToRun; 

      requestPermissions(new String[]{requestPermission}, 
        requestCode); 
     } 
    } else { 
     codeToRun.run(); 
    } 
} 

@Override 
public void onRequestPermissionsResult(int requestCode, 
             @NonNull String permissions[], 
             @NonNull int[] grantResults) { 
    if (requestCode == requestPermissionCode) { 
     if (grantResults.length == 1 && 
       grantResults[0] == PackageManager.PERMISSION_GRANTED) { 

      if (requestPermissionRunnable != null) 
       requestPermissionRunnable.run(); 
     } else { 
      Toast.makeText(getActivity(), "Permission denied", Toast.LENGTH_SHORT).show(); 
     } 
    } else { 
     super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    } 
} 

और इस तरह इसे चलाने:

runPermissionCode(Manifest.permission.READ_EXTERNAL_STORAGE, READ_CONTACTS_PERMISSIONS_REQUEST, new Runnable() { 

     @Override 
     public void run() { 
      // your code here 
     } 
    }); 

मैं इसे एक सबसे अच्छा तरीका नहीं है यकीन है, लेकिन कम से कम यह करने के लिए एक संभावना प्रदान करता है अनुरोध अनुमति और कार्यों को आसान बनाते हैं।

Answer 3

डिवाइस और अनुमतियों के लिए अनुरोध के लिए आपकी अनुमति के प्रारंभ

private static final int INITIAL_REQUEST = 1337; 
private static final int GET_ACCOUNTS = INITIAL_REQUEST+2; 
private static final int LOCATION_REQUEST =INITIAL_REQUEST+3; 

private static final String[] INITIAL_PERMS = { 
     Manifest.permission.GET_ACCOUNTS, 
     Manifest.permission.INTERNET, 
     Manifest.permission.ACCESS_FINE_LOCATION 
}; 

चेक

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

चेक अनुमति दी जाती है या नहीं

private boolean canAccessAccounts() { 

    return (hasPermission(Manifest.permission.GET_ACCOUNTS)); 
} 
private boolean canAccessLocation() { 

    return (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)); 
} 
private boolean canAccessInternet() { 
    return (hasPermission(Manifest.permission.INTERNET)); 
} 
private boolean hasPermission(String perm) { 
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 
     return (PackageManager.PERMISSION_GRANTED == checkSelfPermission(perm)); 
    } 
    return (true); 
} 

अपडेट अनुमतियां और अनुमतियों के लिए विधि की जाँच करें

void UpdatePermissions(){ 

    canAccessInternet(); 
    canAccessLocation(); 
    canAccessInternet(); 
} 

@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    UpdatePermissions(); 
    switch(requestCode) { 
     case GET_ACCOUNTS: 
      if (canAccessAccounts()) { 

      } 
      else { 

      } 
      break; 

     case LOCATION_REQUEST: 
      if (canAccessLocation()) { 

      } 
      else { 

      } 
      break; 

     case INITIAL_REQUEST: 
      if(canAccessInternet()){ 

      }else { 

      } 
      break; 

    } 
}