mirror of
https://gitlab.futo.org/videostreaming/grayjay.git
synced 2025-04-21 03:54:46 +00:00
Compare commits
No commits in common. "master" and "288" have entirely different histories.
62 changed files with 865 additions and 3222 deletions
|
|
@ -1,266 +0,0 @@
|
|||
package com.futo.platformplayer
|
||||
|
||||
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.net.Socket
|
||||
import java.nio.ByteBuffer
|
||||
import kotlin.random.Random
|
||||
import kotlin.time.Duration.Companion.milliseconds
|
||||
|
||||
class SyncServerTests {
|
||||
|
||||
//private val relayHost = "relay.grayjay.app"
|
||||
//private val relayKey = "xGbHRzDOvE6plRbQaFgSen82eijF+gxS0yeUaeEErkw="
|
||||
private val relayKey = "XlUaSpIlRaCg0TGzZ7JYmPupgUHDqTZXUUBco2K7ejw="
|
||||
private val relayHost = "192.168.1.175"
|
||||
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: ((SyncSocketSession, String, String?) -> Boolean)? = 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()
|
||||
socketSession.startAsInitiator(relayKey)
|
||||
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()
|
||||
}
|
||||
}
|
||||
|
||||
class AlwaysAuthorized : IAuthorizable {
|
||||
override val isAuthorized: Boolean get() = true
|
||||
}
|
||||
|
|
@ -216,14 +216,9 @@ private fun ByteArray.toInetAddress(): InetAddress {
|
|||
return InetAddress.getByAddress(this);
|
||||
}
|
||||
|
||||
fun getConnectedSocket(attemptAddresses: List<InetAddress>, port: Int): Socket? {
|
||||
fun getConnectedSocket(addresses: List<InetAddress>, port: Int): Socket? {
|
||||
val timeout = 2000
|
||||
|
||||
|
||||
val addresses = if(!Settings.instance.casting.allowIpv6) attemptAddresses.filterIsInstance<Inet4Address>() else attemptAddresses;
|
||||
if(addresses.isEmpty())
|
||||
throw IllegalStateException("No valid addresses found (ipv6: ${(if(Settings.instance.casting.allowIpv6) "enabled" else "disabled")})");
|
||||
|
||||
if (addresses.isEmpty()) {
|
||||
return null;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -205,7 +205,7 @@ class Settings : FragmentedStorageFileJson() {
|
|||
var home = HomeSettings();
|
||||
@Serializable
|
||||
class HomeSettings {
|
||||
@FormField(R.string.feed_style, FieldForm.DROPDOWN, R.string.may_require_restart, 3)
|
||||
@FormField(R.string.feed_style, FieldForm.DROPDOWN, R.string.may_require_restart, 5)
|
||||
@DropdownFieldOptionsId(R.array.feed_style)
|
||||
var homeFeedStyle: Int = 1;
|
||||
|
||||
|
|
@ -216,11 +216,6 @@ class Settings : FragmentedStorageFileJson() {
|
|||
return FeedStyle.THUMBNAIL;
|
||||
}
|
||||
|
||||
@FormField(R.string.show_home_filters, FieldForm.TOGGLE, R.string.show_home_filters_description, 4)
|
||||
var showHomeFilters: Boolean = true;
|
||||
@FormField(R.string.show_home_filters_plugin_names, FieldForm.TOGGLE, R.string.show_home_filters_plugin_names_description, 5)
|
||||
var showHomeFiltersPluginNames: Boolean = false;
|
||||
|
||||
@FormField(R.string.preview_feed_items, FieldForm.TOGGLE, R.string.preview_feed_items_description, 6)
|
||||
var previewFeedItems: Boolean = true;
|
||||
|
||||
|
|
@ -583,15 +578,10 @@ 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, 3)
|
||||
@FormField(R.string.always_proxy_requests, FieldForm.TOGGLE, R.string.always_proxy_requests_description, 1)
|
||||
@Serializable(with = FlexibleBooleanSerializer::class)
|
||||
var alwaysProxyRequests: Boolean = false;
|
||||
|
||||
|
||||
@FormField(R.string.allow_ipv6, FieldForm.TOGGLE, R.string.allow_ipv6_description, 4)
|
||||
@Serializable(with = FlexibleBooleanSerializer::class)
|
||||
var allowIpv6: Boolean = false;
|
||||
|
||||
/*TODO: Should we have a different casting quality?
|
||||
@FormField("Preferred Casting Quality", FieldForm.DROPDOWN, "", 3)
|
||||
@DropdownFieldOptionsId(R.array.preferred_quality_array)
|
||||
|
|
@ -936,15 +926,6 @@ class Settings : FragmentedStorageFileJson() {
|
|||
|
||||
@FormField(R.string.connect_last, FieldForm.TOGGLE, R.string.connect_last_description, 3)
|
||||
var connectLast: Boolean = true;
|
||||
|
||||
@FormField(R.string.discover_through_relay, FieldForm.TOGGLE, R.string.discover_through_relay_description, 3)
|
||||
var discoverThroughRelay: Boolean = true;
|
||||
|
||||
@FormField(R.string.pair_through_relay, FieldForm.TOGGLE, R.string.pair_through_relay_description, 3)
|
||||
var pairThroughRelay: Boolean = true;
|
||||
|
||||
@FormField(R.string.connect_through_relay, FieldForm.TOGGLE, R.string.connect_through_relay_description, 3)
|
||||
var connectThroughRelay: Boolean = true;
|
||||
}
|
||||
|
||||
@FormField(R.string.info, FieldForm.GROUP, -1, 21)
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@ 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
|
||||
|
|
@ -200,21 +199,16 @@ class UIDialogs {
|
|||
dialog.show();
|
||||
}
|
||||
|
||||
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 {
|
||||
fun showDialog(context: Context, icon: Int, text: String, textDetails: String? = null, code: String? = null, defaultCloseAction: Int, vararg actions: Action) {
|
||||
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;
|
||||
|
|
@ -281,7 +275,6 @@ class UIDialogs {
|
|||
registerDialogClosed(dialog);
|
||||
}
|
||||
dialog.show();
|
||||
return dialog;
|
||||
}
|
||||
|
||||
fun showGeneralErrorDialog(context: Context, msg: String, ex: Throwable? = null, button: String = "Ok", onOk: (()->Unit)? = null) {
|
||||
|
|
|
|||
|
|
@ -1148,7 +1148,7 @@ class UISlideOverlays {
|
|||
container.context.getString(R.string.decide_which_buttons_should_be_pinned),
|
||||
tag = "",
|
||||
call = {
|
||||
showOrderOverlay(container, container.context.getString(R.string.select_your_pins_in_order), (visible + hidden).map { Pair(it.text.text.toString(), it.tagRef!!) }, {
|
||||
showOrderOverlay(container, container.context.getString(R.string.select_your_pins_in_order), (visible + hidden).map { Pair(it.text.text.toString(), it.tagRef!!) }) {
|
||||
val selected = it
|
||||
.map { x -> visible.find { it.tagRef == x } ?: hidden.find { it.tagRef == x } }
|
||||
.filter { it != null }
|
||||
|
|
@ -1156,7 +1156,7 @@ class UISlideOverlays {
|
|||
.toList();
|
||||
|
||||
onPinnedbuttons?.invoke(selected + (visible + hidden).filter { !selected.contains(it) });
|
||||
});
|
||||
}
|
||||
},
|
||||
invokeParent = false
|
||||
))
|
||||
|
|
@ -1164,40 +1164,29 @@ 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, description: String? = null) {
|
||||
|
||||
fun showOrderOverlay(container: ViewGroup, title: String, options: List<Pair<String, Any>>, onOrdered: (List<Any>)->Unit) {
|
||||
val selection: MutableList<Any> = mutableListOf();
|
||||
|
||||
var overlay: SlideUpMenuOverlay? = null;
|
||||
|
||||
overlay = SlideUpMenuOverlay(container.context, container, title, container.context.getString(R.string.save), true,
|
||||
listOf(
|
||||
if(!description.isNullOrEmpty()) SlideUpMenuGroup(container.context, "", description, "", listOf()) else null,
|
||||
).filterNotNull() +
|
||||
(options.map { SlideUpMenuItem(
|
||||
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);
|
||||
if(overlayItem != null) {
|
||||
overlayItem.setSubText(selection.indexOf(it.second).toString());
|
||||
}
|
||||
}
|
||||
} else {
|
||||
} else
|
||||
selection.remove(it.second);
|
||||
if(overlayItem != null) {
|
||||
overlayItem.setSubText("");
|
||||
}
|
||||
}
|
||||
},
|
||||
invokeParent = false
|
||||
)
|
||||
}));
|
||||
});
|
||||
overlay.onOK.subscribe {
|
||||
onOrdered.invoke(selection);
|
||||
overlay.hide();
|
||||
|
|
|
|||
|
|
@ -27,17 +27,14 @@ 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.ByteArrayOutputStream
|
||||
import java.io.File
|
||||
import java.io.IOException
|
||||
import java.io.InputStream
|
||||
import java.io.OutputStream
|
||||
import java.nio.ByteBuffer
|
||||
import java.security.SecureRandom
|
||||
import java.time.OffsetDateTime
|
||||
import java.nio.ByteOrder
|
||||
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 {
|
||||
|
|
@ -282,46 +279,3 @@ fun ByteBuffer.toUtf8String(): String {
|
|||
get(remainingBytes)
|
||||
return String(remainingBytes, Charsets.UTF_8)
|
||||
}
|
||||
|
||||
fun generateReadablePassword(length: Int): String {
|
||||
val validChars = "ABCDEFGHJKLMNPQRSTUVWXYZabcdefghjkmnpqrstuvwxyz23456789"
|
||||
val secureRandom = SecureRandom()
|
||||
val randomBytes = ByteArray(length)
|
||||
secureRandom.nextBytes(randomBytes)
|
||||
val sb = StringBuilder(length)
|
||||
for (byte in randomBytes) {
|
||||
val index = (byte.toInt() and 0xFF) % validChars.length
|
||||
sb.append(validChars[index])
|
||||
}
|
||||
return sb.toString()
|
||||
}
|
||||
|
||||
fun ByteArray.toGzip(): ByteArray {
|
||||
if (this == null || this.isEmpty()) return ByteArray(0)
|
||||
|
||||
val gzipTimeStart = OffsetDateTime.now();
|
||||
|
||||
val outputStream = ByteArrayOutputStream()
|
||||
GZIPOutputStream(outputStream).use { gzip ->
|
||||
gzip.write(this)
|
||||
}
|
||||
val result = outputStream.toByteArray();
|
||||
Logger.i("Utility", "Gzip compression time: ${gzipTimeStart.getNowDiffMiliseconds()}ms");
|
||||
return result;
|
||||
}
|
||||
|
||||
fun ByteArray.fromGzip(): ByteArray {
|
||||
if (this == null || this.isEmpty()) return ByteArray(0)
|
||||
|
||||
val inputStream = ByteArrayInputStream(this)
|
||||
val outputStream = ByteArrayOutputStream()
|
||||
|
||||
GZIPInputStream(inputStream).use { gzip ->
|
||||
val buffer = ByteArray(1024)
|
||||
var bytesRead: Int
|
||||
while (gzip.read(buffer).also { bytesRead = it } != -1) {
|
||||
outputStream.write(buffer, 0, bytesRead)
|
||||
}
|
||||
}
|
||||
return outputStream.toByteArray()
|
||||
}
|
||||
|
|
@ -100,8 +100,7 @@ class SyncHomeActivity : AppCompatActivity() {
|
|||
|
||||
private fun updateDeviceView(syncDeviceView: SyncDeviceView, publicKey: String, session: SyncSession?): SyncDeviceView {
|
||||
val connected = session?.connected ?: false
|
||||
|
||||
syncDeviceView.setLinkType(session?.linkType ?: LinkType.None)
|
||||
syncDeviceView.setLinkType(if (connected) LinkType.Local else LinkType.None)
|
||||
.setName(session?.displayName ?: StateSync.instance.getCachedName(publicKey) ?: publicKey)
|
||||
//TODO: also display public key?
|
||||
.setStatus(if (connected) "Connected" else "Disconnected")
|
||||
|
|
|
|||
|
|
@ -109,9 +109,9 @@ class SyncPairActivity : AppCompatActivity() {
|
|||
|
||||
lifecycleScope.launch(Dispatchers.IO) {
|
||||
try {
|
||||
StateSync.instance.connect(deviceInfo) { complete, message ->
|
||||
StateSync.instance.connect(deviceInfo) { session, complete, message ->
|
||||
lifecycleScope.launch(Dispatchers.Main) {
|
||||
if (complete != null && complete) {
|
||||
if (complete) {
|
||||
_layoutPairingSuccess.visibility = View.VISIBLE
|
||||
_layoutPairing.visibility = View.GONE
|
||||
} else {
|
||||
|
|
|
|||
|
|
@ -67,7 +67,7 @@ class SyncShowPairingCodeActivity : AppCompatActivity() {
|
|||
}
|
||||
|
||||
val ips = getIPs()
|
||||
val selfDeviceInfo = SyncDeviceInfo(StateSync.instance.publicKey!!, ips.toTypedArray(), StateSync.PORT, StateSync.instance.pairingCode)
|
||||
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}"
|
||||
|
|
|
|||
|
|
@ -3,7 +3,6 @@ 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 {
|
||||
|
|
|
|||
|
|
@ -10,7 +10,6 @@ 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
|
||||
|
|
@ -21,7 +20,6 @@ open class SerializedPlatformVideo(
|
|||
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 = "",
|
||||
|
|
|
|||
|
|
@ -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>: IPager<T> {
|
||||
interface IRefreshPager<T> {
|
||||
val onPagerChanged: Event1<IPager<T>>;
|
||||
val onPagerError: Event1<Throwable>;
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,5 @@
|
|||
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
|
||||
|
||||
/**
|
||||
|
|
@ -11,8 +9,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
|
||||
*/
|
||||
open class ReusablePager<T>: INestedPager<T>, IReusablePager<T> {
|
||||
protected var _pager: IPager<T>;
|
||||
class ReusablePager<T>: INestedPager<T>, IPager<T> {
|
||||
private val _pager: IPager<T>;
|
||||
val previousResults = arrayListOf<T>();
|
||||
|
||||
constructor(subPager: IPager<T>) {
|
||||
|
|
@ -46,7 +44,7 @@ open class ReusablePager<T>: INestedPager<T>, IReusablePager<T> {
|
|||
return previousResults;
|
||||
}
|
||||
|
||||
override fun getWindow(): Window<T> {
|
||||
fun getWindow(): Window<T> {
|
||||
return Window(this);
|
||||
}
|
||||
|
||||
|
|
@ -97,118 +95,4 @@ open class ReusablePager<T>: INestedPager<T>, IReusablePager<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>;
|
||||
}
|
||||
|
|
@ -3,7 +3,6 @@ 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
|
||||
|
|
@ -33,7 +32,6 @@ 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
|
||||
|
|
|
|||
|
|
@ -1,6 +1,5 @@
|
|||
package com.futo.platformplayer.casting
|
||||
|
||||
import android.app.AlertDialog
|
||||
import android.content.ContentResolver
|
||||
import android.content.Context
|
||||
import android.net.Uri
|
||||
|
|
@ -10,7 +9,6 @@ import android.util.Log
|
|||
import android.util.Xml
|
||||
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
|
||||
|
|
@ -241,9 +239,6 @@ class StateCasting {
|
|||
Logger.i(TAG, "CastingService stopped.")
|
||||
}
|
||||
|
||||
private val _castingDialogLock = Any();
|
||||
private var _currentDialog: AlertDialog? = null;
|
||||
|
||||
@Synchronized
|
||||
fun connectDevice(device: CastingDevice) {
|
||||
if (activeDevice == device)
|
||||
|
|
@ -277,41 +272,10 @@ class StateCasting {
|
|||
invokeInMainScopeIfRequired {
|
||||
StateApp.withContext(false) { context ->
|
||||
context.let {
|
||||
Logger.i(TAG, "Casting state changed to ${castConnectionState}");
|
||||
when (castConnectionState) {
|
||||
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;
|
||||
}
|
||||
}
|
||||
}
|
||||
CastConnectionState.CONNECTED -> UIDialogs.toast(it, "Connected to device")
|
||||
CastConnectionState.CONNECTING -> UIDialogs.toast(it, "Connecting to device...")
|
||||
CastConnectionState.DISCONNECTED -> UIDialogs.toast(it, "Disconnected from device")
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -73,11 +73,11 @@ class ConnectCastingDialog(context: Context?) : AlertDialog(context) {
|
|||
};
|
||||
_rememberedAdapter.onConnect.subscribe { _ ->
|
||||
dismiss()
|
||||
//UIDialogs.showCastingDialog(context)
|
||||
UIDialogs.showCastingDialog(context)
|
||||
}
|
||||
_adapter.onConnect.subscribe { _ ->
|
||||
dismiss()
|
||||
//UIDialogs.showCastingDialog(context)
|
||||
UIDialogs.showCastingDialog(context)
|
||||
}
|
||||
_recyclerRememberedDevices.adapter = _rememberedAdapter;
|
||||
_recyclerRememberedDevices.layoutManager = LinearLayoutManager(context);
|
||||
|
|
|
|||
|
|
@ -21,8 +21,6 @@ import com.futo.platformplayer.models.Playlist
|
|||
import com.futo.platformplayer.states.StateDownloads
|
||||
import com.futo.platformplayer.states.StatePlayer
|
||||
import com.futo.platformplayer.states.StatePlaylists
|
||||
import com.futo.platformplayer.stores.FragmentedStorage
|
||||
import com.futo.platformplayer.stores.StringStorage
|
||||
import com.futo.platformplayer.toHumanBytesSize
|
||||
import com.futo.platformplayer.toHumanDuration
|
||||
import com.futo.platformplayer.views.AnyInsertedAdapterView
|
||||
|
|
@ -105,15 +103,12 @@ class DownloadsFragment : MainFragment() {
|
|||
private val _listDownloaded: AnyInsertedAdapterView<VideoLocal, VideoDownloadViewHolder>;
|
||||
|
||||
private var lastDownloads: List<VideoLocal>? = null;
|
||||
private var ordering = FragmentedStorage.get<StringStorage>("downloads_ordering")
|
||||
private var ordering: String? = "nameAsc";
|
||||
|
||||
constructor(frag: DownloadsFragment, inflater: LayoutInflater): super(frag.requireContext()) {
|
||||
inflater.inflate(R.layout.fragment_downloads, this);
|
||||
_frag = frag;
|
||||
|
||||
if(ordering.value.isNullOrBlank())
|
||||
ordering.value = "nameAsc";
|
||||
|
||||
_usageUsed = findViewById(R.id.downloads_usage_used);
|
||||
_usageAvailable = findViewById(R.id.downloads_usage_available);
|
||||
_usageProgress = findViewById(R.id.downloads_usage_progress);
|
||||
|
|
@ -137,23 +132,22 @@ class DownloadsFragment : MainFragment() {
|
|||
spinnerSortBy.adapter = ArrayAdapter(context, R.layout.spinner_item_simple, resources.getStringArray(R.array.downloads_sortby_array)).also {
|
||||
it.setDropDownViewResource(R.layout.spinner_dropdownitem_simple);
|
||||
};
|
||||
val options = listOf("nameAsc", "nameDesc", "downloadDateAsc", "downloadDateDesc", "releasedAsc", "releasedDesc");
|
||||
spinnerSortBy.setSelection(0);
|
||||
spinnerSortBy.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
|
||||
override fun onItemSelected(parent: AdapterView<*>, view: View?, pos: Int, id: Long) {
|
||||
when(pos) {
|
||||
0 -> ordering.setAndSave("nameAsc")
|
||||
1 -> ordering.setAndSave("nameDesc")
|
||||
2 -> ordering.setAndSave("downloadDateAsc")
|
||||
3 -> ordering.setAndSave("downloadDateDesc")
|
||||
4 -> ordering.setAndSave("releasedAsc")
|
||||
5 -> ordering.setAndSave("releasedDesc")
|
||||
else -> ordering.setAndSave("")
|
||||
0 -> ordering = "nameAsc"
|
||||
1 -> ordering = "nameDesc"
|
||||
2 -> ordering = "downloadDateAsc"
|
||||
3 -> ordering = "downloadDateDesc"
|
||||
4 -> ordering = "releasedAsc"
|
||||
5 -> ordering = "releasedDesc"
|
||||
else -> ordering = null
|
||||
}
|
||||
updateContentFilters()
|
||||
}
|
||||
override fun onNothingSelected(parent: AdapterView<*>?) = Unit
|
||||
};
|
||||
spinnerSortBy.setSelection(Math.max(0, options.indexOf(ordering.value)));
|
||||
|
||||
_listDownloaded = findViewById<RecyclerView>(R.id.list_downloaded)
|
||||
.asAnyWithTop(findViewById(R.id.downloads_top)) {
|
||||
|
|
@ -236,8 +230,8 @@ class DownloadsFragment : MainFragment() {
|
|||
var vidsToReturn = vids;
|
||||
if(!_listDownloadSearch.text.isNullOrEmpty())
|
||||
vidsToReturn = vids.filter { it.name.contains(_listDownloadSearch.text, true) || it.author.name.contains(_listDownloadSearch.text, true) };
|
||||
if(!ordering.value.isNullOrEmpty()) {
|
||||
vidsToReturn = when(ordering.value){
|
||||
if(!ordering.isNullOrEmpty()) {
|
||||
vidsToReturn = when(ordering){
|
||||
"downloadDateAsc" -> vidsToReturn.sortedBy { it.downloadDate ?: OffsetDateTime.MAX };
|
||||
"downloadDateDesc" -> vidsToReturn.sortedByDescending { it.downloadDate ?: OffsetDateTime.MIN };
|
||||
"nameAsc" -> vidsToReturn.sortedBy { it.name.lowercase() }
|
||||
|
|
|
|||
|
|
@ -3,15 +3,12 @@ package com.futo.platformplayer.fragment.mainactivity.main
|
|||
import android.content.Context
|
||||
import android.content.res.Configuration
|
||||
import android.graphics.Color
|
||||
import android.util.DisplayMetrics
|
||||
import android.view.Display
|
||||
import android.view.LayoutInflater
|
||||
import android.view.View
|
||||
import android.view.ViewGroup
|
||||
import android.widget.*
|
||||
import androidx.lifecycle.lifecycleScope
|
||||
import androidx.recyclerview.widget.GridLayoutManager
|
||||
import androidx.recyclerview.widget.LinearLayoutManager
|
||||
import androidx.recyclerview.widget.RecyclerView
|
||||
import androidx.recyclerview.widget.RecyclerView.LayoutManager
|
||||
import androidx.swiperefreshlayout.widget.SwipeRefreshLayout
|
||||
|
|
@ -23,7 +20,6 @@ import com.futo.platformplayer.constructs.Event1
|
|||
import com.futo.platformplayer.constructs.TaskHandler
|
||||
import com.futo.platformplayer.engine.exceptions.PluginException
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.states.StateApp
|
||||
import com.futo.platformplayer.views.FeedStyle
|
||||
import com.futo.platformplayer.views.others.ProgressBar
|
||||
import com.futo.platformplayer.views.others.TagsView
|
||||
|
|
@ -32,9 +28,7 @@ import com.futo.platformplayer.views.adapters.InsertedViewHolder
|
|||
import com.futo.platformplayer.views.announcements.AnnouncementView
|
||||
import kotlinx.coroutines.CancellationException
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.delay
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.withContext
|
||||
import java.time.OffsetDateTime
|
||||
import kotlin.math.max
|
||||
|
||||
|
|
@ -74,7 +68,6 @@ abstract class FeedView<TFragment, TResult, TConverted, TPager, TViewHolder> : L
|
|||
|
||||
private val _scrollListener: RecyclerView.OnScrollListener;
|
||||
private var _automaticNextPageCounter = 0;
|
||||
private val _automaticBackoff = arrayOf(0, 500, 1000, 1000, 2000, 5000, 5000, 5000);
|
||||
|
||||
constructor(fragment: TFragment, inflater: LayoutInflater, cachedRecyclerData: RecyclerData<InsertedViewAdapterWithLoader<TViewHolder>, GridLayoutManager, TPager, TResult, TConverted, InsertedViewHolder<TViewHolder>>? = null) : super(inflater.context) {
|
||||
this.fragment = fragment;
|
||||
|
|
@ -136,7 +129,6 @@ abstract class FeedView<TFragment, TResult, TConverted, TPager, TViewHolder> : L
|
|||
_toolbarContentView = findViewById(R.id.container_toolbar_content);
|
||||
|
||||
_nextPageHandler = TaskHandler<TPager, List<TResult>>({fragment.lifecycleScope}, {
|
||||
|
||||
if (it is IAsyncPager<*>)
|
||||
it.nextPageAsync();
|
||||
else
|
||||
|
|
@ -190,61 +182,29 @@ abstract class FeedView<TFragment, TResult, TConverted, TPager, TViewHolder> : L
|
|||
|
||||
private fun ensureEnoughContentVisible(filteredResults: List<TConverted>) {
|
||||
val canScroll = if (recyclerData.results.isEmpty()) false else {
|
||||
val height = resources.displayMetrics.heightPixels;
|
||||
|
||||
val layoutManager = recyclerData.layoutManager
|
||||
val firstVisibleItemPosition = layoutManager.findFirstVisibleItemPosition()
|
||||
val firstVisibleItemView = if(firstVisibleItemPosition != RecyclerView.NO_POSITION) layoutManager.findViewByPosition(firstVisibleItemPosition) else null;
|
||||
val lastVisibleItemPosition = layoutManager.findLastCompletelyVisibleItemPosition();
|
||||
val lastVisibleItemView = if(lastVisibleItemPosition != RecyclerView.NO_POSITION) layoutManager.findViewByPosition(lastVisibleItemPosition) else null;
|
||||
val rows = if(recyclerData.layoutManager is GridLayoutManager) Math.max(1, recyclerData.results.size / recyclerData.layoutManager.spanCount) else 1;
|
||||
val rowsHeight = (firstVisibleItemView?.height ?: 0) * rows;
|
||||
if(lastVisibleItemView != null && lastVisibleItemPosition == (recyclerData.results.size - 1)) {
|
||||
false;
|
||||
}
|
||||
else if (firstVisibleItemView != null && height != null && rowsHeight < height) {
|
||||
false;
|
||||
|
||||
if (firstVisibleItemPosition != RecyclerView.NO_POSITION) {
|
||||
val firstVisibleView = layoutManager.findViewByPosition(firstVisibleItemPosition)
|
||||
val itemHeight = firstVisibleView?.height ?: 0
|
||||
val occupiedSpace = recyclerData.results.size / recyclerData.layoutManager.spanCount * itemHeight
|
||||
val recyclerViewHeight = _recyclerResults.height
|
||||
Logger.i(TAG, "ensureEnoughContentVisible loadNextPage occupiedSpace=$occupiedSpace recyclerViewHeight=$recyclerViewHeight")
|
||||
occupiedSpace >= recyclerViewHeight
|
||||
} else {
|
||||
true;
|
||||
false
|
||||
}
|
||||
}
|
||||
|
||||
Logger.i(TAG, "ensureEnoughContentVisible loadNextPage canScroll=$canScroll _automaticNextPageCounter=$_automaticNextPageCounter")
|
||||
if (!canScroll || filteredResults.isEmpty()) {
|
||||
_automaticNextPageCounter++
|
||||
if(_automaticNextPageCounter < _automaticBackoff.size) {
|
||||
if(_automaticNextPageCounter > 0) {
|
||||
val automaticNextPageCounterSaved = _automaticNextPageCounter;
|
||||
fragment.lifecycleScope.launch(Dispatchers.Default) {
|
||||
val backoff = _automaticBackoff[Math.min(_automaticBackoff.size - 1, _automaticNextPageCounter)];
|
||||
|
||||
withContext(Dispatchers.Main) {
|
||||
setLoading(true);
|
||||
}
|
||||
delay(backoff.toLong());
|
||||
if(automaticNextPageCounterSaved == _automaticNextPageCounter) {
|
||||
withContext(Dispatchers.Main) {
|
||||
loadNextPage();
|
||||
}
|
||||
}
|
||||
else {
|
||||
withContext(Dispatchers.Main) {
|
||||
setLoading(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
loadNextPage();
|
||||
}
|
||||
if(_automaticNextPageCounter <= 4)
|
||||
loadNextPage()
|
||||
} else {
|
||||
Logger.i(TAG, "ensureEnoughContentVisible automaticNextPageCounter reset");
|
||||
_automaticNextPageCounter = 0;
|
||||
}
|
||||
}
|
||||
fun resetAutomaticNextPageCounter(){
|
||||
_automaticNextPageCounter = 0;
|
||||
}
|
||||
|
||||
protected fun setTextCentered(text: String?) {
|
||||
_textCentered.text = text;
|
||||
|
|
|
|||
|
|
@ -5,38 +5,29 @@ import android.os.Bundle
|
|||
import android.view.LayoutInflater
|
||||
import android.view.View
|
||||
import android.view.ViewGroup
|
||||
import androidx.core.view.allViews
|
||||
import androidx.lifecycle.lifecycleScope
|
||||
import androidx.recyclerview.widget.GridLayoutManager
|
||||
import com.futo.platformplayer.*
|
||||
import com.futo.platformplayer.UISlideOverlays.Companion.showOrderOverlay
|
||||
import com.futo.platformplayer.activities.MainActivity
|
||||
import com.futo.platformplayer.api.media.models.contents.IPlatformContent
|
||||
import com.futo.platformplayer.api.media.platforms.js.JSClient
|
||||
import com.futo.platformplayer.api.media.structures.EmptyPager
|
||||
import com.futo.platformplayer.api.media.structures.IPager
|
||||
import com.futo.platformplayer.api.media.structures.IRefreshPager
|
||||
import com.futo.platformplayer.api.media.structures.IReusablePager
|
||||
import com.futo.platformplayer.api.media.structures.ReusablePager
|
||||
import com.futo.platformplayer.api.media.structures.ReusableRefreshPager
|
||||
import com.futo.platformplayer.constructs.TaskHandler
|
||||
import com.futo.platformplayer.engine.exceptions.ScriptCaptchaRequiredException
|
||||
import com.futo.platformplayer.engine.exceptions.ScriptExecutionException
|
||||
import com.futo.platformplayer.engine.exceptions.ScriptImplementationException
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.states.StateApp
|
||||
import com.futo.platformplayer.states.StateHistory
|
||||
import com.futo.platformplayer.states.StateMeta
|
||||
import com.futo.platformplayer.states.StatePlatform
|
||||
import com.futo.platformplayer.states.StatePlugins
|
||||
import com.futo.platformplayer.stores.FragmentedStorage
|
||||
import com.futo.platformplayer.stores.StringArrayStorage
|
||||
import com.futo.platformplayer.views.FeedStyle
|
||||
import com.futo.platformplayer.views.NoResultsView
|
||||
import com.futo.platformplayer.views.ToggleBar
|
||||
import com.futo.platformplayer.views.adapters.ContentPreviewViewHolder
|
||||
import com.futo.platformplayer.views.adapters.InsertedViewAdapterWithLoader
|
||||
import com.futo.platformplayer.views.adapters.InsertedViewHolder
|
||||
import com.futo.platformplayer.views.announcements.AnnouncementView
|
||||
import com.futo.platformplayer.views.buttons.BigButton
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import java.time.OffsetDateTime
|
||||
|
|
@ -48,12 +39,6 @@ class HomeFragment : MainFragment() {
|
|||
|
||||
private var _view: HomeView? = null;
|
||||
private var _cachedRecyclerData: FeedView.RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null;
|
||||
private var _cachedLastPager: IReusablePager<IPlatformContent>? = null
|
||||
|
||||
private var _toggleRecent = false;
|
||||
private var _toggleWatched = false;
|
||||
private var _togglePluginsDisabled = mutableListOf<String>();
|
||||
|
||||
|
||||
fun reloadFeed() {
|
||||
_view?.reloadFeed()
|
||||
|
|
@ -79,7 +64,7 @@ class HomeFragment : MainFragment() {
|
|||
}
|
||||
|
||||
override fun onCreateMainView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
|
||||
val view = HomeView(this, inflater, _cachedRecyclerData, _cachedLastPager);
|
||||
val view = HomeView(this, inflater, _cachedRecyclerData);
|
||||
_view = view;
|
||||
return view;
|
||||
}
|
||||
|
|
@ -97,7 +82,6 @@ class HomeFragment : MainFragment() {
|
|||
val view = _view;
|
||||
if (view != null) {
|
||||
_cachedRecyclerData = view.recyclerData;
|
||||
_cachedLastPager = view.lastPager;
|
||||
view.cleanup();
|
||||
_view = null;
|
||||
}
|
||||
|
|
@ -107,7 +91,6 @@ class HomeFragment : MainFragment() {
|
|||
_view?.setPreviewsEnabled(previewsEnabled && Settings.instance.home.previewFeedItems);
|
||||
}
|
||||
|
||||
|
||||
@SuppressLint("ViewConstructor")
|
||||
class HomeView : ContentFeedView<HomeFragment> {
|
||||
override val feedStyle: FeedStyle get() = Settings.instance.home.getHomeFeedStyle();
|
||||
|
|
@ -117,22 +100,11 @@ class HomeFragment : MainFragment() {
|
|||
private val _taskGetPager: TaskHandler<Boolean, IPager<IPlatformContent>>;
|
||||
override val shouldShowTimeBar: Boolean get() = Settings.instance.home.progressBar
|
||||
|
||||
var lastPager: IReusablePager<IPlatformContent>? = null;
|
||||
|
||||
constructor(fragment: HomeFragment, inflater: LayoutInflater, cachedRecyclerData: RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null, cachedLastPager: IReusablePager<IPlatformContent>? = null) : super(fragment, inflater, cachedRecyclerData) {
|
||||
lastPager = cachedLastPager
|
||||
constructor(fragment: HomeFragment, inflater: LayoutInflater, cachedRecyclerData: RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null) : super(fragment, inflater, cachedRecyclerData) {
|
||||
_taskGetPager = TaskHandler<Boolean, IPager<IPlatformContent>>({ fragment.lifecycleScope }, {
|
||||
StatePlatform.instance.getHomeRefresh(fragment.lifecycleScope)
|
||||
})
|
||||
.success {
|
||||
val wrappedPager = if(it is IRefreshPager)
|
||||
ReusableRefreshPager(it);
|
||||
else
|
||||
ReusablePager(it);
|
||||
lastPager = wrappedPager;
|
||||
resetAutomaticNextPageCounter();
|
||||
loadedResult(wrappedPager.getWindow());
|
||||
}
|
||||
.success { loadedResult(it); }
|
||||
.exception<ScriptCaptchaRequiredException> { }
|
||||
.exception<ScriptExecutionException> {
|
||||
Logger.w(ChannelFragment.TAG, "Plugin failure.", it);
|
||||
|
|
@ -235,94 +207,22 @@ class HomeFragment : MainFragment() {
|
|||
}
|
||||
|
||||
private val _filterLock = Object();
|
||||
private var _togglesConfig = FragmentedStorage.get<StringArrayStorage>("home_toggles");
|
||||
private var _toggleRecent = false;
|
||||
fun initializeToolbarContent() {
|
||||
if(_toolbarContentView.allViews.any { it is ToggleBar })
|
||||
_toolbarContentView.removeView(_toolbarContentView.allViews.find { it is ToggleBar });
|
||||
|
||||
if(Settings.instance.home.showHomeFilters) {
|
||||
|
||||
if (!_togglesConfig.any()) {
|
||||
_togglesConfig.set("today", "watched", "plugins");
|
||||
_togglesConfig.save();
|
||||
}
|
||||
_toggleBar = ToggleBar(context).apply {
|
||||
layoutParams =
|
||||
LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
|
||||
}
|
||||
|
||||
synchronized(_filterLock) {
|
||||
var buttonsPlugins: List<ToggleBar.Toggle> = listOf()
|
||||
buttonsPlugins = (if (_togglesConfig.contains("plugins"))
|
||||
(StatePlatform.instance.getEnabledClients()
|
||||
.filter { it is JSClient && it.enableInHome }
|
||||
.map { plugin ->
|
||||
ToggleBar.Toggle(if(Settings.instance.home.showHomeFiltersPluginNames) plugin.name else "", plugin.icon, !fragment._togglePluginsDisabled.contains(plugin.id), { view, active ->
|
||||
var dontSwap = false;
|
||||
if (active) {
|
||||
if (fragment._togglePluginsDisabled.contains(plugin.id))
|
||||
fragment._togglePluginsDisabled.remove(plugin.id);
|
||||
} else {
|
||||
if (!fragment._togglePluginsDisabled.contains(plugin.id)) {
|
||||
val enabledClients = StatePlatform.instance.getEnabledClients();
|
||||
val availableAfterDisable = enabledClients.count { !fragment._togglePluginsDisabled.contains(it.id) && it.id != plugin.id };
|
||||
if(availableAfterDisable > 0)
|
||||
fragment._togglePluginsDisabled.add(plugin.id);
|
||||
else {
|
||||
UIDialogs.appToast("Home needs atleast 1 plugin active");
|
||||
dontSwap = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if(!dontSwap)
|
||||
reloadForFilters();
|
||||
else {
|
||||
view.setToggle(!active);
|
||||
}
|
||||
}).withTag("plugins")
|
||||
})
|
||||
else listOf())
|
||||
val buttons = (listOf<ToggleBar.Toggle?>(
|
||||
(if (_togglesConfig.contains("today"))
|
||||
ToggleBar.Toggle("Today", fragment._toggleRecent) { view, active ->
|
||||
fragment._toggleRecent = active; reloadForFilters()
|
||||
}
|
||||
.withTag("today") else null),
|
||||
(if (_togglesConfig.contains("watched"))
|
||||
ToggleBar.Toggle("Unwatched", fragment._toggleWatched) { view, active ->
|
||||
fragment._toggleWatched = active; reloadForFilters()
|
||||
}
|
||||
.withTag("watched") else null),
|
||||
).filterNotNull() + buttonsPlugins)
|
||||
.sortedBy { _togglesConfig.indexOf(it.tag ?: "") } ?: listOf()
|
||||
|
||||
val buttonSettings = ToggleBar.Toggle("", R.drawable.ic_settings, true, { view, active ->
|
||||
showOrderOverlay(_overlayContainer,
|
||||
"Visible home filters",
|
||||
listOf(
|
||||
Pair("Plugins", "plugins"),
|
||||
Pair("Today", "today"),
|
||||
Pair("Watched", "watched")
|
||||
),
|
||||
{
|
||||
val newArray = it.map { it.toString() }.toTypedArray();
|
||||
_togglesConfig.set(*(if (newArray.any()) newArray else arrayOf("none")));
|
||||
_togglesConfig.save();
|
||||
initializeToolbarContent();
|
||||
},
|
||||
"Select which toggles you want to see in order. You can also choose to hide filters in the Grayjay Settings"
|
||||
);
|
||||
}).asButton();
|
||||
|
||||
val buttonsOrder = (buttons + listOf(buttonSettings)).toTypedArray();
|
||||
_toggleBar?.setToggles(*buttonsOrder);
|
||||
}
|
||||
|
||||
_toolbarContentView.addView(_toggleBar, 0);
|
||||
//Not stable enough with current viewport paging, doesn't work with less results, and reloads content instead of just re-filtering existing
|
||||
/*
|
||||
_toggleBar = ToggleBar(context).apply {
|
||||
layoutParams = LayoutParams(LayoutParams.MATCH_PARENT, LayoutParams.WRAP_CONTENT);
|
||||
}
|
||||
}
|
||||
fun reloadForFilters() {
|
||||
lastPager?.let { loadedResult(it.getWindow()) };
|
||||
synchronized(_filterLock) {
|
||||
_toggleBar?.setToggles(
|
||||
//TODO: loadResults needs to be replaced with an internal reload of the current content
|
||||
ToggleBar.Toggle("Recent", _toggleRecent) { _toggleRecent = it; loadResults(false) }
|
||||
)
|
||||
}
|
||||
|
||||
_toolbarContentView.addView(_toggleBar, 0);
|
||||
*/
|
||||
}
|
||||
|
||||
override fun filterResults(results: List<IPlatformContent>): List<IPlatformContent> {
|
||||
|
|
@ -332,11 +232,7 @@ class HomeFragment : MainFragment() {
|
|||
if(StateMeta.instance.isCreatorHidden(it.author.url))
|
||||
return@filter false;
|
||||
|
||||
if(fragment._toggleRecent && (it.datetime?.getNowDiffHours() ?: 0) > 25)
|
||||
return@filter false;
|
||||
if(fragment._toggleWatched && StateHistory.instance.isHistoryWatched(it.url, 0))
|
||||
return@filter false;
|
||||
if(fragment._togglePluginsDisabled.any() && it.id.pluginId != null && fragment._togglePluginsDisabled.contains(it.id.pluginId)) {
|
||||
if(_toggleRecent && (it.datetime?.getNowDiffHours() ?: 0) > 23) {
|
||||
return@filter false;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -326,10 +326,6 @@ class PlaylistFragment : MainFragment() {
|
|||
playlist.videos = ArrayList(playlist.videos.filter { it != video });
|
||||
StatePlaylists.instance.createOrUpdatePlaylist(playlist);
|
||||
}
|
||||
|
||||
override fun onVideoOptions(video: IPlatformVideo) {
|
||||
UISlideOverlays.showVideoOptionsOverlay(video, overlayContainer);
|
||||
}
|
||||
override fun onVideoClicked(video: IPlatformVideo) {
|
||||
val playlist = _playlist;
|
||||
if (playlist != null) {
|
||||
|
|
|
|||
|
|
@ -26,8 +26,6 @@ import com.futo.platformplayer.api.media.models.video.IPlatformVideo
|
|||
import com.futo.platformplayer.models.Playlist
|
||||
import com.futo.platformplayer.states.StatePlayer
|
||||
import com.futo.platformplayer.states.StatePlaylists
|
||||
import com.futo.platformplayer.stores.FragmentedStorage
|
||||
import com.futo.platformplayer.stores.StringStorage
|
||||
import com.futo.platformplayer.views.SearchView
|
||||
import com.futo.platformplayer.views.adapters.*
|
||||
import com.futo.platformplayer.views.overlays.slideup.SlideUpMenuOverlay
|
||||
|
|
@ -84,7 +82,7 @@ class PlaylistsFragment : MainFragment() {
|
|||
|
||||
private var _listPlaylistsSearch: EditText;
|
||||
|
||||
private var _ordering = FragmentedStorage.get<StringStorage>("playlists_ordering")
|
||||
private var _ordering: String? = null;
|
||||
|
||||
|
||||
constructor(fragment: PlaylistsFragment, inflater: LayoutInflater) : super(inflater.context) {
|
||||
|
|
@ -147,25 +145,24 @@ class PlaylistsFragment : MainFragment() {
|
|||
spinnerSortBy.adapter = ArrayAdapter(context, R.layout.spinner_item_simple, resources.getStringArray(R.array.playlists_sortby_array)).also {
|
||||
it.setDropDownViewResource(R.layout.spinner_dropdownitem_simple);
|
||||
};
|
||||
val options = listOf("nameAsc", "nameDesc", "dateEditAsc", "dateEditDesc", "dateCreateAsc", "dateCreateDesc", "datePlayAsc", "datePlayDesc");
|
||||
spinnerSortBy.setSelection(0);
|
||||
spinnerSortBy.onItemSelectedListener = object : AdapterView.OnItemSelectedListener {
|
||||
override fun onItemSelected(parent: AdapterView<*>, view: View?, pos: Int, id: Long) {
|
||||
when(pos) {
|
||||
0 -> _ordering.setAndSave("nameAsc")
|
||||
1 -> _ordering.setAndSave("nameDesc")
|
||||
2 -> _ordering.setAndSave("dateEditAsc")
|
||||
3 -> _ordering.setAndSave("dateEditDesc")
|
||||
4 -> _ordering.setAndSave("dateCreateAsc")
|
||||
5 -> _ordering.setAndSave("dateCreateDesc")
|
||||
6 -> _ordering.setAndSave("datePlayAsc")
|
||||
7 -> _ordering.setAndSave("datePlayDesc")
|
||||
else -> _ordering.setAndSave("")
|
||||
0 -> _ordering = "nameAsc"
|
||||
1 -> _ordering = "nameDesc"
|
||||
2 -> _ordering = "dateEditAsc"
|
||||
3 -> _ordering = "dateEditDesc"
|
||||
4 -> _ordering = "dateCreateAsc"
|
||||
5 -> _ordering = "dateCreateDesc"
|
||||
6 -> _ordering = "datePlayAsc"
|
||||
7 -> _ordering = "datePlayDesc"
|
||||
else -> _ordering = null
|
||||
}
|
||||
updatePlaylistsFiltering()
|
||||
}
|
||||
override fun onNothingSelected(parent: AdapterView<*>?) = Unit
|
||||
};
|
||||
spinnerSortBy.setSelection(Math.max(0, options.indexOf(_ordering.value)));
|
||||
|
||||
|
||||
findViewById<TextView>(R.id.text_view_all).setOnClickListener { _fragment.navigate<WatchLaterFragment>(context.getString(R.string.watch_later)); };
|
||||
|
|
@ -217,8 +214,8 @@ class PlaylistsFragment : MainFragment() {
|
|||
var playlistsToReturn = pls;
|
||||
if(!_listPlaylistsSearch.text.isNullOrEmpty())
|
||||
playlistsToReturn = playlistsToReturn.filter { it.name.contains(_listPlaylistsSearch.text, true) };
|
||||
if(!_ordering.value.isNullOrEmpty()){
|
||||
playlistsToReturn = when(_ordering.value){
|
||||
if(!_ordering.isNullOrEmpty()){
|
||||
playlistsToReturn = when(_ordering){
|
||||
"nameAsc" -> playlistsToReturn.sortedBy { it.name.lowercase() }
|
||||
"nameDesc" -> playlistsToReturn.sortedByDescending { it.name.lowercase() };
|
||||
"dateEditAsc" -> playlistsToReturn.sortedBy { it.dateUpdate ?: OffsetDateTime.MAX };
|
||||
|
|
|
|||
|
|
@ -18,7 +18,6 @@ import com.futo.platformplayer.constructs.TaskHandler
|
|||
import com.futo.platformplayer.engine.exceptions.PluginException
|
||||
import com.futo.platformplayer.exceptions.ChannelException
|
||||
import com.futo.platformplayer.exceptions.RateLimitException
|
||||
import com.futo.platformplayer.fragment.mainactivity.main.SubscriptionsFeedFragment.SubscriptionsFeedView.FeedFilterSettings
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.models.SearchType
|
||||
import com.futo.platformplayer.models.SubscriptionGroup
|
||||
|
|
@ -57,9 +56,6 @@ class SubscriptionsFeedFragment : MainFragment() {
|
|||
private var _group: SubscriptionGroup? = null;
|
||||
private var _cachedRecyclerData: FeedView.RecyclerData<InsertedViewAdapterWithLoader<ContentPreviewViewHolder>, GridLayoutManager, IPager<IPlatformContent>, IPlatformContent, IPlatformContent, InsertedViewHolder<ContentPreviewViewHolder>>? = null;
|
||||
|
||||
private val _filterLock = Object();
|
||||
private val _filterSettings = FragmentedStorage.get<FeedFilterSettings>("subFeedFilter");
|
||||
|
||||
override fun onShownWithView(parameter: Any?, isBack: Boolean) {
|
||||
super.onShownWithView(parameter, isBack);
|
||||
_view?.onShown();
|
||||
|
|
@ -188,6 +184,8 @@ class SubscriptionsFeedFragment : MainFragment() {
|
|||
return Json.encodeToString(this);
|
||||
}
|
||||
}
|
||||
private val _filterLock = Object();
|
||||
private val _filterSettings = FragmentedStorage.get<FeedFilterSettings>("subFeedFilter");
|
||||
|
||||
private var _bypassRateLimit = false;
|
||||
private val _lastExceptions: List<Throwable>? = null;
|
||||
|
|
@ -286,18 +284,13 @@ class SubscriptionsFeedFragment : MainFragment() {
|
|||
fragment.navigate<SubscriptionGroupFragment>(g);
|
||||
};
|
||||
|
||||
synchronized(fragment._filterLock) {
|
||||
synchronized(_filterLock) {
|
||||
_subscriptionBar?.setToggles(
|
||||
SubscriptionBar.Toggle(context.getString(R.string.videos), fragment._filterSettings.allowContentTypes.contains(ContentType.MEDIA)) { view, active ->
|
||||
toggleFilterContentTypes(listOf(ContentType.MEDIA, ContentType.NESTED_VIDEO), active); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.posts), fragment._filterSettings.allowContentTypes.contains(ContentType.POST)) { view, active ->
|
||||
toggleFilterContentType(ContentType.POST, active); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.live), fragment._filterSettings.allowLive) { view, active ->
|
||||
fragment._filterSettings.allowLive = active; fragment._filterSettings.save(); loadResults(false); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.planned), fragment._filterSettings.allowPlanned) { view, active ->
|
||||
fragment._filterSettings.allowPlanned = active; fragment._filterSettings.save(); loadResults(false); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.watched), fragment._filterSettings.allowWatched) { view, active ->
|
||||
fragment._filterSettings.allowWatched = active; fragment._filterSettings.save(); loadResults(false); }
|
||||
SubscriptionBar.Toggle(context.getString(R.string.videos), _filterSettings.allowContentTypes.contains(ContentType.MEDIA)) { toggleFilterContentTypes(listOf(ContentType.MEDIA, ContentType.NESTED_VIDEO), it); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.posts), _filterSettings.allowContentTypes.contains(ContentType.POST)) { toggleFilterContentType(ContentType.POST, it); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.live), _filterSettings.allowLive) { _filterSettings.allowLive = it; _filterSettings.save(); loadResults(false); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.planned), _filterSettings.allowPlanned) { _filterSettings.allowPlanned = it; _filterSettings.save(); loadResults(false); },
|
||||
SubscriptionBar.Toggle(context.getString(R.string.watched), _filterSettings.allowWatched) { _filterSettings.allowWatched = it; _filterSettings.save(); loadResults(false); }
|
||||
);
|
||||
}
|
||||
|
||||
|
|
@ -308,13 +301,13 @@ class SubscriptionsFeedFragment : MainFragment() {
|
|||
toggleFilterContentType(contentType, isTrue);
|
||||
}
|
||||
private fun toggleFilterContentType(contentType: ContentType, isTrue: Boolean) {
|
||||
synchronized(fragment._filterLock) {
|
||||
synchronized(_filterLock) {
|
||||
if(!isTrue) {
|
||||
fragment._filterSettings.allowContentTypes.remove(contentType);
|
||||
} else if(!fragment._filterSettings.allowContentTypes.contains(contentType)) {
|
||||
fragment._filterSettings.allowContentTypes.add(contentType)
|
||||
_filterSettings.allowContentTypes.remove(contentType);
|
||||
} else if(!_filterSettings.allowContentTypes.contains(contentType)) {
|
||||
_filterSettings.allowContentTypes.add(contentType)
|
||||
}
|
||||
fragment._filterSettings.save();
|
||||
_filterSettings.save();
|
||||
};
|
||||
if(Settings.instance.subscriptions.fetchOnTabOpen) { //TODO: Do this different, temporary workaround
|
||||
loadResults(false);
|
||||
|
|
@ -327,9 +320,9 @@ class SubscriptionsFeedFragment : MainFragment() {
|
|||
val nowSoon = OffsetDateTime.now().plusMinutes(5);
|
||||
val filterGroup = subGroup;
|
||||
return results.filter {
|
||||
val allowedContentType = fragment._filterSettings.allowContentTypes.contains(if(it.contentType == ContentType.NESTED_VIDEO || it.contentType == ContentType.LOCKED) ContentType.MEDIA else it.contentType);
|
||||
val allowedContentType = _filterSettings.allowContentTypes.contains(if(it.contentType == ContentType.NESTED_VIDEO || it.contentType == ContentType.LOCKED) ContentType.MEDIA else it.contentType);
|
||||
|
||||
if(it is IPlatformVideo && it.duration > 0 && !fragment._filterSettings.allowWatched && StateHistory.instance.isHistoryWatched(it.url, it.duration))
|
||||
if(it is IPlatformVideo && it.duration > 0 && !_filterSettings.allowWatched && StateHistory.instance.isHistoryWatched(it.url, it.duration))
|
||||
return@filter false;
|
||||
|
||||
//TODO: Check against a sub cache
|
||||
|
|
@ -338,11 +331,11 @@ class SubscriptionsFeedFragment : MainFragment() {
|
|||
|
||||
|
||||
if(it.datetime?.isAfter(nowSoon) == true) {
|
||||
if(!fragment._filterSettings.allowPlanned)
|
||||
if(!_filterSettings.allowPlanned)
|
||||
return@filter false;
|
||||
}
|
||||
|
||||
if(fragment._filterSettings.allowLive) { //If allowLive, always show live
|
||||
if(_filterSettings.allowLive) { //If allowLive, always show live
|
||||
if(it is IPlatformVideo && it.isLive)
|
||||
return@filter true;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -693,9 +693,6 @@ class VideoDetailView : ConstraintLayout {
|
|||
_container_content_description.onClose.subscribe { switchContentView(_container_content_main); };
|
||||
_container_content_liveChat.onClose.subscribe { switchContentView(_container_content_main); };
|
||||
_container_content_queue.onClose.subscribe { switchContentView(_container_content_main); };
|
||||
_container_content_queue.onOptions.subscribe {
|
||||
UISlideOverlays.showVideoOptionsOverlay(it, _overlayContainer);
|
||||
}
|
||||
_container_content_replies.onClose.subscribe { switchContentView(_container_content_main); };
|
||||
_container_content_support.onClose.subscribe { switchContentView(_container_content_main); };
|
||||
_container_content_browser.onClose.subscribe { switchContentView(_container_content_main); };
|
||||
|
|
|
|||
|
|
@ -1,11 +1,9 @@
|
|||
package com.futo.platformplayer.fragment.mainactivity.main
|
||||
|
||||
import android.content.Context
|
||||
import android.graphics.drawable.Animatable
|
||||
import android.util.TypedValue
|
||||
import android.view.LayoutInflater
|
||||
import android.view.View
|
||||
import android.view.inputmethod.InputMethodManager
|
||||
import android.widget.FrameLayout
|
||||
import android.widget.ImageButton
|
||||
import android.widget.ImageView
|
||||
|
|
@ -50,11 +48,6 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
private var _loadedVideos: List<IPlatformVideo>? = null;
|
||||
private var _loadedVideosCanEdit: Boolean = false;
|
||||
|
||||
fun hideSearchKeyboard() {
|
||||
(context?.getSystemService(Context.INPUT_METHOD_SERVICE) as? InputMethodManager)?.hideSoftInputFromWindow(_search.textSearch.windowToken, 0)
|
||||
_search.textSearch.clearFocus();
|
||||
}
|
||||
|
||||
constructor(inflater: LayoutInflater) : super(inflater.context) {
|
||||
inflater.inflate(R.layout.fragment_video_list_editor, this);
|
||||
|
||||
|
|
@ -86,7 +79,6 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
_search.textSearch.text = "";
|
||||
updateVideoFilters();
|
||||
_buttonSearch.setImageResource(R.drawable.ic_search);
|
||||
hideSearchKeyboard();
|
||||
}
|
||||
else {
|
||||
_search.visibility = View.VISIBLE;
|
||||
|
|
@ -97,23 +89,22 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
_buttonShare = findViewById(R.id.button_share);
|
||||
val onShare = _onShare;
|
||||
if(onShare != null) {
|
||||
_buttonShare.setOnClickListener { hideSearchKeyboard(); onShare.invoke() };
|
||||
_buttonShare.setOnClickListener { onShare.invoke() };
|
||||
_buttonShare.visibility = View.VISIBLE;
|
||||
}
|
||||
else
|
||||
_buttonShare.visibility = View.GONE;
|
||||
|
||||
buttonPlayAll.setOnClickListener { hideSearchKeyboard();onPlayAllClick(); hideSearchKeyboard(); };
|
||||
buttonShuffle.setOnClickListener { hideSearchKeyboard();onShuffleClick(); hideSearchKeyboard(); };
|
||||
buttonPlayAll.setOnClickListener { onPlayAllClick(); };
|
||||
buttonShuffle.setOnClickListener { onShuffleClick(); };
|
||||
|
||||
_buttonEdit.setOnClickListener { hideSearchKeyboard(); onEditClick(); };
|
||||
_buttonEdit.setOnClickListener { onEditClick(); };
|
||||
setButtonExportVisible(false);
|
||||
setButtonDownloadVisible(canEdit());
|
||||
|
||||
videoListEditorView.onVideoOrderChanged.subscribe(::onVideoOrderChanged);
|
||||
videoListEditorView.onVideoRemoved.subscribe(::onVideoRemoved);
|
||||
videoListEditorView.onVideoOptions.subscribe(::onVideoOptions);
|
||||
videoListEditorView.onVideoClicked.subscribe { hideSearchKeyboard(); onVideoClicked(it)};
|
||||
videoListEditorView.onVideoClicked.subscribe(::onVideoClicked);
|
||||
|
||||
_videoListEditorView = videoListEditorView;
|
||||
}
|
||||
|
|
@ -121,7 +112,6 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
fun setOnShare(onShare: (()-> Unit)? = null) {
|
||||
_onShare = onShare;
|
||||
_buttonShare.setOnClickListener {
|
||||
hideSearchKeyboard();
|
||||
onShare?.invoke();
|
||||
};
|
||||
_buttonShare.visibility = View.VISIBLE;
|
||||
|
|
@ -132,7 +122,6 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
open fun onShuffleClick() { }
|
||||
open fun onEditClick() { }
|
||||
open fun onVideoRemoved(video: IPlatformVideo) {}
|
||||
open fun onVideoOptions(video: IPlatformVideo) {}
|
||||
open fun onVideoOrderChanged(videos : List<IPlatformVideo>) {}
|
||||
open fun onVideoClicked(video: IPlatformVideo) {
|
||||
|
||||
|
|
@ -154,7 +143,7 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
setButtonExportVisible(false);
|
||||
_buttonDownload.setImageResource(R.drawable.ic_loader_animated);
|
||||
_buttonDownload.drawable.assume<Animatable, Unit> { it.start() };
|
||||
_buttonDownload.setOnClickListener { hideSearchKeyboard();
|
||||
_buttonDownload.setOnClickListener {
|
||||
UIDialogs.showConfirmationDialog(context, context.getString(R.string.are_you_sure_you_want_to_delete_the_downloaded_videos), {
|
||||
StateDownloads.instance.deleteCachedPlaylist(playlistId);
|
||||
});
|
||||
|
|
@ -163,7 +152,7 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
else if(isDownloaded) {
|
||||
setButtonExportVisible(true)
|
||||
_buttonDownload.setImageResource(R.drawable.ic_download_off);
|
||||
_buttonDownload.setOnClickListener { hideSearchKeyboard();
|
||||
_buttonDownload.setOnClickListener {
|
||||
UIDialogs.showConfirmationDialog(context, context.getString(R.string.are_you_sure_you_want_to_delete_the_downloaded_videos), {
|
||||
StateDownloads.instance.deleteCachedPlaylist(playlistId);
|
||||
});
|
||||
|
|
@ -172,7 +161,7 @@ abstract class VideoListEditorView : LinearLayout {
|
|||
else {
|
||||
setButtonExportVisible(false);
|
||||
_buttonDownload.setImageResource(R.drawable.ic_download);
|
||||
_buttonDownload.setOnClickListener { hideSearchKeyboard();
|
||||
_buttonDownload.setOnClickListener {
|
||||
onDownload();
|
||||
//UISlideOverlays.showDownloadPlaylistOverlay(playlist, overlayContainer);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -103,9 +103,6 @@ class WatchLaterFragment : MainFragment() {
|
|||
StatePlaylists.instance.removeFromWatchLater(video, true);
|
||||
}
|
||||
}
|
||||
override fun onVideoOptions(video: IPlatformVideo) {
|
||||
UISlideOverlays.showVideoOptionsOverlay(video, overlayContainer);
|
||||
}
|
||||
|
||||
override fun onVideoClicked(video: IPlatformVideo) {
|
||||
val watchLater = StatePlaylists.instance.getWatchLater();
|
||||
|
|
|
|||
|
|
@ -19,10 +19,10 @@ import kotlinx.serialization.json.jsonPrimitive
|
|||
class PlatformContentSerializer : JsonContentPolymorphicSerializer<SerializedPlatformContent>(SerializedPlatformContent::class) {
|
||||
|
||||
override fun selectDeserializer(element: JsonElement): DeserializationStrategy<SerializedPlatformContent> {
|
||||
val obj = element.jsonObject["contentType"] ?: element.jsonObject["ContentType"];
|
||||
val obj = element.jsonObject["contentType"];
|
||||
|
||||
//TODO: Remove this temporary fallback..at some point
|
||||
if(obj == null && (element.jsonObject["isLive"]?.jsonPrimitive?.booleanOrNull ?: element.jsonObject["IsLive"]?.jsonPrimitive?.booleanOrNull) != null)
|
||||
if(obj == null && element.jsonObject["isLive"]?.jsonPrimitive?.booleanOrNull != null)
|
||||
return SerializedPlatformVideo.serializer();
|
||||
|
||||
if(obj?.jsonPrimitive?.isString != false) {
|
||||
|
|
|
|||
|
|
@ -6,60 +6,38 @@ import com.futo.platformplayer.LittleEndianDataInputStream
|
|||
import com.futo.platformplayer.LittleEndianDataOutputStream
|
||||
import com.futo.platformplayer.Settings
|
||||
import com.futo.platformplayer.UIDialogs
|
||||
import com.futo.platformplayer.activities.MainActivity
|
||||
import com.futo.platformplayer.activities.SyncShowPairingCodeActivity
|
||||
import com.futo.platformplayer.api.media.Serializer
|
||||
import com.futo.platformplayer.constructs.Event1
|
||||
import com.futo.platformplayer.constructs.Event2
|
||||
import com.futo.platformplayer.encryption.GEncryptionProvider
|
||||
import com.futo.platformplayer.generateReadablePassword
|
||||
import com.futo.platformplayer.getConnectedSocket
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.mdns.DnsService
|
||||
import com.futo.platformplayer.mdns.ServiceDiscoverer
|
||||
import com.futo.platformplayer.models.HistoryVideo
|
||||
import com.futo.platformplayer.models.Subscription
|
||||
import com.futo.platformplayer.noise.protocol.DHState
|
||||
import com.futo.platformplayer.noise.protocol.Noise
|
||||
import com.futo.platformplayer.smartMerge
|
||||
import com.futo.platformplayer.stores.FragmentedStorage
|
||||
import com.futo.platformplayer.stores.StringStringMapStorage
|
||||
import com.futo.platformplayer.stores.StringArrayStorage
|
||||
import com.futo.platformplayer.stores.StringStorage
|
||||
import com.futo.platformplayer.stores.StringTMapStorage
|
||||
import com.futo.platformplayer.sync.SyncSessionData
|
||||
import com.futo.platformplayer.sync.internal.ChannelSocket
|
||||
import com.futo.platformplayer.sync.internal.GJSyncOpcodes
|
||||
import com.futo.platformplayer.sync.internal.IAuthorizable
|
||||
import com.futo.platformplayer.sync.internal.IChannel
|
||||
import com.futo.platformplayer.sync.internal.LinkType
|
||||
import com.futo.platformplayer.sync.internal.Opcode
|
||||
import com.futo.platformplayer.sync.internal.SyncDeviceInfo
|
||||
import com.futo.platformplayer.sync.internal.SyncKeyPair
|
||||
import com.futo.platformplayer.sync.internal.SyncSession
|
||||
import com.futo.platformplayer.sync.internal.SyncSocketSession
|
||||
import com.futo.platformplayer.sync.models.SendToDevicePackage
|
||||
import com.futo.platformplayer.sync.models.SyncPlaylistsPackage
|
||||
import com.futo.platformplayer.sync.models.SyncSubscriptionGroupsPackage
|
||||
import com.futo.platformplayer.sync.models.SyncSubscriptionsPackage
|
||||
import com.futo.platformplayer.sync.models.SyncWatchLaterPackage
|
||||
import com.futo.polycentric.core.base64ToByteArray
|
||||
import com.futo.polycentric.core.toBase64
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.coroutines.runBlocking
|
||||
import kotlinx.coroutines.withContext
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import java.io.ByteArrayInputStream
|
||||
import java.net.InetAddress
|
||||
import java.net.InetSocketAddress
|
||||
import java.net.ServerSocket
|
||||
import java.net.Socket
|
||||
import java.nio.ByteBuffer
|
||||
import java.time.Instant
|
||||
import java.time.OffsetDateTime
|
||||
import java.time.ZoneOffset
|
||||
import java.util.Base64
|
||||
import java.util.Locale
|
||||
import kotlin.system.measureTimeMillis
|
||||
|
|
@ -81,20 +59,13 @@ class StateSync {
|
|||
//TODO: Should sync mdns and casting mdns be merged?
|
||||
//TODO: Decrease interval that devices are updated
|
||||
//TODO: Send less data
|
||||
private val _serviceDiscoverer = ServiceDiscoverer(arrayOf("_gsync._tcp.local")) { handleServiceUpdated(it) }
|
||||
private val _pairingCode: String? = generateReadablePassword(8)
|
||||
val pairingCode: String? get() = _pairingCode
|
||||
private var _relaySession: SyncSocketSession? = null
|
||||
private var _threadRelay: Thread? = null
|
||||
private val _remotePendingStatusUpdate = mutableMapOf<String, (complete: Boolean?, message: String) -> Unit>()
|
||||
val _serviceDiscoverer = ServiceDiscoverer(arrayOf("_gsync._tcp.local")) { handleServiceUpdated(it) }
|
||||
|
||||
var keyPair: DHState? = null
|
||||
var publicKey: String? = null
|
||||
val deviceRemoved: Event1<String> = Event1()
|
||||
val deviceUpdatedOrAdded: Event2<String, SyncSession> = Event2()
|
||||
|
||||
//TODO: Should authorize acknowledge be implemented?
|
||||
|
||||
fun hasAuthorizedDevice(): Boolean {
|
||||
synchronized(_sessions) {
|
||||
return _sessions.any{ it.value.connected && it.value.isAuthorized };
|
||||
|
|
@ -156,7 +127,10 @@ class StateSync {
|
|||
|
||||
while (_started) {
|
||||
val socket = serverSocket.accept()
|
||||
val session = createSocketSession(socket, true)
|
||||
val session = createSocketSession(socket, true) { session, socketSession ->
|
||||
|
||||
}
|
||||
|
||||
session.startAsResponder()
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
|
|
@ -190,6 +164,8 @@ class StateSync {
|
|||
|
||||
for (connectPair in addressesToConnect) {
|
||||
try {
|
||||
val syncDeviceInfo = SyncDeviceInfo(connectPair.first, arrayOf(connectPair.second), PORT)
|
||||
|
||||
val now = System.currentTimeMillis()
|
||||
val lastConnectTime = synchronized(_lastConnectTimesIp) {
|
||||
_lastConnectTimesIp[connectPair.first] ?: 0
|
||||
|
|
@ -202,7 +178,7 @@ class StateSync {
|
|||
}
|
||||
|
||||
Logger.i(TAG, "Attempting to connect to authorized device by last known IP '${connectPair.first}' with pkey=${connectPair.first}")
|
||||
connect(arrayOf(connectPair.second), PORT, connectPair.first, null)
|
||||
connect(syncDeviceInfo)
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
Logger.i(TAG, "Failed to connect to " + connectPair.first, e)
|
||||
|
|
@ -212,125 +188,6 @@ class StateSync {
|
|||
}
|
||||
}.apply { start() }
|
||||
}
|
||||
|
||||
if (Settings.instance.synchronization.discoverThroughRelay) {
|
||||
_threadRelay = Thread {
|
||||
while (_started) {
|
||||
try {
|
||||
Log.i(TAG, "Starting relay session...")
|
||||
|
||||
var socketClosed = false;
|
||||
val socket = Socket(RELAY_SERVER, 9000)
|
||||
_relaySession = SyncSocketSession(
|
||||
(socket.remoteSocketAddress as InetSocketAddress).address.hostAddress!!,
|
||||
keyPair!!,
|
||||
LittleEndianDataInputStream(socket.getInputStream()),
|
||||
LittleEndianDataOutputStream(socket.getOutputStream()),
|
||||
isHandshakeAllowed = { linkType, syncSocketSession, publicKey, pairingCode -> isHandshakeAllowed(linkType, syncSocketSession, publicKey, pairingCode) },
|
||||
onNewChannel = { _, c ->
|
||||
val remotePublicKey = c.remotePublicKey
|
||||
if (remotePublicKey == null) {
|
||||
Log.e(TAG, "Remote public key should never be null in onNewChannel.")
|
||||
return@SyncSocketSession
|
||||
}
|
||||
|
||||
Log.i(TAG, "New channel established from relay (pk: '$remotePublicKey').")
|
||||
|
||||
var session: SyncSession?
|
||||
synchronized(_sessions) {
|
||||
session = _sessions[remotePublicKey]
|
||||
if (session == null) {
|
||||
val remoteDeviceName = synchronized(_nameStorage) {
|
||||
_nameStorage.get(remotePublicKey)
|
||||
}
|
||||
session = createNewSyncSession(remotePublicKey, remoteDeviceName)
|
||||
_sessions[remotePublicKey] = session!!
|
||||
}
|
||||
session!!.addChannel(c)
|
||||
}
|
||||
|
||||
c.setDataHandler { _, channel, opcode, subOpcode, data ->
|
||||
session?.handlePacket(opcode, subOpcode, data)
|
||||
}
|
||||
c.setCloseHandler { channel ->
|
||||
session?.removeChannel(channel)
|
||||
}
|
||||
},
|
||||
onChannelEstablished = { _, channel, isResponder ->
|
||||
handleAuthorization(channel, isResponder)
|
||||
},
|
||||
onClose = { socketClosed = true },
|
||||
onHandshakeComplete = { relaySession ->
|
||||
Thread {
|
||||
try {
|
||||
while (_started && !socketClosed) {
|
||||
val unconnectedAuthorizedDevices = synchronized(_authorizedDevices) {
|
||||
_authorizedDevices.values.filter { !isConnected(it) }.toTypedArray()
|
||||
}
|
||||
|
||||
relaySession.publishConnectionInformation(unconnectedAuthorizedDevices, PORT, Settings.instance.synchronization.discoverThroughRelay, false, false, Settings.instance.synchronization.discoverThroughRelay && Settings.instance.synchronization.connectThroughRelay)
|
||||
|
||||
val connectionInfos = runBlocking { relaySession.requestBulkConnectionInfo(unconnectedAuthorizedDevices) }
|
||||
|
||||
for ((targetKey, connectionInfo) in connectionInfos) {
|
||||
val potentialLocalAddresses = connectionInfo.ipv4Addresses.union(connectionInfo.ipv6Addresses)
|
||||
.filter { it != connectionInfo.remoteIp }
|
||||
if (connectionInfo.allowLocalDirect) {
|
||||
Thread {
|
||||
try {
|
||||
Log.v(TAG, "Attempting to connect directly, locally to '$targetKey'.")
|
||||
connect(potentialLocalAddresses.map { it }.toTypedArray(), PORT, targetKey, null)
|
||||
} catch (e: Throwable) {
|
||||
Log.e(TAG, "Failed to start direct connection using connection info with $targetKey.", e)
|
||||
}
|
||||
}.start()
|
||||
}
|
||||
|
||||
if (connectionInfo.allowRemoteDirect) {
|
||||
// TODO: Implement direct remote connection if needed
|
||||
}
|
||||
|
||||
if (connectionInfo.allowRemoteHolePunched) {
|
||||
// TODO: Implement hole punching if needed
|
||||
}
|
||||
|
||||
if (connectionInfo.allowRemoteRelayed && Settings.instance.synchronization.connectThroughRelay) {
|
||||
try {
|
||||
Log.v(TAG, "Attempting relayed connection with '$targetKey'.")
|
||||
runBlocking { relaySession.startRelayedChannel(targetKey, null) }
|
||||
} catch (e: Throwable) {
|
||||
Log.e(TAG, "Failed to start relayed channel with $targetKey.", e)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Thread.sleep(15000)
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
Log.e(TAG, "Unhandled exception in relay session.", e)
|
||||
relaySession.stop()
|
||||
}
|
||||
}.start()
|
||||
}
|
||||
)
|
||||
|
||||
_relaySession!!.authorizable = object : IAuthorizable {
|
||||
override val isAuthorized: Boolean get() = true
|
||||
}
|
||||
|
||||
_relaySession!!.startAsInitiator(RELAY_PUBLIC_KEY, null)
|
||||
|
||||
Log.i(TAG, "Started relay session.")
|
||||
} catch (e: Throwable) {
|
||||
Log.e(TAG, "Relay session failed.", e)
|
||||
Thread.sleep(5000)
|
||||
} finally {
|
||||
_relaySession?.stop()
|
||||
_relaySession = null
|
||||
}
|
||||
}
|
||||
}.apply { start() }
|
||||
}
|
||||
}
|
||||
|
||||
private fun getDeviceName(): String {
|
||||
|
|
@ -362,14 +219,14 @@ class StateSync {
|
|||
}
|
||||
}
|
||||
fun getSessions(): List<SyncSession> {
|
||||
synchronized(_sessions) {
|
||||
return synchronized(_sessions) {
|
||||
return _sessions.values.toList()
|
||||
}
|
||||
};
|
||||
}
|
||||
fun getAuthorizedSessions(): List<SyncSession> {
|
||||
synchronized(_sessions) {
|
||||
return synchronized(_sessions) {
|
||||
return _sessions.values.filter { it.isAuthorized }.toList()
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
fun getSyncSessionData(key: String): SyncSessionData {
|
||||
|
|
@ -396,7 +253,7 @@ class StateSync {
|
|||
val urlSafePkey = s.texts.firstOrNull { it.startsWith("pk=") }?.substring("pk=".length) ?: continue
|
||||
val pkey = Base64.getEncoder().encodeToString(Base64.getDecoder().decode(urlSafePkey.replace('-', '+').replace('_', '/')))
|
||||
|
||||
val syncDeviceInfo = SyncDeviceInfo(pkey, addresses, port, null)
|
||||
val syncDeviceInfo = SyncDeviceInfo(pkey, addresses, port)
|
||||
val authorized = isAuthorized(pkey)
|
||||
|
||||
if (authorized && !isConnected(pkey)) {
|
||||
|
|
@ -431,342 +288,12 @@ class StateSync {
|
|||
deviceRemoved.emit(remotePublicKey)
|
||||
}
|
||||
|
||||
|
||||
private fun handleSyncSubscriptionPackage(origin: SyncSession, pack: SyncSubscriptionsPackage) {
|
||||
val added = mutableListOf<Subscription>()
|
||||
for(sub in pack.subscriptions) {
|
||||
if(!StateSubscriptions.instance.isSubscribed(sub.channel)) {
|
||||
val removalTime = StateSubscriptions.instance.getSubscriptionRemovalTime(sub.channel.url);
|
||||
if(sub.creationTime > removalTime) {
|
||||
val newSub = StateSubscriptions.instance.addSubscription(sub.channel, sub.creationTime);
|
||||
added.add(newSub);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(added.size > 3)
|
||||
UIDialogs.appToast("${added.size} Subscriptions from ${origin.remotePublicKey.substring(0, Math.min(8, origin.remotePublicKey.length))}");
|
||||
else if(added.size > 0)
|
||||
UIDialogs.appToast("Subscriptions from ${origin.remotePublicKey.substring(0, Math.min(8, origin.remotePublicKey.length))}:\n" +
|
||||
added.map { it.channel.name }.joinToString("\n"));
|
||||
|
||||
|
||||
if(pack.subscriptions.isNotEmpty()) {
|
||||
for (subRemoved in pack.subscriptionRemovals) {
|
||||
val removed = StateSubscriptions.instance.applySubscriptionRemovals(pack.subscriptionRemovals);
|
||||
if(removed.size > 3) {
|
||||
UIDialogs.appToast("Removed ${removed.size} Subscriptions from ${origin.remotePublicKey.substring(0, 8.coerceAtMost(origin.remotePublicKey.length))}");
|
||||
} else if(removed.isNotEmpty()) {
|
||||
UIDialogs.appToast("Subscriptions removed from ${origin.remotePublicKey.substring(0, 8.coerceAtMost(origin.remotePublicKey.length))}:\n" + removed.map { it.channel.name }.joinToString("\n"));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun handleData(session: SyncSession, opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
|
||||
val remotePublicKey = session.remotePublicKey
|
||||
when (subOpcode) {
|
||||
GJSyncOpcodes.sendToDevices -> {
|
||||
StateApp.instance.scopeOrNull?.launch(Dispatchers.Main) {
|
||||
val context = StateApp.instance.contextOrNull;
|
||||
if (context != null && context is MainActivity) {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
val remainder = data.remaining();
|
||||
data.get(dataBody, 0, remainder);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val obj = Json.decodeFromString<SendToDevicePackage>(json);
|
||||
UIDialogs.appToast("Received url from device [${session.remotePublicKey}]:\n{${obj.url}");
|
||||
context.handleUrl(obj.url, obj.position);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncStateExchange -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val syncSessionData = Serializer.json.decodeFromString<SyncSessionData>(json);
|
||||
|
||||
Logger.i(TAG, "Received SyncSessionData from $remotePublicKey");
|
||||
|
||||
|
||||
session.sendData(GJSyncOpcodes.syncSubscriptions, StateSubscriptions.instance.getSyncSubscriptionsPackageString());
|
||||
session.sendData(GJSyncOpcodes.syncSubscriptionGroups, StateSubscriptionGroups.instance.getSyncSubscriptionGroupsPackageString());
|
||||
session.sendData(GJSyncOpcodes.syncPlaylists, StatePlaylists.instance.getSyncPlaylistsPackageString())
|
||||
|
||||
session.sendData(GJSyncOpcodes.syncWatchLater, Json.encodeToString(StatePlaylists.instance.getWatchLaterSyncPacket(false)));
|
||||
|
||||
val recentHistory = StateHistory.instance.getRecentHistory(syncSessionData.lastHistory);
|
||||
if(recentHistory.isNotEmpty())
|
||||
session.sendJsonData(GJSyncOpcodes.syncHistory, recentHistory);
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncExport -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
val bytesStr = ByteArrayInputStream(data.array(), data.position(), data.remaining());
|
||||
bytesStr.use { bytesStrBytes ->
|
||||
val exportStruct = StateBackup.ExportStructure.fromZipBytes(bytesStrBytes);
|
||||
for (store in exportStruct.stores) {
|
||||
if (store.key.equals("subscriptions", true)) {
|
||||
val subStore =
|
||||
StateSubscriptions.instance.getUnderlyingSubscriptionsStore();
|
||||
StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
|
||||
val pack = SyncSubscriptionsPackage(
|
||||
store.value.map {
|
||||
subStore.fromReconstruction(it, exportStruct.cache)
|
||||
},
|
||||
StateSubscriptions.instance.getSubscriptionRemovals()
|
||||
);
|
||||
handleSyncSubscriptionPackage(session, pack);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncSubscriptions -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val subPackage = Serializer.json.decodeFromString<SyncSubscriptionsPackage>(json);
|
||||
handleSyncSubscriptionPackage(session, subPackage);
|
||||
|
||||
val newestSub = subPackage.subscriptions.maxOf { it.creationTime };
|
||||
|
||||
val sesData = getSyncSessionData(remotePublicKey);
|
||||
if(newestSub > sesData.lastSubscription) {
|
||||
sesData.lastSubscription = newestSub;
|
||||
saveSyncSessionData(sesData);
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncSubscriptionGroups -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val pack = Serializer.json.decodeFromString<SyncSubscriptionGroupsPackage>(json);
|
||||
|
||||
var lastSubgroupChange = OffsetDateTime.MIN;
|
||||
for(group in pack.groups){
|
||||
if(group.lastChange > lastSubgroupChange)
|
||||
lastSubgroupChange = group.lastChange;
|
||||
|
||||
val existing = StateSubscriptionGroups.instance.getSubscriptionGroup(group.id);
|
||||
|
||||
if(existing == null)
|
||||
StateSubscriptionGroups.instance.updateSubscriptionGroup(group, false, true);
|
||||
else if(existing.lastChange < group.lastChange) {
|
||||
existing.name = group.name;
|
||||
existing.urls = group.urls;
|
||||
existing.image = group.image;
|
||||
existing.priority = group.priority;
|
||||
existing.lastChange = group.lastChange;
|
||||
StateSubscriptionGroups.instance.updateSubscriptionGroup(existing, false, true);
|
||||
}
|
||||
}
|
||||
for(removal in pack.groupRemovals) {
|
||||
val creation = StateSubscriptionGroups.instance.getSubscriptionGroup(removal.key);
|
||||
val removalTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(removal.value, 0), ZoneOffset.UTC);
|
||||
if(creation != null && creation.creationTime < removalTime)
|
||||
StateSubscriptionGroups.instance.deleteSubscriptionGroup(removal.key, false);
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncPlaylists -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val pack = Serializer.json.decodeFromString<SyncPlaylistsPackage>(json);
|
||||
|
||||
for(playlist in pack.playlists) {
|
||||
val existing = StatePlaylists.instance.getPlaylist(playlist.id);
|
||||
|
||||
if(existing == null)
|
||||
StatePlaylists.instance.createOrUpdatePlaylist(playlist, false);
|
||||
else if(existing.dateUpdate.toLocalDateTime() < playlist.dateUpdate.toLocalDateTime()) {
|
||||
existing.dateUpdate = playlist.dateUpdate;
|
||||
existing.name = playlist.name;
|
||||
existing.videos = playlist.videos;
|
||||
existing.dateCreation = playlist.dateCreation;
|
||||
existing.datePlayed = playlist.datePlayed;
|
||||
StatePlaylists.instance.createOrUpdatePlaylist(existing, false);
|
||||
}
|
||||
}
|
||||
for(removal in pack.playlistRemovals) {
|
||||
val creation = StatePlaylists.instance.getPlaylist(removal.key);
|
||||
val removalTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(removal.value, 0), ZoneOffset.UTC);
|
||||
if(creation != null && creation.dateCreation < removalTime)
|
||||
StatePlaylists.instance.removePlaylist(creation, false);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncWatchLater -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val pack = Serializer.json.decodeFromString<SyncWatchLaterPackage>(json);
|
||||
|
||||
Logger.i(TAG, "SyncWatchLater received ${pack.videos.size} (${pack.videoAdds?.size}, ${pack.videoRemovals?.size})");
|
||||
|
||||
val allExisting = StatePlaylists.instance.getWatchLater();
|
||||
for(video in pack.videos) {
|
||||
val existing = allExisting.firstOrNull { it.url == video.url };
|
||||
val time = if(pack.videoAdds != null && pack.videoAdds.containsKey(video.url)) OffsetDateTime.ofInstant(Instant.ofEpochSecond(pack.videoAdds[video.url] ?: 0), ZoneOffset.UTC) else OffsetDateTime.MIN;
|
||||
|
||||
if(existing == null) {
|
||||
StatePlaylists.instance.addToWatchLater(video, false);
|
||||
if(time > OffsetDateTime.MIN)
|
||||
StatePlaylists.instance.setWatchLaterAddTime(video.url, time);
|
||||
}
|
||||
}
|
||||
for(removal in pack.videoRemovals) {
|
||||
val watchLater = allExisting.firstOrNull { it.url == removal.key } ?: continue;
|
||||
val creation = StatePlaylists.instance.getWatchLaterRemovalTime(watchLater.url) ?: OffsetDateTime.MIN;
|
||||
val removalTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(removal.value), ZoneOffset.UTC);
|
||||
if(creation < removalTime)
|
||||
StatePlaylists.instance.removeFromWatchLater(watchLater, false, removalTime);
|
||||
}
|
||||
|
||||
val packReorderTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pack.reorderTime), ZoneOffset.UTC);
|
||||
val localReorderTime = StatePlaylists.instance.getWatchLaterLastReorderTime();
|
||||
if(localReorderTime < packReorderTime && pack.ordering != null) {
|
||||
StatePlaylists.instance.updateWatchLaterOrdering(smartMerge(pack.ordering!!, StatePlaylists.instance.getWatchLaterOrdering()), true);
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncHistory -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val history = Serializer.json.decodeFromString<List<HistoryVideo>>(json);
|
||||
Logger.i(TAG, "SyncHistory received ${history.size} videos from ${remotePublicKey}");
|
||||
|
||||
var lastHistory = OffsetDateTime.MIN;
|
||||
for(video in history){
|
||||
val hist = StateHistory.instance.getHistoryByVideo(video.video, true, video.date);
|
||||
if(hist != null)
|
||||
StateHistory.instance.updateHistoryPosition(video.video, hist, true, video.position, video.date)
|
||||
if(lastHistory < video.date)
|
||||
lastHistory = video.date;
|
||||
}
|
||||
|
||||
if(lastHistory != OffsetDateTime.MIN && history.size > 1) {
|
||||
val sesData = getSyncSessionData(remotePublicKey);
|
||||
if (lastHistory > sesData.lastHistory) {
|
||||
sesData.lastHistory = lastHistory;
|
||||
saveSyncSessionData(sesData);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private fun onAuthorized(remotePublicKey: String) {
|
||||
synchronized(_remotePendingStatusUpdate) {
|
||||
_remotePendingStatusUpdate.remove(remotePublicKey)?.invoke(true, "Authorized")
|
||||
}
|
||||
}
|
||||
|
||||
private fun onUnuthorized(remotePublicKey: String) {
|
||||
synchronized(_remotePendingStatusUpdate) {
|
||||
_remotePendingStatusUpdate.remove(remotePublicKey)?.invoke(false, "Unauthorized")
|
||||
}
|
||||
}
|
||||
|
||||
private fun createNewSyncSession(remotePublicKey: String, remoteDeviceName: String?): SyncSession {
|
||||
return SyncSession(
|
||||
remotePublicKey,
|
||||
onAuthorized = { it, isNewlyAuthorized, isNewSession ->
|
||||
if (!isNewSession) {
|
||||
return@SyncSession
|
||||
}
|
||||
|
||||
it.remoteDeviceName?.let { remoteDeviceName ->
|
||||
synchronized(_nameStorage) {
|
||||
_nameStorage.setAndSave(remotePublicKey, remoteDeviceName)
|
||||
}
|
||||
}
|
||||
|
||||
Logger.i(TAG, "$remotePublicKey authorized (name: ${it.displayName})")
|
||||
onAuthorized(remotePublicKey)
|
||||
_authorizedDevices.addDistinct(remotePublicKey)
|
||||
_authorizedDevices.save()
|
||||
deviceUpdatedOrAdded.emit(it.remotePublicKey, it)
|
||||
|
||||
checkForSync(it);
|
||||
},
|
||||
onUnauthorized = {
|
||||
unauthorize(remotePublicKey)
|
||||
|
||||
Logger.i(TAG, "$remotePublicKey unauthorized (name: ${it.displayName})")
|
||||
onUnuthorized(remotePublicKey)
|
||||
|
||||
synchronized(_sessions) {
|
||||
it.close()
|
||||
_sessions.remove(remotePublicKey)
|
||||
}
|
||||
},
|
||||
onConnectedChanged = { it, connected ->
|
||||
Logger.i(TAG, "$remotePublicKey connected: $connected")
|
||||
deviceUpdatedOrAdded.emit(it.remotePublicKey, it)
|
||||
},
|
||||
onClose = {
|
||||
Logger.i(TAG, "$remotePublicKey closed")
|
||||
|
||||
synchronized(_sessions)
|
||||
{
|
||||
_sessions.remove(it.remotePublicKey)
|
||||
}
|
||||
|
||||
deviceRemoved.emit(it.remotePublicKey)
|
||||
|
||||
synchronized(_remotePendingStatusUpdate) {
|
||||
_remotePendingStatusUpdate.remove(remotePublicKey)?.invoke(false, "Connection closed")
|
||||
}
|
||||
},
|
||||
dataHandler = { it, opcode, subOpcode, data ->
|
||||
handleData(it, opcode, subOpcode, data)
|
||||
},
|
||||
remoteDeviceName
|
||||
)
|
||||
}
|
||||
|
||||
private fun isHandshakeAllowed(linkType: LinkType, syncSocketSession: SyncSocketSession, publicKey: String, pairingCode: String?): Boolean {
|
||||
Log.v(TAG, "Check if handshake allowed from '$publicKey'.")
|
||||
if (publicKey == RELAY_PUBLIC_KEY)
|
||||
return true
|
||||
|
||||
synchronized(_authorizedDevices) {
|
||||
if (_authorizedDevices.values.contains(publicKey)) {
|
||||
if (linkType == LinkType.Relayed && !Settings.instance.synchronization.connectThroughRelay)
|
||||
return false
|
||||
return true
|
||||
}
|
||||
}
|
||||
|
||||
Log.v(TAG, "Check if handshake allowed with pairing code '$pairingCode' with active pairing code '$_pairingCode'.")
|
||||
if (_pairingCode == null || pairingCode.isNullOrEmpty())
|
||||
return false
|
||||
|
||||
if (linkType == LinkType.Relayed && !Settings.instance.synchronization.pairThroughRelay)
|
||||
return false
|
||||
|
||||
return _pairingCode == pairingCode
|
||||
}
|
||||
|
||||
private fun createSocketSession(socket: Socket, isResponder: Boolean): SyncSocketSession {
|
||||
private fun createSocketSession(socket: Socket, isResponder: Boolean, onAuthorized: (session: SyncSession, socketSession: SyncSocketSession) -> Unit): SyncSocketSession {
|
||||
var session: SyncSession? = null
|
||||
var channelSocket: ChannelSocket? = null
|
||||
return SyncSocketSession(
|
||||
(socket.remoteSocketAddress as InetSocketAddress).address.hostAddress!!,
|
||||
keyPair!!,
|
||||
LittleEndianDataInputStream(socket.getInputStream()),
|
||||
LittleEndianDataOutputStream(socket.getOutputStream()),
|
||||
return SyncSocketSession((socket.remoteSocketAddress as InetSocketAddress).address.hostAddress!!, keyPair!!, LittleEndianDataInputStream(socket.getInputStream()), LittleEndianDataOutputStream(socket.getOutputStream()),
|
||||
onClose = { s ->
|
||||
if (channelSocket != null)
|
||||
session?.removeChannel(channelSocket!!)
|
||||
session?.removeSocketSession(s)
|
||||
},
|
||||
isHandshakeAllowed = { linkType, syncSocketSession, publicKey, pairingCode -> isHandshakeAllowed(linkType, syncSocketSession, publicKey, pairingCode) },
|
||||
onHandshakeComplete = { s ->
|
||||
val remotePublicKey = s.remotePublicKey
|
||||
if (remotePublicKey == null) {
|
||||
|
|
@ -776,8 +303,6 @@ class StateSync {
|
|||
|
||||
Logger.i(TAG, "Handshake complete with (LocalPublicKey = ${s.localPublicKey}, RemotePublicKey = ${s.remotePublicKey})")
|
||||
|
||||
channelSocket = ChannelSocket(s)
|
||||
|
||||
synchronized(_sessions) {
|
||||
session = _sessions[s.remotePublicKey]
|
||||
if (session == null) {
|
||||
|
|
@ -785,99 +310,126 @@ class StateSync {
|
|||
_nameStorage.get(remotePublicKey)
|
||||
}
|
||||
|
||||
synchronized(_lastAddressStorage) {
|
||||
_lastAddressStorage.setAndSave(remotePublicKey, s.remoteAddress)
|
||||
}
|
||||
session = SyncSession(remotePublicKey, onAuthorized = { it, isNewlyAuthorized, isNewSession ->
|
||||
if (!isNewSession) {
|
||||
return@SyncSession
|
||||
}
|
||||
|
||||
session = createNewSyncSession(remotePublicKey, remoteDeviceName)
|
||||
_sessions[remotePublicKey] = session!!
|
||||
}
|
||||
session!!.addChannel(channelSocket!!)
|
||||
}
|
||||
|
||||
handleAuthorization(channelSocket!!, isResponder)
|
||||
},
|
||||
onData = { s, opcode, subOpcode, data ->
|
||||
session?.handlePacket(opcode, subOpcode, data)
|
||||
}
|
||||
)
|
||||
}
|
||||
|
||||
private fun handleAuthorization(channel: IChannel, isResponder: Boolean) {
|
||||
val syncSession = channel.syncSession!!
|
||||
val remotePublicKey = channel.remotePublicKey!!
|
||||
|
||||
if (isResponder) {
|
||||
val isAuthorized = synchronized(_authorizedDevices) {
|
||||
_authorizedDevices.values.contains(remotePublicKey)
|
||||
}
|
||||
|
||||
if (!isAuthorized) {
|
||||
val scope = StateApp.instance.scopeOrNull
|
||||
val activity = SyncShowPairingCodeActivity.activity
|
||||
|
||||
if (scope != null && activity != null) {
|
||||
scope.launch(Dispatchers.Main) {
|
||||
UIDialogs.showConfirmationDialog(activity, "Allow connection from ${remotePublicKey}?",
|
||||
action = {
|
||||
scope.launch(Dispatchers.IO) {
|
||||
try {
|
||||
syncSession.authorize()
|
||||
Logger.i(TAG, "Connection authorized for $remotePublicKey by confirmation")
|
||||
} catch (e: Throwable) {
|
||||
Logger.e(TAG, "Failed to send authorize", e)
|
||||
}
|
||||
}
|
||||
},
|
||||
cancelAction = {
|
||||
scope.launch(Dispatchers.IO) {
|
||||
try {
|
||||
unauthorize(remotePublicKey)
|
||||
} catch (e: Throwable) {
|
||||
Logger.w(TAG, "Failed to send unauthorize", e)
|
||||
}
|
||||
|
||||
syncSession.close()
|
||||
synchronized(_sessions) {
|
||||
_sessions.remove(remotePublicKey)
|
||||
}
|
||||
it.remoteDeviceName?.let { remoteDeviceName ->
|
||||
synchronized(_nameStorage) {
|
||||
_nameStorage.setAndSave(remotePublicKey, remoteDeviceName)
|
||||
}
|
||||
}
|
||||
)
|
||||
|
||||
Logger.i(TAG, "${s.remotePublicKey} authorized (name: ${it.displayName})")
|
||||
synchronized(_lastAddressStorage) {
|
||||
_lastAddressStorage.setAndSave(remotePublicKey, s.remoteAddress)
|
||||
}
|
||||
|
||||
onAuthorized(it, s)
|
||||
_authorizedDevices.addDistinct(remotePublicKey)
|
||||
_authorizedDevices.save()
|
||||
deviceUpdatedOrAdded.emit(it.remotePublicKey, session!!)
|
||||
|
||||
checkForSync(it);
|
||||
}, onUnauthorized = {
|
||||
unauthorize(remotePublicKey)
|
||||
|
||||
synchronized(_sessions) {
|
||||
session?.close()
|
||||
_sessions.remove(remotePublicKey)
|
||||
}
|
||||
}, onConnectedChanged = { it, connected ->
|
||||
Logger.i(TAG, "${s.remotePublicKey} connected: " + connected)
|
||||
deviceUpdatedOrAdded.emit(it.remotePublicKey, session!!)
|
||||
}, onClose = {
|
||||
Logger.i(TAG, "${s.remotePublicKey} closed")
|
||||
|
||||
synchronized(_sessions)
|
||||
{
|
||||
_sessions.remove(it.remotePublicKey)
|
||||
}
|
||||
|
||||
deviceRemoved.emit(it.remotePublicKey)
|
||||
|
||||
}, remoteDeviceName)
|
||||
_sessions[remotePublicKey] = session!!
|
||||
}
|
||||
session!!.addSocketSession(s)
|
||||
}
|
||||
|
||||
if (isResponder) {
|
||||
val isAuthorized = synchronized(_authorizedDevices) {
|
||||
_authorizedDevices.values.contains(remotePublicKey)
|
||||
}
|
||||
|
||||
if (!isAuthorized) {
|
||||
val scope = StateApp.instance.scopeOrNull
|
||||
val activity = SyncShowPairingCodeActivity.activity
|
||||
|
||||
if (scope != null && activity != null) {
|
||||
scope.launch(Dispatchers.Main) {
|
||||
UIDialogs.showConfirmationDialog(activity, "Allow connection from ${remotePublicKey}?", action = {
|
||||
scope.launch(Dispatchers.IO) {
|
||||
try {
|
||||
session!!.authorize(s)
|
||||
Logger.i(TAG, "Connection authorized for $remotePublicKey by confirmation")
|
||||
} catch (e: Throwable) {
|
||||
Logger.e(TAG, "Failed to send authorize", e)
|
||||
}
|
||||
}
|
||||
}, cancelAction = {
|
||||
scope.launch(Dispatchers.IO) {
|
||||
try {
|
||||
unauthorize(remotePublicKey)
|
||||
} catch (e: Throwable) {
|
||||
Logger.w(TAG, "Failed to send unauthorize", e)
|
||||
}
|
||||
|
||||
synchronized(_sessions) {
|
||||
session?.close()
|
||||
_sessions.remove(remotePublicKey)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
} else {
|
||||
val publicKey = session!!.remotePublicKey
|
||||
session!!.unauthorize(s)
|
||||
session!!.close()
|
||||
|
||||
synchronized(_sessions) {
|
||||
_sessions.remove(publicKey)
|
||||
}
|
||||
|
||||
Logger.i(TAG, "Connection unauthorized for ${remotePublicKey} because not authorized and not on pairing activity to ask")
|
||||
}
|
||||
} else {
|
||||
//Responder does not need to check because already approved
|
||||
session!!.authorize(s)
|
||||
Logger.i(TAG, "Connection authorized for ${remotePublicKey} because already authorized")
|
||||
}
|
||||
} else {
|
||||
val publicKey = syncSession.remotePublicKey
|
||||
syncSession.unauthorize()
|
||||
syncSession.close()
|
||||
|
||||
synchronized(_sessions) {
|
||||
_sessions.remove(publicKey)
|
||||
}
|
||||
|
||||
Logger.i(TAG, "Connection unauthorized for $remotePublicKey because not authorized and not on pairing activity to ask")
|
||||
//Initiator does not need to check because the manual action of scanning the QR counts as approval
|
||||
session!!.authorize(s)
|
||||
Logger.i(TAG, "Connection authorized for ${remotePublicKey} because initiator")
|
||||
}
|
||||
} else {
|
||||
//Responder does not need to check because already approved
|
||||
syncSession.authorize()
|
||||
Logger.i(TAG, "Connection authorized for $remotePublicKey because already authorized")
|
||||
}
|
||||
} else {
|
||||
//Initiator does not need to check because the manual action of scanning the QR counts as approval
|
||||
syncSession.authorize()
|
||||
Logger.i(TAG, "Connection authorized for $remotePublicKey because initiator")
|
||||
}
|
||||
},
|
||||
onData = { s, opcode, subOpcode, data ->
|
||||
session?.handlePacket(s, opcode, subOpcode, data)
|
||||
})
|
||||
}
|
||||
|
||||
inline fun <reified T> broadcastJsonData(subOpcode: UByte, data: T) {
|
||||
broadcast(Opcode.DATA.value, subOpcode, Json.encodeToString(data));
|
||||
broadcast(SyncSocketSession.Opcode.DATA.value, subOpcode, Json.encodeToString(data));
|
||||
}
|
||||
fun broadcastData(subOpcode: UByte, data: String) {
|
||||
broadcast(Opcode.DATA.value, subOpcode, ByteBuffer.wrap(data.toByteArray(Charsets.UTF_8)));
|
||||
broadcast(SyncSocketSession.Opcode.DATA.value, subOpcode, data.toByteArray(Charsets.UTF_8));
|
||||
}
|
||||
fun broadcast(opcode: UByte, subOpcode: UByte, data: String) {
|
||||
broadcast(opcode, subOpcode, ByteBuffer.wrap(data.toByteArray(Charsets.UTF_8)));
|
||||
broadcast(opcode, subOpcode, data.toByteArray(Charsets.UTF_8));
|
||||
}
|
||||
fun broadcast(opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
|
||||
fun broadcast(opcode: UByte, subOpcode: UByte, data: ByteArray) {
|
||||
for(session in getAuthorizedSessions()) {
|
||||
try {
|
||||
session.send(opcode, subOpcode, data);
|
||||
|
|
@ -904,53 +456,21 @@ class StateSync {
|
|||
_serverSocket?.close()
|
||||
_serverSocket = null
|
||||
|
||||
_thread?.interrupt()
|
||||
//_thread?.join()
|
||||
_thread = null
|
||||
_connectThread?.interrupt()
|
||||
_connectThread = null
|
||||
_threadRelay?.interrupt()
|
||||
_threadRelay = null
|
||||
|
||||
_relaySession?.stop()
|
||||
_relaySession = null
|
||||
}
|
||||
|
||||
fun connect(deviceInfo: SyncDeviceInfo, onStatusUpdate: ((complete: Boolean?, message: String) -> Unit)? = null) {
|
||||
try {
|
||||
connect(deviceInfo.addresses, deviceInfo.port, deviceInfo.publicKey, deviceInfo.pairingCode, onStatusUpdate)
|
||||
} catch (e: Throwable) {
|
||||
Logger.e(TAG, "Failed to connect directly", e)
|
||||
val relaySession = _relaySession
|
||||
if (relaySession != null && Settings.instance.synchronization.pairThroughRelay) {
|
||||
onStatusUpdate?.invoke(null, "Connecting via relay...")
|
||||
fun connect(deviceInfo: SyncDeviceInfo, onStatusUpdate: ((session: SyncSocketSession?, complete: Boolean, message: String) -> Unit)? = null): SyncSocketSession {
|
||||
onStatusUpdate?.invoke(null, false, "Connecting...")
|
||||
val socket = getConnectedSocket(deviceInfo.addresses.map { InetAddress.getByName(it) }, deviceInfo.port) ?: throw Exception("Failed to connect")
|
||||
onStatusUpdate?.invoke(null, false, "Handshaking...")
|
||||
|
||||
runBlocking {
|
||||
if (onStatusUpdate != null) {
|
||||
synchronized(_remotePendingStatusUpdate) {
|
||||
_remotePendingStatusUpdate[deviceInfo.publicKey] = onStatusUpdate
|
||||
}
|
||||
}
|
||||
relaySession.startRelayedChannel(deviceInfo.publicKey, deviceInfo.pairingCode)
|
||||
}
|
||||
} else {
|
||||
throw e
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fun connect(addresses: Array<String>, port: Int, publicKey: String, pairingCode: String?, onStatusUpdate: ((complete: Boolean?, message: String) -> Unit)? = null): SyncSocketSession {
|
||||
onStatusUpdate?.invoke(null, "Connecting directly...")
|
||||
val socket = getConnectedSocket(addresses.map { InetAddress.getByName(it) }, port) ?: throw Exception("Failed to connect")
|
||||
onStatusUpdate?.invoke(null, "Handshaking...")
|
||||
|
||||
val session = createSocketSession(socket, false)
|
||||
if (onStatusUpdate != null) {
|
||||
synchronized(_remotePendingStatusUpdate) {
|
||||
_remotePendingStatusUpdate[publicKey] = onStatusUpdate
|
||||
}
|
||||
val session = createSocketSession(socket, false) { _, ss ->
|
||||
onStatusUpdate?.invoke(ss, true, "Handshake complete")
|
||||
}
|
||||
|
||||
session.startAsInitiator(publicKey, pairingCode)
|
||||
session.startAsInitiator(deviceInfo.publicKey)
|
||||
return session
|
||||
}
|
||||
|
||||
|
|
@ -1006,8 +526,6 @@ class StateSync {
|
|||
val hash = "BLAKE2b"
|
||||
var protocolName = "Noise_${pattern}_${dh}_${cipher}_${hash}"
|
||||
val version = 1
|
||||
val RELAY_SERVER = "relay.grayjay.app"
|
||||
val RELAY_PUBLIC_KEY = "xGbHRzDOvE6plRbQaFgSen82eijF+gxS0yeUaeEErkw="
|
||||
|
||||
private const val TAG = "StateSync"
|
||||
const val PORT = 12315
|
||||
|
|
|
|||
|
|
@ -41,19 +41,4 @@ class StringArrayStorage : FragmentedStorageFileJson() {
|
|||
return values.toList();
|
||||
}
|
||||
}
|
||||
fun any(): Boolean {
|
||||
synchronized(values) {
|
||||
return values.any();
|
||||
}
|
||||
}
|
||||
fun contains(v: String): Boolean {
|
||||
synchronized(values) {
|
||||
return values.contains(v);
|
||||
}
|
||||
}
|
||||
fun indexOf(v: String): Int {
|
||||
synchronized(values){
|
||||
return values.indexOf(v);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -15,14 +15,12 @@ import com.futo.platformplayer.api.media.structures.EmptyPager
|
|||
import com.futo.platformplayer.api.media.structures.IPager
|
||||
import com.futo.platformplayer.api.media.structures.MultiChronoContentPager
|
||||
import com.futo.platformplayer.api.media.structures.PlatformContentPager
|
||||
import com.futo.platformplayer.debug.Stopwatch
|
||||
import com.futo.platformplayer.engine.exceptions.PluginException
|
||||
import com.futo.platformplayer.engine.exceptions.ScriptCaptchaRequiredException
|
||||
import com.futo.platformplayer.engine.exceptions.ScriptCriticalException
|
||||
import com.futo.platformplayer.exceptions.ChannelException
|
||||
import com.futo.platformplayer.findNonRuntimeException
|
||||
import com.futo.platformplayer.fragment.mainactivity.main.SubscriptionsFeedFragment
|
||||
import com.futo.platformplayer.getNowDiffMiliseconds
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.models.Subscription
|
||||
import com.futo.platformplayer.states.StateApp
|
||||
|
|
@ -34,8 +32,6 @@ import com.futo.platformplayer.subsexchange.ChannelRequest
|
|||
import com.futo.platformplayer.subsexchange.ChannelResolve
|
||||
import com.futo.platformplayer.subsexchange.ExchangeContract
|
||||
import kotlinx.coroutines.CoroutineScope
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.launch
|
||||
import java.time.OffsetDateTime
|
||||
import java.util.concurrent.ExecutionException
|
||||
import java.util.concurrent.ForkJoinPool
|
||||
|
|
@ -86,30 +82,23 @@ abstract class SubscriptionsTaskFetchAlgorithm(
|
|||
var providedTasks: MutableList<SubscriptionTask>? = null;
|
||||
|
||||
try {
|
||||
val contractingTime = measureTimeMillis {
|
||||
val contractableTasks =
|
||||
tasks.filter { !it.fromPeek && !it.fromCache && (it.type == ResultCapabilities.TYPE_VIDEOS || it.type == ResultCapabilities.TYPE_MIXED) };
|
||||
contract =
|
||||
if (contractableTasks.size > 10) subsExchangeClient?.requestContract(*contractableTasks.map {
|
||||
ChannelRequest(it.url)
|
||||
}.toTypedArray()) else null;
|
||||
if (contract?.provided?.isNotEmpty() == true)
|
||||
Logger.i(TAG, "Received subscription exchange contract (Requires ${contract?.required?.size}, Provides ${contract?.provided?.size}), ID: ${contract?.id}");
|
||||
if (contract != null && contract!!.required.isNotEmpty()) {
|
||||
providedTasks = mutableListOf()
|
||||
for (task in tasks.toList()) {
|
||||
if (!task.fromCache && !task.fromPeek && contract!!.provided.contains(task.url)) {
|
||||
providedTasks!!.add(task);
|
||||
tasks.remove(task);
|
||||
}
|
||||
val contractableTasks =
|
||||
tasks.filter { !it.fromPeek && !it.fromCache && (it.type == ResultCapabilities.TYPE_VIDEOS || it.type == ResultCapabilities.TYPE_MIXED) };
|
||||
contract =
|
||||
if (contractableTasks.size > 10) subsExchangeClient?.requestContract(*contractableTasks.map {
|
||||
ChannelRequest(it.url)
|
||||
}.toTypedArray()) else null;
|
||||
if (contract?.provided?.isNotEmpty() == true)
|
||||
Logger.i(TAG, "Received subscription exchange contract (Requires ${contract?.required?.size}, Provides ${contract?.provided?.size}), ID: ${contract?.id}");
|
||||
if (contract != null && contract.required.isNotEmpty()) {
|
||||
providedTasks = mutableListOf()
|
||||
for (task in tasks.toList()) {
|
||||
if (!task.fromCache && !task.fromPeek && contract.provided.contains(task.url)) {
|
||||
providedTasks.add(task);
|
||||
tasks.remove(task);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(contract != null)
|
||||
Logger.i(TAG, "Subscription Exchange contract received in ${contractingTime}ms");
|
||||
else if(contractingTime > 100)
|
||||
Logger.i(TAG, "Subscription Exchange contract failed to received in${contractingTime}ms");
|
||||
|
||||
}
|
||||
catch(ex: Throwable){
|
||||
Logger.e("SubscriptionsTaskFetchAlgorithm", "Failed to retrieve SubsExchange contract due to: " + ex.message, ex);
|
||||
|
|
@ -120,8 +109,6 @@ abstract class SubscriptionsTaskFetchAlgorithm(
|
|||
val forkTasks = executeSubscriptionTasks(tasks, failedPlugins, cachedChannels);
|
||||
|
||||
val taskResults = arrayListOf<SubscriptionTaskResult>();
|
||||
var resolveCount = 0;
|
||||
var resolveTime = 0L;
|
||||
val timeTotal = measureTimeMillis {
|
||||
for(task in forkTasks) {
|
||||
try {
|
||||
|
|
@ -150,82 +137,50 @@ abstract class SubscriptionsTaskFetchAlgorithm(
|
|||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
//Resolve Subscription Exchange
|
||||
if(contract != null) {
|
||||
fun resolve() {
|
||||
try {
|
||||
resolveTime = measureTimeMillis {
|
||||
val resolves = taskResults.filter { it.pager != null && (it.task.type == ResultCapabilities.TYPE_MIXED || it.task.type == ResultCapabilities.TYPE_VIDEOS) && contract!!.required.contains(it.task.url) }.map {
|
||||
ChannelResolve(
|
||||
it.task.url,
|
||||
it.pager!!.getResults().filter { it is IPlatformVideo }.map { SerializedPlatformVideo.fromVideo(it as IPlatformVideo) }
|
||||
)
|
||||
}.toTypedArray()
|
||||
|
||||
val resolveRequestStart = OffsetDateTime.now();
|
||||
|
||||
val resolve = subsExchangeClient?.resolveContract(
|
||||
contract!!,
|
||||
*resolves
|
||||
);
|
||||
|
||||
Logger.i(TAG, "Subscription Exchange contract resolved request in ${resolveRequestStart.getNowDiffMiliseconds()}ms");
|
||||
|
||||
if (resolve != null) {
|
||||
resolveCount = resolves.size;
|
||||
UIDialogs.appToast("SubsExchange (Res: ${resolves.size}, Prov: ${resolve.size}")
|
||||
for(result in resolve){
|
||||
val task = providedTasks?.find { it.url == result.channelUrl };
|
||||
if(task != null) {
|
||||
taskResults.add(SubscriptionTaskResult(task, PlatformContentPager(result.content, result.content.size), null));
|
||||
providedTasks?.remove(task);
|
||||
}
|
||||
}
|
||||
}
|
||||
if (providedTasks != null) {
|
||||
for(task in providedTasks!!) {
|
||||
taskResults.add(SubscriptionTaskResult(task, null, IllegalStateException("No data received from exchange")));
|
||||
}
|
||||
}
|
||||
//Resolve Subscription Exchange
|
||||
if(contract != null) {
|
||||
try {
|
||||
val resolves = taskResults.filter { it.pager != null && (it.task.type == ResultCapabilities.TYPE_MIXED || it.task.type == ResultCapabilities.TYPE_VIDEOS) && contract.required.contains(it.task.url) }.map {
|
||||
ChannelResolve(
|
||||
it.task.url,
|
||||
it.pager!!.getResults().filter { it is IPlatformVideo }.map { SerializedPlatformVideo.fromVideo(it as IPlatformVideo) }
|
||||
)
|
||||
}.toTypedArray()
|
||||
val resolve = subsExchangeClient?.resolveContract(
|
||||
contract,
|
||||
*resolves
|
||||
);
|
||||
if (resolve != null) {
|
||||
UIDialogs.appToast("SubsExchange (Res: ${resolves.size}, Prov: ${resolve.size})")
|
||||
for(result in resolve){
|
||||
val task = providedTasks?.find { it.url == result.channelUrl };
|
||||
if(task != null) {
|
||||
taskResults.add(SubscriptionTaskResult(task, PlatformContentPager(result.content, result.content.size), null));
|
||||
providedTasks?.remove(task);
|
||||
}
|
||||
Logger.i(TAG, "Subscription Exchange contract resolved in ${resolveTime}ms");
|
||||
|
||||
}
|
||||
catch(ex: Throwable) {
|
||||
//TODO: fetch remainder after all?
|
||||
Logger.e(TAG, "Failed to resolve Subscription Exchange contract due to: " + ex.message, ex);
|
||||
}
|
||||
}
|
||||
if(providedTasks?.size ?: 0 == 0)
|
||||
scope.launch(Dispatchers.IO) {
|
||||
resolve();
|
||||
if (providedTasks != null) {
|
||||
for(task in providedTasks) {
|
||||
taskResults.add(SubscriptionTaskResult(task, null, IllegalStateException("No data received from exchange")));
|
||||
}
|
||||
else
|
||||
resolve();
|
||||
}
|
||||
}
|
||||
catch(ex: Throwable) {
|
||||
//TODO: fetch remainder after all?
|
||||
Logger.e(TAG, "Failed to resolve Subscription Exchange contract due to: " + ex.message, ex);
|
||||
}
|
||||
}
|
||||
|
||||
Logger.i("StateSubscriptions", "Subscriptions results in ${timeTotal}ms");
|
||||
if(resolveCount > 0) {
|
||||
val selfFetchTime = timeTotal - resolveTime;
|
||||
val selfFetchCount = tasks.count { !it.fromPeek && !it.fromCache };
|
||||
if(selfFetchCount > 0) {
|
||||
val selfResolvePercentage = resolveCount.toDouble() / selfFetchCount;
|
||||
val estimateSelfFetchTime = selfFetchTime + selfFetchTime * selfResolvePercentage;
|
||||
val selfFetchDelta = timeTotal - estimateSelfFetchTime;
|
||||
if(selfFetchDelta > 0)
|
||||
UIDialogs.appToast("Subscription Exchange lost ${selfFetchDelta}ms (out of ${timeTotal}ms)", true);
|
||||
else
|
||||
UIDialogs.appToast("Subscription Exchange saved ${(selfFetchDelta * -1).toInt()}ms (out of ${timeTotal}ms)", true);
|
||||
}
|
||||
}
|
||||
Logger.i("StateSubscriptions", "Subscriptions results in ${timeTotal}ms")
|
||||
|
||||
//Cache pagers grouped by channel
|
||||
val groupedPagers = taskResults.groupBy { it.task.sub.channel.url }
|
||||
.map { entry ->
|
||||
val sub = if(!entry.value.isEmpty()) entry.value[0].task.sub else null;
|
||||
val liveTasks = entry.value.filter { !it.task.fromCache && it.pager != null };
|
||||
val liveTasks = entry.value.filter { !it.task.fromCache };
|
||||
val cachedTasks = entry.value.filter { it.task.fromCache };
|
||||
val livePager = if(liveTasks.isNotEmpty()) StateCache.cachePagerResults(scope, MultiChronoContentPager(liveTasks.map { it.pager!! }, true).apply { this.initialize() }) {
|
||||
onNewCacheHit.emit(sub!!, it);
|
||||
|
|
|
|||
|
|
@ -5,7 +5,6 @@ import com.futo.platformplayer.api.media.models.contents.IPlatformContent
|
|||
import com.futo.platformplayer.api.media.models.video.SerializedPlatformContent
|
||||
import com.futo.platformplayer.serializers.OffsetDateTimeNullableSerializer
|
||||
import com.futo.platformplayer.serializers.OffsetDateTimeSerializer
|
||||
import com.futo.platformplayer.serializers.OffsetDateTimeStringSerializer
|
||||
import kotlinx.serialization.SerialName
|
||||
import kotlinx.serialization.Serializable
|
||||
import java.time.OffsetDateTime
|
||||
|
|
@ -13,12 +12,12 @@ import java.time.OffsetDateTime
|
|||
@Serializable
|
||||
class ChannelResult(
|
||||
@kotlinx.serialization.Serializable(with = OffsetDateTimeSerializer::class)
|
||||
@SerialName("dateTime")
|
||||
@SerialName("DateTime")
|
||||
var dateTime: OffsetDateTime,
|
||||
@SerialName("channelUrl")
|
||||
@SerialName("ChannelUrl")
|
||||
var channelUrl: String,
|
||||
@SerialName("content")
|
||||
@SerialName("Content")
|
||||
var content: List<SerializedPlatformContent>,
|
||||
@SerialName("channel")
|
||||
@SerialName("Channel")
|
||||
var channel: IPlatformChannel? = null
|
||||
)
|
||||
|
|
@ -1,14 +1,10 @@
|
|||
import com.futo.platformplayer.api.media.Serializer
|
||||
import com.futo.platformplayer.getNowDiffMiliseconds
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.subscription.SubscriptionFetchAlgorithm.Companion.TAG
|
||||
import com.futo.platformplayer.subsexchange.ChannelRequest
|
||||
import com.futo.platformplayer.subsexchange.ChannelResolve
|
||||
import com.futo.platformplayer.subsexchange.ChannelResult
|
||||
import com.futo.platformplayer.subsexchange.ExchangeContract
|
||||
import com.futo.platformplayer.subsexchange.ExchangeContractResolve
|
||||
import com.futo.platformplayer.toGzip
|
||||
import com.futo.platformplayer.toHumanBytesSize
|
||||
import kotlinx.serialization.*
|
||||
import kotlinx.serialization.json.*
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
|
|
@ -30,10 +26,9 @@ import java.nio.charset.StandardCharsets
|
|||
import java.security.KeyPairGenerator
|
||||
import java.security.spec.PKCS8EncodedKeySpec
|
||||
import java.security.spec.RSAPublicKeySpec
|
||||
import java.time.OffsetDateTime
|
||||
|
||||
|
||||
class SubsExchangeClient(private val server: String, private val privateKey: String, private val contractTimeout: Int = 1000) {
|
||||
class SubsExchangeClient(private val server: String, private val privateKey: String) {
|
||||
|
||||
private val json = Json {
|
||||
ignoreUnknownKeys = true
|
||||
|
|
@ -45,27 +40,23 @@ class SubsExchangeClient(private val server: String, private val privateKey: Str
|
|||
|
||||
// Endpoint: Contract
|
||||
fun requestContract(vararg channels: ChannelRequest): ExchangeContract {
|
||||
val data = post("/api/Channel/Contract", Json.encodeToString(channels).toByteArray(Charsets.UTF_8), "application/json", contractTimeout)
|
||||
val data = post("/api/Channel/Contract", Json.encodeToString(channels), "application/json")
|
||||
return Json.decodeFromString(data)
|
||||
}
|
||||
suspend fun requestContractAsync(vararg channels: ChannelRequest): ExchangeContract {
|
||||
val data = postAsync("/api/Channel/Contract", Json.encodeToString(channels).toByteArray(Charsets.UTF_8), "application/json")
|
||||
val data = postAsync("/api/Channel/Contract", Json.encodeToString(channels), "application/json")
|
||||
return Json.decodeFromString(data)
|
||||
}
|
||||
|
||||
// Endpoint: Resolve
|
||||
fun resolveContract(contract: ExchangeContract, vararg resolves: ChannelResolve): Array<ChannelResult> {
|
||||
val contractResolve = convertResolves(*resolves)
|
||||
val contractResolveJson = Serializer.json.encodeToString(contractResolve);
|
||||
val contractResolveTimeStart = OffsetDateTime.now();
|
||||
val result = post("/api/Channel/Resolve?contractId=${contract.id}", contractResolveJson.toByteArray(Charsets.UTF_8), "application/json", 0, true)
|
||||
val contractResolveTime = contractResolveTimeStart.getNowDiffMiliseconds();
|
||||
Logger.v("SubsExchangeClient", "Subscription Exchange Resolve Request [${contractResolveTime}ms]:" + result);
|
||||
val result = post("/api/Channel/Resolve?contractId=${contract.id}", Serializer.json.encodeToString(contractResolve), "application/json")
|
||||
return Serializer.json.decodeFromString(result)
|
||||
}
|
||||
suspend fun resolveContractAsync(contract: ExchangeContract, vararg resolves: ChannelResolve): Array<ChannelResult> {
|
||||
val contractResolve = convertResolves(*resolves)
|
||||
val result = postAsync("/api/Channel/Resolve?contractId=${contract.id}", Serializer.json.encodeToString(contractResolve).toByteArray(Charsets.UTF_8), "application/json", true)
|
||||
val result = postAsync("/api/Channel/Resolve?contractId=${contract.id}", Serializer.json.encodeToString(contractResolve), "application/json")
|
||||
return Serializer.json.decodeFromString(result)
|
||||
}
|
||||
|
||||
|
|
@ -82,24 +73,13 @@ class SubsExchangeClient(private val server: String, private val privateKey: Str
|
|||
}
|
||||
|
||||
// IO methods
|
||||
private fun post(query: String, body: ByteArray, contentType: String, timeout: Int = 0, gzip: Boolean = false): String {
|
||||
private fun post(query: String, body: String, contentType: String): String {
|
||||
val url = URL("${server.trim('/')}$query")
|
||||
with(url.openConnection() as HttpURLConnection) {
|
||||
if(timeout > 0)
|
||||
this.connectTimeout = timeout
|
||||
requestMethod = "POST"
|
||||
setRequestProperty("Content-Type", contentType)
|
||||
doOutput = true
|
||||
|
||||
|
||||
if(gzip) {
|
||||
val gzipData = body.toGzip();
|
||||
setRequestProperty("Content-Encoding", "gzip");
|
||||
outputStream.write(gzipData);
|
||||
Logger.i("SubsExchangeClient", "SubsExchange using gzip (${body.size.toHumanBytesSize()} => ${gzipData.size.toHumanBytesSize()}");
|
||||
}
|
||||
else
|
||||
outputStream.write(body);
|
||||
OutputStreamWriter(outputStream, StandardCharsets.UTF_8).use { it.write(body); it.flush() }
|
||||
|
||||
val status = responseCode;
|
||||
Logger.i("SubsExchangeClient", "POST [${url}]: ${status}");
|
||||
|
|
@ -122,9 +102,9 @@ class SubsExchangeClient(private val server: String, private val privateKey: Str
|
|||
}
|
||||
}
|
||||
}
|
||||
private suspend fun postAsync(query: String, body: ByteArray, contentType: String, gzip: Boolean = false): String {
|
||||
private suspend fun postAsync(query: String, body: String, contentType: String): String {
|
||||
return withContext(Dispatchers.IO) {
|
||||
post(query, body, contentType, 0, gzip)
|
||||
post(query, body, contentType)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -1,335 +0,0 @@
|
|||
package com.futo.platformplayer.sync.internal
|
||||
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.noise.protocol.CipherStatePair
|
||||
import com.futo.platformplayer.noise.protocol.DHState
|
||||
import com.futo.platformplayer.noise.protocol.HandshakeState
|
||||
import com.futo.platformplayer.states.StateSync
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import java.util.Base64
|
||||
|
||||
interface IChannel : AutoCloseable {
|
||||
val remotePublicKey: String?
|
||||
val remoteVersion: Int?
|
||||
var authorizable: IAuthorizable?
|
||||
var syncSession: SyncSession?
|
||||
fun setDataHandler(onData: ((SyncSocketSession, IChannel, UByte, UByte, ByteBuffer) -> Unit)?)
|
||||
fun send(opcode: UByte, subOpcode: UByte = 0u, data: ByteBuffer? = null)
|
||||
fun setCloseHandler(onClose: ((IChannel) -> Unit)?)
|
||||
val linkType: LinkType
|
||||
}
|
||||
|
||||
class ChannelSocket(private val session: SyncSocketSession) : IChannel {
|
||||
override val remotePublicKey: String? get() = session.remotePublicKey
|
||||
override val remoteVersion: Int? get() = session.remoteVersion
|
||||
private var onData: ((SyncSocketSession, IChannel, UByte, UByte, ByteBuffer) -> Unit)? = null
|
||||
private var onClose: ((IChannel) -> Unit)? = null
|
||||
override val linkType: LinkType get() = LinkType.Direct
|
||||
|
||||
override var authorizable: IAuthorizable?
|
||||
get() = session.authorizable
|
||||
set(value) { session.authorizable = value }
|
||||
override var syncSession: SyncSession? = null
|
||||
|
||||
override fun setDataHandler(onData: ((SyncSocketSession, IChannel, UByte, UByte, ByteBuffer) -> Unit)?) {
|
||||
this.onData = onData
|
||||
}
|
||||
|
||||
override fun setCloseHandler(onClose: ((IChannel) -> Unit)?) {
|
||||
this.onClose = onClose
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
session.stop()
|
||||
onClose?.invoke(this)
|
||||
}
|
||||
|
||||
fun invokeDataHandler(opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
|
||||
onData?.invoke(session, this, opcode, subOpcode, data)
|
||||
}
|
||||
|
||||
override fun send(opcode: UByte, subOpcode: UByte, data: ByteBuffer?) {
|
||||
if (data != null) {
|
||||
session.send(opcode, subOpcode, data)
|
||||
} else {
|
||||
session.send(opcode, subOpcode)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
class ChannelRelayed(
|
||||
private val session: SyncSocketSession,
|
||||
private val localKeyPair: DHState,
|
||||
private val publicKey: String,
|
||||
private val initiator: Boolean
|
||||
) : IChannel {
|
||||
private val sendLock = Object()
|
||||
private val decryptLock = Object()
|
||||
private var handshakeState: HandshakeState? = if (initiator) {
|
||||
HandshakeState(StateSync.protocolName, HandshakeState.INITIATOR).apply {
|
||||
localKeyPair.copyFrom(this@ChannelRelayed.localKeyPair)
|
||||
remotePublicKey.setPublicKey(Base64.getDecoder().decode(publicKey), 0)
|
||||
}
|
||||
} else {
|
||||
HandshakeState(StateSync.protocolName, HandshakeState.RESPONDER).apply {
|
||||
localKeyPair.copyFrom(this@ChannelRelayed.localKeyPair)
|
||||
}
|
||||
}
|
||||
private var transport: CipherStatePair? = null
|
||||
override var authorizable: IAuthorizable? = null
|
||||
val isAuthorized: Boolean get() = authorizable?.isAuthorized ?: false
|
||||
var connectionId: Long = 0L
|
||||
override var remotePublicKey: String? = publicKey
|
||||
private set
|
||||
override var remoteVersion: Int? = null
|
||||
private set
|
||||
override var syncSession: SyncSession? = null
|
||||
override val linkType: LinkType get() = LinkType.Relayed
|
||||
|
||||
private var onData: ((SyncSocketSession, IChannel, UByte, UByte, ByteBuffer) -> Unit)? = null
|
||||
private var onClose: ((IChannel) -> Unit)? = null
|
||||
private var disposed = false
|
||||
|
||||
init {
|
||||
handshakeState?.start()
|
||||
}
|
||||
|
||||
override fun setDataHandler(onData: ((SyncSocketSession, IChannel, UByte, UByte, ByteBuffer) -> Unit)?) {
|
||||
this.onData = onData
|
||||
}
|
||||
|
||||
override fun setCloseHandler(onClose: ((IChannel) -> Unit)?) {
|
||||
this.onClose = onClose
|
||||
}
|
||||
|
||||
override fun close() {
|
||||
disposed = true
|
||||
|
||||
if (connectionId != 0L) {
|
||||
Thread {
|
||||
try {
|
||||
session.sendRelayError(connectionId, SyncErrorCode.ConnectionClosed)
|
||||
} catch (e: Exception) {
|
||||
Logger.e("ChannelRelayed", "Exception while sending relay error", e)
|
||||
}
|
||||
}.start()
|
||||
}
|
||||
|
||||
transport?.sender?.destroy()
|
||||
transport?.receiver?.destroy()
|
||||
transport = null
|
||||
handshakeState?.destroy()
|
||||
handshakeState = null
|
||||
|
||||
onClose?.invoke(this)
|
||||
}
|
||||
|
||||
private fun throwIfDisposed() {
|
||||
if (disposed) throw IllegalStateException("ChannelRelayed is disposed")
|
||||
}
|
||||
|
||||
fun invokeDataHandler(opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
|
||||
onData?.invoke(session, this, opcode, subOpcode, data)
|
||||
}
|
||||
|
||||
private fun completeHandshake(remoteVersion: Int, transport: CipherStatePair) {
|
||||
throwIfDisposed()
|
||||
|
||||
this.remoteVersion = remoteVersion
|
||||
val remoteKeyBytes = ByteArray(handshakeState!!.remotePublicKey.publicKeyLength)
|
||||
handshakeState!!.remotePublicKey.getPublicKey(remoteKeyBytes, 0)
|
||||
this.remotePublicKey = Base64.getEncoder().encodeToString(remoteKeyBytes)
|
||||
handshakeState?.destroy()
|
||||
handshakeState = null
|
||||
this.transport = transport
|
||||
Logger.i("ChannelRelayed", "Completed handshake for connectionId $connectionId")
|
||||
}
|
||||
|
||||
private fun sendPacket(packet: ByteArray) {
|
||||
throwIfDisposed()
|
||||
|
||||
synchronized(sendLock) {
|
||||
val encryptedPayload = ByteArray(packet.size + 16)
|
||||
val encryptedLength = transport!!.sender.encryptWithAd(null, packet, 0, encryptedPayload, 0, packet.size)
|
||||
|
||||
val relayedPacket = ByteArray(8 + encryptedLength)
|
||||
ByteBuffer.wrap(relayedPacket).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putLong(connectionId)
|
||||
put(encryptedPayload, 0, encryptedLength)
|
||||
}
|
||||
|
||||
session.send(Opcode.RELAY.value, RelayOpcode.DATA.value, ByteBuffer.wrap(relayedPacket).order(ByteOrder.LITTLE_ENDIAN))
|
||||
}
|
||||
}
|
||||
|
||||
fun sendError(errorCode: SyncErrorCode) {
|
||||
throwIfDisposed()
|
||||
|
||||
synchronized(sendLock) {
|
||||
val packet = ByteArray(4)
|
||||
ByteBuffer.wrap(packet).order(ByteOrder.LITTLE_ENDIAN).putInt(errorCode.value)
|
||||
|
||||
val encryptedPayload = ByteArray(4 + 16)
|
||||
val encryptedLength = transport!!.sender.encryptWithAd(null, packet, 0, encryptedPayload, 0, packet.size)
|
||||
|
||||
val relayedPacket = ByteArray(8 + encryptedLength)
|
||||
ByteBuffer.wrap(relayedPacket).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putLong(connectionId)
|
||||
put(encryptedPayload, 0, encryptedLength)
|
||||
}
|
||||
|
||||
session.send(Opcode.RELAY.value, RelayOpcode.ERROR.value, ByteBuffer.wrap(relayedPacket))
|
||||
}
|
||||
}
|
||||
|
||||
override fun send(opcode: UByte, subOpcode: UByte, data: ByteBuffer?) {
|
||||
throwIfDisposed()
|
||||
|
||||
val actualCount = data?.remaining() ?: 0
|
||||
val ENCRYPTION_OVERHEAD = 16
|
||||
val CONNECTION_ID_SIZE = 8
|
||||
val HEADER_SIZE = 6
|
||||
val MAX_DATA_PER_PACKET = SyncSocketSession.MAXIMUM_PACKET_SIZE - HEADER_SIZE - CONNECTION_ID_SIZE - ENCRYPTION_OVERHEAD - 16
|
||||
|
||||
if (actualCount > MAX_DATA_PER_PACKET && data != null) {
|
||||
val streamId = session.generateStreamId()
|
||||
val totalSize = actualCount
|
||||
var sendOffset = 0
|
||||
|
||||
while (sendOffset < totalSize) {
|
||||
val bytesRemaining = totalSize - sendOffset
|
||||
val bytesToSend = minOf(MAX_DATA_PER_PACKET - 8 - 2, bytesRemaining)
|
||||
|
||||
val streamData: ByteArray
|
||||
val streamOpcode: StreamOpcode
|
||||
if (sendOffset == 0) {
|
||||
streamOpcode = StreamOpcode.START
|
||||
streamData = ByteArray(4 + 4 + 1 + 1 + bytesToSend)
|
||||
ByteBuffer.wrap(streamData).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putInt(streamId)
|
||||
putInt(totalSize)
|
||||
put(opcode.toByte())
|
||||
put(subOpcode.toByte())
|
||||
put(data.array(), data.position() + sendOffset, bytesToSend)
|
||||
}
|
||||
} else {
|
||||
streamData = ByteArray(4 + 4 + bytesToSend)
|
||||
ByteBuffer.wrap(streamData).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putInt(streamId)
|
||||
putInt(sendOffset)
|
||||
put(data.array(), data.position() + sendOffset, bytesToSend)
|
||||
}
|
||||
streamOpcode = if (bytesToSend < bytesRemaining) StreamOpcode.DATA else StreamOpcode.END
|
||||
}
|
||||
|
||||
val fullPacket = ByteArray(HEADER_SIZE + streamData.size)
|
||||
ByteBuffer.wrap(fullPacket).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putInt(streamData.size + 2)
|
||||
put(Opcode.STREAM.value.toByte())
|
||||
put(streamOpcode.value.toByte())
|
||||
put(streamData)
|
||||
}
|
||||
|
||||
sendPacket(fullPacket)
|
||||
sendOffset += bytesToSend
|
||||
}
|
||||
} else {
|
||||
val packet = ByteArray(HEADER_SIZE + actualCount)
|
||||
ByteBuffer.wrap(packet).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putInt(actualCount + 2)
|
||||
put(opcode.toByte())
|
||||
put(subOpcode.toByte())
|
||||
if (actualCount > 0 && data != null) put(data.array(), data.position(), actualCount)
|
||||
}
|
||||
sendPacket(packet)
|
||||
}
|
||||
}
|
||||
|
||||
fun sendRequestTransport(requestId: Int, publicKey: String, pairingCode: String? = null) {
|
||||
throwIfDisposed()
|
||||
|
||||
synchronized(sendLock) {
|
||||
val channelMessage = ByteArray(1024)
|
||||
val channelBytesWritten = handshakeState!!.writeMessage(channelMessage, 0, null, 0, 0)
|
||||
|
||||
val publicKeyBytes = Base64.getDecoder().decode(publicKey)
|
||||
if (publicKeyBytes.size != 32) throw IllegalArgumentException("Public key must be 32 bytes")
|
||||
|
||||
val (pairingMessageLength, pairingMessage) = if (pairingCode != null) {
|
||||
val pairingHandshake = HandshakeState(SyncSocketSession.nProtocolName, HandshakeState.INITIATOR).apply {
|
||||
remotePublicKey.setPublicKey(publicKeyBytes, 0)
|
||||
start()
|
||||
}
|
||||
val pairingCodeBytes = pairingCode.toByteArray(Charsets.UTF_8)
|
||||
if (pairingCodeBytes.size > 32) throw IllegalArgumentException("Pairing code must not exceed 32 bytes")
|
||||
val pairingMessageBuffer = ByteArray(1024)
|
||||
val bytesWritten = pairingHandshake.writeMessage(pairingMessageBuffer, 0, pairingCodeBytes, 0, pairingCodeBytes.size)
|
||||
bytesWritten to pairingMessageBuffer.copyOf(bytesWritten)
|
||||
} else {
|
||||
0 to ByteArray(0)
|
||||
}
|
||||
|
||||
val packetSize = 4 + 32 + 4 + pairingMessageLength + 4 + channelBytesWritten
|
||||
val packet = ByteArray(packetSize)
|
||||
ByteBuffer.wrap(packet).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putInt(requestId)
|
||||
put(publicKeyBytes)
|
||||
putInt(pairingMessageLength)
|
||||
if (pairingMessageLength > 0) put(pairingMessage)
|
||||
putInt(channelBytesWritten)
|
||||
put(channelMessage, 0, channelBytesWritten)
|
||||
}
|
||||
|
||||
session.send(Opcode.REQUEST.value, RequestOpcode.TRANSPORT.value, ByteBuffer.wrap(packet))
|
||||
}
|
||||
}
|
||||
|
||||
fun sendResponseTransport(remoteVersion: Int, requestId: Int, handshakeMessage: ByteArray) {
|
||||
throwIfDisposed()
|
||||
|
||||
synchronized(sendLock) {
|
||||
val message = ByteArray(1024)
|
||||
val plaintext = ByteArray(1024)
|
||||
handshakeState!!.readMessage(handshakeMessage, 0, handshakeMessage.size, plaintext, 0)
|
||||
val bytesWritten = handshakeState!!.writeMessage(message, 0, null, 0, 0)
|
||||
val transport = handshakeState!!.split()
|
||||
|
||||
val responsePacket = ByteArray(20 + bytesWritten)
|
||||
ByteBuffer.wrap(responsePacket).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
putInt(0) // Status code
|
||||
putLong(connectionId)
|
||||
putInt(requestId)
|
||||
putInt(bytesWritten)
|
||||
put(message, 0, bytesWritten)
|
||||
}
|
||||
|
||||
completeHandshake(remoteVersion, transport)
|
||||
session.send(Opcode.RESPONSE.value, ResponseOpcode.TRANSPORT.value, ByteBuffer.wrap(responsePacket))
|
||||
}
|
||||
}
|
||||
|
||||
fun decrypt(encryptedPayload: ByteBuffer): ByteBuffer {
|
||||
throwIfDisposed()
|
||||
|
||||
synchronized(decryptLock) {
|
||||
val encryptedBytes = ByteArray(encryptedPayload.remaining()).also { encryptedPayload.get(it) }
|
||||
val decryptedPayload = ByteArray(encryptedBytes.size - 16)
|
||||
val plen = transport!!.receiver.decryptWithAd(null, encryptedBytes, 0, decryptedPayload, 0, encryptedBytes.size)
|
||||
if (plen != decryptedPayload.size) throw IllegalStateException("Expected decrypted payload length to be $plen")
|
||||
return ByteBuffer.wrap(decryptedPayload).order(ByteOrder.LITTLE_ENDIAN)
|
||||
}
|
||||
}
|
||||
|
||||
fun handleTransportRelayed(remoteVersion: Int, connectionId: Long, handshakeMessage: ByteArray) {
|
||||
throwIfDisposed()
|
||||
|
||||
synchronized(decryptLock) {
|
||||
this.connectionId = connectionId
|
||||
val plaintext = ByteArray(1024)
|
||||
val plen = handshakeState!!.readMessage(handshakeMessage, 0, handshakeMessage.size, plaintext, 0)
|
||||
val transport = handshakeState!!.split()
|
||||
completeHandshake(remoteVersion, transport)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -2,6 +2,6 @@ package com.futo.platformplayer.sync.internal;
|
|||
|
||||
public enum LinkType {
|
||||
None,
|
||||
Direct,
|
||||
Relayed
|
||||
Local,
|
||||
Proxied
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,60 +0,0 @@
|
|||
package com.futo.platformplayer.sync.internal
|
||||
|
||||
enum class Opcode(val value: UByte) {
|
||||
PING(0u),
|
||||
PONG(1u),
|
||||
NOTIFY(2u),
|
||||
STREAM(3u),
|
||||
DATA(4u),
|
||||
REQUEST(5u),
|
||||
RESPONSE(6u),
|
||||
RELAY(7u)
|
||||
}
|
||||
|
||||
enum class NotifyOpcode(val value: UByte) {
|
||||
AUTHORIZED(0u),
|
||||
UNAUTHORIZED(1u),
|
||||
CONNECTION_INFO(2u)
|
||||
}
|
||||
|
||||
enum class StreamOpcode(val value: UByte) {
|
||||
START(0u),
|
||||
DATA(1u),
|
||||
END(2u)
|
||||
}
|
||||
|
||||
enum class RequestOpcode(val value: UByte) {
|
||||
CONNECTION_INFO(0u),
|
||||
TRANSPORT(1u),
|
||||
TRANSPORT_RELAYED(2u),
|
||||
PUBLISH_RECORD(3u),
|
||||
DELETE_RECORD(4u),
|
||||
LIST_RECORD_KEYS(5u),
|
||||
GET_RECORD(6u),
|
||||
BULK_PUBLISH_RECORD(7u),
|
||||
BULK_GET_RECORD(8u),
|
||||
BULK_CONNECTION_INFO(9u),
|
||||
BULK_DELETE_RECORD(10u)
|
||||
}
|
||||
|
||||
enum class ResponseOpcode(val value: UByte) {
|
||||
CONNECTION_INFO(0u),
|
||||
TRANSPORT(1u),
|
||||
TRANSPORT_RELAYED(2u), //TODO: Server errors also included in this one, disentangle?
|
||||
PUBLISH_RECORD(3u),
|
||||
DELETE_RECORD(4u),
|
||||
LIST_RECORD_KEYS(5u),
|
||||
GET_RECORD(6u),
|
||||
BULK_PUBLISH_RECORD(7u),
|
||||
BULK_GET_RECORD(8u),
|
||||
BULK_CONNECTION_INFO(9u),
|
||||
BULK_DELETE_RECORD(10u)
|
||||
}
|
||||
|
||||
enum class RelayOpcode(val value: UByte) {
|
||||
DATA(0u),
|
||||
RELAYED_DATA(1u),
|
||||
ERROR(2u),
|
||||
RELAYED_ERROR(3u),
|
||||
RELAY_ERROR(4u)
|
||||
}
|
||||
|
|
@ -5,12 +5,10 @@ class SyncDeviceInfo {
|
|||
var publicKey: String
|
||||
var addresses: Array<String>
|
||||
var port: Int
|
||||
var pairingCode: String?
|
||||
|
||||
constructor(publicKey: String, addresses: Array<String>, port: Int, pairingCode: String?) {
|
||||
constructor(publicKey: String, addresses: Array<String>, port: Int) {
|
||||
this.publicKey = publicKey
|
||||
this.addresses = addresses
|
||||
this.port = port
|
||||
this.pairingCode = pairingCode
|
||||
}
|
||||
}
|
||||
|
|
@ -1,6 +0,0 @@
|
|||
package com.futo.platformplayer.sync.internal
|
||||
|
||||
enum class SyncErrorCode(val value: Int) {
|
||||
ConnectionClosed(1),
|
||||
NotFound(2)
|
||||
}
|
||||
|
|
@ -1,13 +1,37 @@
|
|||
package com.futo.platformplayer.sync.internal
|
||||
|
||||
import com.futo.platformplayer.UIDialogs
|
||||
import com.futo.platformplayer.activities.MainActivity
|
||||
import com.futo.platformplayer.api.media.Serializer
|
||||
import com.futo.platformplayer.logging.Logger
|
||||
import com.futo.platformplayer.models.HistoryVideo
|
||||
import com.futo.platformplayer.models.Subscription
|
||||
import com.futo.platformplayer.smartMerge
|
||||
import com.futo.platformplayer.states.StateApp
|
||||
import com.futo.platformplayer.states.StateBackup
|
||||
import com.futo.platformplayer.states.StateHistory
|
||||
import com.futo.platformplayer.states.StatePlaylists
|
||||
import com.futo.platformplayer.states.StateSubscriptionGroups
|
||||
import com.futo.platformplayer.states.StateSubscriptions
|
||||
import com.futo.platformplayer.states.StateSync
|
||||
import com.futo.platformplayer.sync.SyncSessionData
|
||||
import com.futo.platformplayer.sync.internal.SyncSocketSession.Opcode
|
||||
import com.futo.platformplayer.sync.models.SendToDevicePackage
|
||||
import com.futo.platformplayer.sync.models.SyncPlaylistsPackage
|
||||
import com.futo.platformplayer.sync.models.SyncSubscriptionGroupsPackage
|
||||
import com.futo.platformplayer.sync.models.SyncSubscriptionsPackage
|
||||
import com.futo.platformplayer.sync.models.SyncWatchLaterPackage
|
||||
import com.futo.platformplayer.toUtf8String
|
||||
import kotlinx.coroutines.Dispatchers
|
||||
import kotlinx.coroutines.launch
|
||||
import kotlinx.serialization.encodeToString
|
||||
import kotlinx.serialization.json.Json
|
||||
import java.io.ByteArrayInputStream
|
||||
import java.nio.ByteBuffer
|
||||
import java.nio.ByteOrder
|
||||
import java.time.Instant
|
||||
import java.time.OffsetDateTime
|
||||
import java.time.ZoneOffset
|
||||
import java.util.UUID
|
||||
|
||||
interface IAuthorizable {
|
||||
|
|
@ -15,14 +39,13 @@ interface IAuthorizable {
|
|||
}
|
||||
|
||||
class SyncSession : IAuthorizable {
|
||||
private val _channels: MutableList<IChannel> = mutableListOf()
|
||||
private val _socketSessions: MutableList<SyncSocketSession> = mutableListOf()
|
||||
private var _authorized: Boolean = false
|
||||
private var _remoteAuthorized: Boolean = false
|
||||
private val _onAuthorized: (session: SyncSession, isNewlyAuthorized: Boolean, isNewSession: Boolean) -> Unit
|
||||
private val _onUnauthorized: (session: SyncSession) -> Unit
|
||||
private val _onClose: (session: SyncSession) -> Unit
|
||||
private val _onConnectedChanged: (session: SyncSession, connected: Boolean) -> Unit
|
||||
private val _dataHandler: (session: SyncSession, opcode: UByte, subOpcode: UByte, data: ByteBuffer) -> Unit
|
||||
val remotePublicKey: String
|
||||
override val isAuthorized get() = _authorized && _remoteAuthorized
|
||||
private var _wasAuthorized = false
|
||||
|
|
@ -33,143 +56,140 @@ class SyncSession : IAuthorizable {
|
|||
private set
|
||||
val displayName: String get() = remoteDeviceName ?: remotePublicKey
|
||||
|
||||
val linkType: LinkType get()
|
||||
{
|
||||
var linkType = LinkType.None
|
||||
synchronized(_channels)
|
||||
{
|
||||
for (channel in _channels)
|
||||
{
|
||||
if (channel.linkType == LinkType.Direct)
|
||||
return LinkType.Direct
|
||||
if (channel.linkType == LinkType.Relayed)
|
||||
linkType = LinkType.Relayed
|
||||
}
|
||||
}
|
||||
return linkType
|
||||
}
|
||||
|
||||
var connected: Boolean = false
|
||||
private set(v) {
|
||||
if (field != v) {
|
||||
field = v
|
||||
this._onConnectedChanged(this, v)
|
||||
}
|
||||
if (field != v) {
|
||||
field = v
|
||||
this._onConnectedChanged(this, v)
|
||||
}
|
||||
}
|
||||
|
||||
constructor(
|
||||
remotePublicKey: String,
|
||||
onAuthorized: (session: SyncSession, isNewlyAuthorized: Boolean, isNewSession: Boolean) -> Unit,
|
||||
onUnauthorized: (session: SyncSession) -> Unit,
|
||||
onConnectedChanged: (session: SyncSession, connected: Boolean) -> Unit,
|
||||
onClose: (session: SyncSession) -> Unit,
|
||||
dataHandler: (session: SyncSession, opcode: UByte, subOpcode: UByte, data: ByteBuffer) -> Unit,
|
||||
remoteDeviceName: String? = null
|
||||
) {
|
||||
constructor(remotePublicKey: String, onAuthorized: (session: SyncSession, isNewlyAuthorized: Boolean, isNewSession: Boolean) -> Unit, onUnauthorized: (session: SyncSession) -> Unit, onConnectedChanged: (session: SyncSession, connected: Boolean) -> Unit, onClose: (session: SyncSession) -> Unit, remoteDeviceName: String?) {
|
||||
this.remotePublicKey = remotePublicKey
|
||||
this.remoteDeviceName = remoteDeviceName
|
||||
_onAuthorized = onAuthorized
|
||||
_onUnauthorized = onUnauthorized
|
||||
_onConnectedChanged = onConnectedChanged
|
||||
_onClose = onClose
|
||||
_dataHandler = dataHandler
|
||||
}
|
||||
|
||||
fun addChannel(channel: IChannel) {
|
||||
if (channel.remotePublicKey != remotePublicKey) {
|
||||
throw Exception("Public key of session must match public key of channel")
|
||||
fun addSocketSession(socketSession: SyncSocketSession) {
|
||||
if (socketSession.remotePublicKey != remotePublicKey) {
|
||||
throw Exception("Public key of session must match public key of socket session")
|
||||
}
|
||||
|
||||
synchronized(_channels) {
|
||||
_channels.add(channel)
|
||||
connected = _channels.isNotEmpty()
|
||||
synchronized(_socketSessions) {
|
||||
_socketSessions.add(socketSession)
|
||||
connected = _socketSessions.isNotEmpty()
|
||||
}
|
||||
|
||||
channel.authorizable = this
|
||||
channel.syncSession = this
|
||||
socketSession.authorizable = this
|
||||
}
|
||||
|
||||
fun authorize() {
|
||||
fun authorize(socketSession: SyncSocketSession) {
|
||||
Logger.i(TAG, "Sent AUTHORIZED with session id $_id")
|
||||
val idString = _id.toString()
|
||||
val idBytes = idString.toByteArray(Charsets.UTF_8)
|
||||
val name = "${android.os.Build.MANUFACTURER}-${android.os.Build.MODEL}"
|
||||
val nameBytes = name.toByteArray(Charsets.UTF_8)
|
||||
val buffer = ByteArray(1 + idBytes.size + 1 + nameBytes.size)
|
||||
buffer[0] = idBytes.size.toByte()
|
||||
System.arraycopy(idBytes, 0, buffer, 1, idBytes.size)
|
||||
buffer[1 + idBytes.size] = nameBytes.size.toByte()
|
||||
System.arraycopy(nameBytes, 0, buffer, 2 + idBytes.size, nameBytes.size)
|
||||
send(Opcode.NOTIFY.value, NotifyOpcode.AUTHORIZED.value, ByteBuffer.wrap(buffer))
|
||||
|
||||
if (socketSession.remoteVersion >= 3) {
|
||||
val idStringBytes = _id.toString().toByteArray()
|
||||
val nameBytes = "${android.os.Build.MANUFACTURER}-${android.os.Build.MODEL}".toByteArray()
|
||||
val buffer = ByteArray(1 + idStringBytes.size + 1 + nameBytes.size)
|
||||
socketSession.send(Opcode.NOTIFY_AUTHORIZED.value, 0u, ByteBuffer.wrap(buffer).order(ByteOrder.LITTLE_ENDIAN).apply {
|
||||
put(idStringBytes.size.toByte())
|
||||
put(idStringBytes)
|
||||
put(nameBytes.size.toByte())
|
||||
put(nameBytes)
|
||||
}.apply { flip() })
|
||||
} else {
|
||||
socketSession.send(Opcode.NOTIFY_AUTHORIZED.value, 0u, ByteBuffer.wrap(_id.toString().toByteArray()))
|
||||
}
|
||||
_authorized = true
|
||||
checkAuthorized()
|
||||
}
|
||||
|
||||
fun unauthorize() {
|
||||
send(Opcode.NOTIFY.value, NotifyOpcode.UNAUTHORIZED.value)
|
||||
fun unauthorize(socketSession: SyncSocketSession? = null) {
|
||||
if (socketSession != null)
|
||||
socketSession.send(Opcode.NOTIFY_UNAUTHORIZED.value)
|
||||
else {
|
||||
val ss = synchronized(_socketSessions) {
|
||||
_socketSessions.first()
|
||||
}
|
||||
|
||||
ss.send(Opcode.NOTIFY_UNAUTHORIZED.value)
|
||||
}
|
||||
}
|
||||
|
||||
private fun checkAuthorized() {
|
||||
if (isAuthorized) {
|
||||
val isNewlyAuthorized = !_wasAuthorized
|
||||
val isNewSession = _lastAuthorizedRemoteId != _remoteId
|
||||
Logger.i(TAG, "onAuthorized (isNewlyAuthorized = $isNewlyAuthorized, isNewSession = $isNewSession)")
|
||||
_onAuthorized(this, isNewlyAuthorized, isNewSession)
|
||||
val isNewlyAuthorized = !_wasAuthorized;
|
||||
val isNewSession = _lastAuthorizedRemoteId != _remoteId;
|
||||
Logger.i(TAG, "onAuthorized (isNewlyAuthorized = $isNewlyAuthorized, isNewSession = $isNewSession)");
|
||||
_onAuthorized.invoke(this, !_wasAuthorized, _lastAuthorizedRemoteId != _remoteId)
|
||||
_wasAuthorized = true
|
||||
_lastAuthorizedRemoteId = _remoteId
|
||||
}
|
||||
}
|
||||
|
||||
fun removeChannel(channel: IChannel) {
|
||||
synchronized(_channels) {
|
||||
_channels.remove(channel)
|
||||
connected = _channels.isNotEmpty()
|
||||
fun removeSocketSession(socketSession: SyncSocketSession) {
|
||||
synchronized(_socketSessions) {
|
||||
_socketSessions.remove(socketSession)
|
||||
connected = _socketSessions.isNotEmpty()
|
||||
}
|
||||
}
|
||||
|
||||
fun close() {
|
||||
synchronized(_channels) {
|
||||
_channels.forEach { it.close() }
|
||||
_channels.clear()
|
||||
synchronized(_socketSessions) {
|
||||
for (socketSession in _socketSessions) {
|
||||
socketSession.stop()
|
||||
}
|
||||
|
||||
_socketSessions.clear()
|
||||
}
|
||||
_onClose(this)
|
||||
|
||||
_onClose.invoke(this)
|
||||
}
|
||||
|
||||
fun handlePacket(opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
|
||||
fun handlePacket(socketSession: SyncSocketSession, opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
|
||||
try {
|
||||
Logger.i(TAG, "Handle packet (opcode: $opcode, subOpcode: $subOpcode, data.length: ${data.remaining()})")
|
||||
Logger.i(TAG, "Handle packet (opcode: ${opcode}, subOpcode: ${subOpcode}, data.length: ${data.remaining()})")
|
||||
|
||||
when (opcode) {
|
||||
Opcode.NOTIFY.value -> when (subOpcode) {
|
||||
NotifyOpcode.AUTHORIZED.value -> {
|
||||
Opcode.NOTIFY_AUTHORIZED.value -> {
|
||||
if (socketSession.remoteVersion >= 3) {
|
||||
val idByteCount = data.get().toInt()
|
||||
if (idByteCount > 64)
|
||||
throw Exception("Id should always be smaller than 64 bytes")
|
||||
|
||||
val idBytes = ByteArray(idByteCount)
|
||||
data.get(idBytes)
|
||||
|
||||
val nameByteCount = data.get().toInt()
|
||||
if (nameByteCount > 64)
|
||||
throw Exception("Name should always be smaller than 64 bytes")
|
||||
|
||||
val nameBytes = ByteArray(nameByteCount)
|
||||
data.get(nameBytes)
|
||||
|
||||
_remoteId = UUID.fromString(idBytes.toString(Charsets.UTF_8))
|
||||
remoteDeviceName = nameBytes.toString(Charsets.UTF_8)
|
||||
_remoteAuthorized = true
|
||||
Logger.i(TAG, "Received AUTHORIZED with session id $_remoteId (device name: '${remoteDeviceName ?: "not set"}')")
|
||||
checkAuthorized()
|
||||
return
|
||||
}
|
||||
NotifyOpcode.UNAUTHORIZED.value -> {
|
||||
_remoteAuthorized = false
|
||||
_remoteId = null
|
||||
} else {
|
||||
val str = data.toUtf8String()
|
||||
_remoteId = if (data.remaining() >= 0) UUID.fromString(str) else UUID.fromString("00000000-0000-0000-0000-000000000000")
|
||||
remoteDeviceName = null
|
||||
_lastAuthorizedRemoteId = null
|
||||
_onUnauthorized(this)
|
||||
return
|
||||
}
|
||||
|
||||
_remoteAuthorized = true
|
||||
Logger.i(TAG, "Received AUTHORIZED with session id $_remoteId (device name: '${remoteDeviceName ?: "not set"}')")
|
||||
checkAuthorized()
|
||||
return
|
||||
}
|
||||
Opcode.NOTIFY_UNAUTHORIZED.value -> {
|
||||
_remoteId = null
|
||||
remoteDeviceName = null
|
||||
_lastAuthorizedRemoteId = null
|
||||
_remoteAuthorized = false
|
||||
_onUnauthorized(this)
|
||||
return
|
||||
}
|
||||
//TODO: Handle any kind of packet (that is not necessarily authorized)
|
||||
}
|
||||
|
||||
if (!isAuthorized) {
|
||||
|
|
@ -177,57 +197,282 @@ class SyncSession : IAuthorizable {
|
|||
}
|
||||
|
||||
if (opcode != Opcode.DATA.value) {
|
||||
Logger.w(TAG, "Unknown opcode received: (opcode = $opcode, subOpcode = $subOpcode)")
|
||||
Logger.w(TAG, "Unknown opcode received: (opcode = ${opcode}, subOpcode = ${subOpcode})}")
|
||||
return
|
||||
}
|
||||
|
||||
Logger.i(TAG, "Received (opcode = $opcode, subOpcode = $subOpcode) (${data.remaining()} bytes)")
|
||||
_dataHandler.invoke(this, opcode, subOpcode, data)
|
||||
} catch (ex: Exception) {
|
||||
Logger.w(TAG, "Failed to handle sync package $opcode: ${ex.message}", ex)
|
||||
Logger.i(TAG, "Received (opcode = ${opcode}, subOpcode = ${subOpcode}) (${data.remaining()} bytes)")
|
||||
//TODO: Abstract this out
|
||||
when (subOpcode) {
|
||||
GJSyncOpcodes.sendToDevices -> {
|
||||
StateApp.instance.scopeOrNull?.launch(Dispatchers.Main) {
|
||||
val context = StateApp.instance.contextOrNull;
|
||||
if (context != null && context is MainActivity) {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
val remainder = data.remaining();
|
||||
data.get(dataBody, 0, remainder);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val obj = Json.decodeFromString<SendToDevicePackage>(json);
|
||||
UIDialogs.appToast("Received url from device [${socketSession.remotePublicKey}]:\n{${obj.url}");
|
||||
context.handleUrl(obj.url, obj.position);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncStateExchange -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val syncSessionData = Serializer.json.decodeFromString<SyncSessionData>(json);
|
||||
|
||||
Logger.i(TAG, "Received SyncSessionData from " + remotePublicKey);
|
||||
|
||||
|
||||
sendData(GJSyncOpcodes.syncSubscriptions, StateSubscriptions.instance.getSyncSubscriptionsPackageString());
|
||||
sendData(GJSyncOpcodes.syncSubscriptionGroups, StateSubscriptionGroups.instance.getSyncSubscriptionGroupsPackageString());
|
||||
sendData(GJSyncOpcodes.syncPlaylists, StatePlaylists.instance.getSyncPlaylistsPackageString())
|
||||
|
||||
sendData(GJSyncOpcodes.syncWatchLater, Json.encodeToString(StatePlaylists.instance.getWatchLaterSyncPacket(false)));
|
||||
|
||||
val recentHistory = StateHistory.instance.getRecentHistory(syncSessionData.lastHistory);
|
||||
if(recentHistory.size > 0)
|
||||
sendJsonData(GJSyncOpcodes.syncHistory, recentHistory);
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncExport -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
val bytesStr = ByteArrayInputStream(data.array(), data.position(), data.remaining());
|
||||
try {
|
||||
val exportStruct = StateBackup.ExportStructure.fromZipBytes(bytesStr);
|
||||
for (store in exportStruct.stores) {
|
||||
if (store.key.equals("subscriptions", true)) {
|
||||
val subStore =
|
||||
StateSubscriptions.instance.getUnderlyingSubscriptionsStore();
|
||||
StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
|
||||
val pack = SyncSubscriptionsPackage(
|
||||
store.value.map {
|
||||
subStore.fromReconstruction(it, exportStruct.cache)
|
||||
},
|
||||
StateSubscriptions.instance.getSubscriptionRemovals()
|
||||
);
|
||||
handleSyncSubscriptionPackage(this@SyncSession, pack);
|
||||
}
|
||||
}
|
||||
}
|
||||
} finally {
|
||||
bytesStr.close();
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncSubscriptions -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val subPackage = Serializer.json.decodeFromString<SyncSubscriptionsPackage>(json);
|
||||
handleSyncSubscriptionPackage(this, subPackage);
|
||||
|
||||
val newestSub = subPackage.subscriptions.maxOf { it.creationTime };
|
||||
|
||||
val sesData = StateSync.instance.getSyncSessionData(remotePublicKey);
|
||||
if(newestSub > sesData.lastSubscription) {
|
||||
sesData.lastSubscription = newestSub;
|
||||
StateSync.instance.saveSyncSessionData(sesData);
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncSubscriptionGroups -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val pack = Serializer.json.decodeFromString<SyncSubscriptionGroupsPackage>(json);
|
||||
|
||||
var lastSubgroupChange = OffsetDateTime.MIN;
|
||||
for(group in pack.groups){
|
||||
if(group.lastChange > lastSubgroupChange)
|
||||
lastSubgroupChange = group.lastChange;
|
||||
|
||||
val existing = StateSubscriptionGroups.instance.getSubscriptionGroup(group.id);
|
||||
|
||||
if(existing == null)
|
||||
StateSubscriptionGroups.instance.updateSubscriptionGroup(group, false, true);
|
||||
else if(existing.lastChange < group.lastChange) {
|
||||
existing.name = group.name;
|
||||
existing.urls = group.urls;
|
||||
existing.image = group.image;
|
||||
existing.priority = group.priority;
|
||||
existing.lastChange = group.lastChange;
|
||||
StateSubscriptionGroups.instance.updateSubscriptionGroup(existing, false, true);
|
||||
}
|
||||
}
|
||||
for(removal in pack.groupRemovals) {
|
||||
val creation = StateSubscriptionGroups.instance.getSubscriptionGroup(removal.key);
|
||||
val removalTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(removal.value, 0), ZoneOffset.UTC);
|
||||
if(creation != null && creation.creationTime < removalTime)
|
||||
StateSubscriptionGroups.instance.deleteSubscriptionGroup(removal.key, false);
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncPlaylists -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val pack = Serializer.json.decodeFromString<SyncPlaylistsPackage>(json);
|
||||
|
||||
for(playlist in pack.playlists) {
|
||||
val existing = StatePlaylists.instance.getPlaylist(playlist.id);
|
||||
|
||||
if(existing == null)
|
||||
StatePlaylists.instance.createOrUpdatePlaylist(playlist, false);
|
||||
else if(existing.dateUpdate.toLocalDateTime() < playlist.dateUpdate.toLocalDateTime()) {
|
||||
existing.dateUpdate = playlist.dateUpdate;
|
||||
existing.name = playlist.name;
|
||||
existing.videos = playlist.videos;
|
||||
existing.dateCreation = playlist.dateCreation;
|
||||
existing.datePlayed = playlist.datePlayed;
|
||||
StatePlaylists.instance.createOrUpdatePlaylist(existing, false);
|
||||
}
|
||||
}
|
||||
for(removal in pack.playlistRemovals) {
|
||||
val creation = StatePlaylists.instance.getPlaylist(removal.key);
|
||||
val removalTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(removal.value, 0), ZoneOffset.UTC);
|
||||
if(creation != null && creation.dateCreation < removalTime)
|
||||
StatePlaylists.instance.removePlaylist(creation, false);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncWatchLater -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val pack = Serializer.json.decodeFromString<SyncWatchLaterPackage>(json);
|
||||
|
||||
Logger.i(TAG, "SyncWatchLater received ${pack.videos.size} (${pack.videoAdds?.size}, ${pack.videoRemovals?.size})");
|
||||
|
||||
val allExisting = StatePlaylists.instance.getWatchLater();
|
||||
for(video in pack.videos) {
|
||||
val existing = allExisting.firstOrNull { it.url == video.url };
|
||||
val time = if(pack.videoAdds != null && pack.videoAdds.containsKey(video.url)) OffsetDateTime.ofInstant(Instant.ofEpochSecond(pack.videoAdds[video.url] ?: 0), ZoneOffset.UTC) else OffsetDateTime.MIN;
|
||||
|
||||
if(existing == null) {
|
||||
StatePlaylists.instance.addToWatchLater(video, false);
|
||||
if(time > OffsetDateTime.MIN)
|
||||
StatePlaylists.instance.setWatchLaterAddTime(video.url, time);
|
||||
}
|
||||
}
|
||||
for(removal in pack.videoRemovals) {
|
||||
val watchLater = allExisting.firstOrNull { it.url == removal.key } ?: continue;
|
||||
val creation = StatePlaylists.instance.getWatchLaterRemovalTime(watchLater.url) ?: OffsetDateTime.MIN;
|
||||
val removalTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(removal.value), ZoneOffset.UTC);
|
||||
if(creation < removalTime)
|
||||
StatePlaylists.instance.removeFromWatchLater(watchLater, false, removalTime);
|
||||
}
|
||||
|
||||
val packReorderTime = OffsetDateTime.ofInstant(Instant.ofEpochSecond(pack.reorderTime), ZoneOffset.UTC);
|
||||
val localReorderTime = StatePlaylists.instance.getWatchLaterLastReorderTime();
|
||||
if(localReorderTime < packReorderTime && pack.ordering != null) {
|
||||
StatePlaylists.instance.updateWatchLaterOrdering(smartMerge(pack.ordering!!, StatePlaylists.instance.getWatchLaterOrdering()), true);
|
||||
}
|
||||
}
|
||||
|
||||
GJSyncOpcodes.syncHistory -> {
|
||||
val dataBody = ByteArray(data.remaining());
|
||||
data.get(dataBody);
|
||||
val json = String(dataBody, Charsets.UTF_8);
|
||||
val history = Serializer.json.decodeFromString<List<HistoryVideo>>(json);
|
||||
Logger.i(TAG, "SyncHistory received ${history.size} videos from ${remotePublicKey}");
|
||||
|
||||
var lastHistory = OffsetDateTime.MIN;
|
||||
for(video in history){
|
||||
val hist = StateHistory.instance.getHistoryByVideo(video.video, true, video.date);
|
||||
if(hist != null)
|
||||
StateHistory.instance.updateHistoryPosition(video.video, hist, true, video.position, video.date)
|
||||
if(lastHistory < video.date)
|
||||
lastHistory = video.date;
|
||||
}
|
||||
|
||||
if(lastHistory != OffsetDateTime.MIN && history.size > 1) {
|
||||
val sesData = StateSync.instance.getSyncSessionData(remotePublicKey);
|
||||
if (lastHistory > sesData.lastHistory) {
|
||||
sesData.lastHistory = lastHistory;
|
||||
StateSync.instance.saveSyncSessionData(sesData);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
catch(ex: Exception) {
|
||||
Logger.w(TAG, "Failed to handle sync package ${opcode}: ${ex.message}", ex);
|
||||
}
|
||||
}
|
||||
|
||||
private fun handleSyncSubscriptionPackage(origin: SyncSession, pack: SyncSubscriptionsPackage) {
|
||||
val added = mutableListOf<Subscription>()
|
||||
for(sub in pack.subscriptions) {
|
||||
if(!StateSubscriptions.instance.isSubscribed(sub.channel)) {
|
||||
val removalTime = StateSubscriptions.instance.getSubscriptionRemovalTime(sub.channel.url);
|
||||
if(sub.creationTime > removalTime) {
|
||||
val newSub = StateSubscriptions.instance.addSubscription(sub.channel, sub.creationTime);
|
||||
added.add(newSub);
|
||||
}
|
||||
}
|
||||
}
|
||||
if(added.size > 3)
|
||||
UIDialogs.appToast("${added.size} Subscriptions from ${origin.remotePublicKey.substring(0, Math.min(8, origin.remotePublicKey.length))}");
|
||||
else if(added.size > 0)
|
||||
UIDialogs.appToast("Subscriptions from ${origin.remotePublicKey.substring(0, Math.min(8, origin.remotePublicKey.length))}:\n" +
|
||||
added.map { it.channel.name }.joinToString("\n"));
|
||||
|
||||
|
||||
if(pack.subscriptions != null && pack.subscriptions.size > 0) {
|
||||
for (subRemoved in pack.subscriptionRemovals) {
|
||||
val removed = StateSubscriptions.instance.applySubscriptionRemovals(pack.subscriptionRemovals);
|
||||
if(removed.size > 3)
|
||||
UIDialogs.appToast("Removed ${removed.size} Subscriptions from ${origin.remotePublicKey.substring(0, Math.min(8, origin.remotePublicKey.length))}");
|
||||
else if(removed.size > 0)
|
||||
UIDialogs.appToast("Subscriptions removed from ${origin.remotePublicKey.substring(0, Math.min(8, origin.remotePublicKey.length))}:\n" +
|
||||
removed.map { it.channel.name }.joinToString("\n"));
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
inline fun <reified T> sendJsonData(subOpcode: UByte, data: T) {
|
||||
send(Opcode.DATA.value, subOpcode, Json.encodeToString(data))
|
||||
send(Opcode.DATA.value, subOpcode, Json.encodeToString<T>(data));
|
||||
}
|
||||
|
||||
fun sendData(subOpcode: UByte, data: String) {
|
||||
send(Opcode.DATA.value, subOpcode, ByteBuffer.wrap(data.toByteArray(Charsets.UTF_8)))
|
||||
send(Opcode.DATA.value, subOpcode, data.toByteArray(Charsets.UTF_8));
|
||||
}
|
||||
|
||||
fun send(opcode: UByte, subOpcode: UByte, data: String) {
|
||||
send(opcode, subOpcode, ByteBuffer.wrap(data.toByteArray(Charsets.UTF_8)))
|
||||
send(opcode, subOpcode, data.toByteArray(Charsets.UTF_8));
|
||||
}
|
||||
fun send(opcode: UByte, subOpcode: UByte, data: ByteArray) {
|
||||
val socketSessions = synchronized(_socketSessions) {
|
||||
_socketSessions.toList()
|
||||
}
|
||||
|
||||
fun send(opcode: UByte, subOpcode: UByte, data: ByteBuffer? = null) {
|
||||
val channels = synchronized(_channels) { _channels.sortedBy { it.linkType.ordinal }.toList() }
|
||||
if (channels.isEmpty()) {
|
||||
//TODO: Should this throw?
|
||||
Logger.v(TAG, "Packet was not sent (opcode = $opcode, subOpcode = $subOpcode) due to no connected sockets")
|
||||
if (socketSessions.isEmpty()) {
|
||||
Logger.v(TAG, "Packet was not sent (opcode = ${opcode}, subOpcode = ${subOpcode}) due to no connected sockets")
|
||||
return
|
||||
}
|
||||
|
||||
var sent = false
|
||||
for (channel in channels) {
|
||||
for (socketSession in socketSessions) {
|
||||
try {
|
||||
channel.send(opcode, subOpcode, data)
|
||||
socketSession.send(opcode, subOpcode, ByteBuffer.wrap(data))
|
||||
sent = true
|
||||
break
|
||||
} catch (e: Throwable) {
|
||||
Logger.w(TAG, "Packet failed to send (opcode = $opcode, subOpcode = $subOpcode)", e)
|
||||
Logger.w(TAG, "Packet failed to send (opcode = ${opcode}, subOpcode = ${subOpcode})", e)
|
||||
}
|
||||
}
|
||||
|
||||
if (!sent) {
|
||||
throw Exception("Packet was not sent (opcode = $opcode, subOpcode = $subOpcode) due to send errors and no remaining candidates")
|
||||
throw Exception("Packet was not sent (opcode = ${opcode}, subOpcode = ${subOpcode}) due to send errors and no remaining candidates")
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
private const val TAG = "SyncSession"
|
||||
private companion object {
|
||||
const val TAG = "SyncSession"
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,9 +1,7 @@
|
|||
package com.futo.platformplayer.views
|
||||
|
||||
import android.content.Context
|
||||
import android.text.TextWatcher
|
||||
import android.util.AttributeSet
|
||||
import android.view.inputmethod.InputMethodManager
|
||||
import android.widget.FrameLayout
|
||||
import android.widget.ImageButton
|
||||
import android.widget.ImageView
|
||||
|
|
@ -20,9 +18,6 @@ class SearchView : FrameLayout {
|
|||
val buttonClear: ImageButton;
|
||||
|
||||
var onSearchChanged = Event1<String>();
|
||||
var onEnter = Event1<String>();
|
||||
|
||||
val text: String get() = textSearch.text.toString();
|
||||
|
||||
constructor(context: Context, attrs: AttributeSet? = null) : super(context, attrs) {
|
||||
inflate(context, R.layout.view_search_bar, this);
|
||||
|
|
|
|||
|
|
@ -12,7 +12,6 @@ import com.futo.platformplayer.Settings
|
|||
import com.futo.platformplayer.UIDialogs
|
||||
import com.futo.platformplayer.api.media.models.channels.SerializedChannel
|
||||
import com.futo.platformplayer.constructs.Event1
|
||||
import com.futo.platformplayer.models.ImageVariable
|
||||
import com.futo.platformplayer.models.Subscription
|
||||
import com.futo.platformplayer.models.SubscriptionGroup
|
||||
import com.futo.platformplayer.states.StateSubscriptionGroups
|
||||
|
|
@ -47,13 +46,8 @@ class ToggleBar : LinearLayout {
|
|||
_tagsContainer.removeAllViews();
|
||||
for(button in buttons) {
|
||||
_tagsContainer.addView(ToggleTagView(context).apply {
|
||||
if(button.icon > 0)
|
||||
this.setInfo(button.icon, button.name, button.isActive, button.isButton);
|
||||
else if(button.iconVariable != null)
|
||||
this.setInfo(button.iconVariable, button.name, button.isActive, button.isButton);
|
||||
else
|
||||
this.setInfo(button.name, button.isActive, button.isButton);
|
||||
this.onClick.subscribe({ view, enabled -> button.action(view, enabled); });
|
||||
this.setInfo(button.name, button.isActive);
|
||||
this.onClick.subscribe { button.action(it); };
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -61,42 +55,20 @@ class ToggleBar : LinearLayout {
|
|||
class Toggle {
|
||||
val name: String;
|
||||
val icon: Int;
|
||||
val iconVariable: ImageVariable?;
|
||||
val action: (ToggleTagView, Boolean)->Unit;
|
||||
val action: (Boolean)->Unit;
|
||||
val isActive: Boolean;
|
||||
var isButton: Boolean = false
|
||||
private set;
|
||||
var tag: String? = null;
|
||||
|
||||
constructor(name: String, icon: ImageVariable?, isActive: Boolean = false, action: (ToggleTagView, Boolean)->Unit) {
|
||||
this.name = name;
|
||||
this.icon = 0;
|
||||
this.iconVariable = icon;
|
||||
this.action = action;
|
||||
this.isActive = isActive;
|
||||
}
|
||||
constructor(name: String, icon: Int, isActive: Boolean = false, action: (ToggleTagView, Boolean)->Unit) {
|
||||
constructor(name: String, icon: Int, isActive: Boolean = false, action: (Boolean)->Unit) {
|
||||
this.name = name;
|
||||
this.icon = icon;
|
||||
this.iconVariable = null;
|
||||
this.action = action;
|
||||
this.isActive = isActive;
|
||||
}
|
||||
constructor(name: String, isActive: Boolean = false, action: (ToggleTagView, Boolean)->Unit) {
|
||||
constructor(name: String, isActive: Boolean = false, action: (Boolean)->Unit) {
|
||||
this.name = name;
|
||||
this.icon = 0;
|
||||
this.iconVariable = null;
|
||||
this.action = action;
|
||||
this.isActive = isActive;
|
||||
}
|
||||
|
||||
fun asButton(): Toggle{
|
||||
isButton = true;
|
||||
return this;
|
||||
}
|
||||
fun withTag(str: String): Toggle {
|
||||
tag = str;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -14,7 +14,6 @@ class VideoListEditorAdapter : RecyclerView.Adapter<VideoListEditorViewHolder> {
|
|||
|
||||
val onClick = Event1<IPlatformVideo>();
|
||||
val onRemove = Event1<IPlatformVideo>();
|
||||
val onOptions = Event1<IPlatformVideo>();
|
||||
var canEdit = false
|
||||
private set;
|
||||
|
||||
|
|
@ -29,7 +28,6 @@ class VideoListEditorAdapter : RecyclerView.Adapter<VideoListEditorViewHolder> {
|
|||
val holder = VideoListEditorViewHolder(view, _touchHelper);
|
||||
|
||||
holder.onRemove.subscribe { v -> onRemove.emit(v); };
|
||||
holder.onOptions.subscribe { v -> onOptions.emit(v); };
|
||||
holder.onClick.subscribe { v -> onClick.emit(v); };
|
||||
|
||||
return holder;
|
||||
|
|
|
|||
|
|
@ -32,7 +32,6 @@ class VideoListEditorViewHolder : ViewHolder {
|
|||
private val _containerDuration: LinearLayout;
|
||||
private val _containerLive: LinearLayout;
|
||||
private val _imageRemove: ImageButton;
|
||||
private val _imageOptions: ImageButton;
|
||||
private val _imageDragDrop: ImageButton;
|
||||
private val _platformIndicator: PlatformIndicator;
|
||||
private val _layoutDownloaded: FrameLayout;
|
||||
|
|
@ -42,7 +41,6 @@ class VideoListEditorViewHolder : ViewHolder {
|
|||
|
||||
val onClick = Event1<IPlatformVideo>();
|
||||
val onRemove = Event1<IPlatformVideo>();
|
||||
val onOptions = Event1<IPlatformVideo>();
|
||||
|
||||
@SuppressLint("ClickableViewAccessibility")
|
||||
constructor(view: View, touchHelper: ItemTouchHelper? = null) : super(view) {
|
||||
|
|
@ -56,7 +54,6 @@ class VideoListEditorViewHolder : ViewHolder {
|
|||
_containerDuration = view.findViewById(R.id.thumbnail_duration_container);
|
||||
_containerLive = view.findViewById(R.id.thumbnail_live_container);
|
||||
_imageRemove = view.findViewById(R.id.image_trash);
|
||||
_imageOptions = view.findViewById(R.id.image_settings);
|
||||
_imageDragDrop = view.findViewById<ImageButton>(R.id.image_drag_drop);
|
||||
_platformIndicator = view.findViewById(R.id.thumbnail_platform);
|
||||
_layoutDownloaded = view.findViewById(R.id.layout_downloaded);
|
||||
|
|
@ -77,10 +74,6 @@ class VideoListEditorViewHolder : ViewHolder {
|
|||
val v = video ?: return@setOnClickListener;
|
||||
onRemove.emit(v);
|
||||
};
|
||||
_imageOptions?.setOnClickListener {
|
||||
val v = video ?: return@setOnClickListener;
|
||||
onOptions.emit(v);
|
||||
}
|
||||
}
|
||||
|
||||
fun bind(v: IPlatformVideo, canEdit: Boolean) {
|
||||
|
|
|
|||
|
|
@ -8,7 +8,6 @@ import androidx.recyclerview.widget.LinearLayoutManager
|
|||
import androidx.recyclerview.widget.RecyclerView
|
||||
import com.futo.platformplayer.Settings
|
||||
import com.futo.platformplayer.UIDialogs
|
||||
import com.futo.platformplayer.UISlideOverlays
|
||||
import com.futo.platformplayer.api.media.models.video.IPlatformVideo
|
||||
import com.futo.platformplayer.constructs.Event1
|
||||
import com.futo.platformplayer.constructs.Event2
|
||||
|
|
@ -23,7 +22,6 @@ class VideoListEditorView : FrameLayout {
|
|||
|
||||
val onVideoOrderChanged = Event1<List<IPlatformVideo>>()
|
||||
val onVideoRemoved = Event1<IPlatformVideo>();
|
||||
val onVideoOptions = Event1<IPlatformVideo>();
|
||||
val onVideoClicked = Event1<IPlatformVideo>();
|
||||
val isEmpty get() = _videos.isEmpty();
|
||||
|
||||
|
|
@ -56,9 +54,6 @@ class VideoListEditorView : FrameLayout {
|
|||
}
|
||||
};
|
||||
|
||||
adapterVideos.onOptions.subscribe { v ->
|
||||
onVideoOptions?.emit(v);
|
||||
}
|
||||
adapterVideos.onRemove.subscribe { v ->
|
||||
val executeDelete = {
|
||||
synchronized(_videos) {
|
||||
|
|
|
|||
|
|
@ -9,7 +9,6 @@ import android.view.View
|
|||
import android.widget.ImageView
|
||||
import androidx.constraintlayout.widget.ConstraintLayout
|
||||
import com.bumptech.glide.Glide
|
||||
import com.bumptech.glide.load.engine.DiskCacheStrategy
|
||||
import com.futo.platformplayer.R
|
||||
import com.futo.platformplayer.constructs.Event1
|
||||
import com.futo.platformplayer.getDataLinkFromUrl
|
||||
|
|
@ -82,14 +81,12 @@ class CreatorThumbnail : ConstraintLayout {
|
|||
Glide.with(_imageChannelThumbnail)
|
||||
.load(url)
|
||||
.placeholder(R.drawable.placeholder_channel_thumbnail)
|
||||
.diskCacheStrategy(DiskCacheStrategy.DATA)
|
||||
.crossfade()
|
||||
.into(_imageChannelThumbnail);
|
||||
} else {
|
||||
Glide.with(_imageChannelThumbnail)
|
||||
.load(url)
|
||||
.placeholder(R.drawable.placeholder_channel_thumbnail)
|
||||
.diskCacheStrategy(DiskCacheStrategy.DATA)
|
||||
.into(_imageChannelThumbnail);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -4,42 +4,27 @@ import android.content.Context
|
|||
import android.graphics.Color
|
||||
import android.util.AttributeSet
|
||||
import android.view.LayoutInflater
|
||||
import android.view.View
|
||||
import android.widget.FrameLayout
|
||||
import android.widget.ImageView
|
||||
import android.widget.LinearLayout
|
||||
import android.widget.TextView
|
||||
import com.bumptech.glide.Glide
|
||||
import com.futo.platformplayer.R
|
||||
import com.futo.platformplayer.constructs.Event1
|
||||
import com.futo.platformplayer.constructs.Event2
|
||||
import com.futo.platformplayer.images.GlideHelper
|
||||
import com.futo.platformplayer.models.ImageVariable
|
||||
import com.futo.platformplayer.views.ToggleBar
|
||||
|
||||
class ToggleTagView : LinearLayout {
|
||||
private val _root: FrameLayout;
|
||||
private val _textTag: TextView;
|
||||
private var _text: String = "";
|
||||
private var _image: ImageView;
|
||||
|
||||
var isActive: Boolean = false
|
||||
private set;
|
||||
var isButton: Boolean = false
|
||||
private set;
|
||||
|
||||
var onClick = Event2<ToggleTagView, Boolean>();
|
||||
var onClick = Event1<Boolean>();
|
||||
|
||||
constructor(context: Context, attrs: AttributeSet? = null) : super(context, attrs) {
|
||||
LayoutInflater.from(context).inflate(R.layout.view_toggle_tag, this, true);
|
||||
_root = findViewById(R.id.root);
|
||||
_textTag = findViewById(R.id.text_tag);
|
||||
_image = findViewById(R.id.image_tag);
|
||||
_root.setOnClickListener {
|
||||
if(!isButton)
|
||||
setToggle(!isActive);
|
||||
onClick.emit(this, isActive);
|
||||
}
|
||||
_root.setOnClickListener { setToggle(!isActive); onClick.emit(isActive); }
|
||||
}
|
||||
|
||||
fun setToggle(isActive: Boolean) {
|
||||
|
|
@ -54,48 +39,9 @@ class ToggleTagView : LinearLayout {
|
|||
}
|
||||
}
|
||||
|
||||
fun setInfo(toggle: ToggleBar.Toggle){
|
||||
_text = toggle.name;
|
||||
_textTag.text = toggle.name;
|
||||
setToggle(toggle.isActive);
|
||||
if(toggle.iconVariable != null) {
|
||||
toggle.iconVariable.setImageView(_image, R.drawable.ic_error_pred);
|
||||
_image.visibility = View.GONE;
|
||||
}
|
||||
else if(toggle.icon > 0) {
|
||||
_image.setImageResource(toggle.icon);
|
||||
_image.visibility = View.GONE;
|
||||
}
|
||||
else
|
||||
_image.visibility = View.VISIBLE;
|
||||
_textTag.visibility = if(!toggle.name.isNullOrEmpty()) View.VISIBLE else View.GONE;
|
||||
this.isButton = isButton;
|
||||
}
|
||||
|
||||
fun setInfo(imageResource: Int, text: String, isActive: Boolean, isButton: Boolean = false) {
|
||||
fun setInfo(text: String, isActive: Boolean) {
|
||||
_text = text;
|
||||
_textTag.text = text;
|
||||
setToggle(isActive);
|
||||
_image.setImageResource(imageResource);
|
||||
_image.visibility = View.VISIBLE;
|
||||
_textTag.visibility = if(!text.isNullOrEmpty()) View.VISIBLE else View.GONE;
|
||||
this.isButton = isButton;
|
||||
}
|
||||
fun setInfo(image: ImageVariable, text: String, isActive: Boolean, isButton: Boolean = false) {
|
||||
_text = text;
|
||||
_textTag.text = text;
|
||||
setToggle(isActive);
|
||||
image.setImageView(_image, R.drawable.ic_error_pred);
|
||||
_image.visibility = View.VISIBLE;
|
||||
_textTag.visibility = if(!text.isNullOrEmpty()) View.VISIBLE else View.GONE;
|
||||
this.isButton = isButton;
|
||||
}
|
||||
fun setInfo(text: String, isActive: Boolean, isButton: Boolean = false) {
|
||||
_image.visibility = View.GONE;
|
||||
_text = text;
|
||||
_textTag.text = text;
|
||||
_textTag.visibility = if(!text.isNullOrEmpty()) View.VISIBLE else View.GONE;
|
||||
setToggle(isActive);
|
||||
this.isButton = isButton;
|
||||
}
|
||||
}
|
||||
|
|
@ -8,9 +8,7 @@ import android.widget.LinearLayout
|
|||
import com.futo.platformplayer.states.StatePlayer
|
||||
import com.futo.platformplayer.R
|
||||
import com.futo.platformplayer.UISlideOverlays
|
||||
import com.futo.platformplayer.api.media.models.video.IPlatformVideo
|
||||
import com.futo.platformplayer.constructs.Event0
|
||||
import com.futo.platformplayer.constructs.Event1
|
||||
import com.futo.platformplayer.views.lists.VideoListEditorView
|
||||
import com.futo.platformplayer.views.overlays.slideup.SlideUpMenuItem
|
||||
import com.futo.platformplayer.views.overlays.slideup.SlideUpMenuOverlay
|
||||
|
|
@ -25,7 +23,6 @@ class QueueEditorOverlay : LinearLayout {
|
|||
private val _overlayContainer: FrameLayout;
|
||||
|
||||
|
||||
val onOptions = Event1<IPlatformVideo>();
|
||||
val onClose = Event0();
|
||||
|
||||
constructor(context: Context, attrs: AttributeSet? = null) : super(context, attrs) {
|
||||
|
|
@ -38,9 +35,6 @@ class QueueEditorOverlay : LinearLayout {
|
|||
|
||||
_topbar.onClose.subscribe(this, onClose::emit);
|
||||
_editor.onVideoOrderChanged.subscribe { StatePlayer.instance.setQueueWithExisting(it) }
|
||||
_editor.onVideoOptions.subscribe { v ->
|
||||
onOptions?.emit(v);
|
||||
}
|
||||
_editor.onVideoRemoved.subscribe { v ->
|
||||
StatePlayer.instance.removeFromQueue(v);
|
||||
_topbar.setInfo(context.getString(R.string.queue), "${StatePlayer.instance.queueSize} " + context.getString(R.string.videos));
|
||||
|
|
|
|||
|
|
@ -113,13 +113,6 @@ class SlideUpMenuOverlay : RelativeLayout {
|
|||
_textOK.visibility = View.VISIBLE;
|
||||
}
|
||||
}
|
||||
fun getSlideUpItemByTag(itemTag: Any?): SlideUpMenuItem? {
|
||||
for(view in groupItems){
|
||||
if(view is SlideUpMenuItem && view.itemTag == itemTag)
|
||||
return view;
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
fun selectOption(groupTag: Any?, itemTag: Any?, multiSelect: Boolean = false, toggle: Boolean = false): Boolean {
|
||||
var didSelect = false;
|
||||
|
|
|
|||
|
|
@ -158,7 +158,7 @@ class SubscriptionBar : LinearLayout {
|
|||
for(button in buttons) {
|
||||
_tagsContainer.addView(ToggleTagView(context).apply {
|
||||
this.setInfo(button.name, button.isActive);
|
||||
this.onClick.subscribe({ view, value -> button.action(view, value); });
|
||||
this.onClick.subscribe { button.action(it); };
|
||||
});
|
||||
}
|
||||
}
|
||||
|
|
@ -166,16 +166,16 @@ class SubscriptionBar : LinearLayout {
|
|||
class Toggle {
|
||||
val name: String;
|
||||
val icon: Int;
|
||||
val action: (ToggleTagView, Boolean)->Unit;
|
||||
val action: (Boolean)->Unit;
|
||||
val isActive: Boolean;
|
||||
|
||||
constructor(name: String, icon: Int, isActive: Boolean = false, action: (ToggleTagView, Boolean)->Unit) {
|
||||
constructor(name: String, icon: Int, isActive: Boolean = false, action: (Boolean)->Unit) {
|
||||
this.name = name;
|
||||
this.icon = icon;
|
||||
this.action = action;
|
||||
this.isActive = isActive;
|
||||
}
|
||||
constructor(name: String, isActive: Boolean = false, action: (ToggleTagView, Boolean)->Unit) {
|
||||
constructor(name: String, isActive: Boolean = false, action: (Boolean)->Unit) {
|
||||
this.name = name;
|
||||
this.icon = 0;
|
||||
this.action = action;
|
||||
|
|
|
|||
|
|
@ -43,13 +43,13 @@ class SyncDeviceView : ConstraintLayout {
|
|||
|
||||
_layoutLinkType.visibility = View.VISIBLE
|
||||
_imageLinkType.setImageResource(when (linkType) {
|
||||
LinkType.Relayed -> R.drawable.ic_internet
|
||||
LinkType.Direct -> R.drawable.ic_lan
|
||||
LinkType.Proxied -> R.drawable.ic_internet
|
||||
LinkType.Local -> R.drawable.ic_lan
|
||||
else -> 0
|
||||
})
|
||||
_textLinkType.text = when(linkType) {
|
||||
LinkType.Relayed -> "Relayed"
|
||||
LinkType.Direct -> "Direct"
|
||||
LinkType.Proxied -> "Proxied"
|
||||
LinkType.Local -> "Local"
|
||||
else -> null
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -144,9 +144,6 @@
|
|||
android:layout_marginTop="10dp"
|
||||
android:layout_marginLeft="15dp"
|
||||
android:layout_marginRight="15dp"
|
||||
android:inputType="text"
|
||||
android:imeOptions="actionDone"
|
||||
android:singleLine="true"
|
||||
android:background="@drawable/background_button_round"
|
||||
android:hint="Search.." />
|
||||
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@
|
|||
android:ellipsize="end"
|
||||
app:layout_constraintLeft_toRightOf="@id/layout_video_thumbnail"
|
||||
app:layout_constraintTop_toTopOf="parent"
|
||||
app:layout_constraintRight_toLeftOf="@id/buttons"
|
||||
app:layout_constraintRight_toLeftOf="@id/image_trash"
|
||||
app:layout_constraintBottom_toTopOf="@id/text_author"
|
||||
android:layout_marginStart="10dp" />
|
||||
|
||||
|
|
@ -152,7 +152,7 @@
|
|||
android:ellipsize="end"
|
||||
app:layout_constraintLeft_toRightOf="@id/layout_video_thumbnail"
|
||||
app:layout_constraintTop_toBottomOf="@id/text_video_name"
|
||||
app:layout_constraintRight_toLeftOf="@id/buttons"
|
||||
app:layout_constraintRight_toLeftOf="@id/image_trash"
|
||||
app:layout_constraintBottom_toTopOf="@id/text_video_metadata"
|
||||
android:layout_marginStart="10dp" />
|
||||
|
||||
|
|
@ -169,35 +169,19 @@
|
|||
android:ellipsize="end"
|
||||
app:layout_constraintLeft_toRightOf="@id/layout_video_thumbnail"
|
||||
app:layout_constraintTop_toBottomOf="@id/text_author"
|
||||
app:layout_constraintRight_toLeftOf="@id/buttons"
|
||||
app:layout_constraintRight_toLeftOf="@id/image_trash"
|
||||
android:layout_marginStart="10dp" />
|
||||
|
||||
<LinearLayout
|
||||
android:id="@+id/buttons"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:orientation="vertical"
|
||||
<ImageButton
|
||||
android:id="@+id/image_trash"
|
||||
android:layout_width="40dp"
|
||||
android:layout_height="40dp"
|
||||
android:contentDescription="@string/cd_button_delete"
|
||||
app:srcCompat="@drawable/ic_trash_18dp"
|
||||
android:scaleType="fitCenter"
|
||||
android:paddingTop="10dp"
|
||||
android:paddingBottom="10dp"
|
||||
app:layout_constraintRight_toRightOf="parent"
|
||||
app:layout_constraintTop_toTopOf="@id/layout_video_thumbnail"
|
||||
app:layout_constraintBottom_toBottomOf="@id/layout_video_thumbnail" >
|
||||
<ImageButton
|
||||
android:id="@+id/image_trash"
|
||||
android:layout_width="40dp"
|
||||
android:layout_height="40dp"
|
||||
android:contentDescription="@string/cd_button_delete"
|
||||
app:srcCompat="@drawable/ic_trash_18dp"
|
||||
android:scaleType="fitCenter"
|
||||
android:paddingTop="10dp"
|
||||
android:paddingBottom="10dp"/>
|
||||
<ImageButton
|
||||
android:id="@+id/image_settings"
|
||||
android:layout_width="40dp"
|
||||
android:layout_height="40dp"
|
||||
android:contentDescription="@string/cd_button_settings"
|
||||
app:srcCompat="@drawable/ic_settings"
|
||||
android:scaleType="fitCenter"
|
||||
android:paddingTop="10dp"
|
||||
android:paddingBottom="10dp" />
|
||||
|
||||
</LinearLayout>
|
||||
app:layout_constraintBottom_toBottomOf="@id/layout_video_thumbnail" />
|
||||
</androidx.constraintlayout.widget.ConstraintLayout>
|
||||
|
|
@ -3,14 +3,14 @@
|
|||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content">
|
||||
|
||||
<HorizontalScrollView
|
||||
<ScrollView
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:scrollbars="horizontal">
|
||||
<LinearLayout
|
||||
android:id="@+id/container_tags"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_width="match_parent"
|
||||
android:layout_height="wrap_content"
|
||||
android:orientation="horizontal" />
|
||||
</HorizontalScrollView>
|
||||
</ScrollView>
|
||||
</LinearLayout>
|
||||
|
|
@ -3,37 +3,23 @@
|
|||
xmlns:tools="http://schemas.android.com/tools"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="32dp"
|
||||
android:paddingStart="12dp"
|
||||
android:paddingEnd="12dp"
|
||||
android:paddingStart="15dp"
|
||||
android:paddingEnd="15dp"
|
||||
android:background="@drawable/background_pill"
|
||||
android:layout_marginEnd="6dp"
|
||||
android:layout_marginTop="17dp"
|
||||
android:layout_marginBottom="8dp"
|
||||
android:id="@+id/root">
|
||||
<LinearLayout
|
||||
|
||||
<TextView
|
||||
android:id="@+id/text_tag"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="match_parent"
|
||||
android:orientation="horizontal">
|
||||
<ImageView
|
||||
android:id="@+id/image_tag"
|
||||
android:visibility="gone"
|
||||
android:layout_width="24dp"
|
||||
android:layout_height="24dp"
|
||||
android:layout_gravity="center"
|
||||
android:layout_marginLeft="2.5dp"
|
||||
android:layout_marginRight="2.5dp" />
|
||||
<TextView
|
||||
android:id="@+id/text_tag"
|
||||
android:layout_width="wrap_content"
|
||||
android:layout_height="wrap_content"
|
||||
android:layout_marginLeft="2.5dp"
|
||||
android:layout_marginRight="2.5dp"
|
||||
android:textColor="@color/white"
|
||||
android:layout_gravity="center"
|
||||
android:gravity="center"
|
||||
android:textSize="11dp"
|
||||
android:fontFamily="@font/inter_light"
|
||||
tools:text="Tag text" />
|
||||
</LinearLayout>
|
||||
android:layout_height="wrap_content"
|
||||
android:textColor="@color/white"
|
||||
android:layout_gravity="center"
|
||||
android:gravity="center"
|
||||
android:textSize="11dp"
|
||||
android:fontFamily="@font/inter_light"
|
||||
tools:text="Tag text" />
|
||||
|
||||
</FrameLayout>
|
||||
|
|
@ -72,8 +72,6 @@
|
|||
<string name="keep_screen_on_while_casting">Keep screen on while casting</string>
|
||||
<string name="always_proxy_requests">Always proxy requests</string>
|
||||
<string name="always_proxy_requests_description">Always proxy requests when casting data through the device.</string>
|
||||
<string name="allow_ipv6">Allow IPV6</string>
|
||||
<string name="allow_ipv6_description">If casting over IPV6 is allowed, can cause issues on some networks</string>
|
||||
<string name="discover">Discover</string>
|
||||
<string name="find_new_video_sources_to_add">Find new video sources to add</string>
|
||||
<string name="these_sources_have_been_disabled">These sources have been disabled</string>
|
||||
|
|
@ -372,12 +370,6 @@
|
|||
<string name="connect_discovered_description">Allow device to search for and initiate connection with known paired devices</string>
|
||||
<string name="connect_last">Try connect last</string>
|
||||
<string name="connect_last_description">Allow device to automatically connect to last known</string>
|
||||
<string name="discover_through_relay">Discover through relay</string>
|
||||
<string name="discover_through_relay_description">Allow paired devices to be discovered and connected to through the relay</string>
|
||||
<string name="pair_through_relay">Pair through relay</string>
|
||||
<string name="pair_through_relay_description">Allow devices to be paired through the relay</string>
|
||||
<string name="connect_through_relay">Connection through relay</string>
|
||||
<string name="connect_through_relay_description">Allow devices to be connected to through the relay</string>
|
||||
<string name="gesture_controls">Gesture controls</string>
|
||||
<string name="volume_slider">Volume slider</string>
|
||||
<string name="volume_slider_descr">Enable slide gesture to change volume</string>
|
||||
|
|
@ -425,10 +417,6 @@
|
|||
<string name="show_subscription_group_description">If subscription groups should be shown above your subscriptions to filter</string>
|
||||
<string name="preview_feed_items">Preview Feed Items</string>
|
||||
<string name="preview_feed_items_description">When the preview feedstyle is used, if items should auto-preview when scrolling over them</string>
|
||||
<string name="show_home_filters">Show Home Filters</string>
|
||||
<string name="show_home_filters_description">If the home filters should be shown above home</string>
|
||||
<string name="show_home_filters_plugin_names">Home filter Plugin Names</string>
|
||||
<string name="show_home_filters_plugin_names_description">If home filters should show full plugin names or just icons</string>
|
||||
<string name="log_level">Log Level</string>
|
||||
<string name="logging">Logging</string>
|
||||
<string name="sync_grayjay">Sync Grayjay</string>
|
||||
|
|
|
|||
|
|
@ -1 +1 @@
|
|||
Subproject commit 215cd9bd70d3cc68e25441f7696dcbe5beee2709
|
||||
Subproject commit f2f83344ebc905b36c0689bfef407bb95e6d9af0
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit f8234d6af8573414d07fd364bc136aa67ad0e379
|
||||
Subproject commit bff981c3ce7abad363e79705214a4710fb347f7d
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit b61095ec200284a686edb8f3b2a595599ad8b5ed
|
||||
Subproject commit 331dd929293614875af80e3ab4cb162dc6183410
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit 6f1266a038d11998fef429ae0eac0798b3280d75
|
||||
Subproject commit ae7b62f4d85cf398d9566a6ed07a6afc193f6b48
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit 215cd9bd70d3cc68e25441f7696dcbe5beee2709
|
||||
Subproject commit f2f83344ebc905b36c0689bfef407bb95e6d9af0
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit f8234d6af8573414d07fd364bc136aa67ad0e379
|
||||
Subproject commit bff981c3ce7abad363e79705214a4710fb347f7d
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit b61095ec200284a686edb8f3b2a595599ad8b5ed
|
||||
Subproject commit 331dd929293614875af80e3ab4cb162dc6183410
|
||||
|
|
@ -1 +1 @@
|
|||
Subproject commit 6f1266a038d11998fef429ae0eac0798b3280d75
|
||||
Subproject commit ae7b62f4d85cf398d9566a6ed07a6afc193f6b48
|
||||
Loading…
Add table
Reference in a new issue