एंड्रॉइड मार्शमलो

Question

में एकाधिक अनुमति मांगने में परेशानी होने पर मैं एक ऐप पर काम कर रहा हूं जिसमें मैं रन टाइम पर एकाधिक अनुमति मांगना चाहता हूं। मेरा कोड एक अनुमति के लिए ठीक काम किया है। हालांकि जब मैं एकाधिक अनुमति मांगना चाहता हूं तो मेरा कोड कुछ भी नहीं करता है। क्या कोई मुझे बता सकता है कि मेरे कोड में क्या गलत है?

package saleskit.orbitsys.com.androidpermissiondemo; 

import android.Manifest; 
import android.content.DialogInterface; 
import android.content.Intent; 
import android.content.pm.PackageManager; 
import android.net.Uri; 
import android.os.Build; 
import android.provider.Settings; 
import android.support.annotation.NonNull; 
import android.support.v4.app.ActivityCompat; 
import android.support.v4.content.ContextCompat; 
import android.support.v7.app.ActionBar; 
import android.support.v7.app.AlertDialog; 
import android.support.v7.app.AppCompatActivity; 
import android.os.Bundle; 
import android.util.Log; 
import android.view.Window; 
import android.view.WindowManager; 
import android.webkit.WebSettings; 
import android.webkit.WebView; 
import android.webkit.WebViewClient; 

import java.util.ArrayList; 
import java.util.List; 


public class MainActivity extends AppCompatActivity { 

    private static final int REQUEST_INTERNET = 200; 
    private static final int REQUEST_CODE_INTERNET = 110; 
    private static final int PERMISSION_REQUEST_CODE_GPS = 111; 
    public static final int PERMISSION_REQUEST_CODE_CONTACT = 112; 
    public static final int PERMISSION_REQUEST_CODE_CAMARA = 113; 
    public static final int REQUEST_ID_MULTIPLE_PERMISSIONS = 201; 
    private WebView htmlWebView; 

    @Override 
    protected void onCreate(Bundle savedInstanceState) { 
     requestWindowFeature(Window.FEATURE_NO_TITLE); 
     getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN, WindowManager.LayoutParams.FLAG_FULLSCREEN); 
     super.onCreate(savedInstanceState); 
     setContentView(R.layout.activity_main); 
     ActionBar actionBar 
       = getSupportActionBar(); 
     if (null != actionBar) { 
      actionBar.hide(); 
     } 
checkMultiplePermission(); 

     /* if (ContextCompat.checkSelfPermission(MainActivity.this,Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) { 
      ActivityCompat.requestPermissions(MainActivity.this, new String[]{ Manifest.permission.RECORD_AUDIO}, REQUEST_INTERNET); 
     }*/ 


