feature(gui): first basic attempt for a gui frontend in flutter

caesar-core/Cargo.toml

@@ -5,6 +5,9 @@ edition = "2021"
 build = "src/build.rs"
 authors = ["Manuel Keidel", "Patryk Hegenberg", "Krzysztof Stankiewicz"]
 
+# [lib]
+# crate-type = ["lib", "cdylib", "staticlib"]
+
 [dependencies]
 futures-util = "0.3"
 tungstenite = "0.21.0"
@@ -40,6 +43,9 @@ headers = "0.4"
 tower = { version = "0.4", features = ["util"] }
 reqwest = { version = "0.12.4", features = ["blocking", "json"] }
 hex = "0.4.3"
+openssl-sys = { version = "0.9.102", features = ["vendored"] }
+# rinf = "6.8.0"
+anyhow = "1.0.83"
 
 [build-dependencies]
 prost-build = "0.12.4"

caesar-core/src/receiver/http_client.rs

@@ -1,27 +1,22 @@
+use anyhow::{anyhow, Result};
 use hex;
 use reqwest::{self, Client};
 use sha2::{Digest, Sha256};
-use tracing::error;
 
 use crate::relay::transfer::TransferResponse;
 
-type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
-
 pub async fn download_info(relay: &str, name: &str) -> Result<TransferResponse> {
     let url = String::from(relay);
     let hashed_name = Sha256::digest(name.as_bytes());
     let hashed_string = hex::encode(hashed_name);
 
-    match reqwest::get(format!("{}/download/{}", url, hashed_string)).await {
-        Ok(resp) => match resp.json::<TransferResponse>().await {
-            Ok(res) => Ok(res),
-            Err(e) => Err(Box::new(e)),
-        },
-        Err(err) => {
-            error!("Error: {err}");
-            Err(Box::new(err))
-        }
-    }
+    let resp = reqwest::get(format!("{}/download/{}", url, hashed_string))
+        .await
+        .map_err(|e| anyhow!("Failed to send GET request: {}", e))?;
+
+    resp.json::<TransferResponse>()
+        .await
+        .map_err(|e| anyhow!("Failed to parse JSON response: {}", e))
 }
 
 pub async fn download_success(relay: &str, name: &str) -> Result<()> {
@@ -33,6 +28,8 @@ pub async fn download_success(relay: &str, name: &str) -> Result<()> {
     let _ = client
         .post(format!("{}/download_success/{}", url, hashed_string))
         .send()
-        .await?;
+        .await
+        .map_err(|e| anyhow!("Failed to send POST request: {}", e))?;
+
     Ok(())
 }

caesar-core/src/receiver/mod.rs

@@ -2,6 +2,7 @@ pub mod client;
 pub mod http_client;
 
 use crate::{receiver::client as receiver, sender::util::replace_protocol};
+use anyhow::{anyhow, Result};
 
 use tokio_tungstenite::{
     connect_async,
@@ -9,7 +10,7 @@ use tokio_tungstenite::{
 };
 use tracing::{debug, error};
 
-pub async fn start_receiver(relay: &str, name: &str) {
+pub async fn start_receiver(relay: &str, name: &str) -> Result<()> {
     let http_url = replace_protocol(relay);
     let res = http_client::download_info(http_url.as_str(), name)
         .await
@@ -23,19 +24,19 @@ pub async fn start_receiver(relay: &str, name: &str) {
             debug!("Failed to connect remote: {relay_err}");
         }
     }
-    let success = http_client::download_success(http_url.as_str(), name).await;
-    match success {
-        Ok(()) => debug!("Success"),
-        Err(e) => error!("Error: {e:?}"),
-    };
+    let _success = http_client::download_success(http_url.as_str(), name)
+        .await
+        .map_err(|e| anyhow!("Failed to download success: {}", e))?;
+
+    debug!("Success");
+    Ok(())
 }
 
-pub async fn start_ws_com(relay: &str, name: &str) -> Result<(), Box<dyn std::error::Error>> {
+pub async fn start_ws_com(relay: &str, name: &str) -> Result<()> {
     let url = String::from(relay) + "/ws";
-    let Ok(mut request) = url.into_client_request() else {
-        println!("Error: Failed to create request.");
-        return Err("Failed to create request".into());
-    };
+    let mut request = url
+        .into_client_request()
+        .map_err(|e| anyhow!("Failed to create request: {}", e))?;
 
     request
         .headers_mut()

caesar-core/src/sender/client.rs

@@ -22,6 +22,7 @@ use std::{
     path::Path,
     time::Duration,
 };
+// use tokio::sync::mpsc;
 use tokio::{io::AsyncReadExt, task::JoinHandle, time::sleep};
 use tokio_tungstenite::tungstenite::{protocol::Message as WebSocketMessage, Error};
 use tracing::{debug, error};
@@ -47,6 +48,21 @@ struct Context {
     task: Option<JoinHandle<()>>,
 }
 
+// pub struct ProgressSender {
+//     tx: mpsc::Sender<String>,
+// }
+//
+// impl ProgressSender {
+//     pub fn new() -> (Self, mpsc::Receiver<String>) {
+//         let (tx, rx) = mpsc::channel(100);
+//         (Self { tx }, rx)
+//     }
+//
+//     pub async fn send(&self, message: String) -> Result<(), mpsc::error::SendError<String>> {
+//         self.tx.send(message).await
+//     }
+// }
+//
 fn on_create_room(
     context: &Context,
     id: String,
@@ -143,6 +159,7 @@ fn on_leave_room(context: &mut Context, _: usize) -> Status {
 }
 
 fn on_progress(context: &Context, progress: ProgressPacket) -> Status {
+    // let prog_sender = ProgressSender::new();
     if context.shared_key.is_none() {
         return Status::Err("Invalid progress packet: no shared key established".into());
     }
@@ -155,6 +172,11 @@ fn on_progress(context: &Context, progress: ProgressPacket) -> Status {
     print!("\rTransferring '{}': {}%", file.name, progress.progress);
     stdout().flush().unwrap();
 
+    // let progress_message = format!("Transferring '{}': {}%", file.name, progress.progress);
+    // print!("\r{}", progress_message);
+    // stdout().flush().unwrap();
+    // prog_sender.0.send(progress_message);
+    //
     if progress.progress == 100 {
         println!();
 
@@ -275,7 +297,7 @@ fn on_message(
             };
             return match packet {
                 JsonPacketResponse::Create { id } => {
-                   on_create_room(context, id, relay, transfer_name, is_local) 
+                    on_create_room(context, id, relay, transfer_name, is_local)
                 }
                 JsonPacketResponse::Join { size } => on_join_room(context, size),
                 JsonPacketResponse::Leave { index } => on_leave_room(context, index),
@@ -303,7 +325,7 @@ fn on_message(
                 }
                 Value::Progress(progress) => on_progress(context, progress),
                 _ => Status::Err(format!("Unexpected packet: {:?}", value)),
-            }
+            };
         }
         _ => (),
     }

caesar-core/src/sender/mod.rs

@@ -6,7 +6,7 @@ use std::{net::SocketAddr, sync::Arc};
 
 use crate::{
     relay::{appstate::AppState, server::ws_handler},
-    sender::{client as sender, util::generate_random_name},
+    sender::client as sender,
 };
 use axum::{routing::get, Router};
 use tokio::{net::TcpListener, sync::mpsc, task};
@@ -18,15 +18,16 @@ use tower_http::trace::{DefaultMakeSpan, TraceLayer};
 use tracing::{debug, error, info};
 use uuid::Uuid;
 
-pub async fn start_sender(relay: Arc<String>, files: Arc<Vec<String>>) {
+pub async fn start_sender(name: String, relay: Arc<String>, files: Arc<Vec<String>>) {
+    debug!("Got name: {:?}", name);
     let (tx, mut rx) = mpsc::channel(1);
     debug!("Got relay: {relay}");
     let room_id = Uuid::new_v4().to_string();
-    let rand_name = generate_random_name();
+    // let rand_name = generate_random_name();
     let local_room_id = room_id.clone();
     let local_files = files.clone();
     let local_relay = relay.clone();
-    let local_rand_name = rand_name.clone();
+    let local_rand_name = name.clone();
     let local_tx = tx.clone();
     let local_ws_thread = task::spawn(async move {
         start_local_ws().await;
@@ -37,7 +38,7 @@ pub async fn start_sender(relay: Arc<String>, files: Arc<Vec<String>>) {
             files.clone(),
             Some(room_id),
             relay.clone(),
-            Arc::new(rand_name.clone()),
+            Arc::new(name.clone()),
             tx.clone(),
             false,
         )