Struct Packet 

pub struct Packet {
    pub opcode: Opcode,
    pub payload: Value,
}

Represents a Discord IPC message packet.

Fields

opcode: Opcode

payload: Value

Implementations

impl Packet

pub fn new(opcode: Opcode, payload: impl Into<Value>) -> Self

Creates a new packet with the given opcode and payload.

Arguments

• opcode: The Opcode for the packet.
• payload: Data that can be converted into a JSON Value.

Examples found in repository

examples/01_basics.rs (line 39)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // === Build a client ===

    // Build your client instance (with your own application ID)
    // You can create one in https://discord.com/developers/applications
    let client = Client::new("<application_id>");

    // Listen to "READY" event
    // The "READY" event is triggered when the client has successfully connected to Discord
    // and is ready to receive and send packets.
    client.on("READY", |client, _packet| {
        println!("Connected");
        // You will receive as arguments a reference to the client instance you created and the incoming Discord packet.
        // Once the client is connected, you can start interacting with Discord's IPC.

        // === Build a packet ===
        // A packet is built from an opcode and a payload.
        // The opcode establishes the kind of operation to be performed
        // The most common opcodes are Opcode::Frame (1) and Opcode::Ping (3).
        // Frame is used for most operations, while Ping is only used to ping Discord.
        let opcode = Opcode::Ping;
        // The payload contains the command data in JSON format in addition to a
        // unique nonce for identifying the packet exchange.
        // The payload of a ping packet is optional; you can send an empty value if you prefer.
        // You can listen to the opcode (4)Pong to handle the response
        // or you can include a "nonce" field in the payload.
        let nonce = Packet::generate_nonce();
        let payload = json!({
            "nonce": nonce,
            "example_field": "ping"
        });

        let ping = Packet::new(opcode, payload);

        // === Listen for a response ===
        client.once(nonce, |_client, packet| {
            // If you receive this, the ping was successful.
            println!("Pong!");
            // The received packet has the opcode (4)Pong and has the same payload as the one sent before.
            println!("{}", packet);
        });

        // === Send the packet ===
        // Once you set up the listener, you can now send your packet
        if let Err(e) = client.send(ping) {
            eprintln!("Couldn't send packet: {}", e)
        };
        // When a response is received, the listener will be triggered.
    });

    // Try to connect
    client.connect()?;
    std::io::stdin().read_line(&mut String::new()).unwrap();
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

pub fn new_activity(activity: Option<&Activity>, nonce: Option<&str>) -> Self

Creates a new activity packet for Discord IPC.

Arguments

• activity: Optional Activity. Pass None to clear.
• nonce: Optional nonce string.

Examples found in repository

examples/00_simple.rs (line 32)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build your client instance (with your own application ID)
    // You can create one in https://discord.com/developers/applications
    let client = Client::new_simple("<application_id>");

    // `connect_and_wait()` is a blocking method that sends a connection request,
    // waits for a direct response, and returns the response packet.
    let connection_response = client.connect_and_wait()?;

    // You can use `filter()` in any packet to search for an error response.
    match connection_response.filter() {
        Ok(_packet) => println!("Connected"),
        Err(e) => {
            eprintln!("Couldn't connect to Discord: {}", e);
            return Ok(());
        }
    }

    // === Set an activity ===
    let activity = Activity::new().details("Simple activity");

    // Build an activity packet.
    // Pass Some(&activity) to set an activity or None to clear it.
    // The second argument is a nonce used to identify a packet exchange, but it's not needed here,
    // since `send_and_wait()` already waits for a direct response.
    let packet = Packet::new_activity(Some(&activity), None);

    // You can use `filter()` in `send_and_wait()` as it returns a packet
    match client.send_and_wait(packet)?.filter() {
        Ok(_packet) => println!("Activity has been set!"),
        Err(e) => eprintln!("Couldn't set activity: {}", e),
    };

    std::thread::sleep(std::time::Duration::from_secs(10));

    // === Clear the activity ===
    let packet = Packet::new_activity(None, None);
    match client.send_and_wait(packet)?.filter() {
        Ok(_packet) => println!("Activity has been cleared!"),
        Err(e) => eprintln!("Couldn't clear activity: {}", e),
    };

    std::thread::sleep(std::time::Duration::from_secs(3));
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

examples/02_activity.rs (line 40)

