Android M 权限：未调用 onRequestPermissionsResult()答案

【问题标题】：Android M Permissions: onRequestPermissionsResult() not being calledAndroid M 权限：未调用 onRequestPermissionsResult()
【发布时间】：2015-12-19 07:23:42
【问题描述】：

我正在更新我们的应用程序以使用新的 M 运行时权限系统。除了 onRequestPermissionsResult() 之外，一切正常。我需要检查按钮按下的权限，如果成功，请发送短信。当我授予执行此操作的权限时，对话框关闭，但在我再次按下按钮之前它不会触发发送文本。

我已经在 onRequestPermissionsResult() 方法中调试并设置了断点，但它从未进入它。

首先调用此方法：

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

然后我的回调看起来像这样：

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

有人遇到过类似的问题吗？感谢您对此的任何帮助。谢谢

【问题讨论】：

标签： java android permissions android-permissions

【解决方案1】：

你可以试试这个：

requestPermissions(permissions, PERMISSIONS_CODE);

如果您从片段中调用此代码，它有自己的 requestPermissions 方法。我认为问题在于您正在调用静态方法。

专业提示，如果您想在片段中使用 onRequestPermissionsResult()： FragmentCompat.requestPermissions(Fragment fragment, String[] permissions, int requestCode)

【讨论】：

感谢您的帮助。我确实注意到，如果它在片段中，则有一个 requestPermissions 方法。我在一个片段中，我尝试只调用 requestPermissions，不幸的是它没有用。你说的我也试过了，还是不行。
这在 Android M 中对我有用。但只是想知道它是否会在 Pre-M 设备中引起任何问题？
@goodgamerguy 确保您不要在活动的 onRequestPermissionsResult 中使用请求代码。如果您的活动还使用 onRequestPermissionsResult 回调，您应该提供默认值：super.onRequestPermissionsResult(requestCode, permissions, grantResults);

【解决方案2】：

您在 FragmentCompat 中具有用于预 Marshmallow 设备的 checkPermissions 功能。我是这样使用的：

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

【讨论】：

只有在 android.app.fragment 中请求权限时才有效，并且必须导入 support-v13 库！
FragmentCompat.requestPermissions() 不适用于 android.support.v4.app.Fragment。任何人都知道如何处理。

【解决方案3】：

我遇到了同样的问题，我刚刚找到了解决方案。使用 Support 库时，您必须使用正确的方法调用。例如：

在 AppCompatActivity 中时，应使用 ActivityCompat.requestPermissions；
在android.support.v4.app.Fragment中，你应该简单地使用requestPermissions（这是android.support.v4.app.Fragment的一个实例方法)

如果您在片段中调用 ActivityCompat.requestPermissions，则会在 Activity 而不是片段上调用 onRequestPermissionsResult 回调。

【讨论】：

noHistory 活动也会发生这种情况：code.google.com/p/android-developer-preview/issues/…
"在 android.support.v4.app.Fragment 中，您应该简单地使用 requestPermissions" - 谢谢！
@AnthonyBobenrieth 那么 noHistory 活动的解决方案是什么？我们根本无法向他们请求权限？
链接已损坏@AnthonyBobenrieth。没有历史有什么解决办法吗？
当使用Fragment.requestPermissions()时，父Activity实际上是在接收onRequestPermissionsResult()。（这是支持库 23.3.0）

【解决方案4】：

这个问题实际上是由 NestedFragments 引起的。基本上，我们扩展了 HostedFragment 的大多数片段，而 HostedFragment 又扩展了 CompatFragment。拥有这些嵌套片段会导致问题，最终由该项目的另一位开发人员解决。

他正在做一些低级的事情，比如位切换来让它工作，所以我不太确定实际的最终解决方案

【讨论】：

这帮助我解决了我的问题：我必须将 onRequestPermissionsResult 从父片段重定向到子（嵌套）片段。感谢您的提示！

【解决方案5】：

如果您在活动和片段中都有onRequestPermissionsResult，请确保在活动中调用super.onRequestPermissionsResult。在片段中不是必需的，但在活动中。

