Added boolean setting to allow link local casting over ipv4.

Merge branch 'hotfix-250606' of gitlab.futo.org:videostreaming/grayjay
Added potential fix for having to restart app to get casting devices to show. Added persistent ordering for creators.
2026-05-16 04:52:39 +02:00 · 2025-06-06 11:20:04 +02:00 · 2025-06-06 11:12:58 +02:00 · 2025-06-06 11:12:31 +02:00 · 2025-06-06 10:17:40 +02:00 · 2025-06-06 10:17:03 +02:00
470 changed files with 15290 additions and 7087 deletions
@@ -0,0 +1,2 @@
+aar/* filter=lfs diff=lfs merge=lfs -text
+app/aar/* filter=lfs diff=lfs merge=lfs -text
@@ -0,0 +1,166 @@
+name: Bug Report
+description: Let us know about an unexpected error, a crash, or an incorrect behavior.
+labels: ["Bug", "Android"]
+title: "Bug: "
+type: bug
+projects: ["futo-org/19"]
+body:
+  - type: markdown
+    attributes:
+      value: |
+        # Thank you for taking the time to fill out this bug report.
+
+        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application
+
+        For general usage questions, please see: [The Official FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)
+
+        ## Filing a bug report
+
+        To fix your issues faster, we need clear reproduction cases - ideally allowing us to make it happen locally.
+        * Please include all needed context. For example, Device, OS, Application, your Grayjay Configurations and Plugin versioning info.
+        * if you've found out a particular series of UI interactions can introduce buggy behavior, please label those steps 1-n with markdown
+
+  - type: textarea
+    id: reproduction-steps
+    attributes:
+      label: Reproduction steps
+      description: Please provide us with the steps to reproduce the issue if possible. This step makes a big difference if we are going to be able to fix it so be as precise as possible.
+      placeholder: |
+        0. Play a Youtube video
+        1. Press on Download button
+        2. Select quality 1440p
+        3. Grayjay crashes when attempting to download
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual-result
+    attributes:
+      label: Actual result
+      description: What happend?
+      placeholder: Tell us what you saw!
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected-result
+    attributes:
+      label: Expected result
+      description: What was suppose to happen?
+      placeholder: Tell us what you expected to happen!
+    validations:
+      required: true
+
+  - type: input
+    id: grayjay-version
+    attributes:
+      label: Grayjay Version
+      description: In the application, select More > Settings, scroll to the bottom and locate the value next to "Version Name".
+      placeholder: "311"
+    validations:
+      required: true
+
+  - type: dropdown
+    id: plugin
+    attributes:
+      label: What plugins are you seeing the problem on?
+      multiple: true
+      options:
+        - "All"
+        - "Apple Podcasts"
+        - "BiliBili (CN)"
+        - "Bitchute"
+        - "Crunchyroll"
+        - "CuriosityStream"
+        - "Dailymotion"
+        - "Kick"
+        - "Nebula"
+        - "Odysee"
+        - "Patreon"
+        - "PeerTube"
+        - "Rumble"
+        - "SoundCloud"
+        - "Spotify"
+        - "TedTalks"
+        - "Twitch"
+        - "Youtube"
+        - "Other"
+    validations:
+      required: true
+
+  - type: input
+    id: plugin-version
+    attributes:
+      label: Plugin Version
+      description: In the application, select Sources > [the broken plugin], write down the value under "Version".
+      placeholder: "12"
+
+  - type: input
+    id: android-version
+    attributes:
+      label: Which android version are you using?
+      placeholder: "Android 15"
+    validations:
+      required: true
+
+  - type: input
+    id: phone-model
+    attributes:
+      label: Which device are you using?
+      placeholder: "Google Pixel 9"
+    validations:
+      required: true
+
+  - type: input
+    id: os-version
+    attributes:
+      label: Which operating system are you using?
+      placeholder: "GrapheneOS/CalyxOS/Tizen/HyperOS 2/..."
+    validations:
+      required: true
+
+  - type: checkboxes
+    id: login
+    attributes:
+      label: When do you experience the issue?
+      options:
+      - label: While logged in
+      - label: While logged out
+      - label: N/A
+
+  - type: dropdown
+    id: vpn
+    attributes:
+      label: Are you using a VPN?
+      multiple: false
+      options:
+        - "No"
+        - "Yes"
+    validations:
+      required: true
+
+  - type: textarea
+    id: grayjay-references
+    attributes:
+      label: References
+      description: |
+        Are there any other GitHub issues, whether open or closed, that are related to the problem you've described above? If so, please create a list below that mentions each of them. For example:
+        ```
+          - #10
+        ```
+      placeholder:
+      value:
+    validations:
+      required: false
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Relevant log output
+      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
+      render: shell
+
+  - type: markdown
+    attributes:
+      value: |
+        **Note:** If the submit button is disabled and you have filled out all required fields, please check that you did not forget a **Title** for the issue.
@@ -1,15 +1,16 @@
 name: Feature Request
 description: Suggest a new feature or other enhancement.
-labels: ["enhancement", "new"]
+labels: ["Enhancement", "Android"]
+title: "Feature request: "
+type: feature
+projects: ["futo-org/19"]
 body:
  - type: markdown
    attributes:
      value: |
        # Thank you for opening a feature request.

-        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application
-
-        [External Contributions are closed at this time](https://github.com/tom-futo/grayjay-android/blob/master/CONTRIBUTION.md#contributing-to-core)
+        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues and feature requests relating to the Grayjay android application

        For discussion related to enhancements, please see: [The FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)

@@ -55,4 +56,4 @@ body:
    attributes:
      value: |
        **Note:** If the submit button is disabled and you have filled out all required fields, please check that you did not forget a **Title** for the issue.
-        
+
@@ -1,13 +1,16 @@
 name: Documentation Issue
 description: Report an issue or suggest a change in the documentation.
-labels: ["documentation", "new"]
+labels: ["Documentation"]
+title: "Documentation: "
+type: task
+projects: ["futo-org/19"]
 body:
  - type: markdown
    attributes:
      value: |
        # Thank you for opening a documentation change request.

-        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application. Use the `Documentation` issue type to report problems with the documentation in our code repositories, inside the application, or on [https://grayjay.app](https://grayjay.app) 
+        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay android application. Use the `Documentation` issue type to report problems with the documentation in our code repositories, inside the application, or on [https://grayjay.app](https://grayjay.app)
        Technical writers monitor this issue type, so report Grayjay bugs or feature requests with the `Bug report` or `Feature Request` issue types instead to get engineering attention.

        For general usage questions, please see: [The Official FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)
@@ -1,80 +0,0 @@
-name: Bug Report
-description: Let us know about an unexpected error, a crash, or an incorrect behavior.
-labels: ["bug", "new"]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        # Thank you for taking the time to fill out this bug report.
-        
-        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application
-
-        For general usage questions, please see: [The Official FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)
-
-        ## Filing a bug report
-
-        To fix your issues faster, we need clear reproduction cases - ideally allowing us to make it happen locally. 
-        * Please include all needed context. For example, Device, OS, Application, your Grayjay Configurations and Plugin versioning info.
-        * if you've found out a particular series of UI interactions can introduce buggy behavior, please label those steps 1-n with markdown
-
-  - type: textarea
-    id: what-happened
-    attributes:
-      label: What happened?
-      description: What did you expect to happen?
-      placeholder: Tell us what you see!
-    validations:
-      required: true
-
-  - type: input
-    id: grayjay-version
-    attributes:
-      label: Grayjay Version
-      description: In the application, select More > Settings, scroll to the bottom and locate the value next to "Version Name".
-      placeholder: "242"
-    validations:
-      required: true
-
-  - type: dropdown
-    id: plugin
-    attributes:
-      label: What plugins are you seeing the problem on?
-      multiple: true
-      options:
-        - All
-        - Youtube
-        - BiliBili (CN)
-        - Twitch
-        - Odysee
-        - Rumble
-        - Kick
-        - PeerTube
-        - Patreon
-        - Nebula
-        - SoundCloud
-        - Other
-    validations:
-      required: true
-
-  - type: input
-    id: plugin-version
-    attributes:
-      label: Plugin Version
-      description: In the application, select Sources > [the broken plugin], write down the value under "Version".
-      placeholder: "12"
-
-  - type: checkboxes
-    id: login
-    attributes:
-      label: When do you experience the issue?
-      options:
-      - label: While logged in
-      - label: While logged out
-      - label: N/A
-
-  - type: textarea
-    id: logs
-    attributes:
-      label: Relevant log output
-      description: Please copy and paste any relevant log output. This will be automatically formatted into code, so no need for backticks.
-      render: shell
@@ -1,34 +0,0 @@
-name: Issue labeler
-on:
-  issues:
-    types: [ opened ]
-
-permissions:
-  contents: read
-
-jobs:
-  label-component:
-    runs-on: ubuntu-latest
-
-    permissions:
-      # required for all workflows
-      issues: write
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Parse issue form
-        uses: stefanbuck/github-issue-parser@v3
-        id: issue-parser
-        with:
-          template-path: .github/ISSUE_TEMPLATE/bug_report.yml
-
-      - name: Set labels based on plugin field
-        uses: redhat-plumbers-in-action/advanced-issue-labeler@v2
-        with:
-          issue-form: ${{ steps.issue-parser.outputs.jsonString }}
-          section: plugin
-          block-list: |
-            None
-            Other
-          token: ${{ secrets.GITHUB_TOKEN }}
@@ -82,3 +82,27 @@
 [submodule "app/src/stable/assets/sources/dailymotion"]
 	path = app/src/stable/assets/sources/dailymotion
 	url = ../plugins/dailymotion.git
+[submodule "app/src/stable/assets/sources/apple-podcast"]
+	path = app/src/stable/assets/sources/apple-podcasts
+	url = ../plugins/apple-podcasts.git
+[submodule "app/src/unstable/assets/sources/apple-podcasts"]
+	path = app/src/unstable/assets/sources/apple-podcasts
+	url = ../plugins/apple-podcasts.git
+[submodule "app/src/stable/assets/sources/tedtalks"]
+	path = app/src/stable/assets/sources/tedtalks
+	url = ../plugins/tedtalks.git
+[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
@@ -49,9 +49,23 @@ We encourage developers to write their own plugins. Please refer to the "Getting

 ## Contributing to Core

-**We are currently not accepting contributions to the core.**

-The core is currently licensed under the FUTO Temporary License (FTL). The licensing and ownership of contributions to the core are complex topics that we are still working on. We'll update these guidelines when we have more clarity.
+### License
+
+The core is currently licensed under the [Source First License 1.1](./LICENSE.md). All contributors have to sign FUTO Individual Contributor License Agreement before contributions can be accepted. You can read more about it at [https://cla.futo.org/](https://cla.futo.org/).
+
+### How to Contribute
+
+1. Fork the core repository.
+2. Clone your fork.
+3. Make your changes.
+4. Commit and push your changes.
+5. Open a pull request.
+
+### Guidelines
+
+- Ensure your code adheres to the existing style.
+- Include documentation and unit tests (where applicable).

 ---

@@ -9,8 +9,8 @@ technologies that frustrate centralization and industry consolidation.

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/video.jpg" height="700" /></b></td>
-    <td><b style="font-size:30px"><img src="images/video-details.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/video.png" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/video-details.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Video</td>
@@ -24,12 +24,10 @@ The FUTO media app is a player that exposes multiple video websites as sources i

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/sources.jpg" height="700" /></b></td>
-    <td><b style="font-size:30px"><img src="images/sources-disabled.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/source.png" height="700" /></b></td>
 </tr>
 <tr>
-    <td>Sources (all enabled)</td>
-    <td>Sources (one disabled)</td>
+    <td>Sources</td>
 </tr>
 </table>

@@ -38,7 +36,7 @@ Additional sources can also be installed. These sources are JavaScript sources,
 <table border="0">
 <tr>
    <td><b style="font-size:30px"><img src="images/source-install.png" height="700" /></b></td>
-    <td><b style="font-size:30px"><img src="images/source-settings.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/source-settings.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Install a new source</td>
@@ -54,8 +52,8 @@ When a user enters a search term into the search bar,  the query is posted to th

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/search-list.jpg" height="700" /></b></td>
-    <td><b style="font-size:30px"><img src="images/search-preview.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/search-list.png" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/search-preview.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Search (list)</td>
@@ -71,7 +69,7 @@ Creators are able to configure their profile using NeoPass.

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/channel.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/channel.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Channel</td>
@@ -112,7 +110,7 @@ The app offers a lot of settings customizing how the app looks and feels. An exa

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/settings.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/settings.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Settings</td>
@@ -125,8 +123,8 @@ Playlists allow you to make a collection of videos that you can create and custo

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/playlists.jpg" height="700" /></b></td>
-    <td><b style="font-size:30px"><img src="images/playlist.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/playlists.png" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/playlist.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Playlists</td>
@@ -142,7 +140,7 @@ Both individual videos and playlists can be downloaded for local, offline playba

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/downloads.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/downloads.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Downloads</td>
@@ -157,7 +155,7 @@ For more information about casting please click [here](./docs/casting.md).

 <table border="0">
 <tr>
-    <td><b style="font-size:30px"><img src="images/casting.jpg" height="700" /></b></td>
+    <td><b style="font-size:30px"><img src="images/casting.png" height="700" /></b></td>
 </tr>
 <tr>
    <td>Casting</td>
@@ -182,6 +180,12 @@ In the future we hope to offer users the choice of their desired recommendation

 1. Download a copy of the repository.
 2. Open the project in Android Studio: Once the repository is cloned, you can open it in Android Studio by selecting "Open an Existing Project" from the welcome screen and navigating to the directory where you cloned the repository.
+3. Open the terminal in Android Studio by clicking on the terminal icon on bottom left and run the following command:
+
+```sh
+git submodule update --init --recursive
+```
+
 3. Build the project: With the project open in Android Studio, you can build it by selecting "Build > Make Project" from the main menu. This will compile the code and generate an APK file that you can install on your device or emulator.
 4. Run the project: To run the project, select "Run > Run 'app'" from the main menu. This will launch the app on your device or emulator, allowing you to test it and make any necessary changes.

@@ -199,7 +203,6 @@ Create a tag on the master branch, incrementing the last version number by 1 (fo

 Click on the CI/CD tab, you should now see the tests and build are in progress. If the build succeeds the last step will become available. The last step is a manual action which can be triggered by clicking the run button on the action. This action will deploy the build to all users using the app through auto-update.

-
 ## Documentation

 The documentation can be found [here](https://gitlab.futo.org/videostreaming/documents/-/wikis/API-Overview).
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ea10d3c5562c9f449a4e89e9c3dfcf881ed79a952f3409bc005bcc62c2cf4b81
+size 65512557
@@ -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:5.1'
+    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'
@@ -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
+}
@@ -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
+}
@@ -36,6 +36,12 @@
            <meta-data android:name="android.support.FILE_PROVIDER_PATHS" android:resource="@xml/file_paths" />
        </provider>

+        <receiver android:name=".receivers.MediaButtonReceiver" android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.MEDIA_BUTTON" />
+            </intent-filter>
+        </receiver>
+
        <service android:name=".services.MediaPlaybackService"
            android:enabled="true"
            android:foregroundServiceType="mediaPlayback" />
@@ -49,11 +55,10 @@

        <activity
            android:name=".activities.MainActivity"
-            android:configChanges="orientation|screenSize|smallestScreenSize|screenLayout"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize|screenLayout|uiMode"
            android:exported="true"
-            android:screenOrientation="sensorPortrait"
            android:theme="@style/Theme.FutoVideo.NoActionBar"
-            android:launchMode="singleTask"
+            android:launchMode="singleInstance"
            android:resizeableActivity="true"
            android:supportsPictureInPicture="true">

@@ -146,14 +151,11 @@
                <data android:scheme="polycentric" />
            </intent-filter>
        </activity>
-
        <activity
            android:name=".activities.TestActivity"
            android:theme="@style/Theme.FutoVideo.NoActionBar" />
-
        <activity
            android:name=".activities.SettingsActivity"
-            android:screenOrientation="sensorPortrait"
            android:theme="@style/Theme.FutoVideo.NoActionBar" />
        <activity
            android:name=".activities.DeveloperActivity"
@@ -173,7 +175,6 @@
            android:theme="@style/Theme.FutoVideo.NoActionBar" />
        <activity
            android:name=".activities.AddSourceActivity"
-            android:screenOrientation="sensorPortrait"
            android:exported="true"
            android:theme="@style/Theme.FutoVideo.NoActionBar">
            <intent-filter>
@@ -217,7 +218,6 @@
            android:name=".activities.ManageTabsActivity"
            android:screenOrientation="sensorPortrait"
            android:theme="@style/Theme.FutoVideo.NoActionBar" />
-
        <activity
            android:name=".activities.QRCaptureActivity"
            android:screenOrientation="sensorPortrait"
@@ -226,10 +226,6 @@
            android:name=".activities.FCastGuideActivity"
            android:screenOrientation="sensorPortrait"
            android:theme="@style/Theme.FutoVideo.NoActionBar" />
-        <activity
-            android:name=".activities.PolycentricWhyActivity"
-            android:screenOrientation="sensorPortrait"
-            android:theme="@style/Theme.FutoVideo.NoActionBar" />
        <activity
            android:name=".activities.SyncHomeActivity"
            android:screenOrientation="sensorPortrait"
@@ -243,4 +239,4 @@
            android:screenOrientation="sensorPortrait"
            android:theme="@style/Theme.FutoVideo.NoActionBar" />
    </application>
-</manifest>
+</manifest>
@@ -11,7 +11,8 @@ let Type = {
        Streams: "STREAMS",
        Mixed: "MIXED",
        Live: "LIVE",
-        Subscriptions: "SUBSCRIPTIONS"
+        Subscriptions: "SUBSCRIPTIONS",
+        Shorts: "SHORTS"
    },
    Order: {
        Chronological: "CHRONOLOGICAL"
@@ -31,7 +32,8 @@ let Type = {
    Text: {
        RAW: 0,
        HTML: 1,
-        MARKUP: 2
+        MARKUP: 2,
+        CODE: 3
    },
    Chapter: {
        NORMAL: 0,
@@ -244,6 +246,7 @@ class PlatformVideo extends PlatformContent {
        this.viewCount = obj.viewCount ?? -1; //Long

        this.isLive = obj.isLive ?? false; //Boolean
+        this.isShort = !!obj.isShort ?? false;
    }
 }
 class PlatformVideoDetails extends PlatformVideo {
@@ -260,6 +263,11 @@ class PlatformVideoDetails extends PlatformVideo {

        this.rating = obj.rating ?? null; //IRating
        this.subtitles = obj.subtitles ?? [];
+        this.isShort = !!obj.isShort ?? false;
+
+        if (obj.getContentRecommendations) {
+            this.getContentRecommendations = obj.getContentRecommendations
+        }
    }
 }

@@ -284,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 {
@@ -308,9 +340,17 @@ class ArticleTextSegment extends ArticleSegment {
    }
 }
 class ArticleImagesSegment extends ArticleSegment {
-    constructor(images) {
+    constructor(images, caption) {
        super(2);
        this.images = images;
+        this.caption = caption;
+    }
+}
+class ArticleHeaderSegment extends ArticleSegment {
+    constructor(content, level) {
+        super(3);
+        this.level = level;
+        this.content = content;
    }
 }
 class ArticleNestedSegment extends ArticleSegment {
@@ -367,6 +407,16 @@ class VideoUrlSource {
            this.requestModifier = obj.requestModifier;
    }
 }
+class VideoUrlWidevineSource extends VideoUrlSource {
+    constructor(obj) {
+        super(obj);
+        this.plugin_type = "VideoUrlWidevineSource";
+
+        this.licenseUri = obj.licenseUri;
+        if(obj.getLicenseRequestExecutor)
+            this.getLicenseRequestExecutor = obj.getLicenseRequestExecutor;
+    }
+}
 class VideoUrlRangeSource extends VideoUrlSource {
    constructor(obj) {
        super(obj);
@@ -399,8 +449,26 @@ class AudioUrlWidevineSource extends AudioUrlSource {
        super(obj);
        this.plugin_type = "AudioUrlWidevineSource";

-        this.bearerToken = obj.bearerToken;
        this.licenseUri = obj.licenseUri;
+        if(obj.getLicenseRequestExecutor)
+            this.getLicenseRequestExecutor = obj.getLicenseRequestExecutor;
+
+        // deprecated api conversion
+        if(obj.bearerToken) {
+            this.getLicenseRequestExecutor = () => {
+                return {
+                    executeRequest: (url, _headers, _method, license_request_data) => {
+                        return http.POST(
+                           url,
+                           license_request_data,
+                           { Authorization: `Bearer ${obj.bearerToken}` },
+                           false,
+                           true
+                       ).body
+                    }
+                }
+            }
+        }
    }
 }
 class AudioUrlRangeSource extends AudioUrlSource {
@@ -443,6 +511,16 @@ class DashSource {
            this.requestModifier = obj.requestModifier;
    }
 }
+class DashWidevineSource extends DashSource {
+    constructor(obj) {
+        super(obj);
+        this.plugin_type = "DashWidevineSource";
+
+        this.licenseUri = obj.licenseUri;
+        if(obj.getLicenseRequestExecutor)
+            this.getLicenseRequestExecutor = obj.getLicenseRequestExecutor;
+    }
+}
 class DashManifestRawSource {
    constructor(obj) {
        obj = obj ?? {};
@@ -550,6 +628,8 @@ class PlatformComment {
        this.date = obj.date ?? 0;
        this.replyCount = obj.replyCount ?? 0;
        this.context = obj.context ?? {};
+        if(obj.getReplies)
+            this.getReplies = obj.getReplies;
    }
 }

@@ -1,122 +0,0 @@
-import android.app.Activity
-import android.content.Context
-import android.content.pm.ActivityInfo
-import android.hardware.Sensor
-import android.hardware.SensorEvent
-import android.hardware.SensorEventListener
-import android.hardware.SensorManager
-import com.futo.platformplayer.constructs.Event1
-import com.futo.platformplayer.logging.Logger
-import kotlinx.coroutines.CoroutineScope
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.delay
-import kotlinx.coroutines.launch
-
-
-class AdvancedOrientationListener(private val activity: Activity, private val lifecycleScope: CoroutineScope) {
-    private val sensorManager: SensorManager = activity.getSystemService(Context.SENSOR_SERVICE) as SensorManager
-    private val accelerometer: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
-    private val magnetometer: Sensor? = sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
-
-    private var lastOrientation: Int = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-    private var lastStableOrientation: Int = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-    private var lastOrientationChangeTime = 0L
-    private val debounceTime = 200L
-    private val stabilityThresholdTime = 800L
-    private var deviceAspectRatio: Float = 1.0f
-
-    private val gravity = FloatArray(3)
-    private val geomagnetic = FloatArray(3)
-    private val rotationMatrix = FloatArray(9)
-    private val orientationAngles = FloatArray(3)
-
-    val onOrientationChanged = Event1<Int>()
-
-    private val sensorListener = object : SensorEventListener {
-        override fun onSensorChanged(event: SensorEvent) {
-            when (event.sensor.type) {
-                Sensor.TYPE_ACCELEROMETER -> {
-                    System.arraycopy(event.values, 0, gravity, 0, gravity.size)
-                }
-                Sensor.TYPE_MAGNETIC_FIELD -> {
-                    System.arraycopy(event.values, 0, geomagnetic, 0, geomagnetic.size)
-                }
-            }
-
-            if (gravity.isNotEmpty() && geomagnetic.isNotEmpty()) {
-                val success = SensorManager.getRotationMatrix(rotationMatrix, null, gravity, geomagnetic)
-                if (success) {
-                    SensorManager.getOrientation(rotationMatrix, orientationAngles)
-
-                    val azimuth = Math.toDegrees(orientationAngles[0].toDouble()).toFloat()
-                    val pitch = Math.toDegrees(orientationAngles[1].toDouble()).toFloat()
-                    val roll = Math.toDegrees(orientationAngles[2].toDouble()).toFloat()
-
-                    val newOrientation = when {
-                        roll in -155f .. -15f && isWithinThreshold(pitch, 0f, 30.0) -> {
-                            ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-                        }
-                        roll in 15f .. 155f && isWithinThreshold(pitch, 0f, 30.0) -> {
-                            ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
-                        }
-                        isWithinThreshold(pitch, -90f, 30.0 * deviceAspectRatio) && roll in -15f .. 15f -> {
-                            ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
-                        }
-                        isWithinThreshold(pitch, 90f, 30.0 * deviceAspectRatio) && roll in -15f .. 15f -> {
-                            ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
-                        }
-                        else -> lastOrientation
-                    }
-
-                    //Logger.i("AdvancedOrientationListener", "newOrientation = ${newOrientation}, roll = ${roll}, pitch = ${pitch}, azimuth = ${azimuth}")
-
-                    if (newOrientation != lastStableOrientation) {
-                        val currentTime = System.currentTimeMillis()
-                        if (currentTime - lastOrientationChangeTime > debounceTime) {
-                            lastOrientationChangeTime = currentTime
-                            lastStableOrientation = newOrientation
-
-                            lifecycleScope.launch(Dispatchers.Main) {
-                                try {
-                                    delay(stabilityThresholdTime)
-                                    if (newOrientation == lastStableOrientation) {
-                                        lastOrientation = newOrientation
-                                        onOrientationChanged.emit(newOrientation)
-                                    }
-                                } catch (e: Throwable) {
-                                    Logger.i(TAG, "Failed to trigger onOrientationChanged", e)
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
-    }
-
-    private fun isWithinThreshold(value: Float, target: Float, threshold: Double): Boolean {
-        return Math.abs(value - target) <= threshold
-    }
-
-    init {
-        sensorManager.registerListener(sensorListener, accelerometer, SensorManager.SENSOR_DELAY_GAME)
-        sensorManager.registerListener(sensorListener, magnetometer, SensorManager.SENSOR_DELAY_GAME)
-
-        val metrics = activity.resources.displayMetrics
-        deviceAspectRatio = (metrics.heightPixels.toFloat() / metrics.widthPixels.toFloat())
-        if (deviceAspectRatio == 0.0f)
-            deviceAspectRatio = 1.0f
-
-        lastOrientation = activity.resources.configuration.orientation
-    }
-
-    fun stopListening() {
-        sensorManager.unregisterListener(sensorListener)
-    }
-
-    companion object {
-        private val TAG = "AdvancedOrientationListener"
-    }
-}
@@ -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


@@ -226,6 +225,25 @@ fun Long.toHumanTime(isMs: Boolean): String {
    else
        return  "${prefix}${minsStr}:${secsStr}"
 }
+fun Long.toHumanDuration(isMs: Boolean): String {
+    var scaler = 1;
+    if(isMs)
+        scaler = 1000;
+    val v = Math.abs(this);
+    val hours = Math.max(v/(secondsInHour*scaler), 0);
+    val mins = Math.max((v % (secondsInHour*scaler)) / (secondsInMinute * scaler), 0);
+    val minsStr = mins.toString();
+    val seconds = Math.max(((v % (secondsInHour*scaler)) % (secondsInMinute * scaler))/scaler, 0);
+    val secsStr = seconds.toString().padStart(2, '0');
+    val prefix = if (this < 0) { "-" } else { "" };
+
+    return listOf(
+        if(hours > 0) "${hours}h" else null,
+        if(mins > 0) "${mins}m" else null ,
+        if(seconds > 0) "${seconds}s" else null
+    ).filterNotNull().joinToString(" ");
+}
+

 //TODO: Determine if below stuff should have its own proper class, seems a bit too complex for a utility method
 fun String.fixHtmlWhitespace(): Spanned {
@@ -357,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
@@ -376,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;
 }
@@ -6,6 +6,7 @@ import java.io.ByteArrayOutputStream
 import java.io.IOException
 import java.io.InputStream
 import java.net.Inet4Address
+import java.net.Inet6Address
 import java.net.InetAddress
 import java.net.InetSocketAddress
 import java.net.Socket
@@ -215,8 +216,13 @@ private fun ByteArray.toInetAddress(): InetAddress {
    return InetAddress.getByAddress(this);
 }

-fun getConnectedSocket(addresses: List<InetAddress>, port: Int): Socket? {
-    val timeout = 2000
+fun getConnectedSocket(attemptAddresses: List<InetAddress>, port: Int): Socket? {
+    ensureNotMainThread()
+
+    val timeout = 10000
+    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;
@@ -1,13 +1,13 @@
 package com.futo.platformplayer

 import com.futo.platformplayer.logging.Logger
-import com.futo.platformplayer.polycentric.PolycentricCache
 import com.futo.platformplayer.states.AnnouncementType
 import com.futo.platformplayer.states.StateAnnouncement
 import com.futo.platformplayer.states.StatePlatform
 import com.futo.polycentric.core.ProcessHandle
 import com.futo.polycentric.core.Store
 import com.futo.polycentric.core.SystemState
+import com.futo.polycentric.core.base64UrlToByteArray
 import userpackage.Protocol
 import kotlin.math.abs
 import kotlin.math.min
@@ -40,33 +40,25 @@ fun Protocol.ImageBundle?.selectHighestResolutionImage(): Protocol.ImageManifest
    return imageManifestsList.filter { it.byteCount < maximumFileSize }.maxByOrNull { abs(it.width * it.height) }
 }

+fun String.getDataLinkFromUrl(): Protocol.URLInfoDataLink? {
+    val urlData = if (this.startsWith("polycentric://")) {
+        this.substring("polycentric://".length)
+    } else this;
+
+    val urlBytes = urlData.base64UrlToByteArray();
+    val urlInfo = Protocol.URLInfo.parseFrom(urlBytes);
+    if (urlInfo.urlType != 4L) {
+        return null
+    }
+
+    val dataLink = Protocol.URLInfoDataLink.parseFrom(urlInfo.body);
+    return dataLink
+}
+
 fun Protocol.Claim.resolveChannelUrl(): String? {
    return StatePlatform.instance.resolveChannelUrlByClaimTemplates(this.claimType.toInt(), this.claimFieldsList.associate { Pair(it.key.toInt(), it.value) })
 }

 fun Protocol.Claim.resolveChannelUrls(): List<String> {
    return StatePlatform.instance.resolveChannelUrlsByClaimTemplates(this.claimType.toInt(), this.claimFieldsList.associate { Pair(it.key.toInt(), it.value) })
-}
-
-suspend fun ProcessHandle.fullyBackfillServersAnnounceExceptions() {
-    val systemState = SystemState.fromStorageTypeSystemState(Store.instance.getSystemState(system))
-    if (!systemState.servers.contains(PolycentricCache.SERVER)) {
-        Logger.w("Backfill", "Polycentric prod server not added, adding it.")
-        addServer(PolycentricCache.SERVER)
-    }
-
-    val exceptions = fullyBackfillServers()
-    for (pair in exceptions) {
-        val server = pair.key
-        val exception = pair.value
-
-        StateAnnouncement.instance.registerAnnouncement(
-            "backfill-failed",
-            "Backfill failed",
-            "Failed to backfill server $server. $exception",
-            AnnouncementType.SESSION_RECURRING
-        );
-
-        Logger.e("Backfill", "Failed to backfill server $server.", exception)
-    }
 }
@@ -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 -> {
-            "[${toString()}]"
+            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 -> {
-            toString()
+            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)
 }
@@ -2,11 +2,8 @@ package com.futo.platformplayer

 import android.content.ActivityNotFoundException
 import android.content.Context
-import android.content.Context.POWER_SERVICE
 import android.content.Intent
 import android.net.Uri
-import android.os.Build
-import android.os.PowerManager
 import android.webkit.CookieManager
 import androidx.lifecycle.lifecycleScope
 import com.futo.platformplayer.activities.MainActivity
@@ -27,19 +24,17 @@ import com.futo.platformplayer.states.StateBackup
 import com.futo.platformplayer.states.StateCache
 import com.futo.platformplayer.states.StateMeta
 import com.futo.platformplayer.states.StatePayment
-import com.futo.platformplayer.states.StatePlayer
 import com.futo.platformplayer.states.StatePolycentric
 import com.futo.platformplayer.states.StateUpdate
 import com.futo.platformplayer.stores.FragmentedStorage
 import com.futo.platformplayer.stores.FragmentedStorageFileJson
 import com.futo.platformplayer.views.FeedStyle
+import com.futo.platformplayer.views.fields.AdvancedField
 import com.futo.platformplayer.views.fields.DropdownFieldOptionsId
 import com.futo.platformplayer.views.fields.FieldForm
 import com.futo.platformplayer.views.fields.FormField
 import com.futo.platformplayer.views.fields.FormFieldButton
-import com.futo.platformplayer.views.fields.FormFieldWarning
 import com.futo.platformplayer.views.overlays.slideup.SlideUpMenuItem
-import com.stripe.android.customersheet.injection.CustomerSheetViewModelModule_Companion_ContextFactory.context
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -150,7 +145,6 @@ class Settings : FragmentedStorageFileJson() {
    fun import() {
        val act = SettingsActivity.getActivity() ?: return;
        val intent = MainActivity.getImportOptionsIntent(act);
-        intent.flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK;
        act.startActivity(intent);
    }

@@ -182,6 +176,10 @@ class Settings : FragmentedStorageFileJson() {
        }
    }*/

