sipio 0.4.1

SIP client with rtp input / output handling
Documentation
use std::io::{Write, stdin, stdout};

use rsipstack::dialog::authenticate::Credential;
use sipio::{CallHandler, Config, OnCallAction};
use tokio::io::{AsyncReadExt, AsyncWriteExt};
use tokio_util::sync::CancellationToken;

#[derive(Clone)]
struct CliHandler;

impl CallHandler for CliHandler {
    async fn on_call(&self, user: String) -> sipio::OnCallAction {
        loop {
            let mut stdout = tokio::io::stdout();
            stdout
                .write_all(format!("incoming call from '{user}', accept? (y/n): ").as_bytes())
                .await
                .unwrap();
            stdout.flush().await.unwrap();
            let mut byte = 0;
            tokio::io::stdin()
                .read_exact(std::slice::from_mut(&mut byte))
                .await
                .unwrap();

            match byte {
                b'y' | b'Y' => break OnCallAction::Accept,
                b'n' | b'N' => break OnCallAction::Reject,

                _ => {}
            }
        }
    }

    async fn handle_call(
        &self,
        user: String,
        mut incoming: tokio::sync::mpsc::Receiver<sipio::CallEvent>,
        _outgoing: tokio::sync::mpsc::Sender<sipio::CallAction>,
    ) -> sipio::Hangup {
        loop {
            if let Some(ev) = incoming.recv().await {
                let t = match ev {
                    sipio::CallEvent::Input { digit, end } => {
                        if end && digit < 14 {
                            format!("{digit} from '{user}'")
                        } else {
                            continue;
                        }
                    }
                };
                tokio::io::stdout()
                    .write_all(format!("{t}\n").as_bytes())
                    .await
                    .unwrap();
            }
        }
    }
}

#[tokio::main]
async fn main() {
    env_logger::init();

    print!("Enter remote addr: ");
    stdout().flush().unwrap();
    let mut remote_addr = String::new();
    stdin().read_line(&mut remote_addr).unwrap();

    print!("Enter username: ");
    stdout().flush().unwrap();
    let mut username = String::new();
    stdin().read_line(&mut username).unwrap();
    print!("Enter password: ");
    stdout().flush().unwrap();
    let mut password = String::new();
    stdin().read_line(&mut password).unwrap();

    sipio::run(
        Config {
            bind_addr: "0.0.0.0:0".to_owned(),
            remote_addr: remote_addr.trim().to_owned(),
            credential: Credential {
                username: username.trim().to_owned(),
                password: password.trim().to_owned(),
                realm: None,
            },
        },
        CancellationToken::new(),
        CliHandler,
    )
    .await
    .unwrap();
}