Android marshmallow yêu cầu cho phép?


165

Tôi hiện đang làm việc trên một ứng dụng yêu cầu một số quyền "nguy hiểm". Vì vậy, tôi đã thử thêm "xin phép" theo yêu cầu trong Android Marshmallow (API cấp 23), nhưng không thể tìm thấy cách thực hiện.

Làm cách nào tôi có thể xin phép sử dụng mô hình cấp phép mới trong ứng dụng của mình?


1
Hãy nhìn vào đây, đây là tất cả những gì bạn cần: developer.android.com/training/permissions/requesting.html
Thomas R.


Bạn đã xem các mẫu trên repo GitHub của Google chưa?
IgorGanapolsky

thấy từ developer.android.com/training/permissions/requesting.html, lúc đó tôi mới dùng Android và ngay sau đó Android Marshmallow đã đến và việc đào tạo của google khiến tôi bối rối hơn và không thể tìm thấy bất kỳ hướng dẫn nào về điều này
Nilabja

Tôi đã tạo thư viện cho nó. Nó rất dễ sử dụng bằng các bước đơn giản. github.com/Kishanjvaghela/Ask-Permission
Kishan Vaghela

Câu trả lời:


240

Mở Hộp thoại bằng mã bên dưới:

 ActivityCompat.requestPermissions(MainActivity.this,
                    new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                    1);

Nhận kết quả Hoạt động như sau:

@Override
public void onRequestPermissionsResult(int requestCode,
                                       String permissions[], int[] grantResults) {
    switch (requestCode) {
        case 1: {

          // 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.
                Toast.makeText(MainActivity.this, "Permission denied to read your External storage", Toast.LENGTH_SHORT).show();
            }
            return;
        }

        // other 'case' lines to check for other
        // permissions this app might request
    }
}

Thông tin thêm: https://developer.android.com/training/permissions/requesting.html


3
Tôi đã tạo thư viện cho nó. Nó rất dễ sử dụng bằng các bước đơn giản. github.com/Kishanjvaghela/Ask-Permission
Kishan Vaghela

cũng là phần này nếu người dùng nhấp vào hủy: other if (GrantResults.length> 0 && GrantResults [0] == PackageManager.PERMISSION_DENIED)
mehmet

đang ActivityCompat.requestPermissionsbị phản đối? (ở Nugat)
ThunderWires

bạn lấy biến đó ở đâu? Hoạt độngCompat?
gumuruh

@gumuruh, biến nào?
CoolMind

61

Cấu trúc này tôi đang sử dụng để kiểm tra xem ứng dụng của tôi có được phép hay không và yêu cầu nếu nó không có quyền. Vì vậy, trong mã chính của tôi từ nơi tôi muốn kiểm tra viết như sau:

int MyVersion = Build.VERSION.SDK_INT;
if (MyVersion > Build.VERSION_CODES.LOLLIPOP_MR1) {
                if (!checkIfAlreadyhavePermission()) {
                    requestForSpecificPermission();
                }
}

Mô-đun kiểm tra IfAlperedhavePermission () được triển khai như sau:

private boolean checkIfAlreadyhavePermission() {
    int result = ContextCompat.checkSelfPermission(this, Manifest.permission.GET_ACCOUNTS);
    if (result == PackageManager.PERMISSION_GRANTED) {
        return true;
    } else {
        return false;
    }
}

Mô-đun requestForSpecificPermission () được triển khai như sau:

private void requestForSpecificPermission() {
        ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.GET_ACCOUNTS, Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_SMS, Manifest.permission.READ_EXTERNAL_STORAGE, Manifest.permission.WRITE_EXTERNAL_STORAGE}, 101);
}

và ghi đè trong hoạt động:

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    switch (requestCode) {
        case 101:
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                //granted
            } else {
                //not granted
            }
            break;
        default:
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

Tham khảo liên kết này để biết thêm chi tiết: http://revisitingandroid.blogspot.in/2017/01/how-to-check-and-request-for-run-time.html


Gợi ý thân thiện: Thay thế câu lệnh if checkIfAlreadyhavePermissionthànhreturn result == PackageManager.PERMISSION_GRANTED;
Ellen Spertus

19

Tôi đã sử dụng trình bao bọc này (Được khuyến nghị) được viết bởi các nhà phát triển google. Nó siêu dễ sử dụng.

https://github.com/googlesamples/easypermissions

Chức năng xử lý kiểm tra và xin phép nếu được yêu cầu

public void locationAndContactsTask() {
    String[] perms = { Manifest.permission.ACCESS_FINE_LOCATION, Manifest.permission.READ_CONTACTS };
    if (EasyPermissions.hasPermissions(this, perms)) {
        // Have permissions, do the thing!
        Toast.makeText(this, "TODO: Location and Contacts things", Toast.LENGTH_LONG).show();
    } else {
        // Ask for both permissions
        EasyPermissions.requestPermissions(this, getString(R.string.rationale_location_contacts),
                RC_LOCATION_CONTACTS_PERM, perms);
    }
}

Chúc mừng mã hóa :)


1
@Farhan Tôi hiểu điều đó :) Tôi chỉ ước rằng API của Android sẽ dễ dàng hơn vì vậy chúng tôi sẽ không phải sử dụng trình bao bọc.
younes0

Tôi không thể thấy "RC_CAMERA_AND_LOCATION" đến từ đâu hoặc tìm các quyền khác thay vì các quyền đó, bạn có biết nó đến từ đâu không?
Fonix

17