     htmlWebView = (WebView) findViewById(R.id.webView); 
     assert htmlWebView != null; 
     WebSettings webSetting = htmlWebView.getSettings(); 
     webSetting.setJavaScriptEnabled(true); 
     webSetting.setDisplayZoomControls(true); 
     htmlWebView.setWebViewClient(new CustomWebViewClient()); 
     htmlWebView.loadUrl("https://inducesmile.com/blog"); 

    } 

    public boolean checkMultiplePermission() { 
     if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { 

       int permissionFineLocation = ContextCompat.checkSelfPermission(MainActivity.this, 
         Manifest.permission.ACCESS_FINE_LOCATION); 
       int permissionCorseLocation = ContextCompat.checkSelfPermission(MainActivity.this, 
         Manifest.permission.ACCESS_COARSE_LOCATION); 
       int permissioncamera = ContextCompat.checkSelfPermission(MainActivity.this, 
         Manifest.permission.CAMERA); 
       int permissioncall = ContextCompat.checkSelfPermission(MainActivity.this, 
         Manifest.permission.CALL_PHONE); 
       int permissionSDCARD = ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.WRITE_EXTERNAL_STORAGE); 
       int permissionSDCARD2 = ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.READ_EXTERNAL_STORAGE); 
       int readSms = ContextCompat.checkSelfPermission(MainActivity.this, Manifest.permission.READ_SMS); 
       List<String> listPermissionsNeeded = new ArrayList<>(); 
       if (permissioncall != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.CALL_PHONE); 
       } 
       if (permissionCorseLocation != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.ACCESS_COARSE_LOCATION); 
       } 
       if (permissionFineLocation != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.ACCESS_FINE_LOCATION); 
       } 
       if (permissioncamera != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.CAMERA); 
       } 
       if (permissionSDCARD != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.WRITE_EXTERNAL_STORAGE); 
       } 
       if (permissionSDCARD2 != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.READ_EXTERNAL_STORAGE); 
       } 
       if (readSms != PackageManager.PERMISSION_GRANTED) { 
        listPermissionsNeeded.add(Manifest.permission.READ_SMS); 
       } 

       if (!listPermissionsNeeded.isEmpty()) { 
        ActivityCompat.requestPermissions(MainActivity.this, listPermissionsNeeded.toArray(new String[listPermissionsNeeded.size()]), REQUEST_ID_MULTIPLE_PERMISSIONS); 
        return false; 
       } 

       return true; 
      } else { 
       return true; 
      } 
     } 





    @Override 
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] listPermissionsNeeded, @NonNull int[] grantResults) { 
     if(listPermissionsNeeded.length == 0){ 
      return; 
     } 
     boolean allPermissionsGranted = true; 
     if(grantResults.length>0){ 
      for(int grantResult: grantResults){ 
       if(grantResult != PackageManager.PERMISSION_GRANTED){ 
        allPermissionsGranted = false; 
        break; 
       } 
      } 
     } 
     if(!allPermissionsGranted){ 
      boolean somePermissionsForeverDenied = false; 
      for(String permission: listPermissionsNeeded){ 
       if(ActivityCompat.shouldShowRequestPermissionRationale(this, permission)){ 
        ActivityCompat.requestPermissions(MainActivity.this, new String[]{ permission}, requestCode); 
        //denied 
        Log.e("denied", permission); 
       }else{ 
        if(ActivityCompat.checkSelfPermission(this, permission) == PackageManager.PERMISSION_GRANTED){ 
         ActivityCompat.requestPermissions(MainActivity.this, new String[]{ permission}, requestCode); 

         //allowed 
         Log.e("allowed", permission); 
        } else{ 


         somePermissionsForeverDenied = true; 
        } 
       } 
      } 
      if(somePermissionsForeverDenied){ 
       AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(this); 
       alertDialogBuilder.setTitle("Permissions Required") 
         .setMessage("You have forcefully denied some of the required permissions " + 
           "for this action. Please open settings, go to permissions and allow them.") 
         .setPositiveButton("OK", new DialogInterface.OnClickListener() { 
          @Override 
          public void onClick(DialogInterface dialog, int which) { 
           Intent intent = new Intent(Settings.ACTION_MANAGE_OVERLAY_PERMISSION, 
             Uri.fromParts("package", getPackageName(), null)); 
           intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
           startActivity(intent); 
          } 
         }) 


         .show(); 
      } 
     } else { 
      switch (requestCode) { 
       //act according to the request code used while requesting the permission(s). 
      } 
     } 
    } 
    private class CustomWebViewClient extends WebViewClient { 
     @Override 
     public boolean shouldOverrideUrlLoading(WebView view, String url) { 
      view.loadUrl(url); 
      return true; 
     } 
    } 
} 

किसी भी प्रकार की सहायता मेरे द्वारा धन्यवाद की सराहना करता है।

Answer 1

ऐसा करने ... यदि पहले से ही अनुमति जाँच हो रही है पर on create

int PERMISSION_ALL = 1; 
    String[] PERMISSIONS = {Manifest.permission.CAMERA,Manifest.permission.WRITE_EXTERNAL_STORAGE}; 
    if(!hasPermissions(this, PERMISSIONS)){ 
     //ask user for granting permissions on api22+ 
     ActivityCompat.requestPermissions(this, PERMISSIONS, PERMISSION_ALL); 
    } 

...

public static boolean hasPermissions(Context context, String... permissions) { 
    //checaking if the application has permission 
    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; 
} 

