fix: external player m3u8 playlist opening

Author: tymmesyde

Cargo.lock

@@ -37,6 +37,7 @@ chrono = "0.4.45"
 anyhow = "1.0.102"
 url = "2.5.8"
 dirs = "6.0.0"
+base64 = "0.22.1"
 
 [build-dependencies]
 anyhow = "1.0.102"

Cargo.toml

@@ -2,18 +2,22 @@ use std::cell::{Cell, RefCell};
 
 use adw::{prelude::*, subclass::prelude::*};
 use gtk::glib::{self, Properties, clone};
-
-use crate::app::{
-    config::{APP_ID, APP_NAME, URI_SCHEME},
-    ipc::{
-        self,
-        event::{IpcEvent, IpcEventMpv},
+use tracing::error;
+
+use crate::{
+    app::{
+        config::{APP_ID, APP_NAME, URI_SCHEME},
+        ipc::{
+            self,
+            event::{IpcEvent, IpcEventMpv},
+        },
+        mpris::Mpris,
+        tray::Tray,
+        video::Video,
+        webview::WebView,
+        window::Window,
     },
-    mpris::Mpris,
-    tray::Tray,
-    video::Video,
-    webview::WebView,
-    window::Window,
+    spawn_local, utils,
 };
 
 const PRELOAD_SCRIPT: &str = include_str!("ipc/preload.js");
@@ -182,8 +186,17 @@ impl ApplicationImpl for Application {
         webview.connect_open_external(clone!(
             #[weak]
             window,
-            move |uri| {
-                window.open_uri(uri);
+            move |data| {
+                if data.starts_with("application/octet-stream") {
+                    spawn_local!(async move {
+                        match utils::download_file("playlist.m3u8", data).await {
+                            Ok(file_path) => window.open_file(file_path),
+                            Err(e) => error!("Failed to download file: {e}"),
+                        }
+                    });
+                } else {
+                    window.open_uri(data);
+                }
             }
         ));
 

src/app/imp.rs

@@ -129,13 +129,21 @@ impl WebView {
         widget
             .webview
             .connect_decide_policy(move |_, decision, decision_type| {
-                if let PolicyDecisionType::NewWindowAction = decision_type
-                    && let Some(decision) = decision.downcast_ref::<NavigationPolicyDecision>()
-                    && let Some(action) = decision.navigation_action()
-                    && let Some(request) = action.request()
-                    && let Some(uri) = request.uri()
+                if let Some(uri) = decision
+                    .downcast_ref::<NavigationPolicyDecision>()
+                    .and_then(|decision| decision.navigation_action())
+                    .and_then(|action| action.request())
+                    .and_then(|request| request.uri())
                 {
-                    callback(uri.to_string());
+                    match decision_type {
+                        PolicyDecisionType::NavigationAction if uri.starts_with("data:") => {
+                            callback(uri.replace("data:", ""));
+                        }
+                        PolicyDecisionType::NewWindowAction => {
+                            callback(uri.to_string());
+                        }
+                        _ => {}
+                    }
                 }
 
                 true

src/app/webview/mod.rs

@@ -1,4 +1,4 @@
-use std::{cell::Cell, sync::Arc};
+use std::{cell::Cell, fs::File, os::fd::AsFd, sync::Arc};
 
 use adw::prelude::*;
 use adw::subclass::prelude::*;
@@ -120,6 +120,28 @@ impl Window {
         ));
     }
 
+    pub fn open_file(&self, file_path: String) {
+        let object = self.obj();
+
+        spawn_local!(clone!(
+            #[weak]
+            object,
+            async move {
+                if let Some(identifier) = WindowIdentifier::from_native(&object).await {
+                    let request = OpenFileRequest::default().identifier(identifier);
+
+                    if let Ok(file) = File::open(&file_path) {
+                        request
+                            .send_file(&file.as_fd())
+                            .await
+                            .map_err(|e| error!("Failed to open file: {e}"))
+                            .ok();
+                    }
+                }
+            }
+        ));
+    }
+
     pub fn show_header(&self, state: bool) {
         self.header.set_visible(self.decorations.get() && state);
     }

src/app/window/imp.rs

@@ -60,6 +60,10 @@ impl Window {
     pub fn open_uri(&self, uri: String) {
         self.imp().open_uri(uri);
     }
+
+    pub fn open_file(&self, file_path: String) {
+        self.imp().open_file(file_path);
+    }
 }
 
 fn graphics_offload(widget: &impl IsA<Widget>) -> gtk::GraphicsOffload {

src/app/window/mod.rs

@@ -1,4 +1,11 @@
-use std::sync::LazyLock;
+use std::{
+    io::{self, Cursor},
+    sync::LazyLock,
+};
+
+use anyhow::{Context, Error, Result, anyhow};
+use base64::{engine::general_purpose, read};
+use tokio::fs;
 
 #[macro_export]
 macro_rules! spawn_local {
@@ -12,3 +19,42 @@ pub static IS_DESKTOP_KDE: LazyLock<bool> = LazyLock::new(|| {
         .ok()
         .is_some_and(|value| value == "KDE")
 });
+
+pub fn decode_base64(data: &str) -> Result<Vec<u8>> {
+    let mut input = Cursor::new(data);
+    let mut output = Vec::new();
+
+    let engine = general_purpose::STANDARD;
+    let mut decoder = read::DecoderReader::new(&mut input, &engine);
+
+    if let Err(e) = io::copy(&mut decoder, &mut output) {
+        return Err(Error::msg(format!("Failed to decode base64: {e}")));
+    }
+
+    Ok(output)
+}
+
+pub async fn download_file(file_name: &str, data: String) -> Result<String> {
+    let base_64 = data
+        .strip_prefix("application/octet-stream;charset=utf-8;base64,")
+        .ok_or_else(|| anyhow!("Failed to parse data URL"))?;
+    let bytes = decode_base64(base_64)?;
+
+    let out_dir = dirs::download_dir()
+        .ok_or_else(|| anyhow!("Failed to get download dir"))?
+        .join("Stremio");
+
+    fs::create_dir_all(&out_dir)
+        .await
+        .context("Failed to create download dir")?;
+
+    let file_name = out_dir.join(file_name);
+    fs::write(&file_name, bytes)
+        .await
+        .context("Failed to write file to download dir")?;
+
+    file_name
+        .into_os_string()
+        .into_string()
+        .map_err(|os_str| anyhow!("Failed to convert path to string: {:?}", os_str))
+}