+
+    @FormField(R.string.advanced_settings, FieldForm.TOGGLE, R.string.advanced_settings_description, -1, "advancedSettings")
+    var advancedSettings: Boolean = false;
+
    @FormField(R.string.language, "group", -1, 0)
    var language = LanguageSettings();
    @Serializable
@@ -212,7 +210,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;

@@ -223,10 +221,16 @@ 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;
+
+        @AdvancedField
        @FormField(R.string.preview_feed_items, FieldForm.TOGGLE, R.string.preview_feed_items_description, 6)
        var previewFeedItems: Boolean = true;

-
+        @AdvancedField
        @FormField(R.string.progress_bar, FieldForm.TOGGLE, R.string.progress_bar_description, 6)
        var progressBar: Boolean = true;

@@ -255,12 +259,17 @@ class Settings : FragmentedStorageFileJson() {
        @DropdownFieldOptionsId(R.array.feed_style)
        var searchFeedStyle: Int = 1;

+        @AdvancedField
        @FormField(R.string.preview_feed_items, FieldForm.TOGGLE, R.string.preview_feed_items_description, 5)
        var previewFeedItems: Boolean = true;

+        @AdvancedField
        @FormField(R.string.progress_bar, FieldForm.TOGGLE, R.string.progress_bar_description, 6)
        var progressBar: Boolean = true;

+        @FormField(R.string.hide_hidden_from_search, FieldForm.TOGGLE, R.string.hide_hidden_from_search_description, 7)
+        var hidefromSearch: Boolean = false;
+

        fun getSearchFeedStyle(): FeedStyle {
            if(searchFeedStyle == 0)
@@ -276,6 +285,7 @@ class Settings : FragmentedStorageFileJson() {
    @Serializable
    class ChannelSettings {

+        @AdvancedField
        @FormField(R.string.progress_bar, FieldForm.TOGGLE, R.string.progress_bar_description, 6)
        var progressBar: Boolean = true;
    }
@@ -298,16 +308,23 @@ 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;
+
+        @AdvancedField
        @FormField(R.string.preview_feed_items, FieldForm.TOGGLE, R.string.preview_feed_items_description, 6)
        var previewFeedItems: Boolean = true;

+        @AdvancedField
        @FormField(R.string.progress_bar, FieldForm.TOGGLE, R.string.progress_bar_description, 7)
        var progressBar: Boolean = true;

+        @AdvancedField
        @FormField(R.string.fetch_on_app_boot, FieldForm.TOGGLE, R.string.shortly_after_opening_the_app_start_fetching_subscriptions, 8)
        @Serializable(with = FlexibleBooleanSerializer::class)
        var fetchOnAppBoot: Boolean = true;

+        @AdvancedField
        @FormField(R.string.fetch_on_tab_opened, FieldForm.TOGGLE, R.string.fetch_on_tab_opened_description, 9)
        var fetchOnTabOpen: Boolean = true;

@@ -338,13 +355,16 @@ class Settings : FragmentedStorageFileJson() {
        @FormField(R.string.show_watch_metrics, FieldForm.TOGGLE, R.string.show_watch_metrics_description, 12)
        var showWatchMetrics: Boolean = false;

+        @AdvancedField
        @FormField(R.string.track_playtime_locally, FieldForm.TOGGLE, R.string.track_playtime_locally_description, 13)
        var allowPlaytimeTracking: Boolean = true;


+        @AdvancedField
        @FormField(R.string.always_reload_from_cache, FieldForm.TOGGLE, R.string.always_reload_from_cache_description, 14)
        var alwaysReloadFromCache: Boolean = false;

+        @AdvancedField
        @FormField(R.string.peek_channel_contents, FieldForm.TOGGLE, R.string.peek_channel_contents_description, 15)
        var peekChannelContents: Boolean = false;

@@ -360,7 +380,7 @@ class Settings : FragmentedStorageFileJson() {
    var playback = PlaybackSettings();
    @Serializable
    class PlaybackSettings {
-        @FormField(R.string.primary_language, FieldForm.DROPDOWN, -1, -1)
+        @FormField(R.string.primary_language, FieldForm.DROPDOWN, -1, -2)
        @DropdownFieldOptionsId(R.array.audio_languages)
        var primaryLanguage: Int = 0;

@@ -384,6 +404,8 @@ class Settings : FragmentedStorageFileJson() {
                else -> null
            }
        }
+        @FormField(R.string.prefer_original_audio, FieldForm.TOGGLE, R.string.prefer_original_audio_description, -1)
+        var preferOriginalAudio: Boolean = true;

        //= context.resources.getStringArray(R.array.audio_languages)[primaryLanguage];

@@ -419,23 +441,22 @@ class Settings : FragmentedStorageFileJson() {
        var preferredPreviewQuality: Int = 5;
        fun getPreferredPreviewQualityPixelCount(): Int = preferedQualityToPixels(preferredPreviewQuality);

-
+        @AdvancedField
        @FormField(R.string.simplify_sources, FieldForm.TOGGLE, R.string.simplify_sources_description, 4)
        var simplifySources: Boolean = true;

-        @FormField(R.string.auto_rotate, FieldForm.DROPDOWN, -1, 5)
-        @DropdownFieldOptionsId(R.array.system_enabled_disabled_array)
-        var autoRotate: Int = 2;
+        @AdvancedField
+        @FormField(R.string.always_allow_reverse_landscape_auto_rotate, FieldForm.TOGGLE, R.string.always_allow_reverse_landscape_auto_rotate_description, 5)
+        var alwaysAllowReverseLandscapeAutoRotate: Boolean = true

-        fun isAutoRotate() = (autoRotate == 1 && !StatePlayer.instance.rotationLock) || (autoRotate == 2 && StateApp.instance.getCurrentSystemAutoRotate() && !StatePlayer.instance.rotationLock);
-
-        @FormField(R.string.background_behavior, FieldForm.DROPDOWN, -1, 7)
+        @FormField(R.string.background_behavior, FieldForm.DROPDOWN, -1, 6)
        @DropdownFieldOptionsId(R.array.player_background_behavior)
        var backgroundPlay: Int = 2;

        fun isBackgroundContinue() = backgroundPlay == 1;
        fun isBackgroundPictureInPicture() = backgroundPlay == 2;

+        @AdvancedField
        @FormField(R.string.resume_after_preview, FieldForm.DROPDOWN, R.string.when_watching_a_video_in_preview_mode_resume_at_the_position_when_opening_the_video_code, 7)
        @DropdownFieldOptionsId(R.array.resume_after_preview)
        var resumeAfterPreview: Int = 1;
@@ -462,14 +483,10 @@ class Settings : FragmentedStorageFileJson() {
            };
        }

+        @AdvancedField
        @FormField(R.string.live_chat_webview, FieldForm.TOGGLE, R.string.use_the_live_chat_web_window_when_available_over_native_implementation, 9)
        var useLiveChatWindow: Boolean = true;

-
-
-        @FormField(R.string.background_switch_audio, FieldForm.TOGGLE, R.string.background_switch_audio_description, 10)
-        var backgroundSwitchToAudio: Boolean = true;
-
        @FormField(R.string.restart_after_audio_focus_loss, FieldForm.DROPDOWN, R.string.restart_playback_when_gaining_audio_focus_after_a_loss, 11)
        @DropdownFieldOptionsId(R.array.restart_playback_after_loss)
        var restartPlaybackAfterLoss: Int = 1;
@@ -484,17 +501,6 @@ class Settings : FragmentedStorageFileJson() {
        @FormField(R.string.reverse_portrait, FieldForm.TOGGLE, R.string.reverse_portrait_description, 14)
        var reversePortrait: Boolean = false;

-        @FormField(R.string.rotation_zone, FieldForm.DROPDOWN, R.string.rotation_zone_description, 15)
-        @DropdownFieldOptionsId(R.array.rotation_zone)
-        var rotationZone: Int = 2;
-
-        @FormField(R.string.stability_threshold_time, FieldForm.DROPDOWN, R.string.stability_threshold_time_description, 16)
-        @DropdownFieldOptionsId(R.array.rotation_threshold_time)
-        var stabilityThresholdTime: Int = 1;
-
-        @FormField(R.string.full_autorotate_lock, FieldForm.TOGGLE, R.string.full_autorotate_lock_description, 17)
-        var fullAutorotateLock: Boolean = false;
-
        @FormField(R.string.prefer_webm, FieldForm.TOGGLE, R.string.prefer_webm_description, 18)
        var preferWebmVideo: Boolean = false;
        @FormField(R.string.prefer_webm_audio, FieldForm.TOGGLE, R.string.prefer_webm_audio_description, 19)
@@ -505,6 +511,79 @@ class Settings : FragmentedStorageFileJson() {

        @FormField(R.string.autoplay, FieldForm.TOGGLE, R.string.autoplay, 21)
        var autoplay: Boolean = false;
+
+        @AdvancedField
+        @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.min_playback_speed, FieldForm.DROPDOWN, R.string.min_playback_speed_description, 25)
+        @DropdownFieldOptionsId(R.array.min_playback_speed)
+        var minimumPlaybackSpeed: Int = 0;
+        @FormField(R.string.max_playback_speed, FieldForm.DROPDOWN, R.string.max_playback_speed_description, 26)
+        @DropdownFieldOptionsId(R.array.max_playback_speed)
+        var maximumPlaybackSpeed: Int = 2;
+        @FormField(R.string.step_playback_speed, FieldForm.DROPDOWN, R.string.step_playback_speed_description, 26)
+        @DropdownFieldOptionsId(R.array.step_playback_speed)
+        var stepPlaybackSpeed: Int = 1;
+
+        fun getPlaybackSpeedStep(): Double {
+            return when(stepPlaybackSpeed) {
+                0 -> 0.05
+                1 -> 0.1
+                2 -> 0.25
+                else -> 0.1;
+            }
+        }
+        fun getPlaybackSpeeds(): List<Double> {
+            val playbackSpeeds = mutableListOf<Double>();
+            playbackSpeeds.add(1.0);
+            val minSpeed = when(minimumPlaybackSpeed) {
+                0 -> 0.25
+                1 -> 0.5
+                2 -> 1.0
+                else -> 0.25
+            }
+            val maxSpeed = when(maximumPlaybackSpeed) {
+                0 -> 2.0
+                1 -> 2.25
+                2 -> 3.0
+                3 -> 4.0
+                4 -> 5.0
+                else -> 2.25;
+            }
+            var testSpeed = 1.0;
+
+            while(testSpeed > minSpeed) {
+                val nextSpeed = (testSpeed - 0.25) as Double;
+                testSpeed = Math.max(nextSpeed, minSpeed);
+                playbackSpeeds.add(testSpeed);
+            }
+            testSpeed = 1.0;
+            while(testSpeed < maxSpeed) {
+                val nextSpeed = (testSpeed + if(testSpeed < 2) 0.25 else 1.0) as Double;
+                testSpeed = Math.min(nextSpeed, maxSpeed);
+                playbackSpeeds.add(testSpeed);
+            }
+            playbackSpeeds.sort();
+            return playbackSpeeds;
+        }
    }

    @FormField(R.string.comments, "group", R.string.comments_description, 6)
@@ -520,6 +599,7 @@ class Settings : FragmentedStorageFileJson() {
        @FormField(R.string.default_recommendations, FieldForm.TOGGLE, R.string.default_recommendations_description, 0)
        var recommendationsDefault: Boolean = false;

+        @AdvancedField
        @FormField(R.string.hide_recommendations, FieldForm.TOGGLE, R.string.hide_recommendations_description, 0)
        var hideRecommendations: Boolean = false;

@@ -556,10 +636,12 @@ class Settings : FragmentedStorageFileJson() {
        var preferredAudioQuality: Int = 1;
        fun isHighBitrateDefault(): Boolean = preferredAudioQuality > 0;

+        @AdvancedField
        @FormField(R.string.byte_range_download, FieldForm.TOGGLE, R.string.attempt_to_utilize_byte_ranges, 4)
        @Serializable(with = FlexibleBooleanSerializer::class)
        var byteRangeDownload: Boolean = true;

+        @AdvancedField
        @FormField(R.string.byte_range_concurrency, FieldForm.DROPDOWN, R.string.number_of_concurrent_threads_to_multiply_download_speeds_from_throttled_sources, 5)
        @DropdownFieldOptionsId(R.array.thread_count)
        var byteRangeConcurrency: Int = 3;
@@ -589,10 +671,21 @@ 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)
+        @AdvancedField
+        @FormField(R.string.always_proxy_requests, FieldForm.TOGGLE, R.string.always_proxy_requests_description, 3)
        @Serializable(with = FlexibleBooleanSerializer::class)
        var alwaysProxyRequests: Boolean = false;

+        @AdvancedField
+        @FormField(R.string.allow_ipv6, FieldForm.TOGGLE, R.string.allow_ipv6_description, 4)
+        @Serializable(with = FlexibleBooleanSerializer::class)
+        var allowIpv6: Boolean = true;
+
+        @AdvancedField
+        @FormField(R.string.allow_ipv4, FieldForm.TOGGLE, R.string.allow_ipv4_description, 5)
+        @Serializable(with = FlexibleBooleanSerializer::class)
+        var allowLinkLocalIpv4: Boolean = false;
+
        /*TODO: Should we have a different casting quality?
        @FormField("Preferred Casting Quality", FieldForm.DROPDOWN, "", 3)
        @DropdownFieldOptionsId(R.array.preferred_quality_array)
@@ -660,6 +753,11 @@ class Settings : FragmentedStorageFileJson() {
    @Serializable
    class Plugins {

+        @AdvancedField
+        @FormField(R.string.check_disabled_plugin_updates, FieldForm.TOGGLE, R.string.check_disabled_plugin_updates_description, -1)
+        var checkDisabledPluginsForUpdates: Boolean = false;
+
+        @AdvancedField
        @FormField(R.string.clear_cookies_on_logout, FieldForm.TOGGLE, R.string.clears_cookies_when_you_log_out, 0)
        var clearCookiesOnLogout: Boolean = true;

@@ -860,12 +958,32 @@ class Settings : FragmentedStorageFileJson() {
        @FormField(R.string.payment_status, FieldForm.READONLYTEXT, -1, 1)
        val paymentStatus: String get() = SettingsActivity.getActivity()?.let { if (StatePayment.instance.hasPaid) it.getString(R.string.paid) else it.getString(R.string.not_paid); } ?: "Unknown";

-        @FormField(R.string.clear_payment, FieldForm.BUTTON, R.string.deletes_license_keys_from_app, 2)
-        fun clearPayment() {
-            StatePayment.instance.clearLicenses();
+        @FormField(R.string.license_status, FieldForm.BUTTON, R.string.view_license_status, 2)
+        fun viewLicenseStatus() {
            SettingsActivity.getActivity()?.let {
-                UIDialogs.toast(it, it.getString(R.string.licenses_cleared_might_require_app_restart));
-                it.reloadSettings();
+                try {
+                    if (StatePayment.instance.hasPaid) {
+                        val paymentKey = StatePayment.instance.getPaymentKey()
+                        UIDialogs.showDialogOk(it, R.drawable.ic_paid, "License activated\n" + paymentKey.first)
+                    } else {
+                        UIDialogs.showDialogOk(it, R.drawable.ic_paid, "No license activated")
+                    }
+                } catch (e: Throwable) {
+                    Logger.e(TAG, "Failed to show license status dialog", e)
+                }
+            }
+        }
+
+        @FormField(R.string.clear_payment, FieldForm.BUTTON, R.string.deletes_license_keys_from_app, 3)
+        fun clearPayment() {
+            SettingsActivity.getActivity()?.let { context ->
+                UIDialogs.showConfirmationDialog(context, "Are you sure you want to delete your license?", {
+                    StatePayment.instance.clearLicenses();
+                    SettingsActivity.getActivity()?.let {
+                        UIDialogs.toast(it, it.getString(R.string.licenses_cleared_might_require_app_restart));
+                        it.reloadSettings();
+                    }
+                })
            }
        }
    }
@@ -874,12 +992,18 @@ class Settings : FragmentedStorageFileJson() {
    var other = Other();
    @Serializable
    class Other {
-        @FormField(R.string.bypass_rotation_prevention, FieldForm.TOGGLE, R.string.bypass_rotation_prevention_description, 1)
-        @FormFieldWarning(R.string.bypass_rotation_prevention_warning)
-        var bypassRotationPrevention: Boolean = false;
+        @AdvancedField
+        @FormField(R.string.playlist_delete_confirmation, FieldForm.TOGGLE, R.string.playlist_delete_confirmation_description, 2)
+        var playlistDeleteConfirmation: Boolean = true;
+        @AdvancedField
+        @FormField(R.string.playlist_allow_dups, FieldForm.TOGGLE, R.string.playlist_allow_dups_description, 3)
+        var playlistAllowDups: Boolean = true;

-        @FormField(R.string.enable_polycentric, FieldForm.TOGGLE, R.string.can_be_disabled_when_you_are_experiencing_issues, 1)
+        @FormField(R.string.enable_polycentric, FieldForm.TOGGLE, R.string.can_be_disabled_when_you_are_experiencing_issues, 4)
        var polycentricEnabled: Boolean = true;
+
+        @FormField(R.string.polycentric_local_cache, FieldForm.TOGGLE, R.string.polycentric_local_cache_description, 5)
+        var polycentricLocalCache: Boolean = true;
    }

    @FormField(R.string.gesture_controls, FieldForm.GROUP, -1, 19)
@@ -916,16 +1040,31 @@ 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 = true;
+        var broadcast: Boolean = false;

        @FormField(R.string.connect_discovered, FieldForm.TOGGLE, R.string.connect_discovered_description, 2)
        var connectDiscovered: Boolean = true;

        @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)
@@ -994,4 +1133,4 @@ class Settings : FragmentedStorageFileJson() {
        }
    }
    //endregion
-}
+}
@@ -1,6 +1,7 @@
 package com.futo.platformplayer

 import android.content.Context
+import android.content.Intent
 import android.webkit.CookieManager
 import androidx.work.Data
 import androidx.work.OneTimeWorkRequestBuilder
@@ -1,86 +0,0 @@
-package com.futo.platformplayer
-
-import android.app.Activity
-import android.content.pm.ActivityInfo
-import android.hardware.SensorManager
-import android.view.OrientationEventListener
-import com.futo.platformplayer.constructs.Event1
-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.launch
-
-class SimpleOrientationListener(
-    private val activity: Activity,
-    private val lifecycleScope: CoroutineScope
-) {
-    private var lastOrientation: Int = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-    private var lastStableOrientation: Int = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED
-    private var _currentJob: Job? = null
-
-    val onOrientationChanged = Event1<Int>()
-
-    private val orientationListener = object : OrientationEventListener(activity, SensorManager.SENSOR_DELAY_UI) {
-        override fun onOrientationChanged(orientation: Int) {
-            //val rotationZone = 45
-            val stabilityThresholdTime = when (Settings.instance.playback.stabilityThresholdTime) {
-                0 -> 100L
-                1 -> 500L
-                2 -> 750L
-                3 -> 1000L
-                4 -> 1500L
-                5 -> 2000L
-                else -> 500L
-            }
-
-            val rotationZone = when (Settings.instance.playback.rotationZone) {
-                0 -> 15
-                1 -> 30
-                2 -> 45
-                else -> 45
-            }
-
-            val newOrientation = when {
-                orientation in (90 - rotationZone)..(90 + rotationZone - 1) -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE
-                orientation in (180 - rotationZone)..(180 + rotationZone - 1) -> ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT
-                orientation in (270 - rotationZone)..(270 + rotationZone - 1) -> ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE
-                orientation in (360 - rotationZone)..(360 + rotationZone - 1) || orientation in 0..(rotationZone - 1) -> ActivityInfo.SCREEN_ORIENTATION_PORTRAIT
-                else -> lastOrientation
-            }
-
-            if (newOrientation != lastStableOrientation) {
-                lastStableOrientation = newOrientation
-
-                _currentJob?.cancel()
-                _currentJob = lifecycleScope.launch(Dispatchers.Main) {
-                    try {
-                        delay(stabilityThresholdTime)
-                        if (newOrientation == lastStableOrientation) {
-                            lastOrientation = newOrientation
-                            onOrientationChanged.emit(newOrientation)
-                        }
-                    } catch (e: Throwable) {
-                        Logger.i(TAG, "Failed to trigger onOrientationChanged", e)
-                    }
-                }
-            }
-        }
-    }
-
-    init {
-        orientationListener.enable()
-        lastOrientation = activity.resources.configuration.orientation
-    }
-
-    fun stopListening() {
-        _currentJob?.cancel()
-        _currentJob = null
-        orientationListener.disable()
-    }
-
-    companion object {
-        private val TAG = "SimpleOrientationListener"
-    }
-}
@@ -5,7 +5,9 @@ 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
 import android.util.TypedValue
 import android.view.Gravity
@@ -198,34 +200,39 @@ 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;
            };
            view.findViewById<TextView>(R.id.dialog_text_details).apply {
-                if(textDetails == null)
+                if (textDetails == null)
                    this.visibility = View.GONE;
-                else
+                else {
                    this.text = textDetails;
+                }
            };
            view.findViewById<TextView>(R.id.dialog_text_code).apply {
-                if(code == null)
-                    this.visibility = View.GONE;
+                if (code == null) this.visibility = View.GONE;
                else {
                    this.text = code;
                    this.movementMethod = ScrollingMovementMethod.getInstance();
                    this.visibility = View.VISIBLE;
+                    this.textAlignment = View.TEXT_ALIGNMENT_VIEW_START
                }
            };
            view.findViewById<LinearLayout>(R.id.dialog_buttons).apply {
@@ -274,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) {
@@ -311,7 +319,11 @@ class UIDialogs {
                        closeAction?.invoke()
                    }, UIDialogs.ActionStyle.NONE),
                    UIDialogs.Action(context.getString(R.string.retry), {
-                        retryAction?.invoke();
+                        try {
+                            retryAction?.invoke();
+                        } catch (e: Throwable) {
+                            Logger.e(TAG, "Unhandled exception retrying", e)
+                        }
                    }, UIDialogs.ActionStyle.PRIMARY)
                );
            else
@@ -325,7 +337,11 @@ class UIDialogs {
                        closeAction?.invoke()
                    }, UIDialogs.ActionStyle.NONE),
                    UIDialogs.Action(context.getString(R.string.retry), {
-                        retryAction?.invoke();
+                        try {
+                            retryAction?.invoke();
+                        } catch (e: Throwable) {
+                            Logger.e(TAG, "Unhandled exception retrying", e)
+                        }
                    }, UIDialogs.ActionStyle.PRIMARY)
                );
        }
@@ -348,6 +364,13 @@ class UIDialogs {
            showDialog(context, R.drawable.ic_error, text, null, null, 0, cancelButtonAction, confirmButtonAction)
        }

+        fun showConfirmationDialog(context: Context, text: String, action: () -> Unit, cancelAction: (() -> Unit)? = null, doNotAskAgainAction: (() -> Unit)? = null) {
+            val confirmButtonAction = Action(context.getString(R.string.confirm), action, ActionStyle.PRIMARY)
+            val cancelButtonAction = Action(context.getString(R.string.cancel), cancelAction ?: {}, ActionStyle.ACCENT)
+            val doNotAskAgain = Action(context.getString(R.string.do_not_ask_again), doNotAskAgainAction ?: {}, ActionStyle.NONE)
+            showDialog(context, R.drawable.ic_error, text, null, null, 0, doNotAskAgain, cancelButtonAction, confirmButtonAction)
+        }
+
        fun showUpdateAvailableDialog(context: Context, lastVersion: Int, hideExceptionButtons: Boolean = false) {
            val dialog = AutoUpdateDialog(context);
            registerDialogOpened(dialog);
@@ -360,8 +383,8 @@ class UIDialogs {
            }
        }

-        fun showChangelogDialog(context: Context, lastVersion: Int) {
-            val dialog = ChangelogDialog(context);
+        fun showChangelogDialog(context: Context, lastVersion: Int, changelogs: Map<Int, String>? = null) {
+            val dialog = ChangelogDialog(context, changelogs);
            registerDialogOpened(dialog);
            dialog.setOnDismissListener { registerDialogClosed(dialog) };
            dialog.show();
@@ -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
@@ -25,6 +31,7 @@ import com.futo.platformplayer.api.media.models.subtitles.ISubtitleSource
 import com.futo.platformplayer.api.media.models.video.IPlatformVideo
 import com.futo.platformplayer.api.media.models.video.IPlatformVideoDetails
 import com.futo.platformplayer.api.media.models.video.SerializedPlatformVideo
+import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSDashManifestRawAudioSource
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSDashManifestRawSource
 import com.futo.platformplayer.downloads.VideoLocal
@@ -36,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
@@ -62,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 {
@@ -78,6 +90,36 @@ class UISlideOverlays {
            return menu;
        }

+        fun showQueueOptionsOverlay(context: Context, container: ViewGroup) {
+            UISlideOverlays.showOverlay(container, "Queue options", null, {
+
+            }, SlideUpMenuItem(context, R.drawable.ic_playlist, "Save as playlist", "", "Creates a new playlist with queue as videos", null, {
+                val nameInput = SlideUpMenuTextInput(container.context, container.context.getString(R.string.name));
+                val addPlaylistOverlay = SlideUpMenuOverlay(container.context, container, container.context.getString(R.string.create_new_playlist), container.context.getString(R.string.ok), false, nameInput);
+
+                addPlaylistOverlay.onOK.subscribe {
+                    val text = nameInput.text.trim()
+                    if (text.isBlank()) {
+                        return@subscribe;
+                    }
+
+                    addPlaylistOverlay.hide();
+                    nameInput.deactivate();
+                    nameInput.clear();
+                    StatePlayer.instance.saveQueueAsPlaylist(text);
+                    UIDialogs.appToast("Playlist [${text}] created");
+                };
+
+                addPlaylistOverlay.onCancel.subscribe {
+                    nameInput.deactivate();
+                    nameInput.clear();
+                };
+
+                addPlaylistOverlay.show();
+                nameInput.activate();
+            }, false));
+        }
+
        fun showSubscriptionOptionsOverlay(subscription: Subscription, container: ViewGroup): SlideUpMenuOverlay {
            val items = arrayListOf<View>();

@@ -268,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)
@@ -279,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
@@ -291,53 +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)
+                            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
+                            ))
+                        } 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))
-                            },
-                            invokeParent = false
-                        ))
-                    }
+                            }, 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)
-                                slideUpMenuOverlay.setOk(container.context.getString(R.string.download))
-                            },
-                            invokeParent = 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>()
@@ -365,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, 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 {
@@ -416,7 +511,7 @@ class UISlideOverlays {
            }

            items.add(SlideUpMenuGroup(container.context, container.context.getString(R.string.video), videoSources,
-                listOf(listOf(SlideUpMenuItem(
+                listOf((if (audioSources != null) listOf(SlideUpMenuItem(
                    container.context,
                    R.drawable.ic_movie,
                    container.context.getString(R.string.none),
@@ -429,7 +524,7 @@ class UISlideOverlays {
                            menu?.setOk(container.context.getString(R.string.download));
                    },
                    invokeParent = false
-                )) +
+                )) else listOf()) +
                videoSources
                .filter { it.isDownloadable() }
                .map {
@@ -651,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() };
@@ -879,6 +978,12 @@ class UISlideOverlays {
            val items = arrayListOf<View>();
            val lastUpdated = StatePlaylists.instance.getLastUpdatedPlaylist();

+            val isLimited = video?.url != null && StatePlatform.instance.getContentClientOrNull(video!!.url)?.let {
+                if (it is JSClient)
+                    return@let it.config.reduceFunctionsInLimitedVersion && BuildConfig.IS_PLAYSTORE_BUILD
+                else false;
+            } ?: false;
+
            if (lastUpdated != null) {
                items.add(
                    SlideUpMenuGroup(container.context, container.context.getString(R.string.recently_used_playlist), "recentlyusedplaylist",
@@ -888,7 +993,8 @@ class UISlideOverlays {
                            "${lastUpdated.videos.size} " + container.context.getString(R.string.videos),
                            tag = "",
                            call = {
-                                StatePlaylists.instance.addToPlaylist(lastUpdated.id, video);
+                                if(StatePlaylists.instance.addToPlaylist(lastUpdated.id, video))
+                                    UIDialogs.appToast("Added to playlist [${lastUpdated?.name}]", false);
                                StateDownloads.instance.checkForOutdatedPlaylists();
                            }))
                );
@@ -899,17 +1005,18 @@ class UISlideOverlays {
            val watchLater = StatePlaylists.instance.getWatchLater();
            items.add(SlideUpMenuGroup(container.context, container.context.getString(R.string.actions), "actions",
                (listOf(
-                    SlideUpMenuItem(
-                        container.context,
-                        R.drawable.ic_download,
-                        container.context.getString(R.string.download),
-                        container.context.getString(R.string.download_the_video),
-                        tag = "download",
-                        call = {
-                            showDownloadVideoOverlay(video, container, true);
-                        },
-                        invokeParent = false
-                    ),
+                    if(!isLimited && !video.isLive)
+                        SlideUpMenuItem(
+                            container.context,
+                            R.drawable.ic_download,
+                            container.context.getString(R.string.download),
+                            container.context.getString(R.string.download_the_video),
+                            tag = "download",
+                            call = {
+                                showDownloadVideoOverlay(video, container, true);
+                            },
+                            invokeParent = false
+                        ) else null,
                    SlideUpMenuItem(
                        container.context,
                        R.drawable.ic_share,
@@ -936,29 +1043,33 @@ class UISlideOverlays {
                            StateMeta.instance.addHiddenCreator(video.author.url);
                            UIDialogs.toast(container.context, "[${video.author.name}] hidden, you may need to reload home");
                        }))
-                        + actions)
+                        + 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)); }),
-                    SlideUpMenuItem(container.context,
+                        call = { StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(video), true); }),
+                    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(
@@ -983,7 +1094,8 @@ class UISlideOverlays {
                    "${playlist.videos.size} " + container.context.getString(R.string.videos),
                    tag = "",
                    call = {
-                        StatePlaylists.instance.addToPlaylist(playlist.id, video);
+                        if(StatePlaylists.instance.addToPlaylist(playlist.id, video))
+                            UIDialogs.appToast("Added to playlist [${playlist.name}]", false);
                        StateDownloads.instance.checkForOutdatedPlaylists();
                    }));
            }
@@ -1010,7 +1122,8 @@ class UISlideOverlays {
                            "${lastUpdated.videos.size} " + container.context.getString(R.string.videos),
                            tag = "",
                            call = {
-                                StatePlaylists.instance.addToPlaylist(lastUpdated.id, video);
+                                if(StatePlaylists.instance.addToPlaylist(lastUpdated.id, video))
+                                    UIDialogs.appToast("Added to playlist [${lastUpdated?.name}]", false);
                                StateDownloads.instance.checkForOutdatedPlaylists();
                            }))
                );
@@ -1020,28 +1133,26 @@ 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),
                        tag = "watch later",
-                        call = { StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(video)); }),
-                    SlideUpMenuItem(
-                        container.context,
-                        R.drawable.ic_download,
-                        container.context.getString(R.string.download),
-                        container.context.getString(R.string.download_the_video),
-                        tag = container.context.getString(R.string.download),
-                        call = { showDownloadVideoOverlay(video, container, true); },
-                        invokeParent = false
-                    ))
+                        call = {
+                            if(StatePlaylists.instance.addToWatchLater(SerializedPlatformVideo.fromVideo(video), true))
+                                UIDialogs.appToast("Added to watch later", false);
+                        }),
+                )
            );

            val playlistItems = arrayListOf<SlideUpMenuItem>();
@@ -1067,7 +1178,8 @@ class UISlideOverlays {
                    "${playlist.videos.size} " + container.context.getString(R.string.videos),
                    tag = "",
                    call = {
-                        StatePlaylists.instance.addToPlaylist(playlist.id, video);
+                        if(StatePlaylists.instance.addToPlaylist(playlist.id, video))
+                            UIDialogs.appToast("Added to playlist [${playlist.name}]", false);
                        StateDownloads.instance.checkForOutdatedPlaylists();
                    }));
            }
@@ -1078,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;
        }
@@ -1109,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 }
@@ -1117,7 +1229,7 @@ class UISlideOverlays {
                                .toList();

                            onPinnedbuttons?.invoke(selected + (visible + hidden).filter { !selected.contains(it) });
-                        }
+                        });
                    },
                    invokeParent = false
                ))
@@ -1125,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();
@@ -27,13 +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.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 {
@@ -65,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")
    }
@@ -232,4 +249,213 @@ fun String.decodeUnicode(): String {
        i++
    }
    return sb.toString()
-}
+}
+
+fun <T> smartMerge(targetArr: List<T>, toMerge: List<T>) : List<T>{
+    val missingToMerge = toMerge.filter { !targetArr.contains(it) }.toList();
+    val newArrResult = targetArr.toMutableList();
+
+    for(missing in missingToMerge) {
+        val newIndex = findNewIndex(toMerge, newArrResult, missing);
+        newArrResult.add(newIndex, missing);
+    }
+
+    return newArrResult;
+}
+fun <T> findNewIndex(originalArr: List<T>, newArr: List<T>, item: T): Int{
+    var originalIndex = originalArr.indexOf(item);
+    var newIndex = -1;
+
+    for(i in originalIndex-1 downTo 0) {
+        val previousItem = originalArr[i];
+        val indexInNewArr = newArr.indexOfFirst { it == previousItem };
+        if(indexInNewArr >= 0) {
+            newIndex = indexInNewArr + 1;
+            break;
+        }
+    }
+    if(newIndex < 0) {
+        for(i in originalIndex+1 until originalArr.size) {
+            val previousItem = originalArr[i];
+            val indexInNewArr = newArr.indexOfFirst { it == previousItem };
+            if(indexInNewArr >= 0) {
+                newIndex = indexInNewArr - 1;
+                break;
+            }
+        }
+    }
+    if(newIndex < 0)
+        return newArr.size;
+    else
+        return newIndex;
+}
+
+fun ByteBuffer.toUtf8String(): String {
+    val remainingBytes = ByteArray(remaining())
+    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 findCandidateAddresses(): List<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
+        .sortedWith(
+            compareBy<Pair<NetworkInterface, InterfaceAddress>>(
+                { addressScore(it.second.address) },
+                { interfaceScore(it.first) },
+                { -it.second.networkPrefixLength.toInt() },
+                { -it.first.mtu }
+            )
+        ).map { it.second.address }
+}
+
+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)
@@ -10,11 +10,13 @@ import androidx.appcompat.app.AppCompatActivity
 import com.futo.platformplayer.*
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.views.buttons.BigButton
+import com.futo.platformplayer.views.overlays.slideup.SlideUpMenuTextInput
 import com.google.zxing.integration.android.IntentIntegrator

 class AddSourceOptionsActivity : AppCompatActivity() {
    lateinit var _buttonBack: ImageButton;

+    lateinit var _overlayContainer: FrameLayout;
    lateinit var _buttonQR: BigButton;
    lateinit var _buttonBrowse: BigButton;
    lateinit var _buttonURL: BigButton;
@@ -54,6 +56,7 @@ class AddSourceOptionsActivity : AppCompatActivity() {
        setContentView(R.layout.activity_add_source_options);
        setNavigationBarColorAndIcons();

+        _overlayContainer = findViewById(R.id.overlay_container);
        _buttonBack = findViewById(R.id.button_back);

        _buttonQR = findViewById(R.id.option_qr);
@@ -81,7 +84,25 @@ class AddSourceOptionsActivity : AppCompatActivity() {
        }

        _buttonURL.onClick.subscribe {
-            UIDialogs.toast(this, getString(R.string.not_implemented_yet));
+            val nameInput = SlideUpMenuTextInput(this, "ex. https://yourplugin.com/config.json");
+            UISlideOverlays.showOverlay(_overlayContainer, "Enter your url", "Install", {
+
+                val content = nameInput.text;
+
+                val url = if (content.startsWith("https://")) {
+                    content
+                } else if (content.startsWith("grayjay://plugin/")) {
+                    content.substring("grayjay://plugin/".length)
+                } else {
+                    UIDialogs.toast(this, getString(R.string.not_a_plugin_url))
+                    return@showOverlay;
+                }
+
+                val intent = Intent(this, AddSourceActivity::class.java).apply {
+                    data = Uri.parse(url);
+                };
+                startActivity(intent);
+            }, nameInput)
        }
    }
 }
@@ -113,7 +113,7 @@ class LoginActivity : AppCompatActivity() {

    companion object {
        private val TAG = "LoginActivity";
-        private val REGEX_LOGIN_BUTTON = Regex("[a-zA-Z\\-\\.#_ ]*");
+        private val REGEX_LOGIN_BUTTON = Regex("[a-zA-Z\\-\\.#:_ ]*");

        private var _callback: ((SourceAuth?) -> Unit)? = null;

@@ -11,16 +11,16 @@ import androidx.appcompat.app.AppCompatActivity
 import androidx.lifecycle.lifecycleScope
 import com.futo.platformplayer.R
 import com.futo.platformplayer.UIDialogs
-import com.futo.platformplayer.fullyBackfillServersAnnounceExceptions
 import com.futo.platformplayer.logging.Logger
-import com.futo.platformplayer.polycentric.PolycentricCache
 import com.futo.platformplayer.polycentric.PolycentricStorage
 import com.futo.platformplayer.setNavigationBarColorAndIcons
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StatePolycentric
 import com.futo.platformplayer.views.LoaderView
+import com.futo.polycentric.core.ApiMethods
 import com.futo.polycentric.core.ProcessHandle
 import com.futo.polycentric.core.Store
+import com.futo.polycentric.core.fullyBackfillServersAnnounceExceptions
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.launch
 import kotlinx.coroutines.withContext
@@ -87,7 +87,7 @@ class PolycentricCreateProfileActivity : AppCompatActivity() {
                                Logger.e(TAG, "Failed to save process secret to secret storage.", e)
                            }

-                            processHandle.addServer(PolycentricCache.SERVER);
+                            processHandle.addServer(ApiMethods.SERVER);
                            processHandle.setUsername(username);
                            StatePolycentric.instance.setProcessHandle(processHandle);
                        } catch (e: Throwable) {
@@ -12,12 +12,12 @@ import androidx.lifecycle.lifecycleScope
 import com.futo.platformplayer.R
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.logging.Logger
-import com.futo.platformplayer.polycentric.PolycentricCache
 import com.futo.platformplayer.polycentric.PolycentricStorage
 import com.futo.platformplayer.setNavigationBarColorAndIcons
 import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StatePolycentric
 import com.futo.platformplayer.views.overlays.LoaderOverlay
+import com.futo.polycentric.core.ApiMethods
 import com.futo.polycentric.core.KeyPair
 import com.futo.polycentric.core.Process
 import com.futo.polycentric.core.ProcessSecret
@@ -145,7 +145,7 @@ class PolycentricImportProfileActivity : AppCompatActivity() {
                }

                StatePolycentric.instance.setProcessHandle(processHandle);
-                processHandle.fullyBackfillClient(PolycentricCache.SERVER);
+                processHandle.fullyBackfillClient(ApiMethods.SERVER);
                withContext(Dispatchers.Main) {
                    startActivity(Intent(this@PolycentricImportProfileActivity, PolycentricProfileActivity::class.java));
                    finish();
@@ -21,10 +21,8 @@ import com.bumptech.glide.Glide
 import com.futo.platformplayer.R
 import com.futo.platformplayer.UIDialogs
 import com.futo.platformplayer.dp
-import com.futo.platformplayer.fullyBackfillServersAnnounceExceptions
 import com.futo.platformplayer.images.GlideHelper.Companion.crossfade
 import com.futo.platformplayer.logging.Logger
-import com.futo.platformplayer.polycentric.PolycentricCache
 import com.futo.platformplayer.polycentric.PolycentricStorage
 import com.futo.platformplayer.selectBestImage
 import com.futo.platformplayer.setNavigationBarColorAndIcons
@@ -32,8 +30,10 @@ import com.futo.platformplayer.states.StateApp
 import com.futo.platformplayer.states.StatePolycentric
 import com.futo.platformplayer.views.buttons.BigButton
 import com.futo.platformplayer.views.overlays.LoaderOverlay
+import com.futo.polycentric.core.ApiMethods
 import com.futo.polycentric.core.Store
 import com.futo.polycentric.core.SystemState
+import com.futo.polycentric.core.fullyBackfillServersAnnounceExceptions
 import com.futo.polycentric.core.systemToURLInfoSystemLinkUrl
 import com.futo.polycentric.core.toBase64Url
 import com.futo.polycentric.core.toURLInfoSystemLinkUrl
@@ -145,7 +145,7 @@ class PolycentricProfileActivity : AppCompatActivity() {

            lifecycleScope.launch(Dispatchers.IO) {
                try {
-                    processHandle.fullyBackfillClient(PolycentricCache.SERVER)
+                    processHandle.fullyBackfillClient(ApiMethods.SERVER)

                    withContext(Dispatchers.Main) {
                        updateUI();
@@ -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,9 +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)
-            .setName(publicKey)
-            .setStatus(if (connected) "Connected" else "Disconnected")
+        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 && authorized) "Connected" else "Disconnected or unauthorized")
        return syncDeviceView
    }

@@ -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
                            }
@@ -122,7 +129,11 @@ class SyncPairActivity : AppCompatActivity() {
                } catch (e: Throwable) {
                    withContext(Dispatchers.Main) {
                        _layoutPairingError.visibility = View.VISIBLE
-                        _textError.text = e.message
+                        if(e.message == "Failed to connect") {
+                            _textError.text = "Failed to connect.\n\nThis may be due to not being on the same network, due to firewall, or vpn.\nSync currently operates only over local direct connections."
+                        }
+                        else
+                            _textError.text = e.message
                        _layoutPairing.visibility = View.GONE
                        Logger.e(TAG, "Failed to pair", e)
                    }
@@ -133,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
        }
    }

@@ -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?) {
@@ -5,6 +5,8 @@ import com.futo.platformplayer.SettingsDev
 import com.futo.platformplayer.constructs.Event1
 import com.futo.platformplayer.ensureNotMainThread
 import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.states.StateApp
+import com.futo.platformplayer.stores.FragmentedStorage
 import okhttp3.Call
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
 import okhttp3.OkHttpClient
@@ -63,7 +65,7 @@ open class ManagedHttpClient {

    constructor(builder: OkHttpClient.Builder = OkHttpClient.Builder()) {
        _builderTemplate = builder;
-        if(SettingsDev.instance.developerMode && SettingsDev.instance.networking.allowAllCertificates)
+        if(FragmentedStorage.isInitialized && StateApp.instance.isMainActive && SettingsDev.instance.developerMode && SettingsDev.instance.networking.allowAllCertificates)
            trustAllCertificates(builder);
        client = builder.addNetworkInterceptor { chain ->
            val request = beforeRequest(chain.request());
@@ -88,6 +90,7 @@ open class ManagedHttpClient {
    }

    fun tryHead(url: String): Map<String, String>? {
+        ensureNotMainThread()
        try {
            val result = head(url);
            if(result.isOk)
@@ -102,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" })
@@ -298,6 +301,7 @@ open class ManagedHttpClient {
        }

        fun send(msg: String) {
+            ensureNotMainThread()
            socket.send(msg);
        }

@@ -73,7 +73,7 @@ class HttpFileHandler(method: String, path: String, private val contentType: Str
                        Logger.v(TAG, "Sent bytes $current-${current + bytesToSend}, totalBytesSent=$totalBytesSent")

                        current += bytesToSend.toLong()
-                        if (current >= end) {
+                        if (current > end) {
                            Logger.i(TAG, "Expected amount of bytes sent")
                            break
                        }
@@ -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
    /**
@@ -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);
@@ -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)
@@ -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
+    }
 }
@@ -30,6 +30,7 @@ class ResultCapabilities(
        const val TYPE_POSTS = "POSTS";
        const val TYPE_MIXED = "MIXED";
        const val TYPE_SUBSCRIPTIONS = "SUBSCRIPTIONS";
+        const val TYPE_SHORTS = "SHORTS";

        const val ORDER_CHONOLOGICAL = "CHRONOLOGICAL";

@@ -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?;
+}
@@ -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;
+}
@@ -0,0 +1,63 @@
+package com.futo.platformplayer.api.media.models.comments
+
+import com.futo.platformplayer.api.media.IPlatformClient
+import com.futo.platformplayer.api.media.models.PlatformAuthorLink
+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.ratings.RatingType
+import com.futo.platformplayer.api.media.structures.IPager
+import com.futo.platformplayer.logging.Logger
+import kotlinx.coroutines.Deferred
+import java.time.OffsetDateTime
+
+class LazyComment: IPlatformComment {
+    private var _commentDeferred: Deferred<IPlatformComment>;
+    private var _commentLoaded: IPlatformComment? = null;
+    private var _commentException: Throwable? = null;
+
+    override val contextUrl: String
+        get() = _commentLoaded?.contextUrl ?: "";
+    override val author: PlatformAuthorLink
+        get() = _commentLoaded?.author ?: PlatformAuthorLink.UNKNOWN;
+    override val message: String
+        get() = _commentLoaded?.message ?: "";
+    override val rating: IRating
+        get() = _commentLoaded?.rating ?: RatingLikes(0);
+    override val date: OffsetDateTime?
+        get() = _commentLoaded?.date ?: OffsetDateTime.MIN;
+    override val replyCount: Int?
+        get() = _commentLoaded?.replyCount ?: 0;
+
+    val isAvailable: Boolean get() = _commentLoaded != null;
+
+    private var _uiHandler: ((LazyComment)->Unit)? = null;
+
+    constructor(commentDeferred: Deferred<IPlatformComment>) {
+        _commentDeferred = commentDeferred;
+        _commentDeferred.invokeOnCompletion {
+            if(it == null) {
+                _commentLoaded = commentDeferred.getCompleted();
+                Logger.i("LazyComment", "Resolved comment");
+            }
+            else {
+                _commentException = it;
+                Logger.e("LazyComment", "Resolving comment failed: ${it.message}", it);
+            }
+
+            _uiHandler?.invoke(this);
+        }
+    }
+
+    fun getUnderlyingComment(): IPlatformComment? {
+        return _commentLoaded;
+    }
+
+    fun setUIHandler(handler: (LazyComment)->Unit){
+        _uiHandler = handler;
+    }
+
+    override fun getReplies(client: IPlatformClient): IPager<IPlatformComment>? {
+        return _commentLoaded?.getReplies(client);
+    }
+
+}
@@ -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),

@@ -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 {
@@ -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
@@ -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();
@@ -13,7 +13,8 @@ class AudioUrlSource(
    override val codec: String = "",
    override val language: String = Language.UNKNOWN,
    override val duration: Long? = null,
-    override var priority: Boolean = false
+    override var priority: Boolean = false,
+    override var original: Boolean = false
 ) : IAudioUrlSource, IStreamMetaDataSource{
    override var streamMetaData: StreamMetaData? = null;

@@ -36,7 +37,9 @@ class AudioUrlSource(
                source.container,
                source.codec,
                source.language,
-                source.duration
+                source.duration,
+                source.priority,
+                source.original
            );
            ret.streamMetaData = streamData;

@@ -27,6 +27,7 @@ class HLSVariantAudioUrlSource(
    override val language: String,
    override val duration: Long?,
    override val priority: Boolean,
+    override val original: Boolean,
    val url: String
 ) : IAudioUrlSource {
    override fun getAudioUrl(): String {
@@ -8,4 +8,5 @@ interface IAudioSource {
    val language : String;
    val duration : Long?;
    val priority: Boolean;
+    val original: Boolean;
 }
@@ -1,6 +1,3 @@
 package com.futo.platformplayer.api.media.models.streams.sources

-interface IAudioUrlWidevineSource : IAudioUrlSource {
-    val bearerToken: String
-    val licenseUri: String
-}
+interface IAudioUrlWidevineSource : IAudioUrlSource, IWidevineSource
@@ -0,0 +1,5 @@
+package com.futo.platformplayer.api.media.models.streams.sources
+
+interface IDashManifestWidevineSource : IWidevineSource {
+    val url: String
+}
@@ -0,0 +1,3 @@
+package com.futo.platformplayer.api.media.models.streams.sources
+
+interface IVideoUrlWidevineSource : IVideoUrlSource, IWidevineSource
@@ -0,0 +1,9 @@
+package com.futo.platformplayer.api.media.models.streams.sources
+
+import com.futo.platformplayer.api.media.platforms.js.models.JSRequestExecutor
+
+interface IWidevineSource {
+    val licenseUri: String
+    val hasLicenseRequestExecutor: Boolean
+    fun getLicenseRequestExecutor(): JSRequestExecutor?
+}
@@ -15,6 +15,7 @@ class LocalAudioSource : IAudioSource, IStreamMetaDataSource {
    override val duration: Long? = null;

    override var priority: Boolean = false;
+    override val original: Boolean = false;

    val filePath : String;
    val fileSize: Long;
@@ -33,13 +34,13 @@ class LocalAudioSource : IAudioSource, IStreamMetaDataSource {
    }

    companion object {
-        fun fromSource(source: IAudioSource, path: String, fileSize: Long): LocalAudioSource {
+        fun fromSource(source: IAudioSource, path: String, fileSize: Long, overrideContainer: String? = null): LocalAudioSource {
            return LocalAudioSource(
                source.name,
                path,
                fileSize,
                source.bitrate,
-                source.container,
+                overrideContainer ?: source.container,
                source.codec,
                source.language
            );
@@ -35,7 +35,7 @@ class LocalVideoSource : IVideoSource, IStreamMetaDataSource {
    }

    companion object {
-        fun fromSource(source: IVideoSource, path: String, fileSize: Long): LocalVideoSource {
+        fun fromSource(source: IVideoSource, path: String, fileSize: Long, overrideContainer: String? = null): LocalVideoSource {
            return LocalVideoSource(
                source.name,
                path,
@@ -43,7 +43,7 @@ class LocalVideoSource : IVideoSource, IStreamMetaDataSource {
                source.width,
                source.height,
                source.duration,
-                source.container,
+                overrideContainer ?: source.container,
                source.codec,
                source.bitrate?:0
            );
@@ -13,4 +13,6 @@ interface IPlatformVideo : IPlatformContent {
    val viewCount: Long;

    val isLive : Boolean;
+
+    val isShort: Boolean;
 }
@@ -10,23 +10,26 @@ 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 = "",

    override val duration: Long,
    override val viewCount: Long,
+    override val isShort: Boolean = false
 ) : IPlatformVideo, SerializedPlatformContent {
-    override val contentType: ContentType = ContentType.MEDIA;

    override val isLive: Boolean = false;

@@ -43,6 +46,7 @@ open class SerializedPlatformVideo(
    companion object {
        fun fromVideo(video: IPlatformVideo) : SerializedPlatformVideo {
            return SerializedPlatformVideo(
+                ContentType.MEDIA,
                video.id,
                video.name,
                video.thumbnails,
@@ -38,7 +38,8 @@ open class SerializedPlatformVideoDetails(
    override val video: ISerializedVideoSourceDescriptor,
    override val preview: ISerializedVideoSourceDescriptor?,

-    override val subtitles: List<SubtitleRawSource> = listOf()
+    override val subtitles: List<SubtitleRawSource> = listOf(),
+    override val isShort: Boolean = false
 ) : IPlatformVideo, IPlatformVideoDetails {
    final override val contentType: ContentType get() = ContentType.MEDIA;

@@ -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() {
@@ -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)")
@@ -33,6 +33,7 @@ class SourcePluginConfig(
    override val allowEval: Boolean = false,
    override val allowUrls: List<String> = listOf(),
    override val packages: List<String> = listOf(),
+    override val packagesOptional: List<String> = listOf(),

    val settings: List<Setting> = listOf(),

@@ -50,7 +51,9 @@ class SourcePluginConfig(
    var primaryClaimFieldType: Int? = null,
    var developerSubmitUrl: String? = null,
    var allowAllHttpHeaderAccess: Boolean = false,
-    var maxDownloadParallelism: Int = 0
+    var maxDownloadParallelism: Int = 0,
+    var reduceFunctionsInLimitedVersion: Boolean = false,
+    var changelog: HashMap<String, List<String>>? = null
 ) : IV8PluginConfig {

    val absoluteIconUrl: String? get() = resolveAbsoluteUrl(iconUrl, sourceUrl);
@@ -100,6 +103,10 @@ class SourcePluginConfig(
            if(!packages.contains(pack))
                return false;
        }
+        for(pack in newConfig.packagesOptional) {
+            if(!packagesOptional.contains(pack))
+                return false;
+        }
        //Developer Submit Url should be same or empty
        if(!newConfig.developerSubmitUrl.isNullOrEmpty() && developerSubmitUrl != newConfig.developerSubmitUrl)
            return false;
@@ -128,7 +135,7 @@ class SourcePluginConfig(

        val currentlyInstalledPlugin = StatePlugins.instance.getPlugin(id);
        if (currentlyInstalledPlugin != null) {
-            if (currentlyInstalledPlugin.config.scriptPublicKey != scriptPublicKey) {
+            if (currentlyInstalledPlugin.config.scriptPublicKey != scriptPublicKey && !currentlyInstalledPlugin.config.scriptPublicKey.isNullOrEmpty()) {
                list.add(Pair(
                    "Different Author",
                    "This plugin was signed by a different author. Please ensure that this is correct and that the plugin was not provided by a malicious actor."));
@@ -177,6 +184,19 @@ class SourcePluginConfig(
        return _allowUrlsLower.any { it == host || (it.length > 0 && it[0] == '.' && host.matchesDomain(it)) };
    }

+    fun getChangelogString(version: String): String?{
+        if(changelog == null || !changelog!!.containsKey(version))
+            return null;
+        val changelog = changelog!![version]!!;
+        if(changelog.size > 1) {
+            return "Changelog (${version})\n" + changelog.map { " - " + it.trim() }.joinToString("\n");
+        }
+        else if(changelog.size == 1) {
+            return "Changelog (${version})\n" + changelog[0].trim();
+        }
+        return null;
+    }
+
    companion object {
        fun fromJson(json: String, sourceUrl: String? = null): SourcePluginConfig {
            val obj = Serializer.json.decodeFromString<SourcePluginConfig>(json);
@@ -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("; ");
@@ -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}");
            }
        }
@@ -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}");
            }
        }
@@ -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));
+
+    }
+}
@@ -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);
@@ -99,6 +101,7 @@ open class JSArticleDetails : JSContent, IPluginSourced, IPlatformContentDetails
            return when(SegmentType.fromInt(obj.getOrThrow(client.config, "type", "JSArticle.Segment"))) {
                SegmentType.TEXT -> JSTextSegment(client, obj);
                SegmentType.IMAGES -> JSImagesSegment(client, obj);
+                SegmentType.HEADER -> JSHeaderSegment(client, obj);
                SegmentType.NESTED -> JSNestedSegment(client, obj);
                else -> null;
            }
@@ -110,6 +113,7 @@ enum class SegmentType(val value: Int) {
    UNKNOWN(0),
    TEXT(1),
    IMAGES(2),
+    HEADER(3),

    NESTED(9);

@@ -150,6 +154,17 @@ class JSImagesSegment: IJSArticleSegment {
        caption = obj.getOrDefault(client.config, "caption", contextName, "") ?: "";
    }
 }
+class JSHeaderSegment: IJSArticleSegment {
+    override val type = SegmentType.HEADER;
+    val content: String;
+    val level: Int;
+
+    constructor(client: JSClient, obj: V8ValueObject) {
+        val contextName = "JSHeaderSegment";
+        content = obj.getOrDefault(client.config, "content", contextName, "") ?: "";
+        level = obj.getOrDefault(client.config, "level", contextName, 1) ?: 1;
+    }
+}
 class JSNestedSegment: IJSArticleSegment {
    override val type = SegmentType.NESTED;
    val nested: IPlatformContent;
@@ -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> {

@@ -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);
@@ -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);
+    }
 }
@@ -71,6 +71,8 @@ abstract class JSPager<T> : IPager<T> {

        warnIfMainThread("JSPager.getResults");
        val items = pager.getOrThrow<V8ValueArray>(config, "results", "JSPager");
+        if(items.v8Runtime.isDead || items.v8Runtime.isClosed)
+            throw IllegalStateException("Runtime closed");
        val newResults = items.toArray()
            .map { convertResult(it as V8ValueObject) }
            .toList();
@@ -10,6 +10,7 @@ import com.futo.platformplayer.api.media.structures.IPager
 import com.futo.platformplayer.api.media.structures.ReusablePager
 import com.futo.platformplayer.getOrThrow
 import com.futo.platformplayer.models.Playlist
+import java.util.UUID

 class JSPlaylistDetails: JSPlaylist, IPlatformPlaylistDetails {
    override val contents: IPager<IPlatformVideo>;
@@ -37,6 +38,6 @@ class JSPlaylistDetails: JSPlaylist, IPlatformPlaylistDetails {
            onProgress?.invoke(videos.size);
        }

-        return Playlist(id.toString(), name, videos.map { SerializedPlatformVideo.fromVideo(it)});
+        return Playlist(UUID.randomUUID().toString(), name, videos.map { SerializedPlatformVideo.fromVideo(it)});
    }
 }
@@ -42,7 +42,7 @@ class JSRequestExecutor {

    //TODO: Executor properties?
    @Throws(ScriptException::class)
-    open fun executeRequest(url: String, headers: Map<String, String>): ByteArray {
+    open fun executeRequest(method: String, url: String, body: ByteArray?, headers: Map<String, String>): ByteArray {
        if (_executor.isClosed)
            throw IllegalStateException("Executor object is closed");

@@ -53,7 +53,7 @@ class JSRequestExecutor {
                    "[${_config.name}] JSRequestExecutor",
                    "builder.modifyRequest()"
                ) {
-                    _executor.invoke("executeRequest", url, headers);
+                    _executor.invoke("executeRequest", url, headers, method, body);
                } as V8Value;
            }
            else V8Plugin.catchScriptErrors<Any>(
@@ -61,7 +61,7 @@ class JSRequestExecutor {
                "[${_config.name}] JSRequestExecutor",
                "builder.modifyRequest()"
            ) {
-                _executor.invoke("executeRequest", url, headers);
+                _executor.invoke("executeRequest", url, headers, method, body);
            } as V8Value;

        try {
@@ -6,6 +6,7 @@ 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.IPlatformVideo
 import com.futo.platformplayer.api.media.platforms.js.SourcePluginConfig
+import com.futo.platformplayer.getOrDefault
 import com.futo.platformplayer.getOrThrow

 open class JSVideo : JSContent, IPlatformVideo, IPluginSourced {
@@ -17,6 +18,7 @@ open class JSVideo : JSContent, IPlatformVideo, IPluginSourced {
    final override val viewCount: Long;

    final override val isLive: Boolean;
+    final override val isShort: Boolean;

    constructor(config: SourcePluginConfig, obj: V8ValueObject): super(config, obj) {
        val contextName = "PlatformVideo";
@@ -26,5 +28,6 @@ open class JSVideo : JSContent, IPlatformVideo, IPluginSourced {
        duration = _content.getOrThrow<Int>(config, "duration", contextName).toLong();
        viewCount = _content.getOrThrow(config, "viewCount", contextName);
        isLive = _content.getOrThrow(config, "isLive", contextName);
+        isShort = _content.getOrDefault(config, "isShort", contextName, false) ?: false;
    }
 }
@@ -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";
+    }
+}
@@ -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;
+
+}
@@ -21,6 +21,8 @@ open class JSAudioUrlSource : IAudioUrlSource, JSSource {

    override var priority: Boolean = false;

+    override var original: Boolean = false;
+
    constructor(plugin: JSClient, obj: V8ValueObject) : super(TYPE_AUDIOURL, plugin, obj) {
        val contextName = "AudioUrlSource";
        val config = plugin.config;
@@ -35,6 +37,7 @@ open class JSAudioUrlSource : IAudioUrlSource, JSSource {
        name = _obj.getOrDefault(config, "name", contextName, "${container} ${bitrate}") ?: "${container} ${bitrate}";

        priority = if(_obj.has("priority")) obj.getOrThrow(config, "priority", contextName) else false;
+        original =  if(_obj.has("original")) obj.getOrThrow(config, "original", contextName) else false;
    }

    override fun getAudioUrl() : String {
@@ -3,22 +3,39 @@ package com.futo.platformplayer.api.media.platforms.js.models.sources
 import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.models.streams.sources.IAudioUrlWidevineSource
 import com.futo.platformplayer.api.media.platforms.js.JSClient
+import com.futo.platformplayer.api.media.platforms.js.models.JSRequestExecutor
+import com.futo.platformplayer.engine.V8Plugin
 import com.futo.platformplayer.getOrThrow

 class JSAudioUrlWidevineSource : JSAudioUrlSource, IAudioUrlWidevineSource {
-    override val bearerToken: String
    override val licenseUri: String
+    override val hasLicenseRequestExecutor: Boolean

    @Suppress("ConvertSecondaryConstructorToPrimary")
    constructor(plugin: JSClient, obj: V8ValueObject) : super(plugin, obj) {
        val contextName = "JSAudioUrlWidevineSource"
        val config = plugin.config
-        bearerToken = _obj.getOrThrow(config, "bearerToken", contextName)
+
        licenseUri = _obj.getOrThrow(config, "licenseUri", contextName)
+        hasLicenseRequestExecutor = obj.has("getLicenseRequestExecutor")
+    }
+
+    override fun getLicenseRequestExecutor(): JSRequestExecutor? {
+        if (!hasLicenseRequestExecutor || _obj.isClosed)
+            return null
+
+        val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSAudioUrlWidevineSource", "obj.getLicenseRequestExecutor()") {
+            _obj.invoke("getLicenseRequestExecutor", arrayOf<Any>())
+        }
+
+        if (result !is V8ValueObject)
+            return null
+
+        return JSRequestExecutor(_plugin, result)
    }

    override fun toString(): String {
        val url = getAudioUrl()
-        return "(name=$name, container=$container, bitrate=$bitrate, codec=$codec, url=$url, language=$language, duration=$duration, bearerToken=$bearerToken, licenseUri=$licenseUri)"
+        return "(name=$name, container=$container, bitrate=$bitrate, codec=$codec, url=$url, language=$language, duration=$duration, hasLicenseRequestExecutor=${hasLicenseRequestExecutor}, licenseUri=$licenseUri)"
    }
 }
@@ -4,6 +4,8 @@ import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.models.streams.sources.IAudioSource
 import com.futo.platformplayer.api.media.models.streams.sources.IDashManifestSource
 import com.futo.platformplayer.api.media.models.streams.sources.IVideoUrlSource
+import com.futo.platformplayer.api.media.models.streams.sources.other.IStreamMetaDataSource
+import com.futo.platformplayer.api.media.models.streams.sources.other.StreamMetaData
 import com.futo.platformplayer.api.media.platforms.js.DevJSClient
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.engine.IV8PluginConfig
@@ -14,13 +16,14 @@ import com.futo.platformplayer.getOrThrow
 import com.futo.platformplayer.others.Language
 import com.futo.platformplayer.states.StateDeveloper

-class JSDashManifestRawAudioSource : JSSource, IAudioSource, IJSDashManifestRawSource {
-    override val container : String = "application/dash+xml";
+class JSDashManifestRawAudioSource : JSSource, IAudioSource, IJSDashManifestRawSource, IStreamMetaDataSource {
+    override val container : String;
    override val name : String;
    override val codec: String;
    override val bitrate: Int;
    override val duration: Long;
    override val priority: Boolean;
+    override var original: Boolean = false;

    override val language: String;

@@ -29,17 +32,21 @@ class JSDashManifestRawAudioSource : JSSource, IAudioSource, IJSDashManifestRawS

    override val hasGenerate: Boolean;

+    override var streamMetaData: StreamMetaData? = null;
+
    constructor(plugin: JSClient, obj: V8ValueObject) : super(TYPE_DASH_RAW, plugin, obj) {
        val contextName = "DashRawSource";
        val config = plugin.config;
        name = _obj.getOrThrow(config, "name", contextName);
        url = _obj.getOrThrow(config, "url", contextName);
+        container = _obj.getOrDefault<String>(config, "container", contextName, null) ?: "application/dash+xml";
        manifest = _obj.getOrThrow(config, "manifest", contextName);
        codec = _obj.getOrDefault(config, "codec", contextName, "") ?: "";
        bitrate = _obj.getOrDefault(config, "bitrate", contextName, 0) ?: 0;
        duration = _obj.getOrDefault(config, "duration", contextName, 0) ?: 0;
        priority = _obj.getOrDefault(config, "priority", contextName, false) ?: false;
        language = _obj.getOrDefault(config, "language", contextName, Language.UNKNOWN) ?: Language.UNKNOWN;
+        original =  if(_obj.has("original")) obj.getOrThrow(config, "original", contextName) else false;
        hasGenerate = _obj.has("generate");
    }

@@ -50,15 +57,28 @@ class JSDashManifestRawAudioSource : JSSource, IAudioSource, IJSDashManifestRawS
            throw IllegalStateException("Source object already closed");

        val plugin = _plugin.getUnderlyingPlugin();
+
+        var result: String? = null;
        if(_plugin is DevJSClient)
-            return StateDeveloper.instance.handleDevCall(_plugin.devID, "DashManifestRaw", false) {
+            result = StateDeveloper.instance.handleDevCall(_plugin.devID, "DashManifestRaw", false) {
                _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw", "dashManifestRaw.generate()") {
                    _obj.invokeString("generate");
                }
            }
        else
-            return _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw", "dashManifestRaw.generate()") {
+            result = _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw", "dashManifestRaw.generate()") {
                _obj.invokeString("generate");
            }
+
+        if(result != null){
+            val initStart = _obj.getOrDefault<Int>(_config, "initStart", "JSDashManifestRawSource", null) ?: 0;
+            val initEnd = _obj.getOrDefault<Int>(_config, "initEnd", "JSDashManifestRawSource", null) ?: 0;
+            val indexStart = _obj.getOrDefault<Int>(_config, "indexStart", "JSDashManifestRawSource", null) ?: 0;
+            val indexEnd = _obj.getOrDefault<Int>(_config, "indexEnd", "JSDashManifestRawSource", null) ?: 0;
+            if(initEnd > 0 && indexStart > 0 && indexEnd > 0) {
+                streamMetaData = StreamMetaData(initStart, initEnd, indexStart, indexEnd);
+            }
+        }
+        return result;
    }
 }
@@ -6,6 +6,8 @@ import com.caoccao.javet.values.reference.V8ValueObject
 import com.futo.platformplayer.api.media.models.streams.sources.IDashManifestSource
 import com.futo.platformplayer.api.media.models.streams.sources.IVideoSource
 import com.futo.platformplayer.api.media.models.streams.sources.IVideoUrlSource
+import com.futo.platformplayer.api.media.models.streams.sources.other.IStreamMetaDataSource
+import com.futo.platformplayer.api.media.models.streams.sources.other.StreamMetaData
 import com.futo.platformplayer.api.media.platforms.js.DevJSClient
 import com.futo.platformplayer.api.media.platforms.js.JSClient
 import com.futo.platformplayer.engine.IV8PluginConfig
@@ -20,8 +22,8 @@ interface IJSDashManifestRawSource {
    var manifest: String?;
    fun generate(): String?;
 }
-open class JSDashManifestRawSource: JSSource, IVideoSource, IJSDashManifestRawSource {
-    override val container : String = "application/dash+xml";
+open class JSDashManifestRawSource: JSSource, IVideoSource, IJSDashManifestRawSource, IStreamMetaDataSource {
+    override val container : String;
    override val name : String;
    override val width: Int;
    override val height: Int;
@@ -36,11 +38,14 @@ open class JSDashManifestRawSource: JSSource, IVideoSource, IJSDashManifestRawSo
    override val hasGenerate: Boolean;
    val canMerge: Boolean;

+    override var streamMetaData: StreamMetaData? = null;
+
    constructor(plugin: JSClient, obj: V8ValueObject) : super(TYPE_DASH_RAW, plugin, obj) {
        val contextName = "DashRawSource";
        val config = plugin.config;
        name = _obj.getOrThrow(config, "name", contextName);
        url = _obj.getOrThrow(config, "url", contextName);
+        container = _obj.getOrDefault<String>(config, "container", contextName, null) ?: "application/dash+xml";
        manifest = _obj.getOrDefault<String>(config, "manifest", contextName, null);
        width = _obj.getOrDefault(config, "width", contextName, 0) ?: 0;
        height = _obj.getOrDefault(config, "height", contextName, 0) ?: 0;
@@ -57,17 +62,30 @@ open class JSDashManifestRawSource: JSSource, IVideoSource, IJSDashManifestRawSo
            return manifest;
        if(_obj.isClosed)
            throw IllegalStateException("Source object already closed");
+
+        var result: String? = null;
        if(_plugin is DevJSClient) {
-            return StateDeveloper.instance.handleDevCall(_plugin.devID, "DashManifestRawSource.generate()") {
+            result = StateDeveloper.instance.handleDevCall(_plugin.devID, "DashManifestRawSource.generate()") {
                _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw.generate", "generate()", {
                    _obj.invokeString("generate");
                });
            }
        }
        else
-            return _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw.generate", "generate()", {
+            result = _plugin.getUnderlyingPlugin().catchScriptErrors("DashManifestRaw.generate", "generate()", {
                _obj.invokeString("generate");
            });
+
+        if(result != null){
+            val initStart = _obj.getOrDefault<Int>(_config, "initStart", "JSDashManifestRawSource", null) ?: 0;
+            val initEnd = _obj.getOrDefault<Int>(_config, "initEnd", "JSDashManifestRawSource", null) ?: 0;
+            val indexStart = _obj.getOrDefault<Int>(_config, "indexStart", "JSDashManifestRawSource", null) ?: 0;
+            val indexEnd = _obj.getOrDefault<Int>(_config, "indexEnd", "JSDashManifestRawSource", null) ?: 0;
+            if(initEnd > 0 && indexStart > 0 && indexEnd > 0) {
+                streamMetaData = StreamMetaData(initStart, initEnd, indexStart, indexEnd);
+            }
+        }
+        return result;
    }
 }

@@ -100,12 +118,16 @@ class JSDashManifestMergingRawSource(
        if(videoDash == null) return null;

        //TODO: Temporary simple solution..make more reliable version
+
+        var result: String? = null;
        val audioAdaptationSet = adaptationSetRegex.find(audioDash!!);
        if(audioAdaptationSet != null) {
-            return videoDash.replace("</AdaptationSet>", "</AdaptationSet>\n" + audioAdaptationSet.value)
+            result = videoDash.replace("</AdaptationSet>", "</AdaptationSet>\n" + audioAdaptationSet.value)
        }
        else
-            return videoDash;
+            result = videoDash;
+
+        return result;
    }

    companion object {
@@ -0,0 +1,60 @@
+package com.futo.platformplayer.api.media.platforms.js.models.sources
+
+import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.models.streams.sources.IDashManifestSource
+import com.futo.platformplayer.api.media.models.streams.sources.IDashManifestWidevineSource
+import com.futo.platformplayer.api.media.models.streams.sources.IVideoUrlSource
+import com.futo.platformplayer.api.media.platforms.js.JSClient
+import com.futo.platformplayer.api.media.platforms.js.models.JSRequestExecutor
+import com.futo.platformplayer.engine.V8Plugin
+import com.futo.platformplayer.getOrNull
+import com.futo.platformplayer.getOrThrow
+
+class JSDashManifestWidevineSource : IVideoUrlSource, IDashManifestSource,
+    IDashManifestWidevineSource, JSSource {
+    override val width: Int = 0
+    override val height: Int = 0
+    override val container: String = "application/dash+xml"
+    override val codec: String = "Dash"
+    override val name: String
+    override val bitrate: Int? = null
+    override val url: String
+    override val duration: Long
+
+    override var priority: Boolean = false
+
+    override val licenseUri: String
+    override val hasLicenseRequestExecutor: Boolean
+
+    @Suppress("ConvertSecondaryConstructorToPrimary")
+    constructor(plugin: JSClient, obj: V8ValueObject) : super(TYPE_DASH, plugin, obj) {
+        val contextName = "DashWidevineSource"
+        val config = plugin.config
+        name = _obj.getOrThrow(config, "name", contextName)
+        url = _obj.getOrThrow(config, "url", contextName)
+        duration = _obj.getOrThrow(config, "duration", contextName)
+
+        priority = obj.getOrNull(config, "priority", contextName) ?: false
+
+        licenseUri = _obj.getOrThrow(config, "licenseUri", contextName)
+        hasLicenseRequestExecutor = obj.has("getLicenseRequestExecutor")
+    }
+
+    override fun getLicenseRequestExecutor(): JSRequestExecutor? {
+        if (!hasLicenseRequestExecutor || _obj.isClosed)
+            return null
+
+        val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSDashManifestWidevineSource", "obj.getLicenseRequestExecutor()") {
+            _obj.invoke("getLicenseRequestExecutor", arrayOf<Any>())
+        }
+
+        if (result !is V8ValueObject)
+            return null
+
+        return JSRequestExecutor(_plugin, result)
+    }
+
+    override fun getVideoUrl(): String {
+        return url
+    }
+}
@@ -21,6 +21,7 @@ class JSHLSManifestAudioSource : IHLSManifestAudioSource, JSSource {
    override val language: String;

    override var priority: Boolean = false;
+    override var original: Boolean = false;

    constructor(plugin: JSClient, obj: V8ValueObject) : super(TYPE_HLS, plugin, obj) {
        val contextName = "HLSAudioSource";
@@ -32,6 +33,7 @@ class JSHLSManifestAudioSource : IHLSManifestAudioSource, JSSource {
        language = _obj.getOrThrow(config, "language", contextName);

        priority = obj.getOrNull(config, "priority", contextName) ?: false;
+        original =  if(_obj.has("original")) obj.getOrThrow(config, "original", contextName) else false;
    }


@@ -98,18 +98,22 @@ abstract class JSSource {
        const val TYPE_AUDIO_WITH_METADATA = "AudioUrlRangeSource";
        const val TYPE_VIDEO_WITH_METADATA = "VideoUrlRangeSource";
        const val TYPE_DASH = "DashSource";
+        const val TYPE_DASH_WIDEVINE = "DashWidevineSource";
        const val TYPE_DASH_RAW = "DashRawSource";
        const val TYPE_DASH_RAW_AUDIO = "DashRawAudioSource";
        const val TYPE_HLS = "HLSSource";
        const val TYPE_AUDIOURL_WIDEVINE = "AudioUrlWidevineSource"
+        const val TYPE_VIDEOURL_WIDEVINE = "VideoUrlWidevineSource"

        fun fromV8VideoNullable(plugin: JSClient, obj: V8Value?) : IVideoSource? = obj.orNull { fromV8Video(plugin, it as V8ValueObject) };
        fun fromV8Video(plugin: JSClient, obj: V8ValueObject) : IVideoSource? {
            val type = obj.getString("plugin_type");
            return when(type) {
                TYPE_VIDEOURL -> JSVideoUrlSource(plugin, obj);
+                TYPE_VIDEOURL_WIDEVINE -> JSVideoUrlWidevineSource(plugin, obj);
                TYPE_VIDEO_WITH_METADATA -> JSVideoUrlRangeSource(plugin, obj);
                TYPE_HLS -> fromV8HLS(plugin, obj);
+                TYPE_DASH_WIDEVINE -> JSDashManifestWidevineSource(plugin, obj)
                TYPE_DASH -> fromV8Dash(plugin, obj);
                TYPE_DASH_RAW -> fromV8DashRaw(plugin, obj);
                else -> {
@@ -0,0 +1,41 @@
+package com.futo.platformplayer.api.media.platforms.js.models.sources
+
+import com.caoccao.javet.values.reference.V8ValueObject
+import com.futo.platformplayer.api.media.models.streams.sources.IVideoUrlWidevineSource
+import com.futo.platformplayer.api.media.platforms.js.JSClient
+import com.futo.platformplayer.api.media.platforms.js.models.JSRequestExecutor
+import com.futo.platformplayer.engine.V8Plugin
+import com.futo.platformplayer.getOrThrow
+
+class JSVideoUrlWidevineSource : JSVideoUrlSource, IVideoUrlWidevineSource {
+    override val licenseUri: String
+    override val hasLicenseRequestExecutor: Boolean
+
+    @Suppress("ConvertSecondaryConstructorToPrimary")
+    constructor(plugin: JSClient, obj: V8ValueObject) : super(plugin, obj) {
+        val contextName = "JSAudioUrlWidevineSource"
+        val config = plugin.config
+
+        licenseUri = _obj.getOrThrow(config, "licenseUri", contextName)
+        hasLicenseRequestExecutor = obj.has("getLicenseRequestExecutor")
+    }
+
+    override fun getLicenseRequestExecutor(): JSRequestExecutor? {
+        if (!hasLicenseRequestExecutor || _obj.isClosed)
+            return null
+
+        val result = V8Plugin.catchScriptErrors<Any>(_config, "[${_config.name}] JSAudioUrlWidevineSource", "obj.getLicenseRequestExecutor()") {
+            _obj.invoke("getLicenseRequestExecutor", arrayOf<Any>())
+        }
+
+        if (result !is V8ValueObject)
+            return null
+
+        return JSRequestExecutor(_plugin, result)
+    }
+
+    override fun toString(): String {
+        val url = getVideoUrl()
+        return "(width=$width, height=$height, container=$container, codec=$codec, name=$name, bitrate=$bitrate, duration=$duration, url=$url, hasLicenseRequestExecutor=$hasLicenseRequestExecutor, licenseUri=$licenseUri)"
+    }
+}
@@ -0,0 +1,5 @@
+package com.futo.platformplayer.api.media.platforms.local
+
+class LocalClient {
+    //TODO
+}
@@ -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;
+    }
+}
@@ -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);
+}
@@ -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;
+        }
+    }
+}
@@ -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;
+    }
+
+}
@@ -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>;

@@ -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>;
 }
@@ -88,7 +88,8 @@ class DashBuilder : XMLBuilder {
    fun withRepresentationOnDemand(id: String, subtitleSource: ISubtitleSource, subtitleUrl: String) {
        withRepresentation(id, mapOf(
            Pair("mimeType", subtitleSource.format ?: "text/vtt"),
-            Pair("startWithSAP", "1"),
+            Pair("default", "true"),
+            Pair("lang", "en"),
            Pair("bandwidth", "1000")
        )) {
            it.withBaseURL(subtitleUrl)
@@ -151,7 +152,7 @@ class DashBuilder : XMLBuilder {
                    )
                ) {
                    //TODO: Verify if & really should be replaced like this?
-                    it.withRepresentationOnDemand("1", subtitleSource, subtitleUrl.replace("&", "&amp;"))
+                    it.withRepresentationOnDemand("caption_en", subtitleSource, subtitleUrl.replace("&", "&amp;"))
                }
            }
            //Video
@@ -164,7 +165,7 @@ class DashBuilder : XMLBuilder {
                        Pair("subsegmentStartsWithSAP", "1")
                    )
                ) {
-                    it.withRepresentationOnDemand("1", vidSource, vidUrl.replace("&", "&amp;"));
+                    it.withRepresentationOnDemand("2", vidSource, vidUrl.replace("&", "&amp;"));
                }
            }

@@ -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);
                    }
                }

@@ -108,7 +108,7 @@ abstract class CastingDevice {

    val expectedCurrentTime: Double
        get() {
-            val diff = (System.currentTimeMillis() - lastTimeChangeTime_ms).toDouble() / 1000.0;
+            val diff = if (isPlaying) ((System.currentTimeMillis() - lastTimeChangeTime_ms).toDouble() / 1000.0) else 0.0;
            return time + diff;
        };
    var connectionState: CastConnectionState = CastConnectionState.DISCONNECTED
@@ -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);
                    }
                }

@@ -334,6 +344,10 @@ class ChromecastCastingDevice : CastingDevice {

                //Connection loop
                while (_scopeIO?.isActive == true) {
+                    _sessionId = null;
+                    _launchRetries = 0
+                    _mediaSessionId = null;
+
                    Logger.i(TAG, "Connecting to Chromecast.");
                    connectionState = CastConnectionState.CONNECTING;

@@ -392,7 +406,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 +418,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 +427,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) {
@@ -485,6 +503,10 @@ class ChromecastCastingDevice : CastingDevice {
            }
        } catch (e: Throwable) {
            Logger.w(TAG, "Failed to send channel message (sourceId: $sourceId, destinationId: $destinationId, namespace: $namespace, json: $json)", e);
+            _socket?.close();
+            Logger.i(TAG, "Socket disconnected.");
+
+            connectionState = CastConnectionState.CONNECTING;
        }
    }

@@ -511,6 +533,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 +548,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");
@@ -566,7 +608,7 @@ class ChromecastCastingDevice : CastingDevice {
                    }

                    isPlaying = playerState == "PLAYING";
-                    if (isPlaying) {
+                    if (isPlaying ||  playerState == "PAUSED") {
                        setTime(currentTime);
                    }

@@ -581,6 +623,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 +659,9 @@ class ChromecastCastingDevice : CastingDevice {
        localAddress = null;
        _started = false;

+        _retryJob?.cancel()
+        _retryJob = null
+
        val socket = _socket;
        val scopeIO = _scopeIO;

@@ -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")
@@ -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 {
@@ -64,11 +70,10 @@ class StateCasting {
    private val _scopeMain = CoroutineScope(Dispatchers.Main);
    private val _storage: CastingDeviceInfoStorage = FragmentedStorage.get();

-    private val _castServer = ManagedHttpServer(9999);
+    private val _castServer = ManagedHttpServer();
    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,34 @@ 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
+        startDiscovering()
    }

    @Synchronized
-    fun startDiscovering() {
-        try {
-            _serviceDiscoverer.start()
-        } catch (e: Throwable) {
-            Logger.i(TAG, "Failed to start ServiceDiscoverer", e)
+    private fun startDiscovering() {
+        _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)
+    private fun stopDiscovering() {
+        _nsdManager?.apply {
+            _discoveryListeners.forEach {
+                try {
+                    stopServiceDiscovery(it.value)
+                } catch (e: Throwable) {
+                    Logger.w(TAG, "Failed to stop service discovery", e)
+                }
+            }
        }
    }

@@ -237,8 +213,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 +330,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 +384,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 +405,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 +489,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 +584,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 +603,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 +622,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 +718,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 +768,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 +833,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 +1003,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 +1133,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 +1219,22 @@ class StateCasting {
        }
    }

+    private fun getLocalUrl(ad: CastingDevice): String {
+        var address = ad.localAddress!!
+        if (Settings.instance.casting.allowLinkLocalIpv4) {
+            if (address.isLinkLocalAddress && address is Inet6Address) {
+                address = findPreferredAddress() ?: address
+                Logger.i(TAG, "Selected casting address: $address")
+            }
+        } else {
+            if (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 +1242,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}"
@@ -1245,7 +1348,7 @@ class StateCasting {

                    val videoExecutor = _videoExecutor;
                    if (videoExecutor != null) {
-                        val data = videoExecutor.executeRequest(originalUrl, httpContext.headers)
+                        val data = videoExecutor.executeRequest("GET", originalUrl, null, httpContext.headers)
                        httpContext.respondBytes(200, HttpHeaders().apply {
                            put("Content-Type", mediaType)
                        }, data);
@@ -1263,7 +1366,7 @@ class StateCasting {

                    val audioExecutor = _audioExecutor;
                    if (audioExecutor != null) {
-                        val data = audioExecutor.executeRequest(originalUrl, httpContext.headers)
+                        val data = audioExecutor.executeRequest("GET", originalUrl, null, httpContext.headers)
                        httpContext.respondBytes(200, HttpHeaders().apply {
                            put("Content-Type", mediaType)
                        }, data);
--- a/Show More
+++ b/Show More