Struct ReadyData 

pub struct ReadyData {
    pub config: ServerConfigurationData,
    pub user: DiscordUser,
    /* private fields */
}

Data received from a READY event.

Fields

config: ServerConfigurationData

The server configuration data for the RPC.

user: DiscordUser

The user to whom you are connected.

Implementations

impl ReadyData

pub fn version(&self) -> u8

The version of the RPC that is being used.

Examples found in repository

examples/indefinite.rs (line 13)

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 Clone for ReadyData

fn clone(&self) -> ReadyData

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReadyData

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ReadyData

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.