Android
एपीआई -23 + में रनटाइम अनुमतियाँ

परिचय

टिप्पणियों

Android 6.0 एकाधिक अनुमतियाँ

यह उदाहरण दिखाता है कि एंड्रॉइड 6 और बाद में रनटाइम पर अनुमतियों की जांच कैसे करें।

public static final int MULTIPLE_PERMISSIONS = 10; // code you want.

String[] permissions = new String[] {
    Manifest.permission.WRITE_EXTERNAL_STORAGE,
    Manifest.permission.CAMERA,
    Manifest.permission.ACCESS_COARSE_LOCATION,
    Manifest.permission.ACCESS_FINE_LOCATION
};

@Override
void onStart() {
    if (checkPermissions()){
        // permissions granted.    
    } else {
        // show dialog informing them that we lack certain permissions
    }
}

private boolean checkPermissions() {
    int result;
    List<String> listPermissionsNeeded = new ArrayList<>();
    for (String p:permissions) {
        result = ContextCompat.checkSelfPermission(getActivity(),p);
        if (result != PackageManager.PERMISSION_GRANTED) {
            listPermissionsNeeded.add(p);
        }
    }
    if (!listPermissionsNeeded.isEmpty()) {
        ActivityCompat.requestPermissions(this, listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]), MULTIPLE_PERMISSIONS);
        return false;
    }
    return true;
}

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case MULTIPLE_PERMISSIONS:{
            if(grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED){
                // permissions granted.
            } else {
                // no permissions granted.
            }
            return;
        }
    }
}

प्रसारण में अनुमतियाँ लागू करना, यू.आर.आई.

एक पंजीकृत प्रसारण रिसीवर को एक आशय भेजते समय आप एक अनुमतियों की जांच कर सकते हैं। आपके द्वारा भेजी जाने वाली अनुमतियां टैग के तहत पंजीकृत लोगों के साथ क्रॉस-चेक की जाती हैं। वे प्रतिबंधित करते हैं जो संबंधित रिसीवर को प्रसारण भेज सकते हैं।

अनुमति के साथ एक प्रसारण अनुरोध भेजने के लिए, में एक स्ट्रिंग के रूप अनुमति निर्दिष्ट Context.sendBroadcast(Intent intent, String permission) कॉल, लेकिन ध्यान रखें कि रिसीवर के एप्लिकेशन चाहिए ताकि आपके प्रसारण प्राप्त करने के लिए है कि अनुमति है। प्रेषक को प्रेषक से पहले पहले स्थापित किया जाना चाहिए।

विधि हस्ताक्षर है:

 void sendBroadcast (Intent intent, String receiverPermission)
 //for example to send a broadcast to Bcastreceiver receiver
 Intent broadcast = new Intent(this, Bcastreceiver.class);
 sendBroadcast(broadcast, "org.quadcore.mypermission");

और आप अपने मैनिफेस्ट में यह निर्दिष्ट कर सकते हैं कि प्रसारण प्रेषक को SendBroadcast के माध्यम से भेजे गए अनुरोध को शामिल करना आवश्यक है:

 <!--  Your special permission -->
 <permission android:name="org.quadcore.mypermission" 
    android:label="my_permission" 
    android:protectionLevel="dangerous"></permission>

इस प्रसारण को प्राप्त करने वाले एप्लिकेशन के प्रकट होने की अनुमति की भी घोषणा करें:

 <!--  I use the permission ! -->
 <uses-permission android:name="org.quadcore.mypermission"/>
 <!-- along with the receiver -->
 <receiver android:name="Bcastreceiver" android:exported="true" />

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

अनुमतियों पर यहां पूर्ण प्रलेखन का पता लगाएं।

एक ही अनुमति समूहों से कई रनटाइम अनुमतियाँ

प्रकट में हमारे पास दो समूहों से चार खतरनाक रनटाइम अनुमतियां हैं।

<!-- Required to read and write to shredPref file. -->
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/>