Bắt đầu từ Android Marshmallow, chúng tôi cần yêu cầu người dùng cấp quyền cụ thể. Chúng tôi cũng có thể kiểm tra thông qua mã nếu sự cho phép đã được đưa ra. Dưới đây là danh sách các quyền thường cần:

  • ERIC_group.CALENDAR

    • ERIC.READ_CALENDAR
    • ERIC.WRITE_CALENDAR
  • ERIC_group.CAMERA

    • ERIC.CAMERA
  • ERIC_group.CONTACTS

    • ERIC.READ_CONTACTS
    • ERIC.WRITE_CONTACTS
    • ERIC.GET_ACCOUNTS
  • ERIC_group.LOCATION

    • ERIC.ACCESS_FINE_LOCATION
    • ERIC.ACCESS_COARSE_LOCATION
  • ERIC_group.MICROPHONE

    • ERIC.RECORD_AUDIO
  • ERIC_group.PHONE

    • ERIC.READ_PHONE_STATE
    • ERIC.CALL_PHONE
    • ERIC.READ_CALL_LOG
    • ERIC.WRITE_CALL_LOG
    • ERIC.ADD_VOICEMAIL
    • ERIC.USE_SIP
    • ERIC.PROCESS_OUTGOING_CALLS
  • ERIC_group.SENSORS

    • ERIC.BODY_SENSORS
  • ERIC_group.SMS

    • ERIC.SEND_SMS
    • ERIC.RECEIVE_SMS
    • ERIC.READ_SMS
    • ERIC.RECEIVE_WAP_PUSH
    • ERIC.RECEIVE_MMS
    • ERIC.READ_CELL_BROADCASTS
  • ERIC_group.STORAGE

    • ERIC.READ_EXTERNAL_STORAGE
    • ERIC.WRITE_EXTERNAL_STORAGE

Đây là mã mẫu để kiểm tra quyền:

if (ContextCompat.checkSelfPermission(context, Manifest.permission.WRITE_CALENDAR) != PackageManager.PERMISSION_GRANTED) {
    if (ActivityCompat.shouldShowRequestPermissionRationale((Activity) context, Manifest.permission.WRITE_CALENDAR)) {
        AlertDialog.Builder alertBuilder = new AlertDialog.Builder(context);
        alertBuilder.setCancelable(true);
        alertBuilder.setMessage("Write calendar permission is necessary to write event!!!");
        alertBuilder.setPositiveButton(android.R.string.yes, new DialogInterface.OnClickListener() {
            @TargetApi(Build.VERSION_CODES.JELLY_BEAN)
            public void onClick(DialogInterface dialog, int which) {
                ActivityCompat.requestPermissions((Activity)context, new String[]{Manifest.permission.WRITE_CALENDAR}, MY_PERMISSIONS_REQUEST_WRITE_CALENDAR);
            }
        });
    } else {
        ActivityCompat.requestPermissions((Activity)context, new String[]{Manifest.permission.WRITE_CALENDAR}, MY_PERMISSIONS_REQUEST_WRITE_CALENDAR);
    }
}

14

Lớp của tôi cho quyền yêu cầu thời gian chạy trong ActivityhoặcFragment

Nó cũng giúp bạn hiển thị lý do hoặc mở Cài đặt để bật quyền sau khi người dùng từ chối Never ask againtùy chọn quyền (có / không ) dễ dàng hơn

class RequestPermissionHandler(private val activity: Activity? = null,
                               private val fragment: Fragment? = null,
                               private val permissions: Set<String> = hashSetOf(),
                               private val listener: Listener? = null
) {
    private var hadShowRationale: Boolean = false

    fun requestPermission() {
        hadShowRationale = showRationaleIfNeed()
        if (!hadShowRationale) {
            doRequestPermission(permissions)
        }
    }

    fun retryRequestDeniedPermission() {
        doRequestPermission(permissions)
    }

    private fun showRationaleIfNeed(): Boolean {
        val unGrantedPermissions = getPermission(permissions, Status.UN_GRANTED)
        val permanentDeniedPermissions = getPermission(unGrantedPermissions, Status.PERMANENT_DENIED)
        if (permanentDeniedPermissions.isNotEmpty()) {
            val consume = listener?.onShowSettingRationale(unGrantedPermissions)
            if (consume != null && consume) {
                return true
            }
        }

        val temporaryDeniedPermissions = getPermission(unGrantedPermissions, Status.TEMPORARY_DENIED)
        if (temporaryDeniedPermissions.isNotEmpty()) {
            val consume = listener?.onShowPermissionRationale(temporaryDeniedPermissions)
            if (consume != null && consume) {
                return true
            }
        }
        return false
    }

    fun requestPermissionInSetting() {
        val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
        val packageName = activity?.packageName ?: run {
            fragment?.requireActivity()?.packageName
        }
        val uri = Uri.fromParts("package", packageName, null)
        intent.data = uri
        activity?.apply {
            startActivityForResult(intent, REQUEST_CODE)
        } ?: run {
            fragment?.startActivityForResult(intent, REQUEST_CODE)
        }
    }

    fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>,
                                   grantResults: IntArray) {
        if (requestCode == REQUEST_CODE) {
            for (i in grantResults.indices) {
                if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    markNeverAskAgainPermission(permissions[i], false)
                } else if (!shouldShowRequestPermissionRationale(permissions[i])) {
                    markNeverAskAgainPermission(permissions[i], true)
                }
            }
            var hasShowRationale = false
            if (!hadShowRationale) {
                hasShowRationale = showRationaleIfNeed()
            }
            if (hadShowRationale || !hasShowRationale) {
                notifyComplete()
            }
        }
    }

    fun onActivityResult(requestCode: Int) {
        if (requestCode == REQUEST_CODE) {
            getPermission(permissions, Status.GRANTED).forEach {
                markNeverAskAgainPermission(it, false)
            }
            notifyComplete()
        }
    }

    fun cancel() {
        notifyComplete()
    }

    private fun doRequestPermission(permissions: Set<String>) {
        activity?.let {
            ActivityCompat.requestPermissions(it, permissions.toTypedArray(), REQUEST_CODE)
        } ?: run {
            fragment?.requestPermissions(permissions.toTypedArray(), REQUEST_CODE)
        }
    }

    private fun getPermission(permissions: Set<String>, status: Status): Set<String> {
        val targetPermissions = HashSet<String>()
        for (p in permissions) {
            when (status) {
                Status.GRANTED -> {
                    if (isPermissionGranted(p)) {
                        targetPermissions.add(p)
                    }
                }
                Status.TEMPORARY_DENIED -> {
                    if (shouldShowRequestPermissionRationale(p)) {
                        targetPermissions.add(p)
                    }
                }
                Status.PERMANENT_DENIED -> {
                    if (isNeverAskAgainPermission(p)) {
                        targetPermissions.add(p)
                    }
                }
                Status.UN_GRANTED -> {
                    if (!isPermissionGranted(p)) {
                        targetPermissions.add(p)
                    }
                }
            }
        }
        return targetPermissions
    }

    private fun isPermissionGranted(permission: String): Boolean {
        return activity?.let {
            ActivityCompat.checkSelfPermission(it, permission) == PackageManager.PERMISSION_GRANTED
        } ?: run {
            ActivityCompat.checkSelfPermission(fragment!!.requireActivity(), permission) == PackageManager.PERMISSION_GRANTED
        }
    }

    private fun shouldShowRequestPermissionRationale(permission: String): Boolean {
        return activity?.let {
            ActivityCompat.shouldShowRequestPermissionRationale(it, permission)
        } ?: run {
            ActivityCompat.shouldShowRequestPermissionRationale(fragment!!.requireActivity(), permission)
        }
    }

    private fun notifyComplete() {
        listener?.onComplete(getPermission(permissions, Status.GRANTED), getPermission(permissions, Status.UN_GRANTED))
    }

    private fun getPrefs(context: Context): SharedPreferences {
        return context.getSharedPreferences("SHARED_PREFS_RUNTIME_PERMISSION", Context.MODE_PRIVATE)
    }

    private fun isNeverAskAgainPermission(permission: String): Boolean {
        return getPrefs(requireContext()).getBoolean(permission, false)
    }

    private fun markNeverAskAgainPermission(permission: String, value: Boolean) {
        getPrefs(requireContext()).edit().putBoolean(permission, value).apply()
    }

    private fun requireContext(): Context {
        return fragment?.requireContext() ?: run {
            activity!!
        }
    }

    enum class Status {
        GRANTED, UN_GRANTED, TEMPORARY_DENIED, PERMANENT_DENIED
    }

    interface Listener {
        fun onComplete(grantedPermissions: Set<String>, deniedPermissions: Set<String>)
        fun onShowPermissionRationale(permissions: Set<String>): Boolean
        fun onShowSettingRationale(permissions: Set<String>): Boolean
    }

    companion object {
        const val REQUEST_CODE = 200
    }
}

