presenceforge 0.1.0

A library for Discord Rich Presence (IPC) integration
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

// Example demonstrating pipe selection and discovery features

use clap::Parser;
use presenceforge::sync::DiscordIpcClient;
use presenceforge::{ActivityBuilder, IpcConnection, PipeConfig};
/// Discord IPC Pipe Selection Example
#[derive(Parser, Debug)]
#[command(author, version, about, long_about = None)]
struct Args {
    /// Discord Application Client ID
    #[arg(short, long)]
    client_id: Option<String>,
}

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load .env file if it exists (optional)
    let _ = dotenvy::dotenv();

    let args = Args::parse();

    let client_id = args
        .client_id
        .or_else(|| std::env::var("DISCORD_CLIENT_ID").ok())
        .unwrap_or_else(|| {
            eprintln!("Error: DISCORD_CLIENT_ID is required!");
            eprintln!("Provide it via:");
            eprintln!(
                "  - Command line: cargo run --example pipe_selection -- --client-id YOUR_ID"
            );
            eprintln!(
                "  - Environment: DISCORD_CLIENT_ID=YOUR_ID cargo run --example pipe_selection"
            );
            eprintln!("  - .env file: Create .env from .env.example and set DISCORD_CLIENT_ID");
            std::process::exit(1);
        });

    println!("=== Discord IPC Pipe Selection Example ===\n");

    // 1. Discover all available Discord IPC pipes
    println!("1. Discovering available Discord IPC pipes...");
    let pipes = IpcConnection::discover_pipes();

    if pipes.is_empty() {
        println!("   No Discord IPC pipes found. Is Discord running?");
        return Ok(());
    }

    println!("   Found {} pipe(s):", pipes.len());
    for pipe in &pipes {
        println!("   - Pipe {}: {}", pipe.pipe_number, pipe.path);
    }
    println!();

    // 2. Connect using auto-discovery (default behavior)
    println!("2. Connecting using auto-discovery (default)...");
    let mut client1 = DiscordIpcClient::new(&client_id)?;
    client1.connect()?;
    println!("   ✓ Connected successfully using auto-discovery");
    client1.clear_activity()?;
    drop(client1);
    println!();

    // 3. Connect to a specific pipe using discovered path
    if !pipes.is_empty() {
        let pipe_num = pipes[0].pipe_number;
        let pipe_path = pipes[0].path.clone();
        println!(
            "3. Connecting to specific pipe {} at {}...",
            pipe_num, pipe_path
        );
        let mut client2 =
            DiscordIpcClient::new_with_config(&client_id, Some(PipeConfig::CustomPath(pipe_path)))?;
        client2.connect()?;
        println!("   ✓ Connected successfully to pipe {}", pipe_num);

        // Set an activity
        let activity = ActivityBuilder::new()
            .state("Using pipe selection")
            .details(format!("Connected to pipe {}", pipe_num))
            .build();

        client2.set_activity(&activity)?;
        println!("   ✓ Activity set successfully");

        // Keep activity for a moment
        std::thread::sleep(std::time::Duration::from_secs(5));

        client2.clear_activity()?;
        println!("   ✓ Activity cleared");
        drop(client2);
    }
    println!();

    // 4. Connect using custom path (Unix only)
    #[cfg(unix)]
    {
        if !pipes.is_empty() {
            let custom_path = pipes[0].path.clone();
            println!("4. Connecting using custom path: {}...", custom_path);
            let mut client3 = DiscordIpcClient::new_with_config(
                &client_id,
                Some(PipeConfig::CustomPath(custom_path.clone())),
            )?;
            client3.connect()?;
            println!("   ✓ Connected successfully using custom path");
            client3.clear_activity()?;
            drop(client3);
            println!();
        }
    }

    // 5. Connect with timeout and specific pipe
    if !pipes.is_empty() {
        let pipe_num = pipes[0].pipe_number;
        let pipe_path = pipes[0].path.clone();
        println!(
            "5. Connecting with timeout (5000ms) to pipe {} at {}...",
            pipe_num, pipe_path
        );
        let mut client4 = DiscordIpcClient::new_with_config_and_timeout(
            &client_id,
            Some(PipeConfig::CustomPath(pipe_path)),
            5000,
        )?;
        client4.connect()?;
        println!("   ✓ Connected successfully with timeout");
        client4.clear_activity()?;
        drop(client4);
    }

    println!("\n=== All examples completed successfully! ===");
    Ok(())
}