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(|| println!("filthy-rich is READY to set activity updates."));

    client.run(true).unwrap();

    client
        .set_activity("this runs forever".to_string(), None)
        .unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 6)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|| println!("filthy-rich is READY to set activity updates."));

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

    client
        .set_activity("this runs".to_string(), Some("for ten seconds".to_string()))
        .unwrap();
    sleep(Duration::from_secs(5));
    client
        .set_activity("believe it".to_string(), Some("or not!".to_string()))
        .unwrap();
    sleep(Duration::from_secs(5));
}

pub fn on_ready<F: Fn() + 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(|| println!("filthy-rich is READY to set activity updates."));

    client.run(true).unwrap();

    client
        .set_activity("this runs forever".to_string(), None)
        .unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 8)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|| println!("filthy-rich is READY to set activity updates."));

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

    client
        .set_activity("this runs".to_string(), Some("for ten seconds".to_string()))
        .unwrap();
    sleep(Duration::from_secs(5));
    client
        .set_activity("believe it".to_string(), Some("or not!".to_string()))
        .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(|| println!("filthy-rich is READY to set activity updates."));

    client.run(true).unwrap();

    client
        .set_activity("this runs forever".to_string(), None)
        .unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 11)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|| println!("filthy-rich is READY to set activity updates."));

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

    client
        .set_activity("this runs".to_string(), Some("for ten seconds".to_string()))
        .unwrap();
    sleep(Duration::from_secs(5));
    client
        .set_activity("believe it".to_string(), Some("or not!".to_string()))
        .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(|| println!("filthy-rich is READY to set activity updates."));

    client.run(true).unwrap();

    client
        .set_activity("this runs forever".to_string(), None)
        .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, details: String, state: Option<String>) -> 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 11)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|| println!("filthy-rich is READY to set activity updates."));

    client.run(true).unwrap();

    client
        .set_activity("this runs forever".to_string(), None)
        .unwrap();
    client.wait().unwrap();
}

examples/timed-sync.rs (line 14)

fn main() {
    let mut client = DiscordIPCSync::new("1463450870480900160")
        .unwrap()
        .on_ready(|| println!("filthy-rich is READY to set activity updates."));

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

    client
        .set_activity("this runs".to_string(), Some("for ten seconds".to_string()))
        .unwrap();
    sleep(Duration::from_secs(5));
    client
        .set_activity("believe it".to_string(), Some("or not!".to_string()))
        .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.