Add client_get_default_timeout and client_get_state functions; enhance ClientState with Display implementation

Author: skadefro

crates/clib/clib_openiap.h

@@ -691,8 +691,12 @@ void connect_async(struct ClientWrapper *client,
                    int32_t request_id,
                    ConnectCallback callback);
 
+int32_t client_get_default_timeout(struct ClientWrapper *client_wrap);
+
 void client_set_default_timeout(struct ClientWrapper *client_wrap, int32_t timeout);
 
+const char *client_get_state(struct ClientWrapper *client_wrap);
+
 void client_set_agent_name(struct ClientWrapper *client_wrap, const char *agent_name);
 
 void client_set_agent_version(struct ClientWrapper *client_wrap, const char *agent_version);

crates/clib/src/lib.rs

@@ -781,6 +781,17 @@ pub extern "C" fn connect_async(client: *mut ClientWrapper, server_address: *con
     });
 }
 #[no_mangle]
+pub extern "C" fn client_get_default_timeout(client_wrap: *mut ClientWrapper) -> i32 {
+    debug!("get_default_timeout");
+    let client = match safe_wrapper( client_wrap ) {
+        Some( wrap ) => wrap.client.clone().unwrap(),
+        None => {
+            Client::new()
+        }
+    };
+    client.get_default_timeout().as_secs() as i32
+}
+#[no_mangle]
 pub extern "C" fn client_set_default_timeout(client_wrap: *mut ClientWrapper, timeout: i32) {
     debug!("set_default_timeout = {:?}", timeout);
     let client = match safe_wrapper( client_wrap ) {
@@ -796,6 +807,19 @@ pub extern "C" fn client_set_default_timeout(client_wrap: *mut ClientWrapper, ti
     client.set_default_timeout(_timeout);
 }
 #[no_mangle]
+pub extern "C" fn client_get_state(client_wrap: *mut ClientWrapper) -> *const c_char {
+    debug!("get_state");
+    let client = match safe_wrapper( client_wrap ) {
+        Some( wrap ) => wrap.client.clone().unwrap(),
+        None => {
+            Client::new()
+        }
+    };
+    let state = client.get_state().to_string();
+    let state_str = CString::new(state).unwrap().into_raw();
+    state_str
+}
+#[no_mangle]
 pub extern "C" fn client_set_agent_name(client_wrap: *mut ClientWrapper, agent_name: *const c_char) {
     let agent_name = c_char_to_str(agent_name);
     debug!("set_agent_name = {:?}", agent_name);

crates/client/src/lib.rs

@@ -27,7 +27,7 @@ pub use openiap_proto::*;
 pub use prost_types::Timestamp;
 pub use protos::flow_service_client::FlowServiceClient;
 use sqids::Sqids;
-
+use std::fmt::{Display,Formatter};
 use tokio::task::JoinHandle;
 use tokio_tungstenite::WebSocketStream;
 use tracing::{debug, error, info, trace};
@@ -227,6 +227,17 @@ pub enum ClientState {
     /// The client is signed in and connected
     Signedin
 }
+impl Display for ClientState {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ClientState::Disconnected => write!(f, "Disconnected"),
+            ClientState::Connecting => write!(f, "Connecting"),
+            ClientState::Connected => write!(f, "Connected"),
+            ClientState::Signedin => write!(f, "Signedin"),
+        }
+    }
+}
+
 /// The `Config` struct provides the configuration for the OpenIAP service we are connecting to.
 #[derive(Debug, Clone, serde::Deserialize)]
 #[allow(dead_code)]
@@ -797,12 +808,14 @@ impl Client {
             }
             if state == ClientState::Disconnected && !current.eq(&state) {
                 let me = self.clone();
-                tokio::task::spawn(async move {
-                    let mut reply_queue_guard = me.rpc_reply_queue.lock().await;
-                    let mut callback_guard = me.rpc_callback.lock().await;
-                    *reply_queue_guard = None;
-                    *callback_guard = None;
-                });
+                if let Ok(_handle) = tokio::runtime::Handle::try_current() {
+                    tokio::task::spawn(async move {
+                        let mut reply_queue_guard = me.rpc_reply_queue.lock().await;
+                        let mut callback_guard = me.rpc_callback.lock().await;
+                        *reply_queue_guard = None;
+                        *callback_guard = None;
+                    });
+                }
             }
             if state == ClientState::Connecting && !current.eq(&state) {
                 if let Ok(_handle) = tokio::runtime::Handle::try_current() {
@@ -811,14 +824,6 @@ impl Client {
                     tokio::task::spawn(async move {
                         me.event_sender.send(crate::ClientEvent::Connecting).await.unwrap();
                     });
-                    // match tokio::task::Builder::new().name("setconnected-notify-connecting").spawn(async move {
-                    //     me.event_sender.send(crate::ClientEvent::Connecting).await.unwrap();
-                    // }) {
-                    //     Ok(_) => (),
-                    //     Err(e) => {
-                    //         error!("Failed to spawn setconnected-notify-connecting task: {:?}", e);
-                    //     }
-                    // }
                 }
 
             }
@@ -829,14 +834,6 @@ impl Client {
                     tokio::task::spawn(async move {
                         me.event_sender.send(crate::ClientEvent::Connected).await.unwrap();
                     });
-                    // match tokio::task::Builder::new().name("setconnected-notify-connected").spawn(async move {
-                    //     me.event_sender.send(crate::ClientEvent::Connected).await.unwrap();
-                    // }) {
-                    //     Ok(_) => (),
-                    //     Err(e) => {
-                    //         error!("Failed to spawn setconnected-notify-connected task: {:?}", e);
-                    //     }
-                    // }
                 }
             }
             if state == ClientState::Signedin && current != ClientState::Signedin {
@@ -845,14 +842,6 @@ impl Client {
                     tokio::task::spawn(async move {
                         me.event_sender.send(crate::ClientEvent::SignedIn).await.unwrap();
                     });
-                    // match tokio::task::Builder::new().name("set_signedin-notify-connected").spawn(async move {
-                    //     me.event_sender.send(crate::ClientEvent::SignedIn).await.unwrap();
-                    // }) {
-                    //     Ok(_) => (),
-                    //     Err(e) => {
-                    //         error!("Failed to spawn set_signedin-notify-connected task: {:?}", e);
-                    //     }
-                    // };
                 }
             }
             if state == ClientState::Disconnected && !current.eq(&state) {
@@ -867,26 +856,14 @@ impl Client {
                         Some(message) => message.to_string(),
                         None => "".to_string(),
                     };
-                    //if current != ClientState::Connecting {
                         tokio::task::spawn(async move {
                             me.event_sender.send(crate::ClientEvent::Disconnected(message)).await.unwrap();
                         });
-                        // match tokio::task::Builder::new().name("setconnected-notify-disconnected").spawn(async move {
-                        //     trace!("Disconnected: {}", message);
-                        //     me.event_sender.send(crate::ClientEvent::Disconnected(message)).await.unwrap();
-                        // }) {
-                        //     Ok(_) => (),
-                        //     Err(e) => {
-                        //         error!("Failed to spawn setconnected-notify-disconnected task: {:?}", e);
-                        //     }
-                        // }
-                    //}
                 }
 
                 self.kill_handles();
                 if let Ok(_handle) = tokio::runtime::Handle::try_current() {
                     let client = self.clone();
-                    // match tokio::task::Builder::new().name("kill_handles").spawn(async move {
                         tokio::task::spawn(async move {
                         {
                             let inner = client.inner.lock().await;
@@ -941,12 +918,6 @@ impl Client {
                             debug!("Reconnecting disabled, stop now");
                         }
                     });
-                    //  {
-                    //     Ok(_) => (),
-                    //     Err(e) => {
-                    //         error!("Failed to spawn kill_handles task: {:?}", e);
-                    //     }
-                    // }
                 }
 
             }