इस कैमरे के लिए है और भंडारण पढ़ते हैं, आप जो कुछ भी आप चाहते हैं जोड़ सकते हैं ...

Answer 2

एकाधिक अनुमतियों के लिए:

public abstract class AbsRuntimePermission extends Activity { 

private SparseIntArray mErrorString; 

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

} 

public abstract void onPermissionsGranted(int requestCode); 

public void requestAppPermissions(final String[]requestedPermissions, final int stringId, final int requestCode) { 
    mErrorString.put(requestCode, stringId); 

    int permissionCheck = PackageManager.PERMISSION_GRANTED; 
    boolean showRequestPermissions = false; 
    for(String permission: requestedPermissions) { 
     permissionCheck = permissionCheck + ContextCompat.checkSelfPermission(this, permission); 
     showRequestPermissions = showRequestPermissions || ActivityCompat.shouldShowRequestPermissionRationale(this, permission); 
    } 

    if (permissionCheck!=PackageManager.PERMISSION_GRANTED) { 
     if(showRequestPermissions) { 
      Snackbar.make(findViewById(android.R.id.content), stringId, Snackbar.LENGTH_INDEFINITE).setAction("GRANT", new View.OnClickListener() { 
       @Override 
       public void onClick(View v) { 
        ActivityCompat.requestPermissions(AbsRuntimePermission.this, requestedPermissions, requestCode); 
       } 
      }).show(); 
     } else { 
      ActivityCompat.requestPermissions(this, requestedPermissions, requestCode); 
     } 
    } else { 
     onPermissionsGranted(requestCode); 
    } 
} 

@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    int permissionCheck = PackageManager.PERMISSION_GRANTED; 
    for(int permisson : grantResults) { 
     permissionCheck = permissionCheck + permisson; 
    } 

    if((grantResults.length > 0) && PackageManager.PERMISSION_GRANTED == permissionCheck) { 
     onPermissionsGranted(requestCode); 
    } else { 
     //Display message when contain some Dangerous permisson not accept 

     AlertDialog.Builder alertDialogBuilder = new AlertDialog.Builder(new ContextThemeWrapper(this, android.R.style.Theme_Holo_Light_Dialog)); 
     alertDialogBuilder 
       .setMessage("Please enble permisions") 
       .setTitle("Please enble permisions") 
       .setCancelable(false) 
       .setPositiveButton(" Enable", 
         new DialogInterface.OnClickListener() { 
          @Override 
          public void onClick(DialogInterface dialog, int which) { 
           Intent i = new Intent(); 
           i.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS); 
           i.setData(Uri.parse("package:" + getPackageName())); 
           i.addCategory(Intent.CATEGORY_DEFAULT); 
           i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); 
           i.addFlags(Intent.FLAG_ACTIVITY_NO_HISTORY); 
           i.addFlags(Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS); 
           startActivity(i); 

          } 
         }); 



         alertDialogBuilder.setNegativeButton(" Cancel ", new DialogInterface.OnClickListener() { 
          public void onClick(DialogInterface dialog, int id) { 
           dialog.cancel(); 
          } 
         }); 

     AlertDialog alert = alertDialogBuilder.create(); 
     alert.show(); 

    } 

      } 

    } 

और अपने मुख्य गतिविधि में:

public class MainActivity extends AbsRuntimePermission { 

private static final int REQUEST_PERMISSION = 10; 

@Override 
protected void onCreate(Bundle savedInstanceState) { 

    super.onCreate(savedInstanceState); 
    setContentView(R.layout.activity_main); 

    requestAppPermissions(new String[]{ 
      Manifest.permission.READ_CONTACTS, 
      Manifest.permission.WRITE_EXTERNAL_STORAGE, 
      Manifest.permission.WRITE_CONTACTS}, 
      R.string.msg,REQUEST_PERMISSION); 
} 

@Override 
public void onPermissionsGranted(int requestCode) { 
    //Do anything when permisson granted 
    Toast.makeText(getApplicationContext(), "Permission granted", Toast.LENGTH_LONG).show(); 
} 
} 

Answer 3

