Reputation: 1204

Having trouble in asking multiple permission in android Marshmallow

I am working on an app in which I want to ask multiple permission at run time. My code is worked fine for one Permission. However when I want to ask for multiple permission my code does nothing . Can anyone tell me what wrong with my code?

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

Any kind of help is appreciate by me thanks.

Upvotes: 4

Answers (7)

Patrick R

Reputation: 6857

In your activity:

private static final int MY_PERMISSIONS = 111;

in onCreate method:

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) {

}

Check for your AndroidManifest.xml file:

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

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

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

Upvotes: 1

Andy Res

Reputation: 16043

My code is worked fine for one Permission. However when I want to ask for multiple permission my code does nothing.

Leaving aside that your code is too verbose and makes it harder to read, the checkMultiplePermission() method works fine. I have copied it into a test project and when I started the app I was asked for the 5 permissions.

(5 because WRITE_EXTERNAL_STORAGE/READ_EXTERNAL_STORAGE and ACCESS_FINE_LOCATION/ACCESS_COARSE_LOCATION are merged each into a single permission request)

Please double check that you updated your AndroidManifest.xml file with the new permissions. It can be that previously when you were testing your code with only one permission, you accepted it, then more permissions were added to the request logic but forgotten to be listed in the AndroidManifest.xml. In this case Android will ignore your request, nor will throw it an exception, it will simply do nothing.

Upvotes: 0

Rahul Chaudhary

Reputation: 1061

you can achieve this by this way

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

now create a method

 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();
    }
}

Upvotes: 0

Sebastian

Reputation: 417

do this... on 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);
    }

Checking if already permission...

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

This is for camera and read storage, you can add whatever you want...

Upvotes: 0

rafsanahmad007

Reputation: 23881

try this:

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();
}

When every single permission got its grant result, the result will be sent to the same callback method, 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);
    }
}

Hope this helps u..

Upvotes: 0

Foram Shah

Reputation: 191

First check permission is already granted or not.

Here you can check more then one permissions.

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

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

checkForPermission method.

/***
 * 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 method its like onActivityResult.

/***
 * 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;
    }
}

Upvotes: 1

Ravish Sharma

Reputation: 207

For Multiple Permisions:

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();

    }

            }

    }

And In Your Main Activity:

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();
}
}

Upvotes: 0

Having trouble in asking multiple permission in android Marshmallow

Answers (7)

Related Questions