Struct PresenceRunner

Source

pub struct PresenceRunner { /* private fields */ }

Expand description

A runner that manages the Discord RPC background task. Create a runner, configure it, run it to get a client handle, then clone the handle for sharing.

Implementations§

Source §

impl PresenceRunner

Source

pub fn new(client_id: &str) -> Self

Create a new PresenceRunner instance. Requires the client ID of your chosen app from the Discord Developer Portal.

Examples found in repository ?

examples/simple.rs (line 6)

5async fn main() -> Result<()> {
6    let mut runner = PresenceRunner::new("1463450870480900160");
7
8    let activity = Activity::new()
9        .name("cool app name")
10        .details("Something?")
11        .state("Probably~")
12        .build();
13
14    let client = runner.run(true).await?;
15    client.set_activity(activity).await?;
16
17    // indefinitely block here
18    runner.wait().await?;
19
20    Ok(())
21}

More examples

Hide additional examples

examples/indefinite.rs (line 9)

8async fn main() -> Result<()> {
9    let mut runner = PresenceRunner::new("1463450870480900160")
10        .on_ready(|data| println!("Connected to user: {}", data.user.username))
11        .on_activity_send(|data| {
12            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
13        })
14        .show_errors() // enables verbose error logging
15    ;
16
17    let client = runner.run(true).await?;
18
19    // the activity can include any combination of builder function calls
20    let activity = Activity::new()
21        .activity_type(ActivityType::Playing)
22        .details("epic game")
23        .details_url("https://github.com/hitblast")
24        .status_display_type(StatusDisplayType::Details)
25        .large_image("game_icon")
26        .large_text("Playing a game")
27        .large_url("https://hitblast.github.io/")
28        .small_image("status")
29        .small_text("Online")
30        .build();
31
32    client.set_activity(activity).await?;
33
34    // indefinitely block here
35    runner.wait().await?;
36
37    Ok(())
38}

examples/timed.rs (line 18)

14async fn main() -> Result<()> {
15    // simple atomic counter
16    let count = Arc::new(AtomicU8::new(0));
17
18    let mut runner = PresenceRunner::new("1463450870480900160")
19        .on_ready(|data| println!("Connected to user: {}", data.user.username))
20        .on_activity_send(move |_| {
21
22            // increments the counter with every send_activity()
23            let val = count.fetch_add(1, Ordering::Relaxed) + 1;
24
25            println!("Activity {val} sent successfully.")
26
27        })
28        .show_errors() // enables verbose error logging
29    ;
30
31    // create activities for later use
32    let activity_1 = Activity::new()
33        .details("this runs")
34        .state("for ten seconds")
35        .build();
36
37    let activity_2 = Activity::new()
38        .details("believe it")
39        .state("or not")
40        .build();
41
42    let closing_activity = Activity::new()
43        .details("closing presence in...")
44        .duration(Duration::from_secs(5))
45        .small_image("status")
46        .build();
47
48    // first run
49    let client = runner.run(true).await?;
50
51    client.set_activity(activity_1).await?;
52    sleep(Duration::from_secs(5)).await;
53    client.set_activity(activity_2).await?;
54    sleep(Duration::from_secs(5)).await;
55    client.set_activity(closing_activity).await?;
56    sleep(Duration::from_secs(5)).await;
57
58    client.close().await?;
59
60    println!("Stopped.");
61
62    Ok(())
63}

Source

pub fn on_ready<F: Fn(ReadyData) + Send + Sync + 'static>(self, f: F) -> Self

Run a particular closure after receiving the READY event from the Discord RPC server.

This event can fire multiple times depending on how many times the client needs to reconnect with Discord RPC.

Examples found in repository ?

examples/indefinite.rs (line 10)

