feat: enable listener functionality

src/client.rs

@@ -72,6 +72,7 @@ impl ClientContext {
     }
 }
 pub struct Client {
+    enable_listen: bool,
     listen_port: u32,
     address: PeerAddress,
     username: String,
@@ -85,6 +86,7 @@ impl Client {
         address: PeerAddress,
         username: String,
         password: String,
+        enable_listen: bool,
         listen_port: Option<u32>,
     ) -> Self {
         crate::utils::logger::init();
@@ -94,6 +96,7 @@ impl Client {
             context.read().unwrap().thread_pool.thread_count()
         );
         Self {
+            enable_listen,
             listen_port: listen_port.unwrap_or(DEFALT_LISTEN_PORT),
             address,
             username,
@@ -107,7 +110,7 @@ impl Client {
         username: String,
         password: String,
     ) -> Self {
-        Self::new(address, username, password, None)
+        Self::new(address, username, password, false, None)
     }
 
     pub fn connect(&mut self) {
@@ -123,39 +126,45 @@ impl Client {
 
         let client_sender = sender.clone();
 
-        self.server =
+        self.server = match Server::new(
-            match Server::new(self.address.clone(), sender, self.listen_port) {
+            self.address.clone(),
-                Ok(server) => {
+            sender,
-                    info!(
+            self.listen_port,
-                        "Connected to server at {}:{}",
+            self.enable_listen,
-                        server.get_address().get_host(),
+        ) {
-                        server.get_address().get_port()
+            Ok(server) => {
-                    );
+                info!(
+                    "Connected to server at {}:{}",
+                    server.get_address().get_host(),
+                    server.get_address().get_port()
+                );
 
-                    // thread::spawn(move || {
+                if self.enable_listen {
-                    //     Listen::start(
+                    thread::spawn(move || {
-                    //         listen_port,
+                        Listen::start(
-                    //         client_sender.clone(),
+                            listen_port,
-                    //         context.clone(),
+                            client_sender.clone(),
-                    //         own_username,
+                            context.clone(),
-                    //     );
+                            own_username,
-                    // });
+                        );
-                    let mut unlocked_context = self.context.write().unwrap();
+                    });
-                    unlocked_context.server_sender =
+                }
-                        Some(server.get_sender().clone());
+                let mut unlocked_context = self.context.write().unwrap();
+                unlocked_context.server_sender =
+                    Some(server.get_sender().clone());
 
-                    Self::listen_to_client_operations(
+                Self::listen_to_client_operations(
-                        message_reader,
+                    message_reader,
-                        self.context.clone(),
+                    self.context.clone(),
-                        self.username.clone(),
+                    self.username.clone(),
-                    );
+                );
-                    Some(server)
+                Some(server)
-                }
+            }
-                Err(e) => {
+            Err(e) => {
-                    error!("Error connecting to server: {}", e);
+                error!("Error connecting to server: {}", e);
-                    None
+                None
-                }
+            }
-            };
+        };
     }
 
     pub fn login(&self) -> Result<bool> {

src/main.rs

@@ -2,11 +2,13 @@ fn main() {
     use soulseek_rs::{Client, PeerAddress};
     use std::time::Duration;
 
-    let mut client = Client::with_defaults(
+    let mut client = Client::new(
         // PeerAddress::new(String::from("server.slsknet.org"), 2242),
         PeerAddress::new(String::from("127.0.0.1"), 2242),
         String::from("insane_in_the_brain3"),
         String::from("13375137"),
+        true,
+        None,
     );
 
     client.connect();

src/server.rs

@@ -195,12 +195,14 @@ pub struct Server {
     sender: Sender<ServerOperation>,
     context: Arc<RwLock<Context>>,
     listen_port: u32,
+    enable_listen: bool,
 }
 impl Server {
     pub fn new(
         address: PeerAddress,
         client_channel: Sender<ClientOperation>,
         listen_port: u32,
+        enable_listen: bool,
     ) -> std::result::Result<Self, io::Error> {
         let (sender, server_channel): (
             Sender<ServerOperation>,
@@ -214,6 +216,7 @@ impl Server {
             context,
             sender,
             listen_port,
+            enable_listen,
         };
 
         server.start_read_write_loops(server_channel, client_channel)?;
@@ -475,9 +478,13 @@ impl Server {
             ));
             self.queue_message(MessageFactory::build_no_parent_message());
             self.queue_message(MessageFactory::build_set_status_message(2));
-            self.queue_message(MessageFactory::build_set_wait_port_message(
+            if self.enable_listen {
-                self.listen_port,
+                self.queue_message(
-            ));
+                    MessageFactory::build_set_wait_port_message(
+                        self.listen_port,
+                    ),
+                );
+            }
         }
 
         Ok(logged_in.unwrap())