Updated submodules.

improve full screen portrait docs

See merge request videostreaming/grayjay!79

.github/ISSUE_TEMPLATE/bug_report.yml

@@ -1,19 +1,19 @@
 name: Bug Report
 description: Let us know about an unexpected error, a crash, or an incorrect behavior.
-labels: ["bug", "new"]
+labels: ["Bug"]
 body:
   - type: markdown
     attributes:
       value: |
         # Thank you for taking the time to fill out this bug report.
-        
+
         The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application
 
         For general usage questions, please see: [The Official FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)
 
         ## Filing a bug report
 
-        To fix your issues faster, we need clear reproduction cases - ideally allowing us to make it happen locally. 
+        To fix your issues faster, we need clear reproduction cases - ideally allowing us to make it happen locally.
         * Please include all needed context. For example, Device, OS, Application, your Grayjay Configurations and Plugin versioning info.
         * if you've found out a particular series of UI interactions can introduce buggy behavior, please label those steps 1-n with markdown
 
@@ -41,18 +41,21 @@ body:
       label: What plugins are you seeing the problem on?
       multiple: true
       options:
-        - All
-        - Youtube
-        - BiliBili (CN)
-        - Twitch
-        - Odysee
-        - Rumble
-        - Kick
-        - PeerTube
-        - Patreon
-        - Nebula
-        - SoundCloud
-        - Other
+        - "All"
+        - "Youtube"
+        - "Odysee"
+        - "Rumble"
+        - "Kick"
+        - "Twitch"
+        - "PeerTube"
+        - "Patreon"
+        - "Nebula"
+        - "BiliBili (CN)"
+        - "Bitchute"
+        - "SoundCloud"
+        - "Dailymotion"
+        - "Apple Podcasts"
+        - "Other"
     validations:
       required: true
 
@@ -72,6 +75,17 @@ body:
       - label: While logged out
       - label: N/A
 
+  - type: dropdown
+    id: vpn
+    attributes:
+      label: Are you using a VPN?
+      multiple: false
+      options:
+        - "No"
+        - "Yes"
+    validations:
+      required: true
+
   - type: textarea
     id: logs
     attributes:

.github/ISSUE_TEMPLATE/documentation_issue.yml

@@ -1,13 +1,13 @@
 name: Documentation Issue
 description: Report an issue or suggest a change in the documentation.
-labels: ["documentation", "new"]
+labels: ["Documentation"]
 body:
   - type: markdown
     attributes:
       value: |
         # Thank you for opening a documentation change request.
 
