Create new permission factory for android

coreapp/src/androidMain/kotlin/com/metacto/core/di/CorePlatformModule.kt

@@ -6,6 +6,8 @@ import com.metacto.core.domain.repos.RepositoriesFactory
 import com.metacto.core.domain.repos.forceUpdate.ForceUpdateRepository
 import com.metacto.core.permissions.IPermissionManager
 import com.metacto.core.permissions.PermissionManager
+import com.metacto.core.permissions.helpers.IPermissionFactory
+import com.metacto.core.permissions.helpers.PermissionFactory
 import com.metacto.core.presentation.base.CommonViewModel
 import com.metacto.core.presentation.camera.CameraController
 import com.metacto.core.presentation.camera.CameraEngine
@@ -84,8 +86,15 @@ actual fun <T : SerializableNetworkError> corePlatformModule(
         )
     }
 
+    single<IPermissionFactory> {
+        PermissionFactory()
+    }
+
     single<IPermissionManager> {
-        PermissionManager(androidContext())
+        PermissionManager(
+            context = androidContext(),
+            permissionFactory = get()
+        )
     }
 
     single<IIntentLauncher> {

coreapp/src/androidMain/kotlin/com/metacto/core/permissions/PermissionManager.kt

@@ -18,8 +18,9 @@ import com.metacto.core.permissions.enums.PermissionState
 import com.metacto.core.permissions.exceptions.DeniedAlwaysException
 import com.metacto.core.permissions.exceptions.DeniedException
 import com.metacto.core.permissions.exceptions.RequestCanceledException
-import com.metacto.core.permissions.helpers.toPlatformPermission
+import com.metacto.core.permissions.helpers.IPermissionFactory
 import com.metacto.core.utils.extensions.openAppSettings
+
 import kotlinx.coroutines.flow.MutableStateFlow
 import kotlinx.coroutines.flow.filterNotNull
 import kotlinx.coroutines.flow.first
@@ -29,7 +30,11 @@ import kotlinx.coroutines.withTimeoutOrNull
 import java.util.UUID
 import kotlin.coroutines.suspendCoroutine
 
-internal class PermissionManager(private val context: Context) : IPermissionManager {
+internal class PermissionManager(
+    private val context: Context,
+    private val permissionFactory: IPermissionFactory
+) : IPermissionManager {
+
     private val activityHolder = MutableStateFlow<Activity?>(null)
     private val launcherHolder = MutableStateFlow<ActivityResultLauncher<Array<String>>?>(null)
     private var permissionCallback: PermissionCallback? = null
@@ -112,7 +117,7 @@ internal class PermissionManager(private val context: Context) : IPermissionMana
     private suspend fun handlePermissionRequest(permission: Permission) {
         mutex.withLock {
             val launcher = awaitActivityResultLauncher()
-            val platformPermissions = permission.toPlatformPermission()
+            val platformPermissions = getAndroidPermissions(permission)
 
             suspendCoroutine { continuation ->
                 permissionCallback = PermissionCallback(permission, continuation::resumeWith)
@@ -133,6 +138,10 @@ internal class PermissionManager(private val context: Context) : IPermissionMana
         }
     }
 
+    private fun getAndroidPermissions(permission: Permission): List<String> {
+        return permissionFactory.getPermissions(permission)
+    }
+
     private suspend fun awaitActivityResultLauncher(): ActivityResultLauncher<Array<String>> {
         return launcherHolder.value ?: withTimeoutOrNull(AWAIT_ACTIVITY_TIMEOUT_MS) {
             launcherHolder.filterNotNull().first()
@@ -155,7 +164,7 @@ internal class PermissionManager(private val context: Context) : IPermissionMana
     }
 
     private suspend fun getRuntimePermissionState(permission: Permission): PermissionState {
-        val permissions = permission.toPlatformPermission()
+        val permissions = getAndroidPermissions(permission)
         val status = permissions.map {
             ContextCompat.checkSelfPermission(context, it)
         }

coreapp/src/androidMain/kotlin/com/metacto/core/permissions/helpers/IPermissionFactory.kt

@@ -0,0 +1,7 @@
+package com.metacto.core.permissions.helpers
+
+import com.metacto.core.permissions.enums.Permission
+
+interface IPermissionFactory {
+    fun getPermissions(permission: Permission): List<String>
+}

coreapp/src/androidMain/kotlin/com/metacto/core/permissions/helpers/PermissionFactory.kt

@@ -0,0 +1,155 @@
+package com.metacto.core.permissions.helpers
+
+import android.Manifest
+import android.os.Build
+import com.metacto.core.permissions.enums.Permission
+
+internal class PermissionFactory : IPermissionFactory {
+
+    @Suppress("CyclomaticComplexMethod")
+    override fun getPermissions(permission: Permission): List<String> {
+        return when (permission) {
+            Permission.CAMERA -> listOf(Manifest.permission.CAMERA)
+            Permission.GALLERY -> galleryCompat()
+            Permission.STORAGE -> allStoragePermissions()
+            Permission.WRITE_STORAGE -> writeStorageCompat()
+            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()
+            Permission.CALENDER -> listOf(
+                Manifest.permission.READ_CALENDAR,
+                Manifest.permission.WRITE_CALENDAR
+            )
+        }
+    }
+
+    private fun writeStorageCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            // On Android 10+, this permission is ignored by the system
+            emptyList()
+        } else {
+            listOf(Manifest.permission.WRITE_EXTERNAL_STORAGE)
+        }
+    }
+
+    private fun allStoragePermissions(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            listOf(
+                Manifest.permission.READ_MEDIA_AUDIO,
+                Manifest.permission.READ_MEDIA_IMAGES,
+                Manifest.permission.READ_MEDIA_VIDEO
+            )
+        } else {
+            listOf(Manifest.permission.READ_EXTERNAL_STORAGE)
+        }
+    }
+
+    private fun galleryCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            listOf(
+                Manifest.permission.READ_MEDIA_IMAGES,
+                Manifest.permission.READ_MEDIA_VIDEO
+            )
+        } else {
+            listOf(Manifest.permission.READ_EXTERNAL_STORAGE)
+        }
+    }
+
+    private fun fineLocationCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+            )
+        } else {
+            listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+        }
+    }
+
+    private fun backgroundLocationCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_COARSE_LOCATION,
+                Manifest.permission.ACCESS_BACKGROUND_LOCATION,
+            )
+        } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            listOf(
+                Manifest.permission.ACCESS_FINE_LOCATION,
+                Manifest.permission.ACCESS_BACKGROUND_LOCATION,
+            )
+        } else {
+            listOf(Manifest.permission.ACCESS_FINE_LOCATION)
+        }
+    }
+
+    private fun allBluetoothPermissions(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(
+                Manifest.permission.BLUETOOTH_CONNECT,
+                Manifest.permission.BLUETOOTH_SCAN,
+                Manifest.permission.BLUETOOTH_ADVERTISE,
+                Manifest.permission.ACCESS_COARSE_LOCATION
+            )
+        } else {
+            listOf(
+                Manifest.permission.BLUETOOTH,
+                Manifest.permission.ACCESS_COARSE_LOCATION
+            )
+        }
+    }
+
+    private fun bluetoothScanCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(Manifest.permission.BLUETOOTH_SCAN)
+        } else {
+            listOf(Manifest.permission.BLUETOOTH)
+        }
+    }
+
+    private fun bluetoothAdvertiseCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(Manifest.permission.BLUETOOTH_ADVERTISE)
+        } else {
+            listOf(Manifest.permission.BLUETOOTH)
+        }
+    }
+
+    private fun bluetoothConnectCompat(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            listOf(Manifest.permission.BLUETOOTH_CONNECT)
+        } else {
+            listOf(Manifest.permission.BLUETOOTH)
+        }
+    }
+
+    private fun motionPermissions(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
+            listOf(
+                Manifest.permission.ACTIVITY_RECOGNITION,
+                Manifest.permission.BODY_SENSORS
+            )
+        } else {
+            listOf(Manifest.permission.BODY_SENSORS)
+        }
+    }
+
+    private fun remoteNotificationsPermissions(): List<String> {
+        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            listOf(Manifest.permission.POST_NOTIFICATIONS)
+        } else {
+            emptyList()
+        }
+    }
+}