Android M-Berechtigungen: onRequestPermissionsResult () wird nicht aufgerufen

Ich aktualisiere unsere App, um das neue M-Laufzeitberechtigungssystem zu verwenden. Es funktioniert alles außer onRequestPermissionsResult (). Ich muss eine Berechtigung bei einem Tastendruck überprüfen und, wenn dies erfolgreich ist, eine Textnachricht senden. Wenn ich die Erlaubnis dazu erteile, wird der Dialog geschlossen, aber der Text senden wird erst ausgelöst, wenn ich die Taste erneut drücke.

Ich habe in der Methode onRequestPermissionsResult () debuggt und Haltepunkte gesetzt, aber es wird nie darauf eingegangen.

Diese Methode wird zuerst aufgerufen:

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

Und dann sieht mein Rückruf so aus:

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

Ist jemand auf ein ähnliches Problem gestoßen? Schätzen Sie jede Hilfe dabei. Vielen Dank

Ich bin auf dasselbe Problem gestoßen und habe gerade die Lösung gefunden. Wenn Sie die Support-Bibliothek verwenden, müssen Sie die richtigen Methodenaufrufe verwenden. Beispielsweise:

• In AppCompatActivity sollten Sie ActivityCompat.requestPermissions verwenden .
• In android.support.v4.app.Fragment sollten Sie einfach requestPermissions verwenden (dies ist eine Instanzmethode von android.support.v4.app.Fragment).

Wenn Sie ActivityCompat.requestPermissions in einem Fragment aufrufen , wird der Rückruf onRequestPermissionsResult für die Aktivität und nicht für das Fragment aufgerufen.

Hoffe das hilft!

Sie können dies versuchen:

requestPermissions(permissions, PERMISSIONS_CODE);

Wenn Sie diesen Code aus einem Fragment aufrufen, verfügt er über eine eigene requestPermissions-Methode. Ich glaube, das Problem ist, dass Sie statische Methode aufrufen.

Pro Tipp, wenn Sie das onRequestPermissionsResult()in einem Fragment wollen: FragmentCompat.requestPermissions(Fragment fragment, String[] permissions, int requestCode)

Ich hoffe es funktioniert gut

Für Aktivität:

 ActivityCompat.requestPermissions(this,permissionsList,REQUEST_CODE);

Für Fragment:

 requestPermissions(permissionsList,REQUEST_CODE);

Ich bin auch auf dieses Problem gestoßen. Wenn Sie die Aktivität möchten, die Berechtigungen verarbeitet, die nicht im Verlauf / in den letzten Jahren enthalten sind, werden Sie versucht sein, Ihren AndroidManifest.xmlEintrag zu ändern .

Wenn Sie die Aktivität festlegen, die Sie aufrufen requestPermissionsoder AppCompatActivity.requestPermissionsmit der Sie arbeiten

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

in deinem AndroidManifest.xmldann onRequestPermissionsResult()wird nicht gerufen. Dies gilt, wenn Ihre Aktivität von Activityoder abgeleitet ist AppCompatActivity.

Dies kann behoben werden, indem Sie beide Flags aus 'AndroidManifest.xml' entfernen und finishAndRemoveTask()stattdessen Ihre Aktivität mit beenden .

Wenn Sie onRequestPermissionsResultsowohl Aktivität als auch Fragment haben, stellen Sie sicher, dass Sie super.onRequestPermissionsResultAktivität aufrufen . Es ist nicht in Fragment erforderlich, aber es ist in Aktivität.

Antwort veraltet finden Sie unter: https://developer.android.com/training/permissions/requesting

Innerhalb des Fragments müssen Sie Folgendes aufrufen:

FragmentCompat.requestPermissions(permissionsList, RequestCode)

Nicht:

ActivityCompat.requestPermissions(Activity, permissionsList, RequestCode);

Wenn Sie requestPermissions in Fragment verwenden, werden 2 statt 3 Parameter akzeptiert.

Du solltest benutzen requestPermissions(permissions, PERMISSIONS_CODE);

Wenn Sie aus irgendeinem Grund eine benutzerdefinierte Aktivität in einer externen Bibliothek erweitert haben, die den Super nicht aufruft, müssen Sie das Fragment super.onRequestPermissionsResult in Ihrer Aktivität onRequestPermissionsResult manuell aufrufen.

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

Sie haben die Funktion checkPermissions für Geräte vor Marshmallow in FragmentCompat . Ich benutze so:

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

Ich habe herausgefunden, dass das wichtig ist, wo Sie anrufen android.support.v4.app.Fragment.requestPermissions.

Wenn Sie es in tun onCreate(),onRequestPermissionsResult() wird nie aufgerufen.

Lösung: Rufen Sie es an 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);

}

