Support remote media control commands (#58)

Adds support for remote media controls (play, pause, etc) and displaying
messages.

app/src/main/java/com/github/damontecres/wholphin/util/ServerEventListener.kt

@@ -0,0 +1,69 @@
+package com.github.damontecres.wholphin.util
+
+import android.content.Context
+import android.widget.Toast
+import com.github.damontecres.wholphin.hilt.IoCoroutineScope
+import com.github.damontecres.wholphin.ui.showToast
+import dagger.hilt.android.qualifiers.ApplicationContext
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.flow.onEach
+import kotlinx.coroutines.launch
+import org.jellyfin.sdk.api.client.ApiClient
+import org.jellyfin.sdk.api.client.extensions.sessionApi
+import org.jellyfin.sdk.api.sockets.subscribe
+import org.jellyfin.sdk.model.api.GeneralCommandMessage
+import org.jellyfin.sdk.model.api.GeneralCommandType
+import org.jellyfin.sdk.model.api.MediaType
+import timber.log.Timber
+import javax.inject.Inject
+import javax.inject.Singleton
+
+@Singleton
+class ServerEventListener
+    @Inject
+    constructor(
+        @param:ApplicationContext private val context: Context,
+        private val api: ApiClient,
+        @param:IoCoroutineScope private val scope: CoroutineScope,
+    ) {
+        init {
+            setupListeners()
+        }
+
+        fun init() {
+            scope.launch(ExceptionHandler()) {
+                api.sessionApi.postCapabilities(
+                    playableMediaTypes = listOf(MediaType.VIDEO),
+                    supportedCommands =
+                        listOf(
+                            GeneralCommandType.DISPLAY_MESSAGE,
+                            GeneralCommandType.SEND_STRING,
+                        ),
+                    supportsMediaControl = true,
+                )
+            }
+        }
+
+        fun setupListeners() {
+            Timber.v("Subscribing to WebSocket")
+            api.webSocket
+                .subscribe<GeneralCommandMessage>()
+                .onEach { message ->
+                    if (message.data?.name in
+                        setOf(
+                            GeneralCommandType.DISPLAY_MESSAGE,
+                            GeneralCommandType.SEND_STRING,
+                        )
+                    ) {
+                        val header = message.data?.arguments["Header"]
+                        val text =
+                            message.data?.arguments["Text"] ?: message.data?.arguments["String"]
+                        val toast =
+                            listOfNotNull(header, text)
+                                .joinToString("\n")
+                        showToast(context, toast, Toast.LENGTH_LONG)
+                    }
+                }.launchIn(scope)
+        }
+    }

app/src/main/java/com/github/damontecres/wholphin/util/TrackActivityPlaybackListener.kt

@@ -20,8 +20,6 @@ import org.jellyfin.sdk.model.extensions.inWholeTicks
 import timber.log.Timber
 import java.util.Timer
 import java.util.TimerTask
-import java.util.concurrent.atomic.AtomicBoolean
-import java.util.concurrent.atomic.AtomicLong
 import kotlin.time.Duration.Companion.milliseconds
 import kotlin.time.Duration.Companion.seconds
 
@@ -38,11 +36,6 @@ class TrackActivityPlaybackListener(
     private val coroutineScope = CoroutineScope(Dispatchers.Main)
     private val task: TimerTask
 
-    private var totalPlayDurationMilliseconds = AtomicLong(0)
-    private var currentDurationMilliseconds = AtomicLong(0)
-    private var isPlaying = AtomicBoolean(false)
-    private var incrementedPlayCount = AtomicBoolean(false)
-
     init {
         coroutineScope.launch(Dispatchers.IO + ExceptionHandler()) {
             api.playStateApi.reportPlaybackStart(
@@ -59,28 +52,13 @@ class TrackActivityPlaybackListener(
                 ),
             )
         }
-        val saveActivityInterval = 10.seconds.inWholeMilliseconds
-        val delay = 1.seconds.inWholeMilliseconds
+        val delay = 5.seconds.inWholeMilliseconds
         // Every x seconds, check if the video is playing
         task =
             object : TimerTask() {
-                private var timestamp = System.currentTimeMillis()
-
                 override fun run() {
                     try {
-                        val now = System.currentTimeMillis()
-                        if (isPlaying.get()) {
-                            val diffTime = now - timestamp
-                            // If it is playing, add the interval to currently tracked duration
-                            val current = currentDurationMilliseconds.addAndGet(diffTime)
-                            // TODO currentDuration.getAndUpdate would be better, but requires API 24+
-                            if (current >= saveActivityInterval) {
-                                // If the accumulated currently tracked duration > threshold, reset it and save activity
-                                totalPlayDurationMilliseconds.addAndGet(current)
-                                saveActivity(-1L)
-                            }
-                        }
-                        timestamp = now
+                        saveActivity(-1L)
                     } catch (ex: Exception) {
                         Timber.Forest.w(ex, "Exception during track activity timer")
                     }
@@ -106,14 +84,7 @@ class TrackActivityPlaybackListener(
     }
 
     override fun onIsPlayingChanged(isPlaying: Boolean) {
-        this.isPlaying.set(isPlaying)
-        if (!isPlaying) {
-            val diff = currentDurationMilliseconds.getAndSet(0)
-            if (diff > 0) {
-                totalPlayDurationMilliseconds.addAndGet(diff)
-                saveActivity(-1)
-            }
-        }
+        saveActivity(-1)
     }
 
     override fun onPlaybackStateChanged(playbackState: Int) {
@@ -125,12 +96,11 @@ class TrackActivityPlaybackListener(
 
     private fun saveActivity(position: Long) {
         coroutineScope.launch(Dispatchers.IO + ExceptionHandler()) {
-//            val totalDuration = totalPlayDurationMilliseconds.get()
             val calcPosition =
                 withContext(Dispatchers.Main) {
                     (if (position >= 0) position else player.currentPosition).milliseconds
                 }
-            Timber.v("saveActivity: itemId=${itemPlayback.itemId}, pos=$calcPosition")
+//            Timber.v("saveActivity: itemId=${itemPlayback.itemId}, pos=$calcPosition")
             api.playStateApi.reportPlaybackProgress(
                 PlaybackProgressInfo(
                     itemId = itemPlayback.itemId,