Izin Android M: onRequestPermissionsResult () tidak dipanggil

Saya memperbarui aplikasi kami untuk menggunakan sistem izin runtime M baru. Semuanya berfungsi kecuali untuk onRequestPermissionsResult (). Saya perlu memeriksa izin pada tombol tekan, dan jika itu berhasil, kirim pesan teks. Ketika saya memberikan izin untuk melakukannya, dialog ditutup, tetapi tidak memicu Kirim Teks sampai saya menekan tombol lagi.

Saya telah men-debug dan menetapkan breakpoints dalam metode onRequestPermissionsResult () tetapi tidak pernah masuk ke dalamnya.

Metode ini dipanggil pertama:

    private void askForPermission() {
    String[] permissions = new String[]{Manifest.permission.SEND_SMS};
    ActivityCompat.requestPermissions(getActivity(), permissions, PERMISSIONS_CODE);
}

Dan kemudian panggilan balik saya terlihat seperti ini:

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

    if (requestCode == PERMISSIONS_CODE) {
        for (int i = 0; i < permissions.length; i++) {
            String permission = permissions[i];
            int grantResult = grantResults[i];

            if (permission.equals(Manifest.permission.SEND_SMS)) {
                if (grantResult == PackageManager.PERMISSION_GRANTED) {
                    onPPSButtonPress();
                } else {
                    requestPermissions(new String[]{Manifest.permission.SEND_SMS}, PERMISSIONS_CODE);
                }
            }
        }
    }
}

Adakah yang mengalami masalah serupa? Hargai bantuan apa pun dengan ini. Terima kasih

Saya mengalami masalah yang sama dan saya baru saja menemukan solusinya. Saat menggunakan perpustakaan Dukungan, Anda harus menggunakan metode panggilan yang benar. Sebagai contoh:

• Saat di AppCompatActivity , Anda harus menggunakan ActivityCompat.requestPermissions ;
• Ketika di android.support.v4.app.Fragment , Anda harus menggunakan cukup requestPermissions (ini adalah metode instance dari android.support.v4.app.Fragment)

Jika Anda memanggil ActivityCompat.requestPermissions dalam sebuah fragmen, callback onRequestPermissionsResult dipanggil pada aktivitas dan bukan fragmen.

Semoga ini membantu!

Anda dapat mencoba ini:

requestPermissions(permissions, PERMISSIONS_CODE);

Jika Anda memanggil kode ini dari sebuah fragmen, ia memiliki metode requestPermissions sendiri. Saya percaya masalahnya adalah Anda memanggil metode statis.

Kiat Pro jika Anda menginginkan bagian onRequestPermissionsResult()dalam: FragmentCompat.requestPermissions(Fragment fragment, String[] permissions, int requestCode)

Saya harap ini berfungsi dengan baik

Untuk Aktivitas:

 ActivityCompat.requestPermissions(this,permissionsList,REQUEST_CODE);

Untuk Fragmen:

 requestPermissions(permissionsList,REQUEST_CODE);

Saya juga mengalami masalah ini. Jika Anda ingin aktivitas yang menangani izin tidak ada dalam sejarah / akhir-akhir ini, maka Anda akan tergoda untuk mengubah AndroidManifest.xmlentri Anda .

Jika Anda mengatur aktivitas yang Anda panggil requestPermissionsatau AppCompatActivity.requestPermissionsdengan

android:noHistory="true"
android:excludeFromRecents="true"

di AndroidManifest.xmlkemudian Anda onRequestPermissionsResult()tidak akan dipanggil. Ini benar jika Aktivitas Anda berasal dari Activityatau AppCompatActivity.

Ini dapat diperbaiki dengan menghapus kedua flag dari 'AndroidManifest.xml' dan menyelesaikan aktivitas Anda finishAndRemoveTask()sebagai gantinya.