Sử dụng Activitynhư

class MainActivity : AppCompatActivity() {
    private lateinit var smsAndStoragePermissionHandler: RequestPermissionHandler

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        smsAndStoragePermissionHandler = RequestPermissionHandler(this@MainActivity,
                permissions = setOf(Manifest.permission.RECEIVE_SMS, Manifest.permission.READ_EXTERNAL_STORAGE),
                listener = object : RequestPermissionHandler.Listener {
                    override fun onComplete(grantedPermissions: Set<String>, deniedPermissions: Set<String>) {
                        Toast.makeText(this@MainActivity, "complete", Toast.LENGTH_SHORT).show()
                        text_granted.text = "Granted: " + grantedPermissions.toString()
                        text_denied.text = "Denied: " + deniedPermissions.toString()
                    }

                    override fun onShowPermissionRationale(permissions: Set<String>): Boolean {
                        AlertDialog.Builder(this@MainActivity).setMessage("To able to Send Photo, we need SMS and" + " Storage permission")
                                .setPositiveButton("OK") { _, _ ->
                                    smsAndStoragePermissionHandler.retryRequestDeniedPermission()
                                }
                                .setNegativeButton("Cancel") { dialog, _ ->
                                    smsAndStoragePermissionHandler.cancel()
                                    dialog.dismiss()
                                }
                                .show()
                        return true // don't want to show any rationale, just return false here
                    }

                    override fun onShowSettingRationale(permissions: Set<String>): Boolean {
                        AlertDialog.Builder(this@MainActivity).setMessage("Go Settings -> Permission. " + "Make SMS on and Storage on")
                                .setPositiveButton("Settings") { _, _ ->
                                    smsAndStoragePermissionHandler.requestPermissionInSetting()
                                }
                                .setNegativeButton("Cancel") { dialog, _ ->
                                    smsAndStoragePermissionHandler.cancel()
                                    dialog.cancel()
                                }
                                .show()
                        return true
                    }
                })

        button_request.setOnClickListener { handleRequestPermission() }
    }

    private fun handleRequestPermission() {
        smsAndStoragePermissionHandler.requestPermission()
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>,
                                            grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        smsAndStoragePermissionHandler.onRequestPermissionsResult(requestCode, permissions,
                grantResults)
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        smsAndStoragePermissionHandler.onActivityResult(requestCode)
    }
}

Mã trên Github

Bản giới thiệu


3
giải pháp tốt nhất về xin phép mà tôi có thể tìm thấy
DolDurma

@Phan, bạn có đoạn mã yêu cầu cấp phép và xử lý không xử lý
binrebin

10

Android-M, tức là API 23 đã giới thiệu Quyền truy cập thời gian để giảm lỗi bảo mật trong thiết bị Android, nơi người dùng hiện có thể trực tiếp quản lý quyền ứng dụng tại runtime.so nếu người dùng từ chối một quyền cụ thể của ứng dụng của bạn, bạn phải có được nó bằng cách hỏi hộp thoại cấp phép mà bạn đã đề cập trong truy vấn của bạn.