<!-- Required to get location of device. -->
<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION"/>
<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>

गतिविधि में जहां अनुमतियों की आवश्यकता होती है। ध्यान दें कि किसी भी गतिविधि में अनुमतियों की जांच करना आवश्यक है, जिनके लिए अनुमतियों की आवश्यकता होती है, क्योंकि एप्लिकेशन पृष्ठभूमि में होने पर अनुमतियों को रद्द किया जा सकता है और ऐप तब क्रैश हो जाएगा।

final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;


@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.act_layout);
    
    // A simple check of whether runtime permissions need to be managed 
    if (Build.VERSION.SDK_INT >= 23) {
        checkMultiplePermissions();
    }

हमें केवल प्रत्येक समूह से इनमें से किसी एक के लिए अनुमति माँगने की आवश्यकता है और इस समूह की अन्य सभी अनुमतियाँ तब तक दी जाती हैं जब तक कि उपयोगकर्ता द्वारा अनुमति रद्द न कर दी जाए।

private void checkMultiplePermissions() {

    if (Build.VERSION.SDK_INT >= 23) {
        List<String> permissionsNeeded = new ArrayList<String>();
        List<String> permissionsList = new ArrayList<String>();
        
        if (!addPermission(permissionsList, android.Manifest.permission.ACCESS_FINE_LOCATION)) {
            permissionsNeeded.add("GPS");
        }

        if (!addPermission(permissionsList, android.Manifest.permission.READ_EXTERNAL_STORAGE)) {
            permissionsNeeded.add("Read Storage");
        }
        
        if (permissionsList.size() > 0) {
            requestPermissions(permissionsList.toArray(new String[permissionsList.size()]),
                    REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS);
            return;
        }
    }
}



