Struct ZelloClient 

pub struct ZelloClient { /* private fields */ }

Zello client for interacting with the Zello API

Implementations

impl ZelloClient

Zello client for interacting with the Zello API

pub async fn new(config: ZelloConfig) -> Result<Self>

Create a new Zello client and connect

#Errors

Returns an error if fail to create a new Zello client

pub async fn run_message_loop( &mut self, decoder: Arc<Mutex<Decoder>>, pcm_tx: &Sender<Vec<i16>>, ) -> Result<()>

Run the main message processing loop

Errors

Returns an error if message receiving fails

Examples found in repository

examples/complete.rs (line 84)

async fn main() -> Result<()> {
    let args = Args::parse();

    load_dotenv_from_file("examples/.env.example")?;
    initialize_logging()?;

    let credentials = load_credentials()?;
    let decoder = create_decoder()?;

    let (pcm_tx, pcm_rx) = bounded::<Vec<i16>>(PCM_CHANNEL_CAPACITY);
    let pcm_rx = Arc::new(Mutex::new(pcm_rx));
    let _stream = setup_audio_output(pcm_rx)?;

    let mut client = connect_to_zello(&credentials).await?;

    match (args.message, args.callsign) {
        (Some(msg), Some(callsign)) => {
            client
                .send_text_message_to_callsign(&msg, &callsign)
                .await?;
        }
        (Some(msg), None) => {
            client.send_text_message(&msg).await?;
        }
        (None, _) => {
            client.run_message_loop(decoder, &pcm_tx).await?;
        }
    }

    client.close().await?;

    Ok(())
}

pub async fn send_text_message(&mut self, text: &str) -> Result<()>

Send a text message to the channel

Errors

Returns an error if fail to send a text message to the channel

Examples found in repository

examples/simple.rs (line 17)

async fn main() -> Result<()> {
    load_dotenv_from_file("examples/.env.example")?;
    initialize_logging()?;
    let credentials = load_credentials()?;
    let mut client = connect_to_zello(&credentials).await?;
    client.send_text_message("Hello from Zello!").await?;
    client.close().await?;
    Ok(())
}

examples/complete.rs (line 81)

async fn main() -> Result<()> {
    let args = Args::parse();

    load_dotenv_from_file("examples/.env.example")?;
    initialize_logging()?;

    let credentials = load_credentials()?;
    let decoder = create_decoder()?;

    let (pcm_tx, pcm_rx) = bounded::<Vec<i16>>(PCM_CHANNEL_CAPACITY);
    let pcm_rx = Arc::new(Mutex::new(pcm_rx));
    let _stream = setup_audio_output(pcm_rx)?;

    let mut client = connect_to_zello(&credentials).await?;

    match (args.message, args.callsign) {
        (Some(msg), Some(callsign)) => {
            client
                .send_text_message_to_callsign(&msg, &callsign)
                .await?;
        }
        (Some(msg), None) => {
            client.send_text_message(&msg).await?;
        }
        (None, _) => {
            client.run_message_loop(decoder, &pcm_tx).await?;
        }
    }

    client.close().await?;

    Ok(())
}

pub async fn send_text_message_to_callsign( &mut self, text: &str, callsign: &str, ) -> Result<()>

Send a text message to the channel

Errors

Returns an error if fail to send a text message to the channel

Examples found in repository

examples/complete.rs (line 77)

async fn main() -> Result<()> {
    let args = Args::parse();

    load_dotenv_from_file("examples/.env.example")?;
    initialize_logging()?;

    let credentials = load_credentials()?;
    let decoder = create_decoder()?;

    let (pcm_tx, pcm_rx) = bounded::<Vec<i16>>(PCM_CHANNEL_CAPACITY);
    let pcm_rx = Arc::new(Mutex::new(pcm_rx));
    let _stream = setup_audio_output(pcm_rx)?;

    let mut client = connect_to_zello(&credentials).await?;

    match (args.message, args.callsign) {
        (Some(msg), Some(callsign)) => {
            client
                .send_text_message_to_callsign(&msg, &callsign)
                .await?;
        }
        (Some(msg), None) => {
            client.send_text_message(&msg).await?;
        }
        (None, _) => {
            client.run_message_loop(decoder, &pcm_tx).await?;
        }
    }

    client.close().await?;

    Ok(())
}

pub async fn start_audio_stream( &mut self, codec: &str, packet_duration: u32, ) -> Result<u32>

Start an audio stream

Errors

Returns an error if fail to start an audio stream

pub async fn send_audio_packet( &mut self, stream_id: u32, data: Vec<u8>, ) -> Result<()>

Send audio data packet

Errors

Returns an error if fail to send audio data packet

pub async fn stop_audio_stream(&mut self, stream_id: u32) -> Result<()>

Stop an audio stream

Errors

Returns an error if fail to stop an audio stream

pub async fn receive_message(&mut self) -> Result<Option<IncomingMessage>>

Receive the next message

Errors

Returns an error if fail to receive the next message

pub fn is_authenticated(&self) -> bool

Check if client is authenticated

pub fn channel(&self) -> &str

Get the current channel

pub async fn close(self) -> Result<()>

Close the connection

Errors

Returns an error if fail to close the connection

Examples found in repository

examples/simple.rs (line 18)

async fn main() -> Result<()> {
    load_dotenv_from_file("examples/.env.example")?;
    initialize_logging()?;
    let credentials = load_credentials()?;
    let mut client = connect_to_zello(&credentials).await?;
    client.send_text_message("Hello from Zello!").await?;
    client.close().await?;
    Ok(())
}

examples/complete.rs (line 88)

async fn main() -> Result<()> {
    let args = Args::parse();

    load_dotenv_from_file("examples/.env.example")?;
    initialize_logging()?;

    let credentials = load_credentials()?;
    let decoder = create_decoder()?;

    let (pcm_tx, pcm_rx) = bounded::<Vec<i16>>(PCM_CHANNEL_CAPACITY);
    let pcm_rx = Arc::new(Mutex::new(pcm_rx));
    let _stream = setup_audio_output(pcm_rx)?;

    let mut client = connect_to_zello(&credentials).await?;

    match (args.message, args.callsign) {
        (Some(msg), Some(callsign)) => {
            client
                .send_text_message_to_callsign(&msg, &callsign)
                .await?;
        }
        (Some(msg), None) => {
            client.send_text_message(&msg).await?;
        }
        (None, _) => {
            client.run_message_loop(decoder, &pcm_tx).await?;
        }
    }

    client.close().await?;

    Ok(())
}

pub fn add_inbound_stream( &mut self, stream_id: u32, channel: String, codec: String, callsign: Option<String>, ) -> Result<()>

Add a new inbound stream to the client

Errors

Returns an error if fail to add a new inbound stream

pub fn get_inbound_stream(&self, stream_id: u32) -> Option<&StreamInfo>

Get an inbound stream from the client

pub fn remove_inbound_stream(&mut self, stream_id: u32) -> Result<()>

Remove an inbound stream from the client

Errors

Returns an error if fail to remove an inbound stream

Trait Implementations

impl Debug for ZelloClient

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.