First Commit

libraries/accountselect/api/build.gradle.kts

@@ -0,0 +1,19 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.libraries.accountselect.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+}

libraries/accountselect/api/src/main/kotlin/io/element/android/libraries/accountselect/api/AccountSelectEntryPoint.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.api
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import io.element.android.libraries.architecture.FeatureEntryPoint
+import io.element.android.libraries.matrix.api.core.SessionId
+
+interface AccountSelectEntryPoint : FeatureEntryPoint {
+    fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        callback: Callback,
+    ): Node
+
+    interface Callback : Plugin {
+        fun onAccountSelected(sessionId: SessionId)
+        fun onCancel()
+    }
+}

libraries/accountselect/impl/build.gradle.kts

@@ -0,0 +1,36 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+plugins {
+    id("io.element.android-compose-library")
+}
+
+android {
+    namespace = "io.element.android.libraries.accountselect.impl"
+}
+
+setupDependencyInjection()
+
+dependencies {
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.sessionStorage.api)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.uiStrings)
+    api(projects.libraries.accountselect.api)
+
+    testCommonDependencies(libs)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.sessionStorage.test)
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectNode.kt

@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+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 dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedInject
+import io.element.android.annotations.ContributesNode
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
+import io.element.android.libraries.architecture.callback
+
+@ContributesNode(AppScope::class)
+@AssistedInject
+class AccountSelectNode(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    private val presenter: AccountSelectPresenter,
+) : Node(buildContext, plugins = plugins) {
+    private val callback: AccountSelectEntryPoint.Callback = callback()
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        val state = presenter.present()
+        AccountSelectView(
+            state = state,
+            onDismiss = callback::onCancel,
+            onSelectAccount = callback::onAccountSelected,
+            modifier = modifier,
+        )
+    }
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectPresenter.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.produceState
+import dev.zacsweers.metro.Inject
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.matrix.api.core.UserId
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import kotlinx.collections.immutable.ImmutableList
+import kotlinx.collections.immutable.persistentListOf
+import kotlinx.collections.immutable.toImmutableList
+
+@Inject
+class AccountSelectPresenter(
+    private val sessionStore: SessionStore,
+) : Presenter<AccountSelectState> {
+    @Composable
+    override fun present(): AccountSelectState {
+        val accounts by produceState<ImmutableList<MatrixUser>>(persistentListOf()) {
+            // Do not use sessionStore.sessionsFlow() to not make it change when an account is selected.
+            value = sessionStore.getAllSessions()
+                .map {
+                    MatrixUser(
+                        userId = UserId(it.userId),
+                        displayName = it.userDisplayName,
+                        avatarUrl = it.userAvatarUrl,
+                    )
+                }
+                .toImmutableList()
+        }
+
+        return AccountSelectState(
+            accounts = accounts,
+        )
+    }
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectState.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import kotlinx.collections.immutable.ImmutableList
+
+data class AccountSelectState(
+    val accounts: ImmutableList<MatrixUser>,
+)

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectStateProvider.kt

@@ -0,0 +1,28 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.ui.components.aMatrixUserList
+import kotlinx.collections.immutable.toImmutableList
+
+open class AccountSelectStateProvider : PreviewParameterProvider<AccountSelectState> {
+    override val values: Sequence<AccountSelectState>
+        get() = sequenceOf(
+            anAccountSelectState(),
+            anAccountSelectState(accounts = aMatrixUserList()),
+        )
+}
+
+private fun anAccountSelectState(
+    accounts: List<MatrixUser> = listOf(),
+) = AccountSelectState(
+    accounts = accounts.toImmutableList(),
+)

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectView.kt

@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.activity.compose.BackHandler
+import androidx.compose.foundation.clickable
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.consumeWindowInsets
+import androidx.compose.foundation.layout.fillMaxWidth
+import androidx.compose.foundation.layout.padding
+import androidx.compose.foundation.lazy.LazyColumn
+import androidx.compose.foundation.lazy.items
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import androidx.compose.ui.unit.dp
+import io.element.android.libraries.designsystem.components.button.BackButton
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.designsystem.theme.components.HorizontalDivider
+import io.element.android.libraries.designsystem.theme.components.Scaffold
+import io.element.android.libraries.designsystem.theme.components.TopAppBar
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.libraries.matrix.ui.components.MatrixUserRow
+import io.element.android.libraries.ui.strings.CommonStrings
+
+@Suppress("MultipleEmitters") // False positive
+@OptIn(ExperimentalMaterial3Api::class)
+@Composable
+fun AccountSelectView(
+    state: AccountSelectState,
+    onSelectAccount: (SessionId) -> Unit,
+    onDismiss: () -> Unit,
+    modifier: Modifier = Modifier,
+) {
+    BackHandler(onBack = { onDismiss() })
+    Scaffold(
+        modifier = modifier,
+        topBar = {
+            TopAppBar(
+                titleStr = stringResource(CommonStrings.common_select_account),
+                navigationIcon = {
+                    BackButton(onClick = { onDismiss() })
+                },
+            )
+        }
+    ) { paddingValues ->
+        Column(
+            Modifier
+                .padding(paddingValues)
+                .consumeWindowInsets(paddingValues)
+        ) {
+            LazyColumn {
+                items(state.accounts, key = { it.userId }) { matrixUser ->
+                    Column {
+                        MatrixUserRow(
+                            modifier = Modifier
+                                .fillMaxWidth()
+                                .clickable {
+                                    onSelectAccount(matrixUser.userId)
+                                }
+                                .padding(vertical = 8.dp),
+                            matrixUser = matrixUser,
+                        )
+                        HorizontalDivider()
+                    }
+                }
+            }
+        }
+    }
+}
+
+@PreviewsDayNight
+@Composable
+internal fun AccountSelectViewPreview(@PreviewParameter(AccountSelectStateProvider::class) state: AccountSelectState) = ElementPreview {
+    AccountSelectView(
+        state = state,
+        onSelectAccount = {},
+        onDismiss = {},
+    )
+}

libraries/accountselect/impl/src/main/kotlin/io/element/android/libraries/accountselect/impl/DefaultAccountSelectEntryPoint.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
+import io.element.android.libraries.architecture.createNode
+
+@ContributesBinding(AppScope::class)
+class DefaultAccountSelectEntryPoint : AccountSelectEntryPoint {
+    override fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        callback: AccountSelectEntryPoint.Callback,
+    ): Node {
+        return parentNode.createNode<AccountSelectNode>(buildContext, listOf(callback))
+    }
+}

libraries/accountselect/impl/src/test/kotlin/io/element/android/libraries/accountselect/impl/AccountSelectPresenterTest.kt

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.matrix.api.user.MatrixUser
+import io.element.android.libraries.matrix.test.A_SESSION_ID
+import io.element.android.libraries.matrix.test.A_SESSION_ID_2
+import io.element.android.libraries.sessionstorage.api.SessionStore
+import io.element.android.libraries.sessionstorage.test.InMemorySessionStore
+import io.element.android.libraries.sessionstorage.test.aSessionData
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.test
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class AccountSelectPresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createAccountSelectPresenter()
+        presenter.test {
+            val initialState = awaitItem()
+            assertThat(initialState.accounts).isEmpty()
+        }
+    }
+
+    @Test
+    fun `present - multiple accounts case`() = runTest {
+        val presenter = createAccountSelectPresenter(
+            sessionStore = InMemorySessionStore(
+                initialList = listOf(
+                    aSessionData(sessionId = A_SESSION_ID.value),
+                    aSessionData(
+                        sessionId = A_SESSION_ID_2.value,
+                        userDisplayName = "Bob",
+                        userAvatarUrl = "avatarUrl",
+                    ),
+                )
+            )
+        )
+        presenter.test {
+            skipItems(1)
+            val initialState = awaitItem()
+            assertThat(initialState.accounts).hasSize(2)
+            val firstAccount = initialState.accounts[0]
+            assertThat(firstAccount).isEqualTo(
+                MatrixUser(
+                    userId = A_SESSION_ID,
+                    displayName = null,
+                    avatarUrl = null,
+                )
+            )
+            val secondAccount = initialState.accounts[1]
+            assertThat(secondAccount).isEqualTo(
+                MatrixUser(
+                    userId = A_SESSION_ID_2,
+                    displayName = "Bob",
+                    avatarUrl = "avatarUrl",
+                )
+            )
+        }
+    }
+}
+
+internal fun createAccountSelectPresenter(
+    sessionStore: SessionStore = InMemorySessionStore(),
+) = AccountSelectPresenter(
+    sessionStore = sessionStore,
+)

libraries/accountselect/impl/src/test/kotlin/io/element/android/libraries/accountselect/impl/DefaultAccountSelectEntryPointTest.kt

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.accountselect.impl
+
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import com.bumble.appyx.core.modality.BuildContext
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.accountselect.api.AccountSelectEntryPoint
+import io.element.android.libraries.matrix.api.core.SessionId
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.node.TestParentNode
+import org.junit.Rule
+import org.junit.Test
+
+class DefaultAccountSelectEntryPointTest {
+    @get:Rule
+    val instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @Test
+    fun `test node builder`() {
+        val entryPoint = DefaultAccountSelectEntryPoint()
+        val parentNode = TestParentNode.create { buildContext, plugins ->
+            AccountSelectNode(
+                buildContext = buildContext,
+                plugins = plugins,
+                presenter = createAccountSelectPresenter(),
+            )
+        }
+        val callback = object : AccountSelectEntryPoint.Callback {
+            override fun onAccountSelected(sessionId: SessionId) = lambdaError()
+            override fun onCancel() = lambdaError()
+        }
+        val result = entryPoint.createNode(
+            parentNode = parentNode,
+            buildContext = BuildContext.root(null),
+            callback = callback,
+        )
+        assertThat(result).isInstanceOf(AccountSelectNode::class.java)
+        assertThat(result.plugins).contains(callback)
+    }
+}

libraries/androidutils/.gitignore

@@ -0,0 +1 @@
+/build

libraries/androidutils/build.gradle.kts

@@ -0,0 +1,42 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023, 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+plugins {
+    id("io.element.android-library")
+}
+
+android {
+    namespace = "io.element.android.libraries.androidutils"
+
+    buildFeatures {
+        buildConfig = true
+    }
+}
+
+setupDependencyInjection()
+
+dependencies {
+    implementation(projects.libraries.di)
+
+    implementation(projects.libraries.core)
+    implementation(projects.services.toolbox.api)
+    implementation(libs.timber)
+    implementation(libs.androidx.corektx)
+    implementation(libs.androidx.activity.activity)
+    implementation(libs.androidx.recyclerview)
+    implementation(libs.androidx.exifinterface)
+    implementation(libs.androidx.datastore.preferences)
+    implementation(libs.serialization.json)
+    api(libs.androidx.browser)
+
+    testCommonDependencies(libs)
+    testImplementation(libs.coroutines.core)
+    testImplementation(projects.services.toolbox.test)
+}

libraries/androidutils/src/main/AndroidManifest.xml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (c) 2025 Element Creations Ltd.
+  ~ Copyright 2023 New Vector Ltd.
+  ~
+  ~ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+  ~ Please see LICENSE files in the repository root for full details.
+  -->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.VIBRATE" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+</manifest>

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/assets/AssetReader.kt