private boolean addPermission(List<String> permissionsList, String permission) {
    if (Build.VERSION.SDK_INT >= 23)

        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(android.Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.PERMISSION_GRANTED);
            perms.put(android.Manifest.permission.READ_EXTERNAL_STORAGE, PackageManager.PERMISSION_GRANTED);
            
            // Fill with results
            for (int i = 0; i < permissions.length; i++)
                perms.put(permissions[i], grantResults[i]);
            if (perms.get(android.Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
                    && perms.get(android.Manifest.permission.READ_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
                // All Permissions Granted
                return;
            } else {
                // Permission Denied
                if (Build.VERSION.SDK_INT >= 23) {
                    Toast.makeText(
                            getApplicationContext(),
                            "My App cannot run without Location and Storage " +
                                    "Permissions.\nRelaunch My App or allow permissions" +
                                    " in Applications Settings",
                            Toast.LENGTH_LONG).show();
                    finish();
                }
            }
        }
        break;
        default:
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

अधिक जानकारी https://inthecheesefactory.com/blog/things-you-need-to-know-about-android-m-permission-developer-edition/en

PermissionUtil का उपयोग करना

PermissionUtil संदर्भ में अनुमति मांगने का एक सरल और सुविधाजनक तरीका है। आप आसानी से प्रदान कर सकते हैं कि सभी अनुरोधित अनुमतियों ( onAllGranted() ) के मामले में क्या होना चाहिए, किसी भी अनुरोध को अस्वीकार कर दिया गया ( onAnyDenied() ) या उस स्थिति में जब तर्कसंगत की जरूरत है ( onRational() )।

कहीं भी आपके AppCompatActivity या Fragment में आप उपयोगकर्ता की अनुमति के लिए पूछना चाहते हैं

mRequestObject = PermissionUtil.with(this).request(Manifest.permission.WRITE_EXTERNAL_STORAGE).onAllGranted(
                new Func() {
                    @Override protected void call() {
                        //Happy Path
                    }
                }).onAnyDenied(
                new Func() {
                    @Override protected void call() {
                        //Sad Path
                    }
                }).ask(REQUEST_CODE_STORAGE);

और इसे onRequestPermissionsResult जोड़ें

if(mRequestObject!=null){
    mRequestObject.onRequestPermissionsResult(requestCode, permissions, grantResults);
}

अपने AndroidManifest.xml के रूप में अच्छी तरह से अनुरोधित अनुमति जोड़ें

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

सभी अनुमति-संबंधित कोड को एक सार आधार वर्ग में शामिल करें और क्लीनर / पुन: प्रयोज्य कोड प्राप्त करने के लिए इस आधार वर्ग की गतिविधि का विस्तार करें

public abstract class BaseActivity extends AppCompatActivity {
    private Map<Integer, PermissionCallback> permissionCallbackMap = new HashMap<>();

    @Override
    protected void onStart() {
        super.onStart();
        ...
    }

    @Override
    public void setContentView(int layoutResId) {
        super.setContentView(layoutResId);
        bindViews();
    }

    ...

    @Override
    public void onRequestPermissionsResult(
            int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        PermissionCallback callback = permissionCallbackMap.get(requestCode);

        if (callback == null) return;

        // Check whether the permission request was rejected.
        if (grantResults.length < 0 && permissions.length > 0) {
            callback.onPermissionDenied(permissions);
            return;
        }

        List<String> grantedPermissions = new ArrayList<>();
        List<String> blockedPermissions = new ArrayList<>();
        List<String> deniedPermissions = new ArrayList<>();
        int index = 0;

        for (String permission : permissions) {
            List<String> permissionList = grantResults[index] == PackageManager.PERMISSION_GRANTED
                    ? grantedPermissions
                    : ! ActivityCompat.shouldShowRequestPermissionRationale(this, permission)
                        ? blockedPermissions
                        : deniedPermissions;
            permissionList.add(permission);
            index ++;
        }

        if (grantedPermissions.size() > 0) {
            callback.onPermissionGranted(
                    grantedPermissions.toArray(new String[grantedPermissions.size()]));
        }

        if (deniedPermissions.size() > 0) {
            callback.onPermissionDenied(
                    deniedPermissions.toArray(new String[deniedPermissions.size()]));
        }

        if (blockedPermissions.size() > 0) {
            callback.onPermissionBlocked(
                    blockedPermissions.toArray(new String[blockedPermissions.size()]));
        }

        permissionCallbackMap.remove(requestCode);
    }

    /**
     * Check whether a permission is granted or not.
     *
     * @param permission
     * @return
     */
    public boolean hasPermission(String permission) {
        return ContextCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED;
    }

    /**
     * Request permissions and get the result on callback.
     *
     * @param permissions
     * @param callback
     */
    public void requestPermission(String [] permissions, @NonNull PermissionCallback callback) {
        int requestCode = permissionCallbackMap.size() + 1;
        permissionCallbackMap.put(requestCode, callback);
        ActivityCompat.requestPermissions(this, permissions, requestCode);
    }

    /**
     * Request permission and get the result on callback.
     *
     * @param permission
     * @param callback
     */
    public void requestPermission(String permission, @NonNull PermissionCallback callback) {
        int requestCode = permissionCallbackMap.size() + 1;
        permissionCallbackMap.put(requestCode, callback);
        ActivityCompat.requestPermissions(this, new String[] { permission }, requestCode);
    }
}

गतिविधि में उदाहरण का उपयोग

गतिविधि को ऊपर दिए गए सार आधार वर्ग का विस्तार करना चाहिए:

private void requestLocationAfterPermissionCheck() {
    if (hasPermission(Manifest.permission.ACCESS_FINE_LOCATION)) {
        requestLocation();
        return;
    }

    // Call the base class method.
    requestPermission(Manifest.permission.ACCESS_FINE_LOCATION, new PermissionCallback() {
        @Override
        public void onPermissionGranted(String[] grantedPermissions) {
            requestLocation();
        }

        @Override
        public void onPermissionDenied(String[] deniedPermissions) {
            // Do something.
        }

        @Override
        public void onPermissionBlocked(String[] blockedPermissions) {
            // Do something.
        }
    });
}