Vì vậy, hãy kiểm tra trước khi hành động tức là kiểm tra xem bạn có quyền truy cập vào liên kết tài nguyên không và nếu ứng dụng của bạn không có quyền cụ thể đó, bạn có thể yêu cầu liên kết cấp phép và xử lý phản hồi yêu cầu quyền như bên dưới.

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

Vì vậy, cuối cùng, đó là một thực tiễn tốt để trải qua các thay đổi hành vi nếu bạn dự định làm việc với các phiên bản mới để tránh bị đóng cửa :)

Quyền Thực hành tốt nhất.

Bạn có thể đi qua các ứng dụng mẫu chính thức ở đây .


Xin lưu ý rằng chúng ta phải có noHistory = false để nhận được cuộc gọi lại. Cũng tham khảo điều này trong trường hợp nếu bạn không nhận được cuộc gọi lại. Tôi đã lãng phí hàng giờ để tìm ra nó.
Atul

6

Từ Android Marshmallow (API 23) trở lên theo mặc định, tất cả các quyền nguy hiểm (theo tài liệu chính thức của tài liệu chính thức ) bị vô hiệu hóa. Sau khi cài đặt khi ứng dụng mở lần đầu tiên thì bạn phải cấp quyền tại Run Time.

Tôi đã đạt được theo cách sau:

public class MarshMallowPermission {

    public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_GALLERY = 0;
    public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_CAMERA = 1;
    public static final int EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE = 2;
    public static final int CAMERA_PERMISSION_REQUEST_CODE = 3;
    public static final int LOCATION_PERMISSION_REQUEST_CODE = 4;
    Activity activity;
    Context mContext;

    public MarshMallowPermission(Activity activity) {
        this.activity = activity;
        this.mContext = activity;
    }

    public boolean checkPermissionForExternalStorage(){
        int result = ContextCompat.checkSelfPermission(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE);
        if (result == PackageManager.PERMISSION_GRANTED){
            return true;
        } else {
            return false;
        }
    }

    public boolean checkPermissionForCamera(){
        int result = ContextCompat.checkSelfPermission(activity, Manifest.permission.CAMERA);
        if (result == PackageManager.PERMISSION_GRANTED){
            return true;
        } else {
            return false;
        }
    }

    public boolean checkLocationPermission(){

        int result = ActivityCompat.checkSelfPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION);
        if (result == PackageManager.PERMISSION_GRANTED){
            return true;
        } else {
            return false;
        }
    }

    public void requestPermissionForExternalStorage(int requestCode){
        if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)){
            Toast.makeText(mContext.getApplicationContext(), "External Storage permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show();
        } else {
            ActivityCompat.requestPermissions(activity,new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE},requestCode);
        }
    }

    public void requestPermissionForCamera(){
        if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.CAMERA)){
            Toast.makeText(mContext.getApplicationContext(), "Camera permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show();
        } else {
            ActivityCompat.requestPermissions(activity,new String[]{Manifest.permission.CAMERA},CAMERA_PERMISSION_REQUEST_CODE);
        }
    }
    public void requestPermissionForLocation(){
        if (ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_FINE_LOCATION) && ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.ACCESS_COARSE_LOCATION)){
            Toast.makeText(mContext.getApplicationContext(), "Location permission needed. Please allow in App Settings for additional functionality.", Toast.LENGTH_LONG).show();
        } else {
            ActivityCompat.requestPermissions(activity, new String[]{Manifest.permission.ACCESS_FINE_LOCATION,Manifest.permission.ACCESS_COARSE_LOCATION}, LOCATION_PERMISSION_REQUEST_CODE);
        }
    }
}

Trong lớp hoạt động của bạn:

 public class MainActivity extends AppCompatActivity{

   private MarshMallowPermission marshMallowPermission;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.d("NavHome", "Oncreate_nav");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        marshMallowPermission = new MarshMallowPermission(MainActivity.this);



        if (!marshMallowPermission.checkPermissionForExternalStorage()) {
            marshMallowPermission.requestPermissionForExternalStorage(MarshMallowPermission.EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);

        switch (requestCode) {
            case MarshMallowPermission.EXTERNAL_STORAGE_PERMISSION_REQUEST_CODE_BY_LOAD_PROFILE:
                if (grantResults.length > 0
                        && grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                    //permission granted successfully

                } else {

                 //permission denied

                }
                break;
    }
    }

}

5

Thêm quyền vào AndroidManifest.xml

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

Để kiểm tra phiên bản Android nếu nó cần sự cho phép thời gian chạy hay không.

if (Build.VERSION.SDK_INT > Build.VERSION_CODES.LOLLIPOP_MR1) {
    askForPermission(Manifest.permission.WRITE_EXTERNAL_STORAGE, 1);
}

Yêu cầu người dùng cấp phép nếu không được cấp.

private void askForPermission(String permission, int requestCode) {
    if (ContextCompat.checkSelfPermission(c, permission)
            != PackageManager.PERMISSION_GRANTED) {
        if (ActivityCompat.shouldShowRequestPermissionRationale(MainActivity.this, permission)) {
            Toast.makeText(c, "Please grant the requested permission to get your task done!", Toast.LENGTH_LONG).show();
            ActivityCompat.requestPermissions(MainActivity.this, new String[]{permission}, requestCode);
        } else {
            ActivityCompat.requestPermissions(MainActivity.this, new String[]{permission}, requestCode);
        }
    }
}

Làm một cái gì đó nếu sự cho phép đã được cấp hay không.

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    switch (requestCode) {
        case 1:
            if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                //permission with request code 1 granted
                Toast.makeText(this, "Permission Granted" , Toast.LENGTH_LONG).show();
            } else {
                //permission with request code 1 was not granted
                Toast.makeText(this, "Permission was not Granted" , Toast.LENGTH_LONG).show();
            }
            break;
        default:
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
}