@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.assets
+
+import android.content.Context
+import dev.zacsweers.metro.Inject
+import io.element.android.libraries.di.annotations.ApplicationContext
+import timber.log.Timber
+import java.util.concurrent.ConcurrentHashMap
+
+/**
+ * Read asset files.
+ */
+@Inject
+class AssetReader(
+    @ApplicationContext private val context: Context,
+) {
+    private val cache = ConcurrentHashMap<String, String?>()
+
+    /**
+     * Read an asset from resource and return a String or null in case of error.
+     *
+     * @param assetFilename Asset filename
+     * @return the content of the asset file, or null in case of error
+     */
+    fun readAssetFile(assetFilename: String): String? {
+        return cache.getOrPut(assetFilename, {
+            return try {
+                context.assets.open(assetFilename).use { it.bufferedReader().readText() }
+            } catch (e: Exception) {
+                Timber.e(e, "## readAssetFile() failed")
+                null
+            }
+        })
+    }
+
+    fun clearCache() {
+        cache.clear()
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/bitmap/Bitmap.kt

@@ -0,0 +1,88 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2022-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.bitmap
+
+import android.graphics.Bitmap
+import android.graphics.BitmapFactory
+import android.graphics.Matrix
+import androidx.core.graphics.scale
+import androidx.exifinterface.media.ExifInterface
+import java.io.File
+import kotlin.math.min
+
+fun File.writeBitmap(bitmap: Bitmap, format: Bitmap.CompressFormat, quality: Int) {
+    outputStream().use { out ->
+        bitmap.compress(format, quality, out)
+        out.flush()
+    }
+}
+
+/**
+ * Scales the current [Bitmap] to fit the ([maxWidth], [maxHeight]) bounds while keeping aspect ratio.
+ * @throws IllegalStateException if [maxWidth] or [maxHeight] <= 0.
+ */
+fun Bitmap.resizeToMax(maxWidth: Int, maxHeight: Int): Bitmap {
+    // No need to resize
+    if (this.width == maxWidth && this.height == maxHeight) return this
+
+    val aspectRatio = this.width.toFloat() / this.height.toFloat()
+    val useWidth = aspectRatio >= 1
+    val calculatedMaxWidth = min(this.width, maxWidth)
+    val calculatedMinHeight = min(this.height, maxHeight)
+    val width = if (useWidth) calculatedMaxWidth else (calculatedMinHeight * aspectRatio).toInt()
+    val height = if (useWidth) (calculatedMaxWidth / aspectRatio).toInt() else calculatedMinHeight
+    return scale(width, height)
+}
+
+/**
+ * Calculates and returns [BitmapFactory.Options.inSampleSize] given a pair of [desiredWidth] & [desiredHeight]
+ * and the previously read [BitmapFactory.Options.outWidth] & [BitmapFactory.Options.outHeight].
+ */
+fun BitmapFactory.Options.calculateInSampleSize(desiredWidth: Int, desiredHeight: Int): Int {
+    var inSampleSize = 1
+
+    if (outWidth > desiredWidth || outHeight > desiredHeight) {
+        val halfHeight: Int = outHeight / 2
+        val halfWidth: Int = outWidth / 2
+
+        // Calculate the largest inSampleSize value that is a power of 2 and keeps both
+        // height and width larger than the requested height and width.
+        while (halfHeight / inSampleSize >= desiredHeight && halfWidth / inSampleSize >= desiredWidth) {
+            inSampleSize *= 2
+        }
+    }
+
+    return inSampleSize
+}
+
+/**
+ * Decodes the [inputStream] into a [Bitmap] and applies the needed rotation based on [orientation].
+ * This orientation value must be one of `ExifInterface.ORIENTATION_*` constants.
+ */
+fun Bitmap.rotateToExifMetadataOrientation(orientation: Int): Bitmap {
+    val matrix = Matrix()
+    when (orientation) {
+        ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f)
+        ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f)
+        ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f)
+        ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.preScale(-1f, 1f)
+        ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.preScale(1f, -1f)
+        ExifInterface.ORIENTATION_TRANSPOSE -> {
+            matrix.preRotate(-90f)
+            matrix.preScale(-1f, 1f)
+        }
+        ExifInterface.ORIENTATION_TRANSVERSE -> {
+            matrix.preRotate(90f)
+            matrix.preScale(-1f, 1f)
+        }
+        else -> return this
+    }
+
+    return Bitmap.createBitmap(this, 0, 0, width, height, matrix, true)
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/browser/ChromeCustomTab.kt

