element-hq · julioromano · Oct 24, 2023 · Oct 3, 2023 · Oct 24, 2023 · Oct 24, 2023
@@ -0,0 +1 @@
+Receive and play a voice message
@@ -52,6 +52,7 @@ dependencies {
     implementation(projects.libraries.permissions.api)
     implementation(projects.libraries.preferences.api)
     implementation(projects.libraries.voicerecorder.api)
+    implementation(projects.libraries.uiUtils)
     implementation(projects.features.networkmonitor.api)
     implementation(projects.services.analytics.api)
     implementation(libs.coil.compose)
@@ -64,6 +65,7 @@ dependencies {
     implementation(libs.vanniktech.blurhash)
     implementation(libs.telephoto.zoomableimage)
     implementation(libs.matrix.emojibase.bindings)
+    implementation(libs.audiowaveform)
 
     testImplementation(libs.test.junit)
     testImplementation(libs.coroutines.test)

@@ -28,9 +28,10 @@ import dagger.assisted.Assisted
 import dagger.assisted.AssistedInject
 import io.element.android.anvilannotations.ContributesNode
 import io.element.android.features.messages.impl.attachments.Attachment
-import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.messages.impl.timeline.di.LocalTimelineItemPresenterFactories
 import io.element.android.features.messages.impl.timeline.di.TimelineItemPresenterFactories
+import io.element.android.features.messages.impl.timeline.model.TimelineItem
+import io.element.android.features.messages.impl.mediaplayer.MediaPlayer
 import io.element.android.libraries.di.RoomScope
 import io.element.android.libraries.matrix.api.core.EventId
 import io.element.android.libraries.matrix.api.core.RoomId
@@ -49,6 +50,7 @@ class MessagesNode @AssistedInject constructor(
     private val analyticsService: AnalyticsService,
     private val presenterFactory: MessagesPresenter.Factory,
     private val timelineItemPresenterFactories: TimelineItemPresenterFactories,
+    private val mediaPlayer: MediaPlayer,
 ) : Node(buildContext, plugins = plugins), MessagesNavigator {
 
     private val presenter = presenterFactory.create(this)
@@ -71,6 +73,9 @@ class MessagesNode @AssistedInject constructor(
         lifecycle.subscribe(
             onCreate = {
                 analyticsService.capture(room.toAnalyticsViewRoom())
+            },
+            onDestroy = {
+                mediaPlayer.close()
             }
         )
     }

@@ -54,6 +54,7 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextBasedContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVoiceContent
 import io.element.android.features.messages.impl.utils.messagesummary.MessageSummaryFormatter
 import io.element.android.features.messages.impl.voicemessages.composer.VoiceMessageComposerPresenter
 import io.element.android.features.networkmonitor.api.NetworkMonitor
@@ -331,6 +332,7 @@ class MessagesPresenter @AssistedInject constructor(
                 type = AttachmentThumbnailType.Location,
             )
             is TimelineItemPollContent, // TODO Polls: handle reply to
+            is TimelineItemVoiceContent, // TODO Voice messages: handle reply to
             is TimelineItemTextBasedContent,
             is TimelineItemRedactedContent,
             is TimelineItemStateContent,

@@ -29,6 +29,7 @@ import io.element.android.features.messages.impl.timeline.model.TimelineItem
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemPollContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemRedactedContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemStateContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVoiceContent
 import io.element.android.features.messages.impl.timeline.model.event.canBeCopied
 import io.element.android.features.messages.impl.timeline.model.event.canReact
 import io.element.android.features.preferences.api.store.PreferencesStore
@@ -131,6 +132,23 @@ class ActionListPresenter @Inject constructor(
                         }
                     }
                 }
+                is TimelineItemVoiceContent -> {
+                    buildList {
+                        if (timelineItem.isRemote) {
+                            add(TimelineItemAction.Reply)
+                            add(TimelineItemAction.Forward)
+                        }
+                        if (isDeveloperModeEnabled) {
+                            add(TimelineItemAction.ViewSource)
+                        }
+                        if (!timelineItem.isMine) {
+                            add(TimelineItemAction.ReportContent)
+                        }
+                        if (timelineItem.isMine || userCanRedact) {
+                            add(TimelineItemAction.Redact)
+                        }
+                    }
+                }
                 else -> buildList<TimelineItemAction> {
                     if (timelineItem.isRemote) {
                         // Can only reply or forward messages already uploaded to the server

@@ -66,6 +66,7 @@ import io.element.android.features.messages.impl.timeline.model.event.TimelineIt
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemTextBasedContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemUnknownContent
 import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVideoContent
+import io.element.android.features.messages.impl.timeline.model.event.TimelineItemVoiceContent
 import io.element.android.features.messages.impl.utils.messagesummary.MessageSummaryFormatterImpl
 import io.element.android.libraries.designsystem.components.avatar.Avatar
 import io.element.android.libraries.designsystem.components.avatar.AvatarSize
@@ -237,6 +238,7 @@ private fun MessageSummary(event: TimelineItem.Event, modifier: Modifier = Modif
 
     when (event.content) {
         is TimelineItemPollContent, // TODO Polls: handle summary
+        is TimelineItemVoiceContent, // TODO Voice messages: handle reply summary
         is TimelineItemTextBasedContent,
         is TimelineItemStateContent,
         is TimelineItemEncryptedContent,

@@ -0,0 +1,192 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.mediaplayer
+
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import com.squareup.anvil.annotations.ContributesBinding
+import io.element.android.libraries.di.RoomScope
+import io.element.android.libraries.di.SingleIn
+import io.element.android.libraries.matrix.api.core.EventId
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.flow.MutableStateFlow
+import kotlinx.coroutines.flow.StateFlow
+import kotlinx.coroutines.flow.asStateFlow
+import kotlinx.coroutines.flow.update
+import kotlinx.coroutines.launch
+import javax.inject.Inject
+
+/**
+ * A media player for Element X.
+ */
+interface MediaPlayer : AutoCloseable {
+
+    /**
+     * The current state of the player.
+     */
+    val state: StateFlow<State>
+
+    /**
+     * Acquires control of the player and starts playing the given media.
+     */
+    fun acquireControlAndPlay(
+        uri: String,
+        mediaId: String,
+        mimeType: String,
+    )
+
+    /**
+     * Plays the current media.
+     */
+    fun play()
+
+    /**
+     * Pauses the current media.
+     */
+    fun pause()
+
+    /**
+     * Seeks the current media to the given position.
+     */
+    fun seekTo(positionMs: Long)
+
+    /**
+     * Releases any resources associated with this player.
+     */
+    override fun close()
+
+    data class State(
+        /**
+         * Whether the player is currently playing.
+         */
+        val isPlaying: Boolean,
+        /**
+         * The id of the media which is currently playing.
+         *
+         * NB: This is usually the string representation of the [EventId] of the event
+         * which contains the media.
+         */
+        val mediaId: String?,
+        /**
+         * The current position of the player.
+         */
+        val currentPosition: Long,
+    )
+}
+
+/**
+ * Default implementation of [MediaPlayer] backed by a [SimplePlayer].
+ */
+@ContributesBinding(RoomScope::class)
+@SingleIn(RoomScope::class)
+class MediaPlayerImpl @Inject constructor(
+    private val player: SimplePlayer,
+) : MediaPlayer {
+
+    private val listener = object : SimplePlayer.Listener {
+        override fun onIsPlayingChanged(isPlaying: Boolean) {
+            _state.update {
+                it.copy(
+                    currentPosition = player.currentPosition,
+                    isPlaying = isPlaying,
+                )
+            }
+            if (isPlaying) {
+                job = scope.launch { updateCurrentPosition() }
+            } else {
+                job?.cancel()
+            }
+        }
+
+        override fun onMediaItemTransition(mediaItem: MediaItem?) {
+            _state.update {
+                it.copy(
+                    currentPosition = player.currentPosition,
+                    mediaId = mediaItem?.mediaId,
+                )
+            }
+        }
+    }
+
+    init {
+        player.addListener(listener)
+    }
+
+    private val scope = CoroutineScope(Job() + Dispatchers.Main)
+    private var job: Job? = null
+
+    private val _state = MutableStateFlow(MediaPlayer.State(false, null, 0L))
+
+    override val state: StateFlow<MediaPlayer.State> = _state.asStateFlow()
+
+    override fun acquireControlAndPlay(uri: String, mediaId: String, mimeType: String) {
+        player.clearMediaItems()
+        player.setMediaItem(
+            MediaItem.Builder()
+                .setUri(uri)
+                .setMediaId(mediaId)
+                .setMimeType(mimeType)
+                .build()
+        )
+        player.prepare()
+        player.play()
+    }
+
+    override fun play() {
+        if (player.playbackState == Player.STATE_ENDED) {
+            // There's a bug with some ogg files that somehow report to
+            // have no duration.
+            // With such files, once playback has ended once, calling
+            // player.seekTo(0) and then player.play() results in the
+            // player starting and stopping playing immediately effectively
+            // playing no sound.
+            // This is a workaround which will reload the media file.
+            player.getCurrentMediaItem()?.let {
+                player.setMediaItem(it)
+                player.prepare()
+                player.play()
+            }
+        } else {
+            player.play()
+        }
+    }
+
+    override fun pause() {
+        player.pause()
+    }
+
+    override fun seekTo(positionMs: Long) {
+        player.seekTo(positionMs)
+    }
+
+    override fun close() {
+        player.release()
+    }
+
+    private suspend fun updateCurrentPosition() {
+        while (true) {
+            if (!_state.value.isPlaying) return
+            delay(100)
+            _state.update {
+                it.copy(currentPosition = player.currentPosition)
+            }
+        }
+    }
+}
@@ -0,0 +1,92 @@
+/*
+ * Copyright (c) 2023 New Vector Ltd
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package io.element.android.features.messages.impl.mediaplayer
+
+import android.content.Context
+import androidx.media3.common.MediaItem
+import androidx.media3.common.Player
+import androidx.media3.exoplayer.ExoPlayer
+import com.squareup.anvil.annotations.ContributesTo
+import dagger.Module
+import dagger.Provides
+import io.element.android.libraries.di.ApplicationContext
+import io.element.android.libraries.di.RoomScope
+
+/**
+ * A subset of media3 [Player] that only exposes the few methods we need making it easier to mock.
+ */
+interface SimplePlayer {
+    fun addListener(listener: Listener)
+    val currentPosition: Long
+    val playbackState: Int
+    fun clearMediaItems()
+    fun setMediaItem(mediaItem: MediaItem)
+    fun getCurrentMediaItem(): MediaItem?
+    fun prepare()
+    fun play()
+    fun pause()
+    fun seekTo(positionMs: Long)
+    fun release()
+    interface Listener {
+        fun onIsPlayingChanged(isPlaying: Boolean)
+        fun onMediaItemTransition(mediaItem: MediaItem?)
+    }
+}
+
+@ContributesTo(RoomScope::class)
+@Module
+object SimplePlayerModule {
+    @Provides
+    fun simplePlayerProvider(
+        @ApplicationContext context: Context,
+    ): SimplePlayer = SimplePlayerImpl(ExoPlayer.Builder(context).build())
+}
+
+/**
+ * Default implementation of [SimplePlayer] backed by a media3 [Player].
+ */
+class SimplePlayerImpl(
+    private val p: Player
+) : SimplePlayer {
+    override fun addListener(listener: SimplePlayer.Listener) {
+        p.addListener(object : Player.Listener {
+            override fun onIsPlayingChanged(isPlaying: Boolean) = listener.onIsPlayingChanged(isPlaying)
+            override fun onMediaItemTransition(mediaItem: MediaItem?, reason: Int) = listener.onMediaItemTransition(mediaItem)
+        })
+    }
+
+    override val currentPosition: Long
+        get() = p.currentPosition
+    override val playbackState: Int
+        get() = p.playbackState
+
+    override fun clearMediaItems() = p.clearMediaItems()
+
+    override fun setMediaItem(mediaItem: MediaItem) = p.setMediaItem(mediaItem)
+
+    override fun getCurrentMediaItem(): MediaItem? = p.currentMediaItem
+
+    override fun prepare() = p.prepare()
+
+    override fun play() = p.play()
+
+    override fun pause() = p.pause()
+
+    override fun seekTo(positionMs: Long) = p.seekTo(positionMs)
+
+    override fun release() = p.release()
+}