Struct DiscordIPCSync 

pub struct DiscordIPCSync { /* private fields */ }

Blocking implementation of DiscordIPC.

Implementations

impl DiscordIPCSync

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

Creates a new Discord IPC client instance.

Examples found in repository

examples/indefinite-sync.rs (line 4)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    client.run(true).unwrap();

    let activity = Activity::new().details("this runs forever").build();

    client.set_activity(activity).unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 6)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    // 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 close_activity = Activity::new()
        .details("closing presence in...")
        .duration(Duration::from_secs(5))
        .build();

    // first run
    client.run(true).unwrap();

    client.set_activity(activity_1).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(activity_2).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(close_activity).unwrap();
    sleep(Duration::from_secs(5));
}

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 local Discord IPC server.

Examples found in repository

examples/indefinite-sync.rs (line 6)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    client.run(true).unwrap();

    let activity = Activity::new().details("this runs forever").build();

    client.set_activity(activity).unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 8)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    // 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 close_activity = Activity::new()
        .details("closing presence in...")
        .duration(Duration::from_secs(5))
        .build();

    // first run
    client.run(true).unwrap();

    client.set_activity(activity_1).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(activity_2).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(close_activity).unwrap();
    sleep(Duration::from_secs(5));
}

pub fn client_id(&self) -> String

The Discord client ID that has been used to initialize this IPC client instance.

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

Run the client. Must be called before any DiscordIPCSync::set_activity calls.

Examples found in repository

examples/indefinite-sync.rs (line 8)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    client.run(true).unwrap();

    let activity = Activity::new().details("this runs forever").build();

    client.set_activity(activity).unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 25)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    // 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 close_activity = Activity::new()
        .details("closing presence in...")
        .duration(Duration::from_secs(5))
        .build();

    // first run
    client.run(true).unwrap();

    client.set_activity(activity_1).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(activity_2).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(close_activity).unwrap();
    sleep(Duration::from_secs(5));
}

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

Waits for the IPC task to finish. DiscordIPCSync::run must be called to spawn it in the first place.

Examples found in repository

examples/indefinite-sync.rs (line 13)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    client.run(true).unwrap();

    let activity = Activity::new().details("this runs forever").build();

    client.set_activity(activity).unwrap();
    client.wait().unwrap();
}

pub fn is_running(&self) -> bool

Checks whether the task is running through the internal atomic indicator flag.

pub fn set_activity(&self, activity: Activity) -> Result<()>

Sets/updates the Discord Rich presence activity. DiscordIPCSync::run must be executed prior to calling this.

Examples found in repository

examples/indefinite-sync.rs (line 12)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    client.run(true).unwrap();

    let activity = Activity::new().details("this runs forever").build();

    client.set_activity(activity).unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 27)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|data| println!("Connected to user: {}", data.user.username));

    // 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 close_activity = Activity::new()
        .details("closing presence in...")
        .duration(Duration::from_secs(5))
        .build();

    // first run
    client.run(true).unwrap();

    client.set_activity(activity_1).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(activity_2).unwrap();
    sleep(Duration::from_secs(5));
    client.set_activity(close_activity).unwrap();
    sleep(Duration::from_secs(5));
}

pub fn clear_activity(&self) -> Result<()>

Clears a previously set Discord Rich Presence activity.

pub fn close(&mut self) -> Result<()>

Closes the current connection if any.

Trait Implementations

impl Drop for DiscordIPCSync

fn drop(&mut self)

Executes the destructor for this type.