Struct PresenceClient 

pub struct PresenceClient { /* private fields */ }

A client handle for communicating with super::PresenceRunner and its inner loop.

Implementations

impl PresenceClient

pub fn client_id(&self) -> &str

Returns the client ID.

pub async fn set_activity( &self, activity: ActivitySpec, ) -> Result<(), PresenceClientError>

Sets/updates the Discord Rich presence activity. The runner must be started before calling this.

NOTE: This will NOT wait for the activity to finish becoming online.

Examples found in repository

examples/simple.rs (line 14)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160");

    let activity = Activity::new()
        .name("cool app name")
        .details("Something?")
        .state("Probably~")
        .build()?;

    let client = runner.run(true).await?;
    client.set_activity(activity).await?;

    // indefinitely block here
    runner.wait().await?;

    Ok(())
}

examples/timed.rs (line 50)

async fn main() -> Result<(), PresenceError> {
    // simple atomic counter
    let count = Arc::new(AtomicUsize::new(0));

    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username()))
        .on_activity_send(move |_| {

            // increments the counter with every send_activity()
            let val = count.fetch_add(1, Ordering::Relaxed) + 1;

            println!("Activity {val} sent successfully.")

        })
        .show_errors() // enables verbose error logging
    ;

    // create activities for later use
    let activity_1 = Activity::new()
        .details("this runs")
        .state("for ten seconds")
        .build()?;

    let activity_2 = Activity::new()
        .details("believe it")
        .state("or not")
        .build()?;

    let closing_activity = Activity::new()
        .details("closing presence in...")
        .duration(Duration::from_secs(5))
        .small_image("status")
        .build()?;

    // first run
    let client = runner.run(true).await?;

    client.set_activity(activity_1).await?;
    sleep(Duration::from_secs(5)).await;
    client.set_activity(activity_2).await?;
    sleep(Duration::from_secs(5)).await;
    client.set_activity(closing_activity).await?;
    sleep(Duration::from_secs(5)).await;

    client.close().await?;

    println!("Stopped.");

    Ok(())
}

examples/indefinite.rs (line 47)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| {
            println!(
                "RPC version: v{}; Connected to user: {}",
                data.version(),
                data.user.global_name().unwrap_or_default(),
            )
        })
        .on_activity_send(|data| {
            println!(
                "Activity sent to app! (running on {})\nCreated at: {}",
                data.platform().unwrap_or_default(),
                data.activity.created_at()
            );
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
        .on_retry(move |c| {
            if c % 10 == 0 {
                println!("Retry count {c}; is Discord open?");
            }
        });

    let client = runner.run(true).await?;

    // the activity can include any combination of builder function calls
    let activity = Activity::new()
        .activity_type(ActivityType::Playing)
        .details("epic game")
        .details_url("https://github.com/hitblast")
        .status_display_type(StatusDisplayType::Details)
        .large_image("game_icon")
        .large_text("Playing a game")
        .large_url("https://hitblast.github.io/")
        .small_image("status")
        .small_text("Online")
        .build()?;

    client.set_activity(activity).await?;

    // indefinitely block here
    runner.wait().await?;

    Ok(())
}

pub async fn clear_activity(&self) -> Result<(), PresenceClientError>

Clears a previously set Discord Rich Presence activity.

NOTE: This will NOT wait for the activity to finish clearing.

pub async fn close(&self) -> Result<(), PresenceClientError>

Closes the current connection if any.

This is a semi-blocking call and does wait for the runner thread to respond to the signal being sent.

Examples found in repository

examples/timed.rs (line 57)

async fn main() -> Result<(), PresenceError> {
    // simple atomic counter
    let count = Arc::new(AtomicUsize::new(0));

    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username()))
        .on_activity_send(move |_| {

            // increments the counter with every send_activity()
            let val = count.fetch_add(1, Ordering::Relaxed) + 1;

            println!("Activity {val} sent successfully.")

        })
        .show_errors() // enables verbose error logging
    ;

    // create activities for later use
    let activity_1 = Activity::new()
        .details("this runs")
        .state("for ten seconds")
        .build()?;

    let activity_2 = Activity::new()
        .details("believe it")
        .state("or not")
        .build()?;

    let closing_activity = Activity::new()
        .details("closing presence in...")
        .duration(Duration::from_secs(5))
        .small_image("status")
        .build()?;

    // first run
    let client = runner.run(true).await?;

    client.set_activity(activity_1).await?;
    sleep(Duration::from_secs(5)).await;
    client.set_activity(activity_2).await?;
    sleep(Duration::from_secs(5)).await;
    client.set_activity(closing_activity).await?;
    sleep(Duration::from_secs(5)).await;

    client.close().await?;

    println!("Stopped.");

    Ok(())
}

Trait Implementations

impl Clone for PresenceClient

fn clone(&self) -> PresenceClient

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for PresenceClient

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

Formats the value using the given formatter.