【讨论】：

另外请注意，如果你的目标是一个API（比如19），你仍然是在旧的权限模型系统下，因此，不会收到请求权限相关的函数调用跨度>
如果您扩展了另一个不调用 super 的活动，请查看我的答案
偶然发现了这个。 FragmentActivity.onRequestPermissionsResult(..) 是对片段的 onRequestPermissionsResult(..) 的调用被转发到的位置。
@Bonatti 所以如果我尝试在 android 4.4.2 中请求权限，我不会得到结果？因此我无法更改权限，只能看到它们？
@AlexanderFragotsis 你会得到一个结果。唯一不同的是不会要求您授予权限，而是系统会自动授予您。

【解决方案6】：

如果您在片段中使用 requestPermissions，它接受 2 个参数而不是 3 个。

你应该使用requestPermissions(permissions, PERMISSIONS_CODE);

【讨论】：

实际上它确实提供了问题的答案。调用requestPermissions（fragment的实例方法）而不是ActivityCompat.requestPermissions，触发result方法。这是这里的主要问题。谢谢唐

【解决方案7】：

如果由于某种原因您扩展了位于某些外部库中的自定义 Activity，但该库不调用 super，您将需要在您的 Activity onRequestPermissionsResult 中手动调用 Fragment super.onRequestPermissionsResult。

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

【讨论】：

我有正常的活动延伸AppCompatActivity，我还应该使用super()吗？

【解决方案8】：

这会起作用..

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

【讨论】：

超级实现调用fragments实现而不是hte框架

【解决方案9】：

我发现你打电话给android.support.v4.app.Fragment.requestPermissions的地方很重要。

如果您在onCreate() 中执行此操作，则永远不会调用onRequestPermissionsResult()。

解决方法：拨打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);

}

【讨论】：

我面临同样的问题，但我无法在我的代码中获得onActivityCreated()。 SDK 23.
参见developer.android.com/reference/android/app/…，或参见mysamplecode.com/2012/08/android-fragment-example.html的示例
我不在片段中，我正在尝试在活动的 onCreate 上执行此操作
嗯，还是用onPause()?

【解决方案10】：

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

【讨论】：

【解决方案11】：

我也遇到过这个问题。如果您想要处理不在历史/最近的权限的活动，那么您会很想更改您的 AndroidManifest.xml 条目。

如果您使用

设置调用 requestPermissions 或 AppCompatActivity.requestPermissions 的活动

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

在您的AndroidManifest.xml 中，onRequestPermissionsResult() 将不会被调用。如果您的 Activity 派生自 Activity 或 AppCompatActivity，这是正确的。

可以通过从“AndroidManifest.xml”中删除这两个标志并使用finishAndRemoveTask() 完成您的活动来解决此问题。

【讨论】：

我宁愿不必删除 noHistory 属性，但这是对我有用的解决方案。谢谢！
我在 Marshmallow 上遇到了问题，但在 Nougat 上没有，谢谢它对我有用

【解决方案12】：

答案已弃用，请参考： https://developer.android.com/training/permissions/requesting

片段内部，需要调用：

FragmentCompat.requestPermissions(permissionsList, RequestCode)

不是：

ActivityCompat.requestPermissions(Activity, permissionsList, RequestCode);

【讨论】：

与android.support.v13.app.FragmentCompat相关
FragmentCompat 自 API 27.1.0 起已弃用。
我的答案已弃用，请参考：developer.android.com/training/permissions/requesting

【解决方案13】：

在根据以上答案检查一切之前，请确保您的请求代码不为0！！！

查看 FragmentActivity.java 中 onRequestPermissionsResult() 的代码：

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

【讨论】：

【解决方案14】：

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

【讨论】：

【解决方案15】：

希望一切顺利

对于活动：

 ActivityCompat.requestPermissions(this,permissionsList,REQUEST_CODE);

对于片段：

 requestPermissions(permissionsList,REQUEST_CODE);

【讨论】：

SDK 15 及更低版本怎么样？
SDK 15不需要权限，只需要Marshmallow及以上版本..