Jika Anda memiliki onRequestPermissionsResultaktivitas dan fragmen, pastikan untuk memanggil super.onRequestPermissionsResultaktivitas. Tidak diperlukan dalam fragmen, tetapi dalam aktivitas.

Jawaban sudah usang silakan merujuk ke: https://developer.android.com/training/permissions/requesting

Di dalam fragmen, Anda perlu menelepon:

FragmentCompat.requestPermissions(permissionsList, RequestCode)

Tidak:

ActivityCompat.requestPermissions(Activity, permissionsList, RequestCode);

Jika Anda menggunakan requestPermissions dalam fragmen, ia menerima 2 parameter alih-alih 3.

Kamu harus menggunakan requestPermissions(permissions, PERMISSIONS_CODE);

Jika karena alasan tertentu Anda telah memperpanjang Aktivitas kustom yang terletak di beberapa pustaka eksternal yang tidak memanggil super, Anda perlu memanggil super Fragmen secara manual. Hubungi kembali permintaan Anda di aktivitas Anda diRequestPermissionsResult.

YourActivity extends SomeActivityNotCallingSuperOnRequestPermissionsResult{
Fragment requestingFragment;//the fragment requesting the permission
...
@Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if(requestingFragment!=null)
            requestingFragment.onRequestPermissionsResult(requestCode, permissions, grantResults);
    }
...

Anda memiliki fungsi checkPermissions untuk perangkat Marshmallow pra di FragmentCompat . Saya menggunakan seperti ini:

FragmentCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_FINE_LOCATION},
                    MY_PERMISSIONS_REQUEST_ACCESS_FINE_LOCATION);

Saya telah menemukan bahwa itu penting di mana Anda menelepon android.support.v4.app.Fragment.requestPermissions.

Jika Anda melakukannya onCreate(),onRequestPermissionsResult() tidak pernah dipanggil.

Solusi: Sebut saja onActivityCreated();

@Override
public void onActivityCreated(Bundle savedInstanceState) {

    super.onActivityCreated(savedInstanceState);

    if (ContextCompat.checkSelfPermission(context, Manifest.permission.READ_CONTACTS) == PackageManager.PERMISSION_DENIED) 
        requestPermissions(new String[]{Manifest.permission.READ_CONTACTS}, 0);

}

Masalah ini sebenarnya disebabkan oleh NestedFragments. Pada dasarnya sebagian besar fragmen kami telah memperpanjang HostedFragment yang pada gilirannya memperluas CompatFragment. Memiliki fragmen bersarang ini menyebabkan masalah yang akhirnya diselesaikan oleh pengembang lain di proyek.

Dia melakukan beberapa hal tingkat rendah seperti bit switching untuk membuatnya bekerja jadi saya tidak terlalu yakin dengan solusi akhir yang sebenarnya

 /* use the object of your fragment to call the 
 * onRequestPermissionsResult in fragment after
 * in activity and use different request Code for 
 * both Activity and Fragment */

   if (isFragment)
    mFragment.requestPermissions(permissions.toArray(new
    String[permissions.size()]),requestPermission);

   else
    ActivityCompat.requestPermissions(mActivity,permissions.toArray(new
    String[permissions.size()]),requestPermission);

Ini akan bekerja ..

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

Jika Anda memanggil kode ini dari sebuah fragmen, ia memiliki metode requestPermissions sendiri.

Jadi konsep dasarnya adalah, Jika Anda berada dalam suatu Kegiatan, maka panggilan

ActivityCompat.requestPermissions(this,
                            permissionsList,
                            permissionscode);

dan jika dalam Fragmen, panggil saja

requestPermissions(permissionsList,
                            permissionscode);

Saya memiliki masalah yang sama kecuali saya menekan tombol untuk melakukan panggilan, yang memicu panggilanIntent. Saya memeriksa izin terlebih dahulu, jika tidak diberikan saya meminta izin dan padaRequestPermissionResult saya memanggil izin cek dan menelepon lagi.

 @Override
