permission not working on android but works on ios compose multiplatform

[prabinshrestha]

I am using voyager library for compose multiplatform, here is the dependencies on shared

implementation("cafe.adriel.voyager:voyager-navigator:$voyagerVersion")
api("dev.icerock.moko:permissions-compose:0.16.0")

gradle properties
kotlin.version=1.8.20
agp.version=7.4.2
compose.version=1.4.1

The issue is the Log inside coroutine scope is called and after that no code run, there is no exception everything is blank or prints nothing on logger on android studio.I beleive something is wrong with controller.isPermissionGranted but in IOS It works properly

Android Log :
2023-07-07 16:06:22.577 744-744 test com.myapplication.MyApplication V on login button clicked.
2023-07-07 16:06:22.578 744-744 test com.myapplication.MyApplication V inside coroutine scope

IOS Log:
07-07 16:16:44.251 💜 VERBOSE test - on login button clicked.
07-07 16:16:44.251 💜 VERBOSE test - inside coroutine scope
07-07 16:16:44.262 💜 VERBOSE test - isGranted true

Android Manifest:

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

import cafe.adriel.voyager.core.model.rememberScreenModel
import cafe.adriel.voyager.core.screen.Screen
import cafe.adriel.voyager.navigator.LocalNavigator
import cafe.adriel.voyager.navigator.Navigator
import kotlinx.coroutines.CoroutineScope
import kotlinx.coroutines.launch
import dev.icerock.moko.permissions.DeniedAlwaysException
import dev.icerock.moko.permissions.DeniedException
import dev.icerock.moko.permissions.Permission
import dev.icerock.moko.permissions.PermissionsController
import dev.icerock.moko.permissions.compose.PermissionsControllerFactory
import dev.icerock.moko.permissions.compose.rememberPermissionsControllerFactory

val factory: PermissionsControllerFactory = rememberPermissionsControllerFactory()
    val controller: PermissionsController =
        remember(factory) { factory.createPermissionsController() }
    val coroutineScope: CoroutineScope = rememberCoroutineScope()

  Button(
            onClick = {
                //  onValid()
                AppLogger.log("on login button clicked.")
                coroutineScope.launch {
                    AppLogger.log("inside coroutine scope")
                    try {
                        val isGranted = controller.isPermissionGranted(Permission.CAMERA)
                        AppLogger.log("isGranted $isGranted")
                        if (!isGranted) {
                            // need to add permission on android manifest and info.plist on ios xcode
                            // https://iosdevcenters.blogspot.com/2016/09/infoplist-privacy-settings-in-ios-10.html
                            val permissionState =
                                controller.getPermissionState(Permission.CAMERA)
                            AppLogger.log(permissionState.name)
                            controller.providePermission(Permission.CAMERA)
                        }
                    } catch (deniedAlways: DeniedAlwaysException) {
                        AppLogger.log(deniedAlways.message.toString())
                        // Permission is always denied.
                        controller.openAppSettings()
                    } catch (denied: DeniedException) {
                        // Permission was denied.
                        AppLogger.log(denied.message.toString())
                        controller.openAppSettings()
                    }

                    //   controller.openAppSettings()
                    //   controller.providePermission(Permission.CAMERA)
                }
            },
            modifier = Modifier
                .fillMaxWidth()
                .padding(top = 16.dp)
        ) {
            Text(
                stringResource(MR.strings.sign_in),
                fontWeight = FontWeight.Bold,
                fontSize = MaterialTheme.typography.h6.fontSize
            )
        }

[Alex009]

hi!

please compare your setup with this template - https://github.com/icerockdev/moko-compose-multiplatform-ios-android-template

[prabinshrestha]

Its working now, BindEffect is required
val factory: PermissionsControllerFactory = rememberPermissionsControllerFactory()
val controller: PermissionsController =
        remember(factory) { factory.createPermissionsController() }
BindEffect(controller) // missing this api otherwise doesnot work, i am not using mokomvvm
val coroutineScope: CoroutineScope = rememberCoroutineScope()

Thank you @Alex009

[RaedGhazal]

Thanks @prabinshrestha for sharing your solution, was debugging for quite a while trying to understand why my viewmodel isn't logging anything, then after checking I saw that the isPermissionGranted is not returning anything.
the solution you wrote fixed it, I'll open a PR to update the readme file, hope they approve it cuz it can be confusing apparently its added to the documentation

[ibaton]

