Merge branch 'futo-org:master' into master

.gitattributes

@@ -0,0 +1,2 @@
+aar/* filter=lfs diff=lfs merge=lfs -text
+app/aar/* filter=lfs diff=lfs merge=lfs -text

.gitmodules

@@ -94,3 +94,15 @@
 [submodule "app/src/unstable/assets/sources/tedtalks"]
 	path = app/src/unstable/assets/sources/tedtalks
 	url = ../plugins/tedtalks.git
+[submodule "app/src/stable/assets/sources/curiositystream"]
+	path = app/src/stable/assets/sources/curiositystream
+	url = ../plugins/curiositystream.git
+[submodule "app/src/unstable/assets/sources/curiositystream"]
+	path = app/src/unstable/assets/sources/curiositystream
+	url = ../plugins/curiositystream.git
+[submodule "app/src/unstable/assets/sources/crunchyroll"]
+	path = app/src/unstable/assets/sources/crunchyroll
+	url = ../plugins/crunchyroll.git
+[submodule "app/src/stable/assets/sources/crunchyroll"]
+	path = app/src/stable/assets/sources/crunchyroll
+	url = ../plugins/crunchyroll.git

app/build.gradle

@@ -197,7 +197,8 @@ dependencies {
     implementation 'org.jsoup:jsoup:1.15.3'
     implementation 'com.google.android.flexbox:flexbox:3.0.0'
     implementation 'androidx.swiperefreshlayout:swiperefreshlayout:1.1.0'
-    implementation 'com.arthenica:ffmpeg-kit-full:6.0-2.LTS'
+    implementation fileTree(dir: 'aar', include: ['*.aar'])
+    implementation 'com.arthenica:smart-exception-java:0.2.1'
     implementation 'org.jetbrains.kotlin:kotlin-reflect:1.9.0'
     implementation 'com.github.dhaval2404:imagepicker:2.1'
     implementation 'com.google.zxing:core:3.4.1'

app/src/androidTest/java/com/futo/platformplayer/SyncServerTests.kt

@@ -0,0 +1,338 @@
+package com.futo.platformplayer
+
+import com.futo.platformplayer.noise.protocol.Noise
+import com.futo.platformplayer.sync.internal.*
+import kotlinx.coroutines.*
+import kotlinx.coroutines.selects.select
+import org.junit.Assert.*
+import org.junit.Test
+import java.net.Socket
+import java.nio.ByteBuffer
+import kotlin.random.Random
+import kotlin.time.Duration.Companion.milliseconds
+import kotlin.time.Duration.Companion.seconds
+
+class SyncServerTests {
+
+    //private val relayHost = "relay.grayjay.app"
+    //private val relayKey = "xGbHRzDOvE6plRbQaFgSen82eijF+gxS0yeUaeEErkw="
+    private val relayKey = "XlUaSpIlRaCg0TGzZ7JYmPupgUHDqTZXUUBco2K7ejw="
+    private val relayHost = "192.168.1.138"
+    private val relayPort = 9000
+
+    /** Creates a client connected to the live relay server. */
+    private suspend fun createClient(
+        onHandshakeComplete: ((SyncSocketSession) -> Unit)? = null,
+        onData: ((SyncSocketSession, UByte, UByte, ByteBuffer) -> Unit)? = null,
+        onNewChannel: ((SyncSocketSession, ChannelRelayed) -> Unit)? = null,
+        isHandshakeAllowed: ((LinkType, SyncSocketSession, String, String?, UInt) -> Boolean)? = null,
+        onException: ((Throwable) -> Unit)? = null
+    ): SyncSocketSession = withContext(Dispatchers.IO) {
+        val p = Noise.createDH("25519")
+        p.generateKeyPair()
+        val socket = Socket(relayHost, relayPort)
+        val inputStream = LittleEndianDataInputStream(socket.getInputStream())
+        val outputStream = LittleEndianDataOutputStream(socket.getOutputStream())
+        val tcs = CompletableDeferred<Boolean>()
+        val socketSession = SyncSocketSession(
+            relayHost,
+            p,
+            inputStream,
+            outputStream,
+            onClose = { socket.close() },
+            onHandshakeComplete = { s ->
+                onHandshakeComplete?.invoke(s)
+                tcs.complete(true)
+            },
+            onData = onData ?: { _, _, _, _ -> },
+            onNewChannel = onNewChannel ?: { _, _ -> },
+            isHandshakeAllowed = isHandshakeAllowed ?: { _, _, _, _, _ -> true }
+        )
+        socketSession.authorizable = AlwaysAuthorized()
+        try {
+            socketSession.startAsInitiator(relayKey)
+        } catch (e: Throwable) {
+            onException?.invoke(e)
+        }
+        withTimeout(5000.milliseconds) { tcs.await() }
+        return@withContext socketSession
+    }
+
+    @Test
+    fun multipleClientsHandshake_Success() = runBlocking {
+        val client1 = createClient()
+        val client2 = createClient()
+        assertNotNull(client1.remotePublicKey, "Client 1 handshake failed")
+        assertNotNull(client2.remotePublicKey, "Client 2 handshake failed")
+        client1.stop()
+        client2.stop()
+    }
+
+    @Test
+    fun publishAndRequestConnectionInfo_Authorized_Success() = runBlocking {
+        val clientA = createClient()
+        val clientB = createClient()
+        val clientC = createClient()
+        clientA.publishConnectionInformation(arrayOf(clientB.localPublicKey), 12345, true, true, true, true)
+        delay(100.milliseconds)
+        val infoB = clientB.requestConnectionInfo(clientA.localPublicKey)
+        val infoC = clientC.requestConnectionInfo(clientA.localPublicKey)
+        assertNotNull("Client B should receive connection info", infoB)
+        assertEquals(12345.toUShort(), infoB!!.port)
+        assertNull("Client C should not receive connection info (unauthorized)", infoC)
+        clientA.stop()
+        clientB.stop()
+        clientC.stop()
+    }
+
+    @Test
+    fun relayedTransport_Bidirectional_Success() = runBlocking {
+        val tcsA = CompletableDeferred<ChannelRelayed>()
+        val tcsB = CompletableDeferred<ChannelRelayed>()
+        val clientA = createClient(onNewChannel = { _, c -> tcsA.complete(c) })
+        val clientB = createClient(onNewChannel = { _, c -> tcsB.complete(c) })
+        val channelTask = async { clientA.startRelayedChannel(clientB.localPublicKey) }
+        val channelA = withTimeout(5000.milliseconds) { tcsA.await() }
+        channelA.authorizable = AlwaysAuthorized()
+        val channelB = withTimeout(5000.milliseconds) { tcsB.await() }
+        channelB.authorizable = AlwaysAuthorized()
+        channelTask.await()
+
+        val tcsDataB = CompletableDeferred<ByteArray>()
+        channelB.setDataHandler { _, _, o, so, d ->
+            val b = ByteArray(d.remaining())
+            d.get(b)
+            if (o == Opcode.DATA.value && so == 0u.toUByte()) tcsDataB.complete(b)
+        }
+        channelA.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(byteArrayOf(1, 2, 3)))
+
+        val tcsDataA = CompletableDeferred<ByteArray>()
+        channelA.setDataHandler { _, _, o, so, d ->
+            val b = ByteArray(d.remaining())
+            d.get(b)
+            if (o == Opcode.DATA.value && so == 0u.toUByte()) tcsDataA.complete(b)
+        }
+        channelB.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(byteArrayOf(4, 5, 6)))
+
+        val receivedB = withTimeout(5000.milliseconds) { tcsDataB.await() }
+        val receivedA = withTimeout(5000.milliseconds) { tcsDataA.await() }
+        assertArrayEquals(byteArrayOf(1, 2, 3), receivedB)
+        assertArrayEquals(byteArrayOf(4, 5, 6), receivedA)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun relayedTransport_MaximumMessageSize_Success() = runBlocking {
+        val MAX_DATA_PER_PACKET = SyncSocketSession.MAXIMUM_PACKET_SIZE - SyncSocketSession.HEADER_SIZE - 8 - 16 - 16
+        val maxSizeData = ByteArray(MAX_DATA_PER_PACKET).apply { Random.nextBytes(this) }
+        val tcsA = CompletableDeferred<ChannelRelayed>()
+        val tcsB = CompletableDeferred<ChannelRelayed>()
+        val clientA = createClient(onNewChannel = { _, c -> tcsA.complete(c) })
+        val clientB = createClient(onNewChannel = { _, c -> tcsB.complete(c) })
+        val channelTask = async { clientA.startRelayedChannel(clientB.localPublicKey) }
+        val channelA = withTimeout(5000.milliseconds) { tcsA.await() }
+        channelA.authorizable = AlwaysAuthorized()
+        val channelB = withTimeout(5000.milliseconds) { tcsB.await() }
+        channelB.authorizable = AlwaysAuthorized()
+        channelTask.await()
+
+        val tcsDataB = CompletableDeferred<ByteArray>()
+        channelB.setDataHandler { _, _, o, so, d ->
+            val b = ByteArray(d.remaining())
+            d.get(b)
+            if (o == Opcode.DATA.value && so == 0u.toUByte()) tcsDataB.complete(b)
+        }
+        channelA.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(maxSizeData))
+        val receivedData = withTimeout(5000.milliseconds) { tcsDataB.await() }
+        assertArrayEquals(maxSizeData, receivedData)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun publishAndGetRecord_Success() = runBlocking {
+        val clientA = createClient()
+        val clientB = createClient()
+        val clientC = createClient()
+        val data = byteArrayOf(1, 2, 3)
+        val success = clientA.publishRecords(listOf(clientB.localPublicKey), "testKey", data)
+        val recordB = clientB.getRecord(clientA.localPublicKey, "testKey")
+        val recordC = clientC.getRecord(clientA.localPublicKey, "testKey")
+        assertTrue(success)
+        assertNotNull(recordB)
+        assertArrayEquals(data, recordB!!.first)
+        assertNull("Unauthorized client should not access record", recordC)
+        clientA.stop()
+        clientB.stop()
+        clientC.stop()
+    }
+
+    @Test
+    fun getNonExistentRecord_ReturnsNull() = runBlocking {
+        val clientA = createClient()
+        val clientB = createClient()
+        val record = clientB.getRecord(clientA.localPublicKey, "nonExistentKey")
+        assertNull("Getting non-existent record should return null", record)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun updateRecord_TimestampUpdated() = runBlocking {
+        val clientA = createClient()
+        val clientB = createClient()
+        val key = "updateKey"
+        val data1 = byteArrayOf(1)
+        val data2 = byteArrayOf(2)
+        clientA.publishRecords(listOf(clientB.localPublicKey), key, data1)
+        val record1 = clientB.getRecord(clientA.localPublicKey, key)
+        delay(1000.milliseconds)
+        clientA.publishRecords(listOf(clientB.localPublicKey), key, data2)
+        val record2 = clientB.getRecord(clientA.localPublicKey, key)
+        assertNotNull(record1)
+        assertNotNull(record2)
+        assertTrue(record2!!.second > record1!!.second)
+        assertArrayEquals(data2, record2.first)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun deleteRecord_Success() = runBlocking {
+        val clientA = createClient()
+        val clientB = createClient()
+        val data = byteArrayOf(1, 2, 3)
+        clientA.publishRecords(listOf(clientB.localPublicKey), "toDelete", data)
+        val success = clientB.deleteRecords(clientA.localPublicKey, clientB.localPublicKey, listOf("toDelete"))
+        val record = clientB.getRecord(clientA.localPublicKey, "toDelete")
+        assertTrue(success)
+        assertNull(record)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun listRecordKeys_Success() = runBlocking {
+        val clientA = createClient()
+        val clientB = createClient()
+        val keys = arrayOf("key1", "key2", "key3")
+        keys.forEach { key ->
+            clientA.publishRecords(listOf(clientB.localPublicKey), key, byteArrayOf(1))
+        }
+        val listedKeys = clientB.listRecordKeys(clientA.localPublicKey, clientB.localPublicKey)
+        assertArrayEquals(keys, listedKeys.map { it.first }.toTypedArray())
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun singleLargeMessageViaRelayedChannel_Success() = runBlocking {
+        val largeData = ByteArray(100000).apply { Random.nextBytes(this) }
+        val tcsA = CompletableDeferred<ChannelRelayed>()
+        val tcsB = CompletableDeferred<ChannelRelayed>()
+        val clientA = createClient(onNewChannel = { _, c -> tcsA.complete(c) })
+        val clientB = createClient(onNewChannel = { _, c -> tcsB.complete(c) })
+        val channelTask = async { clientA.startRelayedChannel(clientB.localPublicKey) }
+        val channelA = withTimeout(5000.milliseconds) { tcsA.await() }
+        channelA.authorizable = AlwaysAuthorized()
+        val channelB = withTimeout(5000.milliseconds) { tcsB.await() }
+        channelB.authorizable = AlwaysAuthorized()
+        channelTask.await()
+
+        val tcsDataB = CompletableDeferred<ByteArray>()
+        channelB.setDataHandler { _, _, o, so, d ->
+            val b = ByteArray(d.remaining())
+            d.get(b)
+            if (o == Opcode.DATA.value && so == 0u.toUByte()) tcsDataB.complete(b)
+        }
+        channelA.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(largeData))
+        val receivedData = withTimeout(10000.milliseconds) { tcsDataB.await() }
+        assertArrayEquals(largeData, receivedData)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun publishAndGetLargeRecord_Success() = runBlocking {
+        val largeData = ByteArray(1000000).apply { Random.nextBytes(this) }
+        val clientA = createClient()
+        val clientB = createClient()
+        val success = clientA.publishRecords(listOf(clientB.localPublicKey), "largeRecord", largeData)
+        val record = clientB.getRecord(clientA.localPublicKey, "largeRecord")
+        assertTrue(success)
+        assertNotNull(record)
+        assertArrayEquals(largeData, record!!.first)
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun relayedTransport_WithValidAppId_Success() = runBlocking {
+        // Arrange: Set up clients
+        val allowedAppId = 1234u
+        val tcsB = CompletableDeferred<ChannelRelayed>()
+
+        // Client B requires appId 1234
+        val clientB = createClient(
+            onNewChannel = { _, c -> tcsB.complete(c) },
+            isHandshakeAllowed = { linkType, _, _, _, appId -> linkType == LinkType.Relayed && appId == allowedAppId }
+        )
+
+        val clientA = createClient()
+
+        // Act: Start relayed channel with valid appId
+        val channelTask = async { clientA.startRelayedChannel(clientB.localPublicKey, appId = allowedAppId) }
+        val channelB = withTimeout(5.seconds) { tcsB.await() }
+        withTimeout(5.seconds) { channelTask.await() }
+
+        // Assert: Channel is established
+        assertNotNull("Channel should be created on target with valid appId", channelB)
+
+        // Clean up
+        clientA.stop()
+        clientB.stop()
+    }
+
+    @Test
+    fun relayedTransport_WithInvalidAppId_Fails() = runBlocking {
+        // Arrange: Set up clients
+        val allowedAppId = 1234u
+        val invalidAppId = 5678u
+        val tcsB = CompletableDeferred<ChannelRelayed>()
+
+        // Client B requires appId 1234
+        val clientB = createClient(
+            onNewChannel = { _, c -> tcsB.complete(c) },
+            isHandshakeAllowed = { linkType, _, _, _, appId -> linkType == LinkType.Relayed && appId == allowedAppId },
+            onException = { }
+        )
+
+        val clientA = createClient()
+
+        // Act & Assert: Attempt with invalid appId should fail
+        try {
+            withTimeout(5.seconds) {
+                clientA.startRelayedChannel(clientB.localPublicKey, appId = invalidAppId)
+            }
+            fail("Starting relayed channel with invalid appId should fail")
+        } catch (e: Throwable) {
+            // Expected: The channel creation should time out or fail
+        }
+
+        // Ensure no channel was created on client B
+        val completedTask = select {
+            tcsB.onAwait { "channel" }
+            async { delay(1.seconds); "timeout" }.onAwait { "timeout" }
+        }
+        assertEquals("No channel should be created with invalid appId", "timeout", completedTask)
+
+        // Clean up
+        clientA.stop()
+        clientB.stop()
+    }
+}
+
+class AlwaysAuthorized : IAuthorizable {
+    override val isAuthorized: Boolean get() = true
+}

app/src/androidTest/java/com/futo/platformplayer/SyncTests.kt

@@ -0,0 +1,512 @@
+package com.futo.platformplayer
+
+import com.futo.platformplayer.noise.protocol.DHState
+import com.futo.platformplayer.noise.protocol.Noise
+import com.futo.platformplayer.sync.internal.*
+import kotlinx.coroutines.*
+import org.junit.Assert.*
+import org.junit.Test
+import java.io.PipedInputStream
+import java.io.PipedOutputStream
+import java.nio.ByteBuffer
+import kotlin.random.Random
+import java.io.InputStream
+import java.io.OutputStream
+import kotlin.time.Duration.Companion.seconds
+
+data class PipeStreams(
+    val initiatorInput: LittleEndianDataInputStream,
+    val initiatorOutput: LittleEndianDataOutputStream,
+    val responderInput: LittleEndianDataInputStream,
+    val responderOutput: LittleEndianDataOutputStream
+)
+
+typealias OnHandshakeComplete = (SyncSocketSession) -> Unit
+typealias IsHandshakeAllowed = (LinkType, SyncSocketSession, String, String?, UInt) -> Boolean
+typealias OnClose = (SyncSocketSession) -> Unit
+typealias OnData = (SyncSocketSession, UByte, UByte, ByteBuffer) -> Unit
+
+class SyncSocketTests {
+    private fun createPipeStreams(): PipeStreams {
+        val initiatorOutput = PipedOutputStream()
+        val responderOutput = PipedOutputStream()
+        val responderInput = PipedInputStream(initiatorOutput)
+        val initiatorInput = PipedInputStream(responderOutput)
+        return PipeStreams(
+            LittleEndianDataInputStream(initiatorInput), LittleEndianDataOutputStream(initiatorOutput),
+            LittleEndianDataInputStream(responderInput), LittleEndianDataOutputStream(responderOutput)
+        )
+    }
+    
+    fun generateKeyPair(): DHState {
+        val p = Noise.createDH("25519")
+        p.generateKeyPair()
+        return p
+    }
+
+    private fun createSessions(
+        initiatorInput: LittleEndianDataInputStream,
+        initiatorOutput: LittleEndianDataOutputStream,
+        responderInput: LittleEndianDataInputStream,
+        responderOutput: LittleEndianDataOutputStream,
+        initiatorKeyPair: DHState,
+        responderKeyPair: DHState,
+        onInitiatorHandshakeComplete: OnHandshakeComplete,
+        onResponderHandshakeComplete: OnHandshakeComplete,
+        onInitiatorClose: OnClose? = null,
+        onResponderClose: OnClose? = null,
+        onClose: OnClose? = null,
+        isHandshakeAllowed: IsHandshakeAllowed? = null,
+        onDataA: OnData? = null,
+        onDataB: OnData? = null
+    ): Pair<SyncSocketSession, SyncSocketSession> {
+        val initiatorSession = SyncSocketSession(
+            "", initiatorKeyPair, initiatorInput, initiatorOutput,
+            onClose = {
+                onClose?.invoke(it)
+                onInitiatorClose?.invoke(it)
+            },
+            onHandshakeComplete = onInitiatorHandshakeComplete,
+            onData = onDataA,
+            isHandshakeAllowed = isHandshakeAllowed
+        )
+
+        val responderSession = SyncSocketSession(
+            "", responderKeyPair, responderInput, responderOutput,
+            onClose = {
+                onClose?.invoke(it)
+                onResponderClose?.invoke(it)
+            },
+            onHandshakeComplete = onResponderHandshakeComplete,
+            onData = onDataB,
+            isHandshakeAllowed = isHandshakeAllowed
+        )
+
+        return Pair(initiatorSession, responderSession)
+    }
+
+    @Test
+    fun handshake_WithValidPairingCode_Succeeds(): Unit = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+        val validPairingCode = "secret"
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            isHandshakeAllowed = { _, _, _, pairingCode, _ -> pairingCode == validPairingCode }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey, pairingCode = validPairingCode)
+        responderSession.startAsResponder()
+
+        withTimeout(5.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+    }
+
+    @Test
+    fun handshake_WithInvalidPairingCode_Fails() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+        val validPairingCode = "secret"
+        val invalidPairingCode = "wrong"
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val initiatorClosed = CompletableDeferred<Boolean>()
+        val responderClosed = CompletableDeferred<Boolean>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onInitiatorClose = {
+                initiatorClosed.complete(true)
+            },
+            onResponderClose = {
+                responderClosed.complete(true)
+            },
+            isHandshakeAllowed = { _, _, _, pairingCode, _ -> pairingCode == validPairingCode }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey, pairingCode = invalidPairingCode)
+        responderSession.startAsResponder()
+
+        withTimeout(100.seconds) {
+            initiatorClosed.await()
+            responderClosed.await()
+        }
+
+        assertFalse(handshakeInitiatorCompleted.isCompleted)
+        assertFalse(handshakeResponderCompleted.isCompleted)
+    }
+
+    @Test
+    fun handshake_WithoutPairingCodeWhenRequired_Fails() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+        val validPairingCode = "secret"
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val initiatorClosed = CompletableDeferred<Boolean>()
+        val responderClosed = CompletableDeferred<Boolean>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onInitiatorClose = {
+                initiatorClosed.complete(true)
+            },
+            onResponderClose = {
+                responderClosed.complete(true)
+            },
+            isHandshakeAllowed = { _, _, _, pairingCode, _ -> pairingCode == validPairingCode }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey) // No pairing code
+        responderSession.startAsResponder()
+
+        withTimeout(5.seconds) {
+            initiatorClosed.await()
+            responderClosed.await()
+        }
+
+        assertFalse(handshakeInitiatorCompleted.isCompleted)
+        assertFalse(handshakeResponderCompleted.isCompleted)
+    }
+
+    @Test
+    fun handshake_WithPairingCodeWhenNotRequired_Succeeds(): Unit = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+        val pairingCode = "unnecessary"
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            isHandshakeAllowed = { _, _, _, _, _ -> true } // Always allow
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey, pairingCode = pairingCode)
+        responderSession.startAsResponder()
+
+        withTimeout(10.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+    }
+
+    @Test
+    fun sendAndReceive_SmallDataPacket_Succeeds() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val tcsDataReceived = CompletableDeferred<ByteArray>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onDataB = { _, opcode, subOpcode, data ->
+                if (opcode == Opcode.DATA.value && subOpcode == 0u.toUByte()) {
+                    val b = ByteArray(data.remaining())
+                    data.get(b)
+                    tcsDataReceived.complete(b)
+                }
+            }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey)
+        responderSession.startAsResponder()
+
+        withTimeout(10.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+
+        // Ensure both sessions are authorized
+        initiatorSession.authorizable = Authorized()
+        responderSession.authorizable = Authorized()
+
+        val smallData = byteArrayOf(1, 2, 3)
+        initiatorSession.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(smallData))
+
+        val receivedData = withTimeout(10.seconds) { tcsDataReceived.await() }
+        assertArrayEquals(smallData, receivedData)
+    }
+
+    @Test
+    fun sendAndReceive_ExactlyMaximumPacketSize_Succeeds() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val tcsDataReceived = CompletableDeferred<ByteArray>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onDataB = { _, opcode, subOpcode, data ->
+                if (opcode == Opcode.DATA.value && subOpcode == 0u.toUByte()) {
+                    val b = ByteArray(data.remaining())
+                    data.get(b)
+                    tcsDataReceived.complete(b)
+                }
+            }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey)
+        responderSession.startAsResponder()
+
+        withTimeout(10.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+
+        // Ensure both sessions are authorized
+        initiatorSession.authorizable = Authorized()
+        responderSession.authorizable = Authorized()
+
+        val maxData = ByteArray(SyncSocketSession.MAXIMUM_PACKET_SIZE - SyncSocketSession.HEADER_SIZE).apply { Random.nextBytes(this) }
+        initiatorSession.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(maxData))
+
+        val receivedData = withTimeout(10.seconds) { tcsDataReceived.await() }
+        assertArrayEquals(maxData, receivedData)
+    }
+
+    @Test
+    fun stream_LargeData_Succeeds() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val tcsDataReceived = CompletableDeferred<ByteArray>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onDataB = { _, opcode, subOpcode, data ->
+                if (opcode == Opcode.DATA.value && subOpcode == 0u.toUByte()) {
+                    val b = ByteArray(data.remaining())
+                    data.get(b)
+                    tcsDataReceived.complete(b)
+                }
+            }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey)
+        responderSession.startAsResponder()
+
+        withTimeout(10.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+
+        // Ensure both sessions are authorized
+        initiatorSession.authorizable = Authorized()
+        responderSession.authorizable = Authorized()
+
+        val largeData = ByteArray(2 * (SyncSocketSession.MAXIMUM_PACKET_SIZE - SyncSocketSession.HEADER_SIZE)).apply { Random.nextBytes(this) }
+        initiatorSession.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(largeData))
+
+        val receivedData = withTimeout(10.seconds) { tcsDataReceived.await() }
+        assertArrayEquals(largeData, receivedData)
+    }
+
+    @Test
+    fun authorizedSession_CanSendData() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val tcsDataReceived = CompletableDeferred<ByteArray>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onDataB = { _, opcode, subOpcode, data ->
+                if (opcode == Opcode.DATA.value && subOpcode == 0u.toUByte()) {
+                    val b = ByteArray(data.remaining())
+                    data.get(b)
+                    tcsDataReceived.complete(b)
+                }
+            }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey)
+        responderSession.startAsResponder()
+
+        withTimeout(10.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+
+        // Authorize both sessions
+        initiatorSession.authorizable = Authorized()
+        responderSession.authorizable = Authorized()
+
+        val data = byteArrayOf(1, 2, 3)
+        initiatorSession.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(data))
+
+        val receivedData = withTimeout(10.seconds) { tcsDataReceived.await() }
+        assertArrayEquals(data, receivedData)
+    }
+
+    @Test
+    fun unauthorizedSession_CannotSendData() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val tcsDataReceived = CompletableDeferred<ByteArray>()
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onDataB = { _, _, _, _ -> }
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey)
+        responderSession.startAsResponder()
+
+        withTimeout(10.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+
+        // Authorize initiator but not responder
+        initiatorSession.authorizable = Authorized()
+        responderSession.authorizable = Unauthorized()
+
+        val data = byteArrayOf(1, 2, 3)
+        initiatorSession.send(Opcode.DATA.value, 0u, ByteBuffer.wrap(data))
+
+        delay(1.seconds)
+        assertFalse(tcsDataReceived.isCompleted)
+    }
+
+    @Test
+    fun directHandshake_WithValidAppId_Succeeds() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+        val allowedAppId = 1234u
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+
+        val responderIsHandshakeAllowed = { linkType: LinkType, _: SyncSocketSession, _: String, _: String?, appId: UInt ->
+            linkType == LinkType.Direct && appId == allowedAppId
+        }
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            isHandshakeAllowed = responderIsHandshakeAllowed
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey, appId = allowedAppId)
+        responderSession.startAsResponder()
+
+        withTimeout(5.seconds) {
+            handshakeInitiatorCompleted.await()
+            handshakeResponderCompleted.await()
+        }
+
+        assertNotNull(initiatorSession.remotePublicKey)
+        assertNotNull(responderSession.remotePublicKey)
+    }
+
+    @Test
+    fun directHandshake_WithInvalidAppId_Fails() = runBlocking {
+        val (initiatorInput, initiatorOutput, responderInput, responderOutput) = createPipeStreams()
+        val initiatorKeyPair = generateKeyPair()
+        val responderKeyPair = generateKeyPair()
+        val allowedAppId = 1234u
+        val invalidAppId = 5678u
+
+        val handshakeInitiatorCompleted = CompletableDeferred<Boolean>()
+        val handshakeResponderCompleted = CompletableDeferred<Boolean>()
+        val initiatorClosed = CompletableDeferred<Boolean>()
+        val responderClosed = CompletableDeferred<Boolean>()
+
+        val responderIsHandshakeAllowed = { linkType: LinkType, _: SyncSocketSession, _: String, _: String?, appId: UInt ->
+            linkType == LinkType.Direct && appId == allowedAppId
+        }
+
+        val (initiatorSession, responderSession) = createSessions(
+            initiatorInput, initiatorOutput, responderInput, responderOutput,
+            initiatorKeyPair, responderKeyPair,
+            { handshakeInitiatorCompleted.complete(true) },
+            { handshakeResponderCompleted.complete(true) },
+            onInitiatorClose = {
+                initiatorClosed.complete(true)
+            },
+            onResponderClose = {
+                responderClosed.complete(true)
+            },
+            isHandshakeAllowed = responderIsHandshakeAllowed
+        )
+
+        initiatorSession.startAsInitiator(responderSession.localPublicKey, appId = invalidAppId)
+        responderSession.startAsResponder()
+
+        withTimeout(5.seconds) {
+            initiatorClosed.await()
+            responderClosed.await()
+        }
+
+        assertFalse(handshakeInitiatorCompleted.isCompleted)
+        assertFalse(handshakeResponderCompleted.isCompleted)
+    }
+}
+
+class Authorized : IAuthorizable {
+    override val isAuthorized: Boolean = true
+}
+
+class Unauthorized : IAuthorizable {
+    override val isAuthorized: Boolean = false
+}

app/src/main/AndroidManifest.xml

@@ -15,6 +15,7 @@
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_MEDIA_PLAYBACK"/>
     <uses-permission android:name="android.permission.FOREGROUND_SERVICE_DATA_SYNC"/>
     <uses-permission android:name="android.permission.WRITE_SETTINGS" tools:ignore="ProtectedPermissions"/>
+    <uses-permission android:name="android.permission.UPDATE_PACKAGES_WITHOUT_USER_ACTION" />
 
     <application
         android:allowBackup="true"
@@ -55,7 +56,7 @@
 
         <activity
             android:name=".activities.MainActivity"
-            android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout|uiMode"
             android:exported="true"
             android:theme="@style/Theme.FutoVideo.NoActionBar"
             android:launchMode="singleInstance"
@@ -239,4 +240,4 @@
             android:screenOrientation="sensorPortrait"
             android:theme="@style/Theme.FutoVideo.NoActionBar" />
     </application>
-</manifest>
+</manifest>

app/src/main/assets/scripts/source.js

@@ -32,7 +32,8 @@ let Type = {
     Text: {
         RAW: 0,
         HTML: 1,
-        MARKUP: 2
+        MARKUP: 2,
+        CODE: 3
     },
     Chapter: {
         NORMAL: 0,
@@ -291,15 +292,39 @@ class PlatformPostDetails extends PlatformPost {
     }
 }
 
-class PlatformArticleDetails extends PlatformContent {
+class PlatformWeb extends PlatformContent {
+    constructor(obj) {
+        super(obj, 7);
+        obj = obj ?? {};
+        this.plugin_type = "PlatformWeb";
+    }
+}
+class PlatformWebDetails extends PlatformWeb {
+    constructor(obj) {
+        super(obj, 7);
+        obj = obj ?? {};
+        this.plugin_type = "PlatformWebDetails";
+        this.html = obj.html;
+    }
+}
+
+class PlatformArticle extends PlatformContent {
+    constructor(obj) {
+        super(obj, 3);
+        obj = obj ?? {};
+        this.plugin_type = "PlatformArticle";
+        this.rating = obj.rating ?? new RatingLikes(-1);
+        this.summary = obj.summary ?? "";
+        this.thumbnails = obj.thumbnails ?? new Thumbnails([]);
+    }
+}
+class PlatformArticleDetails extends PlatformArticle {
     constructor(obj) {
         super(obj, 3);
         obj = obj ?? {};
         this.plugin_type = "PlatformArticleDetails";
         this.rating = obj.rating ?? new RatingLikes(-1);
-        this.summary = obj.summary ?? "";
         this.segments = obj.segments ?? [];
-        this.thumbnails = obj.thumbnails ?? new Thumbnails([]);
     }
 }
 class ArticleSegment {
@@ -315,9 +340,10 @@ class ArticleTextSegment extends ArticleSegment {
     }
 }
 class ArticleImagesSegment extends ArticleSegment {
-    constructor(images) {
+    constructor(images, caption) {
         super(2);
         this.images = images;
+        this.caption = caption;
     }
 }
 class ArticleNestedSegment extends ArticleSegment {
@@ -595,6 +621,8 @@ class PlatformComment {
         this.date = obj.date ?? 0;
         this.replyCount = obj.replyCount ?? 0;
         this.context = obj.context ?? {};
+        if(obj.getReplies)
+            this.getReplies = obj.getReplies;
     }
 }
 

app/src/main/java/com/futo/platformplayer/Extensions_Formatting.kt

@@ -14,7 +14,6 @@ import java.text.DecimalFormat
 import java.time.OffsetDateTime
 import java.time.temporal.ChronoUnit
 import kotlin.math.abs
-import kotlin.math.roundToInt
 import kotlin.math.roundToLong
 
 
@@ -376,14 +375,19 @@ private val slds = hashSetOf(".com.ac", ".net.ac", ".gov.ac", ".org.ac", ".mil.a
 fun String.matchesDomain(queryDomain: String): Boolean {
 
     if(queryDomain.startsWith(".")) {
-
-        val parts = queryDomain.lowercase().split(".");
-        if(parts.size < 3)
+        val parts = this.lowercase().split(".");
+        val queryParts = queryDomain.lowercase().trimStart("."[0]).split(".");
+        if(queryParts.size < 2)
             throw IllegalStateException("Illegal use of wildcards on First-Level-Domain (" + queryDomain + ")");
-        if(parts.size >= 3){
-            val isSLD = slds.contains("." + parts[parts.size - 2] + "." + parts[parts.size - 1]);
-            if(isSLD && parts.size <= 3)
+        else {
+            val possibleDomain = "." + queryParts.joinToString(".");
+            if(slds.contains(possibleDomain))
                 throw IllegalStateException("Illegal use of wildcards on Second-Level-Domain (" + queryDomain + ")");
+            /*
+            val isSLD = slds.contains("." + queryParts[queryParts.size - 2] + "." + queryParts[queryParts.size - 1]);
+            if(isSLD && queryParts.size <= 3)
+                throw IllegalStateException("Illegal use of wildcards on Second-Level-Domain (" + queryDomain + ")");
+            */
         }
 
         //TODO: Should be safe, but double verify if can't be exploited
@@ -395,9 +399,11 @@ fun String.matchesDomain(queryDomain: String): Boolean {
 
 fun String.getSubdomainWildcardQuery(): String {
     val domainParts = this.split(".");
-    val sldParts = "." + domainParts[domainParts.size - 2].lowercase() + "." + domainParts[domainParts.size - 1].lowercase();
-    if(slds.contains(sldParts))
-        return "." + domainParts.drop(domainParts.size - 3).joinToString(".");
+    var wildcardDomain = if(domainParts.size > 2)
+        "." + domainParts.drop(1).joinToString(".")
     else
-        return "." + domainParts.drop(domainParts.size - 2).joinToString(".");
+        "." + domainParts.joinToString(".");
+    if(slds.contains(wildcardDomain.lowercase()))
+        "." + domainParts.joinToString(".");
+    return wildcardDomain;
 }

app/src/main/java/com/futo/platformplayer/Extensions_Network.kt

@@ -216,9 +216,16 @@ private fun ByteArray.toInetAddress(): InetAddress {
     return InetAddress.getByAddress(this);
 }
 
-fun getConnectedSocket(addresses: List<InetAddress>, port: Int): Socket? {
+fun getConnectedSocket(attemptAddresses: List<InetAddress>, port: Int): Socket? {
+    ensureNotMainThread()
+
     val timeout = 2000
 
+
+    val addresses = if(!Settings.instance.casting.allowIpv6) attemptAddresses.filterIsInstance<Inet4Address>() else attemptAddresses;
+    if(addresses.isEmpty())
+        throw IllegalStateException("No valid addresses found (ipv6: ${(if(Settings.instance.casting.allowIpv6) "enabled" else "disabled")})");
+
     if (addresses.isEmpty()) {
         return null;
     }

app/src/main/java/com/futo/platformplayer/Extensions_Syntax.kt

@@ -7,6 +7,9 @@ import java.net.InetAddress
 import java.net.URI
 import java.net.URISyntaxException
 import java.net.URLEncoder
+import java.time.Instant
+import java.time.OffsetDateTime
+import java.time.ZoneOffset
 
 //Syntax sugaring
 inline fun <reified T> Any.assume(): T?{
@@ -33,13 +36,37 @@ fun Boolean?.toYesNo(): String {
 fun InetAddress?.toUrlAddress(): String {
     return when (this) {
         is Inet6Address -> {
-            "[${hostAddress}]"
+            val hostAddr = this.hostAddress ?: throw Exception("Invalid address: hostAddress is null")
+            val index = hostAddr.indexOf('%')
+            if (index != -1) {
+                val addrPart = hostAddr.substring(0, index)
+                val scopeId = hostAddr.substring(index + 1)
+                "[${addrPart}%25${scopeId}]" // %25 is URL-encoded '%'
+            } else {
+                "[$hostAddr]"
+            }
         }
         is Inet4Address -> {
-            hostAddress
+            this.hostAddress ?: throw Exception("Invalid address: hostAddress is null")
         }
         else -> {
             throw Exception("Invalid address type")
         }
     }
+}
+
+fun Long?.sToOffsetDateTimeUTC(): OffsetDateTime {
+    if (this == null || this < 0)
+        return OffsetDateTime.MIN
+    if(this > 4070912400)
+        return OffsetDateTime.MAX;
+    return OffsetDateTime.ofInstant(Instant.ofEpochSecond(this), ZoneOffset.UTC)
+}
+
+fun Long?.msToOffsetDateTimeUTC(): OffsetDateTime {
+    if (this == null || this < 0)
+        return OffsetDateTime.MIN
+    if(this > 4070912400)
+        return OffsetDateTime.MAX;
+    return OffsetDateTime.ofInstant(Instant.ofEpochMilli(this), ZoneOffset.UTC)
 }

app/src/main/java/com/futo/platformplayer/Settings.kt

@@ -205,7 +205,7 @@ class Settings : FragmentedStorageFileJson() {
     var home = HomeSettings();
     @Serializable
     class HomeSettings {
-        @FormField(R.string.feed_style, FieldForm.DROPDOWN, R.string.may_require_restart, 5)
+        @FormField(R.string.feed_style, FieldForm.DROPDOWN, R.string.may_require_restart, 3)
         @DropdownFieldOptionsId(R.array.feed_style)
         var homeFeedStyle: Int = 1;
 
@@ -216,6 +216,11 @@ class Settings : FragmentedStorageFileJson() {
                 return FeedStyle.THUMBNAIL;
         }
 
+        @FormField(R.string.show_home_filters, FieldForm.TOGGLE, R.string.show_home_filters_description, 4)
+        var showHomeFilters: Boolean = true;
+        @FormField(R.string.show_home_filters_plugin_names, FieldForm.TOGGLE, R.string.show_home_filters_plugin_names_description, 5)
+        var showHomeFiltersPluginNames: Boolean = false;
+
         @FormField(R.string.preview_feed_items, FieldForm.TOGGLE, R.string.preview_feed_items_description, 6)
         var previewFeedItems: Boolean = true;
 
@@ -294,6 +299,9 @@ class Settings : FragmentedStorageFileJson() {
         @FormField(R.string.show_subscription_group, FieldForm.TOGGLE, R.string.show_subscription_group_description, 5)
         var showSubscriptionGroups: Boolean = true;
 
+        @FormField(R.string.use_subscription_exchange, FieldForm.TOGGLE, R.string.use_subscription_exchange_description, 6)
+        var useSubscriptionExchange: Boolean = false;
+
         @FormField(R.string.preview_feed_items, FieldForm.TOGGLE, R.string.preview_feed_items_description, 6)
         var previewFeedItems: Boolean = true;
 
@@ -491,6 +499,22 @@ class Settings : FragmentedStorageFileJson() {
 
         @FormField(R.string.delete_watchlist_on_finish, FieldForm.TOGGLE, R.string.delete_watchlist_on_finish_description, 22)
         var deleteFromWatchLaterAuto: Boolean = true;
+
+        @FormField(R.string.seek_offset, FieldForm.DROPDOWN, R.string.seek_offset_description, 23)
+        @DropdownFieldOptionsId(R.array.seek_offset_duration)
+        var seekOffset: Int = 2;
+
+        fun getSeekOffset(): Long {
+          return when(seekOffset) {
+            0 -> 3_000L;
+            1 -> 5_000L;
+            2 -> 10_000L;
+            3 -> 20_000L;
+            4 -> 30_000L;
+            5 -> 60_000L;
+            else -> 10_000L;
+          }
+        }
     }
 
     @FormField(R.string.comments, "group", R.string.comments_description, 6)
@@ -575,10 +599,15 @@ class Settings : FragmentedStorageFileJson() {
         @Serializable(with = FlexibleBooleanSerializer::class)
         var keepScreenOn: Boolean = true;
 
-        @FormField(R.string.always_proxy_requests, FieldForm.TOGGLE, R.string.always_proxy_requests_description, 1)
+        @FormField(R.string.always_proxy_requests, FieldForm.TOGGLE, R.string.always_proxy_requests_description, 3)
         @Serializable(with = FlexibleBooleanSerializer::class)
         var alwaysProxyRequests: Boolean = false;
 
+
+        @FormField(R.string.allow_ipv6, FieldForm.TOGGLE, R.string.allow_ipv6_description, 4)
+        @Serializable(with = FlexibleBooleanSerializer::class)
+        var allowIpv6: Boolean = true;
+
         /*TODO: Should we have a different casting quality?
         @FormField("Preferred Casting Quality", FieldForm.DROPDOWN, "", 3)
         @DropdownFieldOptionsId(R.array.preferred_quality_array)
@@ -913,7 +942,7 @@ class Settings : FragmentedStorageFileJson() {
     @Serializable
     class Synchronization {
         @FormField(R.string.enabled, FieldForm.TOGGLE, R.string.enabled_description, 1)
-        var enabled: Boolean = true;
+        var enabled: Boolean = false;
 
         @FormField(R.string.broadcast, FieldForm.TOGGLE, R.string.broadcast_description, 1)
         var broadcast: Boolean = false;
@@ -923,6 +952,21 @@ class Settings : FragmentedStorageFileJson() {
 
         @FormField(R.string.connect_last, FieldForm.TOGGLE, R.string.connect_last_description, 3)
         var connectLast: Boolean = true;
+
+        @FormField(R.string.discover_through_relay, FieldForm.TOGGLE, R.string.discover_through_relay_description, 3)
+        var discoverThroughRelay: Boolean = true;
+
+        @FormField(R.string.pair_through_relay, FieldForm.TOGGLE, R.string.pair_through_relay_description, 3)
+        var pairThroughRelay: Boolean = true;
+
+        @FormField(R.string.connect_through_relay, FieldForm.TOGGLE, R.string.connect_through_relay_description, 3)
+        var connectThroughRelay: Boolean = true;
+
+        @FormField(R.string.connect_local_direct_through_relay, FieldForm.TOGGLE, R.string.connect_local_direct_through_relay_description, 3)
+        var connectLocalDirectThroughRelay: Boolean = true;
+
+        @FormField(R.string.local_connections, FieldForm.TOGGLE, R.string.local_connections_description, 3)
+        var localConnections: Boolean = true;
     }
 
     @FormField(R.string.info, FieldForm.GROUP, -1, 21)
@@ -991,4 +1035,4 @@ class Settings : FragmentedStorageFileJson() {
         }
     }
     //endregion
-}
+}

app/src/main/java/com/futo/platformplayer/UIDialogs.kt

@@ -5,6 +5,7 @@ import android.app.AlertDialog
 import android.content.Context
 import android.content.Intent
 import android.graphics.Color
+import android.graphics.drawable.Animatable
 import android.net.Uri
 import android.text.Layout
 import android.text.method.ScrollingMovementMethod
@@ -199,16 +200,21 @@ class UIDialogs {
             dialog.show();
         }
 
-        fun showDialog(context: Context, icon: Int, text: String, textDetails: String? = null, code: String? = null, defaultCloseAction: Int, vararg actions: Action) {
+        fun showDialog(context: Context, icon: Int, text: String, textDetails: String? = null, code: String? = null, defaultCloseAction: Int, vararg actions: Action): AlertDialog {
+            return showDialog(context, icon, false, text, textDetails, code, defaultCloseAction, *actions);
+        }
+        fun showDialog(context: Context, icon: Int, animated: Boolean, text: String, textDetails: String? = null, code: String? = null, defaultCloseAction: Int, vararg actions: Action): AlertDialog {
             val builder = AlertDialog.Builder(context);
             val view = LayoutInflater.from(context).inflate(R.layout.dialog_multi_button, null);
             builder.setView(view);
-
+            builder.setCancelable(defaultCloseAction > -2);
             val dialog = builder.create();
             registerDialogOpened(dialog);
 
             view.findViewById<ImageView>(R.id.dialog_icon).apply {
                 this.setImageResource(icon);
+                if(animated)
+                    this.drawable.assume<Animatable, Unit> { it.start() };
             }
             view.findViewById<TextView>(R.id.dialog_text).apply {
                 this.text = text;
@@ -275,6 +281,7 @@ class UIDialogs {
                 registerDialogClosed(dialog);
             }
             dialog.show();
+            return dialog;
         }
 
         fun showGeneralErrorDialog(context: Context, msg: String, ex: Throwable? = null, button: String = "Ok", onOk: (()->Unit)? = null) {

app/src/main/java/com/futo/platformplayer/UISlideOverlays.kt

@@ -4,8 +4,14 @@ import android.app.NotificationManager
 import android.content.ContentResolver
 import android.content.Context
 import android.content.Intent
+import android.net.Uri
 import android.view.View
 import android.view.ViewGroup
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.hls.playlist.DefaultHlsPlaylistParserFactory
+import androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist
+import androidx.media3.exoplayer.hls.playlist.HlsMultivariantPlaylist
 import androidx.recyclerview.widget.RecyclerView
 import com.futo.platformplayer.activities.MainActivity
 import com.futo.platformplayer.activities.SettingsActivity
@@ -37,6 +43,9 @@ import com.futo.platformplayer.models.Playlist
 import com.futo.platformplayer.models.Subscription
 import com.futo.platformplayer.models.SubscriptionGroup
 import com.futo.platformplayer.parsers.HLS
+import com.futo.platformplayer.parsers.HLS.MediaRendition
+import com.futo.platformplayer.parsers.HLS.StreamInfo
+import com.futo.platformplayer.parsers.HLS.VariantPlaylistReference
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StateDownloads
 import com.futo.platformplayer.states.StateHistory
@@ -63,6 +72,8 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
+import java.io.ByteArrayInputStream
+import androidx.core.net.toUri
 
 class UISlideOverlays {
     companion object {
@@ -299,6 +310,7 @@ class UISlideOverlays {
 
         }
 
+        @OptIn(UnstableApi::class)
         fun showHlsPicker(video: IPlatformVideoDetails, source: Any, sourceUrl: String, container: ViewGroup): SlideUpMenuOverlay {
             val items = arrayListOf<View>(LoaderView(container.context))
             val slideUpMenuOverlay = SlideUpMenuOverlay(container.context, container, container.context.getString(R.string.download_video), null, true, items)
@@ -310,6 +322,8 @@ class UISlideOverlays {
                 val masterPlaylistContent = masterPlaylistResponse.body?.string()
                     ?: throw Exception("Master playlist content is empty")
 
+                val resolvedPlaylistUrl = masterPlaylistResponse.url
+
                 val videoButtons = arrayListOf<SlideUpMenuItem>()
                 val audioButtons = arrayListOf<SlideUpMenuItem>()
                 //TODO: Implement subtitles
@@ -322,55 +336,103 @@ class UISlideOverlays {
 
                 val masterPlaylist: HLS.MasterPlaylist
                 try {
-                    masterPlaylist = HLS.parseMasterPlaylist(masterPlaylistContent, sourceUrl)
+                    val inputStream = ByteArrayInputStream(masterPlaylistContent.toByteArray())
+                    val playlist = DefaultHlsPlaylistParserFactory().createPlaylistParser()
+                        .parse(sourceUrl.toUri(), inputStream)
 
-                    masterPlaylist.getAudioSources().forEach { it ->
+                    if (playlist is HlsMediaPlaylist) {
+                        if (source is IHLSManifestAudioSource) {
+                            val variant = HLS.mediaRenditionToVariant(MediaRendition("AUDIO", playlist.baseUri, "Single Playlist", null, null, null, null, null))!!
 
-                        val estSize = VideoHelper.estimateSourceSize(it);
-                        val prefix = if(estSize > 0) "±" + estSize.toHumanBytesSize() + " " else "";
-                        audioButtons.add(SlideUpMenuItem(
-                            container.context,
-                            R.drawable.ic_music,
-                            it.name,
-                            listOf(it.language, it.codec).mapNotNull { x -> x.ifEmpty { null } }.joinToString(", "),
-                            (prefix + it.codec).trim(),
-                            tag = it,
-                            call = {
-                                selectedAudioVariant = it
-                                slideUpMenuOverlay.selectOption(audioButtons, it)
-                                slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
-                            },
-                            invokeParent = false
-                        ))
-                    }
-
-                    /*masterPlaylist.getSubtitleSources().forEach { it ->
-                        subtitleButtons.add(SlideUpMenuItem(container.context, R.drawable.ic_music, it.name, listOf(it.format).mapNotNull { x -> x.ifEmpty { null } }.joinToString(", "), it, {
-                            selectedSubtitleVariant = it
-                            slideUpMenuOverlay.selectOption(subtitleButtons, it)
-                            slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
-                        }, false))
-                    }*/
-
-                    masterPlaylist.getVideoSources().forEach {
-                        val estSize = VideoHelper.estimateSourceSize(it);
-                        val prefix = if(estSize > 0) "±" + estSize.toHumanBytesSize() + " " else "";
-                        videoButtons.add(SlideUpMenuItem(
-                            container.context,
-                            R.drawable.ic_movie,
-                            it.name,
-                            "${it.width}x${it.height}",
-                            (prefix + it.codec).trim(),
-                            tag = it,
-                            call = {
-                                selectedVideoVariant = it
-                                slideUpMenuOverlay.selectOption(videoButtons, it)
-                                if (audioButtons.isEmpty()){
+                            val estSize = VideoHelper.estimateSourceSize(variant);
+                            val prefix = if(estSize > 0) "±" + estSize.toHumanBytesSize() + " " else "";
+                            audioButtons.add(SlideUpMenuItem(
+                                container.context,
+                                R.drawable.ic_music,
+                                variant.name,
+                                listOf(variant.language, variant.codec).mapNotNull { x -> x.ifEmpty { null } }.joinToString(", "),
+                                (prefix + variant.codec).trim(),
+                                tag = variant,
+                                call = {
+                                    selectedAudioVariant = variant
+                                    slideUpMenuOverlay.selectOption(audioButtons, variant)
                                     slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
-                                }
-                            },
-                            invokeParent = false
-                        ))
+                                },
+                                invokeParent = false
+                            ))
+                        } else {
+                            val variant = HLS.variantReferenceToVariant(VariantPlaylistReference(playlist.baseUri, StreamInfo(null, null, null, null, null, null, null, null, null)))
+
+                            val estSize = VideoHelper.estimateSourceSize(variant);
+                            val prefix = if(estSize > 0) "±" + estSize.toHumanBytesSize() + " " else "";
+                            videoButtons.add(SlideUpMenuItem(
+                                container.context,
+                                R.drawable.ic_movie,
+                                variant.name,
+                                "${variant.width}x${variant.height}",
+                                (prefix + variant.codec).trim(),
+                                tag = variant,
+                                call = {
+                                    selectedVideoVariant = variant
+                                    slideUpMenuOverlay.selectOption(videoButtons, variant)
+                                    if (audioButtons.isEmpty()){
+                                        slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
+                                    }
+                                },
+                                invokeParent = false
+                            ))
+                        }
+                    } else if (playlist is HlsMultivariantPlaylist) {
+                        masterPlaylist = HLS.parseMasterPlaylist(masterPlaylistContent, resolvedPlaylistUrl)
+
+                        masterPlaylist.getAudioSources().forEach { it ->
+
+                            val estSize = VideoHelper.estimateSourceSize(it);
+                            val prefix = if(estSize > 0) "±" + estSize.toHumanBytesSize() + " " else "";
+                            audioButtons.add(SlideUpMenuItem(
+                                container.context,
+                                R.drawable.ic_music,
+                                it.name,
+                                listOf(it.language, it.codec).mapNotNull { x -> x.ifEmpty { null } }.joinToString(", "),
+                                (prefix + it.codec).trim(),
+                                tag = it,
+                                call = {
+                                    selectedAudioVariant = it
+                                    slideUpMenuOverlay.selectOption(audioButtons, it)
+                                    slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
+                                },
+                                invokeParent = false
+                            ))
+                        }
+
+                        /*masterPlaylist.getSubtitleSources().forEach { it ->
+                            subtitleButtons.add(SlideUpMenuItem(container.context, R.drawable.ic_music, it.name, listOf(it.format).mapNotNull { x -> x.ifEmpty { null } }.joinToString(", "), it, {
+                                selectedSubtitleVariant = it
+                                slideUpMenuOverlay.selectOption(subtitleButtons, it)
+                                slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
+                            }, false))
+                        }*/
+
+                        masterPlaylist.getVideoSources().forEach {
+                            val estSize = VideoHelper.estimateSourceSize(it);
+                            val prefix = if(estSize > 0) "±" + estSize.toHumanBytesSize() + " " else "";
+                            videoButtons.add(SlideUpMenuItem(
+                                container.context,
+                                R.drawable.ic_movie,
+                                it.name,
+                                "${it.width}x${it.height}",
+                                (prefix + it.codec).trim(),
+                                tag = it,
+                                call = {
+                                    selectedVideoVariant = it
+                                    slideUpMenuOverlay.selectOption(videoButtons, it)
+                                    if (audioButtons.isEmpty()){
+                                        slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
+                                    }
+                                },
+                                invokeParent = false
+                            ))
+                        }
                     }
 
                     val newItems = arrayListOf<View>()
@@ -398,11 +460,11 @@ class UISlideOverlays {
                     if (masterPlaylistContent.lines().any { it.startsWith("#EXTINF:") }) {
                         withContext(Dispatchers.Main) {
                             if (source is IHLSManifestSource) {
-                                StateDownloads.instance.download(video, HLSVariantVideoUrlSource("variant", 0, 0, "application/vnd.apple.mpegurl", "", null, 0, false, sourceUrl), null, null)
+                                StateDownloads.instance.download(video, HLSVariantVideoUrlSource("variant", 0, 0, "application/vnd.apple.mpegurl", "", null, 0, false, resolvedPlaylistUrl), null, null)
                                 UIDialogs.toast(container.context, "Variant video HLS playlist download started")
                                 slideUpMenuOverlay.hide()
                             } else if (source is IHLSManifestAudioSource) {
-                                StateDownloads.instance.download(video, null, HLSVariantAudioUrlSource("variant", 0, "application/vnd.apple.mpegurl", "", "", null, false, false, sourceUrl), null)
+                                StateDownloads.instance.download(video, null, HLSVariantAudioUrlSource("variant", 0, "application/vnd.apple.mpegurl", "", "", null, false, false, resolvedPlaylistUrl), null)
                                 UIDialogs.toast(container.context, "Variant audio HLS playlist download started")
                                 slideUpMenuOverlay.hide()
                             } else {
@@ -684,6 +746,10 @@ class UISlideOverlays {
                             }
                         }
                     }
+                    if(!Settings.instance.downloads.shouldDownload()) {
+                        UIDialogs.appToast("Download will start when you're back on wifi.\n" +
+                                "(You can change this in settings)", true);
+                    }
                 }
             };
             return menu.apply { show() };
@@ -980,26 +1046,30 @@ class UISlideOverlays {
                         + actions).filterNotNull()
             ));
             items.add(
-                SlideUpMenuGroup(container.context, container.context.getString(R.string.add_to), "addto",
-                    SlideUpMenuItem(container.context,
+                SlideUpMenuGroup(
+                    container.context, container.context.getString(R.string.add_to), "addto",
+                    SlideUpMenuItem(
+                        container.context,
                         R.drawable.ic_queue_add,
                         container.context.getString(R.string.add_to_queue),
                         "${queue.size} " + container.context.getString(R.string.videos),
                         tag = "queue",
                         call = { StatePlayer.instance.addToQueue(video); }),
-                    SlideUpMenuItem(container.context,
+                    SlideUpMenuItem(
+                        container.context,
                         R.drawable.ic_watchlist_add,
                         "${container.context.getString(R.string.add_to)} " + StatePlayer.TYPE_WATCHLATER + "",
                         "${watchLater.size} " + container.context.getString(R.string.videos),
                         tag = "watch later",
                         call = { StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(video), true); }),
-                    SlideUpMenuItem(container.context,
+                    SlideUpMenuItem(
+                        container.context,
                         R.drawable.ic_history,
                         container.context.getString(R.string.add_to_history),
                         "Mark as watched",
                         tag = "history",
                         call = { StateHistory.instance.markAsWatched(video); }),
-            ));
+                ));
 
             val playlistItems = arrayListOf<SlideUpMenuItem>();
             playlistItems.add(SlideUpMenuItem(
@@ -1063,14 +1133,17 @@ class UISlideOverlays {
             val queue = StatePlayer.instance.getQueue();
             val watchLater = StatePlaylists.instance.getWatchLater();
             items.add(
-                SlideUpMenuGroup(container.context, container.context.getString(R.string.other), "other",
-                    SlideUpMenuItem(container.context,
+                SlideUpMenuGroup(
+                    container.context, container.context.getString(R.string.other), "other",
+                    SlideUpMenuItem(
+                        container.context,
                         R.drawable.ic_queue_add,
                         container.context.getString(R.string.queue),
                         "${queue.size} " + container.context.getString(R.string.videos),
                         tag = "queue",
                         call = { StatePlayer.instance.addToQueue(video); }),
-                    SlideUpMenuItem(container.context,
+                    SlideUpMenuItem(
+                        container.context,
                         R.drawable.ic_watchlist_add,
                         StatePlayer.TYPE_WATCHLATER,
                         "${watchLater.size} " + container.context.getString(R.string.videos),
@@ -1079,7 +1152,7 @@ class UISlideOverlays {
                             if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(video), true))
                                 UIDialogs.appToast("Added to watch later", false);
                         }),
-                    )
+                )
             );
 
             val playlistItems = arrayListOf<SlideUpMenuItem>();
@@ -1117,8 +1190,8 @@ class UISlideOverlays {
             return SlideUpMenuOverlay(container.context, container, container.context.getString(R.string.add_to), null, true, items).apply { show() };
         }
 
-        fun showFiltersOverlay(lifecycleScope: CoroutineScope, container: ViewGroup, enabledClientsIds: List<String>, filterValues: HashMap<String, List<String>>, isChannelSearch: Boolean = false): SlideUpMenuFilters {
-            val overlay = SlideUpMenuFilters(lifecycleScope, container, enabledClientsIds, filterValues, isChannelSearch);
+        fun showFiltersOverlay(lifecycleScope: CoroutineScope, container: ViewGroup, enabledClientsIds: List<String>, filterValues: HashMap<String, List<String>>): SlideUpMenuFilters {
+            val overlay = SlideUpMenuFilters(lifecycleScope, container, enabledClientsIds, filterValues);
             overlay.show();
             return overlay;
         }
@@ -1148,7 +1221,7 @@ class UISlideOverlays {
                     container.context.getString(R.string.decide_which_buttons_should_be_pinned),
                     tag = "",
                     call = {
-                        showOrderOverlay(container, container.context.getString(R.string.select_your_pins_in_order),  (visible + hidden).map { Pair(it.text.text.toString(), it.tagRef!!) }) {
+                        showOrderOverlay(container, container.context.getString(R.string.select_your_pins_in_order),  (visible + hidden).map { Pair(it.text.text.toString(), it.tagRef!!) }, {
                             val selected = it
                                 .map { x -> visible.find { it.tagRef == x } ?: hidden.find { it.tagRef == x } }
                                 .filter { it != null }
@@ -1156,7 +1229,7 @@ class UISlideOverlays {
                                 .toList();
 
                             onPinnedbuttons?.invoke(selected + (visible + hidden).filter { !selected.contains(it) });
-                        }
+                        });
                     },
                     invokeParent = false
                 ))
@@ -1164,29 +1237,40 @@ class UISlideOverlays {
 
             return SlideUpMenuOverlay(container.context, container, container.context.getString(R.string.more_options), null, true, *views).apply { show() };
         }
-
-        fun showOrderOverlay(container: ViewGroup, title: String, options: List<Pair<String, Any>>, onOrdered: (List<Any>)->Unit) {
+        fun showOrderOverlay(container: ViewGroup, title: String, options: List<Pair<String, Any>>, onOrdered: (List<Any>)->Unit, description: String? = null) {
             val selection: MutableList<Any> = mutableListOf();
 
             var overlay: SlideUpMenuOverlay? = null;
 
             overlay = SlideUpMenuOverlay(container.context, container, title, container.context.getString(R.string.save), true,
-                options.map { SlideUpMenuItem(
+                listOf(
+                    if(!description.isNullOrEmpty()) SlideUpMenuGroup(container.context, "", description, "", listOf()) else null,
+                ).filterNotNull() +
+                (options.map { SlideUpMenuItem(
                     container.context,
                     R.drawable.ic_move_up,
                     it.first,
                     "",
                     tag = it.second,
                     call = {
+                        val overlayItem = overlay?.getSlideUpItemByTag(it.second);
                         if(overlay!!.selectOption(null, it.second, true, true)) {
-                            if(!selection.contains(it.second))
+                            if(!selection.contains(it.second)) {
                                 selection.add(it.second);
-                        } else
+                                if(overlayItem != null) {
+                                    overlayItem.setSubText(selection.indexOf(it.second).toString());
+                                }
+                            }
+                        } else {
                             selection.remove(it.second);
+                            if(overlayItem != null) {
+                                overlayItem.setSubText("");
+                            }
+                        }
                     },
                     invokeParent = false
                 )
-                });
+                }));
             overlay.onOK.subscribe {
                 onOrdered.invoke(selection);
                 overlay.hide();

app/src/main/java/com/futo/platformplayer/Utility.kt

@@ -27,14 +27,23 @@ import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.models.PlatformVideoWithTime
 import com.futo.platformplayer.others.PlatformLinkMovementMethod
 import java.io.ByteArrayInputStream
-import java.io.File
+import java.io.ByteArrayOutputStream
 import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
+import java.net.Inet4Address
+import java.net.Inet6Address
+import java.net.InetAddress
+import java.net.InterfaceAddress
+import java.net.NetworkInterface
+import java.net.SocketException
 import java.nio.ByteBuffer
-import java.nio.ByteOrder
+import java.security.SecureRandom
+import java.time.OffsetDateTime
 import java.util.*
 import java.util.concurrent.ThreadLocalRandom
+import java.util.zip.GZIPInputStream
+import java.util.zip.GZIPOutputStream
 
 private val _allowedCharacters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ";
 fun getRandomString(sizeOfRandomString: Int): String {
@@ -66,7 +75,14 @@ fun warnIfMainThread(context: String) {
 }
 
 fun ensureNotMainThread() {
-    if (Looper.myLooper() == Looper.getMainLooper()) {
+    val isMainLooper = try {
+        Looper.myLooper() == Looper.getMainLooper()
+    } catch (e: Throwable) {
+        //Ignore, for unit tests where its not mocked
+        false
+    }
+
+    if (isMainLooper) {
         Logger.e("Utility", "Throwing exception because a function that should not be called on main thread, is called on main thread")
         throw IllegalStateException("Cannot run on main thread")
     }
@@ -269,7 +285,7 @@ fun <T> findNewIndex(originalArr: List<T>, newArr: List<T>, item: T): Int{
         }
     }
     if(newIndex < 0)
-        return originalArr.size;
+        return newArr.size;
     else
         return newIndex;
 }
@@ -279,3 +295,140 @@ fun ByteBuffer.toUtf8String(): String {
     get(remainingBytes)
     return String(remainingBytes, Charsets.UTF_8)
 }
+
+fun generateReadablePassword(length: Int): String {
+    val validChars = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789"
+    val secureRandom = SecureRandom()
+    val randomBytes = ByteArray(length)
+    secureRandom.nextBytes(randomBytes)
+    val sb = StringBuilder(length)
+    for (byte in randomBytes) {
+        val index = (byte.toInt() and 0xFF) % validChars.length
+        sb.append(validChars[index])
+    }
+    return sb.toString()
+}
+
+fun ByteArray.toGzip(): ByteArray {
+    if (this == null || this.isEmpty()) return ByteArray(0)
+
+    val gzipTimeStart = OffsetDateTime.now();
+
+    val outputStream = ByteArrayOutputStream()
+    GZIPOutputStream(outputStream).use { gzip ->
+        gzip.write(this)
+    }
+    val result = outputStream.toByteArray();
+    Logger.i("Utility", "Gzip compression time: ${gzipTimeStart.getNowDiffMiliseconds()}ms");
+    return result;
+}
+
+fun ByteArray.fromGzip(): ByteArray {
+    if (this == null || this.isEmpty()) return ByteArray(0)
+
+    val inputStream = ByteArrayInputStream(this)
+    val outputStream = ByteArrayOutputStream()
+
+    GZIPInputStream(inputStream).use { gzip ->
+        val buffer = ByteArray(1024)
+        var bytesRead: Int
+        while (gzip.read(buffer).also { bytesRead = it } != -1) {
+            outputStream.write(buffer, 0, bytesRead)
+        }
+    }
+    return outputStream.toByteArray()
+}
+
+fun findPreferredAddress(): InetAddress? {
+    val candidates = NetworkInterface.getNetworkInterfaces()
+        .toList()
+        .asSequence()
+        .filter(::isUsableInterface)
+        .flatMap { nif ->
+            nif.interfaceAddresses
+                .asSequence()
+                .mapNotNull { ia ->
+                    ia.address.takeIf(::isUsableAddress)?.let { addr ->
+                        nif to ia
+                    }
+                }
+        }
+        .toList()
+
+    return candidates
+        .minWithOrNull(
+            compareBy<Pair<NetworkInterface, InterfaceAddress>>(
+                { addressScore(it.second.address) },
+                { interfaceScore(it.first) },
+                { -it.second.networkPrefixLength.toInt() },
+                { -it.first.mtu }
+            )
+        )?.second?.address
+}
+
+private fun isUsableInterface(nif: NetworkInterface): Boolean {
+    val name = nif.name.lowercase()
+    return try {
+        // must be up, not loopback/virtual/PtP, have a MAC, not Docker/tun/etc.
+        nif.isUp
+            && !nif.isLoopback
+            && !nif.isPointToPoint
+            && !nif.isVirtual
+            && !name.startsWith("docker")
+            && !name.startsWith("veth")
+            && !name.startsWith("br-")
+            && !name.startsWith("virbr")
+            && !name.startsWith("vmnet")
+            && !name.startsWith("tun")
+            && !name.startsWith("tap")
+    } catch (e: SocketException) {
+        false
+    }
+}
+
+private fun isUsableAddress(addr: InetAddress): Boolean {
+    return when {
+        addr.isAnyLocalAddress -> false // 0.0.0.0 / ::
+        addr.isLoopbackAddress -> false
+        addr.isLinkLocalAddress -> false // 169.254.x.x or fe80::/10
+        addr.isMulticastAddress -> false
+        else -> true
+    }
+}
+
+private fun interfaceScore(nif: NetworkInterface): Int {
+    val name = nif.name.lowercase()
+    return when {
+        name.matches(Regex("^(eth|enp|eno|ens|em)\\d+")) -> 0
+        name.startsWith("eth") || name.contains("ethernet") -> 0
+        name.matches(Regex("^(wlan|wlp)\\d+")) -> 1
+        name.contains("wi-fi") || name.contains("wifi") -> 1
+        else -> 2
+    }
+}
+
+private fun addressScore(addr: InetAddress): Int {
+    return when (addr) {
+        is Inet4Address -> {
+            val octets = addr.address.map { it.toInt() and 0xFF }
+            when {
+                octets[0] == 10 -> 0  // 10/8
+                octets[0] == 192 && octets[1] == 168 -> 0  // 192.168/16
+                octets[0] == 172 && octets[1] in 16..31 -> 0  // 172.16–31/12
+                else -> 1  // public IPv4
+            }
+        }
+        is Inet6Address -> {
+            // ULA (fc00::/7) vs global vs others
+            val b0 = addr.address[0].toInt() and 0xFF
+            when {
+                (b0 and 0xFE) == 0xFC -> 2  // ULA
+                (b0 and 0xE0) == 0x20 -> 3  // global
+                else -> 4
+            }
+        }
+        else -> Int.MAX_VALUE
+    }
+}
+
+fun <T> Enumeration<T>.toList(): List<T> = Collections.list(this)

app/src/main/java/com/futo/platformplayer/activities/MainActivity.kt

@@ -1,14 +1,15 @@
 package com.futo.platformplayer.activities
 
 import android.annotation.SuppressLint
-import android.content.ComponentName
+import android.app.AlertDialog
+import android.app.UiModeManager
 import android.content.Context
 import android.content.Intent
 import android.content.Intent.FLAG_ACTIVITY_NEW_TASK
 import android.content.pm.PackageManager
 import android.content.res.Configuration
-import android.media.AudioManager
 import android.net.Uri
+import android.os.Build
 import android.os.Bundle
 import android.os.StrictMode
 import android.os.StrictMode.VmPolicy
@@ -21,6 +22,7 @@ import android.widget.ImageView
 import androidx.activity.result.ActivityResult
 import androidx.activity.result.ActivityResultLauncher
 import androidx.activity.result.contract.ActivityResultContracts
+import androidx.annotation.OptIn
 import androidx.appcompat.app.AppCompatActivity
 import androidx.constraintlayout.motion.widget.MotionLayout
 import androidx.core.app.ActivityCompat
@@ -30,6 +32,8 @@ import androidx.fragment.app.Fragment
 import androidx.fragment.app.FragmentContainerView
 import androidx.lifecycle.Lifecycle
 import androidx.lifecycle.lifecycleScope
+import androidx.lifecycle.whenStateAtLeast
+import androidx.lifecycle.withStateAtLeast
 import androidx.media3.common.util.UnstableApi
 import com.futo.platformplayer.BuildConfig
 import com.futo.platformplayer.R
@@ -38,7 +42,9 @@ import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.api.http.ManagedHttpClient
 import com.futo.platformplayer.casting.StateCasting
 import com.futo.platformplayer.constructs.Event1
+import com.futo.platformplayer.dp
 import com.futo.platformplayer.fragment.mainactivity.bottombar.MenuBottomBarFragment
+import com.futo.platformplayer.fragment.mainactivity.main.ArticleDetailFragment
 import com.futo.platformplayer.fragment.mainactivity.main.BrowserFragment
 import com.futo.platformplayer.fragment.mainactivity.main.BuyFragment
 import com.futo.platformplayer.fragment.mainactivity.main.ChannelFragment
@@ -65,7 +71,9 @@ import com.futo.platformplayer.fragment.mainactivity.main.SubscriptionsFeedFragm
 import com.futo.platformplayer.fragment.mainactivity.main.SuggestionsFragment
 import com.futo.platformplayer.fragment.mainactivity.main.TutorialFragment
 import com.futo.platformplayer.fragment.mainactivity.main.VideoDetailFragment
+import com.futo.platformplayer.fragment.mainactivity.main.VideoDetailFragment.State
 import com.futo.platformplayer.fragment.mainactivity.main.WatchLaterFragment
+import com.futo.platformplayer.fragment.mainactivity.main.WebDetailFragment
 import com.futo.platformplayer.fragment.mainactivity.topbar.AddTopBarFragment
 import com.futo.platformplayer.fragment.mainactivity.topbar.GeneralTopBarFragment
 import com.futo.platformplayer.fragment.mainactivity.topbar.ImportTopBarFragment
@@ -74,7 +82,6 @@ import com.futo.platformplayer.fragment.mainactivity.topbar.SearchTopBarFragment
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.models.ImportCache
 import com.futo.platformplayer.models.UrlVideoWithTime
-import com.futo.platformplayer.receivers.MediaButtonReceiver
 import com.futo.platformplayer.setNavigationBarColorAndIcons
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StateBackup
@@ -146,6 +153,8 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
     //Frags Main
     lateinit var _fragMainHome: HomeFragment;
     lateinit var _fragPostDetail: PostDetailFragment;
+    lateinit var _fragArticleDetail: ArticleDetailFragment;
+    lateinit var _fragWebDetail: WebDetailFragment;
     lateinit var _fragMainVideoSearchResults: ContentSearchResultsFragment;
     lateinit var _fragMainCreatorSearchResults: CreatorSearchResultsFragment;
     lateinit var _fragMainPlaylistSearchResults: PlaylistSearchResultsFragment;
@@ -185,6 +194,9 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
 
     private var _isVisible = true;
     private var _wasStopped = false;
+    private var _privateModeEnabled = false
+    private var _pictureInPictureEnabled = false
+    private var _isFullscreen = false
 
     private val _urlQrCodeResultLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
         val scanResult = IntentIntegrator.parseActivityResult(result.resultCode, result.data)
@@ -196,7 +208,7 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
             }
 
             try {
-                runBlocking {
+                lifecycleScope.launch {
                     handleUrlAll(content)
                 }
             } catch (e: Throwable) {
@@ -262,6 +274,10 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         StateApp.instance.mainAppStarting(this);
 
         super.onCreate(savedInstanceState);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+            val uiMode = getSystemService(UiModeManager::class.java)
+            uiMode.setApplicationNightMode(UiModeManager.MODE_NIGHT_YES)
+        }
         setContentView(R.layout.activity_main);
         setNavigationBarColorAndIcons();
         if (Settings.instance.playback.allowVideoToGoUnderCutout)
@@ -269,7 +285,11 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
                 WindowManager.LayoutParams.LAYOUT_IN_DISPLAY_CUTOUT_MODE_SHORT_EDGES
 
         runBlocking {
-            StatePlatform.instance.updateAvailableClients(this@MainActivity);
+            try {
+                StatePlatform.instance.updateAvailableClients(this@MainActivity);
+            } catch (e: Throwable) {
+                Logger.e(TAG, "Unhandled exception in updateAvailableClients", e)
+            }
         }
 
         //Preload common files to memory
@@ -313,6 +333,8 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         _fragMainPlaylist = PlaylistFragment.newInstance();
         _fragMainRemotePlaylist = RemotePlaylistFragment.newInstance();
         _fragPostDetail = PostDetailFragment.newInstance();
+        _fragArticleDetail = ArticleDetailFragment.newInstance();
+        _fragWebDetail = WebDetailFragment.newInstance();
         _fragWatchlist = WatchLaterFragment.newInstance();
         _fragHistory = HistoryFragment.newInstance();
         _fragSourceDetail = SourceDetailFragment.newInstance();
@@ -354,22 +376,18 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
             _fragMainSubscriptionsFeed.setPreviewsEnabled(true);
             _fragContainerVideoDetail.visibility = View.INVISIBLE;
             updateSegmentPaddings();
+            updatePrivateModeVisibility()
         };
 
 
         _buttonIncognito = findViewById(R.id.incognito_button);
-        _buttonIncognito.elevation = -99f;
-        _buttonIncognito.alpha = 0f;
+        updatePrivateModeVisibility()
         StateApp.instance.privateModeChanged.subscribe {
             //Messing with visibility causes some issues with layout ordering?
-            if (it) {
-                _buttonIncognito.elevation = 99f;
-                _buttonIncognito.alpha = 1f;
-            } else {
-                _buttonIncognito.elevation = -99f;
-                _buttonIncognito.alpha = 0f;
-            }
+            _privateModeEnabled = it
+            updatePrivateModeVisibility()
         }
+
         _buttonIncognito.setOnClickListener {
             if (!StateApp.instance.privateMode)
                 return@setOnClickListener;
@@ -386,19 +404,16 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         };
         _fragVideoDetail.onFullscreenChanged.subscribe {
             Logger.i(TAG, "onFullscreenChanged ${it}");
+            _isFullscreen = it
+            updatePrivateModeVisibility()
+        }
 
-            if (it) {
-                _buttonIncognito.elevation = -99f;
-                _buttonIncognito.alpha = 0f;
-            } else {
-                if (StateApp.instance.privateMode) {
-                    _buttonIncognito.elevation = 99f;
-                    _buttonIncognito.alpha = 1f;
-                } else {
-                    _buttonIncognito.elevation = -99f;
-                    _buttonIncognito.alpha = 0f;
-                }
-            }
+        _fragVideoDetail.onMinimize.subscribe {
+            updatePrivateModeVisibility()
+        }
+
+        _fragVideoDetail.onMaximized.subscribe {
+            updatePrivateModeVisibility()
         }
 
         StatePlayer.instance.also {
@@ -446,6 +461,8 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         _fragMainPlaylist.topBar = _fragTopBarNavigation;
         _fragMainRemotePlaylist.topBar = _fragTopBarNavigation;
         _fragPostDetail.topBar = _fragTopBarNavigation;
+        _fragArticleDetail.topBar = _fragTopBarNavigation;
+        _fragWebDetail.topBar = _fragTopBarNavigation;
         _fragWatchlist.topBar = _fragTopBarNavigation;
         _fragHistory.topBar = _fragTopBarNavigation;
         _fragSourceDetail.topBar = _fragTopBarNavigation;
@@ -613,8 +630,18 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
             UIDialogs.toast(this, "No external file permissions\nExporting and auto backups will not work");
     }*/
 
+    private var _qrCodeLoadingDialog: AlertDialog? = null
+
     fun showUrlQrCodeScanner() {
         try {
+            _qrCodeLoadingDialog = UIDialogs.showDialog(this, R.drawable.ic_loader_animated, true,
+                "Launching QR scanner",
+                "Make sure your camera is enabled", null, -2,
+                UIDialogs.Action("Close", {
+                    _qrCodeLoadingDialog?.dismiss()
+                    _qrCodeLoadingDialog = null
+                }));
+
             val integrator = IntentIntegrator(this)
             integrator.setDesiredBarcodeFormats(IntentIntegrator.QR_CODE)
             integrator.setPrompt(getString(R.string.scan_a_qr_code))
@@ -630,6 +657,18 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         }
     }
 
+    @OptIn(UnstableApi::class)
+    private fun updatePrivateModeVisibility() {
+        if (_privateModeEnabled && (_fragVideoDetail.state == State.CLOSED || !_pictureInPictureEnabled && !_isFullscreen)) {
+            _buttonIncognito.elevation = 99f;
+            _buttonIncognito.alpha = 1f;
+            _buttonIncognito.translationY = if (_fragVideoDetail.state == State.MINIMIZED) -60.dp(resources).toFloat() else 0f
+        } else {
+            _buttonIncognito.elevation = -99f;
+            _buttonIncognito.alpha = 0f;
+        }
+    }
+
     override fun onResume() {
         super.onResume();
         Logger.v(TAG, "onResume")
@@ -640,6 +679,9 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         super.onPause();
         Logger.v(TAG, "onPause")
         _isVisible = false;
+
+        _qrCodeLoadingDialog?.dismiss()
+        _qrCodeLoadingDialog = null
     }
 
     override fun onStop() {
@@ -678,7 +720,7 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
 
             "VIDEO" -> {
                 val url = intent.getStringExtra("VIDEO");
-                navigate(_fragVideoDetail, url);
+                navigateWhenReady(_fragVideoDetail, url);
             }
 
             "IMPORT_OPTIONS" -> {
@@ -696,11 +738,11 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
                     "Sources" -> {
                         runBlocking {
                             StatePlatform.instance.updateAvailableClients(this@MainActivity, true) //Ideally this is not needed..
-                            navigate(_fragMainSources);
+                            navigateWhenReady(_fragMainSources);
                         }
                     };
                     "BROWSE_PLUGINS" -> {
-                        navigate(_fragBrowser, BrowserFragment.NavigateOptions("https://plugins.grayjay.app/phone.html", mapOf(
+                        navigateWhenReady(_fragBrowser, BrowserFragment.NavigateOptions("https://plugins.grayjay.app/phone.html", mapOf(
                             Pair("grayjay") { req ->
                                 StateApp.instance.contextOrNull?.let {
                                     if (it is MainActivity) {
@@ -718,8 +760,12 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
 
         try {
             if (targetData != null) {
-                runBlocking {
-                    handleUrlAll(targetData)
+                lifecycleScope.launch(Dispatchers.Main) {
+                    try {
+                        handleUrlAll(targetData)
+                    } catch (e: Throwable) {
+                        Logger.e(TAG, "Unhandled exception in handleUrlAll", e)
+                    }
                 }
             }
         } catch (ex: Throwable) {
@@ -747,10 +793,10 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
                     startActivity(intent);
                 } else if (url.startsWith("grayjay://video/")) {
                     val videoUrl = url.substring("grayjay://video/".length);
-                    navigate(_fragVideoDetail, videoUrl);
+                    navigateWhenReady(_fragVideoDetail, videoUrl);
                 } else if (url.startsWith("grayjay://channel/")) {
                     val channelUrl = url.substring("grayjay://channel/".length);
-                    navigate(_fragMainChannel, channelUrl);
+                    navigateWhenReady(_fragMainChannel, channelUrl);
                 }
             }
 
@@ -816,29 +862,29 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
 
         return withContext(Dispatchers.IO) {
             Logger.i(TAG, "handleUrl(url=$url) on IO");
-            if (StatePlatform.instance.hasEnabledVideoClient(url)) {
+            if (StatePlatform.instance.hasEnabledContentClient(url)) {
                 Logger.i(TAG, "handleUrl(url=$url) found video client");
-                lifecycleScope.launch(Dispatchers.Main) {
+                withContext(Dispatchers.Main) {
                     if (position > 0)
-                        navigate(_fragVideoDetail, UrlVideoWithTime(url, position.toLong(), true));
+                        navigateWhenReady(_fragVideoDetail, UrlVideoWithTime(url, position.toLong(), true));
                     else
-                        navigate(_fragVideoDetail, url);
+                        navigateWhenReady(_fragVideoDetail, url);
 
                     _fragVideoDetail.maximizeVideoDetail(true);
                 }
                 return@withContext true;
             } else if (StatePlatform.instance.hasEnabledChannelClient(url)) {
                 Logger.i(TAG, "handleUrl(url=$url) found channel client");
-                lifecycleScope.launch(Dispatchers.Main) {
-                    navigate(_fragMainChannel, url);
+                withContext(Dispatchers.Main) {
+                    navigateWhenReady(_fragMainChannel, url);
                     delay(100);
                     _fragVideoDetail.minimizeVideoDetail();
                 };
                 return@withContext true;
             } else if (StatePlatform.instance.hasEnabledPlaylistClient(url)) {
                 Logger.i(TAG, "handleUrl(url=$url) found playlist client");
-                lifecycleScope.launch(Dispatchers.Main) {
-                    navigate(_fragMainRemotePlaylist, url);
+                withContext(Dispatchers.Main) {
+                    navigateWhenReady(_fragMainRemotePlaylist, url);
                     delay(100);
                     _fragVideoDetail.minimizeVideoDetail();
                 };
@@ -1050,6 +1096,9 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         Logger.v(TAG, "onPictureInPictureModeChanged isInPictureInPictureMode=$isInPictureInPictureMode isStop=$isStop")
         _fragVideoDetail.onPictureInPictureModeChanged(isInPictureInPictureMode, isStop, newConfig);
         Logger.v(TAG, "onPictureInPictureModeChanged Ready");
+
+        _pictureInPictureEnabled = isInPictureInPictureMode
+        updatePrivateModeVisibility()
     }
 
     override fun onDestroy() {
@@ -1062,6 +1111,18 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
         return fragCurrent is T;
     }
 
+    fun navigateWhenReady(segment: MainFragment, parameter: Any? = null, withHistory: Boolean = true, isBack: Boolean = false) {
+        if (lifecycle.currentState.isAtLeast(Lifecycle.State.RESUMED)) {
+            navigate(segment, parameter, withHistory, isBack)
+        } else {
+            lifecycleScope.launch {
+                lifecycle.withStateAtLeast(Lifecycle.State.RESUMED) {
+                    navigate(segment, parameter, withHistory, isBack)
+                }
+            }
+        }
+    }
+
     /**
      * Navigate takes a MainFragment, and makes them the current main visible view
      * A parameter can be provided which becomes available in the onShow of said fragment
@@ -1186,6 +1247,8 @@ class MainActivity : AppCompatActivity, IWithResultLauncher {
             PlaylistFragment::class -> _fragMainPlaylist as T;
             RemotePlaylistFragment::class -> _fragMainRemotePlaylist as T;
             PostDetailFragment::class -> _fragPostDetail as T;
+            ArticleDetailFragment::class -> _fragArticleDetail as T;
+            WebDetailFragment::class -> _fragWebDetail as T;
             WatchLaterFragment::class -> _fragWatchlist as T;
             HistoryFragment::class -> _fragHistory as T;
             SourceDetailFragment::class -> _fragSourceDetail as T;

app/src/main/java/com/futo/platformplayer/activities/SyncHomeActivity.kt

@@ -9,6 +9,8 @@ import android.widget.LinearLayout
 import androidx.appcompat.app.AppCompatActivity
 import androidx.lifecycle.lifecycleScope
 import com.futo.platformplayer.R
+import com.futo.platformplayer.UIDialogs
+import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.setNavigationBarColorAndIcons
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StateSync
@@ -29,6 +31,16 @@ class SyncHomeActivity : AppCompatActivity() {
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState)
+
+        if (StateApp.instance.contextOrNull == null) {
+            Logger.w(TAG, "No main activity, restarting main.")
+            val intent = Intent(this, MainActivity::class.java)
+            intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+            startActivity(intent)
+            finish()
+            return
+        }
+
         setContentView(R.layout.activity_sync_home)
         setNavigationBarColorAndIcons()
 
@@ -54,7 +66,6 @@ class SyncHomeActivity : AppCompatActivity() {
                 val view = _viewMap[publicKey]
                 if (!session.isAuthorized) {
                     if (view != null) {
-                        _layoutDevices.removeView(view)
                         _viewMap.remove(publicKey)
                     }
                     return@launch
@@ -89,6 +100,20 @@ class SyncHomeActivity : AppCompatActivity() {
                 updateEmptyVisibility()
             }
         }
+
+        StateSync.instance.confirmStarted(this, onStarted = {
+            if (StateSync.instance.syncService?.serverSocketFailedToStart == true) {
+                UIDialogs.toast(this, "Server socket failed to start, is the port in use?", true)
+            }
+            if (StateSync.instance.syncService?.relayConnected == false) {
+                UIDialogs.toast(this, "Not connected to relay, remote connections will work.", false)
+            }
+            if (StateSync.instance.syncService?.serverSocketStarted == false) {
+                UIDialogs.toast(this, "Listener not started, local connections will not work.", false)
+            }
+        }, onNotStarted = {
+            finish()
+        })
     }
 
     override fun onDestroy() {
@@ -100,10 +125,12 @@ class SyncHomeActivity : AppCompatActivity() {
 
     private fun updateDeviceView(syncDeviceView: SyncDeviceView, publicKey: String, session: SyncSession?): SyncDeviceView {
         val connected = session?.connected ?: false
-        syncDeviceView.setLinkType(if (connected) LinkType.Local else LinkType.None)
+        val authorized = session?.isAuthorized ?: false
+
+        syncDeviceView.setLinkType(session?.linkType ?: LinkType.None)
             .setName(session?.displayName ?: StateSync.instance.getCachedName(publicKey) ?: publicKey)
             //TODO: also display public key?
-            .setStatus(if (connected) "Connected" else "Disconnected")
+            .setStatus(if (connected && authorized) "Connected" else "Disconnected or unauthorized")
         return syncDeviceView
     }
 

app/src/main/java/com/futo/platformplayer/activities/SyncPairActivity.kt

@@ -83,6 +83,7 @@ class SyncPairActivity : AppCompatActivity() {
 
         _layoutPairingSuccess.setOnClickListener {
             _layoutPairingSuccess.visibility = View.GONE
+            finish()
         }
         _layoutPairingError.setOnClickListener {
             _layoutPairingError.visibility = View.GONE
@@ -109,11 +110,17 @@ class SyncPairActivity : AppCompatActivity() {
 
             lifecycleScope.launch(Dispatchers.IO) {
                 try {
-                    StateSync.instance.connect(deviceInfo) { session, complete, message ->
+                    StateSync.instance.syncService?.connect(deviceInfo) { complete, message ->
                         lifecycleScope.launch(Dispatchers.Main) {
-                            if (complete) {
-                                _layoutPairingSuccess.visibility = View.VISIBLE
-                                _layoutPairing.visibility = View.GONE
+                            if (complete != null) {
+                                if (complete) {
+                                    _layoutPairingSuccess.visibility = View.VISIBLE
+                                    _layoutPairing.visibility = View.GONE
+                                } else {
+                                    _textError.text = message
+                                    _layoutPairingError.visibility = View.VISIBLE
+                                    _layoutPairing.visibility = View.GONE
+                                }
                             } else {
                                 _textPairingStatus.text = message
                             }
@@ -137,8 +144,6 @@ class SyncPairActivity : AppCompatActivity() {
             _textError.text = e.message
             _layoutPairing.visibility = View.GONE
             Logger.e(TAG, "Failed to pair", e)
-        } finally {
-            _layoutPairing.visibility = View.GONE
         }
     }
 

app/src/main/java/com/futo/platformplayer/activities/SyncShowPairingCodeActivity.kt

@@ -67,11 +67,18 @@ class SyncShowPairingCodeActivity : AppCompatActivity() {
         }
 
         val ips = getIPs()
-        val selfDeviceInfo = SyncDeviceInfo(StateSync.instance.publicKey!!, ips.toTypedArray(), StateSync.PORT)
-        val json = Json.encodeToString(selfDeviceInfo)
-        val base64 = Base64.encodeToString(json.toByteArray(), Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP)
-        val url = "grayjay://sync/${base64}"
-        setCode(url)
+        val publicKey = StateSync.instance.syncService?.publicKey
+        val pairingCode = StateSync.instance.syncService?.pairingCode
+        if (publicKey == null || pairingCode == null) {
+            setCode("Public key or pairing code was not known, is sync enabled?")
+        } else {
+            val selfDeviceInfo = SyncDeviceInfo(publicKey, ips.toTypedArray(), StateSync.PORT, pairingCode)
+            val json = Json.encodeToString(selfDeviceInfo)
+            val base64 = Base64.encodeToString(json.toByteArray(), Base64.URL_SAFE or Base64.NO_PADDING or Base64.NO_WRAP)
+            val url = "grayjay://sync/${base64}"
+            setCode(url)
+        }
+
     }
 
     fun setCode(code: String?) {

app/src/main/java/com/futo/platformplayer/api/http/ManagedHttpClient.kt

@@ -90,6 +90,7 @@ open class ManagedHttpClient {
     }
 
     fun tryHead(url: String): Map<String, String>? {
+        ensureNotMainThread()
         try {
             val result = head(url);
             if(result.isOk)
@@ -104,7 +105,7 @@ open class ManagedHttpClient {
     }
 
     fun socket(url: String, headers: MutableMap<String, String> = HashMap(), listener: SocketListener): Socket {
-
+        ensureNotMainThread()
         val requestBuilder: okhttp3.Request.Builder = okhttp3.Request.Builder()
             .url(url);
         if(user_agent.isNotEmpty() && !headers.any { it.key.lowercase() == "user-agent" })
@@ -300,6 +301,7 @@ open class ManagedHttpClient {
         }
 
         fun send(msg: String) {
+            ensureNotMainThread()
             socket.send(msg);
         }
 

app/src/main/java/com/futo/platformplayer/api/media/IPlatformClient.kt

@@ -1,5 +1,6 @@
 package com.futo.platformplayer.api.media
 
+import com.futo.platformplayer.api.media.models.IPlatformChannelContent
 import com.futo.platformplayer.api.media.models.PlatformAuthorLink
 import com.futo.platformplayer.api.media.models.ResultCapabilities
 import com.futo.platformplayer.api.media.models.channels.IPlatformChannel
@@ -66,6 +67,11 @@ interface IPlatformClient {
      */
     fun searchChannels(query: String): IPager<PlatformAuthorLink>;
 
+    /**
+     * Searches for channels and returns a content pager
+     */
+    fun searchChannelsAsContent(query: String): IPager<IPlatformContent>;
+
 
     //Video Pages
     /**

app/src/main/java/com/futo/platformplayer/api/media/PlatformClientPool.kt

@@ -14,14 +14,16 @@ class PlatformClientPool {
     private var _poolCounter = 0;
     private val _poolName: String?;
     private val _privatePool: Boolean;
+    private val _isolatedInitialization: Boolean
 
     var isDead: Boolean = false
         private set;
     val onDead = Event2<JSClient, PlatformClientPool>();
 
-    constructor(parentClient: IPlatformClient, name: String? = null, privatePool: Boolean = false) {
+    constructor(parentClient: IPlatformClient, name: String? = null, privatePool: Boolean = false, isolatedInitialization: Boolean = false) {
         _poolName = name;
         _privatePool = privatePool;
+        _isolatedInitialization = isolatedInitialization
         if(parentClient !is JSClient)
             throw IllegalArgumentException("Pooling only supported for JSClients right now");
         Logger.i(TAG, "Pool for ${parentClient.name} was started");
@@ -53,7 +55,7 @@ class PlatformClientPool {
             reserved = _pool.keys.find { !it.isBusy };
             if(reserved == null && _pool.size < capacity) {
                 Logger.i(TAG, "Started additional [${_parent.name}] client in pool [${_poolName}] (${_pool.size + 1}/${capacity})");
-                reserved = _parent.getCopy(_privatePool);
+                reserved = _parent.getCopy(_privatePool, _isolatedInitialization);
 
                 reserved?.onCaptchaException?.subscribe { client, ex ->
                     StateApp.instance.handleCaptchaException(client, ex);

app/src/main/java/com/futo/platformplayer/api/media/PlatformMultiClientPool.kt

@@ -7,13 +7,15 @@ class PlatformMultiClientPool {
 
     private var _isFake = false;
     private var _privatePool = false;
+    private val _isolatedInitialization: Boolean
 
-    constructor(name: String, maxCap: Int = -1, isPrivatePool: Boolean = false) {
+    constructor(name: String, maxCap: Int = -1, isPrivatePool: Boolean = false, isolatedInitialization: Boolean = false) {
         _name = name;
         _maxCap = if(maxCap > 0)
             maxCap
         else 99;
         _privatePool = isPrivatePool;
+        _isolatedInitialization = isolatedInitialization
     }
 
     fun getClientPooled(parentClient: IPlatformClient, capacity: Int = _maxCap): IPlatformClient {
@@ -21,7 +23,7 @@ class PlatformMultiClientPool {
             return parentClient;
         val pool = synchronized(_clientPools) {
             if(!_clientPools.containsKey(parentClient))
-                _clientPools[parentClient] = PlatformClientPool(parentClient, _name, _privatePool).apply {
+                _clientPools[parentClient] = PlatformClientPool(parentClient, _name, _privatePool, _isolatedInitialization).apply {
                     this.onDead.subscribe { _, pool ->
                         synchronized(_clientPools) {
                             if(_clientPools[parentClient] == pool)

app/src/main/java/com/futo/platformplayer/api/media/models/PlatformAuthorLink.kt

@@ -2,7 +2,10 @@ package com.futo.platformplayer.api.media.models
 
 import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.PlatformID
+import com.futo.platformplayer.api.media.models.contents.ContentType
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
+import com.futo.platformplayer.api.media.platforms.js.models.JSContent
 import com.futo.platformplayer.getOrDefault
 import com.futo.platformplayer.getOrThrow
 
@@ -42,4 +45,21 @@ open class PlatformAuthorLink {
             );
         }
     }
+}
+
+interface IPlatformChannelContent : IPlatformContent {
+    val thumbnail: String?
+    val subscribers: Long?
+}
+
+open class JSChannelContent : JSContent, IPlatformChannelContent {
+    override val contentType: ContentType get() = ContentType.CHANNEL
+    override val thumbnail: String?
+    override val subscribers: Long?
+
+    constructor(config: SourcePluginConfig, obj: V8ValueObject) : super(config, obj) {
+        val contextName = "Channel";
+        thumbnail = obj.getOrDefault<String>(config, "thumbnail", contextName, null)
+        subscribers = if(obj.has("subscribers")) obj.getOrThrow(config,"subscribers", contextName) else null
+    }
 }

app/src/main/java/com/futo/platformplayer/api/media/models/article/IPlatformArticle.kt

@@ -0,0 +1,9 @@
+package com.futo.platformplayer.api.media.models.article
+
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+
+interface IPlatformArticle: IPlatformContent {
+    val summary: String?;
+    val thumbnails: Thumbnails?;
+}

app/src/main/java/com/futo/platformplayer/api/media/models/article/IPlatformArticleDetails.kt

@@ -0,0 +1,12 @@
+package com.futo.platformplayer.api.media.models.article
+
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+import com.futo.platformplayer.api.media.models.contents.IPlatformContentDetails
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.platforms.js.models.IJSArticleSegment
+
+interface IPlatformArticleDetails: IPlatformContent, IPlatformArticle, IPlatformContentDetails {
+    val segments: List<IJSArticleSegment>;
+    val rating : IRating;
+}

app/src/main/java/com/futo/platformplayer/api/media/models/contents/ContentType.kt

@@ -8,10 +8,12 @@ enum class ContentType(val value: Int) {
     POST(2),
     ARTICLE(3),
     PLAYLIST(4),
+    WEB(7),
 
     URL(9),
 
     NESTED_VIDEO(11),
+    CHANNEL(60),
 
     LOCKED(70),
 

app/src/main/java/com/futo/platformplayer/api/media/models/contents/IPlatformContent.kt

@@ -2,6 +2,8 @@ package com.futo.platformplayer.api.media.models.contents
 
 import com.futo.platformplayer.api.media.PlatformID
 import com.futo.platformplayer.api.media.models.PlatformAuthorLink
+import kotlinx.serialization.Serializable
+import kotlinx.serialization.json.JsonNames
 import java.time.OffsetDateTime
 
 interface IPlatformContent {

app/src/main/java/com/futo/platformplayer/api/media/models/post/TextType.kt

@@ -5,7 +5,8 @@ import com.futo.platformplayer.api.media.exceptions.UnknownPlatformException
 enum class TextType(val value: Int) {
     RAW(0),
     HTML(1),
-    MARKUP(2);
+    MARKUP(2),
+    CODE(3);
 
     companion object {
         fun fromInt(value: Int): TextType

app/src/main/java/com/futo/platformplayer/api/media/models/streams/DownloadedVideoMuxedSourceDescriptor.kt

@@ -3,7 +3,7 @@ package com.futo.platformplayer.api.media.models.streams
 import com.futo.platformplayer.api.media.models.streams.sources.IVideoSource
 import com.futo.platformplayer.downloads.VideoLocal
 
-class LocalVideoMuxedSourceDescriptor(
+class DownloadedVideoMuxedSourceDescriptor(
         private val video: VideoLocal
     ) : VideoMuxedSourceDescriptor() {
     override val videoSources: Array<IVideoSource> get() = video.videoSource.toTypedArray();

app/src/main/java/com/futo/platformplayer/api/media/models/video/SerializedPlatformVideo.kt

@@ -10,15 +10,18 @@ import com.futo.polycentric.core.combineHashCodes
 import kotlinx.serialization.decodeFromString
 import kotlinx.serialization.encodeToString
 import kotlinx.serialization.json.Json
+import kotlinx.serialization.json.JsonNames
 import java.time.OffsetDateTime
 
 @kotlinx.serialization.Serializable
 open class SerializedPlatformVideo(
+    override val contentType: ContentType = ContentType.MEDIA,
     override val id: PlatformID,
     override val name: String,
     override val thumbnails: Thumbnails,
     override val author: PlatformAuthorLink,
     @kotlinx.serialization.Serializable(with = OffsetDateTimeNullableSerializer::class)
+    @JsonNames("datetime", "dateTime")
     override val datetime: OffsetDateTime? = null,
     override val url: String,
     override val shareUrl: String = "",
@@ -27,7 +30,6 @@ open class SerializedPlatformVideo(
     override val viewCount: Long,
     override val isShort: Boolean = false
 ) : IPlatformVideo, SerializedPlatformContent {
-    override val contentType: ContentType = ContentType.MEDIA;
 
     override val isLive: Boolean = false;
 
@@ -44,6 +46,7 @@ open class SerializedPlatformVideo(
     companion object {
         fun fromVideo(video: IPlatformVideo) : SerializedPlatformVideo {
             return SerializedPlatformVideo(
+                ContentType.MEDIA,
                 video.id,
                 video.name,
                 video.thumbnails,

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/DevJSClient.kt

@@ -54,8 +54,11 @@ class DevJSClient : JSClient {
         return DevJSClient(context, config, _devScript, _auth, _captcha, devID, descriptor.settings);
     }
 
-    override fun getCopy(privateCopy: Boolean): JSClient {
-        return DevJSClient(_context, descriptor, _script, if(!privateCopy) _auth else null, _captcha, saveState(), devID);
+    override fun getCopy(privateCopy: Boolean, noSaveState: Boolean): JSClient {
+        val client = DevJSClient(_context, descriptor, _script, if(!privateCopy) _auth else null, _captcha, if (noSaveState) null else saveState(), devID);
+        if (noSaveState)
+            client.initialize()
+        return client
     }
 
     override fun initialize() {

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/JSClient.kt

@@ -10,6 +10,7 @@ import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.http.ManagedHttpClient
 import com.futo.platformplayer.api.media.IPlatformClient
 import com.futo.platformplayer.api.media.PlatformClientCapabilities
+import com.futo.platformplayer.api.media.models.IPlatformChannelContent
 import com.futo.platformplayer.api.media.models.PlatformAuthorLink
 import com.futo.platformplayer.api.media.models.ResultCapabilities
 import com.futo.platformplayer.api.media.models.channels.IPlatformChannel
@@ -31,6 +32,7 @@ import com.futo.platformplayer.api.media.platforms.js.internal.JSParameterDocs
 import com.futo.platformplayer.api.media.platforms.js.models.IJSContent
 import com.futo.platformplayer.api.media.platforms.js.models.IJSContentDetails
 import com.futo.platformplayer.api.media.platforms.js.models.JSChannel
+import com.futo.platformplayer.api.media.platforms.js.models.JSChannelContentPager
 import com.futo.platformplayer.api.media.platforms.js.models.JSChannelPager
 import com.futo.platformplayer.api.media.platforms.js.models.JSChapter
 import com.futo.platformplayer.api.media.platforms.js.models.JSComment
@@ -193,8 +195,11 @@ open class JSClient : IPlatformClient {
         _plugin.changeAllowDevSubmit(descriptor.appSettings.allowDeveloperSubmit);
     }
 
-    open fun getCopy(withoutCredentials: Boolean = false): JSClient {
-        return JSClient(_context, descriptor, saveState(), _script, withoutCredentials);
+    open fun getCopy(withoutCredentials: Boolean = false, noSaveState: Boolean = false): JSClient {
+        val client = JSClient(_context, descriptor, if (noSaveState) null else saveState(), _script, withoutCredentials);
+        if (noSaveState)
+            client.initialize()
+        return client
     }
 
     fun getUnderlyingPlugin(): V8Plugin {
@@ -209,6 +214,8 @@ open class JSClient : IPlatformClient {
     }
 
     override fun initialize() {
+        if (_initialized) return
+
         Logger.i(TAG, "Plugin [${config.name}] initializing");
         plugin.start();
         plugin.execute("plugin.config = ${Json.encodeToString(config)}");
@@ -361,6 +368,10 @@ open class JSClient : IPlatformClient {
         return@isBusyWith JSChannelPager(config, this,
             plugin.executeTyped("source.searchChannels(${Json.encodeToString(query)})"));
     }
+    override fun searchChannelsAsContent(query: String): IPager<IPlatformContent> = isBusyWith("searchChannels") {
+        ensureEnabled();
+        return@isBusyWith JSChannelContentPager(config, this, plugin.executeTyped("source.searchChannels(${Json.encodeToString(query)})"), );
+    }
 
     @JSDocs(6, "source.isChannelUrl(url)", "Validates if an channel url is for this platform")
     @JSDocsParameter("url", "A channel url (May not be your platform)")

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/internal/JSHttpClient.kt

@@ -127,7 +127,7 @@ class JSHttpClient : ManagedHttpClient {
         }
 
         if(doApplyCookies) {
-            if (_currentCookieMap.isNotEmpty()) {
+            if (_currentCookieMap.isNotEmpty() || _otherCookieMap.isNotEmpty()) {
                 val cookiesToApply = hashMapOf<String, String>();
                 synchronized(_currentCookieMap) {
                     for(cookie in _currentCookieMap
@@ -135,6 +135,12 @@ class JSHttpClient : ManagedHttpClient {
                         .flatMap { it.value.toList() })
                         cookiesToApply[cookie.first] = cookie.second;
                 };
+                synchronized(_otherCookieMap) {
+                    for(cookie in _otherCookieMap
+                        .filter { domain.matchesDomain(it.key) }
+                        .flatMap { it.value.toList() })
+                        cookiesToApply[cookie.first] = cookie.second;
+                }
 
                 if(cookiesToApply.size > 0) {
                     val cookieString = cookiesToApply.map { it.key + "=" + it.value }.joinToString("; ");

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/IJSContent.kt

@@ -1,6 +1,7 @@
 package com.futo.platformplayer.api.media.platforms.js.models
 
 import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.models.JSChannelContent
 import com.futo.platformplayer.api.media.models.contents.ContentType
 import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.platforms.js.JSClient
@@ -26,6 +27,9 @@ interface IJSContent: IPlatformContent  {
                 ContentType.NESTED_VIDEO -> JSNestedMediaContent(config, obj);
                 ContentType.PLAYLIST -> JSPlaylist(config, obj);
                 ContentType.LOCKED -> JSLockedContent(config, obj);
+                ContentType.CHANNEL -> JSChannelContent(config, obj);
+                ContentType.ARTICLE -> JSArticle(config, obj);
+                ContentType.WEB -> JSWeb(config, obj);
                 else -> throw NotImplementedError("Unknown content type ${type}");
             }
         }

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/IJSContentDetails.kt

@@ -17,6 +17,7 @@ interface IJSContentDetails: IPlatformContent  {
                 ContentType.MEDIA -> JSVideoDetails(plugin, obj);
                 ContentType.POST -> JSPostDetails(plugin.config, obj);
                 ContentType.ARTICLE -> JSArticleDetails(plugin, obj);
+                ContentType.WEB -> JSWebDetails(plugin, obj);
                 else -> throw NotImplementedError("Unknown content type ${type}");
             }
         }

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSArticle.kt

@@ -0,0 +1,39 @@
+package com.futo.platformplayer.api.media.platforms.js.models
+
+import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.IPlatformClient
+import com.futo.platformplayer.api.media.IPluginSourced
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.article.IPlatformArticle
+import com.futo.platformplayer.api.media.models.comments.IPlatformComment
+import com.futo.platformplayer.api.media.models.contents.ContentType
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+import com.futo.platformplayer.api.media.models.contents.IPlatformContentDetails
+import com.futo.platformplayer.api.media.models.playback.IPlaybackTracker
+import com.futo.platformplayer.api.media.models.post.IPlatformPost
+import com.futo.platformplayer.api.media.models.post.TextType
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.models.ratings.RatingLikes
+import com.futo.platformplayer.api.media.platforms.js.DevJSClient
+import com.futo.platformplayer.api.media.platforms.js.JSClient
+import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
+import com.futo.platformplayer.api.media.structures.IPager
+import com.futo.platformplayer.getOrDefault
+import com.futo.platformplayer.getOrThrow
+import com.futo.platformplayer.getOrThrowNullableList
+import com.futo.platformplayer.states.StateDeveloper
+
+open class JSArticle : JSContent, IPlatformArticle, IPluginSourced {
+    final override val contentType: ContentType get() = ContentType.ARTICLE;
+
+    override val summary: String;
+    override val thumbnails: Thumbnails?;
+
+    constructor(config: SourcePluginConfig, obj: V8ValueObject): super(config, obj) {
+        val contextName = "PlatformArticle";
+
+        summary = _content.getOrDefault(config, "summary", contextName, "") ?: "";
+        thumbnails = Thumbnails.fromV8(config, _content.getOrThrow(config, "thumbnails", contextName));
+
+    }
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSArticleDetails.kt

@@ -4,6 +4,8 @@ import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.IPlatformClient
 import com.futo.platformplayer.api.media.IPluginSourced
 import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.article.IPlatformArticle
+import com.futo.platformplayer.api.media.models.article.IPlatformArticleDetails
 import com.futo.platformplayer.api.media.models.comments.IPlatformComment
 import com.futo.platformplayer.api.media.models.contents.ContentType
 import com.futo.platformplayer.api.media.models.contents.IPlatformContent
@@ -21,20 +23,20 @@ import com.futo.platformplayer.getOrThrow
 import com.futo.platformplayer.getOrThrowNullableList
 import com.futo.platformplayer.states.StateDeveloper
 
-open class JSArticleDetails : JSContent, IPluginSourced, IPlatformContentDetails {
+open class JSArticleDetails : JSContent, IPlatformArticleDetails, IPluginSourced, IPlatformContentDetails {
     final override val contentType: ContentType get() = ContentType.ARTICLE;
 
     private val _hasGetComments: Boolean;
     private val _hasGetContentRecommendations: Boolean;
 
-    val rating: IRating;
+    override val rating: IRating;
 
-    val summary: String;
-    val thumbnails: Thumbnails?;
-    val segments: List<IJSArticleSegment>;
+    override val summary: String;
+    override val thumbnails: Thumbnails?;
+    override val segments: List<IJSArticleSegment>;
 
     constructor(client: JSClient, obj: V8ValueObject): super(client.config, obj) {
-        val contextName = "PlatformPost";
+        val contextName = "PlatformArticle";
 
         rating = obj.getOrDefault<V8ValueObject>(client.config, "rating", contextName, null)?.let { IRating.fromV8(client.config, it, contextName) } ?: RatingLikes(0);
         summary = _content.getOrThrow(client.config, "summary", contextName);

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSChannelPager.kt

@@ -5,7 +5,6 @@ import com.futo.platformplayer.api.media.models.PlatformAuthorLink
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
 import com.futo.platformplayer.api.media.structures.IPager
-import com.futo.platformplayer.engine.V8Plugin
 
 class JSChannelPager : JSPager<PlatformAuthorLink>, IPager<PlatformAuthorLink> {
 

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSContent.kt

@@ -49,8 +49,8 @@ open class JSContent : IPlatformContent, IPluginSourced {
         else
             author = PlatformAuthorLink.UNKNOWN;
 
-        val datetimeInt = _content.getOrThrow<Int>(config, "datetime", contextName).toLong();
-        if(datetimeInt == 0.toLong())
+        val datetimeInt = _content.getOrDefault<Int>(config, "datetime", contextName, null)?.toLong();
+        if(datetimeInt == null || datetimeInt == 0.toLong())
             datetime = null;
         else
             datetime = OffsetDateTime.of(LocalDateTime.ofEpochSecond(datetimeInt, 0, ZoneOffset.UTC), ZoneOffset.UTC);

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSContentPager.kt

@@ -2,6 +2,7 @@ package com.futo.platformplayer.api.media.platforms.js.models
 
 import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.IPluginSourced
+import com.futo.platformplayer.api.media.models.JSChannelContent
 import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
@@ -15,4 +16,14 @@ class JSContentPager : JSPager<IPlatformContent>, IPluginSourced {
     override fun convertResult(obj: V8ValueObject): IPlatformContent {
         return IJSContent.fromV8(plugin, obj);
     }
+}
+
+class JSChannelContentPager : JSPager<IPlatformContent>, IPluginSourced {
+    override val sourceConfig: SourcePluginConfig get() = config;
+
+    constructor(config: SourcePluginConfig, plugin: JSClient, pager: V8ValueObject) : super(config, plugin, pager) {}
+
+    override fun convertResult(obj: V8ValueObject): IPlatformContent {
+        return JSChannelContent(config, obj);
+    }
 }

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSWeb.kt

@@ -0,0 +1,31 @@
+package com.futo.platformplayer.api.media.platforms.js.models
+
+import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.IPlatformClient
+import com.futo.platformplayer.api.media.IPluginSourced
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.comments.IPlatformComment
+import com.futo.platformplayer.api.media.models.contents.ContentType
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+import com.futo.platformplayer.api.media.models.contents.IPlatformContentDetails
+import com.futo.platformplayer.api.media.models.playback.IPlaybackTracker
+import com.futo.platformplayer.api.media.models.post.IPlatformPost
+import com.futo.platformplayer.api.media.models.post.TextType
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.models.ratings.RatingLikes
+import com.futo.platformplayer.api.media.platforms.js.DevJSClient
+import com.futo.platformplayer.api.media.platforms.js.JSClient
+import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
+import com.futo.platformplayer.api.media.structures.IPager
+import com.futo.platformplayer.getOrDefault
+import com.futo.platformplayer.getOrThrow
+import com.futo.platformplayer.getOrThrowNullableList
+import com.futo.platformplayer.states.StateDeveloper
+
+open class JSWeb : JSContent, IPluginSourced {
+    final override val contentType: ContentType get() = ContentType.WEB;
+
+    constructor(config: SourcePluginConfig, obj: V8ValueObject): super(config, obj) {
+        val contextName = "PlatformWeb";
+    }
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/js/models/JSWebDetails.kt

@@ -0,0 +1,41 @@
+package com.futo.platformplayer.api.media.platforms.js.models
+
+import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.IPlatformClient
+import com.futo.platformplayer.api.media.IPluginSourced
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.comments.IPlatformComment
+import com.futo.platformplayer.api.media.models.contents.ContentType
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+import com.futo.platformplayer.api.media.models.contents.IPlatformContentDetails
+import com.futo.platformplayer.api.media.models.playback.IPlaybackTracker
+import com.futo.platformplayer.api.media.models.post.TextType
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.models.ratings.RatingLikes
+import com.futo.platformplayer.api.media.platforms.js.DevJSClient
+import com.futo.platformplayer.api.media.platforms.js.JSClient
+import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
+import com.futo.platformplayer.api.media.structures.IPager
+import com.futo.platformplayer.getOrDefault
+import com.futo.platformplayer.getOrThrow
+import com.futo.platformplayer.getOrThrowNullableList
+import com.futo.platformplayer.states.StateDeveloper
+
+open class JSWebDetails : JSContent, IPluginSourced, IPlatformContentDetails {
+    final override val contentType: ContentType get() = ContentType.WEB;
+
+    val html: String?;
+    //TODO: Options?
+
+
+    constructor(client: JSClient, obj: V8ValueObject): super(client.config, obj) {
+        val contextName = "PlatformWeb";
+
+        html = obj.getOrDefault(client.config, "html", contextName, null);
+    }
+
+    override fun getComments(client: IPlatformClient): IPager<IPlatformComment>? = null;
+    override fun getPlaybackTracker(): IPlaybackTracker? = null;
+    override fun getContentRecommendations(client: IPlatformClient): IPager<IPlatformContent>? = null;
+
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/local/LocalClient.kt

@@ -0,0 +1,5 @@
+package com.futo.platformplayer.api.media.platforms.local
+
+class LocalClient {
+    //TODO
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/local/models/LocalVideoDetails.kt

@@ -0,0 +1,85 @@
+package com.futo.platformplayer.api.media.platforms.local.models
+
+import com.futo.platformplayer.api.media.IPlatformClient
+import com.futo.platformplayer.api.media.PlatformID
+import com.futo.platformplayer.api.media.models.PlatformAuthorLink
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.comments.IPlatformComment
+import com.futo.platformplayer.api.media.models.contents.ContentType
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+import com.futo.platformplayer.api.media.models.playback.IPlaybackTracker
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.models.ratings.RatingLikes
+import com.futo.platformplayer.api.media.models.streams.IVideoSourceDescriptor
+import com.futo.platformplayer.api.media.models.streams.DownloadedVideoMuxedSourceDescriptor
+import com.futo.platformplayer.api.media.models.streams.sources.IDashManifestSource
+import com.futo.platformplayer.api.media.models.streams.sources.IHLSManifestSource
+import com.futo.platformplayer.api.media.models.streams.sources.IVideoSource
+import com.futo.platformplayer.api.media.models.subtitles.ISubtitleSource
+import com.futo.platformplayer.api.media.models.video.IPlatformVideoDetails
+import com.futo.platformplayer.api.media.platforms.local.models.sources.LocalVideoFileSource
+import com.futo.platformplayer.api.media.structures.IPager
+import com.futo.platformplayer.downloads.VideoLocal
+import java.io.File
+import java.time.Instant
+import java.time.OffsetDateTime
+import java.time.ZoneId
+
+class LocalVideoDetails: IPlatformVideoDetails {
+
+    override val contentType: ContentType get() = ContentType.UNKNOWN;
+
+    override val id: PlatformID;
+    override val name: String;
+    override val author: PlatformAuthorLink;
+
+    override val datetime: OffsetDateTime?;
+
+    override val url: String;
+    override val shareUrl: String;
+    override val rating: IRating = RatingLikes(0);
+    override val description: String = "";
+
+    override val video: IVideoSourceDescriptor;
+    override val preview: IVideoSourceDescriptor? = null;
+    override val live: IVideoSource? = null;
+    override val dash: IDashManifestSource? = null;
+    override val hls: IHLSManifestSource? = null;
+    override val subtitles: List<ISubtitleSource> = listOf()
+
+    override val thumbnails: Thumbnails;
+    override val duration: Long;
+    override val viewCount: Long = 0;
+    override val isLive: Boolean = false;
+    override val isShort: Boolean = false;
+
+    constructor(file: File) {
+        id = PlatformID("Local", file.path, "LOCAL")
+        name = file.name;
+        author = PlatformAuthorLink.UNKNOWN;
+
+        url = file.canonicalPath;
+        shareUrl = "";
+
+        duration = 0;
+        thumbnails = Thumbnails(arrayOf());
+
+        datetime = OffsetDateTime.ofInstant(
+            Instant.ofEpochMilli(file.lastModified()),
+            ZoneId.systemDefault()
+        );
+        video = LocalVideoMuxedSourceDescriptor(LocalVideoFileSource(file));
+    }
+
+    override fun getComments(client: IPlatformClient): IPager<IPlatformComment>? {
+        return null;
+    }
+
+    override fun getPlaybackTracker(): IPlaybackTracker? {
+        return null;
+    }
+
+    override fun getContentRecommendations(client: IPlatformClient): IPager<IPlatformContent>? {
+        return null;
+    }
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/local/models/LocalVideoMuxedSourceDescriptor.kt

@@ -0,0 +1,13 @@
+package com.futo.platformplayer.api.media.platforms.local.models
+
+import com.futo.platformplayer.api.media.models.streams.VideoMuxedSourceDescriptor
+import com.futo.platformplayer.api.media.models.streams.sources.IVideoSource
+import com.futo.platformplayer.api.media.models.streams.sources.LocalVideoSource
+import com.futo.platformplayer.api.media.platforms.local.models.sources.LocalVideoFileSource
+import com.futo.platformplayer.downloads.VideoLocal
+
+class LocalVideoMuxedSourceDescriptor(
+    private val video: LocalVideoFileSource
+) : VideoMuxedSourceDescriptor() {
+    override val videoSources: Array<IVideoSource> get() = arrayOf(video);
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/local/models/MediaStoreVideo.kt

@@ -0,0 +1,25 @@
+package com.futo.platformplayer.api.media.platforms.local.models
+
+import android.content.Context
+import android.database.Cursor
+import android.provider.MediaStore
+import android.provider.MediaStore.Video
+
+class MediaStoreVideo {
+
+
+    companion object {
+        val URI = MediaStore.Files.getContentUri("external");
+        val PROJECTION = arrayOf(Video.Media._ID, Video.Media.TITLE, Video.Media.DURATION, Video.Media.HEIGHT, Video.Media.WIDTH, Video.Media.MIME_TYPE);
+        val ORDER = MediaStore.Video.Media.TITLE;
+
+        fun readMediaStoreVideo(cursor: Cursor) {
+
+        }
+
+        fun query(context: Context, selection: String, args: Array<String>, order: String? = null): Cursor? {
+            val cursor = context.contentResolver.query(URI, PROJECTION, selection, args, order ?: ORDER, null);
+            return cursor;
+        }
+    }
+}

app/src/main/java/com/futo/platformplayer/api/media/platforms/local/models/sources/LocalVideoFileSource.kt

@@ -0,0 +1,31 @@
+package com.futo.platformplayer.api.media.platforms.local.models.sources
+
+import android.content.Context
+import android.provider.MediaStore
+import android.provider.MediaStore.Video
+import com.futo.platformplayer.api.media.models.streams.sources.IVideoSource
+import com.futo.platformplayer.api.media.models.streams.sources.VideoUrlSource
+import com.futo.platformplayer.helpers.VideoHelper
+import java.io.File
+
+class LocalVideoFileSource: IVideoSource {
+
+
+    override val name: String;
+    override val width: Int;
+    override val height: Int;
+    override val container: String;
+    override val codec: String = ""
+    override val bitrate: Int = 0
+    override val duration: Long;
+    override val priority: Boolean = false;
+
+    constructor(file: File) {
+        name = file.name;
+        width = 0;
+        height = 0;
+        container = VideoHelper.videoExtensionToMimetype(file.extension) ?: "";
+        duration = 0;
+    }
+
+}

app/src/main/java/com/futo/platformplayer/api/media/structures/IRefreshPager.kt

@@ -6,7 +6,7 @@ import com.futo.platformplayer.constructs.Event1
  * A RefreshPager represents a pager that can be modified overtime (eg. By getting more results later, by recreating the pager)
  * When the onPagerChanged event is emitted, a new pager instance is passed, or requested via getCurrentPager
  */
-interface IRefreshPager<T> {
+interface IRefreshPager<T>: IPager<T> {
     val onPagerChanged: Event1<IPager<T>>;
     val onPagerError: Event1<Throwable>;
 

app/src/main/java/com/futo/platformplayer/api/media/structures/ReusablePager.kt

@@ -1,5 +1,7 @@
 package com.futo.platformplayer.api.media.structures
 
+import com.futo.platformplayer.api.media.structures.ReusablePager.Window
+import com.futo.platformplayer.constructs.Event1
 import com.futo.platformplayer.logging.Logger
 
 /**
@@ -9,8 +11,8 @@ import com.futo.platformplayer.logging.Logger
  * A "Window" is effectively a pager that just reads previous results from the shared results, but when the end is reached, it will call nextPage on the parent if possible for new results.
  * This allows multiple Windows to exist of the same pager, without messing with position, or duplicate requests
  */
-class ReusablePager<T>: INestedPager<T>, IPager<T> {
-    private val _pager: IPager<T>;
+open class ReusablePager<T>: INestedPager<T>, IReusablePager<T> {
+    protected var _pager: IPager<T>;
     val previousResults = arrayListOf<T>();
 
     constructor(subPager: IPager<T>) {
@@ -44,7 +46,7 @@ class ReusablePager<T>: INestedPager<T>, IPager<T> {
         return previousResults;
     }
 
-    fun getWindow(): Window<T> {
+    override fun getWindow(): Window<T> {
         return Window(this);
     }
 
@@ -95,4 +97,118 @@ class ReusablePager<T>: INestedPager<T>, IPager<T> {
             return ReusablePager(this);
         }
     }
+}
+
+
+public class ReusableRefreshPager<T>: INestedPager<T>, IReusablePager<T> {
+    protected var _pager: IRefreshPager<T>;
+    val previousResults = arrayListOf<T>();
+
+    private var _currentPage: IPager<T>;
+
+
+    val onPagerChanged = Event1<IPager<T>>()
+    val onPagerError = Event1<Throwable>()
+
+    constructor(subPager: IRefreshPager<T>) {
+        this._pager = subPager;
+        _currentPage = this;
+        synchronized(previousResults) {
+            previousResults.addAll(subPager.getResults());
+        }
+        _pager.onPagerError.subscribe(onPagerError::emit);
+        _pager.onPagerChanged.subscribe {
+            _currentPage = it;
+            synchronized(previousResults) {
+                previousResults.clear();
+                previousResults.addAll(it.getResults());
+            }
+
+            onPagerChanged.emit(_currentPage);
+        };
+    }
+
+    override fun findPager(query: (IPager<T>) -> Boolean): IPager<T>? {
+        if(query(_pager))
+            return _pager;
+        else if(_pager is INestedPager<*>)
+            return (_pager as INestedPager<T>).findPager(query);
+        return null;
+    }
+
+    override fun hasMorePages(): Boolean {
+        return _pager.hasMorePages();
+    }
+
+    override fun nextPage() {
+        _pager.nextPage();
+    }
+
+    override fun getResults(): List<T> {
+        val results = _pager.getResults();
+        synchronized(previousResults) {
+            previousResults.addAll(results);
+        }
+        return previousResults;
+    }
+
+    override fun getWindow(): RefreshWindow<T> {
+        return RefreshWindow(this);
+    }
+
+
+    class RefreshWindow<T>: IPager<T>, INestedPager<T>, IRefreshPager<T> {
+        private val _parent: ReusableRefreshPager<T>;
+        private var _position: Int = 0;
+        private var _read: Int = 0;
+
+        private var _currentResults: List<T>;
+
+        override val onPagerChanged = Event1<IPager<T>>();
+        override val onPagerError = Event1<Throwable>();
+
+
+        override fun getCurrentPager(): IPager<T> {
+            return _parent.getWindow();
+        }
+
+        constructor(parent: ReusableRefreshPager<T>) {
+            _parent = parent;
+
+            synchronized(_parent.previousResults) {
+                _currentResults = _parent.previousResults.toList();
+                _read += _currentResults.size;
+            }
+            parent.onPagerChanged.subscribe(onPagerChanged::emit);
+            parent.onPagerError.subscribe(onPagerError::emit);
+        }
+
+
+        override fun hasMorePages(): Boolean {
+            return _parent.previousResults.size > _read || _parent.hasMorePages();
+        }
+
+        override fun nextPage() {
+            synchronized(_parent.previousResults) {
+                if (_parent.previousResults.size <= _read) {
+                    _parent.nextPage();
+                    _parent.getResults();
+                }
+                _currentResults = _parent.previousResults.drop(_read).toList();
+                _read += _currentResults.size;
+            }
+        }
+
+        override fun getResults(): List<T> {
+            return _currentResults;
+        }
+
+        override fun findPager(query: (IPager<T>) -> Boolean): IPager<T>? {
+            return _parent.findPager(query);
+        }
+    }
+}
+
+interface IReusablePager<T>: IPager<T> {
+    fun getWindow(): IPager<T>;
 }

app/src/main/java/com/futo/platformplayer/casting/AirPlayCastingDevice.kt

@@ -149,6 +149,7 @@ class AirPlayCastingDevice : CastingDevice {
                         break;
                     } catch (e: Throwable) {
                         Logger.w(TAG, "Failed to get setup initial connection to AirPlay device.", e)
+                        delay(1000);
                     }
                 }
 

app/src/main/java/com/futo/platformplayer/casting/ChomecastCastingDevice.kt

@@ -10,7 +10,9 @@ import com.futo.platformplayer.toHexString
 import com.futo.platformplayer.toInetAddress
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import org.json.JSONObject
@@ -56,6 +58,10 @@ class ChromecastCastingDevice : CastingDevice {
     private var _mediaSessionId: Int? = null;
     private var _thread: Thread? = null;
     private var _pingThread: Thread? = null;
+    private var _launchRetries = 0
+    private val MAX_LAUNCH_RETRIES = 3
+    private var _lastLaunchTime_ms = 0L
+    private var _retryJob: Job? = null
 
     constructor(name: String, addresses: Array<InetAddress>, port: Int) : super() {
         this.name = name;
@@ -229,6 +235,7 @@ class ChromecastCastingDevice : CastingDevice {
         launchObject.put("appId", "CC1AD845");
         launchObject.put("requestId", _requestId++);
         sendChannelMessage("sender-0", "receiver-0", "urn:x-cast:com.google.cast.receiver", launchObject.toString());
+        _lastLaunchTime_ms = System.currentTimeMillis()
     }
 
     private fun getStatus() {
@@ -268,6 +275,7 @@ class ChromecastCastingDevice : CastingDevice {
             _contentType = null;
             _streamType = null;
             _sessionId = null;
+            _launchRetries = 0
             _transportId = null;
         }
 
@@ -282,6 +290,7 @@ class ChromecastCastingDevice : CastingDevice {
 
         _started = true;
         _sessionId = null;
+        _launchRetries = 0
         _mediaSessionId = null;
 
         Logger.i(TAG, "Starting...");
@@ -322,6 +331,7 @@ class ChromecastCastingDevice : CastingDevice {
                         break;
                     } catch (e: Throwable) {
                         Logger.w(TAG, "Failed to get setup initial connection to ChromeCast device.", e)
+                        Thread.sleep(1000);
                     }
                 }
 
@@ -392,7 +402,7 @@ class ChromecastCastingDevice : CastingDevice {
                         try {
                             val inputStream = _inputStream ?: break;
 
-                            synchronized(_inputStreamLock)
+                            val message = synchronized(_inputStreamLock)
                             {
                                 Log.d(TAG, "Receiving next packet...");
                                 val b1 = inputStream.readUnsignedByte();
@@ -404,7 +414,7 @@ class ChromecastCastingDevice : CastingDevice {
                                 if (size > buffer.size) {
                                     Logger.w(TAG, "Skipping packet that is too large $size bytes.")
                                     inputStream.skip(size.toLong());
-                                    return@synchronized
+                                    return@synchronized null
                                 }
 
                                 Log.d(TAG, "Received header indicating $size bytes. Waiting for message.");
@@ -413,15 +423,19 @@ class ChromecastCastingDevice : CastingDevice {
                                 //TODO: In the future perhaps this size-1 will cause issues, why is there a 0 on the end?
                                 val messageBytes = buffer.sliceArray(IntRange(0, size - 1));
                                 Log.d(TAG, "Received $size bytes: ${messageBytes.toHexString()}.");
-                                val message = ChromeCast.CastMessage.parseFrom(messageBytes);
-                                if (message.namespace != "urn:x-cast:com.google.cast.tp.heartbeat") {
-                                    Logger.i(TAG, "Received message: $message");
+                                val msg = ChromeCast.CastMessage.parseFrom(messageBytes);
+                                if (msg.namespace != "urn:x-cast:com.google.cast.tp.heartbeat") {
+                                    Logger.i(TAG, "Received message: $msg");
                                 }
+                                return@synchronized msg
+                            }
 
+                            if (message != null) {
                                 try {
                                     handleMessage(message);
                                 } catch (e: Throwable) {
                                     Logger.w(TAG, "Failed to handle message.", e);
+                                    break
                                 }
                             }
                         } catch (e: java.net.SocketException) {
@@ -511,6 +525,7 @@ class ChromecastCastingDevice : CastingDevice {
                             if (_sessionId == null) {
                                 connectionState = CastConnectionState.CONNECTED;
                                 _sessionId = applicationUpdate.getString("sessionId");
+                                _launchRetries = 0
 
                                 val transportId = applicationUpdate.getString("transportId");
                                 connectMediaChannel(transportId);
@@ -525,21 +540,40 @@ class ChromecastCastingDevice : CastingDevice {
                 }
 
                 if (!sessionIsRunning) {
-                    _sessionId = null;
-                    _mediaSessionId = null;
-                    setTime(0.0);
-                    _transportId = null;
-                    Logger.w(TAG, "Session not found.");
+                    if (System.currentTimeMillis() - _lastLaunchTime_ms > 5000) {
+                        _sessionId = null
+                        _mediaSessionId = null
+                        setTime(0.0)
+                        _transportId = null
 
-                    if (_launching) {
-                        Logger.i(TAG, "Player not found, launching.");
-                        launchPlayer();
+                        if (_launching && _launchRetries < MAX_LAUNCH_RETRIES) {
+                            Logger.i(TAG, "No player yet; attempting launch #${_launchRetries + 1}")
+                            _launchRetries++
+                            launchPlayer()
+                        } else if (!_launching && _launchRetries < MAX_LAUNCH_RETRIES) {
+                            // Maybe the first GET_STATUS came back empty; still try launching
+                            Logger.i(TAG, "Player not found; triggering launch #${_launchRetries + 1}")
+                            _launching = true
+                            _launchRetries++
+                            launchPlayer()
+                        } else {
+                            Logger.e(TAG, "Player not found after $_launchRetries attempts; giving up.")
+                            Logger.i(TAG, "Unable to start media receiver on device")
+                            stop()
+                        }
                     } else {
-                        Logger.i(TAG, "Player not found, disconnecting.");
-                        stop();
+                        if (_retryJob == null) {
+                            Logger.i(TAG, "Scheduled retry job over 5 seconds")
+                            _retryJob = _scopeIO?.launch(Dispatchers.IO) {
+                                delay(5000)
+                                getStatus()
+                                _retryJob = null
+                            }
+                        }
                     }
                 } else {
-                    _launching = false;
+                    _launching = false
+                    _launchRetries = 0
                 }
 
                 val volume = status.getJSONObject("volume");
@@ -581,6 +615,8 @@ class ChromecastCastingDevice : CastingDevice {
                 if (message.sourceId == "receiver-0") {
                     Logger.i(TAG, "Close received.");
                     stop();
+                } else if (_transportId == message.sourceId) {
+                    throw Exception("Transport id closed.")
                 }
             }
         } else {
@@ -615,6 +651,9 @@ class ChromecastCastingDevice : CastingDevice {
         localAddress = null;
         _started = false;
 
+        _retryJob?.cancel()
+        _retryJob = null
+
         val socket = _socket;
         val scopeIO = _scopeIO;
 

app/src/main/java/com/futo/platformplayer/casting/FCastCastingDevice.kt

@@ -3,6 +3,7 @@ package com.futo.platformplayer.casting
 import android.os.Looper
 import android.util.Base64
 import android.util.Log
+import com.futo.platformplayer.Settings
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.casting.models.FCastDecryptedMessage
 import com.futo.platformplayer.casting.models.FCastEncryptedMessage
@@ -24,6 +25,7 @@ import com.futo.platformplayer.toInetAddress
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.cancel
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.isActive
 import kotlinx.coroutines.launch
 import kotlinx.serialization.encodeToString
@@ -32,6 +34,7 @@ import java.io.IOException
 import java.io.InputStream
 import java.io.OutputStream
 import java.math.BigInteger
+import java.net.Inet4Address
 import java.net.InetAddress
 import java.net.InetSocketAddress
 import java.net.Socket
@@ -90,7 +93,7 @@ class FCastCastingDevice : CastingDevice {
     private var _version: Long = 1;
     private var _thread: Thread? = null
     private var _pingThread: Thread? = null
-    private var _lastPongTime = -1L
+    @Volatile private var _lastPongTime = System.currentTimeMillis()
     private var _outputStreamLock = Object()
 
     constructor(name: String, addresses: Array<InetAddress>, port: Int) : super() {
@@ -287,6 +290,7 @@ class FCastCastingDevice : CastingDevice {
                         break;
                     } catch (e: Throwable) {
                         Logger.w(TAG, "Failed to get setup initial connection to FastCast device.", e)
+                        Thread.sleep(1000);
                     }
                 }
 
@@ -324,9 +328,9 @@ class FCastCastingDevice : CastingDevice {
                         continue;
                     }
 
-                    localAddress = _socket?.localAddress;
-                    connectionState = CastConnectionState.CONNECTED;
-                    _lastPongTime = -1L
+                    localAddress = _socket?.localAddress
+                    _lastPongTime = System.currentTimeMillis()
+                    connectionState = CastConnectionState.CONNECTED
 
                     val buffer = ByteArray(4096);
 
@@ -402,36 +406,32 @@ class FCastCastingDevice : CastingDevice {
 
             _pingThread = Thread {
                 Logger.i(TAG, "Started ping loop.")
-
                 while (_scopeIO?.isActive == true) {
-                    try {
-                        send(Opcode.Ping)
-                    } catch (e: Throwable) {
-                        Log.w(TAG, "Failed to send ping.")
-
+                    if (connectionState == CastConnectionState.CONNECTED) {
                         try {
-                            _socket?.close()
-                            _inputStream?.close()
-                            _outputStream?.close()
+                            send(Opcode.Ping)
+                            if (System.currentTimeMillis() - _lastPongTime > 15000) {
+                                Logger.w(TAG, "Closing socket due to last pong time being larger than 15 seconds.")
+                                try {
+                                    _socket?.close()
+                                } catch (e: Throwable) {
+                                    Log.w(TAG, "Failed to close socket.", e)
+                                }
+                            }
                         } catch (e: Throwable) {
-                            Log.w(TAG, "Failed to close socket.", e)
+                            Log.w(TAG, "Failed to send ping.")
+                            try {
+                                _socket?.close()
+                                _inputStream?.close()
+                                _outputStream?.close()
+                            } catch (e: Throwable) {
+                                Log.w(TAG, "Failed to close socket.", e)
+                            }
                         }
                     }
-
-                    /*if (_lastPongTime != -1L && System.currentTimeMillis() - _lastPongTime > 6000) {
-                        Logger.w(TAG, "Closing socket due to last pong time being larger than 6 seconds.")
-
-                        try {
-                            _socket?.close()
-                        } catch (e: Throwable) {
-                            Log.w(TAG, "Failed to close socket.", e)
-                        }
-                    }*/
-
-                    Thread.sleep(2000)
+                    Thread.sleep(5000)
                 }
-
-                Logger.i(TAG, "Stopped ping loop.");
+                Logger.i(TAG, "Stopped ping loop.")
             }.apply { start() }
         } else {
             Log.i(TAG, "Thread was still alive, not restarted")

app/src/main/java/com/futo/platformplayer/casting/StateCasting.kt

@@ -1,14 +1,20 @@
 package com.futo.platformplayer.casting
 
+import android.app.AlertDialog
 import android.content.ContentResolver
 import android.content.Context
 import android.net.Uri
+import android.net.nsd.NsdManager
+import android.net.nsd.NsdServiceInfo
+import android.os.Build
 import android.os.Looper
 import android.util.Base64
 import android.util.Log
-import android.util.Xml
+import java.net.NetworkInterface
+import java.net.Inet4Address
 import androidx.annotation.OptIn
 import androidx.media3.common.util.UnstableApi
+import com.futo.platformplayer.R
 import com.futo.platformplayer.Settings
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.api.http.ManagedHttpClient
@@ -37,9 +43,8 @@ import com.futo.platformplayer.builders.DashBuilder
 import com.futo.platformplayer.constructs.Event1
 import com.futo.platformplayer.constructs.Event2
 import com.futo.platformplayer.exceptions.UnsupportedCastException
+import com.futo.platformplayer.findPreferredAddress
 import com.futo.platformplayer.logging.Logger
-import com.futo.platformplayer.mdns.DnsService
-import com.futo.platformplayer.mdns.ServiceDiscoverer
 import com.futo.platformplayer.models.CastingDeviceInfo
 import com.futo.platformplayer.parsers.HLS
 import com.futo.platformplayer.states.StateApp
@@ -53,10 +58,11 @@ import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.json.Json
-import java.io.ByteArrayInputStream
+import java.net.Inet6Address
 import java.net.InetAddress
 import java.net.URLDecoder
 import java.net.URLEncoder
+import java.util.Collections
 import java.util.UUID
 
 class StateCasting {
@@ -68,7 +74,6 @@ class StateCasting {
     private var _started = false;
 
     var devices: HashMap<String, CastingDevice> = hashMapOf();
-    var rememberedDevices: ArrayList<CastingDevice> = arrayListOf();
     val onDeviceAdded = Event1<CastingDevice>();
     val onDeviceChanged = Event1<CastingDevice>();
     val onDeviceRemoved = Event1<CastingDevice>();
@@ -82,48 +87,15 @@ class StateCasting {
     private var _audioExecutor: JSRequestExecutor? = null
     private val _client = ManagedHttpClient();
     var _resumeCastingDevice: CastingDeviceInfo? = null;
-    val _serviceDiscoverer = ServiceDiscoverer(arrayOf(
-        "_googlecast._tcp.local",
-        "_airplay._tcp.local",
-        "_fastcast._tcp.local",
-        "_fcast._tcp.local"
-    )) { handleServiceUpdated(it) }
-
+    private var _nsdManager: NsdManager? = null
     val isCasting: Boolean get() = activeDevice != null;
 
-    private fun handleServiceUpdated(services: List<DnsService>) {
-        for (s in services) {
-            //TODO: Addresses IPv4 only?
-            val addresses = s.addresses.toTypedArray()
-            val port = s.port.toInt()
-            var name = s.texts.firstOrNull { it.startsWith("md=") }?.substring("md=".length)
-            if (s.name.endsWith("._googlecast._tcp.local")) {
-                if (name == null) {
-                    name = s.name.substring(0, s.name.length - "._googlecast._tcp.local".length)
-                }
-
-                addOrUpdateChromeCastDevice(name, addresses, port)
-            } else if (s.name.endsWith("._airplay._tcp.local")) {
-                if (name == null) {
-                    name = s.name.substring(0, s.name.length - "._airplay._tcp.local".length)
-                }
-
-                addOrUpdateAirPlayDevice(name, addresses, port)
-            } else if (s.name.endsWith("._fastcast._tcp.local")) {
-                if (name == null) {
-                    name = s.name.substring(0, s.name.length - "._fastcast._tcp.local".length)
-                }
-
-                addOrUpdateFastCastDevice(name, addresses, port)
-            } else if (s.name.endsWith("._fcast._tcp.local")) {
-                if (name == null) {
-                    name = s.name.substring(0, s.name.length - "._fcast._tcp.local".length)
-                }
-
-                addOrUpdateFastCastDevice(name, addresses, port)
-            }
-        }
-    }
+    private val _discoveryListeners = mapOf(
+        "_googlecast._tcp" to createDiscoveryListener(::addOrUpdateChromeCastDevice),
+        "_airplay._tcp" to createDiscoveryListener(::addOrUpdateAirPlayDevice),
+        "_fastcast._tcp" to createDiscoveryListener(::addOrUpdateFastCastDevice),
+        "_fcast._tcp" to createDiscoveryListener(::addOrUpdateFastCastDevice)
+    )
 
     fun handleUrl(context: Context, url: String) {
         val uri = Uri.parse(url)
@@ -188,30 +160,33 @@ class StateCasting {
 
         Logger.i(TAG, "CastingService starting...");
 
-        rememberedDevices.clear();
-        rememberedDevices.addAll(_storage.deviceInfos.map { deviceFromCastingDeviceInfo(it) });
-
         _castServer.start();
         enableDeveloper(true);
 
         Logger.i(TAG, "CastingService started.");
+
+        _nsdManager = context.getSystemService(Context.NSD_SERVICE) as NsdManager
     }
 
     @Synchronized
     fun startDiscovering() {
-        try {
-            _serviceDiscoverer.start()
-        } catch (e: Throwable) {
-            Logger.i(TAG, "Failed to start ServiceDiscoverer", e)
+        _nsdManager?.apply {
+            _discoveryListeners.forEach {
+                discoverServices(it.key, NsdManager.PROTOCOL_DNS_SD, it.value)
+            }
         }
     }
 
     @Synchronized
     fun stopDiscovering() {
-        try {
-            _serviceDiscoverer.stop()
-        } catch (e: Throwable) {
-            Logger.i(TAG, "Failed to stop ServiceDiscoverer", e)
+        _nsdManager?.apply {
+            _discoveryListeners.forEach {
+                try {
+                    stopServiceDiscovery(it.value)
+                } catch (e: Throwable) {
+                    Logger.w(TAG, "Failed to stop service discovery", e)
+                }
+            }
         }
     }
 
@@ -237,8 +212,90 @@ class StateCasting {
         _castServer.removeAllHandlers();
 
         Logger.i(TAG, "CastingService stopped.")
+
+        _nsdManager = null
     }
 
+    private fun createDiscoveryListener(addOrUpdate: (String, Array<InetAddress>, Int) -> Unit): NsdManager.DiscoveryListener {
+        return object : NsdManager.DiscoveryListener {
+            override fun onDiscoveryStarted(regType: String) {
+                Log.d(TAG, "Service discovery started for $regType")
+            }
+
+            override fun onDiscoveryStopped(serviceType: String) {
+                Log.i(TAG, "Discovery stopped: $serviceType")
+            }
+
+            override fun onServiceLost(service: NsdServiceInfo) {
+                Log.e(TAG, "service lost: $service")
+                // TODO: Handle service lost, e.g., remove device
+            }
+
+            override fun onStartDiscoveryFailed(serviceType: String, errorCode: Int) {
+                Log.e(TAG, "Discovery failed for $serviceType: Error code:$errorCode")
+                try {
+                    _nsdManager?.stopServiceDiscovery(this)
+                } catch (e: Throwable) {
+                    Logger.w(TAG, "Failed to stop service discovery", e)
+                }
+            }
+
+            override fun onStopDiscoveryFailed(serviceType: String, errorCode: Int) {
+                Log.e(TAG, "Stop discovery failed for $serviceType: Error code:$errorCode")
+                try {
+                    _nsdManager?.stopServiceDiscovery(this)
+                } catch (e: Throwable) {
+                    Logger.w(TAG, "Failed to stop service discovery", e)
+                }
+            }
+
+            override fun onServiceFound(service: NsdServiceInfo) {
+                Log.v(TAG, "Service discovery success for ${service.serviceType}: $service")
+                val addresses = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                    service.hostAddresses.toTypedArray()
+                } else {
+                    arrayOf(service.host)
+                }
+                addOrUpdate(service.serviceName, addresses, service.port)
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+                    _nsdManager?.registerServiceInfoCallback(service, { it.run() }, object : NsdManager.ServiceInfoCallback {
+                        override fun onServiceUpdated(serviceInfo: NsdServiceInfo) {
+                            Log.v(TAG, "onServiceUpdated: $serviceInfo")
+                            addOrUpdate(serviceInfo.serviceName, serviceInfo.hostAddresses.toTypedArray(), serviceInfo.port)
+                        }
+
+                        override fun onServiceLost() {
+                            Log.v(TAG, "onServiceLost: $service")
+                            // TODO: Handle service lost
+                        }
+
+                        override fun onServiceInfoCallbackRegistrationFailed(errorCode: Int) {
+                            Log.v(TAG, "onServiceInfoCallbackRegistrationFailed: $errorCode")
+                        }
+
+                        override fun onServiceInfoCallbackUnregistered() {
+                            Log.v(TAG, "onServiceInfoCallbackUnregistered")
+                        }
+                    })
+                } else {
+                    _nsdManager?.resolveService(service, object : NsdManager.ResolveListener {
+                        override fun onResolveFailed(serviceInfo: NsdServiceInfo, errorCode: Int) {
+                            Log.v(TAG, "Resolve failed: $errorCode")
+                        }
+
+                        override fun onServiceResolved(serviceInfo: NsdServiceInfo) {
+                            Log.v(TAG, "Resolve Succeeded: $serviceInfo")
+                            addOrUpdate(serviceInfo.serviceName, arrayOf(serviceInfo.host), serviceInfo.port)
+                        }
+                    })
+                }
+            }
+        }
+    }
+
+    private val _castingDialogLock = Any();
+    private var _currentDialog: AlertDialog? = null;
+
     @Synchronized
     fun connectDevice(device: CastingDevice) {
         if (activeDevice == device)
@@ -272,10 +329,41 @@ class StateCasting {
             invokeInMainScopeIfRequired {
                 StateApp.withContext(false) { context ->
                     context.let {
+                        Logger.i(TAG, "Casting state changed to ${castConnectionState}");
                         when (castConnectionState) {
-                            CastConnectionState.CONNECTED -> UIDialogs.toast(it, "Connected to device")
-                            CastConnectionState.CONNECTING -> UIDialogs.toast(it, "Connecting to device...")
-                            CastConnectionState.DISCONNECTED -> UIDialogs.toast(it, "Disconnected from device")
+                            CastConnectionState.CONNECTED -> {
+                                Logger.i(TAG, "Casting connected to [${device.name}]");
+                                UIDialogs.appToast("Connected to device")
+                                synchronized(_castingDialogLock) {
+                                    if(_currentDialog != null) {
+                                        _currentDialog?.hide();
+                                        _currentDialog = null;
+                                    }
+                                }
+                            }
+                            CastConnectionState.CONNECTING -> {
+                                Logger.i(TAG, "Casting connecting to [${device.name}]");
+                                UIDialogs.toast(it, "Connecting to device...")
+                                synchronized(_castingDialogLock) {
+                                    if(_currentDialog == null) {
+                                        _currentDialog = UIDialogs.showDialog(context, R.drawable.ic_loader_animated, true,
+                                                "Connecting to [${device.name}]",
+                                                "Make sure you are on the same network\n\nVPNs and guest networks can cause issues", null, -2,
+                                            UIDialogs.Action("Disconnect", {
+                                                device.stop();
+                                            }));
+                                    }
+                                }
+                            }
+                            CastConnectionState.DISCONNECTED -> {
+                                UIDialogs.toast(it, "Disconnected from device")
+                                synchronized(_castingDialogLock) {
+                                    if(_currentDialog != null) {
+                                        _currentDialog?.hide();
+                                        _currentDialog = null;
+                                    }
+                                }
+                            }
                         }
                     }
                 };
@@ -295,9 +383,6 @@ class StateCasting {
             invokeInMainScopeIfRequired { onActiveDeviceTimeChanged.emit(it) };
         };
 
-        addRememberedDevice(device);
-        Logger.i(TAG, "Device added to active discovery. Active discovery now contains ${_storage.getDevicesCount()} devices.")
-
         try {
             device.start();
         } catch (e: Throwable) {
@@ -319,21 +404,22 @@ class StateCasting {
         return addRememberedDevice(device);
     }
 
+    fun getRememberedCastingDevices(): List<CastingDevice> {
+        return _storage.getDevices().map { deviceFromCastingDeviceInfo(it) }
+    }
+
+    fun getRememberedCastingDeviceNames(): List<String> {
+        return _storage.getDeviceNames()
+    }
+
     fun addRememberedDevice(device: CastingDevice): CastingDeviceInfo {
         val deviceInfo = device.getDeviceInfo()
-        val foundInfo = _storage.addDevice(deviceInfo)
-        if (foundInfo == deviceInfo) {
-            rememberedDevices.add(device);
-            return foundInfo;
-        }
-
-        return foundInfo;
+        return _storage.addDevice(deviceInfo)
     }
 
     fun removeRememberedDevice(device: CastingDevice) {
-        val name = device.name ?: return;
-        _storage.removeDevice(name);
-        rememberedDevices.remove(device);
+        val name = device.name ?: return
+        _storage.removeDevice(name)
     }
 
     private fun invokeInMainScopeIfRequired(action: () -> Unit){
@@ -402,7 +488,7 @@ class StateCasting {
             }
         } else {
             val proxyStreams = Settings.instance.casting.alwaysProxyRequests;
-            val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+            val url = getLocalUrl(ad);
             val id = UUID.randomUUID();
 
             if (videoSource is IVideoUrlSource) {
@@ -497,7 +583,7 @@ class StateCasting {
     private fun castLocalVideo(video: IPlatformVideoDetails, videoSource: LocalVideoSource, resumePosition: Double, speed: Double?) : List<String> {
         val ad = activeDevice ?: return listOf();
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
         val videoPath = "/video-${id}"
         val videoUrl = url + videoPath;
@@ -516,7 +602,7 @@ class StateCasting {
     private fun castLocalAudio(video: IPlatformVideoDetails, audioSource: LocalAudioSource, resumePosition: Double, speed: Double?) : List<String> {
         val ad = activeDevice ?: return listOf();
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
         val audioPath = "/audio-${id}"
         val audioUrl = url + audioPath;
@@ -535,7 +621,7 @@ class StateCasting {
     private fun castLocalHls(video: IPlatformVideoDetails, videoSource: LocalVideoSource?, audioSource: LocalAudioSource?, subtitleSource: LocalSubtitleSource?, resumePosition: Double, speed: Double?): List<String> {
         val ad = activeDevice ?: return listOf()
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}"
+        val url = getLocalUrl(ad)
         val id = UUID.randomUUID()
 
         val hlsPath = "/hls-${id}"
@@ -631,7 +717,7 @@ class StateCasting {
     private fun castLocalDash(video: IPlatformVideoDetails, videoSource: LocalVideoSource?, audioSource: LocalAudioSource?, subtitleSource: LocalSubtitleSource?, resumePosition: Double, speed: Double?) : List<String> {
         val ad = activeDevice ?: return listOf();
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
 
         val dashPath = "/dash-${id}"
@@ -681,7 +767,7 @@ class StateCasting {
         val ad = activeDevice ?: return listOf();
         val proxyStreams = Settings.instance.casting.alwaysProxyRequests || ad !is FCastCastingDevice;
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
 
         val videoPath = "/video-${id}"
@@ -746,7 +832,7 @@ class StateCasting {
         _castServer.removeAllHandlers("castProxiedHlsMaster")
 
         val ad = activeDevice ?: return listOf();
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
 
         val id = UUID.randomUUID();
         val hlsPath = "/hls-${id}"
@@ -916,7 +1002,7 @@ class StateCasting {
 
     private suspend fun castHlsIndirect(contentResolver: ContentResolver, video: IPlatformVideoDetails, videoSource: IVideoUrlSource?, audioSource: IAudioUrlSource?, subtitleSource: ISubtitleSource?, resumePosition: Double, speed: Double?) : List<String> {
         val ad = activeDevice ?: return listOf();
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
 
         val hlsPath = "/hls-${id}"
@@ -1046,7 +1132,7 @@ class StateCasting {
         val ad = activeDevice ?: return listOf();
         val proxyStreams = Settings.instance.casting.alwaysProxyRequests || ad !is FCastCastingDevice;
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
 
         val dashPath = "/dash-${id}"
@@ -1132,6 +1218,15 @@ class StateCasting {
         }
     }
 
+    private fun getLocalUrl(ad: CastingDevice): String {
+        var address = ad.localAddress!!
+        if (address is Inet6Address && address.isLinkLocalAddress) {
+            address = findPreferredAddress() ?: address
+            Logger.i(TAG, "Selected casting address: $address")
+        }
+        return "http://${address.toUrlAddress().trim('/')}:${_castServer.port}";
+    }
+
     @OptIn(UnstableApi::class)
     private suspend fun castDashRaw(contentResolver: ContentResolver, video: IPlatformVideoDetails, videoSource: JSDashManifestRawSource?, audioSource: JSDashManifestRawAudioSource?, subtitleSource: ISubtitleSource?, resumePosition: Double, speed: Double?) : List<String> {
         val ad = activeDevice ?: return listOf();
@@ -1139,7 +1234,7 @@ class StateCasting {
         cleanExecutors()
         _castServer.removeAllHandlers("castDashRaw")
 
-        val url = "http://${ad.localAddress.toUrlAddress().trim('/')}:${_castServer.port}";
+        val url = getLocalUrl(ad);
         val id = UUID.randomUUID();
 
         val dashPath = "/dash-${id}"

app/src/main/java/com/futo/platformplayer/dialogs/AutoUpdateDialog.kt

@@ -7,7 +7,9 @@ import android.app.PendingIntent.getBroadcast
 import android.content.Context
 import android.content.Intent
 import android.content.pm.PackageInstaller
+import android.content.pm.PackageInstaller.SessionParams.USER_ACTION_NOT_REQUIRED
 import android.graphics.drawable.Animatable
+import android.os.Build
 import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
@@ -155,6 +157,9 @@ class AutoUpdateDialog(context: Context?) : AlertDialog(context) {
 
             val packageInstaller: PackageInstaller = context.packageManager.packageInstaller;
             val params = PackageInstaller.SessionParams(PackageInstaller.SessionParams.MODE_FULL_INSTALL);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                params.setRequireUserAction(USER_ACTION_NOT_REQUIRED)
+            }
             val sessionId = packageInstaller.createSession(params);
             session = packageInstaller.openSession(sessionId)
 

app/src/main/java/com/futo/platformplayer/dialogs/ConnectCastingDialog.kt

@@ -9,7 +9,9 @@ import android.view.View
 import android.widget.Button
 import android.widget.ImageButton
 import android.widget.ImageView
+import android.widget.LinearLayout
 import android.widget.TextView
+import androidx.recyclerview.widget.DiffUtil
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.futo.platformplayer.R
@@ -21,22 +23,21 @@ import com.futo.platformplayer.casting.StateCasting
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.views.adapters.DeviceAdapter
+import com.futo.platformplayer.views.adapters.DeviceAdapterEntry
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 
 class ConnectCastingDialog(context: Context?) : AlertDialog(context) {
     private lateinit var _imageLoader: ImageView;
     private lateinit var _buttonClose: Button;
-    private lateinit var _buttonAdd: ImageButton;
-    private lateinit var _buttonScanQR: ImageButton;
+    private lateinit var _buttonAdd: LinearLayout;
+    private lateinit var _buttonScanQR: LinearLayout;
     private lateinit var _textNoDevicesFound: TextView;
-    private lateinit var _textNoDevicesRemembered: TextView;
     private lateinit var _recyclerDevices: RecyclerView;
-    private lateinit var _recyclerRememberedDevices: RecyclerView;
     private lateinit var _adapter: DeviceAdapter;
-    private lateinit var _rememberedAdapter: DeviceAdapter;
-    private val _devices: ArrayList<CastingDevice> = arrayListOf();
-    private val _rememberedDevices: ArrayList<CastingDevice> = arrayListOf();
+    private val _devices: MutableSet<String> = mutableSetOf()
+    private val _rememberedDevices: MutableSet<String> = mutableSetOf()
+    private val _unifiedDevices: MutableList<DeviceAdapterEntry> = mutableListOf()
 
     override fun onCreate(savedInstanceState: Bundle?) {
         super.onCreate(savedInstanceState);
@@ -45,42 +46,40 @@ class ConnectCastingDialog(context: Context?) : AlertDialog(context) {
         _imageLoader = findViewById(R.id.image_loader);
         _buttonClose = findViewById(R.id.button_close);
         _buttonAdd = findViewById(R.id.button_add);
-        _buttonScanQR = findViewById(R.id.button_scan_qr);
+        _buttonScanQR = findViewById(R.id.button_qr);
         _recyclerDevices = findViewById(R.id.recycler_devices);
-        _recyclerRememberedDevices = findViewById(R.id.recycler_remembered_devices);
         _textNoDevicesFound = findViewById(R.id.text_no_devices_found);
-        _textNoDevicesRemembered = findViewById(R.id.text_no_devices_remembered);
 
-        _adapter = DeviceAdapter(_devices, false);
+        _adapter = DeviceAdapter(_unifiedDevices)
         _recyclerDevices.adapter = _adapter;
         _recyclerDevices.layoutManager = LinearLayoutManager(context);
 
-        _rememberedAdapter = DeviceAdapter(_rememberedDevices, true);
-        _rememberedAdapter.onRemove.subscribe { d ->
-            if (StateCasting.instance.activeDevice == d) {
-                d.stopCasting();
+        _adapter.onPin.subscribe { d ->
+            val isRemembered = _rememberedDevices.contains(d.name)
+            val newIsRemembered = !isRemembered
+            if (newIsRemembered) {
+                StateCasting.instance.addRememberedDevice(d)
+                val name = d.name
+                if (name != null) {
+                    _rememberedDevices.add(name)
+                }
+            } else {
+                StateCasting.instance.removeRememberedDevice(d)
+                _rememberedDevices.remove(d.name)
             }
-
-            StateCasting.instance.removeRememberedDevice(d);
-            val index = _rememberedDevices.indexOf(d);
-            if (index != -1) {
-                _rememberedDevices.removeAt(index);
-                _rememberedAdapter.notifyItemRemoved(index);
-            }
-
-            _textNoDevicesRemembered.visibility = if (_rememberedDevices.isEmpty()) View.VISIBLE else View.GONE;
-            _recyclerRememberedDevices.visibility = if (_rememberedDevices.isNotEmpty()) View.VISIBLE else View.GONE;
-        };
-        _rememberedAdapter.onConnect.subscribe { _ ->
-            dismiss()
-            UIDialogs.showCastingDialog(context)
+            updateUnifiedList()
         }
+
+        //TODO: Integrate remembered into the main list
+        //TODO: Add green indicator to indicate a device is oneline
+        //TODO: Add pinning
+        //TODO: Implement QR code as an option in add manually
+        //TODO: Remove start button
+
         _adapter.onConnect.subscribe { _ ->
             dismiss()
-            UIDialogs.showCastingDialog(context)
+            //UIDialogs.showCastingDialog(context)
         }
-        _recyclerRememberedDevices.adapter = _rememberedAdapter;
-        _recyclerRememberedDevices.layoutManager = LinearLayoutManager(context);
 
         _buttonClose.setOnClickListener { dismiss(); };
         _buttonAdd.setOnClickListener {
@@ -105,77 +104,112 @@ class ConnectCastingDialog(context: Context?) : AlertDialog(context) {
         Logger.i(TAG, "Dialog shown.");
 
         StateCasting.instance.startDiscovering()
-
         (_imageLoader.drawable as Animatable?)?.start();
 
-        _devices.clear();
-        synchronized (StateCasting.instance.devices) {
-            _devices.addAll(StateCasting.instance.devices.values);
+        synchronized(StateCasting.instance.devices) {
+            _devices.addAll(StateCasting.instance.devices.values.mapNotNull { it.name })
         }
 
-        _rememberedDevices.clear();
-        synchronized (StateCasting.instance.rememberedDevices) {
-            _rememberedDevices.addAll(StateCasting.instance.rememberedDevices);
+        _rememberedDevices.addAll(StateCasting.instance.getRememberedCastingDeviceNames())
+        updateUnifiedList()
+
+        StateCasting.instance.onDeviceAdded.subscribe(this) { d ->
+            val name = d.name
+            if (name != null)
+                _devices.add(name)
+            updateUnifiedList()
+        }
+
+        StateCasting.instance.onDeviceChanged.subscribe(this) { d ->
+            val index = _unifiedDevices.indexOfFirst { it.castingDevice.name == d.name }
+            if (index != -1) {
+                _unifiedDevices[index] = DeviceAdapterEntry(d, _unifiedDevices[index].isPinnedDevice, _unifiedDevices[index].isOnlineDevice)
+                _adapter.notifyItemChanged(index)
+            }
+        }
+
+        StateCasting.instance.onDeviceRemoved.subscribe(this) { d ->
+            _devices.remove(d.name)
+            updateUnifiedList()
+        }
+
+        StateCasting.instance.onActiveDeviceConnectionStateChanged.subscribe(this) { _, connectionState ->
+            if (connectionState == CastConnectionState.CONNECTED) {
+                StateApp.instance.scopeOrNull?.launch(Dispatchers.Main) {
+                    dismiss()
+                }
+            }
         }
 
         _textNoDevicesFound.visibility = if (_devices.isEmpty()) View.VISIBLE else View.GONE;
         _recyclerDevices.visibility = if (_devices.isNotEmpty()) View.VISIBLE else View.GONE;
-        _textNoDevicesRemembered.visibility = if (_rememberedDevices.isEmpty()) View.VISIBLE else View.GONE;
-        _recyclerRememberedDevices.visibility = if (_rememberedDevices.isNotEmpty()) View.VISIBLE else View.GONE;
-
-        StateCasting.instance.onDeviceAdded.subscribe(this) { d ->
-            _devices.add(d);
-            _adapter.notifyItemInserted(_devices.size - 1);
-            _textNoDevicesFound.visibility = View.GONE;
-            _recyclerDevices.visibility = View.VISIBLE;
-        };
-
-        StateCasting.instance.onDeviceChanged.subscribe(this) { d ->
-            val index = _devices.indexOf(d);
-            if (index == -1) {
-                return@subscribe;
-            }
-
-            _devices[index] = d;
-            _adapter.notifyItemChanged(index);
-        };
-
-        StateCasting.instance.onDeviceRemoved.subscribe(this) { d ->
-            val index = _devices.indexOf(d);
-            if (index == -1) {
-                return@subscribe;
-            }
-
-            _devices.removeAt(index);
-            _adapter.notifyItemRemoved(index);
-            _textNoDevicesFound.visibility = if (_devices.isEmpty()) View.VISIBLE else View.GONE;
-            _recyclerDevices.visibility = if (_devices.isNotEmpty()) View.VISIBLE else View.GONE;
-        };
-
-        StateCasting.instance.onActiveDeviceConnectionStateChanged.subscribe(this) { _, connectionState ->
-            if (connectionState != CastConnectionState.CONNECTED) {
-                return@subscribe;
-            }
-
-            StateApp.instance.scopeOrNull?.launch(Dispatchers.Main) {
-                dismiss();
-            };
-        };
-
-        _adapter.notifyDataSetChanged();
-        _rememberedAdapter.notifyDataSetChanged();
     }
 
     override fun dismiss() {
-        super.dismiss();
-
-        (_imageLoader.drawable as Animatable?)?.stop();
-
+        super.dismiss()
+        (_imageLoader.drawable as Animatable?)?.stop()
         StateCasting.instance.stopDiscovering()
-        StateCasting.instance.onDeviceAdded.remove(this);
-        StateCasting.instance.onDeviceChanged.remove(this);
-        StateCasting.instance.onDeviceRemoved.remove(this);
-        StateCasting.instance.onActiveDeviceConnectionStateChanged.remove(this);
+        StateCasting.instance.onDeviceAdded.remove(this)
+        StateCasting.instance.onDeviceChanged.remove(this)
+        StateCasting.instance.onDeviceRemoved.remove(this)
+        StateCasting.instance.onActiveDeviceConnectionStateChanged.remove(this)
+    }
+
+    private fun updateUnifiedList() {
+        val oldList = ArrayList(_unifiedDevices)
+        val newList = buildUnifiedList()
+
+        val diffResult = DiffUtil.calculateDiff(object : DiffUtil.Callback() {
+            override fun getOldListSize() = oldList.size
+            override fun getNewListSize() = newList.size
+            override fun areItemsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
+                val oldItem = oldList[oldItemPosition]
+                val newItem = newList[newItemPosition]
+                return oldItem.castingDevice.name == newItem.castingDevice.name
+                        && oldItem.castingDevice.isReady == newItem.castingDevice.isReady
+                        && oldItem.isOnlineDevice == newItem.isOnlineDevice
+                        && oldItem.isPinnedDevice == newItem.isPinnedDevice
+            }
+            override fun areContentsTheSame(oldItemPosition: Int, newItemPosition: Int): Boolean {
+                val oldItem = oldList[oldItemPosition]
+                val newItem = newList[newItemPosition]
+                return oldItem.castingDevice.name == newItem.castingDevice.name
+                        && oldItem.castingDevice.isReady == newItem.castingDevice.isReady
+                        && oldItem.isOnlineDevice == newItem.isOnlineDevice
+                        && oldItem.isPinnedDevice == newItem.isPinnedDevice
+            }
+        })
+
+        _unifiedDevices.clear()
+        _unifiedDevices.addAll(newList)
+        diffResult.dispatchUpdatesTo(_adapter)
+
+        _textNoDevicesFound.visibility = if (_unifiedDevices.isEmpty()) View.VISIBLE else View.GONE
+        _recyclerDevices.visibility = if (_unifiedDevices.isNotEmpty()) View.VISIBLE else View.GONE
+    }
+
+    private fun buildUnifiedList(): List<DeviceAdapterEntry> {
+        val onlineDevices = StateCasting.instance.devices.values.associateBy { it.name }
+        val rememberedDevices = StateCasting.instance.getRememberedCastingDevices().associateBy { it.name }
+
+        val unifiedList = mutableListOf<DeviceAdapterEntry>()
+
+        val intersectionNames = _devices.intersect(_rememberedDevices)
+        for (name in intersectionNames) {
+            onlineDevices[name]?.let { unifiedList.add(DeviceAdapterEntry(it, true, true)) }
+        }
+
+        val onlineOnlyNames = _devices - _rememberedDevices
+        for (name in onlineOnlyNames) {
+            onlineDevices[name]?.let { unifiedList.add(DeviceAdapterEntry(it, false, true)) }
+        }
+
+        val rememberedOnlyNames = _rememberedDevices - _devices
+        for (name in rememberedOnlyNames) {
+            rememberedDevices[name]?.let { unifiedList.add(DeviceAdapterEntry(it, true, false)) }
+        }
+
+        return unifiedList
     }
 
     companion object {

app/src/main/java/com/futo/platformplayer/downloads/VideoDownload.kt

@@ -47,6 +47,7 @@ import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.states.StatePlugins
 import com.futo.platformplayer.toHumanBitrate
 import com.futo.platformplayer.toHumanBytesSpeed
+import com.futo.polycentric.core.hexStringToByteArray
 import hasAnySource
 import isDownloadable
 import kotlinx.coroutines.CancellationException
@@ -59,16 +60,21 @@ import kotlinx.coroutines.suspendCancellableCoroutine
 import kotlinx.coroutines.withContext
 import kotlinx.serialization.Contextual
 import kotlinx.serialization.Transient
+import java.io.ByteArrayOutputStream
 import java.io.File
 import java.io.FileOutputStream
 import java.io.IOException
 import java.lang.Thread.sleep
+import java.nio.ByteBuffer
 import java.time.OffsetDateTime
 import java.util.UUID
 import java.util.concurrent.Executors
 import java.util.concurrent.ForkJoinPool
 import java.util.concurrent.ForkJoinTask
 import java.util.concurrent.ThreadLocalRandom
+import javax.crypto.Cipher
+import javax.crypto.spec.IvParameterSpec
+import javax.crypto.spec.SecretKeySpec
 import kotlin.coroutines.resumeWithException
 import kotlin.time.times
 
@@ -564,6 +570,14 @@ class VideoDownload {
         }
     }
 
+    private fun decryptSegment(encryptedSegment: ByteArray, key: ByteArray, iv: ByteArray): ByteArray {
+        val cipher = Cipher.getInstance("AES/CBC/PKCS5Padding")
+        val secretKey = SecretKeySpec(key, "AES")
+        val ivSpec = IvParameterSpec(iv)
+        cipher.init(Cipher.DECRYPT_MODE, secretKey, ivSpec)
+        return cipher.doFinal(encryptedSegment)
+    }
+
     private suspend fun downloadHlsSource(context: Context, name: String, client: ManagedHttpClient, hlsUrl: String, targetFile: File, onProgress: (Long, Long, Long) -> Unit): Long {
         if(targetFile.exists())
             targetFile.delete();
@@ -579,6 +593,14 @@ class VideoDownload {
                 ?: throw Exception("Variant playlist content is empty")
 
             val variantPlaylist = HLS.parseVariantPlaylist(vpContent, hlsUrl)
+            val decryptionInfo: DecryptionInfo? = if (variantPlaylist.decryptionInfo != null) {
+                val keyResponse = client.get(variantPlaylist.decryptionInfo.keyUrl)
+                check(keyResponse.isOk) { "HLS request failed for decryption key: ${keyResponse.code}" }
+                DecryptionInfo(keyResponse.body!!.bytes(), variantPlaylist.decryptionInfo.iv?.hexStringToByteArray())
+            } else {
+                null
+            }
+
             variantPlaylist.segments.forEachIndexed { index, segment ->
                 if (segment !is HLS.MediaSegment) {
                     return@forEachIndexed
@@ -590,7 +612,7 @@ class VideoDownload {
                 try {
                     segmentFiles.add(segmentFile)
 
-                    val segmentLength = downloadSource_Sequential(client, outputStream, segment.uri) { segmentLength, totalRead, lastSpeed ->
+                    val segmentLength = downloadSource_Sequential(client, outputStream, segment.uri, if (index == 0) null else decryptionInfo, index) { segmentLength, totalRead, lastSpeed ->
                         val averageSegmentLength = if (index == 0) segmentLength else downloadedTotalLength / index
                         val expectedTotalLength = averageSegmentLength * (variantPlaylist.segments.size - 1) + segmentLength
                         onProgress(expectedTotalLength, downloadedTotalLength + totalRead, lastSpeed)
@@ -630,10 +652,8 @@ class VideoDownload {
 
     private suspend fun combineSegments(context: Context, segmentFiles: List<File>, targetFile: File) = withContext(Dispatchers.IO) {
         suspendCancellableCoroutine { continuation ->
-            val fileList = File(context.cacheDir, "fileList-${UUID.randomUUID()}.txt")
-            fileList.writeText(segmentFiles.joinToString("\n") { "file '${it.absolutePath}'" })
-
-            val cmd = "-f concat -safe 0 -i \"${fileList.absolutePath}\" -c copy \"${targetFile.absolutePath}\""
+            val cmd =
+                "-i \"concat:${segmentFiles.joinToString("|")}\" -c copy \"${targetFile.absolutePath}\""
 
             val statisticsCallback = StatisticsCallback { _ ->
                 //TODO: Show progress?
@@ -643,7 +663,6 @@ class VideoDownload {
             val session = FFmpegKit.executeAsync(cmd,
                 { session ->
                     if (ReturnCode.isSuccess(session.returnCode)) {
-                        fileList.delete()
                         continuation.resumeWith(Result.success(Unit))
                     } else {
                         val errorMessage = if (ReturnCode.isCancel(session.returnCode)) {
@@ -651,7 +670,6 @@ class VideoDownload {
                         } else {
                             "Command failed with state '${session.state}' and return code ${session.returnCode}, stack trace ${session.failStackTrace}"
                         }
-                        fileList.delete()
                         continuation.resumeWithException(RuntimeException(errorMessage))
                     }
                 },
@@ -771,7 +789,7 @@ class VideoDownload {
             else {
                 Logger.i(TAG, "Download $name Sequential");
                 try {
-                    sourceLength = downloadSource_Sequential(client, fileStream, videoUrl, onProgress);
+                    sourceLength = downloadSource_Sequential(client, fileStream, videoUrl, null, 0, onProgress);
                 } catch (e: Throwable) {
                     Logger.w(TAG, "Failed to download sequentially (url = $videoUrl)")
                     throw e
@@ -798,7 +816,31 @@ class VideoDownload {
         }
         return sourceLength!!;
     }
-    private fun downloadSource_Sequential(client: ManagedHttpClient, fileStream: FileOutputStream, url: String, onProgress: (Long, Long, Long) -> Unit): Long {
+
+    data class DecryptionInfo(
+        val key: ByteArray,
+        val iv: ByteArray?
+    ) {
+        override fun equals(other: Any?): Boolean {
+            if (this === other) return true
+            if (javaClass != other?.javaClass) return false
+
+            other as DecryptionInfo
+
+            if (!key.contentEquals(other.key)) return false
+            if (!iv.contentEquals(other.iv)) return false
+
+            return true
+        }
+
+        override fun hashCode(): Int {
+            var result = key.contentHashCode()
+            result = 31 * result + iv.contentHashCode()
+            return result
+        }
+    }
+
+    private fun downloadSource_Sequential(client: ManagedHttpClient, fileStream: FileOutputStream, url: String, decryptionInfo: DecryptionInfo?, index: Int, onProgress: (Long, Long, Long) -> Unit): Long {
         val progressRate: Int = 4096 * 5;
         var lastProgressCount: Int = 0;
         val speedRate: Int = 4096 * 5;
@@ -818,6 +860,8 @@ class VideoDownload {
         val sourceLength = result.body.contentLength();
         val sourceStream = result.body.byteStream();
 
+        val segmentBuffer = ByteArrayOutputStream()
+
         var totalRead: Long = 0;
         try {
             var read: Int;
@@ -828,7 +872,7 @@ class VideoDownload {
                 if (read < 0)
                     break;
 
-                fileStream.write(buffer, 0, read);
+                segmentBuffer.write(buffer, 0, read);
 
                 totalRead += read;
 
@@ -854,6 +898,21 @@ class VideoDownload {
             result.body.close()
         }
 
+        if (decryptionInfo != null) {
+            var iv = decryptionInfo.iv
+            if (iv == null) {
+                iv = ByteBuffer.allocate(16)
+                    .putLong(0L)
+                    .putLong(index.toLong())
+                    .array()
+            }
+
+            val decryptedData = decryptSegment(segmentBuffer.toByteArray(), decryptionInfo.key, iv!!)
+            fileStream.write(decryptedData)
+        } else {
+            fileStream.write(segmentBuffer.toByteArray())
+        }
+
         onProgress(sourceLength, totalRead, 0);
         return sourceLength;
     }
@@ -1160,6 +1219,8 @@ class VideoDownload {
         fun audioContainerToExtension(container: String): String {
             if (container.contains("audio/mp4"))
                 return "mp4a";
+            else if (container.contains("video/mp4"))
+                return "mp4";
             else if (container.contains("audio/mpeg"))
                 return "mpga";
             else if (container.contains("audio/mp3"))
@@ -1167,7 +1228,7 @@ class VideoDownload {
             else if (container.contains("audio/webm"))
                 return "webm";
             else if (container == "application/vnd.apple.mpegurl")
-                return "mp4a";
+                return "m4a";
             else
                 return "audio";// throw IllegalStateException("Unknown container: " + container)
         }

app/src/main/java/com/futo/platformplayer/downloads/VideoExport.kt

@@ -69,7 +69,7 @@ class VideoExport {
             outputFile = f;
         } else if (v != null) {
             val outputFileName = videoLocal.name.sanitizeFileName(true) + "." + VideoDownload.videoContainerToExtension(v.container);
-            val f = downloadRoot.createFile(v.container, outputFileName)
+            val f = downloadRoot.createFile(if (v.container == "application/vnd.apple.mpegurl") "video/mp4" else v.container, outputFileName)
                 ?: throw Exception("Failed to create file in external directory.");
 
             Logger.i(TAG, "Copying video.");
@@ -81,8 +81,8 @@ class VideoExport {
             outputFile = f;
         } else if (a != null) {
             val outputFileName = videoLocal.name.sanitizeFileName(true) + "." + VideoDownload.audioContainerToExtension(a.container);
-            val f = downloadRoot.createFile(a.container, outputFileName)
-                ?: throw Exception("Failed to create file in external directory.");
+            val f = downloadRoot.createFile(if (a.container == "application/vnd.apple.mpegurl") "video/mp4" else a.container, outputFileName)
+                    ?: throw Exception("Failed to create file in external directory.");
 
             Logger.i(TAG, "Copying audio.");
 

app/src/main/java/com/futo/platformplayer/downloads/VideoLocal.kt

@@ -10,7 +10,7 @@ import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.models.playback.IPlaybackTracker
 import com.futo.platformplayer.api.media.models.ratings.IRating
 import com.futo.platformplayer.api.media.models.streams.IVideoSourceDescriptor
-import com.futo.platformplayer.api.media.models.streams.LocalVideoMuxedSourceDescriptor
+import com.futo.platformplayer.api.media.models.streams.DownloadedVideoMuxedSourceDescriptor
 import com.futo.platformplayer.api.media.models.streams.LocalVideoUnMuxedSourceDescriptor
 import com.futo.platformplayer.api.media.models.streams.sources.IDashManifestSource
 import com.futo.platformplayer.api.media.models.streams.sources.IHLSManifestSource
@@ -57,7 +57,7 @@ class VideoLocal: IPlatformVideoDetails, IStoreItem {
     override val video: IVideoSourceDescriptor get() = if(audioSource.isNotEmpty())
         LocalVideoUnMuxedSourceDescriptor(this)
     else
-        LocalVideoMuxedSourceDescriptor(this);
+        DownloadedVideoMuxedSourceDescriptor(this);
     override val preview: IVideoSourceDescriptor? get() = videoSerialized.preview;
 
     override val live: IVideoSource? get() = videoSerialized.live;

app/src/main/java/com/futo/platformplayer/engine/packages/PackageBridge.kt

@@ -12,6 +12,7 @@ import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateDeveloper
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.api.http.ManagedHttpClient
+import com.futo.platformplayer.api.media.models.contents.ContentType
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.api.media.platforms.js.JSClientConstants
 import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
@@ -72,6 +73,26 @@ class PackageBridge : V8Package {
     fun buildSpecVersion(): Int {
         return JSClientConstants.PLUGIN_SPEC_VERSION;
     }
+    @V8Property
+    fun buildPlatform(): String {
+        return "android";
+    }
+
+    @V8Property
+    fun supportedContent(): Array<Int> {
+        return arrayOf(
+            ContentType.MEDIA.value,
+            ContentType.POST.value,
+            ContentType.PLAYLIST.value,
+            ContentType.WEB.value,
+            ContentType.URL.value,
+            ContentType.NESTED_VIDEO.value,
+            ContentType.CHANNEL.value,
+            ContentType.LOCKED.value,
+            ContentType.PLACEHOLDER.value,
+            ContentType.DEFERRED.value
+        )
+    }
 
     @V8Function
     fun dispose(value: V8Value) {

app/src/main/java/com/futo/platformplayer/engine/packages/PackageHttp.kt

@@ -8,9 +8,7 @@ import com.caoccao.javet.enums.V8ProxyMode
 import com.caoccao.javet.interop.V8Runtime
 import com.caoccao.javet.values.V8Value
 import com.caoccao.javet.values.primitive.V8ValueString
-import com.caoccao.javet.values.reference.V8ValueArrayBuffer
 import com.caoccao.javet.values.reference.V8ValueObject
-import com.caoccao.javet.values.reference.V8ValueSharedArrayBuffer
 import com.caoccao.javet.values.reference.V8ValueTypedArray
 import com.futo.platformplayer.api.http.ManagedHttpClient
 import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
@@ -20,15 +18,9 @@ import com.futo.platformplayer.engine.V8Plugin
 import com.futo.platformplayer.engine.internal.IV8Convertable
 import com.futo.platformplayer.engine.internal.V8BindObject
 import com.futo.platformplayer.logging.Logger
-import com.futo.platformplayer.states.StateApp
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
 import java.net.SocketTimeoutException
 import java.util.concurrent.ForkJoinPool
 import java.util.concurrent.ForkJoinTask
-import kotlin.concurrent.thread
-import kotlin.streams.asSequence
 
 class PackageHttp: V8Package {
     @Transient
@@ -111,24 +103,24 @@ class PackageHttp: V8Package {
     @V8Function
     fun request(method: String, url: String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false, bytesResult: Boolean = false) : IBridgeHttpResponse {
         return if(useAuth)
-            _packageClientAuth.request(method, url, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING)
+            _packageClientAuth.requestInternal(method, url, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING)
         else
-            _packageClient.request(method, url, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING);
+            _packageClient.requestInternal(method, url, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING);
     }
 
     @V8Function
     fun requestWithBody(method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false, bytesResult: Boolean = false) : IBridgeHttpResponse {
         return if(useAuth)
-            _packageClientAuth.requestWithBody(method, url, body, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING)
+            _packageClientAuth.requestWithBodyInternal(method, url, body, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING)
         else
-            _packageClient.requestWithBody(method, url, body, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING);
+            _packageClient.requestWithBodyInternal(method, url, body, headers, if(bytesResult) ReturnType.BYTES else ReturnType.STRING);
     }
     @V8Function
     fun GET(url: String, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false, useByteResponse: Boolean = false) : IBridgeHttpResponse {
         return if(useAuth)
-            _packageClientAuth.GET(url, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING)
+            _packageClientAuth.GETInternal(url, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING)
         else
-            _packageClient.GET(url, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
+            _packageClient.GETInternal(url, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
     }
     @V8Function
     fun POST(url: String, body: Any, headers: MutableMap<String, String> = HashMap(), useAuth: Boolean = false, useByteResponse: Boolean = false) : IBridgeHttpResponse {
@@ -136,15 +128,15 @@ class PackageHttp: V8Package {
         val client = if(useAuth) _packageClientAuth else _packageClient;
 
         if(body is V8ValueString)
-            return client.POST(url, body.value, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
+            return client.POSTInternal(url, body.value, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
         else if(body is String)
-            return client.POST(url, body, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
+            return client.POSTInternal(url, body, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
         else if(body is V8ValueTypedArray)
-            return client.POST(url, body.toBytes(), headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
+            return client.POSTInternal(url, body.toBytes(), headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
         else if(body is ByteArray)
-            return client.POST(url, body, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
+            return client.POSTInternal(url, body, headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
         else if(body is ArrayList<*>) //Avoid this case, used purely for testing
-            return client.POST(url, body.map { (it as Double).toInt().toByte() }.toByteArray(), headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
+            return client.POSTInternal(url, body.map { (it as Double).toInt().toByte() }.toByteArray(), headers, if(useByteResponse) ReturnType.BYTES else ReturnType.STRING);
         else
             throw NotImplementedError("Body type " + body?.javaClass?.name?.toString() + " not implemented for POST");
     }
@@ -276,9 +268,9 @@ class PackageHttp: V8Package {
                 if(it.second.method == "DUMMY")
                     return@autoParallelPool null;
                 if(it.second.body != null)
-                    return@autoParallelPool it.first.requestWithBody(it.second.method, it.second.url, it.second.body!!, it.second.headers, it.second.respType);
+                    return@autoParallelPool it.first.requestWithBodyInternal(it.second.method, it.second.url, it.second.body!!, it.second.headers, it.second.respType);
                 else
-                    return@autoParallelPool it.first.request(it.second.method, it.second.url, it.second.headers, it.second.respType);
+                    return@autoParallelPool it.first.requestInternal(it.second.method, it.second.url, it.second.headers, it.second.respType);
             }.map {
                 if(it.second != null)
                     throw it.second!!;
@@ -345,7 +337,9 @@ class PackageHttp: V8Package {
         }
 
         @V8Function
-        fun request(method: String, url: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType) : IBridgeHttpResponse {
+        fun request(method: String, url: String, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
+            = requestInternal(method, url, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING);
+        fun requestInternal(method: String, url: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType) : IBridgeHttpResponse {
             applyDefaultHeaders(headers);
             return logExceptions {
                 return@logExceptions catchHttp {
@@ -364,7 +358,9 @@ class PackageHttp: V8Package {
             };
         }
         @V8Function
-        fun requestWithBody(method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType) : IBridgeHttpResponse {
+        fun requestWithBody(method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
+            = requestWithBodyInternal(method, url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
+        fun requestWithBodyInternal(method: String, url: String, body:String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType) : IBridgeHttpResponse {
             applyDefaultHeaders(headers);
             return logExceptions {
                 catchHttp {
@@ -385,7 +381,9 @@ class PackageHttp: V8Package {
         }
 
         @V8Function
-        fun GET(url: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
+        fun GET(url: String, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
+            = GETInternal(url, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
+        fun GETInternal(url: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
             applyDefaultHeaders(headers);
             return logExceptions {
                 catchHttp {
@@ -407,7 +405,9 @@ class PackageHttp: V8Package {
             };
         }
         @V8Function
-        fun POST(url: String, body: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
+        fun POST(url: String, body: String, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
+            = POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
+        fun POSTInternal(url: String, body: String, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
             applyDefaultHeaders(headers);
             return logExceptions {
                 catchHttp {
@@ -429,7 +429,9 @@ class PackageHttp: V8Package {
             };
         }
         @V8Function
-        fun POST(url: String, body: ByteArray, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
+        fun POST(url: String, body: ByteArray, headers: MutableMap<String, String> = HashMap(), useBytes: Boolean = false) : IBridgeHttpResponse
+                = POSTInternal(url, body, headers, if(useBytes) ReturnType.BYTES else ReturnType.STRING)
+        fun POSTInternal(url: String, body: ByteArray, headers: MutableMap<String, String> = HashMap(), returnType: ReturnType = ReturnType.STRING) : IBridgeHttpResponse {
             applyDefaultHeaders(headers);
             return logExceptions {
                 catchHttp {

app/src/main/java/com/futo/platformplayer/fragment/channel/tab/ChannelContentsFragment.kt

@@ -5,6 +5,7 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import android.widget.FrameLayout
 import androidx.fragment.app.Fragment
 import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.GridLayoutManager
@@ -25,6 +26,7 @@ import com.futo.platformplayer.api.media.structures.MultiPager
 import com.futo.platformplayer.constructs.Event1
 import com.futo.platformplayer.constructs.Event2
 import com.futo.platformplayer.constructs.TaskHandler
+import com.futo.platformplayer.dp
 import com.futo.platformplayer.engine.exceptions.PluginException
 import com.futo.platformplayer.engine.exceptions.ScriptCaptchaRequiredException
 import com.futo.platformplayer.exceptions.ChannelException
@@ -32,9 +34,11 @@ import com.futo.platformplayer.fragment.mainactivity.main.FeedView
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateCache
 import com.futo.platformplayer.states.StatePlatform
+import com.futo.platformplayer.states.StatePlugins
 import com.futo.platformplayer.states.StatePolycentric
 import com.futo.platformplayer.states.StateSubscriptions
 import com.futo.platformplayer.views.FeedStyle
+import com.futo.platformplayer.views.SearchView
 import com.futo.platformplayer.views.adapters.ContentPreviewViewHolder
 import com.futo.platformplayer.views.adapters.InsertedViewAdapterWithLoader
 import com.futo.platformplayer.views.adapters.feedtypes.PreviewContentListAdapter
@@ -54,6 +58,8 @@ class ChannelContentsFragment(private val subType: String? = null) : Fragment(),
     private var _results: ArrayList<IPlatformContent> = arrayListOf();
     private var _adapterResults: InsertedViewAdapterWithLoader<ContentPreviewViewHolder>? = null;
     private var _lastPolycentricProfile: PolycentricProfile? = null;
+    private var _query: String? = null
+    private var _searchView: SearchView? = null
 
     val onContentClicked = Event2<IPlatformContent, Long>();
     val onContentUrlClicked = Event2<String, ContentType>();
@@ -68,16 +74,32 @@ class ChannelContentsFragment(private val subType: String? = null) : Fragment(),
     private fun getContentPager(channel: IPlatformChannel): IPager<IPlatformContent> {
         Logger.i(TAG, "getContentPager");
 
-        val lastPolycentricProfile = _lastPolycentricProfile;
-        var pager: IPager<IPlatformContent>? = null;
-        if (lastPolycentricProfile != null)
-            pager= StatePolycentric.instance.getChannelContent(lifecycleScope, lastPolycentricProfile);
+        var pager: IPager<IPlatformContent>? = null
+        val query = _query
+        if (!query.isNullOrBlank()) {
+            if(subType != null) {
+                Logger.i(TAG, "StatePlatform.instance.searchChannel(channel.url = ${channel.url}, query = ${query}, subType = ${subType})")
+                pager = StatePlatform.instance.searchChannel(channel.url, query, subType);
+            } else {
+                Logger.i(TAG, "StatePlatform.instance.searchChannel(channel.url = ${channel.url}, query = ${query})")
+                pager = StatePlatform.instance.searchChannel(channel.url, query);
+            }
+        } else {
+            val lastPolycentricProfile = _lastPolycentricProfile;
+            if (lastPolycentricProfile != null && StatePolycentric.instance.enabled) {
+                pager = StatePolycentric.instance.getChannelContent(lifecycleScope, lastPolycentricProfile, type = subType);
+                Logger.i(TAG, "StatePolycentric.instance.getChannelContent(lifecycleScope, lastPolycentricProfile, type = ${subType})")
+            }
 
-        if(pager == null) {
-            if(subType != null)
-                pager = StatePlatform.instance.getChannelContent(channel.url, subType);
-            else
-                pager = StatePlatform.instance.getChannelContent(channel.url);
+            if(pager == null) {
+                if(subType != null) {
+                    pager = StatePlatform.instance.getChannelContent(channel.url, subType);
+                    Logger.i(TAG, "StatePlatform.instance.getChannelContent(channel.url = ${channel.url}, subType = ${subType})")
+                } else {
+                    pager = StatePlatform.instance.getChannelContent(channel.url);
+                    Logger.i(TAG, "StatePlatform.instance.getChannelContent(channel.url = ${channel.url})")
+                }
+            }
         }
         return pager;
     }
@@ -144,19 +166,49 @@ class ChannelContentsFragment(private val subType: String? = null) : Fragment(),
 
         _taskLoadVideos.cancel();
 
+        _query = null
         _channel = channel;
+        updateSearchViewVisibility()
         _results.clear();
         _adapterResults?.notifyDataSetChanged();
 
         loadInitial();
     }
 
+    private fun updateSearchViewVisibility() {
+        if (subType != null) {
+            _searchView?.visibility = View.GONE
+            return
+        }
+
+        val client = _channel?.id?.pluginId?.let { StatePlatform.instance.getClientOrNull(it) }
+        Logger.i(TAG, "_searchView.visible = ${client?.capabilities?.hasSearchChannelContents == true}")
+        _searchView?.visibility = if (client?.capabilities?.hasSearchChannelContents == true) View.VISIBLE else View.GONE
+    }
+
+    fun setQuery(query: String) {
+        _query = query
+        _taskLoadVideos.cancel()
+        _results.clear()
+        _adapterResults?.notifyDataSetChanged()
+        loadInitial()
+    }
+
     override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
         val view = inflater.inflate(R.layout.fragment_channel_videos, container, false);
 
+        _query = null
         _recyclerResults = view.findViewById(R.id.recycler_videos);
 
-        _adapterResults = PreviewContentListAdapter(view.context, FeedStyle.THUMBNAIL, _results, null, Settings.instance.channel.progressBar).apply {
+        val searchView = SearchView(requireContext()).apply { layoutParams = FrameLayout.LayoutParams(FrameLayout.LayoutParams.MATCH_PARENT, FrameLayout.LayoutParams.WRAP_CONTENT) }.apply {
+            onEnter.subscribe {
+                setQuery(it)
+            }
+        }
+        _searchView = searchView
+        updateSearchViewVisibility()
+
+        _adapterResults = PreviewContentListAdapter(view.context, FeedStyle.THUMBNAIL, _results, null, Settings.instance.channel.progressBar, viewsToPrepend = arrayListOf(searchView)).apply {
             this.onContentUrlClicked.subscribe(this@ChannelContentsFragment.onContentUrlClicked::emit);
             this.onUrlClicked.subscribe(this@ChannelContentsFragment.onUrlClicked::emit);
             this.onContentClicked.subscribe(this@ChannelContentsFragment.onContentClicked::emit);
@@ -173,6 +225,7 @@ class ChannelContentsFragment(private val subType: String? = null) : Fragment(),
         _recyclerResults?.layoutManager = _glmVideo;
         _recyclerResults?.addOnScrollListener(_scrollListener);
 
+
         return view;
     }
 
@@ -181,6 +234,8 @@ class ChannelContentsFragment(private val subType: String? = null) : Fragment(),
         _recyclerResults?.removeOnScrollListener(_scrollListener);
         _recyclerResults = null;
         _pager = null;
+        _query = null
+        _searchView = null
 
         _taskLoadVideos.cancel();
         _nextPageHandler.cancel();
@@ -303,6 +358,7 @@ class ChannelContentsFragment(private val subType: String? = null) : Fragment(),
     }
 
     private fun loadInitial() {
+        Logger.i(TAG, "loadInitial")
         val channel: IPlatformChannel = _channel ?: return;
         setLoading(true);
         _taskLoadVideos.run(channel);

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/ArticleDetailFragment.kt

@@ -0,0 +1,785 @@
+package com.futo.platformplayer.fragment.mainactivity.main
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.Typeface
+import android.graphics.drawable.Animatable
+import android.os.Bundle
+import android.text.Html
+import android.text.method.ScrollingMovementMethod
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewPropertyAnimator
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.constraintlayout.widget.ConstraintLayout
+import androidx.core.view.children
+import androidx.core.view.isVisible
+import androidx.core.view.setPadding
+import androidx.lifecycle.lifecycleScope
+import com.bumptech.glide.Glide
+import com.futo.platformplayer.R
+import com.futo.platformplayer.Settings
+import com.futo.platformplayer.UIDialogs
+import com.futo.platformplayer.UISlideOverlays
+import com.futo.platformplayer.api.media.PlatformID
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.article.IPlatformArticle
+import com.futo.platformplayer.api.media.models.article.IPlatformArticleDetails
+import com.futo.platformplayer.api.media.models.comments.PolycentricPlatformComment
+import com.futo.platformplayer.api.media.models.contents.IPlatformContent
+import com.futo.platformplayer.api.media.models.locked.IPlatformLockedContent
+import com.futo.platformplayer.api.media.models.nested.IPlatformNestedContent
+import com.futo.platformplayer.api.media.models.post.IPlatformPost
+import com.futo.platformplayer.api.media.models.post.IPlatformPostDetails
+import com.futo.platformplayer.api.media.models.post.TextType
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.models.ratings.RatingLikeDislikes
+import com.futo.platformplayer.api.media.models.ratings.RatingLikes
+import com.futo.platformplayer.api.media.models.video.IPlatformVideo
+import com.futo.platformplayer.api.media.models.video.SerializedPlatformVideo
+import com.futo.platformplayer.api.media.platforms.js.models.JSArticleDetails
+import com.futo.platformplayer.api.media.platforms.js.models.JSImagesSegment
+import com.futo.platformplayer.api.media.platforms.js.models.JSNestedSegment
+import com.futo.platformplayer.api.media.platforms.js.models.JSTextSegment
+import com.futo.platformplayer.api.media.platforms.js.models.SegmentType
+import com.futo.platformplayer.constructs.TaskHandler
+import com.futo.platformplayer.dp
+import com.futo.platformplayer.fixHtmlWhitespace
+import com.futo.platformplayer.images.GlideHelper.Companion.crossfade
+import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.setPlatformPlayerLinkMovementMethod
+import com.futo.platformplayer.states.StateApp
+import com.futo.platformplayer.states.StatePlatform
+import com.futo.platformplayer.states.StatePlayer
+import com.futo.platformplayer.states.StatePlaylists
+import com.futo.platformplayer.states.StatePolycentric
+import com.futo.platformplayer.toHumanNowDiffString
+import com.futo.platformplayer.toHumanNumber
+import com.futo.platformplayer.views.FeedStyle
+import com.futo.platformplayer.views.adapters.feedtypes.PreviewLockedView
+import com.futo.platformplayer.views.adapters.feedtypes.PreviewNestedVideoView
+import com.futo.platformplayer.views.adapters.feedtypes.PreviewPostView
+import com.futo.platformplayer.views.adapters.feedtypes.PreviewVideoView
+import com.futo.platformplayer.views.comments.AddCommentView
+import com.futo.platformplayer.views.others.CreatorThumbnail
+import com.futo.platformplayer.views.overlays.RepliesOverlay
+import com.futo.platformplayer.views.pills.PillRatingLikesDislikes
+import com.futo.platformplayer.views.platform.PlatformIndicator
+import com.futo.platformplayer.views.segments.CommentsList
+import com.futo.platformplayer.views.subscriptions.SubscribeButton
+import com.futo.polycentric.core.ApiMethods
+import com.futo.polycentric.core.ContentType
+import com.futo.polycentric.core.Models
+import com.futo.polycentric.core.Opinion
+import com.futo.polycentric.core.PolycentricProfile
+import com.futo.polycentric.core.fullyBackfillServersAnnounceExceptions
+import com.google.android.flexbox.FlexboxLayout
+import com.google.android.material.imageview.ShapeableImageView
+import com.google.android.material.shape.CornerFamily
+import com.google.android.material.shape.ShapeAppearanceModel
+import com.google.protobuf.ByteString
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import userpackage.Protocol
+import java.lang.Integer.min
+
+class ArticleDetailFragment : MainFragment {
+    override val isMainView: Boolean = true;
+    override val isTab: Boolean = true;
+    override val hasBottomBar: Boolean get() = true;
+
+    private var _viewDetail: ArticleDetailView? = null;
+
+    constructor() : super() { }
+
+    override fun onBackPressed(): Boolean {
+        return false;
+    }
+
+    override fun onCreateMainView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        val view = ArticleDetailView(inflater.context).applyFragment(this);
+        _viewDetail = view;
+        return view;
+    }
+
+    override fun onDestroyMainView() {
+        super.onDestroyMainView();
+        _viewDetail?.onDestroy();
+        _viewDetail = null;
+    }
+
+    override fun onShownWithView(parameter: Any?, isBack: Boolean) {
+        super.onShownWithView(parameter, isBack);
+
+        if (parameter is IPlatformArticleDetails) {
+            _viewDetail?.clear();
+            _viewDetail?.setArticleDetails(parameter);
+        } else if (parameter is IPlatformArticle) {
+            _viewDetail?.setArticleOverview(parameter);
+        } else if(parameter is String) {
+            _viewDetail?.setPostUrl(parameter);
+        }
+    }
+
+    private class ArticleDetailView : ConstraintLayout {
+        private lateinit var _fragment: ArticleDetailFragment;
+        private var _url: String? = null;
+        private var _isLoading = false;
+        private var _article: IPlatformArticleDetails? = null;
+        private var _articleOverview: IPlatformArticle? = null;
+        private var _polycentricProfile: PolycentricProfile? = null;
+        private var _version = 0;
+        private var _isRepliesVisible: Boolean = false;
+        private var _repliesAnimator: ViewPropertyAnimator? = null;
+
+        private val _creatorThumbnail: CreatorThumbnail;
+        private val _buttonSubscribe: SubscribeButton;
+        private val _channelName: TextView;
+        private val _channelMeta: TextView;
+        private val _textTitle: TextView;
+        private val _textMeta: TextView;
+        private val _textSummary: TextView;
+        private val _containerSegments: LinearLayout;
+        private val _platformIndicator: PlatformIndicator;
+        private val _buttonShare: ImageButton;
+
+        private val _layoutRating: LinearLayout;
+        private val _imageLikeIcon: ImageView;
+        private val _textLikes: TextView;
+        private val _imageDislikeIcon: ImageView;
+        private val _textDislikes: TextView;
+
+        private val _addCommentView: AddCommentView;
+
+        private val _rating: PillRatingLikesDislikes;
+
+        private val _layoutLoadingOverlay: FrameLayout;
+        private val _imageLoader: ImageView;
+
+        private var _overlayContainer: FrameLayout
+        private val _repliesOverlay: RepliesOverlay;
+
+        private val _commentsList: CommentsList;
+
+        private var _commentType: Boolean? = null;
+        private val _buttonPolycentric: Button
+        private val _buttonPlatform: Button
+
+        private val _taskLoadPost = if(!isInEditMode) TaskHandler<String, IPlatformArticleDetails>(
+            StateApp.instance.scopeGetter,
+            {
+                val result = StatePlatform.instance.getContentDetails(it).await();
+                if(result !is IPlatformArticleDetails)
+                    throw IllegalStateException(context.getString(R.string.expected_media_content_found) + " ${result.contentType}");
+                return@TaskHandler result;
+            })
+            .success { setArticleDetails(it) }
+            .exception<Throwable> {
+                Logger.w(ChannelFragment.TAG, context.getString(R.string.failed_to_load_post), it);
+                UIDialogs.showGeneralRetryErrorDialog(context, context.getString(R.string.failed_to_load_post), it, ::fetchPost, null, _fragment);
+            } else TaskHandler(IPlatformPostDetails::class.java) { _fragment.lifecycleScope };
+
+        private val _taskLoadPolycentricProfile = TaskHandler<PlatformID, PolycentricProfile?>(StateApp.instance.scopeGetter, {
+            if (!StatePolycentric.instance.enabled)
+                return@TaskHandler null
+
+            ApiMethods.getPolycentricProfileByClaim(ApiMethods.SERVER, ApiMethods.FUTO_TRUST_ROOT, it.claimFieldType.toLong(), it.claimType.toLong(), it.value!!)
+        })
+            .success { it -> setPolycentricProfile(it, animate = true) }
+            .exception<Throwable> {
+                Logger.w(TAG, "Failed to load claims.", it);
+            };
+
+        constructor(context: Context) : super(context) {
+            inflate(context, R.layout.fragview_article_detail, this);
+
+            val root = findViewById<FrameLayout>(R.id.root);
+
+            _creatorThumbnail = findViewById(R.id.creator_thumbnail);
+            _buttonSubscribe = findViewById(R.id.button_subscribe);
+            _channelName = findViewById(R.id.text_channel_name);
+            _channelMeta = findViewById(R.id.text_channel_meta);
+            _textTitle = findViewById(R.id.text_title);
+            _textMeta = findViewById(R.id.text_meta);
+            _textSummary = findViewById(R.id.text_summary);
+            _containerSegments = findViewById(R.id.container_segments);
+            _platformIndicator = findViewById(R.id.platform_indicator);
+            _buttonShare = findViewById(R.id.button_share);
+
+            _overlayContainer = findViewById(R.id.overlay_container);
+
+            _layoutRating = findViewById(R.id.layout_rating);
+            _imageLikeIcon = findViewById(R.id.image_like_icon);
+            _textLikes = findViewById(R.id.text_likes);
+            _imageDislikeIcon = findViewById(R.id.image_dislike_icon);
+            _textDislikes = findViewById(R.id.text_dislikes);
+
+            _commentsList = findViewById(R.id.comments_list);
+            _addCommentView = findViewById(R.id.add_comment_view);
+
+            _rating = findViewById(R.id.rating);
+
+            _layoutLoadingOverlay = findViewById(R.id.layout_loading_overlay);
+            _imageLoader = findViewById(R.id.image_loader);
+
+
+            _repliesOverlay = findViewById(R.id.replies_overlay);
+
+            _buttonPolycentric = findViewById(R.id.button_polycentric)
+            _buttonPlatform = findViewById(R.id.button_platform)
+
+            _buttonSubscribe.onSubscribed.subscribe {
+                //TODO: add overlay to layout
+                //UISlideOverlays.showSubscriptionOptionsOverlay(it, _overlayContainer);
+            };
+
+            val layoutTop: LinearLayout = findViewById(R.id.layout_top);
+            root.removeView(layoutTop);
+            _commentsList.setPrependedView(layoutTop);
+
+            /*TODO: Why is this here?
+            _commentsList.onCommentsLoaded.subscribe {
+                updateCommentType(false);
+            };*/
+
+            _commentsList.onRepliesClick.subscribe { c ->
+                val replyCount = c.replyCount ?: 0;
+                var metadata = "";
+                if (replyCount > 0) {
+                    metadata += "$replyCount " + context.getString(R.string.replies);
+                }
+
+                if (c is PolycentricPlatformComment) {
+                    var parentComment: PolycentricPlatformComment = c;
+                    _repliesOverlay.load(_commentType!!, metadata, c.contextUrl, c.reference, c,
+                        { StatePolycentric.instance.getCommentPager(c.contextUrl, c.reference) },
+                        {
+                            val newComment = parentComment.cloneWithUpdatedReplyCount((parentComment.replyCount ?: 0) + 1);
+                            _commentsList.replaceComment(parentComment, newComment);
+                            parentComment = newComment;
+                        });
+                } else {
+                    _repliesOverlay.load(_commentType!!, metadata, null, null, c, { StatePlatform.instance.getSubComments(c) });
+                }
+
+                setRepliesOverlayVisible(isVisible = true, animate = true);
+            };
+
+            if (StatePolycentric.instance.enabled) {
+                _buttonPolycentric.setOnClickListener {
+                    updateCommentType(false)
+                }
+            } else {
+                _buttonPolycentric.visibility = View.GONE
+            }
+
+            _buttonPlatform.setOnClickListener {
+                updateCommentType(true)
+            }
+
+            _addCommentView.onCommentAdded.subscribe {
+                _commentsList.addComment(it);
+            };
+
+            _repliesOverlay.onClose.subscribe { setRepliesOverlayVisible(isVisible = false, animate = true); };
+
+            _buttonShare.setOnClickListener { share() };
+
+            _creatorThumbnail.onClick.subscribe { openChannel() };
+            _channelName.setOnClickListener { openChannel() };
+            _channelMeta.setOnClickListener { openChannel() };
+        }
+
+        private fun openChannel() {
+            val author = _article?.author ?: _articleOverview?.author ?: return;
+            _fragment.navigate<ChannelFragment>(author);
+        }
+
+        private fun share() {
+            try {
+                Logger.i(PreviewPostView.TAG, "sharePost")
+
+                val url = _article?.shareUrl ?: _articleOverview?.shareUrl ?: _url;
+                _fragment.startActivity(Intent.createChooser(Intent().apply {
+                    action = Intent.ACTION_SEND;
+                    putExtra(Intent.EXTRA_TEXT, url);
+                    type = "text/plain"; //TODO: Determine alt types?
+                }, null));
+            } catch (e: Throwable) {
+                //Ignored
+                Logger.e(PreviewPostView.TAG, "Failed to share.", e);
+            }
+        }
+
+        private fun updatePolycentricRating() {
+            _rating.visibility = View.GONE;
+
+            val ref = Models.referenceFromBuffer((_article?.url ?: _articleOverview?.url)?.toByteArray() ?: return)
+            val extraBytesRef = (_article?.id?.value ?: _articleOverview?.id?.value)?.let { if (it.isNotEmpty()) it.toByteArray() else null }
+            val version = _version;
+
+            _rating.onLikeDislikeUpdated.remove(this);
+
+            if (!StatePolycentric.instance.enabled)
+                return
+
+            _fragment.lifecycleScope.launch(Dispatchers.IO) {
+                if (version != _version) {
+                    return@launch;
+                }
+
+                try {
+                    val queryReferencesResponse = ApiMethods.getQueryReferences(ApiMethods.SERVER, ref, null,null,
+                        arrayListOf(
+                            Protocol.QueryReferencesRequestCountLWWElementReferences.newBuilder().setFromType(
+                                ContentType.OPINION.value).setValue(
+                                ByteString.copyFrom(Opinion.like.data)).build(),
+                            Protocol.QueryReferencesRequestCountLWWElementReferences.newBuilder().setFromType(
+                                ContentType.OPINION.value).setValue(
+                                ByteString.copyFrom(Opinion.dislike.data)).build()
+                        ),
+                        extraByteReferences = listOfNotNull(extraBytesRef)
+                    );
+
+                    if (version != _version) {
+                        return@launch;
+                    }
+
+                    val likes = queryReferencesResponse.countsList[0];
+                    val dislikes = queryReferencesResponse.countsList[1];
+                    val hasLiked = StatePolycentric.instance.hasLiked(ref.toByteArray())/* || extraBytesRef?.let { StatePolycentric.instance.hasLiked(it) } ?: false*/;
+                    val hasDisliked = StatePolycentric.instance.hasDisliked(ref.toByteArray())/* || extraBytesRef?.let { StatePolycentric.instance.hasDisliked(it) } ?: false*/;
+
+                    withContext(Dispatchers.Main) {
+                        if (version != _version) {
+                            return@withContext;
+                        }
+
+                        _rating.visibility = VISIBLE;
+                        _rating.setRating(RatingLikeDislikes(likes, dislikes), hasLiked, hasDisliked);
+                        _rating.onLikeDislikeUpdated.subscribe(this) { args ->
+                            if (args.hasLiked) {
+                                args.processHandle.opinion(ref, Opinion.like);
+                            } else if (args.hasDisliked) {
+                                args.processHandle.opinion(ref, Opinion.dislike);
+                            } else {
+                                args.processHandle.opinion(ref, Opinion.neutral);
+                            }
+
+                            StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
+                                try {
+                                    Logger.i(TAG, "Started backfill");
+                                    args.processHandle.fullyBackfillServersAnnounceExceptions();
+                                    Logger.i(TAG, "Finished backfill");
+                                } catch (e: Throwable) {
+                                    Logger.e(TAG, "Failed to backfill servers", e)
+                                }
+                            }
+
+                            StatePolycentric.instance.updateLikeMap(ref, args.hasLiked, args.hasDisliked)
+                        };
+                    }
+                } catch (e: Throwable) {
+                    Logger.e(TAG, "Failed to get polycentric likes/dislikes.", e);
+                    _rating.visibility = View.GONE;
+                }
+            }
+        }
+
+        private fun setPlatformRating(rating: IRating?) {
+            if (rating == null) {
+                _layoutRating.visibility = View.GONE;
+                return;
+            }
+
+            _layoutRating.visibility = View.VISIBLE;
+
+            when (rating) {
+                is RatingLikeDislikes -> {
+                    _textLikes.visibility = View.VISIBLE;
+                    _imageLikeIcon.visibility = View.VISIBLE;
+                    _textLikes.text = rating.likes.toHumanNumber();
+
+                    _imageDislikeIcon.visibility = View.VISIBLE;
+                    _textDislikes.visibility = View.VISIBLE;
+                    _textDislikes.text = rating.dislikes.toHumanNumber();
+                }
+                is RatingLikes -> {
+                    _textLikes.visibility = View.VISIBLE;
+                    _imageLikeIcon.visibility = View.VISIBLE;
+                    _textLikes.text = rating.likes.toHumanNumber();
+
+                    _imageDislikeIcon.visibility = View.GONE;
+                    _textDislikes.visibility = View.GONE;
+                }
+                else -> {
+                    _textLikes.visibility = View.GONE;
+                    _imageLikeIcon.visibility = View.GONE;
+                    _imageDislikeIcon.visibility = View.GONE;
+                    _textDislikes.visibility = View.GONE;
+                }
+            }
+        }
+
+        fun applyFragment(frag: ArticleDetailFragment): ArticleDetailView {
+            _fragment = frag;
+            return this;
+        }
+
+        fun clear() {
+            _commentsList.cancel();
+            _taskLoadPost.cancel();
+            _taskLoadPolycentricProfile.cancel();
+            _version++;
+
+            updateCommentType(null)
+            _url = null;
+            _article = null;
+            _articleOverview = null;
+            _creatorThumbnail.clear();
+            //_buttonSubscribe.setSubscribeChannel(null); TODO: clear button
+            _channelName.text = "";
+            setChannelMeta(null);
+            _textTitle.text = "";
+            _textMeta.text = "";
+            setPlatformRating(null);
+            _polycentricProfile = null;
+            _rating.visibility = View.GONE;
+            updatePolycentricRating();
+            setRepliesOverlayVisible(isVisible = false, animate = false);
+
+            _containerSegments.removeAllViews();
+
+            _addCommentView.setContext(null, null);
+            _platformIndicator.clearPlatform();
+        }
+
+        fun setArticleDetails(value: IPlatformArticleDetails) {
+            _url = value.url;
+            _article = value;
+
+            _creatorThumbnail.setThumbnail(value.author.thumbnail, false);
+            _buttonSubscribe.setSubscribeChannel(value.author.url);
+            _channelName.text = value.author.name;
+            setChannelMeta(value);
+            _textTitle.text = value.name;
+            _textMeta.text = value.datetime?.toHumanNowDiffString()?.let { "$it ago" } ?: "" //TODO: Include view count?
+
+            _textSummary.text = value.summary
+            _textSummary.isVisible = !value.summary.isNullOrEmpty()
+
+            _platformIndicator.setPlatformFromClientID(value.id.pluginId);
+            setPlatformRating(value.rating);
+
+            for(seg in value.segments) {
+                when(seg.type) {
+                    SegmentType.TEXT -> {
+                        if(seg is JSTextSegment) {
+                            _containerSegments.addView(ArticleTextBlock(context, seg.content, seg.textType))
+                        }
+                    }
+                    SegmentType.IMAGES -> {
+                        if(seg is JSImagesSegment) {
+                            if(seg.images.size > 0)
+                                _containerSegments.addView(ArticleImageBlock(context, seg.images[0], seg.caption))
+                        }
+                    }
+                    SegmentType.NESTED -> {
+                        if(seg is JSNestedSegment) {
+                            _containerSegments.addView(ArticleContentBlock(context, seg.nested, _fragment, _overlayContainer));
+                        }
+                    }
+                    else ->{}
+                }
+            }
+
+            //Fetch only when not already called in setPostOverview
+            if (_articleOverview == null) {
+                fetchPolycentricProfile();
+                updatePolycentricRating();
+                _addCommentView.setContext(value.url, Models.referenceFromBuffer(value.url.toByteArray()));
+            }
+
+            val commentType = !Settings.instance.other.polycentricEnabled || Settings.instance.comments.defaultCommentSection == 1
+            updateCommentType(commentType, true);
+            setLoading(false);
+        }
+
+        fun setArticleOverview(value: IPlatformArticle) {
+            clear();
+            _url = value.url;
+            _articleOverview = value;
+
+            _creatorThumbnail.setThumbnail(value.author.thumbnail, false);
+            _buttonSubscribe.setSubscribeChannel(value.author.url);
+            _channelName.text = value.author.name;
+            setChannelMeta(value);
+            _textTitle.text = value.name;
+            _textMeta.text = value.datetime?.toHumanNowDiffString()?.let { "$it ago" } ?: "" //TODO: Include view count?
+
+            _platformIndicator.setPlatformFromClientID(value.id.pluginId);
+            _addCommentView.setContext(value.url, Models.referenceFromBuffer(value.url.toByteArray()));
+
+            updatePolycentricRating();
+            fetchPolycentricProfile();
+            fetchPost();
+        }
+
+
+        private fun setRepliesOverlayVisible(isVisible: Boolean, animate: Boolean) {
+            if (_isRepliesVisible == isVisible) {
+                return;
+            }
+
+            _isRepliesVisible = isVisible;
+            _repliesAnimator?.cancel();
+
+            if (isVisible) {
+                _repliesOverlay.visibility = View.VISIBLE;
+
+                if (animate) {
+                    _repliesOverlay.translationY = _repliesOverlay.height.toFloat();
+
+                    _repliesAnimator = _repliesOverlay.animate()
+                        .setDuration(300)
+                        .translationY(0f)
+                        .withEndAction {
+                            _repliesAnimator = null;
+                        }.apply { start() };
+                }
+            } else {
+                if (animate) {
+                    _repliesOverlay.translationY = 0f;
+
+                    _repliesAnimator = _repliesOverlay.animate()
+                        .setDuration(300)
+                        .translationY(_repliesOverlay.height.toFloat())
+                        .withEndAction {
+                            _repliesOverlay.visibility = GONE;
+                            _repliesAnimator = null;
+                        }.apply { start(); }
+                } else {
+                    _repliesOverlay.visibility = View.GONE;
+                    _repliesOverlay.translationY = _repliesOverlay.height.toFloat();
+                }
+            }
+        }
+
+        private fun fetchPolycentricProfile() {
+            val author = _article?.author ?: _articleOverview?.author ?: return;
+                setPolycentricProfile(null, animate = false);
+                _taskLoadPolycentricProfile.run(author.id);
+        }
+
+        private fun setChannelMeta(value: IPlatformArticle?) {
+            val subscribers = value?.author?.subscribers;
+            if(subscribers != null && subscribers > 0) {
+                _channelMeta.visibility = View.VISIBLE;
+                _channelMeta.text = if((value.author.subscribers ?: 0) > 0) value.author.subscribers!!.toHumanNumber() + " " + context.getString(R.string.subscribers) else "";
+            } else {
+                _channelMeta.visibility = View.GONE;
+                _channelMeta.text = "";
+            }
+        }
+
+        fun setPostUrl(url: String) {
+            clear();
+            _url = url;
+            fetchPost();
+        }
+
+        fun onDestroy() {
+            _commentsList.cancel();
+            _taskLoadPost.cancel();
+            _repliesOverlay.cleanup();
+        }
+
+        private fun setPolycentricProfile(polycentricProfile: PolycentricProfile?, animate: Boolean) {
+            _polycentricProfile = polycentricProfile;
+
+            val pp = _polycentricProfile;
+            if (pp == null) {
+                _creatorThumbnail.setHarborAvailable(false, animate, null);
+                return;
+            }
+
+            _creatorThumbnail.setHarborAvailable(true, animate, pp.system.toProto());
+        }
+
+        private fun fetchPost() {
+            Logger.i(TAG, "fetchVideo")
+            _article = null;
+
+            val url = _url;
+            if (!url.isNullOrBlank()) {
+                setLoading(true);
+                _taskLoadPost.run(url);
+            }
+        }
+
+        private fun fetchComments() {
+            Logger.i(TAG, "fetchComments")
+            _article?.let {
+                _commentsList.load(true) { StatePlatform.instance.getComments(it); };
+            }
+        }
+
+        private fun fetchPolycentricComments() {
+            Logger.i(TAG, "fetchPolycentricComments")
+            val post = _article;
+            val ref = (_article?.url ?: _articleOverview?.url)?.toByteArray()?.let { Models.referenceFromBuffer(it) }
+            val extraBytesRef = (_article?.id?.value ?: _articleOverview?.id?.value)?.let { if (it.isNotEmpty()) it.toByteArray() else null }
+
+            if (ref == null) {
+                Logger.w(TAG, "Failed to fetch polycentric comments because url was not set null")
+                _commentsList.clear();
+                return
+            }
+
+            _commentsList.load(false) { StatePolycentric.instance.getCommentPager(post!!.url, ref, listOfNotNull(extraBytesRef)); };
+        }
+
+        private fun updateCommentType(commentType: Boolean?, forceReload: Boolean = false) {
+            val changed = commentType != _commentType
+            _commentType = commentType
+
+            if (commentType == null) {
+                _buttonPlatform.setTextColor(resources.getColor(R.color.gray_ac))
+                _buttonPolycentric.setTextColor(resources.getColor(R.color.gray_ac))
+            } else {
+                _buttonPlatform.setTextColor(resources.getColor(if (commentType) R.color.white else R.color.gray_ac))
+                _buttonPolycentric.setTextColor(resources.getColor(if (!commentType) R.color.white else R.color.gray_ac))
+
+                if (commentType) {
+                    _addCommentView.visibility = View.GONE;
+
+                    if (forceReload || changed) {
+                        fetchComments();
+                    }
+                } else {
+                    _addCommentView.visibility = View.VISIBLE;
+
+                    if (forceReload || changed) {
+                        fetchPolycentricComments()
+                    }
+                }
+            }
+        }
+
+        private fun setLoading(isLoading : Boolean) {
+            if (_isLoading == isLoading) {
+                return;
+            }
+
+            _isLoading = isLoading;
+
+            if(isLoading) {
+                (_imageLoader.drawable as Animatable?)?.start()
+                _layoutLoadingOverlay.visibility = View.VISIBLE;
+            }
+            else {
+                _layoutLoadingOverlay.visibility = View.GONE;
+                (_imageLoader.drawable as Animatable?)?.stop()
+            }
+        }
+
+        class ArticleTextBlock : LinearLayout {
+            constructor(context: Context?, content: String, textType: TextType) : super(context){
+                inflate(context, R.layout.view_segment_text, this);
+
+                findViewById<TextView>(R.id.text_content)?.let {
+                    if(textType == TextType.HTML)
+                        it.text = Html.fromHtml(content, Html.FROM_HTML_MODE_COMPACT);
+                    else if(textType == TextType.CODE) {
+                        it.text = content;
+                        it.setPadding(15.dp(resources));
+                        it.setHorizontallyScrolling(true);
+                        it.movementMethod = ScrollingMovementMethod();
+                        it.setTypeface(Typeface.MONOSPACE);
+                        it.setBackgroundResource(R.drawable.background_videodetail_description)
+                    }
+                    else
+                        it.text = content;
+                }
+            }
+        }
+        class ArticleImageBlock: LinearLayout {
+            constructor(context: Context?, image: String, caption: String? = null) : super(context){
+                inflate(context, R.layout.view_segment_image, this);
+
+                findViewById<ImageView>(R.id.image_content)?.let {
+                    Glide.with(it)
+                        .load(image)
+                        .crossfade()
+                        .into(it);
+                }
+                findViewById<TextView>(R.id.text_content)?.let {
+                    if(caption?.isNullOrEmpty() == true)
+                        it.isVisible = false;
+                    else
+                        it.text = caption;
+                }
+            }
+        }
+        class ArticleContentBlock: LinearLayout {
+            constructor(context: Context, content: IPlatformContent?, fragment: ArticleDetailFragment? = null, overlayContainer: FrameLayout? = null): super(context) {
+                if(content != null) {
+                    var view: View? = null;
+                    if(content is IPlatformNestedContent) {
+                        view = PreviewNestedVideoView(context, FeedStyle.THUMBNAIL, null);
+                        view.bind(content);
+                        view.onContentUrlClicked.subscribe { a,b -> }
+                    }
+                    else if(content is IPlatformVideo) {
+                        view = PreviewVideoView(context, FeedStyle.THUMBNAIL, null, true);
+                        view.bind(content);
+                        view.onVideoClicked.subscribe { a,b -> fragment?.navigate<VideoDetailFragment>(a) }
+                        view.onChannelClicked.subscribe { a -> fragment?.navigate<ChannelFragment>(a) }
+                        if(overlayContainer != null) {
+                            view.onAddToClicked.subscribe { a -> UISlideOverlays.showVideoOptionsOverlay(a, overlayContainer) };
+                        }
+                        view.onAddToQueueClicked.subscribe { a -> StatePlayer.instance.addToQueue(a) }
+                        view.onAddToWatchLaterClicked.subscribe { a ->
+                            if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(content), true))
+                                UIDialogs.toast("Added to watch later\n[${content.name}]")
+                        }
+                    }
+                    else if(content is IPlatformPost) {
+                        view = PreviewPostView(context, FeedStyle.THUMBNAIL);
+                        view.bind(content);
+                        view.onContentClicked.subscribe { a -> fragment?.navigate<PostDetailFragment>(a) }
+                        view.onChannelClicked.subscribe { a -> fragment?.navigate<ChannelFragment>(a) }
+                    }
+                    else if(content is IPlatformArticle) {
+                        view = PreviewPostView(context, FeedStyle.THUMBNAIL);
+                        view.bind(content);
+                        view.onContentClicked.subscribe { a -> fragment?.navigate<ArticleDetailFragment>(a) }
+                        view.onChannelClicked.subscribe { a -> fragment?.navigate<ChannelFragment>(a) }
+                    }
+                    else if(content is IPlatformLockedContent) {
+                        view = PreviewLockedView(context, FeedStyle.THUMBNAIL);
+                        view.bind(content);
+                    }
+                    if(view != null)
+                        addView(view);
+                }
+            }
+        }
+
+
+        companion object {
+            const val TAG = "PostDetailFragment"
+        }
+    }
+
+    companion object {
+        fun newInstance() = ArticleDetailFragment().apply {}
+    }
+}

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/ChannelFragment.kt

@@ -47,6 +47,7 @@ import com.futo.platformplayer.selectHighestResolutionImage
 import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.states.StatePlayer
 import com.futo.platformplayer.states.StatePlaylists
+import com.futo.platformplayer.states.StatePolycentric
 import com.futo.platformplayer.states.StateSubscriptions
 import com.futo.platformplayer.toHumanNumber
 import com.futo.platformplayer.views.adapters.ChannelTab
@@ -135,6 +136,8 @@ class ChannelFragment : MainFragment() {
             inflater.inflate(R.layout.fragment_channel, this)
             _taskLoadPolycentricProfile = TaskHandler<PlatformID, PolycentricProfile?>({ fragment.lifecycleScope },
                     { id ->
+                        if (!StatePolycentric.instance.enabled)
+                            return@TaskHandler null
                         return@TaskHandler ApiMethods.getPolycentricProfileByClaim(ApiMethods.SERVER, ApiMethods.FUTO_TRUST_ROOT, id.claimFieldType.toLong(), id.claimType.toLong(), id.value!!)
                     }).success { setPolycentricProfile(it, animate = true) }.exception<Throwable> {
                     Logger.w(TAG, "Failed to load polycentric profile.", it)
@@ -422,17 +425,15 @@ class ChannelFragment : MainFragment() {
             _fragment.lifecycleScope.launch(Dispatchers.IO) {
                 val plugin = StatePlatform.instance.getChannelClientOrNull(channel.url)
                 withContext(Dispatchers.Main) {
-                    if (plugin != null && plugin.capabilities.hasSearchChannelContents) {
-                        buttons.add(Pair(R.drawable.ic_search) {
-                            _fragment.navigate<SuggestionsFragment>(
-                                SuggestionsFragmentData(
-                                    "", SearchType.VIDEO, channel.url
-                                )
+                    buttons.add(Pair(R.drawable.ic_search) {
+                        _fragment.navigate<SuggestionsFragment>(
+                            SuggestionsFragmentData(
+                                "", SearchType.VIDEO
                             )
-                        })
+                        )
+                    })
+                    _fragment.topBar?.assume<NavigationTopBarFragment>()?.setMenuItems(buttons)
 
-                        _fragment.topBar?.assume<NavigationTopBarFragment>()?.setMenuItems(buttons)
-                    }
                     if(plugin != null && plugin.capabilities.hasGetChannelCapabilities) {
                         if(plugin.getChannelCapabilities()?.types?.contains(ResultCapabilities.TYPE_SHORTS) ?: false &&
                             !(_viewPager.adapter as ChannelViewPagerAdapter).containsItem(ChannelTab.SHORTS.ordinal.toLong())) {

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/ContentFeedView.kt

@@ -10,12 +10,14 @@ import com.futo.platformplayer.R
 import com.futo.platformplayer.Settings
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.UISlideOverlays
+import com.futo.platformplayer.api.media.models.article.IPlatformArticle
 import com.futo.platformplayer.api.media.models.contents.ContentType
 import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.models.playlists.IPlatformPlaylist
 import com.futo.platformplayer.api.media.models.post.IPlatformPost
 import com.futo.platformplayer.api.media.models.video.IPlatformVideo
 import com.futo.platformplayer.api.media.models.video.SerializedPlatformVideo
+import com.futo.platformplayer.api.media.platforms.js.models.JSWeb
 import com.futo.platformplayer.api.media.structures.IPager
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateMeta
@@ -196,16 +198,24 @@ abstract class ContentFeedView<TFragment> : FeedView<TFragment, IPlatformContent
             fragment.navigate<RemotePlaylistFragment>(content);
         } else if (content is IPlatformPost) {
             fragment.navigate<PostDetailFragment>(content);
+        } else if(content is IPlatformArticle) {
+            fragment.navigate<ArticleDetailFragment>(content);
         }
+        else if(content is JSWeb) {
+            fragment.navigate<WebDetailFragment>(content);
+        }
+        else
+            UIDialogs.appToast("Unknown content type [" + content.contentType.name + "]");
     }
     protected open fun onContentUrlClicked(url: String, contentType: ContentType) {
         when(contentType) {
             ContentType.MEDIA -> {
-                StatePlayer.instance.clearQueue();
-                fragment.navigate<VideoDetailFragment>(url).maximizeVideoDetail();
-            };
-            ContentType.PLAYLIST -> fragment.navigate<RemotePlaylistFragment>(url);
-            ContentType.URL -> fragment.navigate<BrowserFragment>(url);
+                StatePlayer.instance.clearQueue()
+                fragment.navigate<VideoDetailFragment>(url).maximizeVideoDetail()
+            }
+            ContentType.PLAYLIST -> fragment.navigate<RemotePlaylistFragment>(url)
+            ContentType.URL -> fragment.navigate<BrowserFragment>(url)
+            ContentType.CHANNEL -> fragment.navigate<ChannelFragment>(url)
             else -> {};
         }
     }

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/ContentSearchResultsFragment.kt

@@ -2,14 +2,18 @@ package com.futo.platformplayer.fragment.mainactivity.main
 
 import android.annotation.SuppressLint
 import android.os.Bundle
+import android.util.AttributeSet
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.core.view.allViews
 import androidx.lifecycle.lifecycleScope
 import com.futo.platformplayer.Settings
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.UISlideOverlays
+import com.futo.platformplayer.activities.MainActivity
 import com.futo.platformplayer.api.media.models.ResultCapabilities
+import com.futo.platformplayer.api.media.models.contents.ContentType
 import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.structures.IPager
 import com.futo.platformplayer.constructs.TaskHandler
@@ -17,9 +21,12 @@ import com.futo.platformplayer.engine.exceptions.ScriptCaptchaRequiredException
 import com.futo.platformplayer.fragment.mainactivity.topbar.SearchTopBarFragment
 import com.futo.platformplayer.isHttpUrl
 import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.models.SearchType
 import com.futo.platformplayer.states.StateMeta
 import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.views.FeedStyle
+import com.futo.platformplayer.views.ToggleBar
+import com.futo.platformplayer.views.others.RadioGroupView
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -82,7 +89,7 @@ class ContentSearchResultsFragment : MainFragment() {
         private var _sortBy: String? = null;
         private var _filterValues: HashMap<String, List<String>> = hashMapOf();
         private var _enabledClientIds: List<String>? = null;
-        private var _channelUrl: String? = null;
+        private var _searchType: SearchType? = null;
 
         private val _taskSearch: TaskHandler<String, IPager<IPlatformContent>>;
         override val shouldShowTimeBar: Boolean get() = Settings.instance.search.progressBar
@@ -90,11 +97,12 @@ class ContentSearchResultsFragment : MainFragment() {
         constructor(fragment: ContentSearchResultsFragment, inflater: LayoutInflater) : super(fragment, inflater) {
             _taskSearch = TaskHandler<String, IPager<IPlatformContent>>({fragment.lifecycleScope}, { query ->
                 Logger.i(TAG, "Searching for: $query")
-                val channelUrl = _channelUrl;
-                if (channelUrl != null) {
-                    StatePlatform.instance.searchChannel(channelUrl, query, null, _sortBy, _filterValues, _enabledClientIds)
-                } else {
-                    StatePlatform.instance.searchRefresh(fragment.lifecycleScope, query, null, _sortBy, _filterValues, _enabledClientIds)
+                when (_searchType)
+                {
+                    SearchType.VIDEO -> StatePlatform.instance.searchRefresh(fragment.lifecycleScope, query, null, _sortBy, _filterValues, _enabledClientIds)
+                    SearchType.CREATOR -> StatePlatform.instance.searchChannelsAsContent(query)
+                    SearchType.PLAYLIST -> StatePlatform.instance.searchPlaylist(query)
+                    else -> throw Exception("Search type must be specified")
                 }
             })
             .success { loadedResult(it); }.exception<ScriptCaptchaRequiredException> {  }
@@ -104,6 +112,25 @@ class ContentSearchResultsFragment : MainFragment() {
             }
 
             setPreviewsEnabled(Settings.instance.search.previewFeedItems);
+
+            initializeToolbar();
+        }
+
+        fun initializeToolbar(){
+            if(_toolbarContentView.allViews.any { it is RadioGroupView })
+                _toolbarContentView.removeView(_toolbarContentView.allViews.find { it is RadioGroupView });
+
+            val radioGroup = RadioGroupView(context);
+            radioGroup.onSelectedChange.subscribe {
+
+                if (it.size != 1)
+                    setSearchType(SearchType.VIDEO);
+                else
+                setSearchType((it[0] ?: SearchType.VIDEO) as SearchType);
+            }
+            radioGroup?.setOptions(listOf(Pair("Media", SearchType.VIDEO), Pair("Creators", SearchType.CREATOR), Pair("Playlists", SearchType.PLAYLIST)), listOf(_searchType), false, true)
+
+            _toolbarContentView.addView(radioGroup);
         }
 
         override fun cleanup() {
@@ -114,7 +141,7 @@ class ContentSearchResultsFragment : MainFragment() {
         fun onShown(parameter: Any?) {
             if(parameter is SuggestionsFragmentData) {
                 setQuery(parameter.query, false);
-                setChannelUrl(parameter.channelUrl, false);
+                setSearchType(parameter.searchType, false)
 
                 fragment.topBar?.apply {
                     if (this is SearchTopBarFragment) {
@@ -130,7 +157,7 @@ class ContentSearchResultsFragment : MainFragment() {
                     onFilterClick.subscribe(this) {
                         _overlayContainer.let {
                             val filterValuesCopy = HashMap(_filterValues);
-                            val filtersOverlay = UISlideOverlays.showFiltersOverlay(lifecycleScope, it, _enabledClientIds!!, filterValuesCopy, _channelUrl != null);
+                            val filtersOverlay = UISlideOverlays.showFiltersOverlay(lifecycleScope, it, _enabledClientIds!!, filterValuesCopy);
                             filtersOverlay.onOK.subscribe { enabledClientIds, changed ->
                                 if (changed) {
                                     setFilterValues(filtersOverlay.commonCapabilities, filterValuesCopy);
@@ -160,8 +187,14 @@ class ContentSearchResultsFragment : MainFragment() {
                                 navigate<RemotePlaylistFragment>(it);
                             else if(StatePlatform.instance.hasEnabledChannelClient(it))
                                 navigate<ChannelFragment>(it);
-                            else
-                                navigate<VideoDetailFragment>(it);
+                            else {
+                                val url = it;
+                                activity?.let {
+                                    close()
+                                    if(it is MainActivity)
+                                        it.navigate(it.getFragment<VideoDetailFragment>(), url);
+                                }
+                            }
                         }
                         else
                             setQuery(it, true);
@@ -171,11 +204,7 @@ class ContentSearchResultsFragment : MainFragment() {
 
             fragment.lifecycleScope.launch(Dispatchers.IO) {
                 try {
-                    val commonCapabilities =
-                        if(_channelUrl == null)
-                            StatePlatform.instance.getCommonSearchCapabilities(StatePlatform.instance.getEnabledClients().map { it.id });
-                        else
-                            StatePlatform.instance.getCommonSearchChannelContentsCapabilities(StatePlatform.instance.getEnabledClients().map { it.id });
+                    val commonCapabilities = StatePlatform.instance.getCommonSearchCapabilities(StatePlatform.instance.getEnabledClients().map { it.id });
                     val sorts = commonCapabilities?.sorts ?: listOf();
                     if (sorts.size > 1) {
                         withContext(Dispatchers.Main) {
@@ -242,8 +271,8 @@ class ContentSearchResultsFragment : MainFragment() {
             }
         }
 
-        private fun setChannelUrl(channelUrl: String?, updateResults: Boolean = true) {
-            _channelUrl = channelUrl;
+        private fun setSearchType(searchType: SearchType, updateResults: Boolean = true) {
+            _searchType = searchType
 
             if (updateResults) {
                 clearResults();

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/DownloadsFragment.kt

@@ -14,13 +14,19 @@ import androidx.core.widget.addTextChangedListener
 import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.RecyclerView
 import com.futo.platformplayer.R
+import com.futo.platformplayer.Settings
+import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.downloads.VideoDownload
 import com.futo.platformplayer.downloads.VideoLocal
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.models.Playlist
+import com.futo.platformplayer.services.DownloadService
+import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StateDownloads
 import com.futo.platformplayer.states.StatePlayer
 import com.futo.platformplayer.states.StatePlaylists
+import com.futo.platformplayer.stores.FragmentedStorage
+import com.futo.platformplayer.stores.StringStorage
 import com.futo.platformplayer.toHumanBytesSize
 import com.futo.platformplayer.toHumanDuration
 import com.futo.platformplayer.views.AnyInsertedAdapterView
@@ -52,6 +58,15 @@ class DownloadsFragment : MainFragment() {
         super.onResume()
         _view?.reloadUI();
 
+        if(StateDownloads.instance.getDownloading().any { it.state == VideoDownload.State.QUEUED } &&
+            !StateDownloads.instance.getDownloading().any { it.state == VideoDownload.State.DOWNLOADING } &&
+            Settings.instance.downloads.shouldDownload()) {
+            Logger.w(TAG, "Detected queued download, while not downloading, attempt recreating service");
+            StateApp.withContext {
+                DownloadService.getOrCreateService(it);
+            }
+        }
+
         StateDownloads.instance.onDownloadsChanged.subscribe(this) {
             lifecycleScope.launch(Dispatchers.Main) {
                 try {
@@ -103,12 +118,15 @@ class DownloadsFragment : MainFragment() {
         private val _listDownloaded: AnyInsertedAdapterView<VideoLocal, VideoDownloadViewHolder>;
 
         private var lastDownloads: List<VideoLocal>? = null;
-        private var ordering: String? = "nameAsc";
+        private var ordering = FragmentedStorage.get<StringStorage>("downloads_ordering")
 
         constructor(frag: DownloadsFragment, inflater: LayoutInflater): super(frag.requireContext()) {
             inflater.inflate(R.layout.fragment_downloads, this);
             _frag = frag;
 
+            if(ordering.value.isNullOrBlank())
+                ordering.value = "nameAsc";
+
             _usageUsed = findViewById(R.id.downloads_usage_used);
             _usageAvailable = findViewById(R.id.downloads_usage_available);
             _usageProgress = findViewById(R.id.downloads_usage_progress);
@@ -132,22 +150,23 @@ class DownloadsFragment : MainFragment() {
             spinnerSortBy.adapter = ArrayAdapter(context, R.layout.spinner_item_simple, resources.getStringArray(R.array.downloads_sortby_array)).also {
                 it.setDropDownViewResource(R.layout.spinner_dropdownitem_simple);
             };
-            spinnerSortBy.setSelection(0);
+            val options = listOf("nameAsc", "nameDesc", "downloadDateAsc", "downloadDateDesc", "releasedAsc", "releasedDesc");
             spinnerSortBy.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
                 override fun onItemSelected(parent: AdapterView<*>, view: View?, pos: Int, id: Long) {
                     when(pos) {
-                        0 -> ordering = "nameAsc"
-                        1 -> ordering = "nameDesc"
-                        2 -> ordering = "downloadDateAsc"
-                        3 -> ordering = "downloadDateDesc"
-                        4 -> ordering = "releasedAsc"
-                        5 -> ordering = "releasedDesc"
-                        else -> ordering = null
+                        0 -> ordering.setAndSave("nameAsc")
+                        1 -> ordering.setAndSave("nameDesc")
+                        2 -> ordering.setAndSave("downloadDateAsc")
+                        3 -> ordering.setAndSave("downloadDateDesc")
+                        4 -> ordering.setAndSave("releasedAsc")
+                        5 -> ordering.setAndSave("releasedDesc")
+                        else -> ordering.setAndSave("")
                     }
                     updateContentFilters()
                 }
                 override fun onNothingSelected(parent: AdapterView<*>?) = Unit
             };
+            spinnerSortBy.setSelection(Math.max(0, options.indexOf(ordering.value)));
 
             _listDownloaded = findViewById<RecyclerView>(R.id.list_downloaded)
                 .asAnyWithTop(findViewById(R.id.downloads_top)) {
@@ -229,9 +248,9 @@ class DownloadsFragment : MainFragment() {
         fun filterDownloads(vids: List<VideoLocal>): List<VideoLocal>{
             var vidsToReturn = vids;
             if(!_listDownloadSearch.text.isNullOrEmpty())
-                vidsToReturn = vids.filter { it.name.contains(_listDownloadSearch.text, true) };
-            if(!ordering.isNullOrEmpty()) {
-                vidsToReturn = when(ordering){
+                vidsToReturn = vids.filter { it.name.contains(_listDownloadSearch.text, true) || it.author.name.contains(_listDownloadSearch.text, true) };
+            if(!ordering.value.isNullOrEmpty()) {
+                vidsToReturn = when(ordering.value){
                     "downloadDateAsc" -> vidsToReturn.sortedBy { it.downloadDate ?: OffsetDateTime.MAX };
                     "downloadDateDesc" -> vidsToReturn.sortedByDescending { it.downloadDate ?: OffsetDateTime.MIN };
                     "nameAsc" -> vidsToReturn.sortedBy { it.name.lowercase() }

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/FeedView.kt

@@ -3,12 +3,15 @@ package com.futo.platformplayer.fragment.mainactivity.main
 import android.content.Context
 import android.content.res.Configuration
 import android.graphics.Color
+import android.util.DisplayMetrics
+import android.view.Display
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.*
 import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.GridLayoutManager
+import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import androidx.recyclerview.widget.RecyclerView.LayoutManager
 import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
@@ -20,6 +23,7 @@ import com.futo.platformplayer.constructs.Event1
 import com.futo.platformplayer.constructs.TaskHandler
 import com.futo.platformplayer.engine.exceptions.PluginException
 import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.views.FeedStyle
 import com.futo.platformplayer.views.others.ProgressBar
 import com.futo.platformplayer.views.others.TagsView
@@ -28,7 +32,9 @@ import com.futo.platformplayer.views.adapters.InsertedViewHolder
 import com.futo.platformplayer.views.announcements.AnnouncementView
 import kotlinx.coroutines.CancellationException
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
 import java.time.OffsetDateTime
 import kotlin.math.max
 
@@ -68,6 +74,7 @@ abstract class FeedView<TFragment, TResult, TConverted, TPager, TViewHolder> : L
 
     private val _scrollListener: RecyclerView.OnScrollListener;
     private var _automaticNextPageCounter = 0;
+    private val _automaticBackoff = arrayOf(0, 500, 1000, 1000, 2000, 5000, 5000, 5000);
 
     constructor(fragment: TFragment, inflater: LayoutInflater, cachedRecyclerData: RecyclerData<InsertedViewAdapterWithLoader<TViewHolder>, GridLayoutManager, TPager, TResult, TConverted, InsertedViewHolder<TViewHolder>>? = null) : super(inflater.context) {
         this.fragment = fragment;
@@ -182,29 +189,61 @@ abstract class FeedView<TFragment, TResult, TConverted, TPager, TViewHolder> : L
 
     private fun ensureEnoughContentVisible(filteredResults: List<TConverted>) {
         val canScroll = if (recyclerData.results.isEmpty()) false else {
+            val height = resources.displayMetrics.heightPixels;
+
             val layoutManager = recyclerData.layoutManager
             val firstVisibleItemPosition = layoutManager.findFirstVisibleItemPosition()
-
-            if (firstVisibleItemPosition != RecyclerView.NO_POSITION) {
-                val firstVisibleView = layoutManager.findViewByPosition(firstVisibleItemPosition)
-                val itemHeight = firstVisibleView?.height ?: 0
-                val occupiedSpace = recyclerData.results.size / recyclerData.layoutManager.spanCount * itemHeight
-                val recyclerViewHeight = _recyclerResults.height
-                Logger.i(TAG, "ensureEnoughContentVisible loadNextPage occupiedSpace=$occupiedSpace recyclerViewHeight=$recyclerViewHeight")
-                occupiedSpace >= recyclerViewHeight
+            val firstVisibleItemView = if(firstVisibleItemPosition != RecyclerView.NO_POSITION) layoutManager.findViewByPosition(firstVisibleItemPosition) else null;
+            val lastVisibleItemPosition = layoutManager.findLastCompletelyVisibleItemPosition();
+            val lastVisibleItemView = if(lastVisibleItemPosition != RecyclerView.NO_POSITION) layoutManager.findViewByPosition(lastVisibleItemPosition) else null;
+            val rows = if(recyclerData.layoutManager is GridLayoutManager) Math.max(1, recyclerData.results.size / recyclerData.layoutManager.spanCount) else 1;
+            val rowsHeight = (firstVisibleItemView?.height ?: 0) * rows;
+            if(lastVisibleItemView != null && lastVisibleItemPosition == (recyclerData.results.size - 1)) {
+                false;
+            }
+            else if (firstVisibleItemView != null && height != null && rowsHeight < height) {
+                false;
             } else {
-                false
+                true;
             }
         }
+
         Logger.i(TAG, "ensureEnoughContentVisible loadNextPage canScroll=$canScroll _automaticNextPageCounter=$_automaticNextPageCounter")
         if (!canScroll || filteredResults.isEmpty()) {
             _automaticNextPageCounter++
-            if(_automaticNextPageCounter <= 4)
-                loadNextPage()
+            if(_automaticNextPageCounter < _automaticBackoff.size) {
+                if(_automaticNextPageCounter > 0) {
+                    val automaticNextPageCounterSaved = _automaticNextPageCounter;
+                    fragment.lifecycleScope.launch(Dispatchers.Default) {
+                        val backoff = _automaticBackoff[Math.min(_automaticBackoff.size - 1, _automaticNextPageCounter)];
+
+                        withContext(Dispatchers.Main) {
+                            setLoading(true);
+                        }
+                        delay(backoff.toLong());
+                        if(automaticNextPageCounterSaved == _automaticNextPageCounter) {
+                            withContext(Dispatchers.Main) {
+                                loadNextPage();
+                            }
+                        }
+                        else {
+                            withContext(Dispatchers.Main) {
+                                setLoading(false);
+                            }
+                        }
+                    }
+                }
+                else
+                    loadNextPage();
+            }
         } else {
+            Logger.i(TAG, "ensureEnoughContentVisible automaticNextPageCounter reset");
             _automaticNextPageCounter = 0;
         }
     }
+    fun resetAutomaticNextPageCounter(){
+        _automaticNextPageCounter = 0;
+    }
 
     protected fun setTextCentered(text: String?) {
         _textCentered.text = text;

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/HistoryFragment.kt

@@ -15,6 +15,8 @@ import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.futo.platformplayer.*
+import com.futo.platformplayer.api.media.models.video.IPlatformVideo
+import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.api.media.structures.IAsyncPager
 import com.futo.platformplayer.api.media.structures.IPager
 import com.futo.platformplayer.constructs.TaskHandler
@@ -22,10 +24,14 @@ import com.futo.platformplayer.fragment.mainactivity.topbar.NavigationTopBarFrag
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.models.HistoryVideo
 import com.futo.platformplayer.states.StateHistory
+import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.states.StatePlayer
+import com.futo.platformplayer.states.StatePlugins
+import com.futo.platformplayer.views.ToggleBar
 import com.futo.platformplayer.views.adapters.HistoryListViewHolder
 import com.futo.platformplayer.views.adapters.InsertedViewAdapterWithLoader
 import com.futo.platformplayer.views.others.TagsView
+import com.futo.platformplayer.views.others.Toggle
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
@@ -68,6 +74,8 @@ class HistoryFragment : MainFragment() {
         private var _pager: IPager<HistoryVideo>? = null;
         private val _results = arrayListOf<HistoryVideo>();
         private var _loading = false;
+        private val _toggleBar: ToggleBar
+        private var _togglePluginsDisabled = hashSetOf<String>()
 
         private var _automaticNextPageCounter = 0;
 
@@ -79,6 +87,7 @@ class HistoryFragment : MainFragment() {
             _clearSearch = findViewById(R.id.button_clear_search);
             _editSearch = findViewById(R.id.edit_search);
             _tagsView = findViewById(R.id.tags_text);
+            _toggleBar = findViewById(R.id.toggle_bar)
             _tagsView.setPairs(listOf(
                 Pair(context.getString(R.string.last_hour), 60L),
                 Pair(context.getString(R.string.last_24_hours), 24L * 60L),
@@ -88,6 +97,22 @@ class HistoryFragment : MainFragment() {
                 Pair(context.getString(R.string.all_time), -1L)
             ));
 
+            val toggles = StatePlatform.instance.getEnabledClients()
+                .filter { it is JSClient }
+                .map { plugin ->
+                    val pluginName = plugin.name.lowercase()
+                    ToggleBar.Toggle(if(Settings.instance.home.showHomeFiltersPluginNames) pluginName else "", plugin.icon, !_togglePluginsDisabled.contains(plugin.id), { view, active ->
+                        if (active) {
+                            _togglePluginsDisabled.remove(plugin.id)
+                        } else {
+                            _togglePluginsDisabled.add(plugin.id)
+                        }
+
+                        filtersChanged()
+                    }).withTag("plugins")
+                }.toTypedArray()
+            _toggleBar.setToggles(*toggles)
+
             _adapter = InsertedViewAdapterWithLoader(context, arrayListOf(), arrayListOf(),
                 { _results.size },
                 { view, _ ->
@@ -162,14 +187,15 @@ class HistoryFragment : MainFragment() {
                 else
                     it.nextPage();
 
-                return@TaskHandler it.getResults();
+                return@TaskHandler filterResults(it.getResults());
             }).success {
                 setLoading(false);
 
                 val posBefore = _results.size;
-                _results.addAll(it);
-                _adapter.notifyItemRangeInserted(_adapter.childToParentPosition(posBefore), it.size);
-                ensureEnoughContentVisible(it)
+                val res = filterResults(it)
+                _results.addAll(res);
+                _adapter.notifyItemRangeInserted(_adapter.childToParentPosition(posBefore), res.size);
+                ensureEnoughContentVisible(res)
             }.exception<Throwable> {
                 Logger.w(TAG, "Failed to load next page.", it);
                 UIDialogs.showGeneralRetryErrorDialog(context, context.getString(R.string.failed_to_load_next_page), it, {
@@ -178,6 +204,10 @@ class HistoryFragment : MainFragment() {
             };
         }
 
+        private fun filtersChanged() {
+            updatePager()
+        }
+
         private fun updatePager() {
             val query = _editSearch.text.toString();
             if (_editSearch.text.isNotEmpty()) {
@@ -246,11 +276,22 @@ class HistoryFragment : MainFragment() {
             _adapter.setLoading(loading);
         }
 
+        private fun filterResults(a: List<HistoryVideo>): List<HistoryVideo> {
+            val enabledPluginIds = StatePlatform.instance.getEnabledClients().map { it.id }.toHashSet()
+            val disabledPluginIds = _togglePluginsDisabled.toHashSet()
+            return a.filter {
+                val pluginId = it.video.id.pluginId ?: StatePlatform.instance.getContentClientOrNull(it.video.url)?.id ?: return@filter false
+                if (!enabledPluginIds.contains(pluginId))
+                    return@filter false
+                return@filter !disabledPluginIds.contains(pluginId)
+            };
+        }
+
         private fun loadPagerInternal(pager: IPager<HistoryVideo>) {
             Logger.i(TAG, "Setting new internal pager on feed");
 
             _results.clear();
-            val toAdd = pager.getResults();
+            val toAdd = filterResults(pager.getResults())
             _results.addAll(toAdd);
             _adapter.notifyDataSetChanged();
             ensureEnoughContentVisible(toAdd)

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/HomeFragment.kt

@@ -5,29 +5,38 @@ import android.os.Bundle
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import androidx.core.view.allViews
 import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.GridLayoutManager
 import com.futo.platformplayer.*
+import com.futo.platformplayer.UISlideOverlays.Companion.showOrderOverlay
 import com.futo.platformplayer.activities.MainActivity
 import com.futo.platformplayer.api.media.models.contents.IPlatformContent
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.api.media.structures.EmptyPager
 import com.futo.platformplayer.api.media.structures.IPager
+import com.futo.platformplayer.api.media.structures.IRefreshPager
+import com.futo.platformplayer.api.media.structures.IReusablePager
+import com.futo.platformplayer.api.media.structures.ReusablePager
+import com.futo.platformplayer.api.media.structures.ReusableRefreshPager
 import com.futo.platformplayer.constructs.TaskHandler
 import com.futo.platformplayer.engine.exceptions.ScriptCaptchaRequiredException
 import com.futo.platformplayer.engine.exceptions.ScriptExecutionException
 import com.futo.platformplayer.engine.exceptions.ScriptImplementationException
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateApp
+import com.futo.platformplayer.states.StateHistory
 import com.futo.platformplayer.states.StateMeta
 import com.futo.platformplayer.states.StatePlatform
+import com.futo.platformplayer.states.StatePlugins
+import com.futo.platformplayer.stores.FragmentedStorage
+import com.futo.platformplayer.stores.StringArrayStorage
 import com.futo.platformplayer.views.FeedStyle
 import com.futo.platformplayer.views.NoResultsView
 import com.futo.platformplayer.views.ToggleBar
 import com.futo.platformplayer.views.adapters.ContentPreviewViewHolder
 import com.futo.platformplayer.views.adapters.InsertedViewAdapterWithLoader
 import com.futo.platformplayer.views.adapters.InsertedViewHolder
-import com.futo.platformplayer.views.announcements.AnnouncementView
 import com.futo.platformplayer.views.buttons.BigButton
 import kotlinx.coroutines.runBlocking
 import java.time.OffsetDateTime
@@ -39,6 +48,12 @@ class HomeFragment : MainFragment() {
 
     private var _view: HomeView? = null;
     private var _cachedRecyclerData: FeedView.RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null;
+    private var _cachedLastPager: IReusablePager<IPlatformContent>? = null
+
+    private var _toggleRecent = false;
+    private var _toggleWatched = false;
+    private var _togglePluginsDisabled = mutableListOf<String>();
+
 
     fun reloadFeed() {
         _view?.reloadFeed()
@@ -64,7 +79,7 @@ class HomeFragment : MainFragment() {
     }
 
     override fun onCreateMainView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
-        val view = HomeView(this, inflater, _cachedRecyclerData);
+        val view = HomeView(this, inflater, _cachedRecyclerData, _cachedLastPager);
         _view = view;
         return view;
     }
@@ -82,6 +97,7 @@ class HomeFragment : MainFragment() {
         val view = _view;
         if (view != null) {
             _cachedRecyclerData = view.recyclerData;
+            _cachedLastPager = view.lastPager;
             view.cleanup();
             _view = null;
         }
@@ -91,6 +107,7 @@ class HomeFragment : MainFragment() {
         _view?.setPreviewsEnabled(previewsEnabled && Settings.instance.home.previewFeedItems);
     }
 
+
     @SuppressLint("ViewConstructor")
     class HomeView : ContentFeedView<HomeFragment> {
         override val feedStyle: FeedStyle get() = Settings.instance.home.getHomeFeedStyle();
@@ -100,11 +117,22 @@ class HomeFragment : MainFragment() {
         private val _taskGetPager: TaskHandler<Boolean, IPager<IPlatformContent>>;
         override val shouldShowTimeBar: Boolean get() = Settings.instance.home.progressBar
 
-        constructor(fragment: HomeFragment, inflater: LayoutInflater, cachedRecyclerData: RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null) : super(fragment, inflater, cachedRecyclerData) {
+        var lastPager: IReusablePager<IPlatformContent>? = null;
+
+        constructor(fragment: HomeFragment, inflater: LayoutInflater, cachedRecyclerData: RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null, cachedLastPager: IReusablePager<IPlatformContent>? = null) : super(fragment, inflater, cachedRecyclerData) {
+            lastPager = cachedLastPager
             _taskGetPager = TaskHandler<Boolean, IPager<IPlatformContent>>({ fragment.lifecycleScope }, {
                 StatePlatform.instance.getHomeRefresh(fragment.lifecycleScope)
             })
-            .success { loadedResult(it); }
+            .success {
+                val wrappedPager = if(it is IRefreshPager)
+                    ReusableRefreshPager(it);
+                else
+                    ReusablePager(it);
+                lastPager = wrappedPager;
+                resetAutomaticNextPageCounter();
+                loadedResult(wrappedPager.getWindow());
+            }
             .exception<ScriptCaptchaRequiredException> {  }
             .exception<ScriptExecutionException> {
                 Logger.w(ChannelFragment.TAG, "Plugin failure.", it);
@@ -207,22 +235,94 @@ class HomeFragment : MainFragment() {
         }
 
         private val _filterLock = Object();
-        private var _toggleRecent = false;
+        private var _togglesConfig = FragmentedStorage.get<StringArrayStorage>("home_toggles");
         fun initializeToolbarContent() {
-            //Not stable enough with current viewport paging, doesn't work with less results, and reloads content instead of just re-filtering existing
-            /*
-            _toggleBar = ToggleBar(context).apply {
-                layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
-            }
-            synchronized(_filterLock) {
-                _toggleBar?.setToggles(
-                    //TODO: loadResults needs to be replaced with an internal reload of the current content
-                    ToggleBar.Toggle("Recent", _toggleRecent) { _toggleRecent = it; loadResults(false) }
-                )
-            }
+            if(_toolbarContentView.allViews.any { it is ToggleBar })
+                _toolbarContentView.removeView(_toolbarContentView.allViews.find { it is ToggleBar });
 
-            _toolbarContentView.addView(_toggleBar, 0);
-            */
+            if(Settings.instance.home.showHomeFilters) {
+
+                if (!_togglesConfig.any()) {
+                    _togglesConfig.set("today", "watched", "plugins");
+                    _togglesConfig.save();
+                }
+                _toggleBar = ToggleBar(context).apply {
+                    layoutParams =
+                        LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
+                }
+
+                synchronized(_filterLock) {
+                    var buttonsPlugins: List<ToggleBar.Toggle> = listOf()
+                    buttonsPlugins = (if (_togglesConfig.contains("plugins"))
+                        (StatePlatform.instance.getEnabledClients()
+                            .filter { it is JSClient && it.enableInHome }
+                            .map { plugin ->
+                                ToggleBar.Toggle(if(Settings.instance.home.showHomeFiltersPluginNames) plugin.name else "", plugin.icon, !fragment._togglePluginsDisabled.contains(plugin.id), { view, active ->
+                                    var dontSwap = false;
+                                    if (active) {
+                                        if (fragment._togglePluginsDisabled.contains(plugin.id))
+                                            fragment._togglePluginsDisabled.remove(plugin.id);
+                                    } else {
+                                        if (!fragment._togglePluginsDisabled.contains(plugin.id)) {
+                                            val enabledClients = StatePlatform.instance.getEnabledClients();
+                                            val availableAfterDisable = enabledClients.count { !fragment._togglePluginsDisabled.contains(it.id) && it.id != plugin.id };
+                                            if(availableAfterDisable > 0)
+                                                fragment._togglePluginsDisabled.add(plugin.id);
+                                            else {
+                                                UIDialogs.appToast("Home needs atleast 1 plugin active");
+                                                dontSwap = true;
+                                            }
+                                        }
+                                    }
+                                    if(!dontSwap)
+                                        reloadForFilters();
+                                    else {
+                                        view.setToggle(!active);
+                                    }
+                                }).withTag("plugins")
+                            })
+                    else listOf())
+                    val buttons = (listOf<ToggleBar.Toggle?>(
+                        (if (_togglesConfig.contains("today"))
+                            ToggleBar.Toggle("Today", fragment._toggleRecent) { view, active ->
+                                fragment._toggleRecent = active; reloadForFilters()
+                            }
+                                .withTag("today") else null),
+                        (if (_togglesConfig.contains("watched"))
+                            ToggleBar.Toggle("Unwatched", fragment._toggleWatched) { view, active ->
+                                fragment._toggleWatched = active; reloadForFilters()
+                            }
+                                .withTag("watched") else null),
+                    ).filterNotNull() + buttonsPlugins)
+                        .sortedBy { _togglesConfig.indexOf(it.tag ?: "") } ?: listOf()
+
+                    val buttonSettings = ToggleBar.Toggle("", R.drawable.ic_settings, true, { view, active ->
+                        showOrderOverlay(_overlayContainer,
+                            "Visible home filters",
+                            listOf(
+                                Pair("Plugins", "plugins"),
+                                Pair("Today", "today"),
+                                Pair("Watched", "watched")
+                            ),
+                            {
+                                val newArray = it.map { it.toString() }.toTypedArray();
+                                _togglesConfig.set(*(if (newArray.any()) newArray else arrayOf("none")));
+                                _togglesConfig.save();
+                                initializeToolbarContent();
+                            },
+                            "Select which toggles you want to see in order. You can also choose to hide filters in the Grayjay Settings"
+                        );
+                    }).asButton();
+
+                    val buttonsOrder = (buttons + listOf(buttonSettings)).toTypedArray();
+                    _toggleBar?.setToggles(*buttonsOrder);
+                }
+
+                _toolbarContentView.addView(_toggleBar, 0);
+            }
+        }
+        fun reloadForFilters() {
+            lastPager?.let { loadedResult(it.getWindow()) };
         }
 
         override fun filterResults(results: List<IPlatformContent>): List<IPlatformContent> {
@@ -232,7 +332,11 @@ class HomeFragment : MainFragment() {
                 if(StateMeta.instance.isCreatorHidden(it.author.url))
                     return@filter false;
 
-                if(_toggleRecent && (it.datetime?.getNowDiffHours() ?: 0) > 23) {
+                if(fragment._toggleRecent && (it.datetime?.getNowDiffHours() ?: 0) > 25)
+                    return@filter false;
+                if(fragment._toggleWatched && StateHistory.instance.isHistoryWatched(it.url, 0))
+                    return@filter false;
+                if(fragment._togglePluginsDisabled.any() && it.id.pluginId != null && fragment._togglePluginsDisabled.contains(it.id.pluginId)) {
                     return@filter false;
                 }
 

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/PlaylistFragment.kt

@@ -326,6 +326,10 @@ class PlaylistFragment : MainFragment() {
             playlist.videos = ArrayList(playlist.videos.filter { it != video });
             StatePlaylists.instance.createOrUpdatePlaylist(playlist);
         }
+
+        override fun onVideoOptions(video: IPlatformVideo) {
+            UISlideOverlays.showVideoOptionsOverlay(video, overlayContainer);
+        }
         override fun onVideoClicked(video: IPlatformVideo) {
             val playlist = _playlist;
             if (playlist != null) {

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/PlaylistsFragment.kt

@@ -6,12 +6,17 @@ import android.util.TypedValue
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
+import android.widget.AdapterView
+import android.widget.ArrayAdapter
+import android.widget.EditText
 import android.widget.FrameLayout
 import android.widget.ImageButton
 import android.widget.LinearLayout
+import android.widget.Spinner
 import android.widget.TextView
 import androidx.constraintlayout.widget.ConstraintLayout
 import androidx.coordinatorlayout.widget.CoordinatorLayout
+import androidx.core.widget.addTextChangedListener
 import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
@@ -21,11 +26,15 @@ import com.futo.platformplayer.api.media.models.video.IPlatformVideo
 import com.futo.platformplayer.models.Playlist
 import com.futo.platformplayer.states.StatePlayer
 import com.futo.platformplayer.states.StatePlaylists
+import com.futo.platformplayer.stores.FragmentedStorage
+import com.futo.platformplayer.stores.StringStorage
+import com.futo.platformplayer.views.SearchView
 import com.futo.platformplayer.views.adapters.*
 import com.futo.platformplayer.views.overlays.slideup.SlideUpMenuOverlay
 import com.google.android.material.appbar.AppBarLayout
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
+import java.time.OffsetDateTime
 
 
 class PlaylistsFragment : MainFragment() {
@@ -65,6 +74,7 @@ class PlaylistsFragment : MainFragment() {
         private val _fragment: PlaylistsFragment;
 
         var watchLater: ArrayList<IPlatformVideo> = arrayListOf();
+        var allPlaylists: ArrayList<Playlist> = arrayListOf();
         var playlists: ArrayList<Playlist> = arrayListOf();
         private var _appBar: AppBarLayout;
         private var _adapterWatchLater: VideoListHorizontalAdapter;
@@ -72,12 +82,20 @@ class PlaylistsFragment : MainFragment() {
         private var _layoutWatchlist: ConstraintLayout;
         private var _slideUpOverlay: SlideUpMenuOverlay? = null;
 
+        private var _listPlaylistsSearch: EditText;
+
+        private var _ordering = FragmentedStorage.get<StringStorage>("playlists_ordering")
+
+
         constructor(fragment: PlaylistsFragment, inflater: LayoutInflater) : super(inflater.context) {
             _fragment = fragment;
             inflater.inflate(R.layout.fragment_playlists, this);
 
+            _listPlaylistsSearch = findViewById(R.id.playlists_search);
+
             watchLater = ArrayList();
             playlists = ArrayList();
+            allPlaylists = ArrayList();
 
             val recyclerWatchLater = findViewById<RecyclerView>(R.id.recycler_watch_later);
 
@@ -105,6 +123,7 @@ class PlaylistsFragment : MainFragment() {
             buttonCreatePlaylist.setOnClickListener {
                 _slideUpOverlay = UISlideOverlays.showCreatePlaylistOverlay(findViewById<FrameLayout>(R.id.overlay_create_playlist)) {
                     val playlist = Playlist(it, arrayListOf());
+                    allPlaylists.add(0, playlist);
                     playlists.add(0, playlist);
                     StatePlaylists.instance.createOrUpdatePlaylist(playlist);
 
@@ -120,6 +139,35 @@ class PlaylistsFragment : MainFragment() {
             _appBar = findViewById(R.id.app_bar);
             _layoutWatchlist = findViewById(R.id.layout_watchlist);
 
+
+            _listPlaylistsSearch.addTextChangedListener {
+                updatePlaylistsFiltering();
+            }
+            val spinnerSortBy: Spinner = findViewById(R.id.spinner_sortby);
+            spinnerSortBy.adapter = ArrayAdapter(context, R.layout.spinner_item_simple, resources.getStringArray(R.array.playlists_sortby_array)).also {
+                it.setDropDownViewResource(R.layout.spinner_dropdownitem_simple);
+            };
+            val options = listOf("nameAsc", "nameDesc", "dateEditAsc", "dateEditDesc", "dateCreateAsc", "dateCreateDesc", "datePlayAsc", "datePlayDesc");
+            spinnerSortBy.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
+                override fun onItemSelected(parent: AdapterView<*>, view: View?, pos: Int, id: Long) {
+                    when(pos) {
+                        0 -> _ordering.setAndSave("nameAsc")
+                        1 -> _ordering.setAndSave("nameDesc")
+                        2 -> _ordering.setAndSave("dateEditAsc")
+                        3 -> _ordering.setAndSave("dateEditDesc")
+                        4 -> _ordering.setAndSave("dateCreateAsc")
+                        5 -> _ordering.setAndSave("dateCreateDesc")
+                        6 -> _ordering.setAndSave("datePlayAsc")
+                        7 -> _ordering.setAndSave("datePlayDesc")
+                        else -> _ordering.setAndSave("")
+                    }
+                    updatePlaylistsFiltering()
+                }
+                override fun onNothingSelected(parent: AdapterView<*>?) = Unit
+            };
+            spinnerSortBy.setSelection(Math.max(0, options.indexOf(_ordering.value)));
+
+
             findViewById<TextView>(R.id.text_view_all).setOnClickListener { _fragment.navigate<WatchLaterFragment>(context.getString(R.string.watch_later)); };
             StatePlaylists.instance.onWatchLaterChanged.subscribe(this) {
                 fragment.lifecycleScope.launch(Dispatchers.Main) {
@@ -134,10 +182,12 @@ class PlaylistsFragment : MainFragment() {
 
         @SuppressLint("NotifyDataSetChanged")
         fun onShown() {
+            allPlaylists.clear();
             playlists.clear()
-            playlists.addAll(
+            allPlaylists.addAll(
                 StatePlaylists.instance.getPlaylists().sortedByDescending { maxOf(it.datePlayed, it.dateUpdate, it.dateCreation) }
             );
+            playlists.addAll(filterPlaylists(allPlaylists));
             _adapterPlaylist.notifyDataSetChanged();
 
             updateWatchLater();
@@ -157,6 +207,32 @@ class PlaylistsFragment : MainFragment() {
             return false;
         }
 
+        private fun updatePlaylistsFiltering() {
+            val toFilter = allPlaylists ?: return;
+            playlists.clear();
+            playlists.addAll(filterPlaylists(toFilter));
+            _adapterPlaylist.notifyDataSetChanged();
+        }
+        private fun filterPlaylists(pls: List<Playlist>): List<Playlist> {
+            var playlistsToReturn = pls;
+            if(!_listPlaylistsSearch.text.isNullOrEmpty())
+                playlistsToReturn = playlistsToReturn.filter { it.name.contains(_listPlaylistsSearch.text, true) };
+            if(!_ordering.value.isNullOrEmpty()) {
+                playlistsToReturn = when(_ordering.value){
+                    "nameAsc" -> playlistsToReturn.sortedBy { it.name.lowercase() }
+                    "nameDesc" -> playlistsToReturn.sortedByDescending { it.name.lowercase() };
+                    "dateEditAsc" -> playlistsToReturn.sortedBy { it.dateUpdate ?: OffsetDateTime.MAX };
+                    "dateEditDesc" -> playlistsToReturn.sortedByDescending { it.dateUpdate ?: OffsetDateTime.MIN }
+                    "dateCreateAsc" -> playlistsToReturn.sortedBy { it.dateCreation ?: OffsetDateTime.MAX };
+                    "dateCreateDesc" -> playlistsToReturn.sortedByDescending { it.dateCreation ?: OffsetDateTime.MIN }
+                    "datePlayAsc" -> playlistsToReturn.sortedBy { it.datePlayed ?: OffsetDateTime.MAX };
+                    "datePlayDesc" -> playlistsToReturn.sortedByDescending { it.datePlayed ?: OffsetDateTime.MIN }
+                    else -> playlistsToReturn
+                }
+            }
+            return playlistsToReturn;
+        }
+
         private fun updateWatchLater() {
             val watchList = StatePlaylists.instance.getWatchLater();
             if (watchList.isNotEmpty()) {
@@ -164,7 +240,7 @@ class PlaylistsFragment : MainFragment() {
 
                 _appBar.let { appBar ->
                     val layoutParams: CoordinatorLayout.LayoutParams = appBar.layoutParams as CoordinatorLayout.LayoutParams;
-                    layoutParams.height = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 230.0f, resources.displayMetrics).toInt();
+                    layoutParams.height = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 315.0f, resources.displayMetrics).toInt();
                     appBar.layoutParams = layoutParams;
                 }
             } else {
@@ -172,7 +248,7 @@ class PlaylistsFragment : MainFragment() {
 
                 _appBar.let { appBar ->
                     val layoutParams: CoordinatorLayout.LayoutParams = appBar.layoutParams as CoordinatorLayout.LayoutParams;
-                    layoutParams.height = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 25.0f, resources.displayMetrics).toInt();
+                    layoutParams.height = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 110.0f, resources.displayMetrics).toInt();
                     appBar.layoutParams = layoutParams;
                 };
             }

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/PostDetailFragment.kt

@@ -168,7 +168,12 @@ class PostDetailFragment : MainFragment {
                 UIDialogs.showGeneralRetryErrorDialog(context, context.getString(R.string.failed_to_load_post), it, ::fetchPost, null, _fragment);
             } else TaskHandler(IPlatformPostDetails::class.java) { _fragment.lifecycleScope };
 
-        private val _taskLoadPolycentricProfile = TaskHandler<PlatformID, PolycentricProfile?>(StateApp.instance.scopeGetter, { ApiMethods.getPolycentricProfileByClaim(ApiMethods.SERVER, ApiMethods.FUTO_TRUST_ROOT, it.claimFieldType.toLong(), it.claimType.toLong(), it.value!!) })
+        private val _taskLoadPolycentricProfile = TaskHandler<PlatformID, PolycentricProfile?>(StateApp.instance.scopeGetter, {
+            if (!StatePolycentric.instance.enabled)
+                return@TaskHandler null
+
+            ApiMethods.getPolycentricProfileByClaim(ApiMethods.SERVER, ApiMethods.FUTO_TRUST_ROOT, it.claimFieldType.toLong(), it.claimType.toLong(), it.value!!)
+        })
             .success { it -> setPolycentricProfile(it, animate = true) }
             .exception<Throwable> {
                 Logger.w(TAG, "Failed to load claims.", it);
@@ -327,6 +332,10 @@ class PostDetailFragment : MainFragment {
             val version = _version;
 
             _rating.onLikeDislikeUpdated.remove(this);
+
+            if (!StatePolycentric.instance.enabled)
+                return
+
             _fragment.lifecycleScope.launch(Dispatchers.IO) {
                 if (version != _version) {
                     return@launch;

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/SourcesFragment.kt

@@ -18,6 +18,7 @@ import com.futo.platformplayer.activities.AddSourceOptionsActivity
 import com.futo.platformplayer.api.media.IPlatformClient
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.fragment.mainactivity.topbar.AddTopBarFragment
+import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.states.StatePlugins
 import com.futo.platformplayer.stores.FragmentedStorage
@@ -44,6 +45,7 @@ class SourcesFragment : MainFragment() {
         if(topBar is AddTopBarFragment) {
             (topBar as AddTopBarFragment).onAdd.clear();
             (topBar as AddTopBarFragment).onAdd.subscribe {
+                StateApp.instance.preventPictureInPicture.emit();
                 startActivity(Intent(requireContext(), AddSourceOptionsActivity::class.java));
             };
         }
@@ -93,6 +95,7 @@ class SourcesFragment : MainFragment() {
                 findViewById<LinearLayout>(R.id.plugin_disclaimer).isVisible = false;
             }
             findViewById<BigButton>(R.id.button_add_sources).onClick.subscribe {
+                StateApp.instance.preventPictureInPicture.emit();
                 fragment.startActivity(Intent(context, AddSourceOptionsActivity::class.java));
             };
 

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/SubscriptionsFeedFragment.kt

@@ -18,6 +18,7 @@ import com.futo.platformplayer.constructs.TaskHandler
 import com.futo.platformplayer.engine.exceptions.PluginException
 import com.futo.platformplayer.exceptions.ChannelException
 import com.futo.platformplayer.exceptions.RateLimitException
+import com.futo.platformplayer.fragment.mainactivity.main.SubscriptionsFeedFragment.SubscriptionsFeedView.FeedFilterSettings
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.models.SearchType
 import com.futo.platformplayer.models.SubscriptionGroup
@@ -56,6 +57,9 @@ class SubscriptionsFeedFragment : MainFragment() {
     private var _group: SubscriptionGroup? = null;
     private var _cachedRecyclerData: FeedView.RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null;
 
+    private val _filterLock = Object();
+    private val _filterSettings = FragmentedStorage.get<FeedFilterSettings>("subFeedFilter");
+
     override fun onShownWithView(parameter: Any?, isBack: Boolean) {
         super.onShownWithView(parameter, isBack);
         _view?.onShown();
@@ -184,8 +188,6 @@ class SubscriptionsFeedFragment : MainFragment() {
                 return Json.encodeToString(this);
             }
         }
-        private val _filterLock = Object();
-        private val _filterSettings = FragmentedStorage.get<FeedFilterSettings>("subFeedFilter");
 
         private var _bypassRateLimit = false;
         private val _lastExceptions: List<Throwable>? = null;
@@ -284,13 +286,18 @@ class SubscriptionsFeedFragment : MainFragment() {
                     fragment.navigate<SubscriptionGroupFragment>(g);
             };
 
-            synchronized(_filterLock) {
+            synchronized(fragment._filterLock) {
                 _subscriptionBar?.setToggles(
-                    SubscriptionBar.Toggle(context.getString(R.string.videos), _filterSettings.allowContentTypes.contains(ContentType.MEDIA)) { toggleFilterContentTypes(listOf(ContentType.MEDIA, ContentType.NESTED_VIDEO), it);  },
-                    SubscriptionBar.Toggle(context.getString(R.string.posts),  _filterSettings.allowContentTypes.contains(ContentType.POST)) { toggleFilterContentType(ContentType.POST, it); },
-                    SubscriptionBar.Toggle(context.getString(R.string.live), _filterSettings.allowLive) { _filterSettings.allowLive = it; _filterSettings.save(); loadResults(false); },
-                    SubscriptionBar.Toggle(context.getString(R.string.planned), _filterSettings.allowPlanned) { _filterSettings.allowPlanned = it; _filterSettings.save(); loadResults(false); },
-                    SubscriptionBar.Toggle(context.getString(R.string.watched), _filterSettings.allowWatched) { _filterSettings.allowWatched = it; _filterSettings.save(); loadResults(false); }
+                    SubscriptionBar.Toggle(context.getString(R.string.videos), fragment._filterSettings.allowContentTypes.contains(ContentType.MEDIA)) {  view, active ->
+                        toggleFilterContentTypes(listOf(ContentType.MEDIA, ContentType.NESTED_VIDEO), active);  },
+                    SubscriptionBar.Toggle(context.getString(R.string.posts),  fragment._filterSettings.allowContentTypes.contains(ContentType.POST)) {  view, active ->
+                        toggleFilterContentType(ContentType.POST, active); },
+                    SubscriptionBar.Toggle(context.getString(R.string.live), fragment._filterSettings.allowLive) {  view, active ->
+                        fragment._filterSettings.allowLive = active; fragment._filterSettings.save(); loadResults(false); },
+                    SubscriptionBar.Toggle(context.getString(R.string.planned), fragment._filterSettings.allowPlanned) {  view, active ->
+                        fragment._filterSettings.allowPlanned = active; fragment._filterSettings.save(); loadResults(false); },
+                    SubscriptionBar.Toggle(context.getString(R.string.watched), fragment._filterSettings.allowWatched) {  view, active ->
+                        fragment._filterSettings.allowWatched = active; fragment._filterSettings.save(); loadResults(false); }
                 );
             }
 
@@ -301,13 +308,13 @@ class SubscriptionsFeedFragment : MainFragment() {
                 toggleFilterContentType(contentType, isTrue);
         }
         private fun toggleFilterContentType(contentType: ContentType, isTrue: Boolean) {
-            synchronized(_filterLock) {
+            synchronized(fragment._filterLock) {
                 if(!isTrue) {
-                    _filterSettings.allowContentTypes.remove(contentType);
-                } else if(!_filterSettings.allowContentTypes.contains(contentType)) {
-                    _filterSettings.allowContentTypes.add(contentType)
+                    fragment._filterSettings.allowContentTypes.remove(contentType);
+                } else if(!fragment._filterSettings.allowContentTypes.contains(contentType)) {
+                    fragment._filterSettings.allowContentTypes.add(contentType)
                 }
-                _filterSettings.save();
+                fragment._filterSettings.save();
             };
             if(Settings.instance.subscriptions.fetchOnTabOpen) { //TODO: Do this different, temporary workaround
                 loadResults(false);
@@ -320,9 +327,9 @@ class SubscriptionsFeedFragment : MainFragment() {
             val nowSoon = OffsetDateTime.now().plusMinutes(5);
             val filterGroup = subGroup;
             return results.filter {
-                val allowedContentType = _filterSettings.allowContentTypes.contains(if(it.contentType == ContentType.NESTED_VIDEO || it.contentType == ContentType.LOCKED) ContentType.MEDIA else it.contentType);
+                val allowedContentType = fragment._filterSettings.allowContentTypes.contains(if(it.contentType == ContentType.NESTED_VIDEO || it.contentType == ContentType.LOCKED) ContentType.MEDIA else it.contentType);
 
-                if(it is IPlatformVideo && it.duration > 0 && !_filterSettings.allowWatched && StateHistory.instance.isHistoryWatched(it.url, it.duration))
+                if(it is IPlatformVideo && it.duration > 0 && !fragment._filterSettings.allowWatched && StateHistory.instance.isHistoryWatched(it.url, it.duration))
                     return@filter false;
 
                 //TODO: Check against a sub cache
@@ -331,11 +338,11 @@ class SubscriptionsFeedFragment : MainFragment() {
 
 
                 if(it.datetime?.isAfter(nowSoon) == true) {
-                    if(!_filterSettings.allowPlanned)
+                    if(!fragment._filterSettings.allowPlanned)
                         return@filter false;
                 }
 
-                if(_filterSettings.allowLive) { //If allowLive, always show live
+                if(fragment._filterSettings.allowLive) { //If allowLive, always show live
                     if(it is IPlatformVideo && it.isLive)
                         return@filter true;
                 }

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/SuggestionsFragment.kt

@@ -9,6 +9,7 @@ import androidx.lifecycle.lifecycleScope
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import com.futo.platformplayer.*
+import com.futo.platformplayer.activities.MainActivity
 import com.futo.platformplayer.constructs.TaskHandler
 import com.futo.platformplayer.fragment.mainactivity.topbar.SearchTopBarFragment
 import com.futo.platformplayer.logging.Logger
@@ -17,8 +18,10 @@ import com.futo.platformplayer.states.StatePlatform
 import com.futo.platformplayer.stores.FragmentedStorage
 import com.futo.platformplayer.stores.SearchHistoryStorage
 import com.futo.platformplayer.views.adapters.SearchSuggestionAdapter
+import com.futo.platformplayer.views.others.RadioGroupView
+import com.futo.platformplayer.views.others.TagsView
 
-data class SuggestionsFragmentData(val query: String, val searchType: SearchType, val channelUrl: String? = null);
+data class SuggestionsFragmentData(val query: String, val searchType: SearchType);
 
 class SuggestionsFragment : MainFragment {
     override val isMainView : Boolean = true;
@@ -27,10 +30,10 @@ class SuggestionsFragment : MainFragment {
 
     private var  _recyclerSuggestions: RecyclerView? = null;
     private var _llmSuggestions: LinearLayoutManager? = null;
+    private var _radioGroupView: RadioGroupView? = null;
     private val _suggestions: ArrayList<String> = ArrayList();
     private var _query: String? = null;
     private var _searchType: SearchType = SearchType.VIDEO;
-    private var _channelUrl: String? = null;
 
     private val _adapterSuggestions = SearchSuggestionAdapter(_suggestions);
 
@@ -48,14 +51,7 @@ class SuggestionsFragment : MainFragment {
         _adapterSuggestions.onClicked.subscribe { suggestion ->
             val storage = FragmentedStorage.get<SearchHistoryStorage>();
             storage.add(suggestion);
-
-            if (_searchType == SearchType.CREATOR) {
-                navigate<CreatorSearchResultsFragment>(suggestion);
-            } else if (_searchType == SearchType.PLAYLIST) {
-                navigate<PlaylistSearchResultsFragment>(suggestion);
-            } else {
-                navigate<ContentSearchResultsFragment>(SuggestionsFragmentData(suggestion, SearchType.VIDEO, _channelUrl));
-            }
+            navigate<ContentSearchResultsFragment>(SuggestionsFragmentData(suggestion, _searchType));
         }
         _adapterSuggestions.onRemove.subscribe { suggestion ->
             val index = _suggestions.indexOf(suggestion);
@@ -79,6 +75,15 @@ class SuggestionsFragment : MainFragment {
         recyclerSuggestions.adapter = _adapterSuggestions;
         _recyclerSuggestions = recyclerSuggestions;
 
+        _radioGroupView = view.findViewById<RadioGroupView>(R.id.radio_group).apply {
+            onSelectedChange.subscribe {
+                if (it.size != 1)
+                    _searchType = SearchType.VIDEO
+                else
+                    _searchType = (it[0] ?: SearchType.VIDEO) as SearchType
+            }
+        }
+
         loadSuggestions();
         return view;
     }
@@ -103,31 +108,31 @@ class SuggestionsFragment : MainFragment {
 
         if (parameter is SuggestionsFragmentData) {
             _searchType = parameter.searchType;
-            _channelUrl = parameter.channelUrl;
         } else if (parameter is SearchType) {
             _searchType = parameter;
-            _channelUrl = null;
         }
 
+        _radioGroupView?.setOptions(listOf(Pair("Media", SearchType.VIDEO), Pair("Creators", SearchType.CREATOR), Pair("Playlists", SearchType.PLAYLIST)), listOf(_searchType), false, true)
+
         topBar?.apply {
             if (this is SearchTopBarFragment) {
                 onSearch.subscribe(this) {
-                    if (_searchType == SearchType.CREATOR) {
-                        navigate<CreatorSearchResultsFragment>(it);
-                    } else if (_searchType == SearchType.PLAYLIST) {
-                        navigate<PlaylistSearchResultsFragment>(it);
-                    } else {
-                        if(it.isHttpUrl()) {
-                            if(StatePlatform.instance.hasEnabledPlaylistClient(it))
-                                navigate<RemotePlaylistFragment>(it);
-                            else if(StatePlatform.instance.hasEnabledChannelClient(it))
-                                navigate<ChannelFragment>(it);
-                            else
-                                navigate<VideoDetailFragment>(it);
+                    if(it.isHttpUrl()) {
+                        if(StatePlatform.instance.hasEnabledPlaylistClient(it))
+                            navigate<RemotePlaylistFragment>(it);
+                        else if(StatePlatform.instance.hasEnabledChannelClient(it))
+                            navigate<ChannelFragment>(it);
+                        else {
+                            val url = it;
+                            activity?.let {
+                                close()
+                                if(it is MainActivity)
+                                    it.navigate(it.getFragment<VideoDetailFragment>(), url);
+                            }
                         }
-                        else
-                            navigate<ContentSearchResultsFragment>(SuggestionsFragmentData(it, SearchType.VIDEO, _channelUrl));
                     }
+                    else
+                        navigate<ContentSearchResultsFragment>(SuggestionsFragmentData(it, _searchType));
                 };
 
                 onTextChange.subscribe(this) {
@@ -189,6 +194,7 @@ class SuggestionsFragment : MainFragment {
         super.onDestroyMainView();
         _getSuggestions.onError.clear();
         _recyclerSuggestions = null;
+        _radioGroupView = null
     }
 
     override fun onDestroy() {

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/VideoDetailFragment.kt

@@ -455,6 +455,10 @@ class VideoDetailFragment() : MainFragment() {
                 activity?.enterPictureInPictureMode(params);
             }
         }
+
+        if (isFullscreen) {
+            viewDetail?.restoreBrightness()
+        }
     }
 
     fun forcePictureInPicture() {
@@ -487,6 +491,10 @@ class VideoDetailFragment() : MainFragment() {
         _isActive = true;
         _leavingPiP = false;
 
+        if (isFullscreen) {
+            _viewDetail?.saveBrightness()
+        }
+
         _viewDetail?.let {
             Logger.v(TAG, "onResume preventPictureInPicture=false");
             it.preventPictureInPicture = false;

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/VideoDetailView.kt

@@ -46,6 +46,7 @@ import com.futo.platformplayer.R
 import com.futo.platformplayer.Settings
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.UISlideOverlays
+import com.futo.platformplayer.activities.MainActivity
 import com.futo.platformplayer.api.media.IPluginSourced
 import com.futo.platformplayer.api.media.LiveChatManager
 import com.futo.platformplayer.api.media.PlatformID
@@ -132,6 +133,7 @@ import com.futo.platformplayer.views.behavior.TouchInterceptFrameLayout
 import com.futo.platformplayer.views.casting.CastView
 import com.futo.platformplayer.views.comments.AddCommentView
 import com.futo.platformplayer.views.others.CreatorThumbnail
+import com.futo.platformplayer.views.overlays.ChaptersOverlay
 import com.futo.platformplayer.views.overlays.DescriptionOverlay
 import com.futo.platformplayer.views.overlays.LiveChatOverlay
 import com.futo.platformplayer.views.overlays.QueueEditorOverlay
@@ -195,6 +197,8 @@ class VideoDetailView : ConstraintLayout {
     private var _liveChat: LiveChatManager? = null;
     private var _videoResumePositionMilliseconds : Long = 0L;
 
+    private var _chapters: List<IChapter>? = null;
+
     private val _player: FutoVideoPlayer;
     private val _cast: CastView;
     private val _playerProgress: PlayerControlView;
@@ -263,6 +267,7 @@ class VideoDetailView : ConstraintLayout {
     private val _container_content_liveChat: LiveChatOverlay;
     private val _container_content_browser: WebviewOverlay;
     private val _container_content_support: SupportOverlay;
+    private val _container_content_chapters: ChaptersOverlay;
 
     private var _container_content_current: View;
 
@@ -374,6 +379,7 @@ class VideoDetailView : ConstraintLayout {
         _container_content_liveChat = findViewById(R.id.videodetail_container_livechat);
         _container_content_support = findViewById(R.id.videodetail_container_support);
         _container_content_browser = findViewById(R.id.videodetail_container_webview)
+        _container_content_chapters = findViewById(R.id.videodetail_container_chapters);
 
         _addCommentView = findViewById(R.id.add_comment_view);
         _commentsList = findViewById(R.id.comments_list);
@@ -398,6 +404,10 @@ class VideoDetailView : ConstraintLayout {
         _monetization = findViewById(R.id.monetization);
         _player.attachPlayer();
 
+        _player.onChapterClicked.subscribe {
+            showChaptersUI();
+        };
+
 
         _buttonSubscribe.onSubscribed.subscribe {
             _slideUpOverlay = UISlideOverlays.showSubscriptionOptionsOverlay(it, _overlayContainer);
@@ -561,7 +571,7 @@ class VideoDetailView : ConstraintLayout {
             _player.setIsReplay(true);
 
             val searchVideo = StatePlayer.instance.getCurrentQueueItem();
-            if (searchVideo is SerializedPlatformVideo?) {
+            if (searchVideo is SerializedPlatformVideo? && Settings.instance.playback.deleteFromWatchLaterAuto) {
                 searchVideo?.let { StatePlaylists.instance.removeFromWatchLater(it) };
             }
 
@@ -678,14 +688,36 @@ class VideoDetailView : ConstraintLayout {
             Logger.i(TAG, "MediaControlReceiver.onCloseReceived")
             onClose.emit()
         };
+        MediaControlReceiver.onBackgroundReceived.subscribe(this) {
+            Logger.i(TAG, "MediaControlReceiver.onBackgroundReceived")
+            _player.switchToAudioMode();
+            allowBackground = true;
+            StateApp.instance.contextOrNull?.let {
+                try {
+                    if (it is MainActivity) {
+                        it.moveTaskToBack(true)
+                    }
+                } catch (e: Throwable) {
+                    Logger.i(TAG, "Failed to move task to back", e)
+                }
+            }
+        };
         MediaControlReceiver.onSeekToReceived.subscribe(this) { handleSeek(it); };
 
         _container_content_description.onClose.subscribe { switchContentView(_container_content_main); };
         _container_content_liveChat.onClose.subscribe { switchContentView(_container_content_main); };
         _container_content_queue.onClose.subscribe { switchContentView(_container_content_main); };
+        _container_content_queue.onOptions.subscribe {
+            UISlideOverlays.showVideoOptionsOverlay(it, _overlayContainer);
+        }
         _container_content_replies.onClose.subscribe { switchContentView(_container_content_main); };
         _container_content_support.onClose.subscribe { switchContentView(_container_content_main); };
         _container_content_browser.onClose.subscribe { switchContentView(_container_content_main); };
+        _container_content_chapters.onClose.subscribe { switchContentView(_container_content_main); };
+
+        _container_content_chapters.onClick.subscribe {
+            handleSeek(it.timeStart.toLong() * 1000);
+        }
 
         _description_viewMore.setOnClickListener {
             switchContentView(_container_content_description);
@@ -852,6 +884,22 @@ class VideoDetailView : ConstraintLayout {
         _cast.stopAllGestures();
     }
 
+    fun showChaptersUI(){
+        video?.let {
+            try {
+                _chapters?.let {
+                    if(it.size == 0)
+                        return@let;
+                    _container_content_chapters.setChapters(_chapters);
+                    switchContentView(_container_content_chapters);
+                }
+            }
+            catch(ex: Throwable) {
+
+            }
+        }
+    }
+
     fun updateMoreButtons() {
         val isLimitedVersion = video?.url != null && StatePlatform.instance.getContentClientOrNull(video!!.url)?.let {
             if (it is JSClient)
@@ -865,6 +913,13 @@ class VideoDetailView : ConstraintLayout {
                 };
             }
         },
+            _chapters?.let {
+              if(it != null && it.size > 0)
+                  RoundButton(context, R.drawable.ic_list, "Chapters", TAG_CHAPTERS) {
+                      showChaptersUI();
+                  }
+              else null
+            },
             if(video?.isLive ?: false)
                 RoundButton(context, R.drawable.ic_chat, context.getString(R.string.live_chat), TAG_LIVECHAT) {
                     video?.let {
@@ -1100,6 +1155,7 @@ class VideoDetailView : ConstraintLayout {
         MediaControlReceiver.onNextReceived.remove(this);
         MediaControlReceiver.onPreviousReceived.remove(this);
         MediaControlReceiver.onCloseReceived.remove(this);
+        MediaControlReceiver.onBackgroundReceived.remove(this);
         MediaControlReceiver.onSeekToReceived.remove(this);
 
         val job = _jobHideResume;
@@ -1340,10 +1396,12 @@ class VideoDetailView : ConstraintLayout {
                     val chapters = null ?: StatePlatform.instance.getContentChapters(video.url);
                     _player.setChapters(chapters);
                     _cast.setChapters(chapters);
+                    _chapters = _player.getChapters();
                 } catch (ex: Throwable) {
                     Logger.e(TAG, "Failed to get chapters", ex);
                     _player.setChapters(null);
                     _cast.setChapters(null);
+                    _chapters = null;
 
                     /*withContext(Dispatchers.Main) {
                         UIDialogs.toast(context, "Failed to get chapters\n" + ex.message);
@@ -1382,6 +1440,10 @@ class VideoDetailView : ConstraintLayout {
                         );
                     }
                 }
+
+                fragment.lifecycleScope.launch(Dispatchers.Main) {
+                    updateMoreButtons();
+                }
             };
         }
 
@@ -1463,60 +1525,68 @@ class VideoDetailView : ConstraintLayout {
 
         _rating.visibility = View.GONE;
 
-        fragment.lifecycleScope.launch(Dispatchers.IO) {
-            try {
-                val queryReferencesResponse = ApiMethods.getQueryReferences(
-                    ApiMethods.SERVER, ref, null, null,
-                    arrayListOf(
-                        Protocol.QueryReferencesRequestCountLWWElementReferences.newBuilder()
-                            .setFromType(ContentType.OPINION.value).setValue(
-                            ByteString.copyFrom(Opinion.like.data)
-                        ).build(),
-                        Protocol.QueryReferencesRequestCountLWWElementReferences.newBuilder()
-                            .setFromType(ContentType.OPINION.value).setValue(
-                            ByteString.copyFrom(Opinion.dislike.data)
-                        ).build()
-                    ),
-                    extraByteReferences = listOfNotNull(extraBytesRef)
-                );
+        if (StatePolycentric.instance.enabled) {
+            fragment.lifecycleScope.launch(Dispatchers.IO) {
+                try {
+                    val queryReferencesResponse = ApiMethods.getQueryReferences(
+                        ApiMethods.SERVER, ref, null, null,
+                        arrayListOf(
+                            Protocol.QueryReferencesRequestCountLWWElementReferences.newBuilder()
+                                .setFromType(ContentType.OPINION.value).setValue(
+                                    ByteString.copyFrom(Opinion.like.data)
+                                ).build(),
+                            Protocol.QueryReferencesRequestCountLWWElementReferences.newBuilder()
+                                .setFromType(ContentType.OPINION.value).setValue(
+                                    ByteString.copyFrom(Opinion.dislike.data)
+                                ).build()
+                        ),
+                        extraByteReferences = listOfNotNull(extraBytesRef)
+                    );
 
-                val likes = queryReferencesResponse.countsList[0];
-                val dislikes = queryReferencesResponse.countsList[1];
-                val hasLiked = StatePolycentric.instance.hasLiked(ref.toByteArray())/* || extraBytesRef?.let { StatePolycentric.instance.hasLiked(it) } ?: false*/;
-                val hasDisliked = StatePolycentric.instance.hasDisliked(ref.toByteArray())/* || extraBytesRef?.let { StatePolycentric.instance.hasDisliked(it) } ?: false*/;
+                    val likes = queryReferencesResponse.countsList[0];
+                    val dislikes = queryReferencesResponse.countsList[1];
+                    val hasLiked =
+                        StatePolycentric.instance.hasLiked(ref.toByteArray())/* || extraBytesRef?.let { StatePolycentric.instance.hasLiked(it) } ?: false*/;
+                    val hasDisliked =
+                        StatePolycentric.instance.hasDisliked(ref.toByteArray())/* || extraBytesRef?.let { StatePolycentric.instance.hasDisliked(it) } ?: false*/;
 
-                withContext(Dispatchers.Main) {
-                    _rating.visibility = View.VISIBLE;
-                    _rating.setRating(RatingLikeDislikes(likes, dislikes), hasLiked, hasDisliked);
-                    _rating.onLikeDislikeUpdated.subscribe(this) { args ->
-                        if (args.hasLiked) {
-                            args.processHandle.opinion(ref, Opinion.like);
-                        } else if (args.hasDisliked) {
-                            args.processHandle.opinion(ref, Opinion.dislike);
-                        } else {
-                            args.processHandle.opinion(ref, Opinion.neutral);
-                        }
-
-                        fragment.lifecycleScope.launch(Dispatchers.IO) {
-                            try {
-                                Logger.i(TAG, "Started backfill");
-                                args.processHandle.fullyBackfillServersAnnounceExceptions();
-                                Logger.i(TAG, "Finished backfill");
-                            } catch (e: Throwable) {
-                                Logger.e(TAG, "Failed to backfill servers", e)
+                    withContext(Dispatchers.Main) {
+                        _rating.visibility = View.VISIBLE;
+                        _rating.setRating(
+                            RatingLikeDislikes(likes, dislikes),
+                            hasLiked,
+                            hasDisliked
+                        );
+                        _rating.onLikeDislikeUpdated.subscribe(this) { args ->
+                            if (args.hasLiked) {
+                                args.processHandle.opinion(ref, Opinion.like);
+                            } else if (args.hasDisliked) {
+                                args.processHandle.opinion(ref, Opinion.dislike);
+                            } else {
+                                args.processHandle.opinion(ref, Opinion.neutral);
                             }
-                        }
 
-                        StatePolycentric.instance.updateLikeMap(
-                            ref,
-                            args.hasLiked,
-                            args.hasDisliked
-                        )
-                    };
+                            fragment.lifecycleScope.launch(Dispatchers.IO) {
+                                try {
+                                    Logger.i(TAG, "Started backfill");
+                                    args.processHandle.fullyBackfillServersAnnounceExceptions();
+                                    Logger.i(TAG, "Finished backfill");
+                                } catch (e: Throwable) {
+                                    Logger.e(TAG, "Failed to backfill servers", e)
+                                }
+                            }
+
+                            StatePolycentric.instance.updateLikeMap(
+                                ref,
+                                args.hasLiked,
+                                args.hasDisliked
+                            )
+                        };
+                    }
+                } catch (e: Throwable) {
+                    Logger.e(TAG, "Failed to get polycentric likes/dislikes.", e);
+                    _rating.visibility = View.GONE;
                 }
-            } catch (e: Throwable) {
-                Logger.e(TAG, "Failed to get polycentric likes/dislikes.", e);
-                _rating.visibility = View.GONE;
             }
         }
 
@@ -1863,7 +1933,7 @@ class VideoDetailView : ConstraintLayout {
                             else null;
                             withContext(Dispatchers.Main) {
                                 video = newDetails;
-                                _player.setSource(newVideoSource, newAudioSource, true, true);
+                                _player.setSource(newVideoSource, newAudioSource, true, true, true);
                             }
                         }
                     } catch (e: Throwable) {
@@ -2366,6 +2436,7 @@ class VideoDetailView : ConstraintLayout {
         Logger.i(TAG, "handleFullScreen(fullscreen=$fullscreen)")
 
         if(fullscreen) {
+            _container_content.visibility = GONE
             _layoutPlayerContainer.setPadding(0, 0, 0, 0);
 
             val lp = _container_content.layoutParams as LayoutParams;
@@ -2379,6 +2450,7 @@ class VideoDetailView : ConstraintLayout {
             setProgressBarOverlayed(null);
         }
         else {
+            _container_content.visibility = VISIBLE
             _layoutPlayerContainer.setPadding(0, 0, 0, TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, 6.0f, Resources.getSystem().displayMetrics).toInt());
 
             val lp = _container_content.layoutParams as LayoutParams;
@@ -2438,6 +2510,13 @@ class VideoDetailView : ConstraintLayout {
         }
     }
 
+    fun saveBrightness() {
+        _player.gestureControl.saveBrightness()
+    }
+    fun restoreBrightness() {
+        _player.gestureControl.restoreBrightness()
+    }
+
     fun setFullscreen(fullscreen : Boolean) {
         Logger.i(TAG, "setFullscreen(fullscreen=$fullscreen)")
         _player.setFullScreen(fullscreen)
@@ -2601,7 +2680,11 @@ class VideoDetailView : ConstraintLayout {
                     }
 
                     onChannelClicked.subscribe {
-                        fragment.navigate<ChannelFragment>(it)
+                        if(it.url.isNotBlank()) {
+                            fragment.minimizeVideoDetail()
+                            fragment.navigate<ChannelFragment>(it)
+                        } else
+                            UIDialogs.appToast("No author url present");
                     }
 
                     onAddToWatchLaterClicked.subscribe(this) {
@@ -2675,10 +2758,11 @@ class VideoDetailView : ConstraintLayout {
         else
             RemoteAction(Icon.createWithResource(context, R.drawable.ic_play_notif), context.getString(R.string.play), context.getString(R.string.resumes_the_video), MediaControlReceiver.getPlayIntent(context, 6));
 
+        val toBackgroundAction = RemoteAction(Icon.createWithResource(context, R.drawable.ic_screen_share), context.getString(R.string.background), context.getString(R.string.background_switch_audio), MediaControlReceiver.getToBackgroundIntent(context, 7));
         return PictureInPictureParams.Builder()
             .setAspectRatio(Rational(videoSourceWidth, videoSourceHeight))
             .setSourceRectHint(r)
-            .setActions(listOf(playpauseAction))
+            .setActions(listOf(toBackgroundAction, playpauseAction))
             .build();
     }
 
@@ -2991,7 +3075,12 @@ class VideoDetailView : ConstraintLayout {
             Logger.w(TAG, "Failed to load recommendations.", it);
         };
 
-    private val _taskLoadPolycentricProfile = TaskHandler<PlatformID, PolycentricProfile?>(StateApp.instance.scopeGetter, { ApiMethods.getPolycentricProfileByClaim(ApiMethods.SERVER, ApiMethods.FUTO_TRUST_ROOT, it.claimFieldType.toLong(), it.claimType.toLong(), it.value!!) })
+    private val _taskLoadPolycentricProfile = TaskHandler<PlatformID, PolycentricProfile?>(StateApp.instance.scopeGetter, {
+        if (!StatePolycentric.instance.enabled)
+            return@TaskHandler null
+
+        ApiMethods.getPolycentricProfileByClaim(ApiMethods.SERVER, ApiMethods.FUTO_TRUST_ROOT, it.claimFieldType.toLong(), it.claimType.toLong(), it.value!!)
+    })
         .success { it -> setPolycentricProfile(it, animate = true) }
         .exception<Throwable> {
             Logger.w(TAG, "Failed to load claims.", it);
@@ -3063,10 +3152,6 @@ class VideoDetailView : ConstraintLayout {
 
     fun applyFragment(frag: VideoDetailFragment) {
         fragment = frag;
-        fragment.onMinimize.subscribe {
-            _liveChat?.stop();
-            _container_content_liveChat.close();
-        }
     }
 
 
@@ -3077,6 +3162,7 @@ class VideoDetailView : ConstraintLayout {
         const val TAG_SHARE = "share";
         const val TAG_OVERLAY = "overlay";
         const val TAG_LIVECHAT = "livechat";
+        const val TAG_CHAPTERS = "chapters";
         const val TAG_OPEN = "open";
         const val TAG_SEND_TO_DEVICE = "send_to_device";
         const val TAG_MORE = "MORE";

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/VideoListEditorView.kt

@@ -1,14 +1,17 @@
 package com.futo.platformplayer.fragment.mainactivity.main
 
+import android.content.Context
 import android.graphics.drawable.Animatable
 import android.util.TypedValue
 import android.view.LayoutInflater
 import android.view.View
+import android.view.inputmethod.InputMethodManager
 import android.widget.FrameLayout
 import android.widget.ImageButton
 import android.widget.ImageView
 import android.widget.LinearLayout
 import android.widget.TextView
+import androidx.core.view.isVisible
 import androidx.core.view.setPadding
 import com.bumptech.glide.Glide
 import com.futo.platformplayer.R
@@ -22,6 +25,7 @@ import com.futo.platformplayer.states.StateDownloads
 import com.futo.platformplayer.states.StatePlaylists
 import com.futo.platformplayer.toHumanDuration
 import com.futo.platformplayer.toHumanTime
+import com.futo.platformplayer.views.SearchView
 import com.futo.platformplayer.views.lists.VideoListEditorView
 
 abstract class VideoListEditorView : LinearLayout {
@@ -37,9 +41,20 @@ abstract class VideoListEditorView : LinearLayout {
     protected var _buttonExport: ImageButton;
     private var _buttonShare: ImageButton;
     private var _buttonEdit: ImageButton;
+    private var _buttonSearch: ImageButton;
+
+    private var _search: SearchView;
 
     private var _onShare: (()->Unit)? = null;
 
+    private var _loadedVideos: List<IPlatformVideo>? = null;
+    private var _loadedVideosCanEdit: Boolean = false;
+
+    fun hideSearchKeyboard() {
+        (context?.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager)?.hideSoftInputFromWindow(_search.textSearch.windowToken, 0)
+        _search.textSearch.clearFocus();
+    }
+
     constructor(inflater: LayoutInflater) : super(inflater.context) {
         inflater.inflate(R.layout.fragment_video_list_editor, this);
 
@@ -57,26 +72,48 @@ abstract class VideoListEditorView : LinearLayout {
         _buttonDownload.visibility = View.GONE;
         _buttonExport = findViewById(R.id.button_export);
         _buttonExport.visibility = View.GONE;
+        _buttonSearch = findViewById(R.id.button_search);
+
+        _search = findViewById(R.id.search_bar);
+        _search.visibility = View.GONE;
+        _search.onSearchChanged.subscribe {
+            updateVideoFilters();
+        }
+
+        _buttonSearch.setOnClickListener {
+            if(_search.isVisible) {
+                _search.visibility = View.GONE;
+                _search.textSearch.text = "";
+                updateVideoFilters();
+                _buttonSearch.setImageResource(R.drawable.ic_search);
+                hideSearchKeyboard();
+            }
+            else {
+                _search.visibility = View.VISIBLE;
+                _buttonSearch.setImageResource(R.drawable.ic_search_off);
+            }
+        }
 
         _buttonShare = findViewById(R.id.button_share);
         val onShare = _onShare;
         if(onShare != null) {
-            _buttonShare.setOnClickListener { onShare.invoke() };
+            _buttonShare.setOnClickListener {  hideSearchKeyboard(); onShare.invoke() };
             _buttonShare.visibility = View.VISIBLE;
         }
         else
             _buttonShare.visibility = View.GONE;
 
-        buttonPlayAll.setOnClickListener { onPlayAllClick(); };
-        buttonShuffle.setOnClickListener { onShuffleClick(); };
+        buttonPlayAll.setOnClickListener { hideSearchKeyboard();onPlayAllClick(); hideSearchKeyboard(); };
+        buttonShuffle.setOnClickListener { hideSearchKeyboard();onShuffleClick(); hideSearchKeyboard(); };
 
-        _buttonEdit.setOnClickListener { onEditClick(); };
+        _buttonEdit.setOnClickListener {  hideSearchKeyboard(); onEditClick(); };
         setButtonExportVisible(false);
         setButtonDownloadVisible(canEdit());
 
         videoListEditorView.onVideoOrderChanged.subscribe(::onVideoOrderChanged);
         videoListEditorView.onVideoRemoved.subscribe(::onVideoRemoved);
-        videoListEditorView.onVideoClicked.subscribe(::onVideoClicked);
+        videoListEditorView.onVideoOptions.subscribe(::onVideoOptions);
+        videoListEditorView.onVideoClicked.subscribe { hideSearchKeyboard(); onVideoClicked(it)};
 
         _videoListEditorView = videoListEditorView;
     }
@@ -84,6 +121,7 @@ abstract class VideoListEditorView : LinearLayout {
     fun setOnShare(onShare: (()-> Unit)? = null) {
         _onShare = onShare;
         _buttonShare.setOnClickListener {
+            hideSearchKeyboard();
             onShare?.invoke();
         };
         _buttonShare.visibility = View.VISIBLE;
@@ -94,6 +132,7 @@ abstract class VideoListEditorView : LinearLayout {
     open fun onShuffleClick() { }
     open fun onEditClick() { }
     open fun onVideoRemoved(video: IPlatformVideo) {}
+    open fun onVideoOptions(video: IPlatformVideo) {}
     open fun onVideoOrderChanged(videos : List<IPlatformVideo>) {}
     open fun onVideoClicked(video: IPlatformVideo) {
 
@@ -115,7 +154,7 @@ abstract class VideoListEditorView : LinearLayout {
             setButtonExportVisible(false);
             _buttonDownload.setImageResource(R.drawable.ic_loader_animated);
             _buttonDownload.drawable.assume<Animatable, Unit> { it.start() };
-            _buttonDownload.setOnClickListener {
+            _buttonDownload.setOnClickListener { hideSearchKeyboard();
                 UIDialogs.showConfirmationDialog(context, context.getString(R.string.are_you_sure_you_want_to_delete_the_downloaded_videos), {
                     StateDownloads.instance.deleteCachedPlaylist(playlistId);
                 });
@@ -124,7 +163,7 @@ abstract class VideoListEditorView : LinearLayout {
         else if(isDownloaded) {
             setButtonExportVisible(true)
             _buttonDownload.setImageResource(R.drawable.ic_download_off);
-            _buttonDownload.setOnClickListener {
+            _buttonDownload.setOnClickListener { hideSearchKeyboard();
                 UIDialogs.showConfirmationDialog(context, context.getString(R.string.are_you_sure_you_want_to_delete_the_downloaded_videos), {
                     StateDownloads.instance.deleteCachedPlaylist(playlistId);
                 });
@@ -133,7 +172,7 @@ abstract class VideoListEditorView : LinearLayout {
         else {
             setButtonExportVisible(false);
             _buttonDownload.setImageResource(R.drawable.ic_download);
-            _buttonDownload.setOnClickListener {
+            _buttonDownload.setOnClickListener { hideSearchKeyboard();
                 onDownload();
                 //UISlideOverlays.showDownloadPlaylistOverlay(playlist, overlayContainer);
             }
@@ -171,9 +210,22 @@ abstract class VideoListEditorView : LinearLayout {
                 .load(R.drawable.placeholder_video_thumbnail)
                 .into(_imagePlaylistThumbnail)
         }
-
+        _loadedVideos = videos;
+        _loadedVideosCanEdit = canEdit;
         _videoListEditorView.setVideos(videos, canEdit);
     }
+    fun filterVideos(videos: List<IPlatformVideo>): List<IPlatformVideo> {
+        var toReturn = videos;
+        val searchStr = _search.textSearch.text
+        if(!searchStr.isNullOrBlank())
+            toReturn = toReturn.filter { it.name.contains(searchStr, true) || it.author.name.contains(searchStr, true) };
+        return toReturn;
+    }
+
+    fun updateVideoFilters() {
+        val videos = _loadedVideos ?: return;
+        _videoListEditorView.setVideos(filterVideos(videos), _loadedVideosCanEdit);
+    }
 
     protected fun setButtonDownloadVisible(isVisible: Boolean) {
         _buttonDownload.visibility = if (isVisible) View.VISIBLE else View.GONE;

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/WatchLaterFragment.kt

@@ -103,6 +103,9 @@ class WatchLaterFragment : MainFragment() {
                 StatePlaylists.instance.removeFromWatchLater(video, true);
             }
         }
+        override fun onVideoOptions(video: IPlatformVideo) {
+            UISlideOverlays.showVideoOptionsOverlay(video, overlayContainer);
+        }
 
         override fun onVideoClicked(video: IPlatformVideo) {
             val watchLater = StatePlaylists.instance.getWatchLater();

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/main/WebDetailFragment.kt

@@ -0,0 +1,223 @@
+package com.futo.platformplayer.fragment.mainactivity.main
+
+import android.content.Context
+import android.content.Intent
+import android.graphics.drawable.Animatable
+import android.net.Uri
+import android.os.Bundle
+import android.view.LayoutInflater
+import android.view.View
+import android.view.ViewGroup
+import android.view.ViewPropertyAnimator
+import android.webkit.WebView
+import android.webkit.WebViewClient
+import android.widget.Button
+import android.widget.FrameLayout
+import android.widget.ImageButton
+import android.widget.ImageView
+import android.widget.LinearLayout
+import android.widget.TextView
+import androidx.constraintlayout.widget.ConstraintLayout
+import androidx.core.view.children
+import androidx.lifecycle.lifecycleScope
+import com.bumptech.glide.Glide
+import com.futo.platformplayer.R
+import com.futo.platformplayer.Settings
+import com.futo.platformplayer.UIDialogs
+import com.futo.platformplayer.api.media.PlatformID
+import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.article.IPlatformArticleDetails
+import com.futo.platformplayer.api.media.models.comments.PolycentricPlatformComment
+import com.futo.platformplayer.api.media.models.post.IPlatformPost
+import com.futo.platformplayer.api.media.models.post.IPlatformPostDetails
+import com.futo.platformplayer.api.media.models.ratings.IRating
+import com.futo.platformplayer.api.media.models.ratings.RatingLikeDislikes
+import com.futo.platformplayer.api.media.models.ratings.RatingLikes
+import com.futo.platformplayer.api.media.platforms.js.models.JSWeb
+import com.futo.platformplayer.api.media.platforms.js.models.JSWebDetails
+import com.futo.platformplayer.constructs.TaskHandler
+import com.futo.platformplayer.dp
+import com.futo.platformplayer.fixHtmlWhitespace
+import com.futo.platformplayer.images.GlideHelper.Companion.crossfade
+import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.setPlatformPlayerLinkMovementMethod
+import com.futo.platformplayer.states.StateApp
+import com.futo.platformplayer.states.StatePlatform
+import com.futo.platformplayer.states.StatePolycentric
+import com.futo.platformplayer.toHumanNowDiffString
+import com.futo.platformplayer.toHumanNumber
+import com.futo.platformplayer.views.adapters.ChannelTab
+import com.futo.platformplayer.views.adapters.feedtypes.PreviewPostView
+import com.futo.platformplayer.views.comments.AddCommentView
+import com.futo.platformplayer.views.others.CreatorThumbnail
+import com.futo.platformplayer.views.overlays.RepliesOverlay
+import com.futo.platformplayer.views.pills.PillRatingLikesDislikes
+import com.futo.platformplayer.views.platform.PlatformIndicator
+import com.futo.platformplayer.views.segments.CommentsList
+import com.futo.platformplayer.views.subscriptions.SubscribeButton
+import com.futo.polycentric.core.ApiMethods
+import com.futo.polycentric.core.ContentType
+import com.futo.polycentric.core.Models
+import com.futo.polycentric.core.Opinion
+import com.futo.polycentric.core.PolycentricProfile
+import com.futo.polycentric.core.fullyBackfillServersAnnounceExceptions
+import com.google.android.flexbox.FlexboxLayout
+import com.google.android.material.imageview.ShapeableImageView
+import com.google.android.material.shape.CornerFamily
+import com.google.android.material.shape.ShapeAppearanceModel
+import com.google.protobuf.ByteString
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.withContext
+import userpackage.Protocol
+import java.lang.Integer.min
+
+class WebDetailFragment : MainFragment {
+    override val isMainView: Boolean = true;
+    override val isTab: Boolean = true;
+    override val hasBottomBar: Boolean get() = true;
+
+    private var _viewDetail: WebDetailView? = null;
+
+    constructor() : super() { }
+
+    override fun onBackPressed(): Boolean {
+        return false;
+    }
+
+    override fun onCreateMainView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        val view = WebDetailView(inflater.context).applyFragment(this);
+        _viewDetail = view;
+        return view;
+    }
+
+    override fun onDestroyMainView() {
+        super.onDestroyMainView();
+        _viewDetail?.onDestroy();
+        _viewDetail = null;
+    }
+
+    override fun onShownWithView(parameter: Any?, isBack: Boolean) {
+        super.onShownWithView(parameter, isBack);
+
+        if (parameter is JSWeb) {
+            _viewDetail?.clear();
+            _viewDetail?.setWeb(parameter);
+        }
+        if (parameter is JSWebDetails) {
+            _viewDetail?.clear();
+            _viewDetail?.setWebDetails(parameter);
+        }
+    }
+
+    private class WebDetailView : ConstraintLayout {
+        private lateinit var _fragment: WebDetailFragment;
+        private var _url: String? = null;
+        private var _isLoading = false;
+        private var _web: JSWebDetails? = null;
+
+        private val _layoutLoadingOverlay: FrameLayout;
+        private val _imageLoader: ImageView;
+
+        private val _webview: WebView;
+
+        private val _taskLoadPost = if(!isInEditMode) TaskHandler<String, JSWebDetails>(
+            StateApp.instance.scopeGetter,
+            {
+                val result = StatePlatform.instance.getContentDetails(it).await();
+                if(result !is JSWebDetails)
+                    throw IllegalStateException(context.getString(R.string.expected_media_content_found) + " ${result.contentType}");
+                return@TaskHandler result;
+            })
+            .success { setWebDetails(it) }
+            .exception<Throwable> {
+                Logger.w(ChannelFragment.TAG, context.getString(R.string.failed_to_load_post), it);
+                UIDialogs.showGeneralRetryErrorDialog(context, context.getString(R.string.failed_to_load_post), it, ::fetchPost, null, _fragment);
+            } else TaskHandler(IPlatformPostDetails::class.java) { _fragment.lifecycleScope };
+
+
+        constructor(context: Context) : super(context) {
+            inflate(context, R.layout.fragview_web_detail, this);
+
+            val root = findViewById<FrameLayout>(R.id.root);
+
+            _layoutLoadingOverlay = findViewById(R.id.layout_loading_overlay);
+            _imageLoader = findViewById(R.id.image_loader);
+
+            _webview = findViewById(R.id.webview);
+            _webview.webViewClient = object: WebViewClient() {
+                override fun onPageFinished(view: WebView?, url: String?) {
+                    super.onPageFinished(view, url);
+                    if(url != "about:blank")
+                        setLoading(false);
+                }
+            }
+        }
+
+
+        fun applyFragment(frag: WebDetailFragment): WebDetailView {
+            _fragment = frag;
+            return this;
+        }
+
+        fun clear() {
+            _webview.loadUrl("about:blank");
+        }
+
+        fun setWeb(value: JSWeb) {
+            _url = value.url;
+            setLoading(true);
+            clear();
+            fetchPost();
+        }
+        fun setWebDetails(value: JSWebDetails) {
+            _web = value;
+            setLoading(true);
+            _webview.loadUrl("about:blank");
+            if(!value.html.isNullOrEmpty())
+                _webview.loadData(value.html, "text/html", null);
+            else
+                _webview.loadUrl(value.url ?: "about:blank");
+        }
+
+        private fun fetchPost() {
+            Logger.i(WebDetailView.TAG, "fetchWeb")
+            _web = null;
+
+            val url = _url;
+            if (!url.isNullOrBlank()) {
+                setLoading(true);
+                _taskLoadPost.run(url);
+            }
+        }
+
+        fun onDestroy() {
+            _webview.loadUrl("about:blank");
+        }
+
+        private fun setLoading(isLoading : Boolean) {
+            if (_isLoading == isLoading) {
+                return;
+            }
+
+            _isLoading = isLoading;
+
+            if(isLoading) {
+                (_imageLoader.drawable as Animatable?)?.start()
+                _layoutLoadingOverlay.visibility = View.VISIBLE;
+            }
+            else {
+                _layoutLoadingOverlay.visibility = View.GONE;
+                (_imageLoader.drawable as Animatable?)?.stop()
+            }
+        }
+
+        companion object {
+            const val TAG = "WebDetailFragment"
+        }
+    }
+
+    companion object {
+        fun newInstance() = WebDetailFragment().apply {}
+    }
+}

app/src/main/java/com/futo/platformplayer/fragment/mainactivity/topbar/SearchTopBarFragment.kt

@@ -88,7 +88,6 @@ class SearchTopBarFragment : TopFragment() {
         } else if (parameter is SuggestionsFragmentData) {
             this.setText(parameter.query);
             _searchType = parameter.searchType;
-            _channelUrl = parameter.channelUrl;
         }
 
         if(currentMain is SuggestionsFragment)
@@ -114,7 +113,7 @@ class SearchTopBarFragment : TopFragment() {
     fun clear() {
         _editSearch?.text?.clear();
         if (currentMain !is SuggestionsFragment) {
-            navigate<SuggestionsFragment>(SuggestionsFragmentData("", _searchType, _channelUrl), false);
+            navigate<SuggestionsFragment>(SuggestionsFragmentData("", _searchType), false);
         } else {
             onSearch.emit("");
         }

app/src/main/java/com/futo/platformplayer/helpers/VideoHelper.kt

@@ -214,5 +214,38 @@ class VideoHelper {
             }
             else return 0;
         }
+
+        fun mediaExtensionToMimetype(extension: String): String? {
+            return videoExtensionToMimetype(extension) ?: audioExtensionToMimetype(extension);
+        }
+        fun videoExtensionToMimetype(extension: String): String? {
+            val extensionTrimmed = extension.trim('.').lowercase();
+            return when (extensionTrimmed) {
+                "mp4" -> return "video/mp4";
+                "webm" -> return "video/webm";
+                "m3u8" -> return "video/x-mpegURL";
+                "3gp" -> return "video/3gpp";
+                "mov" -> return "video/quicktime";
+                "mkv" -> return "video/x-matroska";
+                "mp4a" -> return "audio/vnd.apple.mpegurl";
+                "mpga" -> return "audio/mpga";
+                "mp3" -> return "audio/mp3";
+                "webm" -> return "audio/webm";
+                "3gp" -> return "audio/3gpp";
+                else -> null;
+            }
+        }
+        fun audioExtensionToMimetype(extension: String): String? {
+            val extensionTrimmed = extension.trim('.').lowercase();
+            return when (extensionTrimmed) {
+                "mkv" -> return "audio/x-matroska";
+                "mp4a" -> return "audio/vnd.apple.mpegurl";
+                "mpga" -> return "audio/mpga";
+                "mp3" -> return "audio/mp3";
+                "webm" -> return "audio/webm";
+                "3gp" -> return "audio/3gpp";
+                else -> null;
+            }
+        }
     }
 }

app/src/main/java/com/futo/platformplayer/mdns/BroadcastService.kt

@@ -1,11 +0,0 @@
-package com.futo.platformplayer.mdns
-
-data class BroadcastService(
-    val deviceName: String,
-    val serviceName: String,
-    val port: UShort,
-    val ttl: UInt,
-    val weight: UShort,
-    val priority: UShort,
-    val texts: List<String>? = null
-)

app/src/main/java/com/futo/platformplayer/mdns/DnsPacket.kt

@@ -1,93 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-enum class QueryResponse(val value: Byte) {
-    Query(0),
-    Response(1)
-}
-
-enum class DnsOpcode(val value: Byte) {
-    StandardQuery(0),
-    InverseQuery(1),
-    ServerStatusRequest(2)
-}
-
-enum class DnsResponseCode(val value: Byte) {
-    NoError(0),
-    FormatError(1),
-    ServerFailure(2),
-    NameError(3),
-    NotImplemented(4),
-    Refused(5)
-}
-
-data class DnsPacketHeader(
-    val identifier: UShort,
-    val queryResponse: Int,
-    val opcode: Int,
-    val authoritativeAnswer: Boolean,
-    val truncated: Boolean,
-    val recursionDesired: Boolean,
-    val recursionAvailable: Boolean,
-    val answerAuthenticated: Boolean,
-    val nonAuthenticatedData: Boolean,
-    val responseCode: DnsResponseCode
-)
-
-data class DnsPacket(
-    val header: DnsPacketHeader,
-    val questions: List<DnsQuestion>,
-    val answers: List<DnsResourceRecord>,
-    val authorities: List<DnsResourceRecord>,
-    val additionals: List<DnsResourceRecord>
-) {
-    companion object {
-        fun parse(data: ByteArray): DnsPacket {
-            val span = data.asUByteArray()
-            val flags = (span[2].toInt() shl 8 or span[3].toInt()).toUShort()
-            val questionCount = (span[4].toInt() shl 8 or span[5].toInt()).toUShort()
-            val answerCount = (span[6].toInt() shl 8 or span[7].toInt()).toUShort()
-            val authorityCount = (span[8].toInt() shl 8 or span[9].toInt()).toUShort()
-            val additionalCount = (span[10].toInt() shl 8 or span[11].toInt()).toUShort()
-
-            var position = 12
-
-            val questions = List(questionCount.toInt()) {
-                DnsQuestion.parse(data, position).also { position = it.second }
-            }.map { it.first }
-
-            val answers = List(answerCount.toInt()) {
-                DnsResourceRecord.parse(data, position).also { position = it.second }
-            }.map { it.first }
-
-            val authorities = List(authorityCount.toInt()) {
-                DnsResourceRecord.parse(data, position).also { position = it.second }
-            }.map { it.first }
-
-            val additionals = List(additionalCount.toInt()) {
-                DnsResourceRecord.parse(data, position).also { position = it.second }
-            }.map { it.first }
-
-            return DnsPacket(
-                header = DnsPacketHeader(
-                    identifier = (span[0].toInt() shl 8 or span[1].toInt()).toUShort(),
-                    queryResponse = ((flags.toUInt() shr 15) and 0b1u).toInt(),
-                    opcode = ((flags.toUInt() shr 11) and 0b1111u).toInt(),
-                    authoritativeAnswer = (flags.toInt() shr 10) and 0b1 != 0,
-                    truncated = (flags.toInt() shr 9) and 0b1 != 0,
-                    recursionDesired = (flags.toInt() shr 8) and 0b1 != 0,
-                    recursionAvailable = (flags.toInt() shr 7) and 0b1 != 0,
-                    answerAuthenticated = (flags.toInt() shr 5) and 0b1 != 0,
-                    nonAuthenticatedData = (flags.toInt() shr 4) and 0b1 != 0,
-                    responseCode = DnsResponseCode.entries[flags.toInt() and 0b1111]
-                ),
-                questions = questions,
-                answers = answers,
-                authorities = authorities,
-                additionals = additionals
-            )
-        }
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/DnsQuestion.kt

@@ -1,110 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import com.futo.platformplayer.mdns.Extensions.readDomainName
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-
-enum class QuestionType(val value: UShort) {
-    A(1u),
-    NS(2u),
-    MD(3u),
-    MF(4u),
-    CNAME(5u),
-    SOA(6u),
-    MB(7u),
-    MG(8u),
-    MR(9u),
-    NULL(10u),
-    WKS(11u),
-    PTR(12u),
-    HINFO(13u),
-    MINFO(14u),
-    MX(15u),
-    TXT(16u),
-    RP(17u),
-    AFSDB(18u),
-    SIG(24u),
-    KEY(25u),
-    AAAA(28u),
-    LOC(29u),
-    SRV(33u),
-    NAPTR(35u),
-    KX(36u),
-    CERT(37u),
-    DNAME(39u),
-    APL(42u),
-    DS(43u),
-    SSHFP(44u),
-    IPSECKEY(45u),
-    RRSIG(46u),
-    NSEC(47u),
-    DNSKEY(48u),
-    DHCID(49u),
-    NSEC3(50u),
-    NSEC3PARAM(51u),
-    TSLA(52u),
-    SMIMEA(53u),
-    HIP(55u),
-    CDS(59u),
-    CDNSKEY(60u),
-    OPENPGPKEY(61u),
-    CSYNC(62u),
-    ZONEMD(63u),
-    SVCB(64u),
-    HTTPS(65u),
-    EUI48(108u),
-    EUI64(109u),
-    TKEY(249u),
-    TSIG(250u),
-    URI(256u),
-    CAA(257u),
-    TA(32768u),
-    DLV(32769u),
-    AXFR(252u),
-    IXFR(251u),
-    OPT(41u),
-    MAILB(253u),
-    MALA(254u),
-    All(252u)
-}
-
-enum class QuestionClass(val value: UShort) {
-    IN(1u),
-    CS(2u),
-    CH(3u),
-    HS(4u),
-    All(255u)
-}
-
-data class DnsQuestion(
-    override val name: String,
-    override val type: Int,
-    override val clazz: Int,
-    val queryUnicast: Boolean
-) : DnsResourceRecordBase(name, type, clazz) {
-    companion object {
-        fun parse(data: ByteArray, startPosition: Int): Pair<DnsQuestion, Int> {
-            val span = data.asUByteArray()
-            var position = startPosition
-            val qname = span.readDomainName(position).also { position = it.second }
-            val qtype = (span[position].toInt() shl 8 or span[position + 1].toInt()).toUShort()
-            position += 2
-            val qclass = (span[position].toInt() shl 8 or span[position + 1].toInt()).toUShort()
-            position += 2
-
-            return DnsQuestion(
-                name = qname.first,
-                type = qtype.toInt(),
-                queryUnicast = ((qclass.toInt() shr 15) and 0b1) != 0,
-                clazz = qclass.toInt() and 0b111111111111111
-            ) to position
-        }
-    }
-}
-
-open class DnsResourceRecordBase(
-    open val name: String,
-    open val type: Int,
-    open val clazz: Int
-)

app/src/main/java/com/futo/platformplayer/mdns/DnsReader.kt

@@ -1,514 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import com.futo.platformplayer.mdns.Extensions.readDomainName
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import java.nio.charset.StandardCharsets
-import kotlin.math.pow
-import java.net.InetAddress
-
-data class PTRRecord(val domainName: String)
-
-data class ARecord(val address: InetAddress)
-
-data class AAAARecord(val address: InetAddress)
-
-data class MXRecord(val preference: UShort, val exchange: String)
-
-data class CNAMERecord(val cname: String)
-
-data class TXTRecord(val texts: List<String>)
-
-data class SOARecord(
-    val primaryNameServer: String,
-    val responsibleAuthorityMailbox: String,
-    val serialNumber: Int,
-    val refreshInterval: Int,
-    val retryInterval: Int,
-    val expiryLimit: Int,
-    val minimumTTL: Int
-)
-
-data class SRVRecord(val priority: UShort, val weight: UShort, val port: UShort, val target: String)
-
-data class NSRecord(val nameServer: String)
-
-data class CAARecord(val flags: Byte, val tag: String, val value: String)
-
-data class HINFORecord(val cpu: String, val os: String)
-
-data class RPRecord(val mailbox: String, val txtDomainName: String)
-
-
-data class AFSDBRecord(val subtype: UShort, val hostname: String)
-data class LOCRecord(
-    val version: Byte,
-    val size: Double,
-    val horizontalPrecision: Double,
-    val verticalPrecision: Double,
-    val latitude: Double,
-    val longitude: Double,
-    val altitude: Double
-) {
-    companion object {
-        fun decodeSizeOrPrecision(coded: Byte): Double {
-            val baseValue = (coded.toInt() shr 4) and 0x0F
-            val exponent = coded.toInt() and 0x0F
-            return baseValue * 10.0.pow(exponent.toDouble())
-        }
-
-        fun decodeLatitudeOrLongitude(coded: Int): Double {
-            val arcSeconds = coded / 1E3
-            return arcSeconds / 3600.0
-        }
-
-        fun decodeAltitude(coded: Int): Double {
-            return (coded / 100.0) - 100000.0
-        }
-    }
-}
-
-data class NAPTRRecord(
-    val order: UShort,
-    val preference: UShort,
-    val flags: String,
-    val services: String,
-    val regexp: String,
-    val replacement: String
-)
-
-data class RRSIGRecord(
-    val typeCovered: UShort,
-    val algorithm: Byte,
-    val labels: Byte,
-    val originalTTL: UInt,
-    val signatureExpiration: UInt,
-    val signatureInception: UInt,
-    val keyTag: UShort,
-    val signersName: String,
-    val signature: ByteArray
-)
-
-data class KXRecord(val preference: UShort, val exchanger: String)
-
-data class CERTRecord(val type: UShort, val keyTag: UShort, val algorithm: Byte, val certificate: ByteArray)
-
-
-
-data class DNAMERecord(val target: String)
-
-data class DSRecord(val keyTag: UShort, val algorithm: Byte, val digestType: Byte, val digest: ByteArray)
-
-data class SSHFPRecord(val algorithm: Byte, val fingerprintType: Byte, val fingerprint: ByteArray)
-
-data class TLSARecord(val usage: Byte, val selector: Byte, val matchingType: Byte, val certificateAssociationData: ByteArray)
-
-data class SMIMEARecord(val usage: Byte, val selector: Byte, val matchingType: Byte, val certificateAssociationData: ByteArray)
-
-data class URIRecord(val priority: UShort, val weight: UShort, val target: String)
-
-data class NSECRecord(val ownerName: String, val typeBitMaps: List<Pair<Byte, ByteArray>>)
-data class NSEC3Record(
-    val hashAlgorithm: Byte,
-    val flags: Byte,
-    val iterations: UShort,
-    val salt: ByteArray,
-    val nextHashedOwnerName: ByteArray,
-    val typeBitMaps: List<UShort>
-)
-
-data class NSEC3PARAMRecord(val hashAlgorithm: Byte, val flags: Byte, val iterations: UShort, val salt: ByteArray)
-data class SPFRecord(val texts: List<String>)
-data class TKEYRecord(
-    val algorithm: String,
-    val inception: UInt,
-    val expiration: UInt,
-    val mode: UShort,
-    val error: UShort,
-    val keyData: ByteArray,
-    val otherData: ByteArray
-)
-
-data class TSIGRecord(
-    val algorithmName: String,
-    val timeSigned: UInt,
-    val fudge: UShort,
-    val mac: ByteArray,
-    val originalID: UShort,
-    val error: UShort,
-    val otherData: ByteArray
-)
-
-data class OPTRecordOption(val code: UShort, val data: ByteArray)
-data class OPTRecord(val options: List<OPTRecordOption>)
-
-class DnsReader(private val data: ByteArray, private var position: Int = 0, private val length: Int = data.size) {
-
-    private val endPosition: Int = position + length
-
-    fun readDomainName(): String {
-        return data.asUByteArray().readDomainName(position).also { position = it.second }.first
-    }
-
-    fun readDouble(): Double {
-        checkRemainingBytes(Double.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Double.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).double
-        position += Double.SIZE_BYTES
-        return result
-    }
-
-    fun readInt16(): Short {
-        checkRemainingBytes(Short.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Short.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).short
-        position += Short.SIZE_BYTES
-        return result
-    }
-
-    fun readInt32(): Int {
-        checkRemainingBytes(Int.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Int.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).int
-        position += Int.SIZE_BYTES
-        return result
-    }
-
-    fun readInt64(): Long {
-        checkRemainingBytes(Long.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Long.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).long
-        position += Long.SIZE_BYTES
-        return result
-    }
-
-    fun readSingle(): Float {
-        checkRemainingBytes(Float.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Float.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).float
-        position += Float.SIZE_BYTES
-        return result
-    }
-
-    fun readByte(): Byte {
-        checkRemainingBytes(Byte.SIZE_BYTES)
-        return data[position++]
-    }
-
-    fun readBytes(length: Int): ByteArray {
-        checkRemainingBytes(length)
-        return ByteArray(length).also { data.copyInto(it, startIndex = position, endIndex = position + length) }
-            .also { position += length }
-    }
-
-    fun readUInt16(): UShort {
-        checkRemainingBytes(Short.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Short.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).short.toUShort()
-        position += Short.SIZE_BYTES
-        return result
-    }
-
-    fun readUInt32(): UInt {
-        checkRemainingBytes(Int.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Int.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).int.toUInt()
-        position += Int.SIZE_BYTES
-        return result
-    }
-
-    fun readUInt64(): ULong {
-        checkRemainingBytes(Long.SIZE_BYTES)
-        val result = ByteBuffer.wrap(data, position, Long.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).long.toULong()
-        position += Long.SIZE_BYTES
-        return result
-    }
-
-    fun readString(): String {
-        val length = data[position++].toInt()
-        checkRemainingBytes(length)
-        return String(data, position, length, StandardCharsets.UTF_8).also { position += length }
-    }
-
-    private fun checkRemainingBytes(requiredBytes: Int) {
-        if (position + requiredBytes > endPosition) throw IndexOutOfBoundsException()
-    }
-
-    fun readRPRecord(): RPRecord {
-        return RPRecord(readDomainName(), readDomainName())
-    }
-
-    fun readKXRecord(): KXRecord {
-        val preference = readUInt16()
-        val exchanger = readDomainName()
-        return KXRecord(preference, exchanger)
-    }
-
-    fun readCERTRecord(): CERTRecord {
-        val type = readUInt16()
-        val keyTag = readUInt16()
-        val algorithm = readByte()
-        val certificateLength = readUInt16().toInt() - 5
-        val certificate = readBytes(certificateLength)
-        return CERTRecord(type, keyTag, algorithm, certificate)
-    }
-
-    fun readPTRRecord(): PTRRecord {
-        return PTRRecord(readDomainName())
-    }
-
-    fun readARecord(): ARecord {
-        val address = readBytes(4)
-        return ARecord(InetAddress.getByAddress(address))
-    }
-
-    fun readAAAARecord(): AAAARecord {
-        val address = readBytes(16)
-        return AAAARecord(InetAddress.getByAddress(address))
-    }
-
-    fun readMXRecord(): MXRecord {
-        val preference = readUInt16()
-        val exchange = readDomainName()
-        return MXRecord(preference, exchange)
-    }
-
-    fun readCNAMERecord(): CNAMERecord {
-        return CNAMERecord(readDomainName())
-    }
-
-    fun readTXTRecord(): TXTRecord {
-        val texts = mutableListOf<String>()
-        while (position < endPosition) {
-            val textLength = data[position++].toInt()
-            checkRemainingBytes(textLength)
-            val text = String(data, position, textLength, StandardCharsets.UTF_8)
-            texts.add(text)
-            position += textLength
-        }
-        return TXTRecord(texts)
-    }
-
-    fun readSOARecord(): SOARecord {
-        val primaryNameServer = readDomainName()
-        val responsibleAuthorityMailbox = readDomainName()
-        val serialNumber = readInt32()
-        val refreshInterval = readInt32()
-        val retryInterval = readInt32()
-        val expiryLimit = readInt32()
-        val minimumTTL = readInt32()
-        return SOARecord(primaryNameServer, responsibleAuthorityMailbox, serialNumber, refreshInterval, retryInterval, expiryLimit, minimumTTL)
-    }
-
-    fun readSRVRecord(): SRVRecord {
-        val priority = readUInt16()
-        val weight = readUInt16()
-        val port = readUInt16()
-        val target = readDomainName()
-        return SRVRecord(priority, weight, port, target)
-    }
-
-    fun readNSRecord(): NSRecord {
-        return NSRecord(readDomainName())
-    }
-
-    fun readCAARecord(): CAARecord {
-        val length = readUInt16().toInt()
-        val flags = readByte()
-        val tagLength = readByte().toInt()
-        val tag = String(data, position, tagLength, StandardCharsets.US_ASCII).also { position += tagLength }
-        val valueLength = length - 1 - 1 - tagLength
-        val value = String(data, position, valueLength, StandardCharsets.US_ASCII).also { position += valueLength }
-        return CAARecord(flags, tag, value)
-    }
-
-    fun readHINFORecord(): HINFORecord {
-        val cpuLength = readByte().toInt()
-        val cpu = String(data, position, cpuLength, StandardCharsets.US_ASCII).also { position += cpuLength }
-        val osLength = readByte().toInt()
-        val os = String(data, position, osLength, StandardCharsets.US_ASCII).also { position += osLength }
-        return HINFORecord(cpu, os)
-    }
-
-    fun readAFSDBRecord(): AFSDBRecord {
-        return AFSDBRecord(readUInt16(), readDomainName())
-    }
-
-    fun readLOCRecord(): LOCRecord {
-        val version = readByte()
-        val size = LOCRecord.decodeSizeOrPrecision(readByte())
-        val horizontalPrecision = LOCRecord.decodeSizeOrPrecision(readByte())
-        val verticalPrecision = LOCRecord.decodeSizeOrPrecision(readByte())
-        val latitudeCoded = readInt32()
-        val longitudeCoded = readInt32()
-        val altitudeCoded = readInt32()
-        val latitude = LOCRecord.decodeLatitudeOrLongitude(latitudeCoded)
-        val longitude = LOCRecord.decodeLatitudeOrLongitude(longitudeCoded)
-        val altitude = LOCRecord.decodeAltitude(altitudeCoded)
-        return LOCRecord(version, size, horizontalPrecision, verticalPrecision, latitude, longitude, altitude)
-    }
-
-    fun readNAPTRRecord(): NAPTRRecord {
-        val order = readUInt16()
-        val preference = readUInt16()
-        val flags = readString()
-        val services = readString()
-        val regexp = readString()
-        val replacement = readDomainName()
-        return NAPTRRecord(order, preference, flags, services, regexp, replacement)
-    }
-
-    fun readDNAMERecord(): DNAMERecord {
-        return DNAMERecord(readDomainName())
-    }
-
-    fun readDSRecord(): DSRecord {
-        val keyTag = readUInt16()
-        val algorithm = readByte()
-        val digestType = readByte()
-        val digestLength = readUInt16().toInt() - 4
-        val digest = readBytes(digestLength)
-        return DSRecord(keyTag, algorithm, digestType, digest)
-    }
-
-    fun readSSHFPRecord(): SSHFPRecord {
-        val algorithm = readByte()
-        val fingerprintType = readByte()
-        val fingerprintLength = readUInt16().toInt() - 2
-        val fingerprint = readBytes(fingerprintLength)
-        return SSHFPRecord(algorithm, fingerprintType, fingerprint)
-    }
-
-    fun readTLSARecord(): TLSARecord {
-        val usage = readByte()
-        val selector = readByte()
-        val matchingType = readByte()
-        val dataLength = readUInt16().toInt() - 3
-        val certificateAssociationData = readBytes(dataLength)
-        return TLSARecord(usage, selector, matchingType, certificateAssociationData)
-    }
-
-    fun readSMIMEARecord(): SMIMEARecord {
-        val usage = readByte()
-        val selector = readByte()
-        val matchingType = readByte()
-        val dataLength = readUInt16().toInt() - 3
-        val certificateAssociationData = readBytes(dataLength)
-        return SMIMEARecord(usage, selector, matchingType, certificateAssociationData)
-    }
-
-    fun readURIRecord(): URIRecord {
-        val priority = readUInt16()
-        val weight = readUInt16()
-        val length = readUInt16().toInt()
-        val target = String(data, position, length, StandardCharsets.US_ASCII).also { position += length }
-        return URIRecord(priority, weight, target)
-    }
-
-    fun readRRSIGRecord(): RRSIGRecord {
-        val typeCovered = readUInt16()
-        val algorithm = readByte()
-        val labels = readByte()
-        val originalTTL = readUInt32()
-        val signatureExpiration = readUInt32()
-        val signatureInception = readUInt32()
-        val keyTag = readUInt16()
-        val signersName = readDomainName()
-        val signatureLength = readUInt16().toInt()
-        val signature = readBytes(signatureLength)
-        return RRSIGRecord(
-            typeCovered,
-            algorithm,
-            labels,
-            originalTTL,
-            signatureExpiration,
-            signatureInception,
-            keyTag,
-            signersName,
-            signature
-        )
-    }
-
-    fun readNSECRecord(): NSECRecord {
-        val ownerName = readDomainName()
-        val typeBitMaps = mutableListOf<Pair<Byte, ByteArray>>()
-        while (position < endPosition) {
-            val windowBlock = readByte()
-            val bitmapLength = readByte().toInt()
-            val bitmap = readBytes(bitmapLength)
-            typeBitMaps.add(windowBlock to bitmap)
-        }
-        return NSECRecord(ownerName, typeBitMaps)
-    }
-
-    fun readNSEC3Record(): NSEC3Record {
-        val hashAlgorithm = readByte()
-        val flags = readByte()
-        val iterations = readUInt16()
-        val saltLength = readByte().toInt()
-        val salt = readBytes(saltLength)
-        val hashLength = readByte().toInt()
-        val nextHashedOwnerName = readBytes(hashLength)
-        val bitMapLength = readUInt16().toInt()
-        val typeBitMaps = mutableListOf<UShort>()
-        val endPos = position + bitMapLength
-        while (position < endPos) {
-            typeBitMaps.add(readUInt16())
-        }
-        return NSEC3Record(hashAlgorithm, flags, iterations, salt, nextHashedOwnerName, typeBitMaps)
-    }
-
-    fun readNSEC3PARAMRecord(): NSEC3PARAMRecord {
-        val hashAlgorithm = readByte()
-        val flags = readByte()
-        val iterations = readUInt16()
-        val saltLength = readByte().toInt()
-        val salt = readBytes(saltLength)
-        return NSEC3PARAMRecord(hashAlgorithm, flags, iterations, salt)
-    }
-
-
-    fun readSPFRecord(): SPFRecord {
-        val length = readUInt16().toInt()
-        val texts = mutableListOf<String>()
-        val endPos = position + length
-        while (position < endPos) {
-            val textLength = readByte().toInt()
-            val text = String(data, position, textLength, StandardCharsets.US_ASCII).also { position += textLength }
-            texts.add(text)
-        }
-        return SPFRecord(texts)
-    }
-
-    fun readTKEYRecord(): TKEYRecord {
-        val algorithm = readDomainName()
-        val inception = readUInt32()
-        val expiration = readUInt32()
-        val mode = readUInt16()
-        val error = readUInt16()
-        val keySize = readUInt16().toInt()
-        val keyData = readBytes(keySize)
-        val otherSize = readUInt16().toInt()
-        val otherData = readBytes(otherSize)
-        return TKEYRecord(algorithm, inception, expiration, mode, error, keyData, otherData)
-    }
-
-    fun readTSIGRecord(): TSIGRecord {
-        val algorithmName = readDomainName()
-        val timeSigned = readUInt32()
-        val fudge = readUInt16()
-        val macSize = readUInt16().toInt()
-        val mac = readBytes(macSize)
-        val originalID = readUInt16()
-        val error = readUInt16()
-        val otherSize = readUInt16().toInt()
-        val otherData = readBytes(otherSize)
-        return TSIGRecord(algorithmName, timeSigned, fudge, mac, originalID, error, otherData)
-    }
-
-
-
-    fun readOPTRecord(): OPTRecord {
-        val options = mutableListOf<OPTRecordOption>()
-        while (position < endPosition) {
-            val optionCode = readUInt16()
-            val optionLength = readUInt16().toInt()
-            val optionData = readBytes(optionLength)
-            options.add(OPTRecordOption(optionCode, optionData))
-        }
-        return OPTRecord(options)
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/DnsResourceRecord.kt

@@ -1,117 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import com.futo.platformplayer.mdns.Extensions.readDomainName
-
-enum class ResourceRecordType(val value: UShort) {
-    None(0u),
-    A(1u),
-    NS(2u),
-    MD(3u),
-    MF(4u),
-    CNAME(5u),
-    SOA(6u),
-    MB(7u),
-    MG(8u),
-    MR(9u),
-    NULL(10u),
-    WKS(11u),
-    PTR(12u),
-    HINFO(13u),
-    MINFO(14u),
-    MX(15u),
-    TXT(16u),
-    RP(17u),
-    AFSDB(18u),
-    SIG(24u),
-    KEY(25u),
-    AAAA(28u),
-    LOC(29u),
-    SRV(33u),
-    NAPTR(35u),
-    KX(36u),
-    CERT(37u),
-    DNAME(39u),
-    APL(42u),
-    DS(43u),
-    SSHFP(44u),
-    IPSECKEY(45u),
-    RRSIG(46u),
-    NSEC(47u),
-    DNSKEY(48u),
-    DHCID(49u),
-    NSEC3(50u),
-    NSEC3PARAM(51u),
-    TSLA(52u),
-    SMIMEA(53u),
-    HIP(55u),
-    CDS(59u),
-    CDNSKEY(60u),
-    OPENPGPKEY(61u),
-    CSYNC(62u),
-    ZONEMD(63u),
-    SVCB(64u),
-    HTTPS(65u),
-    EUI48(108u),
-    EUI64(109u),
-    TKEY(249u),
-    TSIG(250u),
-    URI(256u),
-    CAA(257u),
-    TA(32768u),
-    DLV(32769u),
-    AXFR(252u),
-    IXFR(251u),
-    OPT(41u)
-}
-
-enum class ResourceRecordClass(val value: UShort) {
-    IN(1u),
-    CS(2u),
-    CH(3u),
-    HS(4u)
-}
-
-data class DnsResourceRecord(
-    override val name: String,
-    override val type: Int,
-    override val clazz: Int,
-    val timeToLive: UInt,
-    val cacheFlush: Boolean,
-    val dataPosition: Int = -1,
-    val dataLength: Int = -1,
-    private val data: ByteArray? = null
-) : DnsResourceRecordBase(name, type, clazz) {
-
-    companion object {
-        fun parse(data: ByteArray, startPosition: Int): Pair<DnsResourceRecord, Int> {
-            val span = data.asUByteArray()
-            var position = startPosition
-            val name = span.readDomainName(position).also { position = it.second }
-            val type = (span[position].toInt() shl 8 or span[position + 1].toInt()).toUShort()
-            position += 2
-            val clazz = (span[position].toInt() shl 8 or span[position + 1].toInt()).toUShort()
-            position += 2
-            val ttl = (span[position].toInt() shl 24 or (span[position + 1].toInt() shl 16) or
-                    (span[position + 2].toInt() shl 8) or span[position + 3].toInt()).toUInt()
-            position += 4
-            val rdlength = (span[position].toInt() shl 8 or span[position + 1].toInt()).toUShort()
-            val rdposition = position + 2
-            position += 2 + rdlength.toInt()
-
-            return DnsResourceRecord(
-                name = name.first,
-                type = type.toInt(),
-                clazz = clazz.toInt() and 0b1111111_11111111,
-                timeToLive = ttl,
-                cacheFlush = ((clazz.toInt() shr 15) and 0b1) != 0,
-                dataPosition = rdposition,
-                dataLength = rdlength.toInt(),
-                data = data
-            ) to position
-        }
-    }
-
-    fun getDataReader(): DnsReader {
-        return DnsReader(data!!, dataPosition, dataLength)
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/DnsWriter.kt

@@ -1,208 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import java.nio.charset.StandardCharsets
-
-class DnsWriter {
-    private val data = mutableListOf<Byte>()
-    private val namePositions = mutableMapOf<String, Int>()
-
-    fun toByteArray(): ByteArray = data.toByteArray()
-
-    fun writePacket(
-        header: DnsPacketHeader,
-        questionCount: Int? = null, questionWriter: ((DnsWriter, Int) -> Unit)? = null,
-        answerCount: Int? = null, answerWriter: ((DnsWriter, Int) -> Unit)? = null,
-        authorityCount: Int? = null, authorityWriter: ((DnsWriter, Int) -> Unit)? = null,
-        additionalsCount: Int? = null, additionalWriter: ((DnsWriter, Int) -> Unit)? = null
-    ) {
-        if (questionCount != null && questionWriter == null || questionCount == null && questionWriter != null)
-            throw Exception("When question count is given, question writer should also be given.")
-        if (answerCount != null && answerWriter == null || answerCount == null && answerWriter != null)
-            throw Exception("When answer count is given, answer writer should also be given.")
-        if (authorityCount != null && authorityWriter == null || authorityCount == null && authorityWriter != null)
-            throw Exception("When authority count is given, authority writer should also be given.")
-        if (additionalsCount != null && additionalWriter == null || additionalsCount == null && additionalWriter != null)
-            throw Exception("When additionals count is given, additional writer should also be given.")
-
-        writeHeader(header, questionCount ?: 0, answerCount ?: 0, authorityCount ?: 0, additionalsCount ?: 0)
-
-        repeat(questionCount ?: 0) { questionWriter?.invoke(this, it) }
-        repeat(answerCount ?: 0) { answerWriter?.invoke(this, it) }
-        repeat(authorityCount ?: 0) { authorityWriter?.invoke(this, it) }
-        repeat(additionalsCount ?: 0) { additionalWriter?.invoke(this, it) }
-    }
-
-    fun writeHeader(header: DnsPacketHeader, questionCount: Int, answerCount: Int, authorityCount: Int, additionalsCount: Int) {
-        write(header.identifier)
-
-        var flags: UShort = 0u
-        flags = flags or ((header.queryResponse.toUInt() and 0xFFFFu) shl 15).toUShort()
-        flags = flags or ((header.opcode.toUInt() and 0xFFFFu) shl 11).toUShort()
-        flags = flags or ((if (header.authoritativeAnswer) 1u else 0u) shl 10).toUShort()
-        flags = flags or ((if (header.truncated) 1u else 0u) shl 9).toUShort()
-        flags = flags or ((if (header.recursionDesired) 1u else 0u) shl 8).toUShort()
-        flags = flags or ((if (header.recursionAvailable) 1u else 0u) shl 7).toUShort()
-        flags = flags or ((if (header.answerAuthenticated) 1u else 0u) shl 5).toUShort()
-        flags = flags or ((if (header.nonAuthenticatedData) 1u else 0u) shl 4).toUShort()
-        flags = flags or header.responseCode.value.toUShort()
-        write(flags)
-
-        write(questionCount.toUShort())
-        write(answerCount.toUShort())
-        write(authorityCount.toUShort())
-        write(additionalsCount.toUShort())
-    }
-
-    fun writeDomainName(name: String) {
-        synchronized(namePositions) {
-            val labels = name.split('.')
-            for (label in labels) {
-                val nameAtOffset = name.substring(name.indexOf(label))
-                if (namePositions.containsKey(nameAtOffset)) {
-                    val position = namePositions[nameAtOffset]!!
-                    val pointer = (0b11000000_00000000 or position).toUShort()
-                    write(pointer)
-                    return
-                }
-                if (label.isNotEmpty()) {
-                    val labelBytes = label.toByteArray(StandardCharsets.UTF_8)
-                    val nameStartPos = data.size
-                    write(labelBytes.size.toByte())
-                    write(labelBytes)
-                    namePositions[nameAtOffset] = nameStartPos
-                }
-            }
-            write(0.toByte())
-        }
-    }
-
-    fun write(value: DnsResourceRecord, dataWriter: (DnsWriter) -> Unit) {
-        writeDomainName(value.name)
-        write(value.type.toUShort())
-        val cls = ((if (value.cacheFlush) 1u else 0u) shl 15).toUShort() or value.clazz.toUShort()
-        write(cls)
-        write(value.timeToLive)
-
-        val lengthOffset = data.size
-        write(0.toUShort())
-        dataWriter(this)
-        val rdLength = data.size - lengthOffset - 2
-        val rdLengthBytes = ByteBuffer.allocate(2).order(ByteOrder.BIG_ENDIAN).putShort(rdLength.toShort()).array()
-        data[lengthOffset] = rdLengthBytes[0]
-        data[lengthOffset + 1] = rdLengthBytes[1]
-    }
-
-    fun write(value: DnsQuestion) {
-        writeDomainName(value.name)
-        write(value.type.toUShort())
-        write(((if (value.queryUnicast) 1u else 0u shl 15).toUShort() or value.clazz.toUShort()))
-    }
-
-    fun write(value: Double) {
-        val bytes = ByteBuffer.allocate(Double.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putDouble(value).array()
-        write(bytes)
-    }
-
-    fun write(value: Short) {
-        val bytes = ByteBuffer.allocate(Short.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putShort(value).array()
-        write(bytes)
-    }
-
-    fun write(value: Int) {
-        val bytes = ByteBuffer.allocate(Int.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putInt(value).array()
-        write(bytes)
-    }
-
-    fun write(value: Long) {
-        val bytes = ByteBuffer.allocate(Long.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putLong(value).array()
-        write(bytes)
-    }
-
-    fun write(value: Float) {
-        val bytes = ByteBuffer.allocate(Float.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putFloat(value).array()
-        write(bytes)
-    }
-
-    fun write(value: Byte) {
-        data.add(value)
-    }
-
-    fun write(value: ByteArray) {
-        data.addAll(value.asIterable())
-    }
-
-    fun write(value: ByteArray, offset: Int, length: Int) {
-        data.addAll(value.slice(offset until offset + length))
-    }
-
-    fun write(value: UShort) {
-        val bytes = ByteBuffer.allocate(Short.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putShort(value.toShort()).array()
-        write(bytes)
-    }
-
-    fun write(value: UInt) {
-        val bytes = ByteBuffer.allocate(Int.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putInt(value.toInt()).array()
-        write(bytes)
-    }
-
-    fun write(value: ULong) {
-        val bytes = ByteBuffer.allocate(Long.SIZE_BYTES).order(ByteOrder.BIG_ENDIAN).putLong(value.toLong()).array()
-        write(bytes)
-    }
-
-    fun write(value: String) {
-        val bytes = value.toByteArray(StandardCharsets.UTF_8)
-        write(bytes.size.toByte())
-        write(bytes)
-    }
-
-    fun write(value: PTRRecord) {
-        writeDomainName(value.domainName)
-    }
-
-    fun write(value: ARecord) {
-        val bytes = value.address.address
-        if (bytes.size != 4) throw Exception("Unexpected amount of address bytes.")
-        write(bytes)
-    }
-
-    fun write(value: AAAARecord) {
-        val bytes = value.address.address
-        if (bytes.size != 16) throw Exception("Unexpected amount of address bytes.")
-        write(bytes)
-    }
-
-    fun write(value: TXTRecord) {
-        value.texts.forEach {
-            val bytes = it.toByteArray(StandardCharsets.UTF_8)
-            write(bytes.size.toByte())
-            write(bytes)
-        }
-    }
-
-    fun write(value: SRVRecord) {
-        write(value.priority)
-        write(value.weight)
-        write(value.port)
-        writeDomainName(value.target)
-    }
-
-    fun write(value: NSECRecord) {
-        writeDomainName(value.ownerName)
-        value.typeBitMaps.forEach { (windowBlock, bitmap) ->
-            write(windowBlock)
-            write(bitmap.size.toByte())
-            write(bitmap)
-        }
-    }
-
-    fun write(value: OPTRecord) {
-        value.options.forEach { option ->
-            write(option.code)
-            write(option.data.size.toUShort())
-            write(option.data)
-        }
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/Extensions.kt

@@ -1,63 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import android.util.Log
-
-object Extensions {
-    fun ByteArray.toByteDump(): String {
-        val result = StringBuilder()
-        for (i in indices) {
-            result.append(String.format("%02X ", this[i]))
-
-            if ((i + 1) % 16 == 0 || i == size - 1) {
-                val padding = 3 * (16 - (i % 16 + 1))
-                if (i == size - 1 && (i + 1) % 16 != 0) result.append(" ".repeat(padding))
-
-                result.append("; ")
-                val start = i - (i % 16)
-                val end = minOf(i, size - 1)
-                for (j in start..end) {
-                    val ch = if (this[j] in 32..127) this[j].toChar() else '.'
-                    result.append(ch)
-                }
-                if (i != size - 1) result.appendLine()
-            }
-        }
-        return result.toString()
-    }
-
-    fun UByteArray.readDomainName(startPosition: Int): Pair<String, Int> {
-        var position = startPosition
-        return readDomainName(position, 0)
-    }
-
-    private fun UByteArray.readDomainName(position: Int, depth: Int = 0): Pair<String, Int> {
-        if (depth > 16) throw Exception("Exceeded maximum recursion depth in DNS packet. Possible circular reference.")
-
-        val domainParts = mutableListOf<String>()
-        var newPosition = position
-
-        while (true) {
-            if (newPosition < 0)
-                println()
-
-            val length = this[newPosition].toUByte()
-            if ((length and 0b11000000u).toUInt() == 0b11000000u) {
-                val offset = (((length and 0b00111111u).toUInt()) shl 8) or this[newPosition + 1].toUInt()
-                val (part, _) = this.readDomainName(offset.toInt(), depth + 1)
-                domainParts.add(part)
-                newPosition += 2
-                break
-            } else if (length.toUInt() == 0u) {
-                newPosition++
-                break
-            } else {
-                newPosition++
-                val part = String(this.asByteArray(), newPosition, length.toInt(), Charsets.UTF_8)
-                domainParts.add(part)
-                newPosition += length.toInt()
-            }
-        }
-
-        return domainParts.joinToString(".") to newPosition
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/MDNSListener.kt

@@ -1,495 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import com.futo.platformplayer.logging.Logger
-import kotlinx.coroutines.*
-import java.net.*
-import java.util.*
-import java.util.concurrent.locks.ReentrantLock
-import kotlin.concurrent.withLock
-
-class MDNSListener {
-    companion object {
-        private val TAG = "MDNSListener"
-        const val MulticastPort = 5353
-        val MulticastAddressIPv4: InetAddress = InetAddress.getByName("224.0.0.251")
-        val MulticastAddressIPv6: InetAddress = InetAddress.getByName("FF02::FB")
-        val MdnsEndpointIPv6: InetSocketAddress = InetSocketAddress(MulticastAddressIPv6, MulticastPort)
-        val MdnsEndpointIPv4: InetSocketAddress = InetSocketAddress(MulticastAddressIPv4, MulticastPort)
-    }
-
-    private val _lockObject = ReentrantLock()
-    private var _receiver4: MulticastSocket? = null
-    private var _receiver6: MulticastSocket? = null
-    private val _senders = mutableListOf<MulticastSocket>()
-    private val _nicMonitor = NICMonitor()
-    private val _serviceRecordAggregator = ServiceRecordAggregator()
-    private var _started = false
-    private var _threadReceiver4: Thread? = null
-    private var _threadReceiver6: Thread? = null
-    private var _scope: CoroutineScope? = null
-
-    var onPacket: ((DnsPacket) -> Unit)? = null
-    var onServicesUpdated: ((List<DnsService>) -> Unit)? = null
-
-    private val _recordLockObject = ReentrantLock()
-    private val _recordsA = mutableListOf<Pair<DnsResourceRecord, ARecord>>()
-    private val _recordsAAAA = mutableListOf<Pair<DnsResourceRecord, AAAARecord>>()
-    private val _recordsPTR = mutableListOf<Pair<DnsResourceRecord, PTRRecord>>()
-    private val _recordsTXT = mutableListOf<Pair<DnsResourceRecord, TXTRecord>>()
-    private val _recordsSRV = mutableListOf<Pair<DnsResourceRecord, SRVRecord>>()
-    private val _services = mutableListOf<BroadcastService>()
-
-    init {
-        _nicMonitor.added = { onNicsAdded(it) }
-        _nicMonitor.removed = { onNicsRemoved(it) }
-        _serviceRecordAggregator.onServicesUpdated = { onServicesUpdated?.invoke(it) }
-    }
-
-    fun start() {
-        if (_started) {
-            Logger.i(TAG, "Already started.")
-            return
-        }
-        _started = true
-
-        _scope = CoroutineScope(Dispatchers.IO);
-
-        Logger.i(TAG, "Starting")
-        _lockObject.withLock {
-            val receiver4 = MulticastSocket(null).apply {
-                reuseAddress = true
-                bind(InetSocketAddress(InetAddress.getByName("0.0.0.0"), MulticastPort))
-            }
-            _receiver4 = receiver4
-
-            val receiver6 = MulticastSocket(null).apply {
-                reuseAddress = true
-                bind(InetSocketAddress(InetAddress.getByName("::"), MulticastPort))
-            }
-            _receiver6 = receiver6
-
-            _nicMonitor.start()
-            _serviceRecordAggregator.start()
-            onNicsAdded(_nicMonitor.current)
-
-            _threadReceiver4 = Thread {
-                receiveLoop(receiver4)
-            }.apply { start() }
-
-            _threadReceiver6 = Thread {
-                receiveLoop(receiver6)
-            }.apply { start() }
-        }
-    }
-
-    fun queryServices(names: Array<String>) {
-        if (names.isEmpty()) throw IllegalArgumentException("At least one name must be specified.")
-
-        val writer = DnsWriter()
-        writer.writePacket(
-            DnsPacketHeader(
-                identifier = 0u,
-                queryResponse = QueryResponse.Query.value.toInt(),
-                opcode = DnsOpcode.StandardQuery.value.toInt(),
-                truncated = false,
-                nonAuthenticatedData = false,
-                recursionDesired = false,
-                answerAuthenticated = false,
-                authoritativeAnswer = false,
-                recursionAvailable = false,
-                responseCode = DnsResponseCode.NoError
-            ),
-            questionCount = names.size,
-            questionWriter = { w, i ->
-                w.write(
-                    DnsQuestion(
-                        name = names[i],
-                        type = QuestionType.PTR.value.toInt(),
-                        clazz = QuestionClass.IN.value.toInt(),
-                        queryUnicast = false
-                    )
-                )
-            }
-        )
-
-        send(writer.toByteArray())
-    }
-
-    private fun send(data: ByteArray) {
-        _lockObject.withLock {
-            for (sender in _senders) {
-                try {
-                    val endPoint = if (sender.localAddress is Inet4Address) MdnsEndpointIPv4 else MdnsEndpointIPv6
-                    sender.send(DatagramPacket(data, data.size, endPoint))
-                } catch (e: Exception) {
-                    Logger.i(TAG, "Failed to send on ${sender.localSocketAddress}: ${e.message}.")
-                }
-            }
-        }
-    }
-
-    fun queryAllQuestions(names: Array<String>) {
-        if (names.isEmpty()) throw IllegalArgumentException("At least one name must be specified.")
-
-        val questions = names.flatMap { _serviceRecordAggregator.getAllQuestions(it) }
-        questions.groupBy { it.name }.forEach { (_, questionsForHost) ->
-            val writer = DnsWriter()
-            writer.writePacket(
-                DnsPacketHeader(
-                    identifier = 0u,
-                    queryResponse = QueryResponse.Query.value.toInt(),
-                    opcode = DnsOpcode.StandardQuery.value.toInt(),
-                    truncated = false,
-                    nonAuthenticatedData = false,
-                    recursionDesired = false,
-                    answerAuthenticated = false,
-                    authoritativeAnswer = false,
-                    recursionAvailable = false,
-                    responseCode = DnsResponseCode.NoError
-                ),
-                questionCount = questionsForHost.size,
-                questionWriter = { w, i -> w.write(questionsForHost[i]) }
-            )
-            send(writer.toByteArray())
-        }
-    }
-
-    private fun onNicsAdded(nics: List<NetworkInterface>) {
-        _lockObject.withLock {
-            if (!_started) return
-
-            val addresses = nics.flatMap { nic ->
-                nic.interfaceAddresses.map { it.address }
-                    .filter { it is Inet4Address || (it is Inet6Address && it.isLinkLocalAddress) }
-            }
-
-            addresses.forEach { address ->
-                Logger.i(TAG, "New address discovered $address")
-
-                try {
-                    when (address) {
-                        is Inet4Address -> {
-                            _receiver4?.let { receiver4 ->
-                                //receiver4.setOption(StandardSocketOptions.IP_MULTICAST_IF, NetworkInterface.getByInetAddress(address))
-                                receiver4.joinGroup(InetSocketAddress(MulticastAddressIPv4, MulticastPort), NetworkInterface.getByInetAddress(address))
-                            }
-
-                            val sender = MulticastSocket(null).apply {
-                                reuseAddress = true
-                                bind(InetSocketAddress(address, MulticastPort))
-                                joinGroup(InetSocketAddress(MulticastAddressIPv4, MulticastPort), NetworkInterface.getByInetAddress(address))
-                            }
-                            _senders.add(sender)
-                        }
-
-                        is Inet6Address -> {
-                            _receiver6?.let { receiver6 ->
-                                //receiver6.setOption(StandardSocketOptions.IP_MULTICAST_IF, NetworkInterface.getByInetAddress(address))
-                                receiver6.joinGroup(InetSocketAddress(MulticastAddressIPv6, MulticastPort), NetworkInterface.getByInetAddress(address))
-                            }
-
-                            val sender = MulticastSocket(null).apply {
-                                reuseAddress = true
-                                bind(InetSocketAddress(address, MulticastPort))
-                                joinGroup(InetSocketAddress(MulticastAddressIPv6, MulticastPort), NetworkInterface.getByInetAddress(address))
-                            }
-                            _senders.add(sender)
-                        }
-
-                        else -> throw UnsupportedOperationException("Address type ${address.javaClass.name} is not supported.")
-                    }
-                } catch (e: Exception) {
-                    Logger.i(TAG, "Exception occurred when processing added address $address: ${e.message}.")
-                    // Close the socket if there was an error
-                    (_senders.lastOrNull() as? MulticastSocket)?.close()
-                }
-            }
-        }
-
-        if (nics.isNotEmpty()) {
-            try {
-                updateBroadcastRecords()
-                broadcastRecords()
-            } catch (e: Exception) {
-                Logger.i(TAG, "Exception occurred when broadcasting records: ${e.message}.")
-            }
-        }
-    }
-
-    private fun onNicsRemoved(nics: List<NetworkInterface>) {
-        _lockObject.withLock {
-            if (!_started) return
-            //TODO: Cleanup?
-        }
-
-        if (nics.isNotEmpty()) {
-            try {
-                updateBroadcastRecords()
-                broadcastRecords()
-            } catch (e: Exception) {
-                Logger.e(TAG, "Exception occurred when broadcasting records", e)
-            }
-        }
-    }
-
-    private fun receiveLoop(client: DatagramSocket) {
-        Logger.i(TAG, "Started receive loop")
-
-        val buffer = ByteArray(8972)
-        val packet = DatagramPacket(buffer, buffer.size)
-        while (_started) {
-            try {
-                client.receive(packet)
-                handleResult(packet)
-            } catch (e: Exception) {
-                Logger.e(TAG, "An exception occurred while handling UDP result:", e)
-            }
-        }
-
-        Logger.i(TAG, "Stopped receive loop")
-    }
-
-    fun broadcastService(
-        deviceName: String,
-        serviceName: String,
-        port: UShort,
-        ttl: UInt = 120u,
-        weight: UShort = 0u,
-        priority: UShort = 0u,
-        texts: List<String>? = null
-    ) {
-        _recordLockObject.withLock {
-            _services.add(
-                BroadcastService(
-                    deviceName = deviceName,
-                    port = port,
-                    priority = priority,
-                    serviceName = serviceName,
-                    texts = texts,
-                    ttl = ttl,
-                    weight = weight
-                )
-            )
-        }
-
-        updateBroadcastRecords()
-        broadcastRecords()
-    }
-
-    private fun updateBroadcastRecords() {
-        _recordLockObject.withLock {
-            _recordsSRV.clear()
-            _recordsPTR.clear()
-            _recordsA.clear()
-            _recordsAAAA.clear()
-            _recordsTXT.clear()
-
-            _services.forEach { service ->
-                val id = UUID.randomUUID().toString()
-                val deviceDomainName = "${service.deviceName}.${service.serviceName}"
-                val addressName = "$id.local"
-
-                _recordsSRV.add(
-                    DnsResourceRecord(
-                        clazz = ResourceRecordClass.IN.value.toInt(),
-                        type = ResourceRecordType.SRV.value.toInt(),
-                        timeToLive = service.ttl,
-                        name = deviceDomainName,
-                        cacheFlush = false
-                    ) to SRVRecord(
-                        target = addressName,
-                        port = service.port,
-                        priority = service.priority,
-                        weight = service.weight
-                    )
-                )
-
-                _recordsPTR.add(
-                    DnsResourceRecord(
-                        clazz = ResourceRecordClass.IN.value.toInt(),
-                        type = ResourceRecordType.PTR.value.toInt(),
-                        timeToLive = service.ttl,
-                        name = service.serviceName,
-                        cacheFlush = false
-                    ) to PTRRecord(
-                        domainName = deviceDomainName
-                    )
-                )
-
-                val addresses = _nicMonitor.current.flatMap { nic ->
-                    nic.interfaceAddresses.map { it.address }
-                }
-
-                addresses.forEach { address ->
-                    when (address) {
-                        is Inet4Address -> _recordsA.add(
-                            DnsResourceRecord(
-                                clazz = ResourceRecordClass.IN.value.toInt(),
-                                type = ResourceRecordType.A.value.toInt(),
-                                timeToLive = service.ttl,
-                                name = addressName,
-                                cacheFlush = false
-                            ) to ARecord(
-                                address = address
-                            )
-                        )
-
-                        is Inet6Address -> _recordsAAAA.add(
-                            DnsResourceRecord(
-                                clazz = ResourceRecordClass.IN.value.toInt(),
-                                type = ResourceRecordType.AAAA.value.toInt(),
-                                timeToLive = service.ttl,
-                                name = addressName,
-                                cacheFlush = false
-                            ) to AAAARecord(
-                                address = address
-                            )
-                        )
-
-                        else -> Logger.i(TAG, "Invalid address type: $address.")
-                    }
-                }
-
-                if (service.texts != null) {
-                    _recordsTXT.add(
-                        DnsResourceRecord(
-                            clazz = ResourceRecordClass.IN.value.toInt(),
-                            type = ResourceRecordType.TXT.value.toInt(),
-                            timeToLive = service.ttl,
-                            name = deviceDomainName,
-                            cacheFlush = false
-                        ) to TXTRecord(
-                            texts = service.texts
-                        )
-                    )
-                }
-            }
-        }
-    }
-
-    private fun broadcastRecords(questions: List<DnsQuestion>? = null) {
-        val writer = DnsWriter()
-        _recordLockObject.withLock {
-            val recordsA: List<Pair<DnsResourceRecord, ARecord>>
-            val recordsAAAA: List<Pair<DnsResourceRecord, AAAARecord>>
-            val recordsPTR: List<Pair<DnsResourceRecord, PTRRecord>>
-            val recordsTXT: List<Pair<DnsResourceRecord, TXTRecord>>
-            val recordsSRV: List<Pair<DnsResourceRecord, SRVRecord>>
-
-            if (questions != null) {
-                recordsA = _recordsA.filter { r -> questions.any { q -> q.name == r.first.name && q.clazz == r.first.clazz && q.type == r.first.type } }
-                recordsAAAA = _recordsAAAA.filter { r -> questions.any { q -> q.name == r.first.name && q.clazz == r.first.clazz && q.type == r.first.type } }
-                recordsPTR = _recordsPTR.filter { r -> questions.any { q -> q.name == r.first.name && q.clazz == r.first.clazz && q.type == r.first.type } }
-                recordsSRV = _recordsSRV.filter { r -> questions.any { q -> q.name == r.first.name && q.clazz == r.first.clazz && q.type == r.first.type } }
-                recordsTXT = _recordsTXT.filter { r -> questions.any { q -> q.name == r.first.name && q.clazz == r.first.clazz && q.type == r.first.type } }
-            } else {
-                recordsA = _recordsA
-                recordsAAAA = _recordsAAAA
-                recordsPTR = _recordsPTR
-                recordsSRV = _recordsSRV
-                recordsTXT = _recordsTXT
-            }
-
-            val answerCount = recordsA.size + recordsAAAA.size + recordsPTR.size + recordsSRV.size + recordsTXT.size
-            if (answerCount < 1) return
-
-            val txtOffset = recordsA.size + recordsAAAA.size + recordsPTR.size + recordsSRV.size
-            val srvOffset = recordsA.size + recordsAAAA.size + recordsPTR.size
-            val ptrOffset = recordsA.size + recordsAAAA.size
-            val aaaaOffset = recordsA.size
-
-            writer.writePacket(
-                DnsPacketHeader(
-                    identifier = 0u,
-                    queryResponse = QueryResponse.Response.value.toInt(),
-                    opcode = DnsOpcode.StandardQuery.value.toInt(),
-                    truncated = false,
-                    nonAuthenticatedData = false,
-                    recursionDesired = false,
-                    answerAuthenticated = false,
-                    authoritativeAnswer = true,
-                    recursionAvailable = false,
-                    responseCode = DnsResponseCode.NoError
-                ),
-                answerCount = answerCount,
-                answerWriter = { w, i ->
-                    when {
-                        i >= txtOffset -> {
-                            val record = recordsTXT[i - txtOffset]
-                            w.write(record.first) { it.write(record.second) }
-                        }
-
-                        i >= srvOffset -> {
-                            val record = recordsSRV[i - srvOffset]
-                            w.write(record.first) { it.write(record.second) }
-                        }
-
-                        i >= ptrOffset -> {
-                            val record = recordsPTR[i - ptrOffset]
-                            w.write(record.first) { it.write(record.second) }
-                        }
-
-                        i >= aaaaOffset -> {
-                            val record = recordsAAAA[i - aaaaOffset]
-                            w.write(record.first) { it.write(record.second) }
-                        }
-
-                        else -> {
-                            val record = recordsA[i]
-                            w.write(record.first) { it.write(record.second) }
-                        }
-                    }
-                }
-            )
-        }
-
-        send(writer.toByteArray())
-    }
-
-    private fun handleResult(result: DatagramPacket) {
-        try {
-            val packet = DnsPacket.parse(result.data)
-            if (packet.questions.isNotEmpty()) {
-                _scope?.launch(Dispatchers.IO) {
-                    try {
-                        broadcastRecords(packet.questions)
-                    } catch (e: Throwable) {
-                        Logger.i(TAG, "Broadcasting records failed", e)
-                    }
-                }
-
-            }
-            _serviceRecordAggregator.add(packet)
-            onPacket?.invoke(packet)
-        } catch (e: Exception) {
-            Logger.v(TAG, "Failed to handle packet: ${Base64.getEncoder().encodeToString(result.data.slice(IntRange(0, result.length - 1)).toByteArray())}", e)
-        }
-    }
-
-    fun stop() {
-        _lockObject.withLock {
-            _started = false
-
-            _scope?.cancel()
-            _scope = null
-
-            _nicMonitor.stop()
-            _serviceRecordAggregator.stop()
-
-            _receiver4?.close()
-            _receiver4 = null
-
-            _receiver6?.close()
-            _receiver6 = null
-
-            _senders.forEach { it.close() }
-            _senders.clear()
-        }
-
-        _threadReceiver4?.join()
-        _threadReceiver4 = null
-
-        _threadReceiver6?.join()
-        _threadReceiver6 = null
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/NICMonitor.kt

@@ -1,66 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import kotlinx.coroutines.*
-import java.net.NetworkInterface
-
-class NICMonitor {
-    private val lockObject = Any()
-    private val nics = mutableListOf<NetworkInterface>()
-    private var cts: Job? = null
-
-    val current: List<NetworkInterface>
-        get() = synchronized(nics) { nics.toList() }
-
-    var added: ((List<NetworkInterface>) -> Unit)? = null
-    var removed: ((List<NetworkInterface>) -> Unit)? = null
-
-    fun start() {
-        synchronized(lockObject) {
-            if (cts != null) throw Exception("Already started.")
-
-            cts = CoroutineScope(Dispatchers.Default).launch {
-                loopAsync()
-            }
-        }
-
-        nics.clear()
-        nics.addAll(getCurrentInterfaces().toList())
-    }
-
-    fun stop() {
-        synchronized(lockObject) {
-            cts?.cancel()
-            cts = null
-        }
-
-        synchronized(nics) {
-            nics.clear()
-        }
-    }
-
-    private suspend fun loopAsync() {
-        while (cts?.isActive == true) {
-            try {
-                val currentNics = getCurrentInterfaces().toList()
-                removed?.invoke(nics.filter { k -> currentNics.none { n -> k.name == n.name } })
-                added?.invoke(currentNics.filter { nic -> nics.none { k -> k.name == nic.name } })
-
-                synchronized(nics) {
-                    nics.clear()
-                    nics.addAll(currentNics)
-                }
-            } catch (ex: Exception) {
-                // Ignored
-            }
-            delay(5000)
-        }
-    }
-
-    private fun getCurrentInterfaces(): List<NetworkInterface> {
-        val nics = NetworkInterface.getNetworkInterfaces().toList()
-            .filter { it.isUp && !it.isLoopback }
-
-        return if (nics.isNotEmpty()) nics else NetworkInterface.getNetworkInterfaces().toList()
-            .filter { it.isUp }
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/ServiceDiscoverer.kt

@@ -1,71 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import com.futo.platformplayer.logging.Logger
-import java.lang.Thread.sleep
-
-class ServiceDiscoverer(names: Array<String>, private val _onServicesUpdated: (List<DnsService>) -> Unit) {
-    private val _names: Array<String>
-    private var _listener: MDNSListener? = null
-    private var _started = false
-    private var _thread: Thread? = null
-
-    init {
-        if (names.isEmpty()) throw IllegalArgumentException("At least one name must be specified.")
-        _names = names
-    }
-
-    fun broadcastService(
-        deviceName: String,
-        serviceName: String,
-        port: UShort,
-        ttl: UInt = 120u,
-        weight: UShort = 0u,
-        priority: UShort = 0u,
-        texts: List<String>? = null
-    ) {
-        _listener?.let {
-            it.broadcastService(deviceName, serviceName, port, ttl, weight, priority, texts)
-        }
-    }
-
-    fun stop() {
-        _started = false
-        _listener?.stop()
-        _listener = null
-        _thread?.join()
-        _thread = null
-    }
-
-    fun start() {
-        if (_started) {
-            Logger.i(TAG, "Already started.")
-            return
-        }
-        _started = true
-
-        val listener = MDNSListener()
-        _listener = listener
-        listener.onServicesUpdated = { _onServicesUpdated?.invoke(it) }
-        listener.start()
-
-        _thread = Thread {
-            try {
-                sleep(2000)
-
-                while (_started) {
-                    listener.queryServices(_names)
-                    sleep(2000)
-                    listener.queryAllQuestions(_names)
-                    sleep(2000)
-                }
-            } catch (e: Throwable) {
-                Logger.i(TAG, "Exception in loop thread", e)
-                stop()
-            }
-        }.apply { start() }
-    }
-
-    companion object {
-        private val TAG = "ServiceDiscoverer"
-    }
-}

app/src/main/java/com/futo/platformplayer/mdns/ServiceRecordAggregator.kt

@@ -1,226 +0,0 @@
-package com.futo.platformplayer.mdns
-
-import com.futo.platformplayer.logging.Logger
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.Job
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.isActive
-import kotlinx.coroutines.launch
-import java.net.InetAddress
-import java.util.Date
-
-data class DnsService(
-    var name: String,
-    var target: String,
-    var port: UShort,
-    val addresses: MutableList<InetAddress> = mutableListOf(),
-    val pointers: MutableList<String> = mutableListOf(),
-    val texts: MutableList<String> = mutableListOf()
-)
-
-data class CachedDnsAddressRecord(
-    val expirationTime: Date,
-    val address: InetAddress
-)
-
-data class CachedDnsTxtRecord(
-    val expirationTime: Date,
-    val texts: List<String>
-)
-
-data class CachedDnsPtrRecord(
-    val expirationTime: Date,
-    val target: String
-)
-
-data class CachedDnsSrvRecord(
-    val expirationTime: Date,
-    val service: SRVRecord
-)
-
-class ServiceRecordAggregator {
-    private val _lockObject = Any()
-    private val _cachedAddressRecords = mutableMapOf<String, MutableList<CachedDnsAddressRecord>>()
-    private val _cachedTxtRecords = mutableMapOf<String, CachedDnsTxtRecord>()
-    private val _cachedPtrRecords = mutableMapOf<String, MutableList<CachedDnsPtrRecord>>()
-    private val _cachedSrvRecords = mutableMapOf<String, CachedDnsSrvRecord>()
-    private val _currentServices = mutableListOf<DnsService>()
-    private var _cts: Job? = null
-
-    var onServicesUpdated: ((List<DnsService>) -> Unit)? = null
-
-    fun start() {
-        synchronized(_lockObject) {
-            if (_cts != null) throw Exception("Already started.")
-
-            _cts = CoroutineScope(Dispatchers.Default).launch {
-                try {
-                    while (isActive) {
-                        val now = Date()
-                        synchronized(_currentServices) {
-                            _cachedAddressRecords.forEach { it.value.removeAll { record -> now.after(record.expirationTime) } }
-                            _cachedTxtRecords.entries.removeIf { now.after(it.value.expirationTime) }
-                            _cachedSrvRecords.entries.removeIf { now.after(it.value.expirationTime) }
-                            _cachedPtrRecords.forEach { it.value.removeAll { record -> now.after(record.expirationTime) } }
-
-                            val newServices = getCurrentServices()
-                            _currentServices.clear()
-                            _currentServices.addAll(newServices)
-                        }
-
-                        onServicesUpdated?.invoke(_currentServices.toList())
-                        delay(5000)
-                    }
-                } catch (e: Throwable) {
-                    Logger.e(TAG, "Unexpected failure in MDNS loop", e)
-                }
-            }
-        }
-    }
-
-    fun stop() {
-        synchronized(_lockObject) {
-            _cts?.cancel()
-            _cts = null
-        }
-    }
-
-    fun add(packet: DnsPacket) {
-        val currentServices: List<DnsService>
-        val dnsResourceRecords = packet.answers + packet.additionals + packet.authorities
-        val txtRecords = dnsResourceRecords.filter { it.type == ResourceRecordType.TXT.value.toInt() }.map { it to it.getDataReader().readTXTRecord() }
-        val aRecords = dnsResourceRecords.filter { it.type == ResourceRecordType.A.value.toInt() }.map { it to it.getDataReader().readARecord() }
-        val aaaaRecords = dnsResourceRecords.filter { it.type == ResourceRecordType.AAAA.value.toInt() }.map { it to it.getDataReader().readAAAARecord() }
-        val srvRecords = dnsResourceRecords.filter { it.type == ResourceRecordType.SRV.value.toInt() }.map { it to it.getDataReader().readSRVRecord() }
-        val ptrRecords = dnsResourceRecords.filter { it.type == ResourceRecordType.PTR.value.toInt() }.map { it to it.getDataReader().readPTRRecord() }
-
-        /*val builder = StringBuilder()
-        builder.appendLine("Received records:")
-        srvRecords.forEach { builder.appendLine("SRV ${it.first.name} ${it.first.type} ${it.first.clazz} TTL ${it.first.timeToLive}: (Port: ${it.second.port}, Target: ${it.second.target}, Priority: ${it.second.priority}, Weight: ${it.second.weight})") }
-        ptrRecords.forEach { builder.appendLine("PTR ${it.first.name} ${it.first.type} ${it.first.clazz} TTL ${it.first.timeToLive}: ${it.second.domainName}") }
-        txtRecords.forEach { builder.appendLine("TXT ${it.first.name} ${it.first.type} ${it.first.clazz} TTL ${it.first.timeToLive}: ${it.second.texts.joinToString(", ")}") }
-        aRecords.forEach { builder.appendLine("A ${it.first.name} ${it.first.type} ${it.first.clazz} TTL ${it.first.timeToLive}: ${it.second.address}") }
-        aaaaRecords.forEach { builder.appendLine("AAAA ${it.first.name} ${it.first.type} ${it.first.clazz} TTL ${it.first.timeToLive}: ${it.second.address}") }
-        Logger.i(TAG, "$builder")*/
-
-        synchronized(this._currentServices) {
-            ptrRecords.forEach { record ->
-                val cachedPtrRecord = _cachedPtrRecords.getOrPut(record.first.name) { mutableListOf() }
-                val newPtrRecord = CachedDnsPtrRecord(Date(System.currentTimeMillis() + record.first.timeToLive.toLong() * 1000L), record.second.domainName)
-                cachedPtrRecord.replaceOrAdd(newPtrRecord) { it.target == record.second.domainName }
-            }
-
-            aRecords.forEach { aRecord ->
-                val cachedARecord = _cachedAddressRecords.getOrPut(aRecord.first.name) { mutableListOf() }
-                val newARecord = CachedDnsAddressRecord(Date(System.currentTimeMillis() + aRecord.first.timeToLive.toLong() * 1000L), aRecord.second.address)
-                cachedARecord.replaceOrAdd(newARecord) { it.address == newARecord.address }
-            }
-
-            aaaaRecords.forEach { aaaaRecord ->
-                val cachedAaaaRecord = _cachedAddressRecords.getOrPut(aaaaRecord.first.name) { mutableListOf() }
-                val newAaaaRecord = CachedDnsAddressRecord(Date(System.currentTimeMillis() + aaaaRecord.first.timeToLive.toLong() * 1000L), aaaaRecord.second.address)
-                cachedAaaaRecord.replaceOrAdd(newAaaaRecord) { it.address == newAaaaRecord.address }
-            }
-
-            txtRecords.forEach { txtRecord ->
-                _cachedTxtRecords[txtRecord.first.name] = CachedDnsTxtRecord(Date(System.currentTimeMillis() + txtRecord.first.timeToLive.toLong() * 1000L), txtRecord.second.texts)
-            }
-
-            srvRecords.forEach { srvRecord ->
-                _cachedSrvRecords[srvRecord.first.name] = CachedDnsSrvRecord(Date(System.currentTimeMillis() + srvRecord.first.timeToLive.toLong() * 1000L), srvRecord.second)
-            }
-
-            currentServices = getCurrentServices()
-            this._currentServices.clear()
-            this._currentServices.addAll(currentServices)
-        }
-
-        onServicesUpdated?.invoke(currentServices)
-    }
-
-    fun getAllQuestions(serviceName: String): List<DnsQuestion> {
-        val questions = mutableListOf<DnsQuestion>()
-        synchronized(_currentServices) {
-            val servicePtrRecords = _cachedPtrRecords[serviceName] ?: return emptyList()
-
-            val ptrWithoutSrvRecord = servicePtrRecords.filterNot { _cachedSrvRecords.containsKey(it.target) }.map { it.target }
-            questions.addAll(ptrWithoutSrvRecord.flatMap { s ->
-                listOf(
-                    DnsQuestion(
-                        name = s,
-                        type = QuestionType.SRV.value.toInt(),
-                        clazz = QuestionClass.IN.value.toInt(),
-                        queryUnicast = false
-                    )
-                )
-            })
-
-            val incompleteCurrentServices = _currentServices.filter { it.addresses.isEmpty() && it.name.endsWith(serviceName) }
-            questions.addAll(incompleteCurrentServices.flatMap { s ->
-                listOf(
-                    DnsQuestion(
-                        name = s.name,
-                        type = QuestionType.TXT.value.toInt(),
-                        clazz = QuestionClass.IN.value.toInt(),
-                        queryUnicast = false
-                    ),
-                    DnsQuestion(
-                        name = s.target,
-                        type = QuestionType.A.value.toInt(),
-                        clazz = QuestionClass.IN.value.toInt(),
-                        queryUnicast = false
-                    ),
-                    DnsQuestion(
-                        name = s.target,
-                        type = QuestionType.AAAA.value.toInt(),
-                        clazz = QuestionClass.IN.value.toInt(),
-                        queryUnicast = false
-                    )
-                )
-            })
-        }
-        return questions
-    }
-
-    private fun getCurrentServices(): MutableList<DnsService> {
-        val currentServices = _cachedSrvRecords.map { (key, value) ->
-            DnsService(
-                name = key,
-                target = value.service.target,
-                port = value.service.port
-            )
-        }.toMutableList()
-
-        currentServices.forEach { service ->
-            _cachedAddressRecords[service.target]?.let {
-                service.addresses.addAll(it.map { record -> record.address })
-            }
-        }
-
-        currentServices.forEach { service ->
-            service.pointers.addAll(_cachedPtrRecords.filter { it.value.any { ptr -> ptr.target == service.name } }.map { it.key })
-        }
-
-        currentServices.forEach { service ->
-            _cachedTxtRecords[service.name]?.let {
-                service.texts.addAll(it.texts)
-            }
-        }
-
-        return currentServices
-    }
-
-    private inline fun <T> MutableList<T>.replaceOrAdd(newElement: T, predicate: (T) -> Boolean) {
-        val index = indexOfFirst(predicate)
-        if (index >= 0) {
-            this[index] = newElement
-        } else {
-            add(newElement)
-        }
-    }
-
-    private companion object {
-        private const val TAG = "ServiceRecordAggregator"
-    }
-}

app/src/main/java/com/futo/platformplayer/models/HistoryVideo.kt

@@ -3,6 +3,7 @@ package com.futo.platformplayer.models
 import com.futo.platformplayer.api.media.PlatformID
 import com.futo.platformplayer.api.media.models.PlatformAuthorLink
 import com.futo.platformplayer.api.media.models.Thumbnails
+import com.futo.platformplayer.api.media.models.contents.ContentType
 import com.futo.platformplayer.api.media.models.video.SerializedPlatformVideo
 import com.futo.platformplayer.serializers.OffsetDateTimeSerializer
 import java.time.LocalDateTime
@@ -46,6 +47,7 @@ class HistoryVideo {
             val name = str.substring(indexNext + 3);
 
             val video = resolve?.invoke(url) ?: SerializedPlatformVideo(
+                ContentType.MEDIA,
                 id = PlatformID.asUrlID(url),
                 name = name,
                 thumbnails = Thumbnails(),

app/src/main/java/com/futo/platformplayer/models/ImageVariable.kt

@@ -8,6 +8,7 @@ import com.bumptech.glide.Glide
 import com.futo.platformplayer.PresetImages
 import com.futo.platformplayer.R
 import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.states.StateSubscriptions
 import kotlinx.serialization.Contextual
 import kotlinx.serialization.Transient
 import java.io.File
@@ -28,13 +29,19 @@ data class ImageVariable(
             Glide.with(imageView)
                 .load(bitmap)
                 .into(imageView)
-        } else if(resId != null) {
+        } else if(resId != null && resId > 0) {
             Glide.with(imageView)
                 .load(resId)
                 .into(imageView)
         } else if(!url.isNullOrEmpty()) {
             Glide.with(imageView)
                 .load(url)
+                .error(if(!subscriptionUrl.isNullOrBlank()) StateSubscriptions.instance.getSubscription(subscriptionUrl!!)?.channel?.thumbnail else null)
+                .placeholder(R.drawable.placeholder_channel_thumbnail)
+                .into(imageView);
+        } else if(!subscriptionUrl.isNullOrEmpty()) {
+            Glide.with(imageView)
+                .load(StateSubscriptions.instance.getSubscription(subscriptionUrl!!)?.channel?.thumbnail)
                 .placeholder(R.drawable.placeholder_channel_thumbnail)
                 .into(imageView);
         } else if(!presetName.isNullOrEmpty()) {

app/src/main/java/com/futo/platformplayer/others/LoginWebViewClient.kt

@@ -113,7 +113,7 @@ class LoginWebViewClient : WebViewClient {
             //val domainParts = domain!!.split(".");
             //val cookieDomain = "." + domainParts.drop(domainParts.size - 2).joinToString(".");
             val cookieDomain = domain!!.getSubdomainWildcardQuery();
-            if(_pluginConfig == null || _pluginConfig.allowUrls.any { it == "everywhere" || it.lowercase().matchesDomain(cookieDomain) })
+            if(_pluginConfig == null || _pluginConfig.allowUrls.any { it == "everywhere" || domain.matchesDomain(it) })
                 _authConfig.cookiesToFind?.let { cookiesToFind ->
                     val cookies = cookieString.split(";");
                     for(cookieStr in cookies) {

app/src/main/java/com/futo/platformplayer/others/WebViewRequirementExtractor.kt

@@ -67,7 +67,7 @@ class WebViewRequirementExtractor {
         if(cookieString != null) {
             //val domainParts = domain!!.split(".");
             val cookieDomain = domain!!.getSubdomainWildcardQuery()//"." + domainParts.drop(domainParts.size - 2).joinToString(".");
-            if(allowedUrls.any { it == "everywhere" || it.lowercase().matchesDomain(cookieDomain) })
+            if(allowedUrls.any { it == "everywhere" || domain.matchesDomain(it) })
                 cookiesToFind?.let { cookiesToFind ->
                     val cookies = cookieString.split(";");
                     for(cookieStr in cookies) {

app/src/main/java/com/futo/platformplayer/parsers/HLS.kt

@@ -1,5 +1,11 @@
 package com.futo.platformplayer.parsers
 
+import android.net.Uri
+import androidx.annotation.OptIn
+import androidx.media3.common.util.UnstableApi
+import androidx.media3.exoplayer.hls.playlist.DefaultHlsPlaylistParserFactory
+import androidx.media3.exoplayer.hls.playlist.HlsMediaPlaylist
+import androidx.media3.exoplayer.hls.playlist.HlsMultivariantPlaylist
 import com.futo.platformplayer.api.media.models.streams.sources.HLSVariantAudioUrlSource
 import com.futo.platformplayer.api.media.models.streams.sources.HLSVariantSubtitleUrlSource
 import com.futo.platformplayer.api.media.models.streams.sources.HLSVariantVideoUrlSource
@@ -7,12 +13,15 @@ import com.futo.platformplayer.api.media.models.streams.sources.IHLSManifestAudi
 import com.futo.platformplayer.api.media.models.streams.sources.IHLSManifestSource
 import com.futo.platformplayer.toYesNo
 import com.futo.platformplayer.yesNoToBoolean
+import java.io.ByteArrayInputStream
 import java.net.URI
 import java.time.ZonedDateTime
 import java.time.format.DateTimeFormatter
+import kotlin.text.ifEmpty
 
 class HLS {
     companion object {
+        @OptIn(UnstableApi::class)
         fun parseMasterPlaylist(masterPlaylistContent: String, sourceUrl: String): MasterPlaylist {
             val baseUrl = URI(sourceUrl).resolve("./").toString()
 
@@ -49,6 +58,31 @@ class HLS {
             return MasterPlaylist(variantPlaylists, mediaRenditions, sessionDataList, independentSegments)
         }
 
+        fun mediaRenditionToVariant(rendition: MediaRendition): HLSVariantAudioUrlSource? {
+            if (rendition.uri == null) {
+                return null
+            }
+
+            val suffix = listOf(rendition.language, rendition.groupID).mapNotNull { x -> x?.ifEmpty { null } }.joinToString(", ")
+            return when (rendition.type) {
+                "AUDIO" -> HLSVariantAudioUrlSource(rendition.name?.ifEmpty { "Audio (${suffix})" } ?: "Audio (${suffix})", 0, "application/vnd.apple.mpegurl", "", rendition.language ?: "", null, false, false, rendition.uri)
+                else -> null
+            }
+        }
+
+        fun variantReferenceToVariant(reference: VariantPlaylistReference): HLSVariantVideoUrlSource {
+            var width: Int? = null
+            var height: Int? = null
+            val resolutionTokens = reference.streamInfo.resolution?.split('x')
+            if (resolutionTokens?.isNotEmpty() == true) {
+                width = resolutionTokens[0].toIntOrNull()
+                height = resolutionTokens[1].toIntOrNull()
+            }
+
+            val suffix = listOf(reference.streamInfo.video, reference.streamInfo.codecs).mapNotNull { x -> x?.ifEmpty { null } }.joinToString(", ")
+            return HLSVariantVideoUrlSource(suffix, width ?: 0, height ?: 0, "application/vnd.apple.mpegurl", reference.streamInfo.codecs ?: "", reference.streamInfo.bandwidth, 0, false, reference.url)
+        }
+
         fun parseVariantPlaylist(content: String, sourceUrl: String): VariantPlaylist {
             val lines = content.lines()
             val version = lines.find { it.startsWith("#EXT-X-VERSION:") }?.substringAfter(":")?.toIntOrNull()
@@ -61,7 +95,25 @@ class HLS {
             val playlistType = lines.find { it.startsWith("#EXT-X-PLAYLIST-TYPE:") }?.substringAfter(":")
             val streamInfo = lines.find { it.startsWith("#EXT-X-STREAM-INF:") }?.let { parseStreamInfo(it) }
 
+            val keyInfo =
+                lines.find { it.startsWith("#EXT-X-KEY:") }?.substringAfter(":")?.split(",")
+
+            val key = keyInfo?.find { it.startsWith("URI=") }?.substringAfter("=")?.trim('"')
+            val iv =
+                keyInfo?.find { it.startsWith("IV=") }?.substringAfter("=")?.substringAfter("x")
+
+            val decryptionInfo: DecryptionInfo? = key?.let { k ->
+                DecryptionInfo(k, iv)
+            }
+
+            val initSegment =
+                lines.find { it.startsWith("#EXT-X-MAP:") }?.substringAfter(":")?.split(",")?.get(0)
+                    ?.substringAfter("=")?.trim('"')
             val segments = mutableListOf<Segment>()
+            if (initSegment != null) {
+                segments.add(MediaSegment(0.0, resolveUrl(sourceUrl, initSegment)))
+            }
+
             var currentSegment: MediaSegment? = null
             lines.forEach { line ->
                 when {
@@ -86,7 +138,7 @@ class HLS {
                 }
             }
 
-            return VariantPlaylist(version, targetDuration, mediaSequence, discontinuitySequence, programDateTime, playlistType, streamInfo, segments)
+            return VariantPlaylist(version, targetDuration, mediaSequence, discontinuitySequence, programDateTime, playlistType, streamInfo, segments, decryptionInfo)
         }
 
         fun parseAndGetVideoSources(source: Any, content: String, url: String): List<HLSVariantVideoUrlSource> {
@@ -270,7 +322,7 @@ class HLS {
         val name: String?,
         val isDefault: Boolean?,
         val isAutoSelect: Boolean?,
-        val isForced: Boolean?
+        val isForced: Boolean?,
     ) {
         fun toM3U8Line(): String = buildString {
             append("#EXT-X-MEDIA:")
@@ -319,30 +371,13 @@ class HLS {
 
         fun getVideoSources(): List<HLSVariantVideoUrlSource> {
             return variantPlaylistsRefs.map {
-                var width: Int? = null
-                var height: Int? = null
-                val resolutionTokens = it.streamInfo.resolution?.split('x')
-                if (resolutionTokens?.isNotEmpty() == true) {
-                    width = resolutionTokens[0].toIntOrNull()
-                    height = resolutionTokens[1].toIntOrNull()
-                }
-
-                val suffix = listOf(it.streamInfo.video, it.streamInfo.codecs).mapNotNull { x -> x?.ifEmpty { null } }.joinToString(", ")
-                HLSVariantVideoUrlSource(suffix, width ?: 0, height ?: 0, "application/vnd.apple.mpegurl", it.streamInfo.codecs ?: "", it.streamInfo.bandwidth, 0, false, it.url)
+                variantReferenceToVariant(it)
             }
         }
 
         fun getAudioSources(): List<HLSVariantAudioUrlSource> {
             return mediaRenditions.mapNotNull {
-                if (it.uri == null) {
-                    return@mapNotNull null
-                }
-
-                val suffix = listOf(it.language, it.groupID).mapNotNull { x -> x?.ifEmpty { null } }.joinToString(", ")
-                return@mapNotNull when (it.type) {
-                    "AUDIO" -> HLSVariantAudioUrlSource(it.name?.ifEmpty { "Audio (${suffix})" } ?: "Audio (${suffix})", 0, "application/vnd.apple.mpegurl", "", it.language ?: "", null, false, false, it.uri)
-                    else -> null
-                }
+                return@mapNotNull mediaRenditionToVariant(it)
             }
         }
 
@@ -368,6 +403,11 @@ class HLS {
         }
     }
 
+    data class DecryptionInfo(
+        val keyUrl: String,
+        val iv: String?
+    )
+
     data class VariantPlaylist(
         val version: Int?,
         val targetDuration: Int?,
@@ -376,7 +416,8 @@ class HLS {
         val programDateTime: ZonedDateTime?,
         val playlistType: String?,
         val streamInfo: StreamInfo?,
-        val segments: List<Segment>
+        val segments: List<Segment>,
+        val decryptionInfo: DecryptionInfo? = null
     ) {
         fun buildM3U8(): String = buildString {
             append("#EXTM3U\n")

app/src/main/java/com/futo/platformplayer/receivers/MediaControlReceiver.kt

@@ -21,6 +21,7 @@ class MediaControlReceiver : BroadcastReceiver() {
                 EVENT_NEXT -> onNextReceived.emit();
                 EVENT_PREV -> onPreviousReceived.emit();
                 EVENT_CLOSE -> onCloseReceived.emit();
+                EVENT_BACKGROUND -> onBackgroundReceived.emit();
             }
         }
         catch(ex: Throwable) {
@@ -38,6 +39,7 @@ class MediaControlReceiver : BroadcastReceiver() {
         const val EVENT_NEXT = "Next";
         const val EVENT_PREV = "Prev";
         const val EVENT_CLOSE = "Close";
+        const val EVENT_BACKGROUND = "Background";
 
         val onPlayReceived = Event0();
         val onPauseReceived = Event0();
@@ -48,6 +50,7 @@ class MediaControlReceiver : BroadcastReceiver() {
         val onLowerVolumeReceived = Event0();
 
         val onCloseReceived = Event0()
+        val onBackgroundReceived = Event0()
 
         fun getPlayIntent(context: Context, code: Int = 0) : PendingIntent = PendingIntent.getBroadcast(context, code, Intent(context, MediaControlReceiver::class.java).apply {
             this.putExtra(EXTRA_MEDIA_ACTION, EVENT_PLAY);
@@ -64,5 +67,8 @@ class MediaControlReceiver : BroadcastReceiver() {
         fun getCloseIntent(context: Context, code: Int = 0) : PendingIntent = PendingIntent.getBroadcast(context, code, Intent(context, MediaControlReceiver::class.java).apply {
             this.putExtra(EXTRA_MEDIA_ACTION, EVENT_CLOSE);
         },PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT);
+        fun getToBackgroundIntent(context: Context, code: Int = 0) : PendingIntent = PendingIntent.getBroadcast(context, code, Intent(context, MediaControlReceiver::class.java).apply {
+            this.putExtra(EXTRA_MEDIA_ACTION, EVENT_BACKGROUND);
+        },PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT);
     }
 }