4

Tôi đang sử dụng nó như là một lớp Fragment cơ sở. Tôi chỉ yêu cầu quyền từ một đoạn, nhưng bạn có thể cấu trúc lại nó và tạo một phiên bản Activity tương tự.

public class BaseFragment extends Fragment {

    private static final int PERMISSION_REQUEST_BLOCK_INTERNAL = 555;
    private static final String PERMISSION_SHARED_PREFERENCES = "permissions";

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        if (requestCode == PERMISSION_REQUEST_BLOCK_INTERNAL) {
            boolean allPermissionsGranted = true;

            for (int iGranting : grantResults) {
                if (iGranting != PermissionChecker.PERMISSION_GRANTED) {
                    allPermissionsGranted = false;
                    break;
                }
            }

            if (allPermissionsGranted && permissionBlock != null) {
                permissionBlock.run();
            }

            permissionBlock = null;
        }
    }

    public void runNowOrAskForPermissionsFirst(String permission, Runnable block) {
        if (hasPermission(permission)) {
            block.run();
        } else if (!hasPermissionOrWillAsk(permission)) {
            permissionBlock = block;
            askForPermission(permission, PERMISSION_REQUEST_BLOCK_INTERNAL);
        }
    }

    public boolean hasPermissionOrWillAsk(String permission) {
        boolean hasPermission = hasPermission(permission);
        boolean hasAsked = hasPreviouslyAskedForPermission(permission);
        boolean shouldExplain = shouldShowRequestPermissionRationale(permission);

        return hasPermission || (hasAsked && !shouldExplain);
    }

    private boolean hasPermission(String permission) {
        return (ContextCompat.checkSelfPermission(getContext(), permission) == PackageManager.PERMISSION_GRANTED);
    }

    private boolean hasPreviouslyAskedForPermission(String permission) {
        SharedPreferences prefs = getContext().getSharedPreferences(PERMISSION_SHARED_PREFERENCES, Context.MODE_PRIVATE);
        return prefs.getBoolean(permission, false);
    }

    private void askForPermission(String permission, int requestCode) {
        SharedPreferences.Editor editor = getContext().getSharedPreferences(PERMISSION_SHARED_PREFERENCES, Context.MODE_PRIVATE).edit();

        editor.putBoolean(permission, true);
        editor.apply();

        requestPermissions(new String[] { permission }, requestCode);
    }
}

Có hai phương pháp chính bạn nên sử dụng:

  • hasPermissionOrWillAsk - Sử dụng điều này để xem nếu một quyền đã được yêu cầu và từ chối bởi người dùng không muốn được hỏi lại. Điều này hữu ích để vô hiệu hóa UI khi người dùng đã đưa ra câu trả lời cuối cùng về việc KHÔNG muốn có một tính năng.

  • runNowOrAskForPermissionsFirst - Sử dụng mã này để chạy một số mã yêu cầu quyền. Nếu người dùng đã được cấp quyền, mã sẽ chạy ngay lập tức. Nếu không, mã sẽ chạy sau nếu người dùng cấp quyền. Hoặc không phải ở tất cả. Thật tuyệt vì bạn chỉ định mã ở một nơi.

Đây là một ví dụ:

mFragment.runNowOrAskForPermissionsFirst(Manifest.permission.ACCESS_FINE_LOCATION, new Runnable() {
    @Override
    public void run() {
        ...do something if we have permission...
    }
});

Rất vui khi nhận được phản hồi về điều này. Không phải là ví dụ cụ thể này được đơn giản hóa một chút ở chỗ bạn cũng cần kiểm tra xem liệu Dịch vụ vị trí có được bật trên thiết bị hay không. (Điều đó khác với quyền.) Ngoài ra, nó chỉ hỗ trợ một quyền mỗi lần, nhưng sẽ đơn giản để sửa đổi nếu bạn cần nó để hỗ trợ nhiều hơn một lần.


4

Nó có thể là một cách sạch hơn. Thêm tất cả các quyền của bạn trong một mảng như

private static final String[] INITIAL_PERMS={
            android.Manifest.permission.ACCESS_FINE_LOCATION,
            android.Manifest.permission.ACCESS_COARSE_LOCATION
    };
    private static final int INITIAL_REQUEST=1337;

Dù hoán vị của bạn là phương pháp tạo cho mỗi hoán vị

@RequiresApi(api = Build.VERSION_CODES.M)
private boolean canAccessFineLocation() {
    return(hasPermission(Manifest.permission.ACCESS_FINE_LOCATION));
}

@RequiresApi(api = Build.VERSION_CODES.M)
private boolean canAccessCoarseLocation() {
    return(hasPermission(Manifest.permission.ACCESS_COARSE_LOCATION));
}

@RequiresApi(api = Build.VERSION_CODES.M)
private boolean hasPermission(String perm) {
    return(PackageManager.PERMISSION_GRANTED == checkSelfPermission(perm));
}

Gọi phương thức này trong onCreate

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

Bây giờ ghi đè onRequestPermissionsResult

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

    if(requestCode == INITIAL_REQUEST){
        if (canAccessFineLocation() && canAccessCoarseLocation())  {
            //call your method
        }
        else {
            //show Toast or alert that this permissions is neccessary
        }
    }
}

1
không có yêu cầuApi và tôi gặp lỗi trong hoạt động của mình, tôi sử dụng chú thích
TragetApi

@Jawad, điều này hoạt động nhưng tốt hơn nếu bạn thêm một số cuộc gọi lại cho phép bị từ chối
binrebin

3

Đối với nhiều quyền tại một thời điểm bạn có thể sử dụng này. Công việc này cho tôi .. Tôi có một giải pháp khác. nếu bạn cung cấp cho TargetSdkVersion của mình dưới 22 thì nó hoạt động với tôi. và nó hoạt động giống như nhận được sự cho phép từ tệp kê khai. Đã thử nghiệm và làm việc cho tôi.

