Pin: rename feature pin to lockscreen

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/DefaultLockScreenEntryPoint.kt

@@ -0,0 +1,33 @@
+/*
+ * 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.features.lockscreen.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.lockscreen.api.LockScreenEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+@ContributesBinding(AppScope::class)
+class DefaultLockScreenEntryPoint @Inject constructor() : LockScreenEntryPoint {
+
+    override fun createNode(parentNode: Node, buildContext: BuildContext): Node {
+        return parentNode.createNode<LockScreenFlowNode>(buildContext)
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/LockScreenFlowNode.kt

@@ -0,0 +1,78 @@
+/*
+ * 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.features.lockscreen.impl
+
+import android.os.Parcelable
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.navmodel.backstack.BackStack
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.features.lockscreen.impl.auth.PinAuthenticationNode
+import io.element.android.features.lockscreen.impl.create.CreatePinNode
+import io.element.android.libraries.architecture.BackstackNode
+import io.element.android.libraries.architecture.animation.rememberDefaultTransitionHandler
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.AppScope
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(AppScope::class)
+class LockScreenFlowNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+) : BackstackNode<LockScreenFlowNode.NavTarget>(
+    backstack = BackStack(
+        initialElement = NavTarget.Auth,
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins,
+) {
+
+    sealed interface NavTarget : Parcelable {
+        @Parcelize
+        data object Auth : NavTarget
+
+        @Parcelize
+        data object Create : NavTarget
+    }
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        return when (navTarget) {
+            NavTarget.Auth -> {
+                createNode<PinAuthenticationNode>(buildContext)
+            }
+            NavTarget.Create -> {
+                createNode<CreatePinNode>(buildContext)
+            }
+        }
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Children(
+            navModel = backstack,
+            modifier = modifier,
+            transitionHandler = rememberDefaultTransitionHandler(),
+        )
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/auth/PinAuthenticationEvents.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.features.lockscreen.impl.auth
+
+sealed interface PinAuthenticationEvents {
+    data object Unlock : PinAuthenticationEvents
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/auth/PinAuthenticationNode.kt

@@ -0,0 +1,44 @@
+/*
+ * 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.features.lockscreen.impl.auth
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.di.AppScope
+
+@ContributesNode(AppScope::class)
+class PinAuthenticationNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: PinAuthenticationPresenter,
+) : Node(buildContext, plugins = plugins) {
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        PinAuthenticationView(
+            state = state,
+            modifier = modifier
+        )
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/auth/PinAuthenticationPresenter.kt

@@ -0,0 +1,43 @@
+/*
+ * 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.features.lockscreen.impl.auth
+
+import androidx.compose.runtime.Composable
+import io.element.android.features.lockscreen.api.LockScreenStateService
+import io.element.android.libraries.architecture.Presenter
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+class PinAuthenticationPresenter @Inject constructor(
+    private val pinStateService: LockScreenStateService,
+    private val coroutineScope: CoroutineScope,
+) : Presenter<PinAuthenticationState> {
+
+    @Composable
+    override fun present(): PinAuthenticationState {
+
+        fun handleEvents(event: PinAuthenticationEvents) {
+            when (event) {
+                PinAuthenticationEvents.Unlock -> coroutineScope.launch { pinStateService.unlock() }
+            }
+        }
+        return PinAuthenticationState(
+            eventSink = ::handleEvents
+        )
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/auth/PinAuthenticationState.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.features.lockscreen.impl.auth
+
+data class PinAuthenticationState(
+    val eventSink: (PinAuthenticationEvents) -> Unit
+)

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/auth/PinAuthenticationStateProvider.kt

@@ -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.
+ */
+
+package io.element.android.features.lockscreen.impl.auth
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+open class PinAuthenticationStateProvider : PreviewParameterProvider<PinAuthenticationState> {
+    override val values: Sequence<PinAuthenticationState>
+        get() = sequenceOf(
+            aPinAuthenticationState(),
+        )
+}
+
+fun aPinAuthenticationState() = PinAuthenticationState(
+    eventSink = {}
+)

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/auth/PinAuthenticationView.kt