public void onRequestPermissionsResult(int requestCode, String permissions[], int[] grantResults) {
    switch (requestCode) {
        case Constants.PERMISSIONS_REQUEST_CALL_PHONE: {
            if ( grantResults[0] == PackageManager.PERMISSION_GRANTED) {

                checkPermissionsAndCall();
            }
        }
    }
}

public void checkPermissionsAndCall(){
    if (Build.VERSION.SDK_INT > 22) {
        if(ContextCompat.checkSelfPermission(getContext(),
                Manifest.permission.CALL_PHONE)
                != PackageManager.PERMISSION_GRANTED){
            requestPermissions( new String[]{Manifest.permission.CALL_PHONE}, Constants.PERMISSIONS_REQUEST_CALL_PHONE);
        }
        else{
            callIntent();
        }
    }
}

Berdasarkan jawaban goodgamerguy solusinya adalah:

myFragment.this.requestPermissions(....)

Sebelum Anda memeriksa semuanya sesuai dengan jawaban di atas, pastikan kode permintaan Anda tidak 0 !!!

periksa kode onRequestPermissionsResult () di FragmentActivity.java:

public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions,
        @NonNull int[] grantResults) {
    int index = (requestCode>>16)&0xffff;
    if (index != 0) {
        index--;

        String who = mPendingFragmentActivityResults.get(index);
        mPendingFragmentActivityResults.remove(index);
        if (who == null) {
            Log.w(TAG, "Activity result delivered for unknown Fragment.");
            return;
        }
        Fragment frag = mFragments.findFragmentByWho(who);
        if (frag == null) {
            Log.w(TAG, "Activity result no fragment exists for who: " + who);
        } else {
            frag.onRequestPermissionsResult(requestCode&0xffff, permissions, grantResults);
        }
    }
}

private void showContacts() {
    if (getActivity().checkSelfPermission(Manifest.permission.READ_CONTACTS)
        != PackageManager.PERMISSION_GRANTED) {
        requestPermissions(new String[]{Manifest.permission.READ_CONTACTS}, PERMISSIONS_REQUEST_READ_CONTACTS);
    } else {
        doShowContacts();
    }
}

@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
    if (requestCode == PERMISSIONS_REQUEST_READ_CONTACTS && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
        doShowContacts();
    }
}

Saya punya solusi luar biasa untuk mencapai ini, buat BaseActivity seperti ini.

public class BaseActivity extends AppCompatActivity {

@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    // Thread.setDefaultUncaughtExceptionHandler(new MyExceptionHandler(this));


}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String permissions[], @NonNull int[] grantResults) {
    switch (requestCode) {
        case 1: {
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                CustomToast.getInstance().setCustomToast("Now you can share the Hack.");

            } else {
                Toast.makeText(this, "Permission denied to read your External storage", Toast.LENGTH_SHORT).show();
            }
        }
    }
}

}

Sekarang Anda dapat memanggil kode untuk meminta izin seperti ini

 ActivityCompat.requestPermissions(getActivity(), new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE}, 1);

Sekarang setiap kali ini terjadi di mana saja baik dalam fragmen Anda atau dalam aktivitas apa pun aktivitas dasar akan dipanggil.

Terima kasih

Anda bisa menggunakannya requestPermissions(PERMISSIONS, MULTIPLE_PERMISSIONS_CODE);. Jangan gunakan FragmentCompat jika Anda menggunakan v4.

Detail

• Kotlin 1.2.70
• diperiksa di minSdkVersion 19
• Android studio 3.1.4

Algoritma

modul - kamera, lokasi, ....

1. Periksa apakah hasSystemFeature (jika modul ada di telepon)
2. Periksa apakah pengguna memiliki akses ke modul
3. Kirim permintaan izin (minta pengguna untuk mengizinkan penggunaan modul )

fitur

1. Bekerja dengan Aktivitas dan Fragmen
2. Hanya memiliki satu respons hasil
3. Dapat memeriksa beberapa modul dalam satu permintaan