पहले जांच कर लें अनुमति पहले से ही दी जाती है या नहीं।

यहां आप एक और अनुमतियों को और अधिक देख सकते हैं।

if (checkForPermission(getActivity(), CAMERA_PERMISSION) && checkForPermission(getActivity(), GALLERY_PERMISSION)) { 
     //Permission granted here 
     //TODO 

    } else { 
     requestPermissions(new String[]{CAMERA_PERMISSION, GALLERY_PERMISSION}, 1); 
} 

चेकफॉरप्रमिशन विधि।

/*** 
* Method is checking permission for Marshmallow 
* 
* @param context 
* @param permission 
* @return 
*/ 
private static boolean checkForPermission(final Context context, String permission) { 
    int result = ContextCompat.checkSelfPermission(context, permission); 
    //If permission is granted then it returns 0 as result 
    if (result == PackageManager.PERMISSION_GRANTED) { 
     return true; 
    } else { 
     return false; 
    } 
} 

onRequestPermissionsResult विधि इसकी सक्रियता पर निर्भर करता है।

/*** 
* This is call when user allow or deny permissions in the Marshmallow 
* 
* @param requestCode 
* @param permissions 
* @param grantResults 
*/ 
@Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    switch (requestCode) { 
     case 1: 
      if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED && grantResults[1] == PackageManager.PERMISSION_GRANTED) { 
       //Permission granted here 
       //TODO 

      } 
      break; 
    } 
} 

Answer 4

कोशिश यह:

final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124; 

public boolean checkMultiplePermission() { 
    List<String> permissionsNeeded = new ArrayList<String>(); 

    final List<String> permissionsList = new ArrayList<String>(); 
    if (!addPermission(permissionsList, Manifest.permission.ACCESS_FINE_LOCATION)) 
     permissionsNeeded.add("GPS"); 
    if (!addPermission(permissionsList, Manifest.permission.READ_CONTACTS)) 
     permissionsNeeded.add("Read Contacts"); 
    if (!addPermission(permissionsList, Manifest.permission.WRITE_CONTACTS)) 
     permissionsNeeded.add("Write Contacts"); 

    if (permissionsList.size() > 0) { 
     if (permissionsNeeded.size() > 0) { 
      // Need Rationale 
      String message = "You need to grant access to " + permissionsNeeded.get(0); 
      for (int i = 1; i < permissionsNeeded.size(); i++) 
       message = message + ", " + permissionsNeeded.get(i); 
      showMessageOKCancel(message, 
        new DialogInterface.OnClickListener() { 
         @Override 
         public void onClick(DialogInterface dialog, int which) { 
          requestPermissions(permissionsList.toArray(new String[permissionsList.size()]), 
            REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS); 
         } 
        }); 
      return; 
     } 
     requestPermissions(permissionsList.toArray(new String[permissionsList.size()]), 
       REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS); 
     return; 
    } 

    insertDummyContact(); 
} 

private boolean addPermission(List<String> permissionsList, String permission) { 
    if (checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED) { 
     permissionsList.add(permission); 
     // Check for Rationale Option 
     if (!shouldShowRequestPermissionRationale(permission)) 
      return false; 
    } 
    return true; 
} 


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

जब हर एक की अनुमति अपने अनुदान परिणाम मिला, परिणाम एक ही कॉलबैक विधि को भेजा जाएगा, onRequestPermissionsResult()

@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(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.PERMISSION_GRANTED); 
      perms.put(Manifest.permission.READ_CONTACTS, PackageManager.PERMISSION_GRANTED); 
      perms.put(Manifest.permission.WRITE_CONTACTS, PackageManager.PERMISSION_GRANTED); 
      // Fill with results 
      for (int i = 0; i < permissions.length; i++) 
       perms.put(permissions[i], grantResults[i]); 
      // Check for ACCESS_FINE_LOCATION 
      if (perms.get(Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED 
        && perms.get(Manifest.permission.READ_CONTACTS) == PackageManager.PERMISSION_GRANTED 
        && perms.get(Manifest.permission.WRITE_CONTACTS) == PackageManager.PERMISSION_GRANTED) { 
       // All Permissions Granted 
       //do your task.. 
      } else { 
       // Permission Denied 
       Toast.makeText(MainActivity.this, "Some Permission is Denied", Toast.LENGTH_SHORT) 
         .show(); 
      } 
      } 
      break; 
     default: 
      super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    } 
} 