8async fn main() -> Result<()> {
9    let mut runner = PresenceRunner::new("1463450870480900160")
10        .on_ready(|data| println!("Connected to user: {}", data.user.username))
11        .on_activity_send(|data| {
12            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
13        })
14        .show_errors() // enables verbose error logging
15    ;
16
17    let client = runner.run(true).await?;
18
19    // the activity can include any combination of builder function calls
20    let activity = Activity::new()
21        .activity_type(ActivityType::Playing)
22        .details("epic game")
23        .details_url("https://github.com/hitblast")
24        .status_display_type(StatusDisplayType::Details)
25        .large_image("game_icon")
26        .large_text("Playing a game")
27        .large_url("https://hitblast.github.io/")
28        .small_image("status")
29        .small_text("Online")
30        .build();
31
32    client.set_activity(activity).await?;
33
34    // indefinitely block here
35    runner.wait().await?;
36
37    Ok(())
38}

More examples

Hide additional examples

examples/timed.rs (line 19)

14async fn main() -> Result<()> {
15    // simple atomic counter
16    let count = Arc::new(AtomicU8::new(0));
17
18    let mut runner = PresenceRunner::new("1463450870480900160")
19        .on_ready(|data| println!("Connected to user: {}", data.user.username))
20        .on_activity_send(move |_| {
21
22            // increments the counter with every send_activity()
23            let val = count.fetch_add(1, Ordering::Relaxed) + 1;
24
25            println!("Activity {val} sent successfully.")
26
27        })
28        .show_errors() // enables verbose error logging
29    ;
30
31    // create activities for later use
32    let activity_1 = Activity::new()
33        .details("this runs")
34        .state("for ten seconds")
35        .build();
36
37    let activity_2 = Activity::new()
38        .details("believe it")
39        .state("or not")
40        .build();
41
42    let closing_activity = Activity::new()
43        .details("closing presence in...")
44        .duration(Duration::from_secs(5))
45        .small_image("status")
46        .build();
47
48    // first run
49    let client = runner.run(true).await?;
50
51    client.set_activity(activity_1).await?;
52    sleep(Duration::from_secs(5)).await;
53    client.set_activity(activity_2).await?;
54    sleep(Duration::from_secs(5)).await;
55    client.set_activity(closing_activity).await?;
56    sleep(Duration::from_secs(5)).await;
57
58    client.close().await?;
59
60    println!("Stopped.");
61
62    Ok(())
63}

Source

pub fn on_activity_send<F: Fn(ActivityResponseData) + Send + Sync + 'static>( self, f: F, ) -> Self

Run a particular closure after ensuring that a PresenceClient::set_activity has successfully managed to pass its data through the IPC channel.

This event can fire multiple times based on how many activities you set.

Examples found in repository ?

examples/indefinite.rs (lines 11-13)

8async fn main() -> Result<()> {
9    let mut runner = PresenceRunner::new("1463450870480900160")
10        .on_ready(|data| println!("Connected to user: {}", data.user.username))
11        .on_activity_send(|data| {
12            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
13        })
14        .show_errors() // enables verbose error logging
15    ;
16
17    let client = runner.run(true).await?;
18
19    // the activity can include any combination of builder function calls
20    let activity = Activity::new()
21        .activity_type(ActivityType::Playing)
22        .details("epic game")
23        .details_url("https://github.com/hitblast")
24        .status_display_type(StatusDisplayType::Details)
25        .large_image("game_icon")
26        .large_text("Playing a game")
27        .large_url("https://hitblast.github.io/")
28        .small_image("status")
29        .small_text("Online")
30        .build();
31
32    client.set_activity(activity).await?;
33
34    // indefinitely block here
35    runner.wait().await?;
36
37    Ok(())
38}

More examples

Hide additional examples

examples/timed.rs (lines 20-27)