final private int REQUEST_CODE_ASK_MULTIPLE_PERMISSIONS = 124;

    private void insertDummyContactWrapper() {
        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;
    }






@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
                    insertDummyContact();
                } else {
                    // Permission Denied
                    Toast.makeText(MainActivity.this, "Some Permission is Denied", Toast.LENGTH_SHORT)
                            .show();
                }
                }
                break;
            default:
                super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        }
    }

Để biết thêm chi tiết. Kiểm tra liên kết dưới đây

https://inthecheesefactory.com/blog/things-you-need-to-ledge-about-android-m- allow-developer-edition / en


cài đặt targetSdkVersion dưới 22 sẽ hoạt động, nhưng điều gì sẽ xảy ra ở người dùng sử dụng Android M từ chối một quyền từ cài đặt?
Nilabja

Vâng, bạn đúng cho lần này các ứng dụng sẽ bị sập. Vì vậy, thời gian đó bạn cần kiểm tra lại quyền từ chối hay không từ người dùng .. tôi không kiểm tra nhưng tôi ước nó sẽ hoạt động. hình thành mọi hành động từ người dùng sẽ tốt hơn nếu kiểm tra sự cho phép có được cấp hay không.
Tariqul

3

Để xử lý sự cho phép thời gian chạy, google đã cung cấp một dự án thư viện. Bạn có thể kiểm tra điều này từ đây https://github.com/googlesamples/easypermissions

EasyPermissions được cài đặt bằng cách thêm phụ thuộc sau vào tệp build.gradle của bạn:

dependencies {
compile 'pub.devrel:easypermissions:0.3.0'
}

Để bắt đầu sử dụng EasyPermissions, hãy để Activity (hoặc Fragment) của bạn ghi đè phương thức onRequestPermissionsResult:

public class MainActivity extends AppCompatActivity implements EasyPermissions.PermissionCallbacks {

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

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);

    // Forward results to EasyPermissions
    EasyPermissions.onRequestPermissionsResult(requestCode, permissions, grantResults, this);
}

@Override
public void onPermissionsGranted(int requestCode, List<String> list) {
    // Some permissions have been granted
    // ...
}

@Override
public void onPermissionsDenied(int requestCode, List<String> list) {
    // Some permissions have been denied
    // ...
}
}

Tại đây bạn sẽ có được một ví dụ hoạt động về cách thư viện này hoạt động https://github.com/milon87/PalPermission


2

Có một thư viện tốt có thể được sử dụng trong trường hợp cần phải xin phép khi cần dịch vụ nền. Mặc dù hạn chế của thư viện là nó không thể được sử dụng để chỉ xác định liệu các quyền hiện có được cấp cho ứng dụng hay không. Nó luôn hỏi người dùng nếu ứng dụng chưa có chúng.

Đừng thử vì nó làm cho cuộc sống đơn giản hơn: Quyền của Android


2

Mã này dưới đây hoạt động hoàn hảo. Tôi đang giải thích với sự giúp đỡ của một ví dụ.

Trong trường hợp của tôi, tôi đã đặt các kiểm tra quyền một cách riêng biệt trong một lớp sử dụng và đã thông qua các quyền cụ thể mà tôi cần kiểm tra từ các lớp thích hợp. Điều này được kích hoạt để sử dụng lại tệp kiểm tra quyền sử dụng trong toàn bộ ứng dụng.

Phần mã dưới đây cho thấy chức năng gọi. Trong trường hợp này đang xin android.Manifest.permission.READ_EXTERNAL_STORAGEphép.

//the below call is from a fragment
     @OnClick(R.id.button)//butterknife implementation
        public void attachPressed() {
            if (PermissionUtils.hasThisPermission(getContext(), android.Manifest.permission.READ_EXTERNAL_STORAGE)) {
                onAttachPressed();
            } else {
                PermissionUtils.isPermissionRequestNeeded(getActivity(), this, android.Manifest.permission.READ_EXTERNAL_STORAGE, PermissionUtils.REQUEST_GROUP_STORAGE);
            }
        }   

Trong trường hợp trên, quyền được kiểm tra nếu nó được cho phép onAttachPressed();chức năng được gọi khác, chúng tôi kiểm tra quyền yêu cầu.

Dưới đây là mã có trong lớp tiện dụng trong trường hợp của tôi PermissionUtils

public final class PermissionUtils {

    public static final int REQUEST_GROUP_STORAGE = 1508;

    private PermissionUtils() {
    }

    public static boolean hasThisPermission(Context context, String permission) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
            return ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED;
        } else {
            return true;
        }
    }

    public static boolean isPermissionRequestNeeded(Activity activity, Fragment fragment, String permission, int requestCode) {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && !hasThisPermission(activity, permission)) {
            final String[] permissions = new String[]{permission};
            if (fragment == null) {
                activity.requestPermissions(permissions, requestCode);
            } else {
                fragment.requestPermissions(permissions, requestCode);
            }
            return true;
        }
        return false;
    }
}

Và sau khi yêu cầu nếu bạn có thể muốn gọi chức năng từ onRequestPermissionsResultnếu không, bạn sẽ cần phải nhấn nút một lần nữa cho cuộc gọi chức năng.

Vì vậy, chỉ cần gọi nó từ onRequestPermissionsResult

//the below call  is from a fragment
     @Override
        public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
            if (requestCode == PermissionUtils.REQUEST_GROUP_STORAGE && grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                onAttachPressed();
            } else {
                Log.e("value", "Permission Denied, You cannot use local drive .");
            }
        }

2

Tôi sử dụng thư viện thư viện RxPermission để xin phép. Bởi vì đó là mã dài mà chúng ta phải viết để xin phép.

