Add permission modules

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/system/SystemUtils.kt

@@ -121,6 +121,23 @@ fun startNotificationSettingsIntent(context: Context, activityResultLauncher: Ac
     activityResultLauncher.launch(intent)
 }
 
+fun openAppSettingsPage(
+    activity: Activity,
+    noActivityFoundMessage: String,
+) {
+    try {
+        activity.startActivity(
+            Intent().apply {
+                action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                data = Uri.fromParts("package", activity.packageName, null)
+            }
+        )
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        activity.toast(noActivityFoundMessage)
+    }
+}
+
 /**
  * Shows notification system settings for the given channel id.
  */

libraries/permissions/api/build.gradle.kts

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+}
+
+android {
+    namespace = "io.element.android.libraries.permissions.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+}

libraries/permissions/api/src/main/kotlin/io/element/android/libraries/permissions/api/PermissionsEvents.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.api
+
+sealed interface PermissionsEvents {
+    object OpenSystemDialog : PermissionsEvents
+    object CloseDialog : PermissionsEvents
+    object OpenSystemSettings : PermissionsEvents
+}

libraries/permissions/api/src/main/kotlin/io/element/android/libraries/permissions/api/PermissionsPresenter.kt

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.api
+
+import io.element.android.libraries.architecture.Presenter
+
+interface PermissionsPresenter : Presenter<PermissionsState> {
+    fun setParameter(permission: String)
+}

libraries/permissions/api/src/main/kotlin/io/element/android/libraries/permissions/api/PermissionsState.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.api
+
+data class PermissionsState(
+    // For instance Manifest.permission.POST_NOTIFICATIONS
+    val permission: String,
+    val permissionGranted: Boolean,
+    val shouldShowRationale: Boolean,
+    val showDialog: Boolean,
+    val permissionAlreadyAsked: Boolean,
+    // If true, there is no need to ask again, the system dialog will not be displayed
+    val permissionAlreadyDenied: Boolean,
+    val eventSink: (PermissionsEvents) -> Unit
+)

libraries/permissions/api/src/main/kotlin/io/element/android/libraries/permissions/api/PermissionsView.kt

@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.api
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import io.element.android.libraries.designsystem.components.dialogs.ConfirmationDialog
+import io.element.android.libraries.designsystem.preview.ElementPreviewDark
+import io.element.android.libraries.designsystem.preview.ElementPreviewLight
+
+@Composable
+fun PermissionsView(
+    state: PermissionsState,
+    modifier: Modifier = Modifier,
+    openSystemSettings: () -> Unit = {},
+) {
+    if (state.showDialog.not()) return
+
+    if (state.permissionGranted) {
+        // Notification Granted, nothing to do
+    } else if (state.permissionAlreadyDenied) {
+        // In this case, tell the user to go to the settings
+        ConfirmationDialog(
+            modifier = modifier,
+            title = "System",
+            content = "In order to let the application display notification, please grant the permission to the system settings",
+            submitText = "Open settings",
+            onSubmitClicked = {
+                state.eventSink.invoke(PermissionsEvents.OpenSystemSettings)
+                openSystemSettings()
+            },
+            onDismiss = { state.eventSink.invoke(PermissionsEvents.CloseDialog) },
+        )
+    } else {
+        val textToShow = if (state.shouldShowRationale) {
+            // TODO Move to state
+            // If the user has denied the permission but the rationale can be shown,
+            // then gently explain why the app requires this permission
+            // permissions_rationale_msg_notification
+            "To be able to receive notifications, please grant the permission. Else you will not be able to be alerted if you've got new messages."
+        } else {
+            // TODO Move to state
+            // If it's the first time the user lands on this feature, or the user
+            // doesn't want to be asked again for this permission, explain that the
+            // permission is required
+            "To be able to receive notifications, please grant the permission."
+        }
+        ConfirmationDialog(
+            modifier = modifier,
+            title = "Notifications",
+            content = textToShow,
+            submitText = "Request permission",
+            onSubmitClicked = {
+                state.eventSink.invoke(PermissionsEvents.OpenSystemDialog)
+            },
+            onCancelClicked = {
+                state.eventSink.invoke(PermissionsEvents.CloseDialog)
+            },
+            onDismiss = {}
+        )
+    }
+}
+
+@Preview
+@Composable
+fun PermissionsViewLightPreview(@PreviewParameter(PermissionsViewStateProvider::class) state: PermissionsState) =
+    ElementPreviewLight { ContentToPreview(state) }
+
+@Preview
+@Composable
+fun PermissionsViewDarkPreview(@PreviewParameter(PermissionsViewStateProvider::class) state: PermissionsState) =
+    ElementPreviewDark { ContentToPreview(state) }
+
+@Composable
+private fun ContentToPreview(state: PermissionsState) {
+    PermissionsView(
+        state = state,
+    )
+}

libraries/permissions/api/src/main/kotlin/io/element/android/libraries/permissions/api/PermissionsViewStateProvider.kt

@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.api
+
+import android.Manifest
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+open class PermissionsViewStateProvider : PreviewParameterProvider<PermissionsState> {
+    override val values: Sequence<PermissionsState>
+        get() = sequenceOf(
+            aPermissionsState(),
+            // Add other state here
+        )
+}
+
+fun aPermissionsState() = PermissionsState(
+    permission = Manifest.permission.INTERNET,
+    permissionGranted = false,
+    shouldShowRationale = false,
+    showDialog = true,
+    permissionAlreadyAsked = false,
+    permissionAlreadyDenied = false,
+    eventSink = {}
+)

libraries/permissions/api/src/main/kotlin/io/element/android/libraries/permissions/api/Util.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.api
+
+fun createDummyPostNotificationPermissionsState() = PermissionsState(
+    permission = "Manifest.permission.POST_NOTIFICATIONS",
+    permissionGranted = true,
+    shouldShowRationale = false,
+    showDialog = false,
+    permissionAlreadyAsked = false,
+    permissionAlreadyDenied = false,
+    eventSink = { }
+)

libraries/permissions/impl/build.gradle.kts

@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// TODO: Remove once https://youtrack.jetbrains.com/issue/KTIJ-19369 is fixed
+@Suppress("DSL_SCOPE_VIOLATION")
+plugins {
+    id("io.element.android-compose-library")
+    alias(libs.plugins.anvil)
+    alias(libs.plugins.ksp)
+}
+
+android {
+    namespace = "io.element.android.libraries.permissions.impl"
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+anvil {
+    generateDaggerFactories.set(true)
+}
+
+dependencies {
+    anvil(projects.anvilcodegen)
+    implementation(projects.anvilannotations)
+
+    implementation(libs.accompanist.permission)
+    implementation(libs.androidx.datastore.preferences)
+
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.elementresources)
+    implementation(projects.libraries.uiStrings)
+    api(projects.libraries.permissions.api)
+
+    testImplementation(libs.test.junit)
+    testImplementation(libs.coroutines.test)
+    testImplementation(libs.molecule.runtime)
+    testImplementation(libs.test.truth)
+    testImplementation(libs.test.turbine)
+    testImplementation(projects.libraries.matrix.test)
+
+
+    androidTestImplementation(libs.test.junitext)
+
+    ksp(libs.showkase.processor)
+}

libraries/permissions/impl/src/main/kotlin/io/element/android/libraries/permissions/impl/DefaultPermissionsPresenter.kt

@@ -0,0 +1,139 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.impl
+
+import android.annotation.SuppressLint
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.collectAsState
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import com.google.accompanist.permissions.ExperimentalPermissionsApi
+import com.google.accompanist.permissions.PermissionState
+import com.google.accompanist.permissions.isGranted
+import com.google.accompanist.permissions.rememberPermissionState
+import com.google.accompanist.permissions.shouldShowRationale
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.permissions.api.PermissionsEvents
+import io.element.android.libraries.permissions.api.PermissionsPresenter
+import io.element.android.libraries.permissions.api.PermissionsState
+import kotlinx.coroutines.launch
+import timber.log.Timber
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultPermissionsPresenter @Inject constructor(
+    private val permissionsStore: PermissionsStore,
+) : PermissionsPresenter {
+
+    private lateinit var permission: String
+
+    // TODO Move to the constructor.
+    override fun setParameter(permission: String) {
+        this.permission = permission
+    }
+
+    @OptIn(ExperimentalPermissionsApi::class)
+    @SuppressLint("InlinedApi")
+    @Composable
+    override fun present(): PermissionsState {
+        val localCoroutineScope = rememberCoroutineScope()
+
+        // To reset the store: resetStore()
+
+        val isAlreadyDenied: Boolean by permissionsStore
+            .isPermissionDenied(permission)
+            .collectAsState(initial = false)
+
+        val isAlreadyAsked: Boolean by permissionsStore
+            .isPermissionAsked(permission)
+            .collectAsState(initial = false)
+
+        var permissionState: PermissionState? = null
+
+        fun onPermissionResult(result: Boolean) {
+            Timber.tag("PERMISSION").w("onPermissionResult: $result")
+            localCoroutineScope.launch {
+                permissionsStore.setPermissionAsked(permission, true)
+            }
+
+            if (!result) {
+                // Should show rational true -> denied.
+                if (permissionState?.status?.shouldShowRationale == true) {
+                    Timber.tag("PERMISSION").w("onPermissionResult: reset the store")
+                    localCoroutineScope.launch {
+                        permissionsStore.setPermissionDenied(permission, true)
+                    }
+                }
+            }
+        }
+
+        permissionState = rememberPermissionState(
+            permission = permission,
+            onPermissionResult = ::onPermissionResult
+        )
+
+        LaunchedEffect(this) {
+            if (permissionState.status.isGranted) {
+                // User may have granted permission from the settings, to reset the store regarding this permission
+                permissionsStore.resetPermission(permission)
+            }
+        }
+
+        val showDialog = rememberSaveable { mutableStateOf(true) }
+
+        fun handleEvents(event: PermissionsEvents) {
+            Timber.tag("PERMISSION").w("New event: $event")
+            when (event) {
+                PermissionsEvents.CloseDialog -> {
+                    showDialog.value = false
+                }
+                PermissionsEvents.OpenSystemDialog -> {
+                    permissionState.launchPermissionRequest()
+                    showDialog.value = false
+                }
+                PermissionsEvents.OpenSystemSettings -> {
+                    showDialog.value = false
+                }
+            }
+        }
+
+        return PermissionsState(
+            permission = permissionState.permission,
+            permissionGranted = permissionState.status.isGranted,
+            shouldShowRationale = permissionState.status.shouldShowRationale,
+            showDialog = showDialog.value,
+            permissionAlreadyAsked = isAlreadyAsked,
+            permissionAlreadyDenied = isAlreadyDenied,
+            eventSink = ::handleEvents
+        ).also {
+            Timber.tag("PERMISSION").w("New state: $it")
+        }
+    }
+
+    @Composable
+    private fun resetStore() {
+        LaunchedEffect(this@DefaultPermissionsPresenter) {
+            launch {
+                permissionsStore.resetStore()
+            }
+        }
+    }
+}

libraries/permissions/impl/src/main/kotlin/io/element/android/libraries/permissions/impl/DefaultPermissionsStore.kt

@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.impl
+
+import android.content.Context
+import androidx.datastore.core.DataStore
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.booleanPreferencesKey
+import androidx.datastore.preferences.core.edit
+import androidx.datastore.preferences.preferencesDataStore
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.core.bool.orFalse
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.map
+import javax.inject.Inject
+
+private val Context.dataStore: DataStore<Preferences> by preferencesDataStore(name = "permissions_store")
+
+@ContributesBinding(AppScope::class)
+class DefaultPermissionsStore @Inject constructor(
+    @ApplicationContext context: Context,
+) : PermissionsStore {
+    private val store = context.dataStore
+
+    override suspend fun setPermissionDenied(permission: String, value: Boolean) {
+        store.edit { prefs ->
+            prefs[getDeniedPreferenceKey(permission)] = value
+        }
+    }
+
+    override fun isPermissionDenied(permission: String): Flow<Boolean> {
+        return store.data.map {
+            it[getDeniedPreferenceKey(permission)].orFalse()
+        }
+    }
+
+    override suspend fun setPermissionAsked(permission: String, value: Boolean) {
+        store.edit { prefs ->
+            prefs[getAskedPreferenceKey(permission)] = value
+        }
+    }
+
+    override fun isPermissionAsked(permission: String): Flow<Boolean> {
+        return store.data.map {
+            it[getAskedPreferenceKey(permission)].orFalse()
+        }
+    }
+
+    override suspend fun resetPermission(permission: String) {
+        setPermissionAsked(permission, false)
+        setPermissionDenied(permission, false)
+    }
+
+    override suspend fun resetStore() {
+        store.edit { it.clear() }
+    }
+
+    private fun getDeniedPreferenceKey(permission: String) = booleanPreferencesKey("${permission}_denied")
+    private fun getAskedPreferenceKey(permission: String) = booleanPreferencesKey("${permission}_asked")
+}

libraries/permissions/impl/src/main/kotlin/io/element/android/libraries/permissions/impl/PermissionsStore.kt

@@ -0,0 +1,32 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.impl
+
+import kotlinx.coroutines.flow.Flow
+
+interface PermissionsStore {
+    suspend fun setPermissionDenied(permission: String, value: Boolean)
+    fun isPermissionDenied(permission: String): Flow<Boolean>
+
+    suspend fun setPermissionAsked(permission: String, value: Boolean)
+    fun isPermissionAsked(permission: String): Flow<Boolean>
+
+    suspend fun resetPermission(permission: String)
+
+    // To debug
+    suspend fun resetStore()
+}

libraries/permissions/impl/src/test/kotlin/io/element/android/libraries/permissions/impl/DefaultPermissionsPresenterTest.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package io.element.android.libraries.permissions.impl
+
+import app.cash.molecule.RecompositionClock
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+const val A_PERMISSION = "A_PERMISSION"
+
+class DefaultPermissionsPresenterTest {
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = DefaultPermissionsPresenter(
+            InMemoryPermissionsStore()
+        )
+        moleculeFlow(RecompositionClock.Immediate) {
+            presenter.setParameter(A_PERMISSION)
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.showDialog).isTrue()
+        }
+    }
+}