@@ -0,0 +1,84 @@
+/*
+ * 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.features.lockscreen.impl.auth
+
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.layout.systemBarsPadding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.filled.Lock
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.atomic.molecules.IconTitleSubtitleMolecule
+import io.element.android.libraries.designsystem.atomic.pages.HeaderFooterPage
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.Button
+import io.element.android.libraries.designsystem.theme.components.Surface
+
+@Composable
+fun PinAuthenticationView(
+    state: PinAuthenticationState,
+    modifier: Modifier = Modifier,
+) {
+    Surface(modifier) {
+        HeaderFooterPage(
+            modifier = Modifier
+                .systemBarsPadding()
+                .fillMaxSize(),
+            header = { PinAuthenticationHeader(modifier = Modifier.padding(top = 60.dp, bottom = 12.dp)) },
+            footer = { PinAuthenticationFooter(state) },
+        )
+    }
+}
+
+@Composable
+private fun PinAuthenticationHeader(
+    modifier: Modifier = Modifier,
+) {
+    IconTitleSubtitleMolecule(
+        modifier = modifier,
+        title = "Element X is locked",
+        subTitle = null,
+        iconImageVector = Icons.Default.Lock,
+    )
+}
+
+@Composable
+private fun PinAuthenticationFooter(state: PinAuthenticationState) {
+    Button(
+        modifier = Modifier.fillMaxWidth(),
+        text = "Unlock",
+        onClick = {
+            state.eventSink(PinAuthenticationEvents.Unlock)
+        }
+    )
+}
+
+@Composable
+@PreviewsDayNight
+internal fun PinAuthenticationViewPreview(@PreviewParameter(PinAuthenticationStateProvider::class) state: PinAuthenticationState) {
+    ElementPreview {
+        PinAuthenticationView(
+            state = state,
+        )
+    }
+}
+

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/create/CreatePinEvents.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.features.lockscreen.impl.create
+
+sealed interface CreatePinEvents {
+    object MyEvent : CreatePinEvents
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/create/CreatePinNode.kt

@@ -0,0 +1,44 @@
+/*
+ * 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.features.lockscreen.impl.create
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dagger.assisted.Assisted
+import dagger.assisted.AssistedInject
+import io.element.android.anvilannotations.ContributesNode
+import io.element.android.libraries.di.AppScope
+
+@ContributesNode(AppScope::class)
+class CreatePinNode @AssistedInject constructor(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: CreatePinPresenter,
+) : Node(buildContext, plugins = plugins) {
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        CreatePinView(
+            state = state,
+            modifier = modifier
+        )
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/create/CreatePinPresenter.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.features.lockscreen.impl.create
+
+import androidx.compose.runtime.Composable
+import io.element.android.libraries.architecture.Presenter
+import javax.inject.Inject
+
+class CreatePinPresenter @Inject constructor() : Presenter<CreatePinState> {
+
+    @Composable
+    override fun present(): CreatePinState {
+
+        fun handleEvents(event: CreatePinEvents) {
+            when (event) {
+                CreatePinEvents.MyEvent -> Unit
+            }
+        }
+
+        return CreatePinState(
+            eventSink = ::handleEvents
+        )
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/create/CreatePinState.kt

@@ -0,0 +1,21 @@
+/*
+ * 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.features.lockscreen.impl.create
+
+data class CreatePinState(
+    val eventSink: (CreatePinEvents) -> Unit
+)

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/create/CreatePinStateProvider.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.features.lockscreen.impl.create
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+
+open class CreatePinStateProvider : PreviewParameterProvider<CreatePinState> {
+    override val values: Sequence<CreatePinState>
+        get() = sequenceOf(
+            aCreatePinState(),
+            // Add other states here
+        )
+}
+
+fun aCreatePinState() = CreatePinState(
+    eventSink = {}
+)

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/create/CreatePinView.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.features.lockscreen.impl.create
+
+import androidx.compose.foundation.layout.Box
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Alignment
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.Text
+import timber.log.Timber
+
+@Composable
+fun CreatePinView(
+    state: CreatePinState,
+    modifier: Modifier = Modifier,
+) {
+    Timber.d("CreatePinView: $state")
+    Box(modifier, contentAlignment = Alignment.Center) {
+        Text(
+            "CreatePin feature view",
+            color = MaterialTheme.colorScheme.primary,
+        )
+    }
+}
+
+@Composable
+@PreviewsDayNight
+internal fun CreatePinViewPreview(@PreviewParameter(CreatePinStateProvider::class) state: CreatePinState) {
+    ElementPreview {
+        CreatePinView(
+            state = state,
+        )
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/pin/DefaultPinCodeManager.kt

@@ -0,0 +1,70 @@
+/*
+ * 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.features.lockscreen.impl.pin
+
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.lockscreen.impl.pin.storage.PinCodeStore
+import io.element.android.libraries.cryptography.api.CryptoService
+import io.element.android.libraries.cryptography.api.EncryptionResult
+import io.element.android.libraries.di.AppScope
+import javax.inject.Inject
+
+private const val SECRET_KEY_ALIAS = "SECRET_KEY_ALIAS_PIN_CODE"
+
+@ContributesBinding(AppScope::class)
+class DefaultPinCodeManager @Inject constructor(
+    private val cryptoService: CryptoService,
+    private val pinCodeStore: PinCodeStore,
+) : PinCodeManager {
+
+    override suspend fun isPinCodeAvailable(): Boolean {
+        return pinCodeStore.hasPinCode()
+    }
+
+    override suspend fun createPinCode(pinCode: String) {
+        val secretKey = cryptoService.getOrCreateSecretKey(SECRET_KEY_ALIAS)
+        val encryptedPinCode = cryptoService.encrypt(secretKey, pinCode.toByteArray()).toBase64()
+        pinCodeStore.saveEncryptedPinCode(encryptedPinCode)
+    }
+
+    override suspend fun verifyPinCode(pinCode: String): Boolean {
+        val encryptedPinCode = pinCodeStore.getEncryptedCode() ?: return false
+        return try {
+            val secretKey = cryptoService.getOrCreateSecretKey(SECRET_KEY_ALIAS)
+            val decryptedPinCode = cryptoService.decrypt(secretKey, EncryptionResult.fromBase64(encryptedPinCode))
+            decryptedPinCode.contentEquals(pinCode.toByteArray())
+        } catch (failure: Throwable) {
+            false
+        }
+    }
+
+    override suspend fun deletePinCode() {
+        pinCodeStore.deleteEncryptedPinCode()
+    }
+
+    override suspend fun getRemainingPinCodeAttemptsNumber(): Int {
+        return pinCodeStore.getRemainingPinCodeAttemptsNumber()
+    }
+
+    override suspend fun onWrongPin(): Int {
+        return pinCodeStore.onWrongPin()
+    }
+
+    override suspend fun resetCounter() {
+        pinCodeStore.resetCounter()
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/pin/PinCodeManager.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.features.lockscreen.impl.pin
+
+/**
+ * This interface is the main interface to manage the pin code.
+ * Implementation should take care of encrypting the pin code and storing it.
+ */
+interface PinCodeManager {
+    /**
+     * @return true if a pin code is available.
+     */
+    suspend fun isPinCodeAvailable(): Boolean
+
+    /**
+     * creates a new encrypted pin code.
+     * @param pinCode the clear pin code to create
+     */
+    suspend fun createPinCode(pinCode: String)
+
+    /**
+     * @return true if the pin code is correct
+     */
+    suspend fun verifyPinCode(pinCode: String): Boolean
+
+    /**
+     * deletes the previously created pin code
+     */
+    suspend fun deletePinCode()
+
+    /**
+     * @return the number of remaining attempts before the pin code is blocked
+     */
+    suspend fun getRemainingPinCodeAttemptsNumber(): Int
+
+    /**
+     * @return the number of remaining attempts before the pin code is blocked
+     */
+    suspend fun onWrongPin(): Int
+
+    /**
+     * Resets the counter of attempts for PIN code.
+     */
+    suspend fun resetCounter()
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/pin/storage/EncryptedPinCodeStorage.kt

@@ -0,0 +1,43 @@
+/*
+ * 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.features.lockscreen.impl.pin.storage
+
+/**
+ * Should be implemented by any class that provides access to the encrypted PIN code.
+ * All methods are suspending in case there are async IO operations involved.
+ */
+interface EncryptedPinCodeStorage {
+    /**
+     * Returns the encrypted PIN code.
+     */
+    suspend fun getEncryptedCode(): String?
+
+    /**
+     * Saves the encrypted PIN code to some persistable storage.
+     */
+    suspend fun saveEncryptedPinCode(pinCode: String)
+
+    /**
+     * Deletes the PIN code from some persistable storage.
+     */
+    suspend fun deleteEncryptedPinCode()
+
+    /**
+     * Returns whether the PIN code is stored or not.
+     */
+    suspend fun hasPinCode(): Boolean
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/pin/storage/PinCodeStore.kt

@@ -0,0 +1,52 @@
+/*
+ * 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.features.lockscreen.impl.pin.storage
+
+interface PinCodeStore : EncryptedPinCodeStorage {
+
+    interface Listener {
+        fun onPinSetUpChange(isConfigured: Boolean)
+    }
+
+    /**
+     * Returns the remaining PIN code attempts. When this reaches 0 the PIN code access won't be available for some time.
+     */
+    suspend fun getRemainingPinCodeAttemptsNumber(): Int
+
+    /**
+     * Should decrement the number of remaining PIN code attempts.
+     * @return The remaining attempts.
+     */
+    suspend fun onWrongPin(): Int
+
+    /**
+     * Resets the counter of attempts for PIN code and biometric access.
+     */
+    suspend fun resetCounter()
+
+    /**
+     * Adds a listener to be notified when the PIN code us created or removed.
+     */
+    fun addListener(listener: Listener)
+
+    /**
+     * Removes a listener to be notified when the PIN code us created or removed.
+     */
+    fun removeListener(listener: Listener)
+}
+
+

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/pin/storage/SharedPreferencesPinCodeStore.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.features.lockscreen.impl.pin.storage
+
+import android.content.SharedPreferences
+import androidx.core.content.edit
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.core.coroutine.CoroutineDispatchers
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.SingleIn
+import kotlinx.coroutines.withContext
+import java.util.concurrent.CopyOnWriteArrayList
+import javax.inject.Inject
+
+private const val ENCODED_PIN_CODE_KEY = "ENCODED_PIN_CODE_KEY"
+private const val REMAINING_PIN_CODE_ATTEMPTS_KEY = "REMAINING_PIN_CODE_ATTEMPTS_KEY"
+private const val MAX_PIN_CODE_ATTEMPTS_NUMBER_BEFORE_LOGOUT = 3
+
+@SingleIn(AppScope::class)
+@ContributesBinding(AppScope::class)
+class SharedPreferencesPinCodeStore @Inject constructor(
+    private val dispatchers: CoroutineDispatchers,
+    private val sharedPreferences: SharedPreferences,
+) : PinCodeStore {
+
+    private val listeners = CopyOnWriteArrayList<PinCodeStore.Listener>()
+
+    override suspend fun getEncryptedCode(): String? = withContext(dispatchers.io) {
+        sharedPreferences.getString(ENCODED_PIN_CODE_KEY, null)
+    }
+
+    override suspend fun saveEncryptedPinCode(pinCode: String) = withContext(dispatchers.io) {
+        sharedPreferences.edit {
+            putString(ENCODED_PIN_CODE_KEY, pinCode)
+        }
+        withContext(dispatchers.main) {
+            listeners.forEach { it.onPinSetUpChange(isConfigured = true) }
+        }
+    }
+
+    override suspend fun deleteEncryptedPinCode() = withContext(dispatchers.io) {
+        // Also reset the counters
+        resetCounter()
+        sharedPreferences.edit {
+            remove(ENCODED_PIN_CODE_KEY)
+        }
+        withContext(dispatchers.main) {
+            listeners.forEach { it.onPinSetUpChange(isConfigured = false) }
+        }
+    }
+
+    override suspend fun hasPinCode(): Boolean = withContext(dispatchers.io) {
+        sharedPreferences.contains(ENCODED_PIN_CODE_KEY)
+    }
+
+    override suspend fun getRemainingPinCodeAttemptsNumber(): Int = withContext(dispatchers.io) {
+        sharedPreferences.getInt(REMAINING_PIN_CODE_ATTEMPTS_KEY, MAX_PIN_CODE_ATTEMPTS_NUMBER_BEFORE_LOGOUT)
+    }
+
+    override suspend fun onWrongPin(): Int = withContext(dispatchers.io) {
+        val remaining = getRemainingPinCodeAttemptsNumber() - 1
+        sharedPreferences.edit {
+            putInt(REMAINING_PIN_CODE_ATTEMPTS_KEY, remaining)
+        }
+        remaining
+    }
+
+    override suspend fun resetCounter() = withContext(dispatchers.io) {
+        sharedPreferences.edit {
+            remove(REMAINING_PIN_CODE_ATTEMPTS_KEY)
+        }
+    }
+
+    override fun addListener(listener: PinCodeStore.Listener) {
+        listeners.add(listener)
+    }
+
+    override fun removeListener(listener: PinCodeStore.Listener) {
+        listeners.remove(listener)
+    }
+}

features/lockscreen/impl/src/main/kotlin/io/element/android/features/lockscreen/impl/state/DefaultLockScreenStateService.kt

@@ -0,0 +1,65 @@
+/*
+ * 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.features.lockscreen.impl.state
+
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.features.lockscreen.api.LockScreenState
+import io.element.android.features.lockscreen.api.LockScreenStateService
+import io.element.android.libraries.di.AppScope
+import io.element.android.libraries.di.SingleIn
+import io.element.android.libraries.featureflag.api.FeatureFlagService
+import io.element.android.libraries.featureflag.api.FeatureFlags
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.coroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+private const val GRACE_PERIOD_IN_MILLIS = 90 * 1000L
+
+@SingleIn(AppScope::class)
+@ContributesBinding(AppScope::class)
+class DefaultLockScreenStateService @Inject constructor(
+    private val featureFlagService: FeatureFlagService,
+) : LockScreenStateService {
+
+    private val _lockScreenState = MutableStateFlow<LockScreenState>(LockScreenState.Unlocked)
+    override val state: StateFlow<LockScreenState> = _lockScreenState
+
+    private var lockJob: Job? = null
+
+    override suspend fun unlock() {
+        if (featureFlagService.isFeatureEnabled(FeatureFlags.PinUnlock)) {
+            _lockScreenState.value = LockScreenState.Unlocked
+        }
+    }
+
+    override suspend fun entersForeground() {
+        lockJob?.cancel()
+    }
+
+    override suspend fun entersBackground() = coroutineScope {
+        lockJob = launch {
+            if (featureFlagService.isFeatureEnabled(FeatureFlags.PinUnlock)) {
+                delay(GRACE_PERIOD_IN_MILLIS)
+                _lockScreenState.value = LockScreenState.Locked
+            }
+        }
+    }
+}