14async fn main() -> Result<()> {
15    // simple atomic counter
16    let count = Arc::new(AtomicU8::new(0));
17
18    let mut runner = PresenceRunner::new("1463450870480900160")
19        .on_ready(|data| println!("Connected to user: {}", data.user.username))
20        .on_activity_send(move |_| {
21
22            // increments the counter with every send_activity()
23            let val = count.fetch_add(1, Ordering::Relaxed) + 1;
24
25            println!("Activity {val} sent successfully.")
26
27        })
28        .show_errors() // enables verbose error logging
29    ;
30
31    // create activities for later use
32    let activity_1 = Activity::new()
33        .details("this runs")
34        .state("for ten seconds")
35        .build();
36
37    let activity_2 = Activity::new()
38        .details("believe it")
39        .state("or not")
40        .build();
41
42    let closing_activity = Activity::new()
43        .details("closing presence in...")
44        .duration(Duration::from_secs(5))
45        .small_image("status")
46        .build();
47
48    // first run
49    let client = runner.run(true).await?;
50
51    client.set_activity(activity_1).await?;
52    sleep(Duration::from_secs(5)).await;
53    client.set_activity(activity_2).await?;
54    sleep(Duration::from_secs(5)).await;
55    client.set_activity(closing_activity).await?;
56    sleep(Duration::from_secs(5)).await;
57
58    client.close().await?;
59
60    println!("Stopped.");
61
62    Ok(())
63}

Source

pub fn show_errors(self) -> Self

Enable verbose error logging for RPC and code events.

Examples found in repository ?

examples/indefinite.rs (line 14)

8async fn main() -> Result<()> {
9    let mut runner = PresenceRunner::new("1463450870480900160")
10        .on_ready(|data| println!("Connected to user: {}", data.user.username))
11        .on_activity_send(|data| {
12            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
13        })
14        .show_errors() // enables verbose error logging
15    ;
16
17    let client = runner.run(true).await?;
18
19    // the activity can include any combination of builder function calls
20    let activity = Activity::new()
21        .activity_type(ActivityType::Playing)
22        .details("epic game")
23        .details_url("https://github.com/hitblast")
24        .status_display_type(StatusDisplayType::Details)
25        .large_image("game_icon")
26        .large_text("Playing a game")
27        .large_url("https://hitblast.github.io/")
28        .small_image("status")
29        .small_text("Online")
30        .build();
31
32    client.set_activity(activity).await?;
33
34    // indefinitely block here
35    runner.wait().await?;
36
37    Ok(())
38}

More examples

Hide additional examples

examples/timed.rs (line 28)

14async fn main() -> Result<()> {
15    // simple atomic counter
16    let count = Arc::new(AtomicU8::new(0));
17
18    let mut runner = PresenceRunner::new("1463450870480900160")
19        .on_ready(|data| println!("Connected to user: {}", data.user.username))
20        .on_activity_send(move |_| {
21
22            // increments the counter with every send_activity()
23            let val = count.fetch_add(1, Ordering::Relaxed) + 1;
24
25            println!("Activity {val} sent successfully.")
26
27        })
28        .show_errors() // enables verbose error logging
29    ;
30
31    // create activities for later use
32    let activity_1 = Activity::new()
33        .details("this runs")
34        .state("for ten seconds")
35        .build();
36
37    let activity_2 = Activity::new()
38        .details("believe it")
39        .state("or not")
40        .build();
41
42    let closing_activity = Activity::new()
43        .details("closing presence in...")
44        .duration(Duration::from_secs(5))
45        .small_image("status")
46        .build();
47
48    // first run
49    let client = runner.run(true).await?;
50
51    client.set_activity(activity_1).await?;
52    sleep(Duration::from_secs(5)).await;
53    client.set_activity(activity_2).await?;
54    sleep(Duration::from_secs(5)).await;
55    client.set_activity(closing_activity).await?;
56    sleep(Duration::from_secs(5)).await;
57
58    client.close().await?;
59
60    println!("Stopped.");
61
62    Ok(())
63}

Source

pub async fn run(&mut self, wait_for_ready: bool) -> Result<&PresenceClient>

Run the runner. Must be called before any client handle operations.

Examples found in repository ?

examples/simple.rs (line 14)

5async fn main() -> Result<()> {
6    let mut runner = PresenceRunner::new("1463450870480900160");
7
8    let activity = Activity::new()
9        .name("cool app name")
10        .details("Something?")
11        .state("Probably~")
12        .build();
13
14    let client = runner.run(true).await?;
15    client.set_activity(activity).await?;
16
17    // indefinitely block here
18    runner.wait().await?;
19
20    Ok(())
21}

More examples

Hide additional examples

examples/indefinite.rs (line 17)