आशा इस यू मदद करता है।

Answer 5

आप इसे इस तरह से प्राप्त कर सकते हैं

private static final int MY_PERMISSIONS_REQUEST_CALL = 7; 
    private static String[] PERMISSIONS = { 
     Manifest.permission.CALL_PHONE, Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}; 

अब एक विधि

public void checkSmsPermission() { 
    try { 
     if (Build.VERSION.SDK_INT >= 23) { 
      if (ActivityCompat.checkSelfPermission(context, Manifest.permission.WRITE_EXTERNAL_STORAGE) 
        != PackageManager.PERMISSION_GRANTED 
        || ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_EXTERNAL_STORAGE) 
        != PackageManager.PERMISSION_GRANTED || 
        ActivityCompat.checkSelfPermission(context, Manifest.permission.CALL_PHONE) 
          != PackageManager.PERMISSION_GRANTED 

        ) { 
       requestPermission(); 
      } else 
       checkLogin(); 
     } else { 
      checkLogin(); 


     } 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 



you can check grants result array for checking which permission is granted 



    @Override 
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) { 
    super.onRequestPermissionsResult(requestCode, permissions, grantResults); 
    try { 
     boolean flagDenied = false; 
     switch (requestCode) { 
      case MY_PERMISSIONS_REQUEST_CALL: 


       if (grantResults.length > 0 
         ) { 
        for (int i : grantResults) 
         if (i == -1) { 
          flagDenied = true; 
          break; 
         } 
        if (!flagDenied) 
         doJob(); 
        else showPermissionDialog(); 
       } 


       break; 


     } 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
} 

Answer 6

मेरे कोड एक अनुमति के लिए ठीक काम किया है पैदा करते हैं। हालांकि जब मैं एकाधिक अनुमति के लिए से पूछना चाहता हूं तो मेरा कोड कुछ भी नहीं करता है।

एक तरफ छोड़कर कि आपका कोड बहुत वर्बोज़ है और इसे पढ़ने में कठिन बनाता है, checkMultiplePermission() विधि ठीक काम करती है। मैंने इसे एक परीक्षण प्रोजेक्ट में कॉपी किया है और जब मैंने ऐप शुरू किया था तो मुझे 5 अनुमतियों के लिए कहा गया था।

(5 क्योंकि WRITE_EXTERNAL_STORAGE/READ_EXTERNAL_STORAGE और ACCESS_FINE_LOCATION/ACCESS_COARSE_LOCATION एक भी अनुमति अनुरोध में प्रत्येक विलय कर रहे हैं)

कृपया दोबारा जांच करें कि आप नए अनुमतियों के साथ अपने AndroidManifest.xml फ़ाइल अद्यतन किया गया। यह हो सकता है कि जब आप केवल एक ही अनुमति के साथ अपने कोड का परीक्षण कर रहे थे, तो आपने इसे स्वीकार कर लिया, फिर अनुरोध तर्क में और अनुमतियां शामिल की गईं लेकिन AndroidManifest.xml में सूचीबद्ध होने के लिए भूल गए। इस मामले में एंड्रॉइड आपके अनुरोध को अनदेखा कर देगा, न ही इसे अपवाद फेंक देगा, यह कुछ भी नहीं करेगा।

Answer 7

अपने activity में: onCreate

में

private static final int MY_PERMISSIONS = 111; 

विधि:

अपनी AndroidManifest.xml फ़ाइल के लिए

String[] mPermissionToRequest = new String[]{Manifest.permission.ACCESS_FINE_LOCATION,Manifest.permission.CAMERA,Manifest.permission.CALL_PHONE}; 

ActivityCompat.requestPermissions(this, mPermissionsToRequest, MY_PERMISSIONS); 

@Override 

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { 

} 

की जांच:

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

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

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