RxPermissions rxPermissions = new RxPermissions(this); // where this is an Activity instance // Must be done during an initialization phase like onCreate
rxPermissions
    .request(Manifest.permission.CAMERA)
    .subscribe(granted -> {
        if (granted) { // Always true pre-M
           // I can control the camera now
        } else {
           // Oups permission denied
        }
    });

Thêm những phụ thuộc này vào build.gradle

allprojects {
    repositories {
        ...
        maven { url 'https://jitpack.io' }
    }
}

dependencies {
    implementation 'com.github.tbruyelle:rxpermissions:0.10.1'
    implementation 'com.jakewharton.rxbinding2:rxbinding:2.1.1'
}

1

Thử cái này

Đây là cách đơn giản nhất để xin phép trong phiên bản Marshmallow.

 if (ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.CAMERA) == PackageManager.PERMISSION_GRANTED&&ContextCompat.checkSelfPermission(getApplicationContext(), Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED)
    {
        //TO do here if permission is granted by user
    }
    else
    {
        //ask for permission if user didnot given
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
        {
            requestPermissions(new String[]{Manifest.permission.CAMERA,Manifest.permission.ACCESS_FINE_LOCATION}, 0);
        }
    }

Lưu ý: - Đừng quên thêm quyền này trong tệp kê khai

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

phương pháp thứ hai để kiểm tra sự cho phép có được cấp hay không?

ActivityCompat.requestPermissions(MainActivity.this, new String[]{Manifest.permission.READ_EXTERNAL_STORAGE,Manifest.permission.CAMERA}, 1);

Và ghi đè phương thức

@Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case 1: {
            if (grantResults.length > 0 && grantResults[1] == PackageManager.PERMISSION_GRANTED) {
         //                    grantResult[0] means it will check for the first postion permission which is READ_EXTERNAL_STORAGE
        //                    grantResult[1] means it will check for the Second postion permission which is CAMERA
                Toast.makeText(this, "Permission Granted", Toast.LENGTH_SHORT).show();
            }
            else
                Toast.makeText(this, "Permission not Granted", Toast.LENGTH_SHORT).show();
            return;
        }
    }
}

Vì vậy, bạn đang nói rằng nếu tôi nhắm mục tiêu Marshmallow trở lên thì tôi không cần phải khai báo quyền? Tôi biết chúng tôi phải đặt nó bất kể phiên bản Android chúng tôi đang nhắm mục tiêu. Vui lòng sửa cho tôi nếu tôi sai @Sunil
Nilabja

@Nilabja tuyên bố cấp phép trong tệp kê khai là bắt buộc đối với tất cả các phiên bản Android thời tiết có phải là marshmallow hay không
Sunil

1

Cách đơn giản để xin phép bằng cách tránh viết nhiều mã,

https://github.com/sachinvarma/ EasyPermission

Làm thế nào để thêm :

repositories {
        maven { url "https://jitpack.io" }
    }

implementation 'com.github.sachinvarma:EasyPermission:1.0.1'

Cách xin phép:

 List<String> permission = new ArrayList<>();
 permission.add(EasyPermissionList.READ_EXTERNAL_STORAGE);
 permission.add(EasyPermissionList.ACCESS_FINE_LOCATION);

 new EasyPermissionInit(MainActivity.this, permission);

Hy vọng nó sẽ hữu ích cho một ai đó.


1

Tôi đã xem qua tất cả các câu trả lời, nhưng không thỏa mãn câu trả lời chính xác cần thiết của mình, vì vậy đây là một ví dụ mà tôi đã viết và hoạt động hoàn hảo, thậm chí người dùng nhấp vào hộp kiểm Đừng hỏi lại .

  1. Tạo một phương thức sẽ được gọi khi bạn muốn xin phép thời gian chạy như thế nào readContacts()hoặc bạn cũng có thể có openCamera()như dưới đây:

    private void readContacts() {
        if (!askContactsPermission()) {
            return;
        } else {
            queryContacts();
        } }

Bây giờ chúng tôi cần phải thực hiện askContactsPermission(), bạn cũng có thể đặt tên nó là askCameraPermission()hoặc bất kỳ sự cho phép nào bạn sẽ yêu cầu.

    private boolean askContactsPermission() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
        return true;
    }
    if (checkSelfPermission(READ_CONTACTS) == PackageManager.PERMISSION_GRANTED) {
        return true;
    }
    if (shouldShowRequestPermissionRationale(READ_CONTACTS)) {
        Snackbar.make(parentLayout, R.string.permission_rationale, Snackbar.LENGTH_INDEFINITE)
                .setAction(android.R.string.ok, new View.OnClickListener() {
                    @Override
                    @TargetApi(Build.VERSION_CODES.M)
                    public void onClick(View v) {
                        requestPermissions(new String[]{READ_CONTACTS}, REQUEST_READ_CONTACTS);
                    }
                }).show();
    } else if (contactPermissionNotGiven) {
        openPermissionSettingDialog();
    } else {
        requestPermissions(new String[]{READ_CONTACTS}, REQUEST_READ_CONTACTS);
        contactPermissionNotGiven = true;

    }
    return false;
}

Trước khi viết hàm này, đảm bảo bạn đã xác định biến thể hiện bên dưới như được hiển thị:

    private View parentLayout;
    private boolean contactPermissionNotGiven;;


/**
 * Id to identity READ_CONTACTS permission request.
 */
private static final int REQUEST_READ_CONTACTS = 0;

Bây giờ bước cuối cùng để ghi đè onRequestPermissionsResultphương thức như dưới đây:

/**
 * Callback received when a permissions request has been completed.
 */
@RequiresApi(api = Build.VERSION_CODES.M)
@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
                                       @NonNull int[] grantResults) {
    if (requestCode == REQUEST_READ_CONTACTS) {
        if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            queryContacts();
        }
    }
}

