add a simple event listener feature

examples/inbound.rs

@@ -4,13 +4,23 @@ use freeswitch_esl::{Esl, EslError};
 async fn main() -> Result<(), EslError> {
     let addr = "localhost:8021"; // Freeswitch host
     let password = "ClueCon";
-    let inbound = Esl::inbound(addr, password).await?;
+    let (tx, mut rx) = tokio::sync::mpsc::channel(100);
+    let inbound = Esl::inbound(addr, password, Some(tx)).await?;
 
     let reloadxml = inbound.api("reloadxml").await?;
     println!("reloadxml response : {:?}", reloadxml);
 
     let reloadxml = inbound.bgapi("reloadxml").await?;
     println!("reloadxml response : {:?}", reloadxml);
 
+    let subscribe = inbound.subscribe(vec!["all"]).await?;
+    println!("subscribe all response : {:?}", subscribe);
+
+    loop {
+        match rx.recv().await {
+            Some(ev) => println!("received event: {:#?}", ev),
+            _ => break,
+        }
+    }
     Ok(())
 }

src/connection.rs

@@ -12,6 +12,7 @@ use tokio::io::WriteHalf;
 use tokio::net::{TcpStream, ToSocketAddrs};
 use tokio::sync::{
     oneshot::{channel, Sender},
+    mpsc,
     Mutex,
 };
 use tokio_stream::StreamExt;
@@ -60,6 +61,7 @@ impl EslConnection {
         stream: TcpStream,
         password: impl ToString,
         connection_type: EslConnectionType,
+        listener: Option<mpsc::Sender<HashMap<String, Value>>>,
     ) -> Result<Self, EslError> {
         // let sender = Arc::new(sender);
         let commands = Arc::new(Mutex::new(VecDeque::new()));
@@ -128,10 +130,16 @@ impl EslConnection {
                                                 }
                                                 trace!("continued");
                                                 trace!("got channel execute complete");
+                                                continue;
                                             }
                                         }
                                     }
                                 }
+                                if let Some(ref listener) = listener {
+                                    if let Err(e) = listener.send(event_body).await {
+                                        trace!("got error forwarding event event to listener: {}", e);
+                                    }
+                                }
                                 continue;
                             }
                             _ => {
@@ -186,9 +194,10 @@ impl EslConnection {
         socket: impl ToSocketAddrs,
         password: impl ToString,
         connection_type: EslConnectionType,
+        listener: Option<mpsc::Sender<HashMap<String, Value>>>,
     ) -> Result<Self, EslError> {
         let stream = TcpStream::connect(socket).await?;
-        Self::with_tcpstream(stream, password, connection_type).await
+        Self::with_tcpstream(stream, password, connection_type, listener).await
     }
     pub(crate) async fn auth(&self) -> Result<String, EslError> {
         let auth_response = self

src/esl.rs

@@ -1,6 +1,8 @@
 use tokio::net::ToSocketAddrs;
 
 use crate::{connection::EslConnection, outbound::Outbound, EslError};
+use std::collections::HashMap;
+use serde_json::Value;
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub(crate) enum EslConnectionType {
     Inbound,
@@ -13,8 +15,9 @@ impl Esl {
     pub async fn inbound(
         addr: impl ToSocketAddrs,
         password: impl ToString,
+        listener: Option<tokio::sync::mpsc::Sender<HashMap<String, Value>>>,
     ) -> Result<EslConnection, EslError> {
-        EslConnection::new(addr, password, EslConnectionType::Inbound).await
+        EslConnection::new(addr, password, EslConnectionType::Inbound, listener).await
     }
 
     /// Creates new server for outbound connection

src/outbound.rs

@@ -15,7 +15,7 @@ impl Outbound {
     pub async fn accept(&self) -> Result<(EslConnection, SocketAddr), EslError> {
         let (stream, addr) = self.listener.accept().await?;
         let connection =
-            EslConnection::with_tcpstream(stream, "None", EslConnectionType::Outbound).await?;
+            EslConnection::with_tcpstream(stream, "None", EslConnectionType::Outbound, None).await?;
         Ok((connection, addr))
     }
 }