@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.browser
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.os.Bundle
+import android.provider.Browser
+import androidx.browser.customtabs.CustomTabColorSchemeParams
+import androidx.browser.customtabs.CustomTabsIntent
+import androidx.browser.customtabs.CustomTabsSession
+import androidx.core.net.toUri
+import io.element.android.libraries.androidutils.system.openUrlInExternalApp
+import java.util.Locale
+
+/**
+ * Open url in custom tab or, if not available, in the default browser.
+ * If several compatible browsers are installed, the user will be proposed to choose one.
+ * Ref: https://developer.chrome.com/multidevice/android/customtabs.
+ */
+fun Activity.openUrlInChromeCustomTab(
+    session: CustomTabsSession?,
+    darkTheme: Boolean,
+    url: String
+) {
+    try {
+        CustomTabsIntent.Builder()
+            .setDefaultColorSchemeParams(
+                CustomTabColorSchemeParams.Builder()
+                    // TODO .setToolbarColor(ThemeUtils.getColor(context, android.R.attr.colorBackground))
+                    // TODO .setNavigationBarColor(ThemeUtils.getColor(context, android.R.attr.colorBackground))
+                    .build()
+            )
+            .setColorScheme(
+                when (darkTheme) {
+                    false -> CustomTabsIntent.COLOR_SCHEME_LIGHT
+                    true -> CustomTabsIntent.COLOR_SCHEME_DARK
+                }
+            )
+            .setShareIdentityEnabled(false)
+            // Note: setting close button icon does not work
+            // .setCloseButtonIcon(BitmapFactory.decodeResource(context.resources, R.drawable.ic_back_24dp))
+            // .setStartAnimations(context, R.anim.enter_fade_in, R.anim.exit_fade_out)
+            // .setExitAnimations(context, R.anim.enter_fade_in, R.anim.exit_fade_out)
+            .apply { session?.let { setSession(it) } }
+            .build()
+            .apply {
+                // Disable download button
+                intent.putExtra("org.chromium.chrome.browser.customtabs.EXTRA_DISABLE_DOWNLOAD_BUTTON", true)
+                // Disable bookmark button
+                intent.putExtra("org.chromium.chrome.browser.customtabs.EXTRA_DISABLE_STAR_BUTTON", true)
+                intent.putExtra(Browser.EXTRA_HEADERS, Bundle().apply {
+                    putString("Accept-Language", Locale.getDefault().toLanguageTag())
+                })
+            }
+            .launchUrl(this, url.toUri())
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        openUrlInExternalApp(url)
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/browser/ConsoleMessageLogger.kt

@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.browser
+
+import android.util.Log
+import android.webkit.ConsoleMessage
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import timber.log.Timber
+
+interface ConsoleMessageLogger {
+    fun log(
+        tag: String,
+        consoleMessage: ConsoleMessage,
+    )
+}
+
+@ContributesBinding(AppScope::class)
+class DefaultConsoleMessageLogger : ConsoleMessageLogger {
+    override fun log(
+        tag: String,
+        consoleMessage: ConsoleMessage,
+    ) {
+        val priority = when (consoleMessage.messageLevel()) {
+            ConsoleMessage.MessageLevel.ERROR -> Log.ERROR
+            ConsoleMessage.MessageLevel.WARNING -> Log.WARN
+            else -> Log.DEBUG
+        }
+
+        val message = buildString {
+            append(consoleMessage.sourceId())
+            append(":")
+            append(consoleMessage.lineNumber())
+            append(" ")
+            append(consoleMessage.message())
+        }
+
+        // Avoid logging any messages that contain "password" to prevent leaking sensitive information
+        if (message.contains("password=")) {
+            return
+        }
+
+        Timber.tag(tag).log(
+            priority = priority,
+            message = buildString {
+                append(consoleMessage.sourceId())
+                append(":")
+                append(consoleMessage.lineNumber())
+                append(" ")
+                append(consoleMessage.message())
+            },
+        )
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/clipboard/AndroidClipboardHelper.kt

@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.clipboard
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import androidx.core.content.getSystemService
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.SingleIn
+import io.element.android.libraries.di.annotations.ApplicationContext
+
+@ContributesBinding(AppScope::class)
+@SingleIn(AppScope::class)
+class AndroidClipboardHelper(
+    @ApplicationContext private val context: Context,
+) : ClipboardHelper {
+    private val clipboardManager = requireNotNull(context.getSystemService<ClipboardManager>())
+
+    override fun copyPlainText(text: String) {
+        clipboardManager.setPrimaryClip(ClipData.newPlainText("", text))
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/clipboard/ClipboardHelper.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.clipboard
+
+/**
+ * Wrapper class for handling clipboard operations so it can be used in JVM environments.
+ */
+interface ClipboardHelper {
+    fun copyPlainText(text: String)
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/clipboard/FakeClipboardHelper.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.clipboard
+
+class FakeClipboardHelper : ClipboardHelper {
+    var clipboardContents: Any? = null
+
+    override fun copyPlainText(text: String) {
+        clipboardContents = text
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/compat/Compat.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.compat
+
+import android.content.Intent
+import android.content.pm.ApplicationInfo
+import android.content.pm.PackageManager
+import android.content.pm.ResolveInfo
+import android.os.Build
+
+fun PackageManager.queryIntentActivitiesCompat(data: Intent, flags: Int): List<ResolveInfo> {
+    return when {
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> queryIntentActivities(
+            data,
+            PackageManager.ResolveInfoFlags.of(flags.toLong())
+        )
+        else -> @Suppress("DEPRECATION") queryIntentActivities(data, flags)
+    }
+}
+
+fun PackageManager.getApplicationInfoCompat(packageName: String, flags: Int): ApplicationInfo {
+    return when {
+        Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU -> getApplicationInfo(
+            packageName,
+            PackageManager.ApplicationInfoFlags.of(flags.toLong())
+        )
+        else -> getApplicationInfo(packageName, flags)
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/diff/DefaultDiffCallback.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.diff
+
+import androidx.recyclerview.widget.DiffUtil
+
+/**
+ *  Default implementation of [DiffUtil.Callback] that uses [areItemsTheSame] to compare items.
+ */
+internal class DefaultDiffCallback<T>(
+    private val oldList: List<T>,
+    private val newList: List<T>,
+    private val areItemsTheSame: (oldItem: T?, newItem: T?) -> Boolean,
+) : DiffUtil.Callback() {
+    override fun getOldListSize(): Int {
+        return oldList.size
+    }
+
+    override fun getNewListSize(): Int {
+        return newList.size
+    }
+
+    override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
+        val oldItem = oldList.getOrNull(oldItemPosition)
+        val newItem = newList.getOrNull(newItemPosition)
+        return areItemsTheSame(oldItem, newItem)
+    }
+
+    override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
+        val oldItem = oldList.getOrNull(oldItemPosition)
+        val newItem = newList.getOrNull(newItemPosition)
+        return oldItem == newItem
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/diff/DiffCache.kt

@@ -0,0 +1,58 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.diff
+
+/**
+ * A cache that can be used to store some data that can be invalidated when a diff is applied.
+ * The cache is invalidated by the [DiffCacheInvalidator].
+ */
+interface DiffCache<E> {
+    fun get(index: Int): E?
+    fun indices(): IntRange
+    fun isEmpty(): Boolean
+}
+
+/**
+ * A [DiffCache] that can be mutated by adding, removing or updating elements.
+ */
+interface MutableDiffCache<E> : DiffCache<E> {
+    fun removeAt(index: Int): E?
+    fun add(index: Int, element: E?)
+    operator fun set(index: Int, element: E?)
+}
+
+/**
+ * A [MutableDiffCache] backed by a [MutableList].
+ *
+ */
+class MutableListDiffCache<E>(private val mutableList: MutableList<E?> = ArrayList()) : MutableDiffCache<E> {
+    override fun removeAt(index: Int): E? {
+        return mutableList.removeAt(index)
+    }
+
+    override fun get(index: Int): E? {
+        return mutableList.getOrNull(index)
+    }
+
+    override fun indices(): IntRange {
+        return mutableList.indices
+    }
+
+    override fun isEmpty(): Boolean {
+        return mutableList.isEmpty()
+    }
+
+    override operator fun set(index: Int, element: E?) {
+        mutableList[index] = element
+    }
+
+    override fun add(index: Int, element: E?) {
+        mutableList.add(index, element)
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/diff/DiffCacheInvalidator.kt

@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.diff
+
+/**
+ * [DiffCacheInvalidator] is used to invalidate the cache when the list is updated.
+ * It is used by [DiffCacheUpdater].
+ * Check the default implementation [DefaultDiffCacheInvalidator].
+ */
+interface DiffCacheInvalidator<T> {
+    fun onChanged(position: Int, count: Int, cache: MutableDiffCache<T>)
+
+    fun onMoved(fromPosition: Int, toPosition: Int, cache: MutableDiffCache<T>)
+
+    fun onInserted(position: Int, count: Int, cache: MutableDiffCache<T>)
+
+    fun onRemoved(position: Int, count: Int, cache: MutableDiffCache<T>)
+}
+
+/**
+ * Default implementation of [DiffCacheInvalidator].
+ * It invalidates the cache by setting values to null.
+ */
+class DefaultDiffCacheInvalidator<T> : DiffCacheInvalidator<T> {
+    override fun onChanged(position: Int, count: Int, cache: MutableDiffCache<T>) {
+        for (i in position until position + count) {
+            // Invalidate cache
+            cache[i] = null
+        }
+    }
+
+    override fun onMoved(fromPosition: Int, toPosition: Int, cache: MutableDiffCache<T>) {
+        val model = cache.removeAt(fromPosition)
+        cache.add(toPosition, model)
+    }
+
+    override fun onInserted(position: Int, count: Int, cache: MutableDiffCache<T>) {
+        repeat(count) {
+            cache.add(position, null)
+        }
+    }
+
+    override fun onRemoved(position: Int, count: Int, cache: MutableDiffCache<T>) {
+        repeat(count) {
+            cache.removeAt(position)
+        }
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/diff/DiffCacheUpdater.kt

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.diff
+
+import androidx.recyclerview.widget.DiffUtil
+import androidx.recyclerview.widget.ListUpdateCallback
+import timber.log.Timber
+import kotlin.system.measureTimeMillis
+
+/**
+ * Class in charge of updating a [MutableDiffCache] according to the cache invalidation rules provided by the [DiffCacheInvalidator].
+ * @param ListItem the type of the items in the list
+ * @param CachedItem the type of the items in the cache
+ * @param diffCache the cache to update
+ * @param detectMoves true if DiffUtil should try to detect moved items, false otherwise
+ * @param cacheInvalidator the invalidator to use to update the cache
+ * @param areItemsTheSame the function to use to compare items
+ */
+class DiffCacheUpdater<ListItem, CachedItem>(
+    private val diffCache: MutableDiffCache<CachedItem>,
+    private val detectMoves: Boolean = false,
+    private val cacheInvalidator: DiffCacheInvalidator<CachedItem> = DefaultDiffCacheInvalidator(),
+    private val areItemsTheSame: (oldItem: ListItem?, newItem: ListItem?) -> Boolean,
+) {
+    private val lock = Object()
+    private var prevOriginalList: List<ListItem> = emptyList()
+
+    private val listUpdateCallback = object : ListUpdateCallback {
+        override fun onInserted(position: Int, count: Int) {
+            cacheInvalidator.onInserted(position, count, diffCache)
+        }
+
+        override fun onRemoved(position: Int, count: Int) {
+            cacheInvalidator.onRemoved(position, count, diffCache)
+        }
+
+        override fun onMoved(fromPosition: Int, toPosition: Int) {
+            cacheInvalidator.onMoved(fromPosition, toPosition, diffCache)
+        }
+
+        override fun onChanged(position: Int, count: Int, payload: Any?) {
+            cacheInvalidator.onChanged(position, count, diffCache)
+        }
+    }
+
+    fun updateWith(newOriginalList: List<ListItem>) = synchronized(lock) {
+        val timeToDiff = measureTimeMillis {
+            val diffCallback = DefaultDiffCallback(prevOriginalList, newOriginalList, areItemsTheSame)
+            val diffResult = DiffUtil.calculateDiff(diffCallback, detectMoves)
+            prevOriginalList = newOriginalList
+            diffResult.dispatchUpdatesTo(listUpdateCallback)
+        }
+        Timber.v("Time to apply diff on new list of ${newOriginalList.size} items: $timeToDiff ms")
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/file/Context.kt

@@ -0,0 +1,49 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.file
+
+import android.content.ContentResolver
+import android.content.Context
+import android.net.Uri
+import android.provider.OpenableColumns
+import androidx.core.net.toFile
+import io.element.android.libraries.core.extensions.runCatchingExceptions
+
+fun Context.getMimeType(uri: Uri): String? = when (uri.scheme) {
+    ContentResolver.SCHEME_CONTENT -> contentResolver.getType(uri)
+    else -> null
+}
+
+fun Context.getFileName(uri: Uri): String? = when (uri.scheme) {
+    ContentResolver.SCHEME_CONTENT -> getContentFileName(uri)
+    ContentResolver.SCHEME_FILE -> uri.toFile().name
+    else -> null
+}
+
+fun Context.getFileSize(uri: Uri): Long {
+    return when (uri.scheme) {
+        ContentResolver.SCHEME_CONTENT -> getContentFileSize(uri)
+        ContentResolver.SCHEME_FILE -> uri.toFile().length()
+        else -> 0
+    } ?: 0
+}
+
+private fun Context.getContentFileSize(uri: Uri): Long? = runCatchingExceptions {
+    contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+        cursor.moveToFirst()
+        return@use cursor.getColumnIndexOrThrow(OpenableColumns.SIZE).let(cursor::getLong)
+    }
+}.getOrNull()
+
+private fun Context.getContentFileName(uri: Uri): String? = runCatchingExceptions {
+    contentResolver.query(uri, null, null, null, null)?.use { cursor ->
+        cursor.moveToFirst()
+        return@use cursor.getColumnIndexOrThrow(OpenableColumns.DISPLAY_NAME).let(cursor::getString)
+    }
+}.getOrNull()

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/file/File.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.file
+
+import android.content.Context
+import androidx.annotation.WorkerThread
+import io.element.android.libraries.core.data.tryOrNull
+import timber.log.Timber
+import java.io.File
+import java.util.UUID
+
+fun File.safeDelete() {
+    if (exists().not()) return
+    tryOrNull(
+        onException = {
+            Timber.e(it, "Error, unable to delete file $path")
+        },
+        operation = {
+            if (delete().not()) {
+                Timber.w("Warning, unable to delete file $path")
+            }
+        }
+    )
+}
+
+fun File.safeRenameTo(dest: File) {
+    tryOrNull(
+        onException = {
+            Timber.e(it, "Error, unable to rename file $path to ${dest.path}")
+        },
+        operation = {
+            if (renameTo(dest).not()) {
+                Timber.w("Warning, unable to rename file $path to ${dest.path}")
+            }
+        }
+    )
+}
+
+fun Context.createTmpFile(baseDir: File = cacheDir, extension: String? = null): File {
+    val suffix = extension?.let { ".$extension" }
+    return File.createTempFile(UUID.randomUUID().toString(), suffix, baseDir).apply { mkdirs() }
+}
+
+/* ==========================================================================================
+ * Size
+ * ========================================================================================== */
+
+@WorkerThread
+fun File.getSizeOfFiles(): Long {
+    return walkTopDown()
+        .onEnter {
+            Timber.v("Get size of ${it.absolutePath}")
+            true
+        }
+        .sumOf { it.length() }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/file/FileCompression.kt

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.file
+
+import timber.log.Timber
+import java.io.File
+import java.util.zip.GZIPOutputStream
+
+/**
+ * GZip a file.
+ *
+ * @param file the input file
+ * @return the gzipped file
+ */
+fun compressFile(file: File): File? {
+    Timber.v("## compressFile() : compress ${file.name}")
+
+    val dstFile = file.resolveSibling(file.name + ".gz")
+
+    if (dstFile.exists()) {
+        dstFile.safeDelete()
+    }
+
+    return try {
+        GZIPOutputStream(dstFile.outputStream()).use { gos ->
+            file.inputStream().use {
+                it.copyTo(gos, 2048)
+            }
+        }
+
+        Timber.v("## compressFile() : ${file.length()} compressed to ${dstFile.length()} bytes")
+        dstFile
+    } catch (e: Exception) {
+        Timber.e(e, "## compressFile() failed")
+        null
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/file/TemporaryUriDeleter.kt

@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.file
+
+import android.content.Context
+import android.net.Uri
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.libraries.di.annotations.ApplicationContext
+import timber.log.Timber
+
+interface TemporaryUriDeleter {
+    /**
+     * Delete the Uri only if it is a temporary one.
+     */
+    fun delete(uri: Uri?)
+}
+
+@ContributesBinding(AppScope::class)
+class DefaultTemporaryUriDeleter(
+    @ApplicationContext private val context: Context,
+) : TemporaryUriDeleter {
+    private val baseCacheUri = "content://${context.packageName}.fileprovider/cache"
+
+    override fun delete(uri: Uri?) {
+        uri ?: return
+        if (uri.toString().startsWith(baseCacheUri)) {
+            context.contentResolver.delete(uri, null, null)
+        } else {
+            Timber.d("Do not delete the uri")
+        }
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/filesize/AndroidFileSizeFormatter.kt

@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.filesize
+
+import android.content.Context
+import android.os.Build
+import android.text.format.Formatter
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.libraries.di.annotations.ApplicationContext
+import io.element.android.services.toolbox.api.sdk.BuildVersionSdkIntProvider
+
+@ContributesBinding(AppScope::class)
+class AndroidFileSizeFormatter(
+    @ApplicationContext private val context: Context,
+    private val sdkIntProvider: BuildVersionSdkIntProvider,
+) : FileSizeFormatter {
+    override fun format(fileSize: Long, useShortFormat: Boolean): String {
+        // Since Android O, the system considers that 1kB = 1000 bytes instead of 1024 bytes.
+        // We want to avoid that.
+        val normalizedSize = if (sdkIntProvider.get() <= Build.VERSION_CODES.N) {
+            fileSize
+        } else {
+            // First convert the size
+            when {
+                fileSize < 1024 -> fileSize
+                fileSize < 1024 * 1024 -> fileSize * 1000 / 1024
+                fileSize < 1024 * 1024 * 1024 -> fileSize * 1000 / 1024 * 1000 / 1024
+                else -> fileSize * 1000 / 1024 * 1000 / 1024 * 1000 / 1024
+            }
+        }
+
+        return if (useShortFormat) {
+            Formatter.formatShortFileSize(context, normalizedSize)
+        } else {
+            Formatter.formatFileSize(context, normalizedSize)
+        }
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/filesize/FakeFileSizeFormatter.kt

@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.filesize
+
+class FakeFileSizeFormatter : FileSizeFormatter {
+    override fun format(fileSize: Long, useShortFormat: Boolean): String {
+        return "$fileSize Bytes"
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/filesize/FileSizeFormatter.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.filesize
+
+interface FileSizeFormatter {
+    /**
+     * Formats a content size to be in the form of bytes, kilobytes, megabytes, etc.
+     */
+    fun format(fileSize: Long, useShortFormat: Boolean = true): String
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/hardware/VibratorTools.kt

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2022-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.hardware
+
+import android.content.Context
+import android.os.Build
+import android.os.VibrationEffect
+import android.os.Vibrator
+import androidx.core.content.getSystemService
+
+fun Context.vibrate(durationMillis: Long = 100) {
+    val vibrator = getSystemService<Vibrator>() ?: return
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        vibrator.vibrate(VibrationEffect.createOneShot(durationMillis, VibrationEffect.DEFAULT_AMPLITUDE))
+    } else {
+        @Suppress("DEPRECATION")
+        vibrator.vibrate(durationMillis)
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/hash/Hash.kt

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.hash
+
+import java.security.MessageDigest
+import java.util.Locale
+
+/**
+ * Compute a Hash of a String, using SHA-512 algorithm.
+ */
+fun String.hash() = try {
+    val digest = MessageDigest.getInstance("SHA-512")
+    digest.update(toByteArray())
+    digest.digest()
+        .joinToString("") { String.format(Locale.ROOT, "%02X", it) }
+        .lowercase(Locale.ROOT)
+} catch (exc: Exception) {
+    // Should not happen, but just in case
+    hashCode().toString()
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/json/JsonProvider.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.json
+
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.Provider
+import dev.zacsweers.metro.SingleIn
+import kotlinx.serialization.json.Json
+
+/**
+ * Provides a Json instance configured to ignore unknown keys.
+ */
+fun interface JsonProvider : Provider<Json>
+
+@ContributesBinding(AppScope::class)
+@SingleIn(AppScope::class)
+class DefaultJsonProvider : JsonProvider {
+    private val json: Json by lazy { Json { ignoreUnknownKeys = true } }
+    override fun invoke() = json
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/media/MediaMetaDataRetriever.kt

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.media
+
+import android.media.MediaMetadataRetriever
+
+/** [MediaMetadataRetriever] only implements `AutoClosable` since API 29, so we need to execute this to have the same in older APIs. */
+inline fun <T> MediaMetadataRetriever.runAndRelease(block: MediaMetadataRetriever.() -> T): T {
+    return try {
+        block()
+    } finally {
+        release()
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/media/VideoCompressorHelper.kt

@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.media
+
+import android.util.Size
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+/**
+ * Helper class to calculate the resulting output size and optimal bitrate for video compression.
+ */
+class VideoCompressorHelper(
+    /**
+     * The maximum size (in pixels) for the output video.
+     * The output will maintain the aspect ratio of the input video.
+     */
+    val maxSize: Int,
+) {
+    /**
+     * Calculates the output size for video compression based on the input size and [maxSize].
+     */
+    fun getOutputSize(inputSize: Size): Size {
+        val resultMajor = min(inputSize.major(), maxSize)
+        val aspectRatio = inputSize.major().toFloat() / inputSize.minor().toFloat()
+        return if (inputSize.isLandscape()) {
+            Size(resultMajor, (resultMajor / aspectRatio).roundToInt())
+        } else {
+            Size((resultMajor / aspectRatio).roundToInt(), resultMajor)
+        }
+    }
+
+    /**
+     * Calculates the optimal bitrate for video compression based on the input size and frame rate.
+     */
+    fun calculateOptimalBitrate(inputSize: Size, frameRate: Int): Long {
+        val outputSize = getOutputSize(inputSize)
+        val pixelsPerFrame = outputSize.width * outputSize.height
+        // Apparently, 0.1 bits per pixel is a sweet spot for video compression
+        val bitsPerPixel = 0.1f
+        return (pixelsPerFrame * bitsPerPixel * frameRate).toLong()
+    }
+}
+
+private fun Size.isLandscape(): Boolean = width > height
+private fun Size.major(): Int = if (isLandscape()) width else height
+private fun Size.minor(): Int = if (isLandscape()) height else width

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/metadata/IsInDebug.kt

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.metadata
+
+import io.element.android.libraries.androidutils.BuildConfig
+
+/**
+ * true if the app is built in debug mode.
+ * For testing purpose, this can be changed with [withReleaseBehavior].
+ */
+var isInDebug: Boolean = BuildConfig.DEBUG
+    private set
+
+/**
+ * Run the lambda simulating the app is in release mode.
+ *
+ * **IMPORTANT**: this should **ONLY** be used for testing purposes.
+ */
+fun withReleaseBehavior(lambda: () -> Unit) {
+    isInDebug = false
+    lambda()
+    isInDebug = BuildConfig.DEBUG
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/preferences/DefaultPreferencesCorruptionHandlerFactory.kt

@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.preferences
+
+import androidx.datastore.core.handlers.ReplaceFileCorruptionHandler
+import androidx.datastore.preferences.core.Preferences
+import androidx.datastore.preferences.core.emptyPreferences
+
+object DefaultPreferencesCorruptionHandlerFactory {
+    /**
+     * Creates a [ReplaceFileCorruptionHandler] that will replace the corrupted preferences file with an empty preferences object.
+     */
+    fun replaceWithEmpty(): ReplaceFileCorruptionHandler<Preferences> {
+        return ReplaceFileCorruptionHandler(
+            produceNewData = {
+                // If the preferences file is corrupted, we return an empty preferences object
+                emptyPreferences()
+            },
+        )
+    }
+}

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

@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.system
+
+import android.content.Context
+import android.provider.Settings
+
+fun Context.getAnimationScale(): Float {
+    return Settings.Global.getFloat(contentResolver, Settings.Global.ANIMATOR_DURATION_SCALE, 1.0f)
+}
+
+fun Context.areAnimationsEnabled(): Boolean {
+    return getAnimationScale() > 0f
+}

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

@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2022-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.system
+
+import android.content.ClipData
+import android.content.ClipboardManager
+import android.content.Context
+import androidx.core.content.getSystemService
+
+class CopyToClipboardUseCase(
+    private val context: Context,
+) {
+    fun execute(text: CharSequence) {
+        context.getSystemService<ClipboardManager>()
+            ?.setPrimaryClip(ClipData.newPlainText("", text))
+    }
+}

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

@@ -0,0 +1,61 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2024, 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.system
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import dev.zacsweers.metro.SingleIn
+import io.element.android.libraries.androidutils.system.DateTimeObserver.Event
+import io.element.android.libraries.di.annotations.ApplicationContext
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.MutableSharedFlow
+import java.time.Instant
+
+interface DateTimeObserver {
+    val changes: Flow<Event>
+
+    sealed interface Event {
+        data object TimeZoneChanged : Event
+        data class DateChanged(val previous: Instant, val new: Instant) : Event
+    }
+}
+
+@ContributesBinding(AppScope::class)
+@SingleIn(AppScope::class)
+class DefaultDateTimeObserver(
+    @ApplicationContext context: Context
+) : DateTimeObserver {
+    private val dateTimeReceiver = object : BroadcastReceiver() {
+        private var lastTime = Instant.now()
+
+        override fun onReceive(context: Context, intent: Intent) {
+            val newDate = Instant.now()
+            when (intent.action) {
+                Intent.ACTION_TIMEZONE_CHANGED -> changes.tryEmit(Event.TimeZoneChanged)
+                Intent.ACTION_DATE_CHANGED -> changes.tryEmit(Event.DateChanged(lastTime, newDate))
+                Intent.ACTION_TIME_CHANGED -> changes.tryEmit(Event.DateChanged(lastTime, newDate))
+            }
+            lastTime = newDate
+        }
+    }
+
+    override val changes = MutableSharedFlow<Event>(extraBufferCapacity = 10)
+
+    init {
+        context.registerReceiver(dateTimeReceiver, IntentFilter().apply {
+            addAction(Intent.ACTION_TIMEZONE_CHANGED)
+            addAction(Intent.ACTION_DATE_CHANGED)
+            addAction(Intent.ACTION_TIME_CHANGED)
+        })
+    }
+}

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

@@ -0,0 +1,207 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.system
+
+import android.app.Activity
+import android.content.ActivityNotFoundException
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.provider.Settings
+import android.widget.Toast
+import androidx.activity.result.ActivityResultLauncher
+import androidx.annotation.RequiresApi
+import androidx.core.content.pm.PackageInfoCompat
+import androidx.core.net.toUri
+import io.element.android.libraries.androidutils.R
+import io.element.android.libraries.androidutils.compat.getApplicationInfoCompat
+import io.element.android.libraries.core.mimetype.MimeTypes
+
+/**
+ * Return the application label of the provided package. If not found, the package is returned.
+ */
+fun Context.getApplicationLabel(packageName: String): String {
+    return try {
+        val ai = packageManager.getApplicationInfoCompat(packageName, 0)
+        packageManager.getApplicationLabel(ai).toString()
+    } catch (e: PackageManager.NameNotFoundException) {
+        packageName
+    }
+}
+
+/**
+ * Retrieve the versionCode from the Manifest.
+ * The value is more accurate than BuildConfig.VERSION_CODE, as it is correct according to the
+ * computation in the `androidComponents` block of the app build.gradle.kts file.
+ * In other words, the last digit (for the architecture) will be set, whereas BuildConfig.VERSION_CODE
+ * last digit will always be 0.
+ */
+fun Context.getVersionCodeFromManifest(): Long {
+    return PackageInfoCompat.getLongVersionCode(
+        packageManager.getPackageInfo(packageName, 0)
+    )
+}
+
+// ==============================================================================================================
+// Clipboard helper
+// ==============================================================================================================
+
+/**
+ * Copy a text to the clipboard, and display a Toast when done.
+ *
+ * @receiver the context
+ * @param text the text to copy
+ * @param toastMessage content of the toast message as a String resource. Null for no toast
+ */
+fun Context.copyToClipboard(
+    text: CharSequence,
+    toastMessage: String? = null
+) {
+    CopyToClipboardUseCase(this).execute(text)
+    toastMessage?.let { toast(it) }
+}
+
+/**
+ * Shows notification settings for the current app.
+ * In android O will directly opens the notification settings, in lower version it will show the App settings
+ */
+fun Context.startNotificationSettingsIntent(
+    activityResultLauncher: ActivityResultLauncher<Intent>? = null,
+    noActivityFoundMessage: String = getString(R.string.error_no_compatible_app_found),
+) {
+    val intent = Intent()
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        intent.action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
+        if (this !is Activity && activityResultLauncher == null) {
+            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        }
+        intent.putExtra(Settings.EXTRA_APP_PACKAGE, packageName)
+    } else {
+        intent.action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+        intent.data = Uri.fromParts("package", packageName, null)
+    }
+
+    try {
+        if (activityResultLauncher != null) {
+            activityResultLauncher.launch(intent)
+        } else {
+            startActivity(intent)
+        }
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        toast(noActivityFoundMessage)
+    }
+}
+
+fun Context.openAppSettingsPage(
+    noActivityFoundMessage: String = getString(R.string.error_no_compatible_app_found),
+) {
+    try {
+        startActivity(
+            Intent().apply {
+                action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
+                addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+                data = Uri.fromParts("package", packageName, null)
+            }
+        )
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        toast(noActivityFoundMessage)
+    }
+}
+
+@RequiresApi(Build.VERSION_CODES.O)
+fun Context.startInstallFromSourceIntent(
+    activityResultLauncher: ActivityResultLauncher<Intent>,
+    noActivityFoundMessage: String = getString(R.string.error_no_compatible_app_found),
+) {
+    val intent = Intent(Settings.ACTION_MANAGE_UNKNOWN_APP_SOURCES)
+        .setData("package:$packageName".toUri())
+    try {
+        activityResultLauncher.launch(intent)
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        toast(noActivityFoundMessage)
+    }
+}
+
+fun Context.startSharePlainTextIntent(
+    activityResultLauncher: ActivityResultLauncher<Intent>?,
+    chooserTitle: String?,
+    text: String,
+    subject: String? = null,
+    extraTitle: String? = null,
+    noActivityFoundMessage: String = getString(R.string.error_no_compatible_app_found),
+) {
+    val share = Intent(Intent.ACTION_SEND)
+    share.type = MimeTypes.PlainText
+    share.addFlags(Intent.FLAG_ACTIVITY_NEW_DOCUMENT)
+    // Add data to the intent, the receiving app will decide what to do with it.
+    share.putExtra(Intent.EXTRA_SUBJECT, subject)
+    share.putExtra(Intent.EXTRA_TEXT, text)
+
+    extraTitle?.let {
+        share.putExtra(Intent.EXTRA_TITLE, it)
+    }
+
+    val intent = Intent.createChooser(share, chooserTitle)
+    try {
+        if (activityResultLauncher != null) {
+            activityResultLauncher.launch(intent)
+        } else {
+            startActivity(intent)
+        }
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        toast(noActivityFoundMessage)
+    }
+}
+
+@Suppress("SwallowedException")
+fun Context.openUrlInExternalApp(
+    url: String,
+    errorMessage: String = getString(R.string.error_no_compatible_app_found),
+    throwInCaseOfError: Boolean = false,
+) {
+    val intent = Intent(Intent.ACTION_VIEW, url.toUri())
+    if (this !is Activity) {
+        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+    }
+    try {
+        startActivity(intent)
+    } catch (activityNotFoundException: ActivityNotFoundException) {
+        if (throwInCaseOfError) throw activityNotFoundException
+        toast(errorMessage)
+    }
+}
+
+/**
+ * Open Google Play on the provided application Id.
+ */
+fun Context.openGooglePlay(
+    appId: String,
+) {
+    try {
+        openUrlInExternalApp(
+            url = "market://details?id=$appId",
+            throwInCaseOfError = true,
+        )
+    } catch (_: ActivityNotFoundException) {
+        openUrlInExternalApp("https://play.google.com/store/apps/details?id=$appId")
+    }
+}
+
+// Not in KTX anymore
+fun Context.toast(resId: Int) {
+    Toast.makeText(this, resId, Toast.LENGTH_SHORT).show()
+}
+
+// Not in KTX anymore
+fun Context.toast(message: String) {
+    Toast.makeText(this, message, Toast.LENGTH_SHORT).show()
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/text/LinkifyHelper.kt

@@ -0,0 +1,110 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.text
+
+import android.text.Spannable
+import android.text.style.URLSpan
+import android.text.util.Linkify
+import androidx.core.text.getSpans
+import androidx.core.text.toSpannable
+import androidx.core.text.util.LinkifyCompat
+import io.element.android.libraries.core.extensions.runCatchingExceptions
+import timber.log.Timber
+import kotlin.collections.component1
+import kotlin.collections.component2
+
+/**
+ * Helper class to linkify text while preserving existing URL spans.
+ *
+ * It also checks the linkified results to make sure URLs spans are not including trailing punctuation.
+ */
+object LinkifyHelper {
+    fun linkify(
+        text: CharSequence,
+        @LinkifyCompat.LinkifyMask linkifyMask: Int = Linkify.WEB_URLS or Linkify.PHONE_NUMBERS or Linkify.EMAIL_ADDRESSES,
+    ): CharSequence {
+        // Convert the text to a Spannable to be able to add URL spans, return the original text if it's not possible (in tests, i.e.)
+        val spannable = text.toSpannable() ?: return text
+
+        // Get all URL spans, as they will be removed by LinkifyCompat.addLinks
+        val oldURLSpans = spannable.getSpans<URLSpan>(0, text.length).associateWith {
+            val start = spannable.getSpanStart(it)
+            val end = spannable.getSpanEnd(it)
+            Pair(start, end)
+        }
+        // Find and set as URLSpans any links present in the text
+        val addedNewLinks = LinkifyCompat.addLinks(spannable, linkifyMask)
+
+        // Process newly added URL spans
+        if (addedNewLinks) {
+            val newUrlSpans = spannable.getSpans<URLSpan>(0, spannable.length)
+            for (urlSpan in newUrlSpans) {
+                val start = spannable.getSpanStart(urlSpan)
+                val end = spannable.getSpanEnd(urlSpan)
+
+                // Try to avoid including trailing punctuation in the link.
+                // Since this might fail in some edge cases, we catch the exception and just use the original end index.
+                val newEnd = runCatchingExceptions {
+                    adjustLinkifiedUrlSpanEndIndex(spannable, start, end)
+                }.onFailure {
+                    Timber.e(it, "Failed to adjust end index for link span")
+                }.getOrNull() ?: end
+
+                // Adapt the url in the URL span to the new end index too if needed
+                if (end != newEnd) {
+                    val url = spannable.subSequence(start, newEnd).toString()
+                    spannable.removeSpan(urlSpan)
+                    spannable.setSpan(URLSpan(url), start, newEnd, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+                } else {
+                    spannable.setSpan(urlSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+                }
+            }
+        }
+
+        // Restore old spans, remove new ones if there is a conflict
+        for ((urlSpan, location) in oldURLSpans) {
+            val (start, end) = location
+            val addedConflictingSpans = spannable.getSpans<URLSpan>(start, end)
+            if (addedConflictingSpans.isNotEmpty()) {
+                for (span in addedConflictingSpans) {
+                    spannable.removeSpan(span)
+                }
+            }
+
+            spannable.setSpan(urlSpan, start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE)
+        }
+        return spannable
+    }
+
+    private fun adjustLinkifiedUrlSpanEndIndex(spannable: Spannable, start: Int, end: Int): Int {
+        var end = end
+
+        // Trailing punctuation found, adjust the end index
+        while (spannable[end - 1] in sequenceOf('.', ',', ';', ':', '!', '?', '…') && end > start) {
+            end--
+        }
+
+        // If the last character is a closing parenthesis, check if it's part of a pair
+        if (spannable[end - 1] == ')' && end > start) {
+            val linkifiedTextLastPath = spannable.substring(start, end).substringAfterLast('/')
+            val closingParenthesisCount = linkifiedTextLastPath.count { it == ')' }
+            val openingParenthesisCount = linkifiedTextLastPath.count { it == '(' }
+            // If it's not part of a pair, remove it from the link span by adjusting the end index
+            end -= closingParenthesisCount - openingParenthesisCount
+        }
+        return end
+    }
+}
+
+/**
+ * Linkify the text with the default mask (WEB_URLS, PHONE_NUMBERS, EMAIL_ADDRESSES).
+ */
+fun CharSequence.safeLinkify(): CharSequence {
+    return LinkifyHelper.linkify(this, Linkify.WEB_URLS or Linkify.PHONE_NUMBERS or Linkify.EMAIL_ADDRESSES)
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/throttler/FirstThrottler.kt

@@ -0,0 +1,35 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+package io.element.android.libraries.androidutils.throttler
+
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
+import java.util.concurrent.atomic.AtomicBoolean
+
+/**
+ * Simple ThrottleFirst
+ * See https://raw.githubusercontent.com/wiki/ReactiveX/RxJava/images/rx-operators/throttleFirst.png
+ */
+class FirstThrottler(
+    private val minimumInterval: Long = 800,
+    private val coroutineScope: CoroutineScope,
+) {
+    private val canHandle = AtomicBoolean(true)
+
+    fun canHandle(): Boolean {
+        return canHandle.getAndSet(false).also { result ->
+            if (result) {
+                coroutineScope.launch {
+                    delay(minimumInterval)
+                    canHandle.set(true)
+                }
+            }
+        }
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/ui/View.kt

@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2022-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.ui
+
+import android.os.Build
+import android.view.View
+import android.view.ViewTreeObserver
+import android.view.WindowInsets
+import android.view.inputmethod.InputMethodManager
+import androidx.core.content.getSystemService
+import kotlinx.coroutines.suspendCancellableCoroutine
+import kotlin.coroutines.resume
+
+fun View.hideKeyboard() {
+    val imm = context?.getSystemService<InputMethodManager>()
+    imm?.hideSoftInputFromWindow(windowToken, 0)
+}
+
+fun View.showKeyboard(andRequestFocus: Boolean = false) {
+    if (andRequestFocus) {
+        requestFocus()
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+        windowInsetsController?.show(WindowInsets.Type.ime())
+    } else {
+        val imm = context?.getSystemService<InputMethodManager>()
+        imm?.showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
+    }
+}
+
+fun View.isKeyboardVisible(): Boolean {
+    val imm = context?.getSystemService<InputMethodManager>()
+    return imm?.isAcceptingText == true
+}
+
+suspend fun View.awaitWindowFocus() = suspendCancellableCoroutine { continuation ->
+    if (hasWindowFocus()) {
+        continuation.resume(Unit)
+    } else {
+        val listener = object : ViewTreeObserver.OnWindowFocusChangeListener {
+            override fun onWindowFocusChanged(hasFocus: Boolean) {
+                if (hasFocus) {
+                    viewTreeObserver.removeOnWindowFocusChangeListener(this)
+                    continuation.resume(Unit)
+                }
+            }
+        }
+
+        viewTreeObserver.addOnWindowFocusChangeListener(listener)
+
+        continuation.invokeOnCancellation {
+            viewTreeObserver.removeOnWindowFocusChangeListener(listener)
+        }
+    }
+}

libraries/androidutils/src/main/kotlin/io/element/android/libraries/androidutils/uri/UriExtensions.kt

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2021-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.uri
+
+import android.net.Uri
+import androidx.core.net.toUri
+
+const val IGNORED_SCHEMA = "ignored"
+
+fun createIgnoredUri(path: String): Uri = "$IGNORED_SCHEMA://$path".toUri()

libraries/androidutils/src/main/res/values-be/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Не знойдзена сумяшчальная праграма для выканання гэтага дзеяння."</string>
+</resources>

libraries/androidutils/src/main/res/values-cs/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nebyla nalezena žádná kompatibilní aplikace, která by tuto akci zpracovala."</string>
+</resources>

libraries/androidutils/src/main/res/values-cy/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Heb ganfod ap cydnaws i drin y weithred hon."</string>
+</resources>

libraries/androidutils/src/main/res/values-da/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Der blev ikke fundet nogen kompatibel app til at håndtere denne handling."</string>
+</resources>

libraries/androidutils/src/main/res/values-de/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Für diese Aktion wurde keine kompatible App gefunden."</string>
+</resources>

libraries/androidutils/src/main/res/values-el/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Δεν βρέθηκε συμβατή εφαρμογή για να χειριστεί αυτήν την ενέργεια."</string>
+</resources>

libraries/androidutils/src/main/res/values-es/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"No se encontró ninguna aplicación compatible con esta acción."</string>
+</resources>

libraries/androidutils/src/main/res/values-et/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Ei õnnestunud leida selle tegevuse jaoks vajalikku välist rakendust."</string>
+</resources>

libraries/androidutils/src/main/res/values-eu/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Ez da ekintza hau kudeatzeko aplikazio bateragarririk aurkitu."</string>
+</resources>

libraries/androidutils/src/main/res/values-fa/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"هیچ برنامه سازگاری برای انجام این عمل یافت نشد."</string>
+</resources>

libraries/androidutils/src/main/res/values-fi/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Yhteensopivaa sovellusta ei löytynyt käsittelemään tätä toimintoa."</string>
+</resources>

libraries/androidutils/src/main/res/values-fr/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Aucune application compatible n’a été trouvée pour gérer cette action."</string>
+</resources>

libraries/androidutils/src/main/res/values-hu/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nem található kompatibilis alkalmazás a művelet kezeléséhez."</string>
+</resources>

libraries/androidutils/src/main/res/values-in/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Tidak ada aplikasi yang kompatibel yang ditemukan untuk menangani tindakan ini."</string>
+</resources>

libraries/androidutils/src/main/res/values-it/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Non è stata trovata alcuna app compatibile per gestire questa azione."</string>
+</resources>

libraries/androidutils/src/main/res/values-ka/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"თავსებადი აპლიკაცია ვერ მოიძებნა ამ მოქმედების შესასრულებლად."</string>
+</resources>

libraries/androidutils/src/main/res/values-ko/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"이 동작을 수행할 수 있는 앱을 찾지 못했습니다."</string>
+</resources>

libraries/androidutils/src/main/res/values-ldrtl/integers.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (c) 2025 Element Creations Ltd.
+  ~ Copyright 2022 New Vector Ltd.
+  ~
+  ~ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+  ~ Please see LICENSE files in the repository root for full details.
+  -->
+<resources>
+
+    <integer name="rtl_x_multiplier">-1</integer>
+    <integer name="rtl_mirror_flip">180</integer>
+
+</resources>

libraries/androidutils/src/main/res/values-lt/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nerasta suderinamos programos, kuri galėtų atlikti šį veiksmą."</string>
+</resources>

libraries/androidutils/src/main/res/values-nb/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Ingen kompatibel app ble funnet for å håndtere denne handlingen."</string>
+</resources>

libraries/androidutils/src/main/res/values-nl/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Er is geen compatibele app gevonden om deze actie uit te voeren."</string>
+</resources>

libraries/androidutils/src/main/res/values-pl/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nie znaleziono kompatybilnej aplikacji do obsługi tej akcji."</string>
+</resources>

libraries/androidutils/src/main/res/values-pt-rBR/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nenhum aplicativo compatível foi encontrado para lidar com essa ação."</string>
+</resources>

libraries/androidutils/src/main/res/values-pt/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nenhuma aplicação encontrada capaz de continuar esta ação."</string>
+</resources>

libraries/androidutils/src/main/res/values-ro/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nu a fost găsită nicio aplicație capabilă să gestioneze această acțiune."</string>
+</resources>

libraries/androidutils/src/main/res/values-ru/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Не найдено совместимое приложение для обработки этого действия."</string>
+</resources>

libraries/androidutils/src/main/res/values-sk/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Nebola nájdená žiadna kompatibilná aplikácia, ktorá by túto akciu dokázala spracovať."</string>
+</resources>

libraries/androidutils/src/main/res/values-sv/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Ingen kompatibel app hittades för att hantera den här åtgärden."</string>
+</resources>

libraries/androidutils/src/main/res/values-tr/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Bu eylemi gerçekleştirecek uyumlu bir uygulama bulunamadı."</string>
+</resources>

libraries/androidutils/src/main/res/values-uk/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Не знайдено сумісного застосунку для виконання цієї дії."</string>
+</resources>

libraries/androidutils/src/main/res/values-ur/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"اس کارروائی کو سنبھالنے کے لیے کوئی مطابقت پذیر اطلاقیہ نہیں ملا۔"</string>
+</resources>

libraries/androidutils/src/main/res/values-uz/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"Bu amalni bajarish uchun mos ilova topilmadi."</string>
+</resources>

libraries/androidutils/src/main/res/values-zh-rTW/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"找不到相容的應用程式來執行此動作。"</string>
+</resources>

libraries/androidutils/src/main/res/values-zh/translations.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"找不到完成此项操作的合适应用。"</string>
+</resources>

libraries/androidutils/src/main/res/values/integers.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?><!--
+  ~ Copyright (c) 2025 Element Creations Ltd.
+  ~ Copyright 2022 New Vector Ltd.
+  ~
+  ~ SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+  ~ Please see LICENSE files in the repository root for full details.
+  -->
+<resources xmlns:tools="http://schemas.android.com/tools">
+
+    <integer name="rtl_x_multiplier" tools:ignore="UnusedResources">1</integer>
+    <integer name="rtl_mirror_flip" tools:ignore="UnusedResources">0</integer>
+
+</resources>

libraries/androidutils/src/main/res/values/localazy.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+  <string name="error_no_compatible_app_found">"No compatible app was found to handle this action."</string>
+</resources>

libraries/androidutils/src/test/kotlin/io/element/android/libraries/androidutils/filesize/AndroidFileSizeFormatterTest.kt

@@ -0,0 +1,63 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.filesize
+
+import android.os.Build
+import com.google.common.truth.Truth.assertThat
+import io.element.android.services.toolbox.test.sdk.FakeBuildVersionSdkIntProvider
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.RuntimeEnvironment
+
+@RunWith(RobolectricTestRunner::class)
+class AndroidFileSizeFormatterTest {
+    @Test
+    fun `test api 24 long format`() {
+        val sut = createAndroidFileSizeFormatter(sdkLevel = Build.VERSION_CODES.N)
+        assertThat(sut.format(1, useShortFormat = false)).isEqualTo("1.00B")
+        assertThat(sut.format(1000, useShortFormat = false)).isEqualTo("0.98KB")
+        assertThat(sut.format(1024, useShortFormat = false)).isEqualTo("1.00KB")
+        assertThat(sut.format(1024 * 1024, useShortFormat = false)).isEqualTo("1.00MB")
+        assertThat(sut.format(1024 * 1024 * 1024, useShortFormat = false)).isEqualTo("1.00GB")
+    }
+
+    @Test
+    fun `test api 26 long format`() {
+        val sut = createAndroidFileSizeFormatter(sdkLevel = Build.VERSION_CODES.O)
+        assertThat(sut.format(1, useShortFormat = false)).isEqualTo("1.00B")
+        assertThat(sut.format(1000, useShortFormat = false)).isEqualTo("0.98KB")
+        assertThat(sut.format(1024 * 1024, useShortFormat = false)).isEqualTo("0.95MB")
+        assertThat(sut.format(1024 * 1024 * 1024, useShortFormat = false)).isEqualTo("0.93GB")
+    }
+
+    @Test
+    fun `test api 24 short format`() {
+        val sut = createAndroidFileSizeFormatter(sdkLevel = Build.VERSION_CODES.N)
+        assertThat(sut.format(1, useShortFormat = true)).isEqualTo("1.0B")
+        assertThat(sut.format(1000, useShortFormat = true)).isEqualTo("0.98KB")
+        assertThat(sut.format(1024, useShortFormat = true)).isEqualTo("1.0KB")
+        assertThat(sut.format(1024 * 1024, useShortFormat = true)).isEqualTo("1.0MB")
+        assertThat(sut.format(1024 * 1024 * 1024, useShortFormat = true)).isEqualTo("1.0GB")
+    }
+
+    @Test
+    fun `test api 26 short format`() {
+        val sut = createAndroidFileSizeFormatter(sdkLevel = Build.VERSION_CODES.O)
+        assertThat(sut.format(1, useShortFormat = true)).isEqualTo("1.0B")
+        assertThat(sut.format(1000, useShortFormat = true)).isEqualTo("0.98KB")
+        assertThat(sut.format(1024 * 1024, useShortFormat = true)).isEqualTo("0.95MB")
+        assertThat(sut.format(1024 * 1024 * 1024, useShortFormat = true)).isEqualTo("0.93GB")
+    }
+
+    private fun createAndroidFileSizeFormatter(sdkLevel: Int) = AndroidFileSizeFormatter(
+        context = RuntimeEnvironment.getApplication(),
+        sdkIntProvider = FakeBuildVersionSdkIntProvider(sdkInt = sdkLevel)
+    )
+}

libraries/androidutils/src/test/kotlin/io/element/android/libraries/androidutils/media/VideoCompressorHelperTest.kt

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.media
+
+import android.util.Size
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import com.google.common.truth.Truth.assertThat
+import org.junit.Test
+import org.junit.runner.RunWith
+
+@RunWith(AndroidJUnit4::class)
+class VideoCompressorHelperTest {
+    @Test
+    fun `test getOutputSize`() {
+        val helper = VideoCompressorHelper(maxSize = 720)
+
+        // Landscape input
+        var inputSize = Size(1920, 1080)
+        var outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(720, 405))
+
+        // Landscape input small height
+        inputSize = Size(1920, 200)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(720, 75))
+
+        // Portrait input
+        inputSize = Size(1080, 1920)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(405, 720))
+
+        // Portrait input small width
+        inputSize = Size(200, 1920)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(75, 720))
+
+        // Square input
+        inputSize = Size(1000, 1000)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(720, 720))
+
+        // Square input same size
+        inputSize = Size(720, 720)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(720, 720))
+
+        // Square input no downscaling
+        inputSize = Size(240, 240)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(240, 240))
+
+        // Small input landscape (no downscaling)
+        inputSize = Size(640, 480)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(640, 480))
+
+        // Small input portrait (no downscaling)
+        inputSize = Size(480, 640)
+        outputSize = helper.getOutputSize(inputSize)
+        assertThat(outputSize).isEqualTo(Size(480, 640))
+    }
+
+    @Test
+    fun `test calculateOptimalBitrate`() {
+        val helper = VideoCompressorHelper(maxSize = 720)
+        val inputSize = Size(1920, 1080)
+        var bitrate = helper.calculateOptimalBitrate(inputSize, frameRate = 30)
+        // Output size will be 720x405, so bitrate = 720*405*0.1*30 = 874800
+        assertThat(bitrate).isEqualTo(874_800L)
+        // Half frame rate, half bitrate
+        bitrate = helper.calculateOptimalBitrate(inputSize, frameRate = 15)
+        assertThat(bitrate).isEqualTo(437_400L)
+    }
+}

libraries/androidutils/src/test/kotlin/io/element/android/libraries/androidutils/text/LinkifierHelperTest.kt

@@ -0,0 +1,125 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.androidutils.text
+
+import android.telephony.TelephonyManager
+import android.text.style.URLSpan
+import androidx.core.text.getSpans
+import androidx.core.text.toSpannable
+import com.google.common.truth.Truth.assertThat
+import io.element.android.tests.testutils.WarmUpRule
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.shadow.api.Shadow.newInstanceOf
+
+@RunWith(RobolectricTestRunner::class)
+class LinkifierHelperTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `linkification finds URL`() {
+        val text = "A url https://matrix.org"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("https://matrix.org")
+    }
+
+    @Test
+    fun `linkification finds partial URL`() {
+        val text = "A partial url matrix.org/test"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("http://matrix.org/test")
+    }
+
+    @Test
+    fun `linkification finds domain`() {
+        val text = "A domain matrix.org"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("http://matrix.org")
+    }
+
+    @Test
+    fun `linkification finds email`() {
+        val text = "An email address john@doe.com"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("mailto:john@doe.com")
+    }
+
+    @Test
+    @Config(sdk = [30])
+    fun `linkification finds phone`() {
+        val text = "Test phone number +34950123456"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("tel:+34950123456")
+    }
+
+    @Test
+    @Config(sdk = [30])
+    fun `linkification finds phone in Germany`() {
+        // For some reason the linkification of phone numbers in Germany is very lenient and any number will fit here
+        val telephonyManager = shadowOf(newInstanceOf(TelephonyManager::class.java))
+        telephonyManager.setSimCountryIso("DE")
+
+        val text = "Test phone number 1234"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("tel:1234")
+    }
+
+    @Test
+    fun `linkification handles trailing dot`() {
+        val text = "A url https://matrix.org."
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("https://matrix.org")
+    }
+
+    @Test
+    fun `linkification handles trailing punctuation`() {
+        val text = "A url https://matrix.org!?; Check it out!"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("https://matrix.org")
+    }
+
+    @Test
+    fun `linkification handles parenthesis surrounding URL`() {
+        val text = "A url (this one (https://github.com/element-hq/element-android/issues/1234))"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("https://github.com/element-hq/element-android/issues/1234")
+    }
+
+    @Test
+    fun `linkification handles parenthesis in URL`() {
+        val text = "A url: (https://github.com/element-hq/element-android/READ(ME))"
+        val result = LinkifyHelper.linkify(text)
+        val urlSpans = result.toSpannable().getSpans<URLSpan>()
+        assertThat(urlSpans.size).isEqualTo(1)
+        assertThat(urlSpans.first().url).isEqualTo("https://github.com/element-hq/element-android/READ(ME)")
+    }
+}

libraries/androidutils/src/test/kotlin/io/element/android/libraries/androidutils/throttler/FirstThrottlerTest.kt

@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+@file:OptIn(ExperimentalCoroutinesApi::class)
+
+package io.element.android.libraries.androidutils.throttler
+
+import com.google.common.truth.Truth.assertThat
+import kotlinx.coroutines.ExperimentalCoroutinesApi
+import kotlinx.coroutines.test.advanceTimeBy
+import kotlinx.coroutines.test.runTest
+import org.junit.Test
+
+class FirstThrottlerTest {
+    @Test
+    fun `throttle canHandle returns the expected result`() = runTest {
+        val throttler = FirstThrottler(
+            minimumInterval = 300,
+            coroutineScope = backgroundScope,
+        )
+        assertThat(throttler.canHandle()).isTrue()
+        assertThat(throttler.canHandle()).isFalse()
+        advanceTimeBy(200)
+        assertThat(throttler.canHandle()).isFalse()
+        advanceTimeBy(110)
+        assertThat(throttler.canHandle()).isTrue()
+    }
+}

libraries/architecture/.gitignore

@@ -0,0 +1 @@
+/build

libraries/architecture/build.gradle.kts

@@ -0,0 +1,31 @@
+import extension.setupDependencyInjection
+import extension.testCommonDependencies
+
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023, 2024 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+plugins {
+    id("io.element.android-compose-library")
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.libraries.architecture"
+}
+
+setupDependencyInjection()
+
+dependencies {
+    api(projects.libraries.di)
+    api(projects.libraries.core)
+    api(libs.metro.runtime)
+    api(libs.appyx.core)
+    api(libs.androidx.lifecycle.runtime)
+    api(libs.molecule.runtime)
+
+    testCommonDependencies(libs)
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/AssistedNodeFactory.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+
+fun interface AssistedNodeFactory<NODE : Node> {
+    fun create(buildContext: BuildContext, plugins: List<Plugin>): NODE
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/AsyncAction.kt

@@ -0,0 +1,185 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.Stable
+import io.element.android.libraries.core.extensions.runCatchingExceptions
+import kotlinx.coroutines.TimeoutCancellationException
+import kotlin.contracts.ExperimentalContracts
+import kotlin.contracts.InvocationKind
+import kotlin.contracts.contract
+
+/**
+ * Sealed type that allows to model an asynchronous operation triggered by the user.
+ */
+@Stable
+sealed interface AsyncAction<out T> {
+    /**
+     * Represents an uninitialized operation (i.e. yet to be run by the user).
+     */
+    data object Uninitialized : AsyncAction<Nothing>
+
+    /**
+     * Represents an operation that is currently waiting for user confirmation.
+     */
+    interface Confirming : AsyncAction<Nothing>
+
+    data object ConfirmingNoParams : Confirming
+
+    /**
+     * User cancels the action, use this object to ask for confirmation.
+     */
+    data object ConfirmingCancellation : Confirming
+
+    /**
+     * Represents an operation that is currently ongoing.
+     */
+    data object Loading : AsyncAction<Nothing>
+
+    /**
+     * Represents a failed operation.
+     *
+     * @property error the error that caused the operation to fail.
+     */
+    data class Failure(
+        val error: Throwable,
+    ) : AsyncAction<Nothing>
+
+    /**
+     * Represents a successful operation.
+     *
+     * @param T the type of data returned by the operation.
+     * @property data the data returned by the operation.
+     */
+    data class Success<out T>(
+        val data: T,
+    ) : AsyncAction<T>
+
+    /**
+     * Returns the data returned by the operation, or null otherwise.
+     */
+    fun dataOrNull(): T? = when (this) {
+        is Success -> data
+        else -> null
+    }
+
+    /**
+     * Returns the error that caused the operation to fail, or null otherwise.
+     */
+    fun errorOrNull(): Throwable? = when (this) {
+        is Failure -> error
+        else -> null
+    }
+
+    fun isUninitialized(): Boolean = this == Uninitialized
+
+    fun isConfirming(): Boolean = this is Confirming
+
+    fun isLoading(): Boolean = this == Loading
+
+    fun isFailure(): Boolean = this is Failure
+
+    fun isSuccess(): Boolean = this is Success
+
+    fun isReady() = isSuccess() || isFailure()
+}
+
+suspend inline fun <T> MutableState<AsyncAction<T>>.runCatchingUpdatingState(
+    errorTransform: (Throwable) -> Throwable = { it },
+    block: () -> T,
+): Result<T> = runUpdatingState(
+    state = this,
+    errorTransform = errorTransform,
+    resultBlock = {
+        runCatchingExceptions {
+            block()
+        }
+    },
+)
+
+suspend inline fun <T> (suspend () -> T).runCatchingUpdatingState(
+    state: MutableState<AsyncAction<T>>,
+    errorTransform: (Throwable) -> Throwable = { it },
+): Result<T> = runUpdatingState(
+    state = state,
+    errorTransform = errorTransform,
+    resultBlock = {
+        runCatchingExceptions {
+            this()
+        }
+    },
+)
+
+suspend inline fun <T> MutableState<AsyncAction<T>>.runUpdatingState(
+    errorTransform: (Throwable) -> Throwable = { it },
+    resultBlock: () -> Result<T>,
+): Result<T> = runUpdatingState(
+    state = this,
+    errorTransform = errorTransform,
+    resultBlock = resultBlock,
+)
+
+/**
+ * Run the given block and update the state accordingly, using only Loading and Failure states.
+ * It's up to the caller to manage the Success state.
+ */
+@OptIn(ExperimentalContracts::class)
+inline fun <T> MutableState<AsyncAction<T>>.runUpdatingStateNoSuccess(
+    resultBlock: () -> Result<Unit>,
+): Result<Unit> {
+    contract {
+        callsInPlace(resultBlock, InvocationKind.EXACTLY_ONCE)
+    }
+    value = AsyncAction.Loading
+    return resultBlock()
+        .onFailure { failure ->
+            value = AsyncAction.Failure(failure)
+        }
+}
+
+/**
+ * Calls the specified [Result]-returning function [resultBlock]
+ * encapsulating its progress and return value into an [AsyncAction] while
+ * posting its updates to the MutableState [state].
+ *
+ * @param T the type of data returned by the operation.
+ * @param state the [MutableState] to post updates to.
+ * @param errorTransform a function to transform the error before posting it.
+ * @param resultBlock a suspending function that returns a [Result].
+ * @return the [Result] returned by [resultBlock].
+ */
+@Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
+suspend inline fun <T> runUpdatingState(
+    state: MutableState<AsyncAction<T>>,
+    errorTransform: (Throwable) -> Throwable = { it },
+    resultBlock: suspend () -> Result<T>,
+): Result<T> {
+    // Restore when the issue with contracts and AGP 8.13.x is fixed
+//    contract {
+//        callsInPlace(resultBlock, InvocationKind.EXACTLY_ONCE)
+//    }
+    state.value = AsyncAction.Loading
+    return try {
+        resultBlock()
+    } catch (e: TimeoutCancellationException) {
+        state.value = AsyncAction.Failure(errorTransform(e))
+        throw e
+    }.fold(
+        onSuccess = {
+            state.value = AsyncAction.Success(it)
+            Result.success(it)
+        },
+        onFailure = {
+            val error = errorTransform(it)
+            state.value = AsyncAction.Failure(error)
+            Result.failure(error)
+        }
+    )
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/AsyncData.kt

@@ -0,0 +1,174 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.Stable
+import io.element.android.libraries.core.extensions.runCatchingExceptions
+
+/**
+ * Sealed type that allows to model an asynchronous operation.
+ */
+@Stable
+sealed interface AsyncData<out T> {
+    /**
+     * Represents a failed operation.
+     *
+     * @param T the type of data returned by the operation.
+     * @property error the error that caused the operation to fail.
+     * @property prevData the data returned by a previous successful run of the operation if any.
+     */
+    data class Failure<out T>(
+        val error: Throwable,
+        val prevData: T? = null,
+    ) : AsyncData<T>
+
+    /**
+     * Represents an operation that is currently ongoing.
+     *
+     * @param T the type of data returned by the operation.
+     * @property prevData the data returned by a previous successful run of the operation if any.
+     */
+    data class Loading<out T>(
+        val prevData: T? = null,
+    ) : AsyncData<T>
+
+    /**
+     * Represents a successful operation.
+     *
+     * @param T the type of data returned by the operation.
+     * @property data the data returned by the operation.
+     */
+    data class Success<out T>(
+        val data: T,
+    ) : AsyncData<T>
+
+    /**
+     * Represents an uninitialized operation (i.e. yet to be run).
+     */
+    data object Uninitialized : AsyncData<Nothing>
+
+    /**
+     * Returns the data returned by the operation, or null otherwise.
+     *
+     * Please note this method may return stale data if the operation is not [Success].
+     */
+    fun dataOrNull(): T? = when (this) {
+        is Failure -> prevData
+        is Loading -> prevData
+        is Success -> data
+        Uninitialized -> null
+    }
+
+    /**
+     * Returns the error that caused the operation to fail, or null otherwise.
+     */
+    fun errorOrNull(): Throwable? = when (this) {
+        is Failure -> error
+        else -> null
+    }
+
+    fun isFailure(): Boolean = this is Failure<T>
+
+    fun isLoading(): Boolean = this is Loading<T>
+
+    fun isSuccess(): Boolean = this is Success<T>
+
+    fun isUninitialized(): Boolean = this == Uninitialized
+
+    fun isReady() = isSuccess() || isFailure()
+}
+
+suspend inline fun <T> MutableState<AsyncData<T>>.runCatchingUpdatingState(
+    errorTransform: (Throwable) -> Throwable = { it },
+    block: () -> T,
+): Result<T> = runUpdatingState(
+    state = this,
+    errorTransform = errorTransform,
+    resultBlock = {
+        runCatchingExceptions {
+            block()
+        }
+    },
+)
+
+suspend inline fun <T> (suspend () -> T).runCatchingUpdatingState(
+    state: MutableState<AsyncData<T>>,
+    errorTransform: (Throwable) -> Throwable = { it },
+): Result<T> = runUpdatingState(
+    state = state,
+    errorTransform = errorTransform,
+    resultBlock = {
+        runCatchingExceptions {
+            this()
+        }
+    },
+)
+
+suspend inline fun <T> MutableState<AsyncData<T>>.runUpdatingState(
+    errorTransform: (Throwable) -> Throwable = { it },
+    resultBlock: () -> Result<T>,
+): Result<T> = runUpdatingState(
+    state = this,
+    errorTransform = errorTransform,
+    resultBlock = resultBlock,
+)
+
+/**
+ * Calls the specified [Result]-returning function [resultBlock]
+ * encapsulating its progress and return value into an [AsyncData] while
+ * posting its updates to the MutableState [state].
+ *
+ * @param T the type of data returned by the operation.
+ * @param state the [MutableState] to post updates to.
+ * @param errorTransform a function to transform the error before posting it.
+ * @param resultBlock a suspending function that returns a [Result].
+ * @return the [Result] returned by [resultBlock].
+ */
+@Suppress("REDUNDANT_INLINE_SUSPEND_FUNCTION_TYPE")
+suspend inline fun <T> runUpdatingState(
+    state: MutableState<AsyncData<T>>,
+    errorTransform: (Throwable) -> Throwable = { it },
+    resultBlock: suspend () -> Result<T>,
+): Result<T> {
+    // Restore when the issue with contracts and AGP 8.13.x is fixed
+//    contract {
+//        callsInPlace(resultBlock, InvocationKind.EXACTLY_ONCE)
+//    }
+    val prevData = state.value.dataOrNull()
+    state.value = AsyncData.Loading(prevData = prevData)
+    return resultBlock().fold(
+        onSuccess = {
+            state.value = AsyncData.Success(it)
+            Result.success(it)
+        },
+        onFailure = {
+            val error = errorTransform(it)
+            state.value = AsyncData.Failure(
+                error = error,
+                prevData = prevData,
+            )
+            Result.failure(error)
+        }
+    )
+}
+
+inline fun <T, R> AsyncData<T>.map(
+    transform: (T) -> R,
+): AsyncData<R> {
+    return when (this) {
+        is AsyncData.Failure -> AsyncData.Failure(
+            error = error,
+            prevData = prevData?.let { transform(prevData) }
+        )
+        is AsyncData.Loading -> AsyncData.Loading(prevData?.let { transform(prevData) })
+        is AsyncData.Success -> AsyncData.Success(transform(data))
+        AsyncData.Uninitialized -> AsyncData.Uninitialized
+    }
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/BaseFlowNode.kt

@@ -0,0 +1,98 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import androidx.compose.animation.core.Spring
+import androidx.compose.animation.core.spring
+import androidx.compose.foundation.layout.Box
+import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.Stable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.children.ChildEntry
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.navigation.model.combined.plus
+import com.bumble.appyx.core.navigation.model.permanent.PermanentNavModel
+import com.bumble.appyx.core.navigation.transition.TransitionHandler
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.node.ParentNode
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.navmodel.backstack.BackStack
+import com.bumble.appyx.navmodel.backstack.transitionhandler.rememberBackstackFader
+import com.bumble.appyx.navmodel.backstack.transitionhandler.rememberBackstackSlider
+import io.element.android.libraries.architecture.overlay.Overlay
+
+/**
+ * This class is a [ParentNode] that contains a [BackStack] and an [Overlay]. It is used to represent a flow in the app.
+ * Should be used instead of [ParentNode] in flow nodes.
+ */
+@Stable
+abstract class BaseFlowNode<NavTarget : Any>(
+    val backstack: BackStack<NavTarget>,
+    buildContext: BuildContext,
+    plugins: List<Plugin>,
+    val overlay: Overlay<NavTarget> = Overlay(null),
+    val permanentNavModel: PermanentNavModel<NavTarget> = PermanentNavModel(emptySet(), null),
+    childKeepMode: ChildEntry.KeepMode = ChildEntry.KeepMode.KEEP,
+) : ParentNode<NavTarget>(
+    navModel = overlay + backstack + permanentNavModel,
+    buildContext = buildContext,
+    plugins = plugins,
+    childKeepMode = childKeepMode,
+) {
+    override fun onBuilt() {
+        super.onBuilt()
+        lifecycle.logLifecycle(this::class.java.simpleName)
+        whenChildAttached<Node> { _, child ->
+            // BackstackNode will be logged by their parent.
+            if (child !is BaseFlowNode<*>) {
+                child.lifecycle.logLifecycle(child::class.java.simpleName)
+            }
+        }
+    }
+}
+
+@Composable
+inline fun <reified NavTarget : Any> BaseFlowNode<NavTarget>.BackstackView(
+    modifier: Modifier = Modifier,
+    transitionHandler: TransitionHandler<NavTarget, BackStack.State> = rememberBackstackSlider(
+        transitionSpec = { spring(stiffness = Spring.StiffnessMediumLow) },
+    ),
+) {
+    Children(
+        modifier = modifier,
+        navModel = backstack,
+        transitionHandler = transitionHandler,
+    )
+}
+
+@Composable
+inline fun <reified NavTarget : Any> BaseFlowNode<NavTarget>.OverlayView(
+    modifier: Modifier = Modifier,
+    transitionHandler: TransitionHandler<NavTarget, BackStack.State> = rememberBackstackFader(),
+) {
+    Children(
+        modifier = modifier,
+        navModel = overlay,
+        transitionHandler = transitionHandler,
+    )
+}
+
+@Composable
+inline fun <reified NavTarget : Any> BaseFlowNode<NavTarget>.BackstackWithOverlayBox(
+    modifier: Modifier = Modifier,
+    content: @Composable BoxScope.() -> Unit = {},
+) {
+    Box(modifier = modifier) {
+        BackstackView()
+        OverlayView()
+        content()
+    }
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/Bindings.kt

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import android.content.Context
+import android.content.ContextWrapper
+import com.bumble.appyx.core.node.Node
+import io.element.android.libraries.di.DependencyInjectionGraphOwner
+
+inline fun <reified T : Any> Node.bindings() = bindings(T::class.java)
+inline fun <reified T : Any> Context.bindings() = bindings(T::class.java)
+
+fun <T : Any> Context.bindings(klass: Class<T>): T {
+    // search the components in the dependency injection graph
+    return generateSequence(this) { (it as? ContextWrapper)?.baseContext }
+        .plus(applicationContext)
+        .filterIsInstance<DependencyInjectionGraphOwner>()
+        .map { it.graph }
+        .flatMap { it as? Collection<*> ?: listOf(it) }
+        .filterIsInstance(klass)
+        .firstOrNull()
+        ?: error("Unable to find bindings for ${klass.name}")
+}
+
+fun <T : Any> Node.bindings(klass: Class<T>): T {
+    // search the components in the node hierarchy
+    return generateSequence(this, Node::parent)
+        .filterIsInstance<DependencyInjectionGraphOwner>()
+        .map { it.graph }
+        .flatMap { it as? Collection<*> ?: listOf(it) }
+        .filterIsInstance(klass)
+        .firstOrNull()
+        ?: error("Unable to find bindings for ${klass.name}")
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/FeatureEntryPoint.kt

@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+
+/**
+ * This interface represents an entrypoint to a feature. Should be used to return the entrypoint node of the feature without exposing the internal types.
+ */
+interface FeatureEntryPoint
+
+/**
+ * Can be used when the feature only exposes a simple node without the need of plugins.
+ */
+fun interface SimpleFeatureEntryPoint : FeatureEntryPoint {
+    fun createNode(parentNode: Node, buildContext: BuildContext): Node
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/LifecycleExt.kt

@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import androidx.lifecycle.Lifecycle
+import com.bumble.appyx.core.lifecycle.subscribe
+import timber.log.Timber
+
+fun Lifecycle.logLifecycle(name: String) {
+    subscribe(
+        onCreate = { Timber.tag("Lifecycle").d("onCreate $name") },
+        onPause = { Timber.tag("Lifecycle").d("onPause $name") },
+        onResume = { Timber.tag("Lifecycle").d("onResume $name") },
+        onDestroy = { Timber.tag("Lifecycle").d("onDestroy $name") },
+    )
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/NodeCallback.kt

@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import com.bumble.appyx.core.plugin.plugins
+
+inline fun <reified I : Plugin> Node.callback(): I {
+    return requireNotNull(plugins<I>().singleOrNull()) { "Make sure to actually pass a Callback plugin to your node" }
+}

libraries/architecture/src/main/kotlin/io/element/android/libraries/architecture/NodeFactories.kt

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2025 Element Creations Ltd.
+ * Copyright 2023-2025 New Vector Ltd.
+ *
+ * SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-Element-Commercial.
+ * Please see LICENSE files in the repository root for full details.
+ */
+
+package io.element.android.libraries.architecture
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.Multibinds
+import kotlin.reflect.KClass
+
+inline fun <reified N : Node> Node.createNode(
+    buildContext: BuildContext,
+    plugins: List<Plugin> = emptyList()
+): N {
+    val bindings: NodeFactoriesBindings = bindings()
+    return bindings.createNode(buildContext, plugins)
+}
+
+inline fun <reified N : Node> NodeFactoriesBindings.createNode(
+    buildContext: BuildContext,
+    plugins: List<Plugin>,
+): N {
+    val nodeClass = N::class
+    val nodeFactoryMap = nodeFactories()
+    // Note to developers: If you got the error below, make sure to build again after
+    // clearing the cache (sometimes several times) to let codegen generate the NodeFactory.
+    val nodeFactory = nodeFactoryMap[nodeClass] ?: error("Cannot find NodeFactory for ${nodeClass.java.name}.")
+
+    @Suppress("UNCHECKED_CAST")
+    val castedNodeFactory = nodeFactory as? AssistedNodeFactory<N>
+    val node = castedNodeFactory?.create(buildContext, plugins)
+    return node as N
+}
+
+fun interface NodeFactoriesBindings {
+    @Multibinds
+    fun nodeFactories(): Map<KClass<out Node>, AssistedNodeFactory<*>>
+}