Struct ActivityBuilder 

pub struct ActivityBuilder { /* private fields */ }

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

Implementations

impl ActivityBuilder

pub fn name(self, text: 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 activity_type(self, type: ActivityType) -> Self

The type of activity you want to create.

Examples found in repository

examples/indefinite.rs (line 22)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

    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(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/indefinite.rs (line 23)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

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

examples/timed.rs (line 32)

async fn main() -> Result<(), PresenceError> {
    // simple atomic counter
    let count = Arc::new(AtomicU8::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 details_url(self, url: impl Into<String>) -> Self

URL for the top text of your activity.

Examples found in repository

examples/indefinite.rs (line 24)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

    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 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(AtomicU8::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 bottom text of your activity.

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

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

    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(AtomicU8::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 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 26)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

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

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

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

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

    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/indefinite.rs (line 29)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

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

examples/timed.rs (line 44)

async fn main() -> Result<(), PresenceError> {
    // simple atomic counter
    let count = Arc::new(AtomicU8::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 small_text(self, text: impl Into<String>) -> Self

Text for the small image of your activity.

Examples found in repository

examples/indefinite.rs (line 30)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

    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 build(self) -> Activity

Parses the state of this builder into a usable Activity for you to pass through super::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/indefinite.rs (line 31)

async fn main() -> Result<(), PresenceError> {
    let mut runner = PresenceRunner::new("1463450870480900160")
        .on_ready(|data| println!("Connected to user: {}", data.user.username))
        .on_activity_send(|data| {
            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
        })
        .on_disconnect(|f| println!("Disconnected: {f:?}"))
        .show_errors() // enables verbose error logging
    ;

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

examples/timed.rs (line 34)

async fn main() -> Result<(), PresenceError> {
    // simple atomic counter
    let count = Arc::new(AtomicU8::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 Default for ActivityBuilder

fn default() -> ActivityBuilder

Returns the “default value” for a type.