fn main() -> Result<()> {
    let client = Client::new("<application_id>");

    client.on("READY", |client, _packet| {
        println!("Connected");

        // === Create an activity ===

        // You can create activities this way... (recommended)
        let activity = Activity::new()
            .details("In Workspace: test")
            .state("Dealing with proc-macros")
            .timestamps(Timestamps::new().start_now())
            .button(Button::new("Get started!", "https://rustup.rs/"));

        // Or this way...
        let _activity = Activity {
            details: Some("In Workspace: test".to_string()),
            state: Some("Dealing with proc-macros".to_string()),
            timestamps: Some(Timestamps::new().start_now()),
            buttons: Some(vec![Button {
                label: "Get started!".to_string(),
                url: "https://rustup.rs/".to_string(),
            }]),
            ..Activity::default()
        };
        // Note that this method is more susceptible to errors as it skips structural checks.

        // === Build the packet ===
        let nonce = Packet::generate_nonce(); // Unique nonce for identifying the packet exchange

        // You can manually build the activity packet with Packet::new()
        // or you can use Packet::new_activity()
        let activity_packet = Packet::new_activity(Some(&activity), Some(&nonce));

        // === Listen for a response ===
        client.once(nonce, |client, packet| {
            // Setting up an activity is an operation that could fail,
            // so the packet payload may contain a success or an error.
            // You can use packet.filter() to automatically search for errors in its payload.
            match packet.filter() {
                Ok(_packet) => {
                    println!("Activity has been set!");

                    std::thread::sleep(std::time::Duration::from_secs(10));

                    if let Err(e) = client.send(Packet::new_activity(None, None)) {
                        eprintln!("Couldn't send packet: {}", e)
                    };
                    println!("Activity cleared!");
                }
                Err(e) => println!("Couldn't set activity: {}", e),
            }
        });

        // Once you set up the listener, you can now send the activity packet.
        if let Err(e) = client.send(activity_packet) {
            eprintln!("Couldn't send packet: {}", e)
        };
    });

    // Try to connect
    client.connect()?;
    std::io::stdin().read_line(&mut String::new()).unwrap();
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

pub fn generate_nonce() -> String

Generates a unique nonce using UUID v4.

Examples found in repository

examples/01_basics.rs (line 33)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // === Build a client ===

    // Build your client instance (with your own application ID)
    // You can create one in https://discord.com/developers/applications
    let client = Client::new("<application_id>");

    // Listen to "READY" event
    // The "READY" event is triggered when the client has successfully connected to Discord
    // and is ready to receive and send packets.
    client.on("READY", |client, _packet| {
        println!("Connected");
        // You will receive as arguments a reference to the client instance you created and the incoming Discord packet.
        // Once the client is connected, you can start interacting with Discord's IPC.

        // === Build a packet ===
        // A packet is built from an opcode and a payload.
        // The opcode establishes the kind of operation to be performed
        // The most common opcodes are Opcode::Frame (1) and Opcode::Ping (3).
        // Frame is used for most operations, while Ping is only used to ping Discord.
        let opcode = Opcode::Ping;
        // The payload contains the command data in JSON format in addition to a
        // unique nonce for identifying the packet exchange.
        // The payload of a ping packet is optional; you can send an empty value if you prefer.
        // You can listen to the opcode (4)Pong to handle the response
        // or you can include a "nonce" field in the payload.
        let nonce = Packet::generate_nonce();
        let payload = json!({
            "nonce": nonce,
            "example_field": "ping"
        });

        let ping = Packet::new(opcode, payload);

        // === Listen for a response ===
        client.once(nonce, |_client, packet| {
            // If you receive this, the ping was successful.
            println!("Pong!");
            // The received packet has the opcode (4)Pong and has the same payload as the one sent before.
            println!("{}", packet);
        });

        // === Send the packet ===
        // Once you set up the listener, you can now send your packet
        if let Err(e) = client.send(ping) {
            eprintln!("Couldn't send packet: {}", e)
        };
        // When a response is received, the listener will be triggered.
    });

    // Try to connect
    client.connect()?;
    std::io::stdin().read_line(&mut String::new()).unwrap();
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

examples/02_activity.rs (line 36)

fn main() -> Result<()> {
    let client = Client::new("<application_id>");

    client.on("READY", |client, _packet| {
        println!("Connected");

        // === Create an activity ===

        // You can create activities this way... (recommended)
        let activity = Activity::new()
            .details("In Workspace: test")
            .state("Dealing with proc-macros")
            .timestamps(Timestamps::new().start_now())
            .button(Button::new("Get started!", "https://rustup.rs/"));

        // Or this way...
        let _activity = Activity {
            details: Some("In Workspace: test".to_string()),
            state: Some("Dealing with proc-macros".to_string()),
            timestamps: Some(Timestamps::new().start_now()),
            buttons: Some(vec![Button {
                label: "Get started!".to_string(),
                url: "https://rustup.rs/".to_string(),
            }]),
            ..Activity::default()
        };
        // Note that this method is more susceptible to errors as it skips structural checks.

        // === Build the packet ===
        let nonce = Packet::generate_nonce(); // Unique nonce for identifying the packet exchange

        // You can manually build the activity packet with Packet::new()
        // or you can use Packet::new_activity()
        let activity_packet = Packet::new_activity(Some(&activity), Some(&nonce));

        // === Listen for a response ===
        client.once(nonce, |client, packet| {
            // Setting up an activity is an operation that could fail,
            // so the packet payload may contain a success or an error.
            // You can use packet.filter() to automatically search for errors in its payload.
            match packet.filter() {
                Ok(_packet) => {
                    println!("Activity has been set!");

                    std::thread::sleep(std::time::Duration::from_secs(10));

                    if let Err(e) = client.send(Packet::new_activity(None, None)) {
                        eprintln!("Couldn't send packet: {}", e)
                    };
                    println!("Activity cleared!");
                }
                Err(e) => println!("Couldn't set activity: {}", e),
            }
        });

        // Once you set up the listener, you can now send the activity packet.
        if let Err(e) = client.send(activity_packet) {
            eprintln!("Couldn't send packet: {}", e)
        };
    });

    // Try to connect
    client.connect()?;
    std::io::stdin().read_line(&mut String::new()).unwrap();
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

pub fn decode_header(header: &[u8; 8]) -> Result<(u32, u32)>

Decodes a Discord IPC response header.

Errors

• DecodeError: If the header is malformed, incomplete, or cannot be decoded.

pub fn filter(self) -> Result<Packet, BadResponseError>

Checks for errors in a Discord IPC response payload.

Returns

• Ok(Packet) if no error is found.
• Err(BadResponseError) if there is an error.

See BadResponseError

Examples found in repository

examples/00_simple.rs (line 17)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Build your client instance (with your own application ID)
    // You can create one in https://discord.com/developers/applications
    let client = Client::new_simple("<application_id>");

    // `connect_and_wait()` is a blocking method that sends a connection request,
    // waits for a direct response, and returns the response packet.
    let connection_response = client.connect_and_wait()?;

    // You can use `filter()` in any packet to search for an error response.
    match connection_response.filter() {
        Ok(_packet) => println!("Connected"),
        Err(e) => {
            eprintln!("Couldn't connect to Discord: {}", e);
            return Ok(());
        }
    }

    // === Set an activity ===
    let activity = Activity::new().details("Simple activity");

    // Build an activity packet.
    // Pass Some(&activity) to set an activity or None to clear it.
    // The second argument is a nonce used to identify a packet exchange, but it's not needed here,
    // since `send_and_wait()` already waits for a direct response.
    let packet = Packet::new_activity(Some(&activity), None);

    // You can use `filter()` in `send_and_wait()` as it returns a packet
    match client.send_and_wait(packet)?.filter() {
        Ok(_packet) => println!("Activity has been set!"),
        Err(e) => eprintln!("Couldn't set activity: {}", e),
    };

    std::thread::sleep(std::time::Duration::from_secs(10));

    // === Clear the activity ===
    let packet = Packet::new_activity(None, None);
    match client.send_and_wait(packet)?.filter() {
        Ok(_packet) => println!("Activity has been cleared!"),
        Err(e) => eprintln!("Couldn't clear activity: {}", e),
    };

    std::thread::sleep(std::time::Duration::from_secs(3));
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

examples/02_activity.rs (line 47)

fn main() -> Result<()> {
    let client = Client::new("<application_id>");

    client.on("READY", |client, _packet| {
        println!("Connected");

        // === Create an activity ===

        // You can create activities this way... (recommended)
        let activity = Activity::new()
            .details("In Workspace: test")
            .state("Dealing with proc-macros")
            .timestamps(Timestamps::new().start_now())
            .button(Button::new("Get started!", "https://rustup.rs/"));

        // Or this way...
        let _activity = Activity {
            details: Some("In Workspace: test".to_string()),
            state: Some("Dealing with proc-macros".to_string()),
            timestamps: Some(Timestamps::new().start_now()),
            buttons: Some(vec![Button {
                label: "Get started!".to_string(),
                url: "https://rustup.rs/".to_string(),
            }]),
            ..Activity::default()
        };
        // Note that this method is more susceptible to errors as it skips structural checks.

        // === Build the packet ===
        let nonce = Packet::generate_nonce(); // Unique nonce for identifying the packet exchange

        // You can manually build the activity packet with Packet::new()
        // or you can use Packet::new_activity()
        let activity_packet = Packet::new_activity(Some(&activity), Some(&nonce));

        // === Listen for a response ===
        client.once(nonce, |client, packet| {
            // Setting up an activity is an operation that could fail,
            // so the packet payload may contain a success or an error.
            // You can use packet.filter() to automatically search for errors in its payload.
            match packet.filter() {
                Ok(_packet) => {
                    println!("Activity has been set!");

                    std::thread::sleep(std::time::Duration::from_secs(10));

                    if let Err(e) = client.send(Packet::new_activity(None, None)) {
                        eprintln!("Couldn't send packet: {}", e)
                    };
                    println!("Activity cleared!");
                }
                Err(e) => println!("Couldn't set activity: {}", e),
            }
        });

        // Once you set up the listener, you can now send the activity packet.
        if let Err(e) = client.send(activity_packet) {
            eprintln!("Couldn't send packet: {}", e)
        };
    });

    // Try to connect
    client.connect()?;
    std::io::stdin().read_line(&mut String::new()).unwrap();
    client.disconnect()?;
    println!("Disconnected");

    Ok(())
}

Trait Implementations

impl Clone for Packet

fn clone(&self) -> Packet

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Packet

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

Formats the value using the given formatter.

impl Display for Packet

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

Formats the value using the given formatter.

impl Serialize for Packet

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.