-        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application. Use the `Documentation` issue type to report problems with the documentation in our code repositories, inside the application, or on [https://grayjay.app](https://grayjay.app) 
+        The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application. Use the `Documentation` issue type to report problems with the documentation in our code repositories, inside the application, or on [https://grayjay.app](https://grayjay.app)
         Technical writers monitor this issue type, so report Grayjay bugs or feature requests with the `Bug report` or `Feature Request` issue types instead to get engineering attention.
 
         For general usage questions, please see: [The Official FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,6 +1,6 @@
 name: Feature Request
 description: Suggest a new feature or other enhancement.
-labels: ["enhancement", "new"]
+labels: ["Enhancement"]
 body:
   - type: markdown
     attributes:
@@ -9,8 +9,6 @@ body:
 
         The [grayjay-android](https://github.com/futo-org/grayjay-android) issue tracker is reserved for issues relating to the Grayjay Android Application
 
-        [External Contributions are closed at this time](https://github.com/tom-futo/grayjay-android/blob/master/CONTRIBUTION.md#contributing-to-core)
-
         For discussion related to enhancements, please see: [The FUTO Grayjay Zulip Channel](https://chat.futo.org/#narrow/stream/46-Grayjay)
 
   - type: textarea
@@ -55,4 +53,4 @@ body:
     attributes:
       value: |
         **Note:** If the submit button is disabled and you have filled out all required fields, please check that you did not forget a **Title** for the issue.
-        
+

.github/workflows/labeler.yml

@@ -1,34 +0,0 @@
-name: Issue labeler
-on:
-  issues:
-    types: [ opened ]
-
-permissions:
-  contents: read
-
-jobs:
-  label-component:
-    runs-on: ubuntu-latest
-
-    permissions:
-      # required for all workflows
-      issues: write
-
-    steps:
-      - uses: actions/checkout@v3
-
-      - name: Parse issue form
-        uses: stefanbuck/github-issue-parser@v3
-        id: issue-parser
-        with:
-          template-path: .github/ISSUE_TEMPLATE/bug_report.yml
-
-      - name: Set labels based on plugin field
-        uses: redhat-plumbers-in-action/advanced-issue-labeler@v2
-        with:
-          issue-form: ${{ steps.issue-parser.outputs.jsonString }}
-          section: plugin
-          block-list: |
-            None
-            Other
-          token: ${{ secrets.GITHUB_TOKEN }}

.gitmodules

@@ -82,3 +82,9 @@
 [submodule "app/src/stable/assets/sources/dailymotion"]
 	path = app/src/stable/assets/sources/dailymotion
 	url = ../plugins/dailymotion.git
+[submodule "app/src/stable/assets/sources/apple-podcast"]
+	path = app/src/stable/assets/sources/apple-podcast
+	url = ../plugins/apple-podcasts.git
+[submodule "app/src/unstable/assets/sources/apple-podcasts"]
+	path = app/src/unstable/assets/sources/apple-podcasts
+	url = ../plugins/apple-podcasts.git

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

@@ -415,8 +415,8 @@ class Settings : FragmentedStorageFileJson() {
         @FormField(R.string.simplify_sources, FieldForm.TOGGLE, R.string.simplify_sources_description, 4)
         var simplifySources: Boolean = true;
 
-        @FormField(R.string.force_allow_full_screen_rotation, FieldForm.TOGGLE, R.string.force_allow_full_screen_rotation_description, 5)
-        var forceAllowFullScreenRotation: Boolean = false
+        @FormField(R.string.always_allow_reverse_landscape_auto_rotate, FieldForm.TOGGLE, R.string.always_allow_reverse_landscape_auto_rotate_description, 5)
+        var alwaysAllowReverseLandscapeAutoRotate: Boolean = true
 
         @FormField(R.string.background_behavior, FieldForm.DROPDOWN, -1, 6)
         @DropdownFieldOptionsId(R.array.player_background_behavior)

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

@@ -1,6 +1,7 @@
 package com.futo.platformplayer
 
 import android.content.Context
+import android.content.Intent
 import android.webkit.CookieManager
 import androidx.work.Data
 import androidx.work.OneTimeWorkRequestBuilder

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

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

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

@@ -5,6 +5,8 @@ import com.futo.platformplayer.SettingsDev
 import com.futo.platformplayer.constructs.Event1
 import com.futo.platformplayer.ensureNotMainThread
 import com.futo.platformplayer.logging.Logger
+import com.futo.platformplayer.states.StateApp
+import com.futo.platformplayer.stores.FragmentedStorage
 import okhttp3.Call
 import okhttp3.MediaType.Companion.toMediaTypeOrNull
 import okhttp3.OkHttpClient
@@ -63,7 +65,7 @@ open class ManagedHttpClient {
 
     constructor(builder: OkHttpClient.Builder = OkHttpClient.Builder()) {
         _builderTemplate = builder;
-        if(SettingsDev.instance.developerMode && SettingsDev.instance.networking.allowAllCertificates)
+        if(FragmentedStorage.isInitialized && StateApp.instance.isMainActive && SettingsDev.instance.developerMode && SettingsDev.instance.networking.allowAllCertificates)
             trustAllCertificates(builder);
         client = builder.addNetworkInterceptor { chain ->
             val request = beforeRequest(chain.request());

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

@@ -2,7 +2,9 @@ package com.futo.platformplayer.engine.packages
 
 import com.caoccao.javet.annotations.V8Function
 import com.caoccao.javet.annotations.V8Property
+import com.caoccao.javet.utils.JavetResourceUtils
 import com.caoccao.javet.values.V8Value
+import com.caoccao.javet.values.reference.V8ValueFunction
 import com.futo.platformplayer.BuildConfig
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.states.StateDeveloper
@@ -16,6 +18,7 @@ import com.futo.platformplayer.engine.IV8PluginConfig
 import com.futo.platformplayer.engine.V8Plugin
 import com.futo.platformplayer.states.StateApp
 import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
 import kotlinx.coroutines.launch
 import kotlinx.serialization.Serializable
 import kotlinx.serialization.encodeToString
@@ -37,6 +40,18 @@ class PackageBridge : V8Package {
         _config = config;
         _client = plugin.httpClient;
         _clientAuth = plugin.httpClientAuth;
+
+        withScript("""
+             function setTimeout(func, delay) {
+                 let args = Array.prototype.slice.call(arguments, 2);
+                 return bridge.setTimeout(func.bind(globalThis, ...args), delay || 0);
+             }
+        """.trimIndent());
+        withScript("""
+               function clearTimeout(id) {
+                    bridge.clearTimeout(id);
+                }
+        """.trimIndent());
     }
 
 
@@ -62,6 +77,48 @@ class PackageBridge : V8Package {
         value.close();
     }
 
+    var timeoutCounter = 0;
+    var timeoutMap = HashSet<Int>();
+    @V8Function
+    fun setTimeout(func: V8ValueFunction, timeout: Long): Int {
+        val id = timeoutCounter++;
+
+        val funcClone = func.toClone<V8ValueFunction>()
+
+        StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
+            delay(timeout);
+            synchronized(timeoutMap) {
+                if(!timeoutMap.contains(id)) {
+                    JavetResourceUtils.safeClose(funcClone);
+                    return@launch;
+                }
+                timeoutMap.remove(id);
+            }
+            try {
+                _plugin.whenNotBusy {
+                    funcClone.callVoid(null, arrayOf<Any>());
+                }
+            }
+            catch(ex: Throwable) {
+                Logger.e(TAG, "Failed timeout callback", ex);
+            }
+            finally {
+                JavetResourceUtils.safeClose(funcClone);
+            }
+        };
+        synchronized(timeoutMap) {
+            timeoutMap.add(id);
+        }
+        return id;
+    }
+    @V8Function
+    fun clearTimeout(id: Int) {
+        synchronized(timeoutMap) {
+            if(timeoutMap.contains(id))
+                timeoutMap.remove(id);
+        }
+    }
+
     @V8Function
     fun toast(str: String) {
         Logger.i(TAG, "Plugin toast [${_config.name}]: ${str}");

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

@@ -1,11 +1,16 @@
 package com.futo.platformplayer.fragment.mainactivity.main
 
 import android.annotation.SuppressLint
+import android.content.Context
 import android.content.pm.ActivityInfo
 import android.content.res.Configuration
+import android.database.ContentObserver
 import android.os.Build
 import android.os.Bundle
+import android.os.Handler
+import android.os.Looper
 import android.view.LayoutInflater
+import android.view.OrientationEventListener
 import android.view.View
 import android.view.ViewGroup
 import android.view.WindowInsets
@@ -28,13 +33,18 @@ import com.futo.platformplayer.models.PlatformVideoWithTime
 import com.futo.platformplayer.models.UrlVideoWithTime
 import com.futo.platformplayer.states.StatePlayer
 import com.futo.platformplayer.views.containers.SingleViewTouchableMotionLayout
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.launch
 import kotlin.math.min
 
+//region Fragment
 @UnstableApi
-class VideoDetailFragment : MainFragment {
-    override val isMainView : Boolean = false;
+class VideoDetailFragment() : MainFragment() {
+    override val isMainView: Boolean = false;
     override val hasBottomBar: Boolean = true;
-    override val isOverlay : Boolean = true;
+    override val isOverlay: Boolean = true;
     override val isHistory: Boolean = false;
 
     private var _isActive: Boolean = false;
@@ -76,8 +86,9 @@ class VideoDetailFragment : MainFragment {
     private var _loadUrlOnCreate: UrlVideoWithTime? = null;
     private var _leavingPiP = false;
 
-//region Fragment
-    constructor() : super()
+    private var _landscapeOrientationListener: LandscapeOrientationListener? = null
+    private var _portraitOrientationListener: PortraitOrientationListener? = null
+    private var _autoRotateObserver: AutoRotateObserver? = null
 
     fun nextVideo() {
         _viewDetail?.nextVideo(true, true, true);
@@ -88,23 +99,27 @@ class VideoDetailFragment : MainFragment {
     }
 
     private fun isSmallWindow(): Boolean {
-        return min(
-            resources.configuration.screenWidthDp,
-            resources.configuration.screenHeightDp
-        ) < resources.getInteger(R.integer.column_width_dp) * 2
+        return resources.configuration.smallestScreenWidthDp < resources.getInteger(R.integer.column_width_dp) * 2
+    }
+
+    private fun isAutoRotateEnabled(): Boolean {
+        return android.provider.Settings.System.getInt(
+            context?.contentResolver,
+            android.provider.Settings.System.ACCELEROMETER_ROTATION, 0
+        ) == 1
     }
 
     override fun onConfigurationChanged(newConfig: Configuration) {
         super.onConfigurationChanged(newConfig)
 
         val isLandscapeVideo: Boolean = _viewDetail?.isLandscapeVideo() ?: false
-
         val isSmallWindow = isSmallWindow()
 
         if (
             isSmallWindow
             && newConfig.orientation == Configuration.ORIENTATION_LANDSCAPE
             && !isFullscreen
+            && !isInPictureInPicture
             && state == State.MAXIMIZED
         ) {
             _viewDetail?.setFullscreen(true)
@@ -141,6 +156,8 @@ class VideoDetailFragment : MainFragment {
         ) {
             _viewDetail?.setFullscreen(true)
         }
+
+        updateOrientation()
     }
 
     fun updateOrientation() {
@@ -148,25 +165,50 @@ class VideoDetailFragment : MainFragment {
         val isFullScreenPortraitAllowed = Settings.instance.playback.fullscreenPortrait
         val isReversePortraitAllowed = Settings.instance.playback.reversePortrait
         val rotationLock = StatePlayer.instance.rotationLock
+        val alwaysAllowReverseLandscapeAutoRotate = Settings.instance.playback.alwaysAllowReverseLandscapeAutoRotate
 
-        val isLandscapeVideo: Boolean = _viewDetail?.isLandscapeVideo() ?: false
+        val isLandscapeVideo: Boolean = _viewDetail?.isLandscapeVideo() ?: true
 
         val isSmallWindow = isSmallWindow()
+        val autoRotateEnabled = isAutoRotateEnabled()
 
         // For small windows if the device isn't landscape right now and full screen portrait isn't allowed then we should force landscape
         if (isSmallWindow && isFullscreen && !isFullScreenPortraitAllowed && resources.configuration.orientation == Configuration.ORIENTATION_PORTRAIT && !rotationLock && isLandscapeVideo) {
-            if(Settings.instance.playback.forceAllowFullScreenRotation){
+            if (alwaysAllowReverseLandscapeAutoRotate){
                 a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
-            }else{
+            } else {
                 a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_USER_LANDSCAPE
             }
+            if (autoRotateEnabled
+            ) {
+                // start listening for the device to rotate to landscape
+                // at which point we'll be able to set requestedOrientation to back to UNSPECIFIED
+                _landscapeOrientationListener?.enableListener()
+            }
+        }
+        // For small windows if always all reverse landscape then we'll lock the orientation to landscape when system auto-rotate is off to make sure that locking
+        // and unlockiung in the player settings keep orientation in landscape
+        else if (isSmallWindow && isFullscreen && !isFullScreenPortraitAllowed && alwaysAllowReverseLandscapeAutoRotate && !rotationLock && isLandscapeVideo && !autoRotateEnabled) {
+            a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE
         }
         // For small windows if the device isn't in a portrait orientation and we're in the maximized state then we should force portrait
+        // only do this if auto-rotate is on portrait is forced when leaving full screen for autorotate off
         else if (isSmallWindow && !isMinimizingFromFullScreen && !isFullscreen && state == State.MAXIMIZED && resources.configuration.orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            @SuppressLint("SourceLockedOrientationActivity")
             a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+            if (autoRotateEnabled
+            ) {
+                // start listening for the device to rotate to portrait
+                // at which point we'll be able to set requestedOrientation to back to UNSPECIFIED
+                _portraitOrientationListener?.enableListener()
+            }
         } else if (rotationLock) {
+            _portraitOrientationListener?.disableListener()
+            _landscapeOrientationListener?.disableListener()
             a.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_LOCKED
         } else {
+            _portraitOrientationListener?.disableListener()
+            _landscapeOrientationListener?.disableListener()
             a.requestedOrientation = if (isReversePortraitAllowed) {
                 ActivityInfo.SCREEN_ORIENTATION_FULL_USER
             } else {
@@ -341,6 +383,30 @@ class VideoDetailFragment : MainFragment {
         StatePlayer.instance.onRotationLockChanged.subscribe(this) {
             updateOrientation()
         }
+
+        val delayBeforeRemoveRotationLock = 800L
+
+        _landscapeOrientationListener = LandscapeOrientationListener(requireContext())
+        {
+            CoroutineScope(Dispatchers.Main).launch {
+                // delay to make sure that the system auto rotate updates
+                delay(delayBeforeRemoveRotationLock)
+                updateOrientation()
+            }
+        }
+        _portraitOrientationListener = PortraitOrientationListener(requireContext())
+        {
+            CoroutineScope(Dispatchers.Main).launch {
+                // delay to make sure that the system auto rotate updates
+                delay(delayBeforeRemoveRotationLock)
+                updateOrientation()
+            }
+        }
+        _autoRotateObserver = AutoRotateObserver(requireContext(), Handler(Looper.getMainLooper())) {
+            updateOrientation()
+        }
+        _autoRotateObserver?.startObserving()
+
         return _view!!;
     }
 
@@ -442,6 +508,10 @@ class VideoDetailFragment : MainFragment {
         SettingsActivity.settingsActivityClosed.remove(this)
         StatePlayer.instance.onRotationLockChanged.remove(this)
 
+        _landscapeOrientationListener?.disableListener()
+        _portraitOrientationListener?.disableListener()
+        _autoRotateObserver?.stopObserving()
+
         _viewDetail?.let {
             _viewDetail = null;
             it.onDestroy();
@@ -513,6 +583,11 @@ class VideoDetailFragment : MainFragment {
             showSystemUI()
         }
 
+        // temporarily force the device to portrait if auto-rotate is disabled to prevent landscape when exiting full screen on a small device
+//        @SuppressLint("SourceLockedOrientationActivity")
+//        if (!isFullscreen && isSmallWindow() && !isAutoRotateEnabled() && !isMinimizingFromFullScreen) {
+//            activity?.requestedOrientation = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT
+//        }
         updateOrientation();
         _view?.allowMotion = !fullscreen;
     }
@@ -534,4 +609,88 @@ class VideoDetailFragment : MainFragment {
 //region View
     //TODO: Determine if encapsulated would be readable enough
 //endregion
-}
+}
+
+class LandscapeOrientationListener(
+    context: Context,
+    private val onLandscapeDetected: () -> Unit
+) : OrientationEventListener(context) {
+
+    private var isListening = false
+
+    override fun onOrientationChanged(orientation: Int) {
+        if (!isListening) return
+
+        if (orientation in 60..120 || orientation in 240..300) {
+            onLandscapeDetected()
+            disableListener()
+        }
+    }
+
+    fun enableListener() {
+        if (!isListening) {
+            isListening = true
+            enable()
+        }
+    }
+
+    fun disableListener() {
+        if (isListening) {
+            isListening = false
+            disable()
+        }
+    }
+}
+
+class PortraitOrientationListener(
+    context: Context,
+    private val onPortraitDetected: () -> Unit
+) : OrientationEventListener(context) {
+
+    private var isListening = false
+
+    override fun onOrientationChanged(orientation: Int) {
+        if (!isListening) return
+
+        if (orientation in 0..30 || orientation in 330..360 || orientation in 150..210) {
+            onPortraitDetected()
+            disableListener()
+        }
+    }
+
+    fun enableListener() {
+        if (!isListening) {
+            isListening = true
+            enable()
+        }
+    }
+
+    fun disableListener() {
+        if (isListening) {
+            isListening = false
+            disable()
+        }
+    }
+}
+
+class AutoRotateObserver(context: Context, handler: Handler, private val onAutoRotateChanged: () -> Unit) : ContentObserver(handler) {
+    private val contentResolver = context.contentResolver
+
+    override fun onChange(selfChange: Boolean) {
+        super.onChange(selfChange)
+
+        onAutoRotateChanged()
+    }
+
+    fun startObserving() {
+        contentResolver.registerContentObserver(
+            android.provider.Settings.System.getUriFor(android.provider.Settings.System.ACCELEROMETER_ROTATION),
+            false,
+            this
+        )
+    }
+
+    fun stopObserving() {
+        contentResolver.unregisterContentObserver(this)
+    }
+}

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

@@ -649,18 +649,9 @@ class VideoDetailView : ConstraintLayout {
         };
 
         var hadDevice = false;
-        StateSync.instance.deviceUpdatedOrAdded.subscribe(this) { id, session ->
-            val hasDevice = StateSync.instance.hasAtLeastOneOnlineDevice();
-            if(hasDevice != hadDevice) {
-                hadDevice = hasDevice;
-                fragment.lifecycleScope.launch(Dispatchers.Main) {
-                    updateMoreButtons();
-                }
-            }
-        };
-        StateSync.instance.deviceRemoved.subscribe(this) { id ->
-            val hasDevice = StateSync.instance.hasAtLeastOneOnlineDevice();
-            if(hasDevice != hadDevice) {
+        val devicesChanged = { id: String ->
+            val hasDevice = StateSync.instance.hasAuthorizedDevice();
+            if (hasDevice != hadDevice) {
                 hadDevice = hasDevice;
                 fragment.lifecycleScope.launch(Dispatchers.Main) {
                     updateMoreButtons();
@@ -668,6 +659,9 @@ class VideoDetailView : ConstraintLayout {
             }
         }
 
+        StateSync.instance.deviceUpdatedOrAdded.subscribe(this) { id, _ -> devicesChanged(id) };
+        StateSync.instance.deviceRemoved.subscribe(this) { id -> devicesChanged(id) };
+
         MediaControlReceiver.onLowerVolumeReceived.subscribe(this) { handleLowerVolume() };
         MediaControlReceiver.onPlayReceived.subscribe(this) { handlePlay() };
         MediaControlReceiver.onPauseReceived.subscribe(this) { handlePause() };
@@ -922,18 +916,25 @@ class VideoDetailView : ConstraintLayout {
                 };
                 _slideUpOverlay?.hide();
             },
-            if(StateSync.instance.hasAtLeastOneOnlineDevice()) {
+            if (StateSync.instance.hasAuthorizedDevice()) {
                 RoundButton(context, R.drawable.ic_device, context.getString(R.string.send_to_device), TAG_SEND_TO_DEVICE) {
-                    val devices = StateSync.instance.getSessions();
+                    val devices = StateSync.instance.getAuthorizedSessions();
                     val videoToSend = video ?: return@RoundButton;
                     if(devices.size > 1) {
                         //not implemented
-                    }
-                    else if(devices.size == 1){
+                    } else if(devices.size == 1){
                         val device = devices.first();
+                        Logger.i(TAG, "Send to device? (public key: ${device.remotePublicKey}): " + videoToSend.url)
                         UIDialogs.showConfirmationDialog(context, "Would you like to open\n[${videoToSend.name}]\non ${device.remotePublicKey}" , {
+                            Logger.i(TAG, "Send to device confirmed (public key: ${device.remotePublicKey}): " + videoToSend.url)
+
                             fragment.lifecycleScope.launch(Dispatchers.IO) {
-                                device.sendJsonData(GJSyncOpcodes.sendToDevices, SendToDevicePackage(videoToSend.url, (lastPositionMilliseconds/1000).toInt()));
+                                try {
+                                    device.sendJsonData(GJSyncOpcodes.sendToDevices, SendToDevicePackage(videoToSend.url, (lastPositionMilliseconds / 1000).toInt()))
+                                    Logger.i(TAG, "Send to device packet sent (public key: ${device.remotePublicKey}): " + videoToSend.url)
+                                } catch (e: Throwable) {
+                                    Logger.e(TAG, "Send to device packet failed to send", e)
+                                }
                             }
                         })
                     }
@@ -2384,8 +2385,13 @@ class VideoDetailView : ConstraintLayout {
     }
 
     fun isLandscapeVideo(): Boolean? {
-        val videoSourceWidth = _player.exoPlayer?.player?.videoSize?.width
-        val videoSourceHeight = _player.exoPlayer?.player?.videoSize?.height
+        var videoSourceWidth = _player.exoPlayer?.player?.videoSize?.width
+        var videoSourceHeight = _player.exoPlayer?.player?.videoSize?.height
+
+        if (video?.video?.videoSources?.isNotEmpty() == true && (videoSourceWidth == null || videoSourceHeight == null || videoSourceWidth == 0 || videoSourceHeight == 0)) {
+            videoSourceWidth = video?.video?.videoSources!![0].width
+            videoSourceHeight = video?.video?.videoSources!![0].height
+        }
 
         return if (videoSourceWidth == null || videoSourceHeight == null || videoSourceWidth == 0 || videoSourceHeight == 0){
             null

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

@@ -13,16 +13,15 @@ import com.futo.platformplayer.api.media.models.streams.IVideoSourceDescriptor
 import com.futo.platformplayer.api.media.models.streams.VideoUnMuxedSourceDescriptor
 import com.futo.platformplayer.api.media.models.streams.sources.IAudioSource
 import com.futo.platformplayer.api.media.models.streams.sources.IAudioUrlSource
-import com.futo.platformplayer.api.media.models.streams.sources.IAudioUrlWidevineSource
 import com.futo.platformplayer.api.media.models.streams.sources.IHLSManifestAudioSource
 import com.futo.platformplayer.api.media.models.streams.sources.IHLSManifestSource
 import com.futo.platformplayer.api.media.models.streams.sources.IVideoSource
 import com.futo.platformplayer.api.media.models.streams.sources.IVideoUrlSource
+import com.futo.platformplayer.api.media.models.streams.sources.IWidevineSource
 import com.futo.platformplayer.api.media.models.video.IPlatformVideoDetails
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSAudioUrlRangeSource
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSDashManifestRawAudioSource
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSDashManifestRawSource
-import com.futo.platformplayer.api.media.platforms.js.models.sources.JSSource
 import com.futo.platformplayer.api.media.platforms.js.models.sources.JSVideoUrlRangeSource
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.others.Language
@@ -47,8 +46,8 @@ class VideoHelper {
             return false
         }
 
-        fun isDownloadable(source: IVideoSource) = source is IVideoUrlSource || source is IHLSManifestSource || source is JSDashManifestRawSource;
-        fun isDownloadable(source: IAudioSource) = (source is IAudioUrlSource || source is IHLSManifestAudioSource || source is JSDashManifestRawAudioSource) && source !is IAudioUrlWidevineSource
+        fun isDownloadable(source: IVideoSource) = (source is IVideoUrlSource || source is IHLSManifestSource || source is JSDashManifestRawSource) && source !is IWidevineSource
+        fun isDownloadable(source: IAudioSource) = (source is IAudioUrlSource || source is IHLSManifestAudioSource || source is JSDashManifestRawAudioSource) && source !is IWidevineSource
 
         fun selectBestVideoSource(desc: IVideoSourceDescriptor, desiredPixelCount : Int, prefContainers : Array<String>) : IVideoSource? = selectBestVideoSource(desc.videoSources.toList(), desiredPixelCount, prefContainers);
         fun selectBestVideoSource(sources: Iterable<IVideoSource>, desiredPixelCount : Int, prefContainers : Array<String>) : IVideoSource? {

app/src/main/java/com/futo/platformplayer/states/StateAssets.kt

@@ -1,6 +1,7 @@
 package com.futo.platformplayer.states
 
 import android.content.Context
+import com.futo.platformplayer.logging.Logger
 import kotlin.streams.asSequence
 
 /***
@@ -45,10 +46,16 @@ class StateAssets {
             var text: String?;
             synchronized(_cache) {
                 if (!_cache.containsKey(path)) {
-                    text = context.assets
-                        ?.open(path)
-                        ?.bufferedReader()
-                        ?.use { it.readText(); };
+                    try {
+                        text = context.assets
+                            ?.open(path)
+                            ?.bufferedReader()
+                            ?.use { it.readText(); };
+                    }
+                    catch(ex: Throwable) {
+                        Logger.e("StateAssets", "Could not open asset: " + path, ex);
+                        return null;
+                    }
 
                     _cache.put(path, text);
                 } else {

app/src/main/java/com/futo/platformplayer/states/StateHistory.kt

@@ -8,6 +8,7 @@ import com.futo.platformplayer.constructs.Event2
 import com.futo.platformplayer.logging.Logger
 import com.futo.platformplayer.models.HistoryVideo
 import com.futo.platformplayer.models.ImportCache
+import com.futo.platformplayer.states.StatePlaylists.Companion
 import com.futo.platformplayer.stores.FragmentedStorage
 import com.futo.platformplayer.stores.db.ManagedDBStore
 import com.futo.platformplayer.stores.db.types.DBHistory
@@ -89,12 +90,14 @@ class StateHistory {
                 if(isUserAction && _lastHistoryBroadcast != historyBroadcastSig) {
                     _lastHistoryBroadcast = historyBroadcastSig;
                     StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-                        if(StateSync.instance.hasAtLeastOneOnlineDevice()) {
+                        try {
                             Logger.i(TAG, "SyncHistory playback broadcasted (${liveObj.name}: ${position})");
                             StateSync.instance.broadcastJsonData(
                                 GJSyncOpcodes.syncHistory,
                                 listOf(historyVideo)
                             );
+                        } catch (e: Throwable) {
+                            Logger.e(StatePlaylists.TAG, "Failed to broadcast sync history", e)
                         }
                     };
                 }

app/src/main/java/com/futo/platformplayer/states/StatePlaylists.kt

@@ -227,31 +227,50 @@ class StatePlaylists {
 
     private fun broadcastWatchLater(orderOnly: Boolean = false) {
         StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-            StateSync.instance.broadcastJsonData(GJSyncOpcodes.syncWatchLater, SyncWatchLaterPackage(
-                if(orderOnly) listOf() else getWatchLater(),
-                if(orderOnly) mapOf() else _watchLaterAdds.all(),
-                if(orderOnly) mapOf() else _watchLaterRemovals.all(),
-                getWatchLaterLastReorderTime().toEpochSecond(),
-                _watchlistOrderStore.values.toList()));
+            try {
+                StateSync.instance.broadcastJsonData(
+                    GJSyncOpcodes.syncWatchLater, SyncWatchLaterPackage(
+                        if (orderOnly) listOf() else getWatchLater(),
+                        if (orderOnly) mapOf() else _watchLaterAdds.all(),
+                        if (orderOnly) mapOf() else _watchLaterRemovals.all(),
+                        getWatchLaterLastReorderTime().toEpochSecond(),
+                        _watchlistOrderStore.values.toList()
+                    )
+                );
+            } catch (e: Throwable) {
+                Logger.w(TAG, "Failed to broadcast watch later", e)
+            }
         };
     }
     private fun broadcastWatchLaterAddition(video: SerializedPlatformVideo, time: OffsetDateTime) {
         StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-            StateSync.instance.broadcastJsonData(GJSyncOpcodes.syncWatchLater, SyncWatchLaterPackage(
-                listOf(video),
-                mapOf(Pair(video.url, time.toEpochSecond())),
-                mapOf(),
+            try {
+                StateSync.instance.broadcastJsonData(
+                    GJSyncOpcodes.syncWatchLater, SyncWatchLaterPackage(
+                        listOf(video),
+                        mapOf(Pair(video.url, time.toEpochSecond())),
+                        mapOf(),
 
-            ))
+                        )
+                )
+            } catch (e: Throwable) {
+                Logger.w(TAG, "Failed to broadcast watch later addition", e)
+            }
         };
     }
     private fun broadcastWatchLaterRemoval(url: String, time: OffsetDateTime) {
         StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-            StateSync.instance.broadcastJsonData(GJSyncOpcodes.syncWatchLater, SyncWatchLaterPackage(
-                listOf(),
-                mapOf(),
-                mapOf(Pair(url, time.toEpochSecond()))
-            ))
+            try {
+                StateSync.instance.broadcastJsonData(
+                    GJSyncOpcodes.syncWatchLater, SyncWatchLaterPackage(
+                        listOf(),
+                        mapOf(),
+                        mapOf(Pair(url, time.toEpochSecond()))
+                    )
+                )
+            } catch (e: Throwable) {
+                Logger.w(TAG, "Failed to broadcast watch later removal", e)
+            }
         };
     }
 
@@ -300,12 +319,14 @@ class StatePlaylists {
 
     private fun broadcastSyncPlaylist(playlist: Playlist){
         StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-            if(StateSync.instance.hasAtLeastOneOnlineDevice()) {
+            try {
                 Logger.i(StateSubscriptionGroups.TAG, "SyncPlaylist (${playlist.name})");
                 StateSync.instance.broadcastJsonData(
                     GJSyncOpcodes.syncPlaylists,
                     SyncPlaylistsPackage(listOf(playlist), mapOf())
                 );
+            } catch (e: Throwable) {
+                Logger.e(TAG, "Failed to broadcast sync playlist", e)
             }
         };
     }
@@ -319,12 +340,14 @@ class StatePlaylists {
             _playlistRemoved.setAndSave(playlist.id, OffsetDateTime.now());
 
             StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-                if(StateSync.instance.hasAtLeastOneOnlineDevice()) {
+                try {
                     Logger.i(StateSubscriptionGroups.TAG, "SyncPlaylist (${playlist.name})");
                     StateSync.instance.broadcastJsonData(
                         GJSyncOpcodes.syncPlaylists,
                         SyncPlaylistsPackage(listOf(), mapOf(Pair(playlist.id, OffsetDateTime.now().toEpochSecond())))
                     );
+                } catch (e: Throwable) {
+                    Logger.e(TAG, "Failed to broadcast sync playlists", e)
                 }
             };
         }

app/src/main/java/com/futo/platformplayer/states/StateSubscriptionGroups.kt

@@ -79,12 +79,14 @@ class StateSubscriptionGroups {
             onGroupsChanged.emit();
         if(!preventSync) {
             StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-                if(StateSync.instance.hasAtLeastOneOnlineDevice()) {
+                try {
                     Logger.i(TAG, "SyncSubscriptionGroup (${subGroup.name})");
                     StateSync.instance.broadcastJsonData(
                         GJSyncOpcodes.syncSubscriptionGroups,
                         SyncSubscriptionGroupsPackage(listOf(subGroup), mapOf())
                     );
+                } catch (e: Throwable) {
+                    Logger.e(TAG, "Failed to broadcast update subscription group", e)
                 }
             };
         }
@@ -98,12 +100,14 @@ class StateSubscriptionGroups {
             if(isUserInteraction) {
                 _groupsRemoved.setAndSave(id, OffsetDateTime.now());
                 StateApp.instance.scopeOrNull?.launch(Dispatchers.IO) {
-                    if(StateSync.instance.hasAtLeastOneOnlineDevice()) {
+                    try {
                         Logger.i(TAG, "SyncSubscriptionGroup delete (${group.name})");
                         StateSync.instance.broadcastJsonData(
                             GJSyncOpcodes.syncSubscriptionGroups,
                             SyncSubscriptionGroupsPackage(listOf(), mapOf(Pair(id, OffsetDateTime.now().toEpochSecond())))
                         );
+                    } catch (e: Throwable) {
+                        Logger.e(TAG, "Failed to delete subscription group", e)
                     }
                 };
             }

app/src/main/java/com/futo/platformplayer/states/StateSync.kt

@@ -65,6 +65,12 @@ class StateSync {
     val deviceRemoved: Event1<String> = Event1()
     val deviceUpdatedOrAdded: Event2<String, SyncSession> = Event2()
 
+    fun hasAuthorizedDevice(): Boolean {
+        synchronized(_sessions) {
+            return _sessions.any{ it.value.connected && it.value.isAuthorized };
+        }
+    }
+
     fun start() {
         if (_started) {
             Logger.i(TAG, "Already started.")
@@ -216,6 +222,11 @@ class StateSync {
             return _sessions.values.toList()
         };
     }
+    fun getAuthorizedSessions(): List<SyncSession> {
+        return synchronized(_sessions) {
+            return _sessions.values.filter { it.isAuthorized }.toList()
+        };
+    }
 
     fun getSyncSessionData(key: String): SyncSessionData {
         return _syncSessionData.get(key) ?: SyncSessionData(key);
@@ -349,8 +360,12 @@ class StateSync {
                             scope.launch(Dispatchers.Main) {
                                 UIDialogs.showConfirmationDialog(activity, "Allow connection from ${remotePublicKey}?", action = {
                                     scope.launch(Dispatchers.IO) {
-                                        session!!.authorize(s)
-                                        Logger.i(TAG, "Connection authorized for ${remotePublicKey} by confirmation")
+                                        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) {
@@ -404,11 +419,9 @@ class StateSync {
         broadcast(opcode, subOpcode, data.toByteArray(Charsets.UTF_8));
     }
     fun broadcast(opcode: UByte, subOpcode: UByte, data: ByteArray) {
-        for(session in getSessions()) {
+        for(session in getAuthorizedSessions()) {
             try {
-                if (session.isAuthorized && session.connected) {
-                    session.send(opcode, subOpcode, data);
-                }
+                session.send(opcode, subOpcode, data);
             }
             catch(ex: Exception) {
                 Logger.w(TAG, "Failed to broadcast (opcode = ${opcode}, subOpcode = ${subOpcode}) to ${session.remotePublicKey}: ${ex.message}}", ex);
@@ -450,17 +463,6 @@ class StateSync {
         return session
     }
 
-    fun hasAtLeastOneDevice(): Boolean {
-        synchronized(_authorizedDevices) {
-            return _authorizedDevices.values.isNotEmpty()
-        }
-    }
-    fun hasAtLeastOneOnlineDevice(): Boolean {
-        synchronized(_sessions) {
-            return _sessions.any{ it.value.connected && it.value.isAuthorized };
-        }
-    }
-
     fun getAll(): List<String> {
         synchronized(_authorizedDevices) {
             return _authorizedDevices.values.toList()

app/src/main/java/com/futo/platformplayer/states/StateUpdate.kt

@@ -189,9 +189,9 @@ class StateUpdate {
             }
         } catch (e: Throwable) {
             Logger.w(TAG, "Failed to check for updates.", e);
-
+            android.util.Log.e(TAG, "Failed to check for updates.", e);
             withContext(Dispatchers.Main) {
-                UIDialogs.toast(context, "Failed to check for updates");
+                UIDialogs.toast(context, "Failed to check for updates\n" + e.message);
             }
         }
     }

app/src/main/java/com/futo/platformplayer/sync/internal/SyncSession.kt

@@ -398,7 +398,6 @@ class SyncSession : IAuthorizable {
         }
     }
 
-
     inline fun <reified T> sendJsonData(subOpcode: UByte, data: T) {
         send(Opcode.DATA.value, subOpcode, Json.encodeToString<T>(data));
     }
@@ -409,12 +408,29 @@ class SyncSession : IAuthorizable {
         send(opcode, subOpcode, data.toByteArray(Charsets.UTF_8));
     }
     fun send(opcode: UByte, subOpcode: UByte, data: ByteArray) {
-        val sock = _socketSessions.firstOrNull();
-        if(sock != null){
-            sock.send(opcode, subOpcode, ByteBuffer.wrap(data));
+        val socketSessions = synchronized(_socketSessions) {
+            _socketSessions.toList()
+        }
+
+        if (socketSessions.isEmpty()) {
+            Logger.v(TAG, "Packet was not sent (opcode = ${opcode}, subOpcode = ${subOpcode}) due to no connected sockets")
+            return
+        }
+
+        var sent = false
+        for (socketSession in socketSessions) {
+            try {
+                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)
+            }
+        }
+
+        if (!sent) {
+            throw Exception("Packet was not sent (opcode = ${opcode}, subOpcode = ${subOpcode}) due to send errors and no remaining candidates")
         }
-        else
-            throw IllegalStateException("Session has no active sockets");
     }
 
     private companion object {

app/src/main/java/com/futo/platformplayer/sync/internal/SyncSocketSession.kt

@@ -300,6 +300,8 @@ class SyncSocketSession {
     }
 
     private fun handlePacket(opcode: UByte, subOpcode: UByte, data: ByteBuffer) {
+        Logger.i(TAG, "Handle packet (opcode = ${opcode}, subOpcode = ${subOpcode})")
+
         when (opcode) {
             Opcode.PING.value -> {
                 send(Opcode.PONG.value)

app/src/main/java/com/futo/platformplayer/views/video/FutoVideoPlayer.kt

@@ -592,11 +592,6 @@ class FutoVideoPlayer : FutoVideoPlayerBase {
 
     @OptIn(UnstableApi::class)
     fun setFullScreen(fullScreen: Boolean) {
-        // prevent fullscreen before the video has loaded to make sure we know whether it's a vertical or horizontal video
-        if(exoPlayer?.player?.videoSize?.height ?: 0 == 0 && fullScreen){
-            return
-        }
-
         updateRotateLock()
 
         if (isFullScreen == fullScreen) {

app/src/main/res/values/strings.xml

@@ -287,8 +287,8 @@
     <string name="planned_content_notifications_description">Schedules discovered planned content as notifications, resulting in more accurate notifications for this content.</string>
     <string name="attempt_to_utilize_byte_ranges">Attempt to utilize byte ranges</string>
     <string name="auto_update">Auto Update</string>
-    <string name="force_allow_full_screen_rotation">Force Allow Full Screen Rotation</string>
-    <string name="force_allow_full_screen_rotation_description">Allow auto-rotation between the two landscape orientations even when you disable auto-rotate at the system level.</string>
+    <string name="always_allow_reverse_landscape_auto_rotate">Always allow reverse landscape auto-rotate</string>
+    <string name="always_allow_reverse_landscape_auto_rotate_description">There will always be auto-rotation between the two landscape orientations in full-screen mode, even when you disable auto-rotate in system settings.</string>
     <string name="simplify_sources">Simplify sources</string>
     <string name="simplify_sources_description">Deduplicate sources by resolution so that only more relevant sources are visible.</string>
     <string name="automatic_backup">Automatic Backup</string>
@@ -400,7 +400,7 @@
     <string name="allow_under_cutout_description">Allow video to go underneath the screen cutout in full screen.\nMay require restart</string>
     <string name="autoplay">Enable autoplay by default</string>
     <string name="autoplay_description">Autoplay will be enabled by default whenever you watch a video</string>
-    <string name="allow_full_screen_portrait">Allow full-screen portrait</string>
+    <string name="allow_full_screen_portrait">Allow full-screen portrait when watching horizontal videos</string>
     <string name="delete_watchlist_on_finish">Delete from WatchLater when watched</string>
     <string name="delete_watchlist_on_finish_description">After you leave a video that you mostly watched, it will be removed from watch later.</string>
     <string name="background_switch_audio">Switch to Audio in Background</string>