Larutan

class PermissionType(val manifest_permission: String, val packageManager: String) {
    object Defined {
        val camera = PermissionType(Manifest.permission.CAMERA, PackageManager.FEATURE_CAMERA)
        val currentLocation = PermissionType(Manifest.permission.ACCESS_FINE_LOCATION, PackageManager.FEATURE_LOCATION_GPS)
    }
}

class  Permission {

    enum class PermissionResult {
        ACCESS_ALLOWED, ACCESS_DENIED, NO_SYSTEM_FEATURE;
    }

    interface ManagerDelegate {
        fun permissionManagerDelegate(result: Array<Pair<String, PermissionResult>>)
    }

    class Manager internal constructor(private val delegate: ManagerDelegate?) {

        private var context: Context? = null
        private var fragment: Fragment? = null
        private var activity: AppCompatActivity? = null
        private var permissionTypes: Array<PermissionType> = arrayOf()
        private val REQUEST_CODE = 999
        private val semaphore = Semaphore(1, true)
        private var result: Array<Pair<String, PermissionResult>> = arrayOf()


        constructor(permissionType: PermissionType, delegate: ManagerDelegate?): this(delegate) {
            permissionTypes = arrayOf(permissionType)
        }

        constructor(permissionTypes: Array<PermissionType>, delegate: ManagerDelegate?): this(delegate) {
            this.permissionTypes = permissionTypes
        }

        init {
            when (delegate) {
                is Fragment -> {
                    this.fragment = delegate
                    this.context = delegate.context
                }

                is AppCompatActivity -> {
                    this.activity = delegate
                    this.context = delegate
                }
            }
        }

        private fun hasSystemFeature(permissionType: PermissionType) : Boolean {
            return context?.packageManager?.hasSystemFeature(permissionType.packageManager) ?: false
        }

        private fun hasAccess(permissionType: PermissionType) : Boolean {
            return if (Build.VERSION.SDK_INT < 23) true else {
                context?.checkSelfPermission(permissionType.manifest_permission) == PackageManager.PERMISSION_GRANTED
            }
        }

        private fun sendRequest(permissionTypes: Array<String>) {

            if (fragment != null) {
                fragment?.requestPermissions(permissionTypes, REQUEST_CODE)
                return
            }

            if (activity != null){
                ActivityCompat.requestPermissions(activity!!, permissionTypes, REQUEST_CODE)
            }
        }

        fun check() {

            semaphore.acquire()
            AsyncTask.execute {
                var permissionsForSendingRequest: Array<String> = arrayOf()
                this.result = arrayOf()

                for (it in permissionTypes) {
                    if (!hasSystemFeature(it)) {
                        result += Pair(it.manifest_permission, PermissionResult.NO_SYSTEM_FEATURE)
                        continue
                    }

                    if (hasAccess(it)) {
                        result += Pair(it.manifest_permission, PermissionResult.ACCESS_ALLOWED)
                    } else {
                        permissionsForSendingRequest += it.manifest_permission
                    }
                }

                if (permissionsForSendingRequest.isNotEmpty()) {
                    sendRequest(permissionsForSendingRequest)
                } else {
                    delegate?.permissionManagerDelegate(result)
                }
            }
        }

        fun onRequestPermissionsResult(requestCode: Int, permissions: Array<out String>, grantResults: IntArray) {
            when (requestCode) {
                REQUEST_CODE -> {
                    if (grantResults.isEmpty()) {
                        return
                    }
                    for ((i,permission) in permissions.withIndex()) {
                        for (item in this.permissionTypes) {
                            if (permission == item.manifest_permission && i < grantResults.size) {
                                result += if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                                    Pair(item.manifest_permission, PermissionResult.ACCESS_ALLOWED)
                                } else {
                                    Pair(item.manifest_permission, PermissionResult.ACCESS_DENIED)
                                }
                                break
                            }
                        }
                    }
                    delegate?.permissionManagerDelegate(result)
                }
            }
            semaphore.release()
        }
    }
}

