Struct ActivityBuilder 

pub struct ActivityBuilder { /* private fields */ }

A builder for a Rich Presence activity. To build a ActivitySpec out of it, use ActivityBuilder::build.

Implementations

impl ActivityBuilder

pub fn name(self, name: impl Into<String>) -> Self

Name of the activity.

Examples found in repository

examples/simple.rs (line 8)

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(())
}

pub fn details(self, text: impl Into<String>) -> Self

Top text for your activity.

Examples found in repository

examples/simple.rs (line 9)

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 32)

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 37)

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 fn details_url(self, url: impl Into<String>) -> Self

URL for the top text of your activity.

Examples found in repository

examples/indefinite.rs (line 38)

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 fn state(self, text: impl Into<String>) -> Self

Bottom text (top if field details is missing) for your activity.

Examples found in repository

examples/simple.rs (line 10)

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 33)

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(())
}

pub fn state_url(self, url: impl Into<String>) -> Self

URL for the state of your activity.

pub fn large_image(self, key: impl Into<String>) -> Self

Large image for your activity (e.g. game icon)

Examples found in repository

examples/indefinite.rs (line 40)

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 fn large_text(self, text: impl Into<String>) -> Self

Text for the large image of your activity.

Examples found in repository

examples/indefinite.rs (line 41)

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 fn large_url(self, url: impl Into<String>) -> Self

URL for the large image of your activity.

Examples found in repository

examples/indefinite.rs (line 42)

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 fn small_image(self, key: impl Into<String>) -> Self

Small image for your activity (e.g. game icon)

Examples found in repository

examples/timed.rs (line 44)

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 43)

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 fn small_text(self, text: impl Into<String>) -> Self

Text for the small image of your activity.

Examples found in repository

examples/indefinite.rs (line 44)

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 fn small_url(self, url: impl Into<String>) -> Self

URL for the small image of your activity.

pub fn activity_type(self, type: ActivityType) -> Self

The type of activity you want to create.

Examples found in repository

examples/indefinite.rs (line 36)

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 fn set_as_instance(self) -> Self

Sets the activity to be an instance.

pub fn status_display_type(self, type: StatusDisplayType) -> Self

The status display type for the activity.

Examples found in repository

examples/indefinite.rs (line 39)

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 fn duration(self, duration: Duration) -> Self

Countdown duration for your activity.

Examples found in repository

examples/timed.rs (line 43)

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(())
}

pub fn add_button( self, label: impl Into<String>, url: impl Into<String>, ) -> Self

Adds a button to the activity.

NOTE: The Discord desktop client may behave in such a way that the buttons may only be visible from anyone but the connected user’s side. This is a wonky feature and must be used with care.

pub fn build(self) -> Result<ActivitySpec, ActivitySpecBuildError>

Parses the state of this builder into a usable ActivitySpec for you to pass through crate::PresenceClient::set_activity.

Examples found in repository

examples/simple.rs (line 11)

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 34)

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 45)

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(())
}

Trait Implementations

impl Default for ActivityBuilder

fn default() -> ActivityBuilder

Returns the “default value” for a type.