Thanks @Alex009 this helped me as well

[MDanishPK]

I am facing the same issue for the Contacts permissions.
Problem:
When permissions popup appears and user allow the permissions, now permission is granted, but it returns always in the state DeniedAlways .

Expected behaviour:
When permission is granted than it should not go in the DeniedAlways. In-case due to any reason PermissionController object is not update than on the next launch, it should get the contact permission granted, but it never comes in the Granted state.

Here is my actual app code:

@Composable
fun homeScreen() {
// some other code is here

val factory = rememberPermissionsControllerFactory()
   val controller = remember(factory) {
       factory.createPermissionsController()
   }

   BindEffect(controller)

   val viewModelPermissionsController: PermissionsViewModel = viewModel {
           PermissionsViewModel(controller)
   }
   
       LaunchedEffect(true) {
       when(viewModelPermissionsController.state) {
           PermissionState.Granted -> {
               getContacts()
           }
           PermissionState.DeniedAlways -> {
           }
           else -> {
               viewModelPermissionsController.providerOrRequestContactasPermission()
           }
       }
   }
   // some other code is here

Here is my viewModel

import androidx.compose.runtime.getValue
import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
import androidx.compose.runtime.setValue
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import dev.icerock.moko.permissions.DeniedAlwaysException
import dev.icerock.moko.permissions.DeniedException
import dev.icerock.moko.permissions.Permission
import dev.icerock.moko.permissions.PermissionState
import dev.icerock.moko.permissions.PermissionsController
import dev.icerock.moko.permissions.RequestCanceledException
import kotlinx.coroutines.launch

class PermissionsViewModel(
    private val controller: PermissionsController
): ViewModel() {
    var state by mutableStateOf(PermissionState.NotDetermined)
        private set
    var isAlreadyAsked by mutableStateOf(false)
    var launchContacts by mutableStateOf(false)

    init {
        viewModelScope.launch {
            state = controller.getPermissionState(Permission.CONTACTS)
            print("init with State: ${state}")
        }
    }

    fun setGrandtedPermission() {
        state = PermissionState.Granted
    }

    fun providerOrRequestContactasPermission() {
        viewModelScope.launch {
            try {
                controller.providePermission(Permission.CONTACTS)
                state = PermissionState.Granted
            } catch (e: DeniedAlwaysException) {
                state = PermissionState.DeniedAlways
            } catch (e: DeniedException) {
                state = PermissionState.Denied
            } catch (e: RequestCanceledException) {
                e.printStackTrace()
            }
        }
    }
}

[llobri]

@MDanishPK the Permission.CONTACTS is a special case, you need to add read and write permission to the AndroidManifest.xml:

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

In the Android implementation, the suspend fun getPermissionState(permission: Permission): PermissionState is calling fun Permission.toPlatformPermission(): List<String>, and the Android implementation for this function is:

private fun Permission.toPlatformPermission(): List<String> {
        return when (this) {
            Permission.CAMERA -> listOf(Manifest.permission.CAMERA)
            Permission.GALLERY -> galleryCompat()
            Permission.STORAGE -> allStoragePermissions()
            Permission.WRITE_STORAGE -> listOf(Manifest.permission.WRITE_EXTERNAL_STORAGE)
            Permission.LOCATION -> fineLocationCompat()
            Permission.COARSE_LOCATION -> listOf(Manifest.permission.ACCESS_COARSE_LOCATION)
            Permission.BACKGROUND_LOCATION -> backgroundLocationCompat()
            Permission.REMOTE_NOTIFICATION -> remoteNotificationsPermissions()
            Permission.RECORD_AUDIO -> listOf(Manifest.permission.RECORD_AUDIO)
            Permission.BLUETOOTH_LE -> allBluetoothPermissions()
            Permission.BLUETOOTH_SCAN -> bluetoothScanCompat()
            Permission.BLUETOOTH_ADVERTISE -> bluetoothAdvertiseCompat()
            Permission.BLUETOOTH_CONNECT -> bluetoothConnectCompat()
            Permission.CONTACTS-> listOf(Manifest.permission.READ_CONTACTS,Manifest.permission.WRITE_CONTACTS)
            Permission.MOTION -> motionPermissions()
        }
    }

Once you add both permissions to the manifest, everything works fine.

[ciprig]

It will be good to have support just for READ_CONTACTS most of the applications only use this, however right now the lib forces us to request both READ and WRITE.

I have made a PR: #160