First Commit

features/share/api/build.gradle.kts

@@ -0,0 +1,21 @@
+/*
+ * 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.
+ */
+
+plugins {
+    id("io.element.android-library")
+    id("kotlin-parcelize")
+}
+
+android {
+    namespace = "io.element.android.features.share.api"
+}
+
+dependencies {
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.matrix.api)
+}

features/share/api/src/main/kotlin/io/element/android/features/share/api/ShareEntryPoint.kt

@@ -0,0 +1,31 @@
+/*
+ * 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.features.share.api
+
+import android.content.Intent
+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.RoomId
+
+interface ShareEntryPoint : FeatureEntryPoint {
+    data class Params(val intent: Intent)
+
+    fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        params: Params,
+        callback: Callback,
+    ): Node
+
+    interface Callback : Plugin {
+        fun onDone(roomIds: List<RoomId>)
+    }
+}

features/share/impl/build.gradle.kts

@@ -0,0 +1,52 @@
+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.features.share.impl"
+
+    testOptions {
+        unitTests {
+            isIncludeAndroidResources = true
+        }
+    }
+}
+
+setupDependencyInjection()
+
+dependencies {
+    implementation(projects.appconfig)
+    implementation(projects.libraries.androidutils)
+    implementation(projects.libraries.core)
+    implementation(projects.libraries.architecture)
+    implementation(projects.libraries.featureflag.api)
+    implementation(projects.libraries.matrix.api)
+    implementation(projects.libraries.matrixui)
+    implementation(projects.libraries.designsystem)
+    implementation(projects.libraries.mediaupload.api)
+    implementation(projects.libraries.roomselect.api)
+    implementation(projects.libraries.uiStrings)
+    implementation(projects.libraries.testtags)
+    implementation(projects.services.appnavstate.api)
+    api(libs.statemachine)
+    api(projects.features.share.api)
+
+    testCommonDependencies(libs, true)
+    testImplementation(projects.libraries.matrix.test)
+    testImplementation(projects.libraries.mediaupload.test)
+    testImplementation(projects.libraries.preferences.test)
+    testImplementation(projects.libraries.roomselect.test)
+    testImplementation(projects.services.appnavstate.impl)
+}

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/DefaultShareEntryPoint.kt

@@ -0,0 +1,34 @@
+/*
+ * 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.features.share.impl
+
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.node.Node
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.features.share.api.ShareEntryPoint
+import io.element.android.libraries.architecture.createNode
+import io.element.android.libraries.di.SessionScope
+
+@ContributesBinding(SessionScope::class)
+class DefaultShareEntryPoint : ShareEntryPoint {
+    override fun createNode(
+        parentNode: Node,
+        buildContext: BuildContext,
+        params: ShareEntryPoint.Params,
+        callback: ShareEntryPoint.Callback,
+    ): Node {
+        return parentNode.createNode<ShareNode>(
+            buildContext = buildContext,
+            plugins = listOf(
+                ShareNode.Inputs(intent = params.intent),
+                callback,
+            )
+        )
+    }
+}

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/ShareEvents.kt

@@ -0,0 +1,13 @@
+/*
+ * 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.features.share.impl
+
+sealed interface ShareEvents {
+    data object ClearError : ShareEvents
+}

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/ShareIntentHandler.kt

@@ -0,0 +1,141 @@
+/*
+ * 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.features.share.impl
+
+import android.content.ComponentName
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.content.pm.ResolveInfo
+import android.net.Uri
+import android.os.Build
+import androidx.core.content.IntentCompat
+import dev.zacsweers.metro.AppScope
+import dev.zacsweers.metro.ContributesBinding
+import io.element.android.libraries.androidutils.compat.queryIntentActivitiesCompat
+import io.element.android.libraries.core.mimetype.MimeTypes
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeAny
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeApplication
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeAudio
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeFile
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeImage
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeText
+import io.element.android.libraries.core.mimetype.MimeTypes.isMimeTypeVideo
+import io.element.android.libraries.di.annotations.ApplicationContext
+import timber.log.Timber
+
+interface ShareIntentHandler {
+    data class UriToShare(
+        val uri: Uri,
+        val mimeType: String,
+    )
+
+    /**
+     * This methods aims to handle incoming share intents.
+     *
+     * @return true if it can handle the intent data, false otherwise
+     */
+    suspend fun handleIncomingShareIntent(
+        intent: Intent,
+        onUris: suspend (List<UriToShare>) -> Boolean,
+        onPlainText: suspend (String) -> Boolean,
+    ): Boolean
+}
+
+@ContributesBinding(AppScope::class)
+class DefaultShareIntentHandler(
+    @ApplicationContext private val context: Context,
+) : ShareIntentHandler {
+    override suspend fun handleIncomingShareIntent(
+        intent: Intent,
+        onUris: suspend (List<ShareIntentHandler.UriToShare>) -> Boolean,
+        onPlainText: suspend (String) -> Boolean,
+    ): Boolean {
+        val type = intent.resolveType(context) ?: return false
+        val uris = getIncomingUris(intent, type)
+        return when {
+            uris.isEmpty() && type == MimeTypes.PlainText -> handlePlainText(intent, onPlainText)
+            type.isMimeTypeImage() ||
+                type.isMimeTypeVideo() ||
+                type.isMimeTypeAudio() ||
+                type.isMimeTypeApplication() ||
+                type.isMimeTypeFile() ||
+                type.isMimeTypeText() ||
+                type.isMimeTypeAny() -> {
+                val result = onUris(uris)
+                revokeUriPermissions(uris.map { it.uri })
+                result
+            }
+            else -> false
+        }
+    }
+
+    private suspend fun handlePlainText(intent: Intent, onPlainText: suspend (String) -> Boolean): Boolean {
+        val content = intent.getCharSequenceExtra(Intent.EXTRA_TEXT)?.toString()
+        return if (content?.isNotEmpty() == true) {
+            onPlainText(content)
+        } else {
+            false
+        }
+    }
+
+    /**
+     * Use this function to retrieve files which are shared from another application or internally
+     * by using android.intent.action.SEND or android.intent.action.SEND_MULTIPLE actions.
+     */
+    private fun getIncomingUris(intent: Intent, fallbackMimeType: String): List<ShareIntentHandler.UriToShare> {
+        val uriList = mutableListOf<Uri>()
+        if (intent.action == Intent.ACTION_SEND) {
+            IntentCompat.getParcelableExtra(intent, Intent.EXTRA_STREAM, Uri::class.java)
+                ?.let { uriList.add(it) }
+        } else if (intent.action == Intent.ACTION_SEND_MULTIPLE) {
+            IntentCompat.getParcelableArrayListExtra(intent, Intent.EXTRA_STREAM, Uri::class.java)
+                ?.let { uriList.addAll(it) }
+        }
+        val resInfoList: List<ResolveInfo> = context.packageManager.queryIntentActivitiesCompat(intent, PackageManager.MATCH_DEFAULT_ONLY)
+        uriList.forEach { uri ->
+            resInfoList.forEach resolve@{ resolveInfo ->
+                val packageName: String = resolveInfo.activityInfo.packageName
+                // Replace implicit intent by an explicit to fix crash on some devices like Xiaomi.
+                // see https://juejin.cn/post/7031736325422186510
+                try {
+                    context.grantUriPermission(packageName, uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                } catch (e: Exception) {
+                    Timber.w(e, "Unable to grant Uri permission")
+                    return@resolve
+                }
+                intent.action = null
+                intent.component = ComponentName(packageName, resolveInfo.activityInfo.name)
+            }
+        }
+        return uriList.map { uri ->
+            // The value in fallbackMimeType can be wrong, especially if several uris were received
+            // in the same intent (i.e. 'image/*'). We need to check the mime type of each uri.
+            val mimeType = context.contentResolver.getType(uri) ?: fallbackMimeType
+            ShareIntentHandler.UriToShare(
+                uri = uri,
+                mimeType = mimeType,
+            )
+        }
+    }
+
+    private fun revokeUriPermissions(uris: List<Uri>) {
+        uris.forEach { uri ->
+            try {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+                    context.revokeUriPermission(context.packageName, uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                } else {
+                    context.revokeUriPermission(uri, Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                }
+            } catch (e: Exception) {
+                Timber.w(e, "Unable to revoke Uri permission")
+            }
+        }
+    }
+}

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/ShareNode.kt

@@ -0,0 +1,93 @@
+/*
+ * 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.features.share.impl
+
+import android.content.Intent
+import android.os.Parcelable
+import androidx.compose.foundation.layout.Box
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.Modifier
+import com.bumble.appyx.core.composable.Children
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.core.navigation.model.permanent.PermanentNavModel
+import com.bumble.appyx.core.node.Node
+import com.bumble.appyx.core.node.ParentNode
+import com.bumble.appyx.core.plugin.Plugin
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedInject
+import io.element.android.annotations.ContributesNode
+import io.element.android.features.share.api.ShareEntryPoint
+import io.element.android.libraries.architecture.NodeInputs
+import io.element.android.libraries.architecture.callback
+import io.element.android.libraries.architecture.inputs
+import io.element.android.libraries.di.SessionScope
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.roomselect.api.RoomSelectEntryPoint
+import io.element.android.libraries.roomselect.api.RoomSelectMode
+import kotlinx.parcelize.Parcelize
+
+@ContributesNode(SessionScope::class)
+@AssistedInject
+class ShareNode(
+    @Assisted buildContext: BuildContext,
+    @Assisted plugins: List<Plugin>,
+    presenterFactory: SharePresenter.Factory,
+    private val roomSelectEntryPoint: RoomSelectEntryPoint,
+) : ParentNode<ShareNode.NavTarget>(
+    navModel = PermanentNavModel(
+        navTargets = setOf(NavTarget),
+        savedStateMap = buildContext.savedStateMap,
+    ),
+    buildContext = buildContext,
+    plugins = plugins,
+) {
+    @Parcelize
+    object NavTarget : Parcelable
+
+    data class Inputs(val intent: Intent) : NodeInputs
+
+    private val inputs = inputs<Inputs>()
+    private val presenter = presenterFactory.create(inputs.intent)
+    private val callback: ShareEntryPoint.Callback = callback()
+
+    override fun resolve(navTarget: NavTarget, buildContext: BuildContext): Node {
+        val callback = object : RoomSelectEntryPoint.Callback {
+            override fun onRoomSelected(roomIds: List<RoomId>) {
+                presenter.onRoomSelected(roomIds)
+            }
+
+            override fun onCancel() {
+                callback.onDone(emptyList())
+            }
+        }
+
+        return roomSelectEntryPoint.createNode(
+            parentNode = this,
+            buildContext = buildContext,
+            params = RoomSelectEntryPoint.Params(mode = RoomSelectMode.Share),
+            callback = callback,
+        )
+    }
+
+    @Composable
+    override fun View(modifier: Modifier) {
+        Box(modifier = modifier) {
+            // Will render to room select screen
+            Children(
+                navModel = navModel,
+            )
+
+            val state = presenter.present()
+            ShareView(
+                state = state,
+                onShareSuccess = callback::onDone,
+            )
+        }
+    }
+}

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/SharePresenter.kt

@@ -0,0 +1,135 @@
+/*
+ * 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.features.share.impl
+
+import android.content.Intent
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.MutableState
+import androidx.compose.runtime.mutableStateOf
+import dev.zacsweers.metro.Assisted
+import dev.zacsweers.metro.AssistedFactory
+import dev.zacsweers.metro.AssistedInject
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.architecture.Presenter
+import io.element.android.libraries.architecture.runCatchingUpdatingState
+import io.element.android.libraries.core.bool.orFalse
+import io.element.android.libraries.di.annotations.SessionCoroutineScope
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.matrix.api.room.JoinedRoom
+import io.element.android.libraries.mediaupload.api.MediaOptimizationConfigProvider
+import io.element.android.libraries.mediaupload.api.MediaSenderRoomFactory
+import io.element.android.services.appnavstate.api.ActiveRoomsHolder
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.launch
+import kotlin.coroutines.cancellation.CancellationException
+
+@AssistedInject
+class SharePresenter(
+    @Assisted private val intent: Intent,
+    @SessionCoroutineScope
+    private val sessionCoroutineScope: CoroutineScope,
+    private val shareIntentHandler: ShareIntentHandler,
+    private val matrixClient: MatrixClient,
+    private val mediaSenderRoomFactory: MediaSenderRoomFactory,
+    private val activeRoomsHolder: ActiveRoomsHolder,
+    private val mediaOptimizationConfigProvider: MediaOptimizationConfigProvider,
+) : Presenter<ShareState> {
+    @AssistedFactory
+    fun interface Factory {
+        fun create(intent: Intent): SharePresenter
+    }
+
+    private val shareActionState: MutableState<AsyncAction<List<RoomId>>> = mutableStateOf(AsyncAction.Uninitialized)
+
+    fun onRoomSelected(roomIds: List<RoomId>) {
+        sessionCoroutineScope.share(intent, roomIds)
+    }
+
+    @Composable
+    override fun present(): ShareState {
+        fun handleEvent(event: ShareEvents) {
+            when (event) {
+                ShareEvents.ClearError -> shareActionState.value = AsyncAction.Uninitialized
+            }
+        }
+
+        return ShareState(
+            shareAction = shareActionState.value,
+            eventSink = ::handleEvent,
+        )
+    }
+
+    private suspend fun getJoinedRoom(roomId: RoomId): JoinedRoom? {
+        return activeRoomsHolder.getActiveRoom(matrixClient.sessionId)
+            ?.takeIf { it.roomId == roomId }
+            ?: matrixClient.getJoinedRoom(roomId)
+    }
+
+    private fun CoroutineScope.share(
+        intent: Intent,
+        roomIds: List<RoomId>,
+    ) = launch {
+        suspend {
+            val result = shareIntentHandler.handleIncomingShareIntent(
+                intent,
+                onUris = { filesToShare ->
+                    if (filesToShare.isEmpty()) {
+                        false
+                    } else {
+                        roomIds
+                            .map { roomId ->
+                                val room = getJoinedRoom(roomId) ?: return@map false
+                                val mediaSender = mediaSenderRoomFactory.create(room = room)
+                                filesToShare
+                                    .map { fileToShare ->
+                                        val result = mediaSender.sendMedia(
+                                            uri = fileToShare.uri,
+                                            mimeType = fileToShare.mimeType,
+                                            mediaOptimizationConfig = mediaOptimizationConfigProvider.get(),
+                                        )
+                                        // If the coroutine was cancelled, destroy the room and rethrow the exception
+                                        val cancellationException = result.exceptionOrNull() as? CancellationException
+                                        if (cancellationException != null) {
+                                            if (activeRoomsHolder.getActiveRoomMatching(matrixClient.sessionId, roomId) == null) {
+                                                room.destroy()
+                                            }
+                                            throw cancellationException
+                                        }
+                                        result.isSuccess
+                                    }
+                                    .all { isSuccess -> isSuccess }
+                                    .also {
+                                        if (activeRoomsHolder.getActiveRoomMatching(matrixClient.sessionId, roomId) == null) {
+                                            room.destroy()
+                                        }
+                                    }
+                            }
+                            .all { it }
+                    }
+                },
+                onPlainText = { text ->
+                    roomIds
+                        .map { roomId ->
+                            getJoinedRoom(roomId)?.liveTimeline?.sendMessage(
+                                body = text,
+                                htmlBody = null,
+                                intentionalMentions = emptyList(),
+                            )?.isSuccess.orFalse()
+                        }
+                        .all { it }
+                }
+            )
+            if (!result) {
+                error("Failed to handle incoming share intent")
+            }
+            roomIds
+        }.runCatchingUpdatingState(shareActionState)
+    }
+}

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/ShareState.kt

@@ -0,0 +1,17 @@
+/*
+ * 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.features.share.impl
+
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+
+data class ShareState(
+    val shareAction: AsyncAction<List<RoomId>>,
+    val eventSink: (ShareEvents) -> Unit
+)

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/ShareStateProvider.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.features.share.impl
+
+import androidx.compose.ui.tooling.preview.PreviewParameterProvider
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.matrix.api.core.RoomId
+
+open class ShareStateProvider : PreviewParameterProvider<ShareState> {
+    override val values: Sequence<ShareState>
+        get() = sequenceOf(
+            aShareState(),
+            aShareState(
+                shareAction = AsyncAction.Loading,
+            ),
+            aShareState(
+                shareAction = AsyncAction.Success(
+                    listOf(RoomId("!room2:domain")),
+                )
+            ),
+            aShareState(
+                shareAction = AsyncAction.Failure(RuntimeException("error")),
+            ),
+        )
+}
+
+fun aShareState(
+    shareAction: AsyncAction<List<RoomId>> = AsyncAction.Uninitialized,
+    eventSink: (ShareEvents) -> Unit = {}
+) = ShareState(
+    shareAction = shareAction,
+    eventSink = eventSink
+)

features/share/impl/src/main/kotlin/io/element/android/features/share/impl/ShareView.kt

@@ -0,0 +1,41 @@
+/*
+ * 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.features.share.impl
+
+import androidx.compose.runtime.Composable
+import androidx.compose.ui.tooling.preview.PreviewParameter
+import io.element.android.libraries.designsystem.components.async.AsyncActionView
+import io.element.android.libraries.designsystem.preview.ElementPreview
+import io.element.android.libraries.designsystem.preview.PreviewsDayNight
+import io.element.android.libraries.matrix.api.core.RoomId
+
+@Composable
+fun ShareView(
+    state: ShareState,
+    onShareSuccess: (List<RoomId>) -> Unit,
+) {
+    AsyncActionView(
+        async = state.shareAction,
+        onSuccess = {
+            onShareSuccess(it)
+        },
+        onErrorDismiss = {
+            state.eventSink(ShareEvents.ClearError)
+        },
+    )
+}
+
+@PreviewsDayNight
+@Composable
+internal fun ShareViewPreview(@PreviewParameter(ShareStateProvider::class) state: ShareState) = ElementPreview {
+    ShareView(
+        state = state,
+        onShareSuccess = {}
+    )
+}

features/share/impl/src/test/kotlin/io/element/android/features/share/impl/DefaultShareEntryPointTest.kt

@@ -0,0 +1,59 @@
+/*
+ * 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.features.share.impl
+
+import android.content.Intent
+import androidx.arch.core.executor.testing.InstantTaskExecutorRule
+import com.bumble.appyx.core.modality.BuildContext
+import com.bumble.appyx.testing.junit4.util.MainDispatcherRule
+import com.google.common.truth.Truth.assertThat
+import io.element.android.features.share.api.ShareEntryPoint
+import io.element.android.libraries.matrix.api.core.RoomId
+import io.element.android.libraries.roomselect.test.FakeRoomSelectEntryPoint
+import io.element.android.tests.testutils.lambda.lambdaError
+import io.element.android.tests.testutils.node.TestParentNode
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+
+class DefaultShareEntryPointTest {
+    @get:Rule
+    val instantTaskExecutorRule = InstantTaskExecutorRule()
+
+    @get:Rule
+    val mainDispatcherRule = MainDispatcherRule()
+
+    @Test
+    fun `test node builder`() = runTest {
+        val entryPoint = DefaultShareEntryPoint()
+        val parentNode = TestParentNode.create { buildContext, plugins ->
+            ShareNode(
+                buildContext = buildContext,
+                plugins = plugins,
+                presenterFactory = { createSharePresenter() },
+                roomSelectEntryPoint = FakeRoomSelectEntryPoint(),
+            )
+        }
+        val callback = object : ShareEntryPoint.Callback {
+            override fun onDone(roomIds: List<RoomId>) = lambdaError()
+        }
+        val params = ShareEntryPoint.Params(
+            intent = Intent(),
+        )
+        val result = entryPoint.createNode(
+            parentNode = parentNode,
+            buildContext = BuildContext.root(null),
+            params = params,
+            callback = callback,
+        )
+        assertThat(result).isInstanceOf(ShareNode::class.java)
+        assertThat(result.plugins).contains(ShareNode.Inputs(params.intent))
+        assertThat(result.plugins).contains(callback)
+    }
+}

features/share/impl/src/test/kotlin/io/element/android/features/share/impl/FakeShareIntentHandler.kt

@@ -0,0 +1,27 @@
+/*
+ * 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.features.share.impl
+
+import android.content.Intent
+
+class FakeShareIntentHandler(
+    private val onIncomingShareIntent: suspend (
+        Intent,
+        suspend (List<ShareIntentHandler.UriToShare>) -> Boolean,
+        suspend (String) -> Boolean,
+    ) -> Boolean = { _, _, _ -> false },
+) : ShareIntentHandler {
+    override suspend fun handleIncomingShareIntent(
+        intent: Intent,
+        onUris: suspend (List<ShareIntentHandler.UriToShare>) -> Boolean,
+        onPlainText: suspend (String) -> Boolean,
+    ): Boolean {
+        return onIncomingShareIntent(intent, onUris, onPlainText)
+    }
+}

features/share/impl/src/test/kotlin/io/element/android/features/share/impl/SharePresenterTest.kt

@@ -0,0 +1,178 @@
+/*
+ * 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.features.share.impl
+
+import android.content.Intent
+import android.net.Uri
+import app.cash.molecule.RecompositionMode
+import app.cash.molecule.moleculeFlow
+import app.cash.turbine.test
+import com.google.common.truth.Truth.assertThat
+import io.element.android.libraries.architecture.AsyncAction
+import io.element.android.libraries.core.mimetype.MimeTypes
+import io.element.android.libraries.matrix.api.MatrixClient
+import io.element.android.libraries.matrix.test.A_MESSAGE
+import io.element.android.libraries.matrix.test.A_ROOM_ID
+import io.element.android.libraries.matrix.test.FakeMatrixClient
+import io.element.android.libraries.matrix.test.room.FakeJoinedRoom
+import io.element.android.libraries.matrix.test.timeline.FakeTimeline
+import io.element.android.libraries.mediaupload.api.MediaOptimizationConfigProvider
+import io.element.android.libraries.mediaupload.api.MediaSenderRoomFactory
+import io.element.android.libraries.mediaupload.test.FakeMediaOptimizationConfigProvider
+import io.element.android.libraries.mediaupload.test.FakeMediaSender
+import io.element.android.services.appnavstate.api.ActiveRoomsHolder
+import io.element.android.services.appnavstate.impl.DefaultActiveRoomsHolder
+import io.element.android.tests.testutils.WarmUpRule
+import io.element.android.tests.testutils.lambda.lambdaRecorder
+import kotlinx.coroutines.test.TestScope
+import kotlinx.coroutines.test.runTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+
+@RunWith(RobolectricTestRunner::class)
+class SharePresenterTest {
+    @get:Rule
+    val warmUpRule = WarmUpRule()
+
+    @Test
+    fun `present - initial state`() = runTest {
+        val presenter = createSharePresenter()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.shareAction.isUninitialized()).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - on room selected error then clear error`() = runTest {
+        val presenter = createSharePresenter()
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.shareAction.isUninitialized()).isTrue()
+            presenter.onRoomSelected(listOf(A_ROOM_ID))
+            assertThat(awaitItem().shareAction.isLoading()).isTrue()
+            val failure = awaitItem()
+            assertThat(failure.shareAction.isFailure()).isTrue()
+            failure.eventSink.invoke(ShareEvents.ClearError)
+            assertThat(awaitItem().shareAction.isUninitialized()).isTrue()
+        }
+    }
+
+    @Test
+    fun `present - on room selected ok`() = runTest {
+        val presenter = createSharePresenter(
+            shareIntentHandler = FakeShareIntentHandler { _, _, _ -> true }
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.shareAction.isUninitialized()).isTrue()
+            presenter.onRoomSelected(listOf(A_ROOM_ID))
+            assertThat(awaitItem().shareAction.isLoading()).isTrue()
+            val success = awaitItem()
+            assertThat(success.shareAction.isSuccess()).isTrue()
+            assertThat(success.shareAction).isEqualTo(AsyncAction.Success(listOf(A_ROOM_ID)))
+        }
+    }
+
+    @Test
+    fun `present - send text ok`() = runTest {
+        val joinedRoom = FakeJoinedRoom(
+            liveTimeline = FakeTimeline().apply {
+                sendMessageLambda = { _, _, _ -> Result.success(Unit) }
+            },
+        )
+        val matrixClient = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, joinedRoom)
+        }
+        val presenter = createSharePresenter(
+            matrixClient = matrixClient,
+            shareIntentHandler = FakeShareIntentHandler { _, _, onText ->
+                onText(A_MESSAGE)
+            }
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.shareAction.isUninitialized()).isTrue()
+            presenter.onRoomSelected(listOf(A_ROOM_ID))
+            assertThat(awaitItem().shareAction.isLoading()).isTrue()
+            val success = awaitItem()
+            assertThat(success.shareAction.isSuccess()).isTrue()
+            assertThat(success.shareAction).isEqualTo(AsyncAction.Success(listOf(A_ROOM_ID)))
+        }
+    }
+
+    @Test
+    fun `present - send media ok`() = runTest {
+        val sendMediaResult = lambdaRecorder<Result<Unit>> { Result.success(Unit) }
+        val joinedRoom = FakeJoinedRoom(
+            liveTimeline = FakeTimeline(),
+        )
+        val matrixClient = FakeMatrixClient().apply {
+            givenGetRoomResult(A_ROOM_ID, joinedRoom)
+        }
+        val mediaSender = FakeMediaSender(
+            sendMediaResult = sendMediaResult,
+        )
+        val presenter = createSharePresenter(
+            matrixClient = matrixClient,
+            shareIntentHandler = FakeShareIntentHandler { _, onFile, _ ->
+                onFile(
+                    listOf(
+                        ShareIntentHandler.UriToShare(
+                            uri = Uri.parse("content://image.jpg"),
+                            mimeType = MimeTypes.Jpeg,
+                        )
+                    )
+                )
+            },
+            mediaSenderRoomFactory = MediaSenderRoomFactory { mediaSender },
+        )
+        moleculeFlow(RecompositionMode.Immediate) {
+            presenter.present()
+        }.test {
+            val initialState = awaitItem()
+            assertThat(initialState.shareAction.isUninitialized()).isTrue()
+            presenter.onRoomSelected(listOf(A_ROOM_ID))
+            assertThat(awaitItem().shareAction.isLoading()).isTrue()
+            val success = awaitItem()
+            assertThat(success.shareAction.isSuccess()).isTrue()
+            assertThat(success.shareAction).isEqualTo(AsyncAction.Success(listOf(A_ROOM_ID)))
+            sendMediaResult.assertions().isCalledOnce()
+        }
+    }
+}
+
+internal fun TestScope.createSharePresenter(
+    intent: Intent = Intent(),
+    shareIntentHandler: ShareIntentHandler = FakeShareIntentHandler(),
+    matrixClient: MatrixClient = FakeMatrixClient(),
+    activeRoomsHolder: ActiveRoomsHolder = DefaultActiveRoomsHolder(),
+    mediaSenderRoomFactory: MediaSenderRoomFactory = MediaSenderRoomFactory { FakeMediaSender() },
+    mediaOptimizationConfigProvider: MediaOptimizationConfigProvider = FakeMediaOptimizationConfigProvider(),
+): SharePresenter {
+    return SharePresenter(
+        intent = intent,
+        sessionCoroutineScope = this,
+        shareIntentHandler = shareIntentHandler,
+        matrixClient = matrixClient,
+        activeRoomsHolder = activeRoomsHolder,
+        mediaSenderRoomFactory = mediaSenderRoomFactory,
+        mediaOptimizationConfigProvider = mediaOptimizationConfigProvider,
+    )
+}