Dieses Problem wurde tatsächlich von NestedFragments verursacht. Grundsätzlich haben die meisten Fragmente ein HostedFragment erweitert, das wiederum ein CompatFragment erweitert. Diese verschachtelten Fragmente verursachten Probleme, die schließlich von einem anderen Entwickler des Projekts gelöst wurden.

Er hat ein paar Sachen auf niedriger Ebene gemacht, wie zum Beispiel Bit-Switching, damit das funktioniert, also bin ich mir der tatsächlichen endgültigen Lösung nicht sicher

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

Das wird funktionieren..

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

Wenn Sie diesen Code aus einem Fragment aufrufen, verfügt er über eine eigene requestPermissions-Methode.

Das Grundkonzept lautet also: Wenn Sie sich in einer Aktivität befinden, rufen Sie an

ActivityCompat.requestPermissions(this,
                            permissionsList,
                            permissionscode);

und wenn in einem Fragment, rufen Sie einfach an

requestPermissions(permissionsList,
                            permissionscode);

Ich hatte ein ähnliches Problem, außer dass ich eine Taste drückte, um einen Anruf zu tätigen, der den callIntent auslöst. Ich habe zuerst die Berechtigung überprüft. Wenn sie nicht erteilt wurde, bitte ich um Erlaubnis und onRequestPermissionResult rufe die Überprüfungsberechtigung auf und rufe erneut auf.

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

Basierend auf der Antwort von goodgamerguy lautet die Lösung:

myFragment.this.requestPermissions(....)

Bevor Sie alles gemäß den obigen Antworten überprüfen, stellen Sie sicher, dass Ihr Anforderungscode nicht 0 ist !!!

Überprüfen Sie den Code von onRequestPermissionsResult () in 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();
    }
}

Ich habe eine erstaunliche Lösung, um dies zu erreichen. Machen Sie eine BaseActivity wie diese.

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

}}

Jetzt können Sie den Code aufrufen, um eine solche Erlaubnis anzufordern

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

Jedes Mal, wenn dies irgendwo passiert, egal ob in Ihrem Fragment oder in einer Aktivität, wird die Basisaktivität aufgerufen.

Vielen Dank

Sie können verwenden requestPermissions(PERMISSIONS, MULTIPLE_PERMISSIONS_CODE);. Verwenden Sie FragmentCompat nicht, wenn Sie v4 verwenden.

Einzelheiten

• Kotlin 1.2.70
• eingecheckt in minSdkVersion 19
• Android Studio 3.1.4

Algorithmus

Modul - Kamera, Ort, ....

1. Überprüfen Sie, ob hasSystemFeature vorhanden ist (falls das Modul im Telefon vorhanden ist).
2. Überprüfen Sie, ob der Benutzer Zugriff auf das Modul hat
3. Berechtigungsanforderung senden (Benutzer bitten, die Modulnutzung zuzulassen )

Eigenschaften

1. Arbeiten Sie mit Aktivitäten und Fragmenten
2. Hat nur eine Ergebnisantwort
3. Kann mehrere Module in einer Anfrage prüfen

Lösung

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

Verwendung in Aktivität (in Fragment gleich)

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 -> {
//                }
//            }
        }
    }
}

Hier möchte ich meinen Code zeigen, wie ich das geschafft habe.

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

Hier in dieser Klasse möchte ich überprüfen, ob die Erlaubnis erteilt wurde oder nicht. Ist nicht dann werde ich Erlaubnis von meiner MainActivity wie nennen

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

Jetzt müssen Sie in der onCreate-Methode die Funktion requestForPermission () aufrufen.

Das war's auch. Sie können mehrere Berechtigungen gleichzeitig anfordern.

UPDATE: Die Antwort eines anderen über das Aufrufen super.onRequestPermissionResult()von Activity wurde angezeigt. Dadurch wurde das von mir erwähnte Problem mit dem Anforderungscode behoben und das onRequestPermissionResult des Fragments aufgerufen.

ignoriere dieses Zeug:

Für mich rief es die onRequestPermissionResultAktivität auf, obwohl ich anrief fragment.requestPermission(...), ABER es gab das Ergebnis mit einem falschen requestCode zurück (111 wurde zu 65647 warum ??? Ich werde es nie erfahren).

Glücklicherweise ist dies die einzige Erlaubnis, die wir auf diesem Bildschirm anfordern, daher ignoriere ich einfach den Anforderungscode (ich habe keine Zeit herauszufinden, warum er momentan nicht korrekt ist).

Ich habe auch ein Problem festgestellt, dass dieses Problem auch dann auftreten kann, wenn Sie korrekte requestPermissions aufrufen. Das Problem ist, dass übergeordnete Aktivitäten diese Methode möglicherweise überschreiben, ohne super aufzurufen. Füge super hinzu und es wird behoben.