libraries/permissions/impl/src/test/kotlin/io/element/android/libraries/permissions/impl/InMemoryPermissionsStore.kt

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.permissions.impl
+
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableStateFlow
+
+class InMemoryPermissionsStore(
+    permissionDenied: Boolean = false,
+    permissionAsked: Boolean = false,
+) : PermissionsStore {
+    private val permissionDeniedFlow = MutableStateFlow(permissionDenied)
+    private val permissionAskedFlow = MutableStateFlow(permissionAsked)
+
+    override suspend fun setPermissionDenied(permission: String, value: Boolean) {
+        permissionDeniedFlow.value = value
+    }
+
+    override fun isPermissionDenied(permission: String): Flow<Boolean> = permissionDeniedFlow
+
+    override suspend fun setPermissionAsked(permission: String, value: Boolean) {
+        permissionAskedFlow.value
+    }
+
+    override fun isPermissionAsked(permission: String): Flow<Boolean> = permissionAskedFlow
+
+    override suspend fun resetPermission(permission: String) {
+        setPermissionAsked(permission, false)
+        setPermissionDenied(permission, false)
+    }
+
+    override suspend fun resetStore() {
+    }
+}

libraries/push/impl/build.gradle.kts

@@ -43,7 +43,7 @@ dependencies {
     implementation(projects.libraries.androidutils)
     implementation(projects.libraries.network)
     implementation(projects.libraries.matrix.api)
-    implementation(projects.libraries.push.api)
+    api(projects.libraries.push.api)
 
     implementation(projects.services.analytics.api)
     implementation(projects.services.toolbox.api)

libraries/push/impl/src/main/kotlin/io/element/android/libraries/push/impl/permission/NotificationPermissionManager.kt

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2022 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.libraries.push.impl.permission
+
+import android.Manifest
+import android.app.Activity
+import android.content.Context
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.core.content.ContextCompat
+import io.element.android.libraries.di.ApplicationContext
+import io.element.android.services.toolbox.api.sdk.BuildVersionSdkIntProvider
+import javax.inject.Inject
+
+// TODO EAx move
+class NotificationPermissionManager @Inject constructor(
+    private val sdkIntProvider: BuildVersionSdkIntProvider,
+    @ApplicationContext private val context: Context,
+) {
+
+    @RequiresApi(Build.VERSION_CODES.TIRAMISU)
+    fun isPermissionGranted(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.POST_NOTIFICATIONS
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    /*
+    fun eventuallyRequestPermission(
+            activity: Activity,
+            requestPermissionLauncher: ActivityResultLauncher<Array<String>>,
+            showRationale: Boolean = true,
+            ignorePreference: Boolean = false,
+    ) {
+        if (!sdkIntProvider.isAtLeast(Build.VERSION_CODES.TIRAMISU)) return
+        // if (!vectorPreferences.areNotificationEnabledForDevice() && !ignorePreference) return
+        checkPermissions(
+                listOf(Manifest.permission.POST_NOTIFICATIONS),
+                activity,
+                activityResultLauncher = requestPermissionLauncher,
+                if (showRationale) R.string.permissions_rationale_msg_notification else 0
+        )
+    }
+    */
+
+    fun eventuallyRevokePermission(
+        activity: Activity,
+    ) {
+        if (!sdkIntProvider.isAtLeast(Build.VERSION_CODES.TIRAMISU)) return
+        activity.revokeSelfPermissionOnKill(Manifest.permission.POST_NOTIFICATIONS)
+    }
+}