Penggunaan dalam Aktivitas (dalam fragmen yang sama)

class BaseActivity : AppCompatActivity(), Permission.ManagerDelegate {

    private lateinit var permissionManager: Permission.Manager

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

        permissionManager = Permission.Manager(arrayOf(PermissionType.Defined.camera, PermissionType.Defined.currentLocation), this)
        permissionManager.check()
    }

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


    override fun permissionManagerDelegate(result: Array<Pair<String, Permission.PermissionResult>>) {
        result.forEach {
            println("!!! ${it.first} ${it.second}")
//            when (it.second) {
//                Permission.PermissionResult.NO_SYSTEM_FEATURE -> {
//                }
//
//                Permission.PermissionResult.ACCESS_DENIED  -> {
//                }
//
//                Permission.PermissionResult.ACCESS_ALLOWED -> {
//                }
//            }
        }
    }
}

Di sini saya ingin menunjukkan kode saya bagaimana saya mengatur ini.

public class CheckPermission {

public Context context;

public static final int PERMISSION_REQUEST_CODE =  200;

public CheckPermission(Context context){
    this.context = context;
}

public boolean isPermissionGranted(){
    int read_contact = ContextCompat.checkSelfPermission(context.getApplicationContext() , READ_CONTACTS);
    int phone = ContextCompat.checkSelfPermission(context.getApplicationContext() , CALL_PHONE);

    return read_contact == PackageManager.PERMISSION_GRANTED && phone == PackageManager.PERMISSION_GRANTED;
   }
}

Di sini, di kelas ini saya ingin memeriksa izin yang diberikan atau tidak. Tidak maka saya akan meminta izin dari MainActivity saya seperti

public void requestForPermission() {
       ActivityCompat.requestPermissions(MainActivity.this, new String[]    {READ_CONTACTS, CALL_PHONE}, PERMISSION_REQUEST_CODE);
}

@Override
public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
    switch (requestCode) {
        case PERMISSION_REQUEST_CODE:
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                if (shouldShowRequestPermissionRationale(ACCESS_FINE_LOCATION)) {
                    showMessageOKCancel("You need to allow access to both the permissions",
                            new DialogInterface.OnClickListener() {
                                @Override
                                public void onClick(DialogInterface dialog, int which) {
                                    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
                                        requestPermissions(new String[]{Manifest.permission.READ_CONTACTS, Manifest.permission.CALL_PHONE},
                                                PERMISSION_REQUEST_CODE);
                                    }
                                }
                            });
                    return;
                }
            }
    }
}

Sekarang dalam metode onCreate Anda perlu memanggil fungsi requestForPermission ().

Itu saja. Anda juga dapat meminta beberapa izin sekaligus.

PEMBARUAN: melihat jawaban orang lain tentang menelepon super.onRequestPermissionResult()dalam Aktivitas dan yang memperbaiki masalah kode permintaan yang saya sebutkan dan menyebut fragmennya padaRequestPermissionResult.

abaikan hal ini:

Bagi saya itu adalah panggilan onRequestPermissionResultKegiatan meskipun saya meneleponfragment.requestPermission(...) , TAPI mengembalikan hasil dengan kode request yang salah (111 berubah menjadi 65647 mengapa ??? Saya tidak akan pernah tahu).

Untungnya ini adalah satu-satunya izin yang kami minta di layar itu, jadi saya abaikan saja kode permintaan (tidak punya waktu untuk mencari tahu mengapa itu tidak benar sekarang)

Saya juga menemui masalah yang bahkan jika Anda memanggil requestPermissions yang benar, Anda masih dapat memiliki masalah ini. Masalahnya adalah bahwa aktivitas orang tua dapat menggantikan metode ini tanpa memanggil super. Tambahkan super dan itu akan diperbaiki.