【解决方案16】：

您可以使用requestPermissions(PERMISSIONS, MULTIPLE_PERMISSIONS_CODE);。如果您使用的是 v4，请不要使用 FragmentCompat。

【讨论】：

请详细说明原因。

【解决方案17】：

如果您从片段中调用此代码，它有自己的 requestPermissions 方法。

所以基本概念是，如果你在一个 Activity 中，那么调用

ActivityCompat.requestPermissions(this,
                            permissionsList,
                            permissionscode);

如果在 Fragment 中，只需调用

requestPermissions(permissionsList,
                            permissionscode);

【讨论】：

需要 API 级别 23... 在早期版本中使用 FragmentCompat.requestPermissions()。

【解决方案18】：

基于goodgamerguy's answer，解决方案是：

myFragment.this.requestPermissions(....)

【讨论】：

【解决方案19】：

更新：看到了其他人关于在 Activity 中调用 super.onRequestPermissionResult() 的回答，并修复了我提到的请求代码问题并调用了 片段的 onRequestPermissionResult。

忽略这些东西：

对我来说，尽管我调用了fragment.requestPermission(...)，但它还是调用了 Activity 的 onRequestPermissionResult，但它返回了错误的 requestCode 的结果（为什么 111 变成了 65647 ???我永远不会知道）。

幸运的是，这是我们在该屏幕上请求的唯一权限，所以我只是忽略了请求代码（现在没有时间弄清楚为什么它不正确）

【讨论】：

加上 65536 和 111 就可以了。这是因为位掩码。查看一些主题。

【解决方案20】：

我有一个了不起的解决方案来实现这一点，让 BaseActivity 像这样。

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

}

现在你可以像这样调用代码来请求许可了

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

现在，每当这种情况发生在任何地方，无论是在您的片段中还是在任何活动中，都会调用基础活动。

谢谢

【讨论】：

【解决方案21】：

详情

Kotlin 1.2.70
已签入 minSdkVersion 19
Android 工作室 3.1.4

算法

模块 - 相机、位置、....

检查hasSystemFeature（如果手机中存在模块）
检查用户是否有权访问模块
发送权限请求（要求用户允许模块使用）

特点

使用活动和片段
只有一个结果响应
可以在一个请求中检查多个模块

解决方案

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

在Activity中的使用（在片段中相同）

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

【讨论】：

【解决方案22】：

我遇到了类似的问题，只是我按下了一个按钮来拨打电话，这会触发 callIntent。我首先检查了权限，如果没有获得权限，我会请求权限，onRequestPermissionResult 我调用检查权限并再次调用。

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

【讨论】：

【解决方案23】：

在这里我想展示我的代码我是如何管理它的。

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

在这个类中，我想检查是否授予权限。不是这样我会从我的 MainActivity 中调用许可

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

现在在 onCreate 方法中你需要调用 requestForPermission() 函数。

就是这样。您还可以一次请求多个权限。

【讨论】：

【解决方案24】：

我还遇到了一个问题，即使你调用了正确的 requestPermissions，你仍然会遇到这个问题。问题是父活动可能会在不调用 super 的情况下覆盖此方法。添加超级，它将被修复。

【讨论】：

【解决方案25】：

对于 kotlin 用户，这是我的扩展程序，用于检查和验证权限而不覆盖 onRequestPermissionResult

 * @param permissionToValidate (request and check currently permission)
 *
 * @return recursive boolean validation callback (no need OnRequestPermissionResult)
 *
 * */
internal fun Activity.validatePermission(
    permissionToValidate: String,
    recursiveCall: (() -> Boolean) = { false }
): Boolean {
    val permission = ContextCompat.checkSelfPermission(
        this,
        permissionToValidate
    )

    if (permission != PackageManager.PERMISSION_GRANTED) {
        if (recursiveCall()) {
            return false
        }

        ActivityCompat.requestPermissions(
            this,
            arrayOf(permissionToValidate),
            110
        )
        return this.validatePermission(permissionToValidate) { true }
    }

    return true

}

【讨论】：