Add inline voice note player to conversation and conversation list.

2026-04-24 10:51:27 +01:00 · 2021-07-07 14:23:37 -03:00
parent 1bb87834d8
commit 06b64fe619
16 changed files with 667 additions and 54 deletions
--- a/app/src/main/java/org/thoughtcrime/securesms/components/AudioView.java
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/AudioView.java
@@ -232,11 +232,11 @@ public final class AudioView extends FrameLayout {

  private void onPlaybackState(@NonNull VoiceNotePlaybackState voiceNotePlaybackState) {
    onDuration(voiceNotePlaybackState.getUri(), voiceNotePlaybackState.getTrackDuration());
-    onStart(voiceNotePlaybackState.getUri(), voiceNotePlaybackState.isAutoReset());
    onProgress(voiceNotePlaybackState.getUri(),
               (double) voiceNotePlaybackState.getPlayheadPositionMillis() / voiceNotePlaybackState.getTrackDuration(),
               voiceNotePlaybackState.getPlayheadPositionMillis());
    onSpeedChanged(voiceNotePlaybackState.getUri(), voiceNotePlaybackState.getSpeed());
+    onStart(voiceNotePlaybackState.getUri(), voiceNotePlaybackState.isPlaying(), voiceNotePlaybackState.isAutoReset());
  }

  private void onDuration(@NonNull Uri uri, long durationMillis) {
@@ -245,8 +245,8 @@ public final class AudioView extends FrameLayout {
    }
  }

-  private void onStart(@NonNull Uri uri, boolean autoReset) {
-    if (!isTarget(uri)) {
+  private void onStart(@NonNull Uri uri, boolean statePlaying, boolean autoReset) {
+    if (!isTarget(uri) || !statePlaying) {
      if (hasAudioUri()) {
        onStop(audioSlide.getUri(), autoReset);
      }
--- a/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNoteMediaController.java
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNoteMediaController.java
@@ -2,6 +2,7 @@ package org.thoughtcrime.securesms.components.voice;

 import android.content.ComponentName;
 import android.media.AudioManager;
+import android.media.session.PlaybackState;
 import android.net.Uri;
 import android.os.Bundle;
 import android.os.Handler;
@@ -9,19 +10,28 @@ import android.os.Looper;
 import android.os.Message;
 import android.os.RemoteException;
 import android.support.v4.media.MediaBrowserCompat;
+import android.support.v4.media.MediaDescriptionCompat;
 import android.support.v4.media.MediaMetadataCompat;
 import android.support.v4.media.session.MediaControllerCompat;
 import android.support.v4.media.session.MediaSessionCompat;
 import android.support.v4.media.session.PlaybackStateCompat;

 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.appcompat.app.AppCompatActivity;
 import androidx.lifecycle.DefaultLifecycleObserver;
 import androidx.lifecycle.LifecycleOwner;
 import androidx.lifecycle.LiveData;
 import androidx.lifecycle.MutableLiveData;
+import androidx.lifecycle.Transformations;

 import org.signal.core.util.logging.Log;
+import org.thoughtcrime.securesms.recipients.LiveRecipient;
+import org.thoughtcrime.securesms.recipients.Recipient;
+import org.thoughtcrime.securesms.recipients.RecipientId;
+import org.thoughtcrime.securesms.util.DefaultValueLiveData;
+import org.thoughtcrime.securesms.util.livedata.LiveDataUtil;
+import org.whispersystems.libsignal.util.guava.Optional;

 import java.util.Objects;

@@ -42,10 +52,11 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {

  private static final String TAG = Log.tag(VoiceNoteMediaController.class);

-  private MediaBrowserCompat                      mediaBrowser;
-  private AppCompatActivity                       activity;
-  private ProgressEventHandler                    progressEventHandler;
-  private MutableLiveData<VoiceNotePlaybackState> voiceNotePlaybackState = new MutableLiveData<>(VoiceNotePlaybackState.NONE);
+  private MediaBrowserCompat                            mediaBrowser;
+  private AppCompatActivity                             activity;
+  private ProgressEventHandler                          progressEventHandler;
+  private MutableLiveData<VoiceNotePlaybackState>       voiceNotePlaybackState = new MutableLiveData<>(VoiceNotePlaybackState.NONE);
+  private LiveData<Optional<VoiceNotePlayerView.State>> voiceNotePlayerViewState;

  private final MediaControllerCompatCallback mediaControllerCompatCallback = new MediaControllerCompatCallback();

@@ -57,12 +68,44 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {
                                               null);

    activity.getLifecycle().addObserver(this);
+
+    voiceNotePlayerViewState = Transformations.switchMap(voiceNotePlaybackState, playbackState -> {
+      if (playbackState.getClipType() instanceof VoiceNotePlaybackState.ClipType.Message) {
+        VoiceNotePlaybackState.ClipType.Message message         = (VoiceNotePlaybackState.ClipType.Message) playbackState.getClipType();
+        LiveRecipient                           sender          = Recipient.live(message.getSenderId());
+        LiveRecipient                           threadRecipient = Recipient.live(message.getThreadRecipientId());
+        LiveData<String>                        name            = LiveDataUtil.combineLatest(sender.getLiveDataResolved(),
+                                                                                             threadRecipient.getLiveDataResolved(),
+                                                                                             (s, t) -> VoiceNoteMediaDescriptionCompatFactory.getTitle(activity, s, t, null));
+
+        return Transformations.map(name, displayName -> Optional.of(
+            new VoiceNotePlayerView.State(
+                playbackState.getUri(),
+                message.getMessageId(),
+                message.getThreadId(),
+                !playbackState.isPlaying(),
+                message.getSenderId(),
+                message.getThreadRecipientId(),
+                message.getMessagePosition(),
+                message.getTimestamp(),
+                displayName,
+                playbackState.getPlayheadPositionMillis(),
+                playbackState.getTrackDuration(),
+                playbackState.getSpeed())));
+      } else {
+        return new DefaultValueLiveData<>(Optional.absent());
+      }
+    });
  }

  public LiveData<VoiceNotePlaybackState> getVoiceNotePlaybackState() {
    return voiceNotePlaybackState;
  }

+  public LiveData<Optional<VoiceNotePlayerView.State>> getVoiceNotePlayerViewState() {
+    return voiceNotePlayerViewState;
+  }
+
  @Override
  public void onStart(@NonNull LifecycleOwner owner) {
    mediaBrowser.connect();
@@ -94,6 +137,14 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {
           playbackStateCompat.getState() == PlaybackStateCompat.STATE_PLAYING;
  }

+  private static boolean isPlayerPaused(@NonNull PlaybackStateCompat playbackStateCompat) {
+    return playbackStateCompat.getState() == PlaybackStateCompat.STATE_PAUSED;
+  }
+
+  private static boolean isPlayerStopped(@NonNull PlaybackStateCompat playbackStateCompat) {
+    return playbackStateCompat.getState() <= PlaybackStateCompat.STATE_STOPPED;
+  }
+
  private @NonNull MediaControllerCompat getMediaController() {
    return MediaControllerCompat.getMediaController(activity);
  }
@@ -215,6 +266,17 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {

        mediaController.registerCallback(mediaControllerCompatCallback);

+        if (Objects.equals(voiceNotePlaybackState.getValue(), VoiceNotePlaybackState.NONE)) {
+          MediaMetadataCompat mediaMetadataCompat = mediaController.getMetadata();
+          if (canExtractPlaybackInformationFromMetadata(mediaMetadataCompat)) {
+            VoiceNotePlaybackState newState = extractStateFromMetadata(mediaController, mediaMetadataCompat, null);
+
+            if (newState != null) {
+              voiceNotePlaybackState.postValue(newState);
+            }
+          }
+        }
+
        mediaControllerCompatCallback.onPlaybackStateChanged(mediaController.getPlaybackState());
      } catch (RemoteException e) {
        Log.w(TAG, "onConnected: Failed to set media controller", e);
@@ -222,6 +284,107 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {
    }
  }

+  private static boolean canExtractPlaybackInformationFromMetadata(@Nullable MediaMetadataCompat mediaMetadataCompat) {
+    return mediaMetadataCompat != null                  &&
+           mediaMetadataCompat.getDescription() != null &&
+           mediaMetadataCompat.getDescription().getMediaUri() != null;
+  }
+
+  private static @Nullable VoiceNotePlaybackState extractStateFromMetadata(@NonNull MediaControllerCompat mediaController,
+                                                                           @NonNull MediaMetadataCompat mediaMetadataCompat,
+                                                                           @Nullable VoiceNotePlaybackState previousState)
+  {
+    Uri     mediaUri  = Objects.requireNonNull(mediaMetadataCompat.getDescription().getMediaUri());
+    boolean autoReset = Objects.equals(mediaUri, VoiceNotePlaybackPreparer.NEXT_URI) || Objects.equals(mediaUri, VoiceNotePlaybackPreparer.END_URI);
+    long    position  = mediaController.getPlaybackState().getPosition();
+    long    duration  = mediaMetadataCompat.getLong(MediaMetadataCompat.METADATA_KEY_DURATION);
+    Bundle  extras    = mediaController.getExtras();
+    float   speed     = extras != null ? extras.getFloat(VoiceNotePlaybackService.ACTION_NEXT_PLAYBACK_SPEED, 1f) : 1f;
+
+    if (previousState != null && Objects.equals(mediaUri, previousState.getUri())) {
+      if (position < 0 && previousState.getPlayheadPositionMillis() >= 0) {
+        position = previousState.getPlayheadPositionMillis();
+      }
+
+      if (duration <= 0 && previousState.getTrackDuration() > 0) {
+        duration = previousState.getTrackDuration();
+      }
+    }
+
+    if (duration > 0 && position >= 0 && position <= duration) {
+      return new VoiceNotePlaybackState(mediaUri,
+                                        position,
+                                        duration,
+                                        autoReset,
+                                        speed,
+                                        isPlayerActive(mediaController.getPlaybackState()),
+                                        getClipType(mediaMetadataCompat.getBundle()));
+    } else {
+      return null;
+    }
+  }
+
+  private static @Nullable VoiceNotePlaybackState constructPlaybackState(@NonNull MediaControllerCompat mediaController,
+                                                                         @Nullable VoiceNotePlaybackState previousState)
+  {
+    MediaMetadataCompat mediaMetadataCompat = mediaController.getMetadata();
+    if (isPlayerActive(mediaController.getPlaybackState()) &&
+        canExtractPlaybackInformationFromMetadata(mediaMetadataCompat))
+    {
+      return extractStateFromMetadata(mediaController, mediaMetadataCompat, previousState);
+    } else if (isPlayerPaused(mediaController.getPlaybackState()) &&
+               mediaMetadataCompat != null)
+    {
+      long position = mediaController.getPlaybackState().getPosition();
+      long duration = mediaMetadataCompat.getLong(MediaMetadataCompat.METADATA_KEY_DURATION);
+
+      if (previousState != null && position < duration) {
+        return previousState.asPaused();
+      } else {
+        return VoiceNotePlaybackState.NONE;
+      }
+    } else {
+      return VoiceNotePlaybackState.NONE;
+    }
+  }
+
+  private static @NonNull VoiceNotePlaybackState.ClipType getClipType(@Nullable Bundle mediaExtras) {
+    long        messageId         = -1L;
+    RecipientId senderId          = RecipientId.UNKNOWN;
+    long        messagePosition   = -1L;
+    long        threadId          = -1L;
+    RecipientId threadRecipientId = RecipientId.UNKNOWN;
+    long        timestamp         = -1L;
+
+    if (mediaExtras != null) {
+      messageId       = mediaExtras.getLong(VoiceNoteMediaDescriptionCompatFactory.EXTRA_MESSAGE_ID, -1L);
+      messagePosition = mediaExtras.getLong(VoiceNoteMediaDescriptionCompatFactory.EXTRA_MESSAGE_POSITION, -1L);
+      threadId        = mediaExtras.getLong(VoiceNoteMediaDescriptionCompatFactory.EXTRA_THREAD_ID, -1L);
+      timestamp       = mediaExtras.getLong(VoiceNoteMediaDescriptionCompatFactory.EXTRA_MESSAGE_TIMESTAMP, -1L);
+
+      String serializedSenderId = mediaExtras.getString(VoiceNoteMediaDescriptionCompatFactory.EXTRA_INDIVIDUAL_RECIPIENT_ID);
+      if (serializedSenderId != null) {
+        senderId = RecipientId.from(serializedSenderId);
+      }
+
+      String serializedThreadRecipientId = mediaExtras.getString(VoiceNoteMediaDescriptionCompatFactory.EXTRA_THREAD_RECIPIENT_ID);
+      if (serializedThreadRecipientId != null) {
+        threadRecipientId = RecipientId.from(serializedThreadRecipientId);
+      }
+    }
+
+    if (messageId != -1L) {
+      return new VoiceNotePlaybackState.ClipType.Message(messageId,
+                                                         senderId,
+                                                         threadRecipientId,
+                                                         messagePosition,
+                                                         threadId,
+                                                         timestamp);
+    } else {
+      return VoiceNotePlaybackState.ClipType.Draft.INSTANCE;
+    }
+  }
+
  private static class ProgressEventHandler extends Handler {

    private final MediaControllerCompat                   mediaController;
@@ -238,38 +401,14 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {

    @Override
    public void handleMessage(@NonNull Message msg) {
-      MediaMetadataCompat mediaMetadataCompat = mediaController.getMetadata();
-      if (isPlayerActive(mediaController.getPlaybackState()) &&
-          mediaMetadataCompat != null                        &&
-          mediaMetadataCompat.getDescription() != null       &&
-          mediaMetadataCompat.getDescription().getMediaUri() != null)
-      {
+      VoiceNotePlaybackState newPlaybackState = constructPlaybackState(mediaController, voiceNotePlaybackState.getValue());

-        Uri                    mediaUri      = Objects.requireNonNull(mediaMetadataCompat.getDescription().getMediaUri());
-        boolean                autoReset     = Objects.equals(mediaUri, VoiceNotePlaybackPreparer.NEXT_URI) || Objects.equals(mediaUri, VoiceNotePlaybackPreparer.END_URI);
-        VoiceNotePlaybackState previousState = voiceNotePlaybackState.getValue();
-        long                   position      = mediaController.getPlaybackState().getPosition();
-        long                   duration      = mediaMetadataCompat.getLong(MediaMetadataCompat.METADATA_KEY_DURATION);
-        Bundle                 extras        = mediaController.getExtras();
-        float                  speed         = extras != null ? extras.getFloat(VoiceNotePlaybackService.ACTION_NEXT_PLAYBACK_SPEED, 1f) : 1f;
-
-        if (previousState != null && Objects.equals(mediaUri, previousState.getUri())) {
-          if (position < 0 && previousState.getPlayheadPositionMillis() >= 0) {
-            position = previousState.getPlayheadPositionMillis();
-          }
-
-          if (duration <= 0 && previousState.getTrackDuration() > 0) {
-            duration = previousState.getTrackDuration();
-          }
-        }
-
-        if (duration > 0 && position >= 0 && position <= duration) {
-          voiceNotePlaybackState.postValue(new VoiceNotePlaybackState(mediaUri, position, duration, autoReset, speed));
-        }
+      if (newPlaybackState != null) {
+        voiceNotePlaybackState.postValue(newPlaybackState);
+      }

+      if (isPlayerActive(mediaController.getPlaybackState())) {
        sendEmptyMessageDelayed(0, 50);
-      } else {
-        voiceNotePlaybackState.postValue(VoiceNotePlaybackState.NONE);
      }
    }
  }
@@ -281,6 +420,10 @@ public class VoiceNoteMediaController implements DefaultLifecycleObserver {
        notifyProgressEventHandler();
      } else {
        clearProgressEventHandler();
+
+        if (isPlayerStopped(state)) {
+          voiceNotePlaybackState.postValue(VoiceNotePlaybackState.NONE);
+        }
      }
    }
  }
--- a/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNoteMediaControllerOwner.kt
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNoteMediaControllerOwner.kt
@@ -0,0 +1,5 @@
+package org.thoughtcrime.securesms.components.voice
+
+interface VoiceNoteMediaControllerOwner {
+  val voiceNoteMediaController: VoiceNoteMediaController
+}
--- a/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNoteMediaDescriptionCompatFactory.java
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNoteMediaDescriptionCompatFactory.java
@@ -6,6 +6,7 @@ import android.os.Bundle;
 import android.support.v4.media.MediaDescriptionCompat;

 import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import androidx.annotation.WorkerThread;

 import org.signal.core.util.logging.Log;
@@ -33,6 +34,7 @@ class VoiceNoteMediaDescriptionCompatFactory {
  public static final String EXTRA_THREAD_ID               = "voice.note.extra.THREAD_ID";
  public static final String EXTRA_COLOR                   = "voice.note.extra.COLOR";
  public static final String EXTRA_MESSAGE_ID              = "voice.note.extra.MESSAGE_ID";
+  public static final String EXTRA_MESSAGE_TIMESTAMP       = "voice.note.extra.MESSAGE_TIMESTAMP";

  private static final String TAG = Log.tag(VoiceNoteMediaDescriptionCompatFactory.class);

@@ -110,19 +112,11 @@ class VoiceNoteMediaDescriptionCompatFactory {
    extras.putLong(EXTRA_THREAD_ID, threadId);
    extras.putLong(EXTRA_COLOR, threadRecipient.getChatColors().asSingleColor());
    extras.putLong(EXTRA_MESSAGE_ID, messageId);
+    extras.putLong(EXTRA_MESSAGE_TIMESTAMP, dateReceived);

    NotificationPrivacyPreference preference = SignalStore.settings().getMessageNotificationsPrivacy();

-    String title;
-    if (preference.isDisplayContact() && threadRecipient.isGroup()) {
-      title = context.getString(R.string.VoiceNoteMediaDescriptionCompatFactory__s_to_s,
-                                sender.getDisplayName(context),
-                                threadRecipient.getDisplayName(context));
-    } else if (preference.isDisplayContact()) {
-      title = sender.getDisplayName(context);
-    } else {
-      title = context.getString(R.string.MessageNotifier_signal_message);
-    }
+    String title = getTitle(context, sender, threadRecipient, preference);

    String subtitle = null;
    if (preference.isDisplayContact()) {
@@ -139,4 +133,22 @@ class VoiceNoteMediaDescriptionCompatFactory {
                                     .build();
  }

+  public static @NonNull String getTitle(@NonNull Context context, @NonNull Recipient sender, @NonNull Recipient threadRecipient, @Nullable NotificationPrivacyPreference notificationPrivacyPreference) {
+    NotificationPrivacyPreference preference;
+    if (notificationPrivacyPreference == null) {
+      preference = new NotificationPrivacyPreference("all");
+    } else {
+      preference = notificationPrivacyPreference;
+    }
+
+    if (preference.isDisplayContact() && threadRecipient.isGroup()) {
+      return context.getString(R.string.VoiceNoteMediaDescriptionCompatFactory__s_to_s,
+                               sender.getDisplayName(context),
+                               threadRecipient.getDisplayName(context));
+    } else if (preference.isDisplayContact()) {
+      return sender.getDisplayName(context);
+    } else {
+      return context.getString(R.string.MessageNotifier_signal_message);
+    }
+  }
 }
--- a/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNotePlaybackState.kt
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNotePlaybackState.kt
@@ -1,6 +1,7 @@
 package org.thoughtcrime.securesms.components.voice

 import android.net.Uri
+import org.thoughtcrime.securesms.recipients.RecipientId

 /**
 * Domain-level state object representing the state of the currently playing voice note.
@@ -29,11 +30,37 @@ data class VoiceNotePlaybackState(
  /**
   * @return The current playback speed factor
   */
-  val speed: Float
+  val speed: Float,

+  /**
+   * @return Whether we are playing or paused
+   */
+  val isPlaying: Boolean,
+
+  /**
+   * @return Information about the type this clip represents.
+   */
+  val clipType: ClipType
 ) {
  companion object {
    @JvmField
-    val NONE = VoiceNotePlaybackState(Uri.EMPTY, 0, 0, false, 1f)
+    val NONE = VoiceNotePlaybackState(Uri.EMPTY, 0, 0, false, 1f, false, ClipType.Idle)
+  }
+
+  fun asPaused(): VoiceNotePlaybackState {
+    return copy(isPlaying = false)
+  }
+
+  sealed class ClipType {
+    data class Message(
+      val messageId: Long,
+      val senderId: RecipientId,
+      val threadRecipientId: RecipientId,
+      val messagePosition: Long,
+      val threadId: Long,
+      val timestamp: Long
+    ) : ClipType()
+    object Draft : ClipType()
+    object Idle : ClipType()
  }
 }
--- a/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNotePlayerView.kt
+++ b/app/src/main/java/org/thoughtcrime/securesms/components/voice/VoiceNotePlayerView.kt
@@ -0,0 +1,199 @@
+package org.thoughtcrime.securesms.components.voice
+
+import android.content.Context
+import android.net.Uri
+import android.util.AttributeSet
+import android.view.View
+import android.view.animation.Animation
+import android.view.animation.AnimationUtils
+import android.widget.TextView
+import androidx.constraintlayout.widget.ConstraintLayout
+import androidx.core.content.ContextCompat
+import com.airbnb.lottie.LottieAnimationView
+import com.airbnb.lottie.LottieProperty
+import com.airbnb.lottie.SimpleColorFilter
+import com.airbnb.lottie.model.KeyPath
+import com.airbnb.lottie.value.LottieValueCallback
+import org.thoughtcrime.securesms.R
+import org.thoughtcrime.securesms.components.PlaybackSpeedToggleTextView
+import org.thoughtcrime.securesms.recipients.RecipientId
+import java.util.concurrent.TimeUnit
+
+private const val ANIMATE_DURATION: Long = 150L
+private const val TO_PAUSE = 1
+private const val TO_PLAY = -1
+
+/**
+ * Renders a bar at the top of Conversation list and in a conversation to allow
+ * playback manipulation of voice notes.
+ */
+class VoiceNotePlayerView @JvmOverloads constructor(
+  context: Context,
+  attrs: AttributeSet? = null,
+  defStyleAttr: Int = 0
+) : ConstraintLayout(context, attrs, defStyleAttr) {
+
+  private val playPauseToggleView: LottieAnimationView
+  private val infoView: TextView
+  private val speedView: PlaybackSpeedToggleTextView
+  private val closeButton: View
+
+  private var lastState: State? = null
+  private var playerVisible: Boolean = false
+  private var lottieDirection: Int = 0
+
+  var listener: Listener? = null
+
+  init {
+    inflate(context, R.layout.voice_note_player_view, this)
+
+    playPauseToggleView = findViewById(R.id.voice_note_player_play_pause_toggle)
+    infoView = findViewById(R.id.voice_note_player_info)
+    speedView = findViewById(R.id.voice_note_player_speed)
+    closeButton = findViewById(R.id.voice_note_player_close)
+
+    val speedTouchTarget: View = findViewById(R.id.voice_note_player_speed_touch_target)
+    speedTouchTarget.setOnClickListener {
+      speedView.performClick()
+    }
+
+    speedView.playbackSpeedListener = object : PlaybackSpeedToggleTextView.PlaybackSpeedListener {
+      override fun onPlaybackSpeedChanged(speed: Float) {
+        lastState?.let {
+          listener?.onSpeedChangeRequested(it.uri, speed)
+        }
+      }
+    }
+
+    closeButton.setOnClickListener {
+      lastState?.let {
+        listener?.onCloseRequested(it.uri)
+      }
+    }
+
+    playPauseToggleView.setOnClickListener {
+      lastState?.let {
+        if (it.isPaused) {
+          if (it.playbackPosition >= it.playbackDuration) {
+            listener?.onPlay(it.uri, it.messageId, 0.0)
+          } else {
+            listener?.onPlay(it.uri, it.messageId, it.playbackPosition.toDouble() / it.playbackDuration)
+          }
+        } else {
+          listener?.onPause(it.uri)
+        }
+      }
+    }
+
+    post {
+      playPauseToggleView.addValueCallback(
+        KeyPath("**"),
+        LottieProperty.COLOR_FILTER,
+        LottieValueCallback(SimpleColorFilter(ContextCompat.getColor(context, R.color.signal_icon_tint_primary)))
+      )
+    }
+
+    if (background != null) {
+      background.colorFilter = SimpleColorFilter(ContextCompat.getColor(context, R.color.voice_note_player_view_background))
+    }
+
+    setOnClickListener {
+      lastState?.let {
+        listener?.onNavigateToMessage(it.threadId, it.threadRecipientId, it.senderId, it.messageTimestamp, it.messagePositionInThread)
+      }
+    }
+  }
+
+  fun setState(state: State) {
+    this.lastState = state
+
+    if (state.isPaused) {
+      animateToggleToPlay()
+    } else {
+      animateToggleToPause()
+    }
+
+    infoView.text = context.getString(R.string.VoiceNotePlayerView__s_dot_s, state.name, formatDuration(state.playbackDuration))
+    speedView.setCurrentSpeed(state.playbackSpeed)
+  }
+
+  fun show() {
+    if (!playerVisible) {
+      visibility = VISIBLE
+
+      val animation = AnimationUtils.loadAnimation(context, R.anim.slide_from_top)
+      animation.duration = ANIMATE_DURATION
+
+      startAnimation(animation)
+    }
+
+    playerVisible = true
+  }
+
+  fun hide() {
+    if (playerVisible) {
+      val animation = AnimationUtils.loadAnimation(context, R.anim.slide_to_top)
+      animation.duration = ANIMATE_DURATION
+      animation.setAnimationListener(object : Animation.AnimationListener {
+        override fun onAnimationStart(animation: Animation?) = Unit
+        override fun onAnimationRepeat(animation: Animation?) = Unit
+
+        override fun onAnimationEnd(animation: Animation?) {
+          visibility = GONE
+        }
+      })
+
+      startAnimation(animation)
+    }
+
+    playerVisible = false
+  }
+
+  private fun formatDuration(duration: Long): String {
+    val secs = TimeUnit.MILLISECONDS.toSeconds(duration)
+
+    return resources.getString(R.string.AudioView_duration, secs / 60, secs % 60)
+  }
+
+  private fun animateToggleToPlay() {
+    startLottieAnimation(TO_PLAY)
+  }
+
+  private fun animateToggleToPause() {
+    startLottieAnimation(TO_PAUSE)
+  }
+
+  private fun startLottieAnimation(direction: Int) {
+    if (lottieDirection == direction) {
+      return
+    }
+
+    lottieDirection = direction
+    playPauseToggleView.pauseAnimation()
+    playPauseToggleView.speed = (direction * 2).toFloat()
+    playPauseToggleView.resumeAnimation()
+  }
+
+  data class State(
+    val uri: Uri,
+    val messageId: Long,
+    val threadId: Long,
+    val isPaused: Boolean,
+    val senderId: RecipientId,
+    val threadRecipientId: RecipientId,
+    val messagePositionInThread: Long,
+    val messageTimestamp: Long,
+    val name: String,
+    val playbackPosition: Long,
+    val playbackDuration: Long,
+    val playbackSpeed: Float
+  )
+
+  interface Listener {
+    fun onPlay(uri: Uri, messageId: Long, position: Double)
+    fun onPause(uri: Uri)
+    fun onCloseRequested(uri: Uri)
+    fun onSpeedChangeRequested(uri: Uri, speed: Float)
+    fun onNavigateToMessage(threadId: Long, threadRecipientId: RecipientId, senderId: RecipientId, messageSentAt: Long, messagePositionInThread: Long)
+  }
+}