Ở đây chúng ta đã thực hiện với các quyền RunTime, addon openPermissionSettingDialog()chỉ đơn giản là mở màn hình Cài đặt nếu người dùng đã vô hiệu hóa vĩnh viễn quyền bằng cách nhấp vào Đừng hỏi lại hộp kiểm. dưới đây là phương pháp:

    private void openPermissionSettingDialog() {
    String message = getString(R.string.message_permission_disabled);
    AlertDialog alertDialog =
            new AlertDialog.Builder(MainActivity.this, AlertDialog.THEME_DEVICE_DEFAULT_LIGHT)
                    .setMessage(message)
                    .setPositiveButton(getString(android.R.string.ok),
                            new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                    Intent intent = new Intent();
                                    intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                                    Uri uri = Uri.fromParts("package", getPackageName(), null);
                                    intent.setData(uri);
                                    startActivity(intent);
                                    dialog.cancel();
                                }
                            }).show();
    alertDialog.setCanceledOnTouchOutside(true);
}

Những gì chúng ta đã bỏ lỡ? 1. Xác định các chuỗi được sử dụng trongstrings.xml

<string name="permission_rationale">"Contacts permissions are needed to display Contacts."</string>
    <string name="message_permission_disabled">You have disabled the permissions permanently,
        To enable the permissions please go to Settings -> Permissions and enable the required Permissions,
        pressing OK you will be navigated to Settings screen</string>

  1. Khởi tạo phương thức parentLayoutbên trongonCreate

    ParentLayout = findViewById (R.id.content);

  2. Xác định sự cho phép cần thiết trong AndroidManifest.xml

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

  1. Các queryContactsphương pháp, dựa trên nhu cầu của bạn hoặc sự cho phép thời gian chạy bạn có thể gọi phương pháp của bạn trước đó permissionlà cần thiết. trong trường hợp của tôi, tôi chỉ cần sử dụng trình tải để lấy liên hệ như hình dưới đây:

    private void queryContacts() {
    getLoaderManager().initLoader(0, null, this);}

Điều này làm việc mã hóa hạnh phúc tuyệt vời :)


1

Nếu bạn đang sử dụng AndroidX Activity 1.2.0 hoặc AndroidX Fragment 1.3.0 :

Có các API kết quả hoạt động mới mà bạn có thể sử dụng để yêu cầu quyền:

val launcher = registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
    if (isGranted) {
        // Permission granted. Do the tasks.
    }
}
launcher.launch(Manifest.permission.ACCESS_FINE_LOCATION)

0
  if (CommonMethod.isNetworkAvailable(MainActivity.this)) {
                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                        int permissionCheck = ContextCompat.checkSelfPermission(MainActivity.this,
                                android.Manifest.permission.CAMERA);
                        if (permissionCheck == PackageManager.PERMISSION_GRANTED) {
                            //showing dialog to select image
                            callFacebook();
                            Log.e("permission", "granted MarshMallow");
                        } else {
                            ActivityCompat.requestPermissions(MainActivity.this,
                                    new String[]{android.Manifest.permission.READ_EXTERNAL_STORAGE,
                                            android.Manifest.permission.WRITE_EXTERNAL_STORAGE, android.Manifest.permission.CAMERA}, 1);
                        }
                    } else {
                        Log.e("permission", "Not Required Less than MarshMallow Version");
                        callFacebook();
                    }
                } else {
                    CommonMethod.showAlert("Internet Connectivity Failure", MainActivity.this);
                }

0

Bạn có thể sử dụng thư viện của tôi - NoPermission (Đây chỉ là một lớp)

compile 'ru.alexbykov:nopermission:1.1.1'

Mẫu vật

PermissionHelper permissionHelper = new PermissionHelper(this); //don't use getActivity in fragment!

permissionHelper.check(Manifest.permission.READ_CONTACTS)
                .onSuccess(this::onSuccess)
                .onDenied(this::onDenied)
                .onNeverAskAgain(this::onNeverAskAgain)
                .run();

onRequestPermissionResult:

 @Override
  public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults)
        permissionHelper.onRequestPermissionsResult(requestCode, permissions, grantResults);
   }

Tôi nghĩ api thuận tiện hơn EasyPermissionsGoogle.


0

Thời gian cho phép bất kỳ nơi nào trong ứng dụng Dưới đây là ví dụ

use dependency
maven { url 'https://jitpack.io' }
dependencies {
implementation 'com.github.irshadsparky:PermissionLib:master-SNAPSHOT'
}

và gọi mã như thế này:

PermissionHelper.requestCamera(new PermissionHelper.OnPermissionGrantedListener() {
@Override
public void onPermissionGranted() {

}
});

bạn có thể tìm thêm Github


0

Chạy thời gian cho phép tạo ra rất nhiều mã soạn sẵn trong hoạt động được kết hợp chặt chẽ. Để giảm mã và làm cho mọi thứ dễ dàng, bạn có thể sử dụng thư viện Dexter .


0

GIẤY PHÉP CHẠY VÀO ANDROID

public void onClick(View view) {
    if (view.getId() == shareButton.getId()) {
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.WRITE_EXTERNAL_STORAGE) == PackageManager.PERMISSION_GRANTED) {
            this.shareLog();
        } else {
            ActivityCompat.requestPermissions(this, new String[] { Manifest.permission.WRITE_EXTERNAL_STORAGE }, LogConstants.PERMISSION_REQ_WRITE_EXTERNAL_STORAGE);
        }
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    if (requestCode == LogConstants.PERMISSION_REQ_WRITE_EXTERNAL_STORAGE) {
        if (grantResults.length > 0 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            this.shareLog();
        }
    }
}

Phương pháp OnClick là kiểm tra quyền chạy

và nếu Quyền bị hạn chế thì nó yêu cầu sự cho phép

Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookieChính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.