8async fn main() -> Result<()> {
9    let mut runner = PresenceRunner::new("1463450870480900160")
10        .on_ready(|data| println!("Connected to user: {}", data.user.username))
11        .on_activity_send(|data| {
12            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
13        })
14        .show_errors() // enables verbose error logging
15    ;
16
17    let client = runner.run(true).await?;
18
19    // the activity can include any combination of builder function calls
20    let activity = Activity::new()
21        .activity_type(ActivityType::Playing)
22        .details("epic game")
23        .details_url("https://github.com/hitblast")
24        .status_display_type(StatusDisplayType::Details)
25        .large_image("game_icon")
26        .large_text("Playing a game")
27        .large_url("https://hitblast.github.io/")
28        .small_image("status")
29        .small_text("Online")
30        .build();
31
32    client.set_activity(activity).await?;
33
34    // indefinitely block here
35    runner.wait().await?;
36
37    Ok(())
38}

examples/timed.rs (line 49)

14async fn main() -> Result<()> {
15    // simple atomic counter
16    let count = Arc::new(AtomicU8::new(0));
17
18    let mut runner = PresenceRunner::new("1463450870480900160")
19        .on_ready(|data| println!("Connected to user: {}", data.user.username))
20        .on_activity_send(move |_| {
21
22            // increments the counter with every send_activity()
23            let val = count.fetch_add(1, Ordering::Relaxed) + 1;
24
25            println!("Activity {val} sent successfully.")
26
27        })
28        .show_errors() // enables verbose error logging
29    ;
30
31    // create activities for later use
32    let activity_1 = Activity::new()
33        .details("this runs")
34        .state("for ten seconds")
35        .build();
36
37    let activity_2 = Activity::new()
38        .details("believe it")
39        .state("or not")
40        .build();
41
42    let closing_activity = Activity::new()
43        .details("closing presence in...")
44        .duration(Duration::from_secs(5))
45        .small_image("status")
46        .build();
47
48    // first run
49    let client = runner.run(true).await?;
50
51    client.set_activity(activity_1).await?;
52    sleep(Duration::from_secs(5)).await;
53    client.set_activity(activity_2).await?;
54    sleep(Duration::from_secs(5)).await;
55    client.set_activity(closing_activity).await?;
56    sleep(Duration::from_secs(5)).await;
57
58    client.close().await?;
59
60    println!("Stopped.");
61
62    Ok(())
63}

Source

pub fn clone_handle(&self) -> PresenceClient

Returns a clone of the client handle for sharing.

Source

pub async fn wait(&mut self) -> Result<()>

Waits for the IPC task to finish.

Examples found in repository ?

examples/simple.rs (line 18)

5async fn main() -> Result<()> {
6    let mut runner = PresenceRunner::new("1463450870480900160");
7
8    let activity = Activity::new()
9        .name("cool app name")
10        .details("Something?")
11        .state("Probably~")
12        .build();
13
14    let client = runner.run(true).await?;
15    client.set_activity(activity).await?;
16
17    // indefinitely block here
18    runner.wait().await?;
19
20    Ok(())
21}

More examples

Hide additional examples

examples/indefinite.rs (line 35)

8async fn main() -> Result<()> {
9    let mut runner = PresenceRunner::new("1463450870480900160")
10        .on_ready(|data| println!("Connected to user: {}", data.user.username))
11        .on_activity_send(|data| {
12            println!("Activity sent to app: {} (running on {})\nMetadata: {}", data.name, data.platform, data.metadata)
13        })
14        .show_errors() // enables verbose error logging
15    ;
16
17    let client = runner.run(true).await?;
18
19    // the activity can include any combination of builder function calls
20    let activity = Activity::new()
21        .activity_type(ActivityType::Playing)
22        .details("epic game")
23        .details_url("https://github.com/hitblast")
24        .status_display_type(StatusDisplayType::Details)
25        .large_image("game_icon")
26        .large_text("Playing a game")
27        .large_url("https://hitblast.github.io/")
28        .small_image("status")
29        .small_text("Online")
30        .build();
31
32    client.set_activity(activity).await?;
33
34    // indefinitely block here
35    runner.wait().await?;
36
37    Ok(())
38}