एंड्रॉयड क्रम permissions- लागू करने के लिए कैसे

Question

Android Developer Documentation रनटाइम पर अनुमतियाँ अनुरोध के इस उदाहरण देता है:

// Here, thisActivity is the current activity 
if (ContextCompat.checkSelfPermission(thisActivity, 
      Manifest.permission.READ_CONTACTS) 
    != PackageManager.PERMISSION_GRANTED) { 

    // Should we show an explanation? 
    if (ActivityCompat.shouldShowRequestPermissionRationale(thisActivity, 
      Manifest.permission.READ_CONTACTS)) { 

     // 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(thisActivity, 
       new String[]{Manifest.permission.READ_CONTACTS}, 
       MY_PERMISSIONS_REQUEST_READ_CONTACTS); 

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

"MY_PERMISSIONS_REQUEST_READ_CONTACTS" इस उदाहरण में क्या है? यह कहता है कि यह एक ऐप-परिभाषित int निरंतर है, लेकिन क्या इसका मतलब है कि मुझे Constants.java बनाना चाहिए और सार्वजनिक स्थैतिक int घोषित करना चाहिए? मूल्य क्या होना चाहिए?

अन्य उदाहरणों में मैं लोगों को 1 यहां, या 0 या 0xFFEEDDCC का उपयोग करता हूं, लेकिन मुझे यह पता नहीं चल रहा है कि यह क्या है। क्या कोई मुझे समझा सकता है कि यहां क्या जाना है और क्यों? (मेरे मामले में, मुझे यह सुनिश्चित करने की ज़रूरत है कि ऐप को ठीक स्थान तक पहुंचने की अनुमति है)

गतिविधि कॉम्पैक्ट दस्तावेज कहता है "परिणाम के लिए अनुरोध करने के लिए आवेदन विशिष्ट अनुरोध कोड पर क्लिक करें परिणामस्वरूप अनुरोध करें"? यह मेरी मदद नहीं करता है।

Answer 1

इस उदाहरण में "MY_PERMISSIONS_REQUEST_READ_CONTACTS" क्या है?

यह एक int है, इसी onRequestPermissionsResult() कॉलबैक करने के लिए एक विशेष requestPermissions() कॉल टाई।

कवर के तहत, requestPermissions()startActivityForResult() का उपयोग करता है; यह int उसी भूमिका में कार्य करता है जैसा यह startActivityForResult() में करता है।

क्या इसका मतलब है कि मुझे Constants.java बनाना चाहिए और सार्वजनिक स्थैतिक int घोषित करना चाहिए?

मैं इसे गतिविधि में private static final int बना दूंगा। लेकिन, आप जहां भी चाहें घोषित कर सकते हैं।

मूल्य क्या होना चाहिए?

मुझे याद है कि इसे 0x8000000 से नीचे होना चाहिए, लेकिन अन्यथा यह जो भी आप चाहते हैं हो सकता है। एक गतिविधि में प्रत्येक requestPermissions() कॉल के लिए उपयोग किए जाने वाले मान को एक अलग int प्राप्त करना चाहिए, लेकिन वास्तविक संख्या कोई फर्क नहीं पड़ता।

यदि आपकी गतिविधि में केवल एक requestPermissions() कॉल है, तो int मान वास्तव में कोई फर्क नहीं पड़ता। लेकिन कई ऐप्स में एक गतिविधि में कई requestPermissions() कॉल होंगे। उस स्थिति में, डेवलपर को onRequestPermissionsResult() में जानना आवश्यक हो सकता है, इसका क्या परिणाम है।

Answer 2

"अनुमति अनुरोध प्रतिक्रिया को संभालने" के तहत दस्तावेज़ में थोड़ा और नीचे देखें और आप इसका उद्देश्य देखेंगे।

एक कॉलबैक विधि onRequestPermissionsResult नामक एक पैरामीटर के रूप में वापस भेज दिया जाता है एक ही कोड तो आप जानते हैं जो अनुमति का अनुरोध किया जा रहा था/दी गई:

@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 
    } 
} 

निरंतर जब से तुम से प्रयोग किया जाता है केवल आप इसे जो भी मूल्य दे सकते हैं आपको public static final int के रूप में पसंद है। अनुरोध की जाने वाली प्रत्येक अनुमति की अपनी स्थिरता की आवश्यकता है।

Answer 3

public class SplashActivity extends RuntimePermissionsActivity { 


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

    SplashActivity.super.requestAppPermissions(new 
        String[]{android.Manifest.permission.READ_PHONE_STATE, 
        Manifest.permission.WRITE_EXTERNAL_STORAGE, 
        Manifest.permission.READ_EXTERNAL_STORAGE}, R.string.app_name 
      , 20); 

} 

@Override 
public void onPermissionsGranted(int requestCode) { 


    try { 
     TelephonyManager tele = (TelephonyManager) getApplicationContext() 
       .getSystemService(Context.TELEPHONY_SERVICE); 

     String imei =tele.getDeviceId() 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

public abstract class RuntimePermissionsActivity extends AppCompatActivity { 
private SparseIntArray mErrorString; 

@Override 
protected void onCreate(@Nullable Bundle savedInstanceState) { 
    super.onCreate(savedInstanceState); 
    mErrorString = new SparseIntArray(); 
} 

@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    int permissionCheck = PackageManager.PERMISSION_GRANTED; 
    for (int permission : grantResults) { 
     permissionCheck = permissionCheck + permission; 
    } 
    if ((grantResults.length > 0) && permissionCheck == PackageManager.PERMISSION_GRANTED) { 
     onPermissionsGranted(requestCode); 
    } else { 

     finish(); 

    } 
} 

public void requestAppPermissions(final String[] requestedPermissions, 
            final int stringId, final int requestCode) { 
    mErrorString.put(requestCode, stringId); 
    int permissionCheck = PackageManager.PERMISSION_GRANTED; 
    boolean shouldShowRequestPermissionRationale = false; 
    for (String permission : requestedPermissions) { 
     permissionCheck = permissionCheck + ContextCompat.checkSelfPermission(this, permission); 
     shouldShowRequestPermissionRationale = shouldShowRequestPermissionRationale || ActivityCompat.shouldShowRequestPermissionRationale(this, permission); 
    } 
    if (permissionCheck != PackageManager.PERMISSION_GRANTED) { 
     if (shouldShowRequestPermissionRationale) { 
      ActivityCompat.requestPermissions(RuntimePermissionsActivity.this, requestedPermissions, requestCode); 
      /*Snackbar.make(findViewById(android.R.id.content), stringId, 
        Snackbar.LENGTH_INDEFINITE).setAction("GRANT", 
        new View.OnClickListener() { 
         @Override 
         public void onClick(View v) { 
          ActivityCompat.requestPermissions(RuntimePermissionsActivity.this, requestedPermissions, requestCode); 
         } 
        }).show();*/ 
     } else { 
      ActivityCompat.requestPermissions(this, requestedPermissions, requestCode); 
     } 
    } else { 
     onPermissionsGranted(requestCode); 
    } 
} 

public abstract void onPermissionsGranted(int requestCode); 

}