Struct BarkClient 

pub struct BarkClient { /* private fields */ }

同步 Bark 推送客户端

使用 reqwest 的 blocking 客户端实现，无需异步运行时，可以在任何环境下工作。 支持单个设备推送和批量推送功能。

创建客户端

use bark_rs::SyncBarkClient;

// 创建没有默认设备密钥的客户端
let client = SyncBarkClient::new("https://api.day.app");

// 创建带有默认设备密钥的客户端
let client = SyncBarkClient::with_device_key("https://api.day.app", "your_device_key");

发送消息

use bark_rs::{SyncBarkClient, BarkMessage, Level};

let client = SyncBarkClient::with_device_key("https://api.day.app", "your_key");

// 方式 1: 使用 message() 方法的 Builder 模式
let response = client
    .message()
    .title("标题")
    .body("内容")
    .level(Level::Active)
    .send()?;

// 方式 2: 先构建消息再发送
let message = BarkMessage::builder()
    .title("标题")
    .body("内容")
    .build();

let response = client.send(&message)?;

Implementations

impl SyncBarkClient

pub fn new(base_url: &str) -> Self

创建新的同步 Bark 客户端

创建一个没有默认设备密钥的客户端实例。发送消息时需要在消息中指定设备密钥， 或者使用 SyncBarkClient::with_device_key 创建带默认密钥的客户端。

参数

• base_url - Bark 服务器的基础 URL（如 https://api.day.app）

示例

use bark_rs::SyncBarkClient;

let client = SyncBarkClient::new("https://api.day.app");

Examples found in repository

examples/batch_push.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建同步客户端
    let client = SyncBarkClient::new("https://api.day.app");

    // 批量推送到多个设备
    let response = client
        .message()
        .device_keys(vec![
            "QJ48vPutCAsPW2B6pE2A3a".to_string(),
            "device_key_2".to_string(),
            "device_key_3".to_string(),
        ])
        .title("批量推送通知")
        .body("这是一个发送给多个设备的批量消息")
        .level(Level::TimeSensitive)
        .volume(7)
        .badge(1)
        .group("批量通知")
        .send()?;

    println!(
        "批量推送成功: code={}, message={}",
        response.code, response.message
    );

    Ok(())
}

examples/error_handling.rs (line 7)

fn main() {
    println!("🚨 演示错误处理");

    // 创建没有默认设备密钥的客户端
    let client = SyncBarkClient::new("https://api.day.app");

    // 尝试发送没有设备密钥的消息
    let message_without_key = BarkMessage::builder()
        .title("错误演示")
        .body("这个消息没有设备密钥")
        .build();

    match client.send(&message_without_key) {
        Ok(_) => println!("❌ 意外成功"),
        Err(BarkError::MissingDeviceKey) => {
            println!("✅ 正确捕获到缺少设备密钥错误");
        }
        Err(e) => println!("❓ 其他错误: {}", e),
    }

    // 演示正确的错误处理模式
    let result = client
        .message()
        .device_key("QJ48vPutCAsPW2B6pE2A3a")
        .title("正确的消息")
        .body("这个消息有设备密钥")
        .send();

    match result {
        Ok(response) => {
            println!(
                "✅ 消息发送成功: code={}, message={}",
                response.code, response.message
            );
        }
        Err(BarkError::RequestError(e)) => {
            println!("❌ 网络请求错误: {}", e);
        }
        Err(BarkError::MissingDeviceKey) => {
            println!("❌ 缺少设备密钥");
        }
        Err(BarkError::SerializationError(e)) => {
            println!("❌ 序列化错误: {}", e);
        }
        Err(BarkError::InvalidUrl) => {
            println!("❌ 无效URL");
        }
    }

    println!("🎉 错误处理演示完成！");
}

examples/mixed_usage.rs (line 19)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔀 演示混合使用场景");

    // 创建一个消息，可以被不同的客户端使用
    let shared_message = BarkMessage::builder()
        .device_key("QJ48vPutCAsPW2B6pE2A3a")
        .title("共享消息")
        .body("这个消息可以被同步和异步客户端共用")
        .level(Level::Active)
        .sound("telegraph")
        .build();

    // 使用同步客户端发送
    let sync_client = SyncBarkClient::new("https://api.day.app");
    let sync_response = sync_client.send(&shared_message)?;
    println!("✅ 同步发送成功: {}", sync_response.message);

    // 如果启用了异步功能，演示异步发送
    #[cfg(feature = "async")]
    {
        println!("🔄 也可以在异步环境中使用...");
        let rt = tokio::runtime::Runtime::new()?;
        rt.block_on(async {
            let async_client = AsyncBarkClient::new("https://api.day.app");
            match async_client.send(&shared_message).await {
                Ok(response) => println!("✅ 异步发送成功: {}", response.message),
                Err(e) => println!("❌ 异步发送失败: {}", e),
            }
        });
    }

    #[cfg(not(feature = "async"))]
    {
        println!("ℹ️  如需异步功能，请启用 'async' feature");
    }

    // 演示消息复用
    let another_client = SyncBarkClient::with_device_key("https://api.day.app", "default_key");

    // 克隆消息并修改部分内容
    let modified_message = BarkMessage::builder()
        .title("修改后的消息")
        .body("基于原消息修改的新消息")
        .level(shared_message.level.clone().unwrap_or(Level::Active))
        .sound(
            &shared_message
                .sound
                .clone()
                .unwrap_or_else(|| "default".to_string()),
        )
        .badge(5)
        .build();

    let response = another_client.send(&modified_message)?;
    println!("✅ 修改消息发送成功: {}", response.message);

    println!("🎉 混合使用演示完成！");

    Ok(())
}

pub fn with_device_key(base_url: &str, device_key: &str) -> Self

创建带有默认设备密钥的同步 Bark 客户端

创建一个具有默认设备密钥的客户端实例。如果消息中没有指定设备密钥， 将使用这里设置的默认密钥。消息中的密钥设置会覆盖默认密钥。

参数

• base_url - Bark 服务器的基础 URL
• device_key - 默认的设备密钥

示例

use bark_rs::SyncBarkClient;

let client = SyncBarkClient::with_device_key(
    "https://api.day.app",
    "your_device_key"
);

Examples found in repository

examples/sync_client.rs (line 5)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建同步客户端（带默认设备密钥）
    let client = SyncBarkClient::with_device_key("https://api.day.app", "QJ48vPutCAsPW2B6pE2A3a");

    // 方式1: 使用客户端的链式调用
    let response = client
        .message()
        .title("同步推送")
        .body("这是同步客户端发送的消息")
        .level(Level::Active)
        .volume(7)
        .send()?;

    println!(
        "同步推送成功: code={}, message={}",
        response.code, response.message
    );

    // 方式2: 先构建消息，再发送
    let message = BarkMessage::builder()
        .title("独立构建的消息")
        .body("消息构建与发送分离")
        .level(Level::Critical)
        .sound("alarm")
        .badge(1)
        .build();

    let response = client.send(&message)?;
    println!(
        "独立消息发送成功: code={}, message={}",
        response.code, response.message
    );

    Ok(())
}

examples/message_builder.rs (line 44)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 演示消息构建的各种方式
    println!("🛠️  演示消息构建功能");

    // 方式1: 使用 BarkMessage::builder()
    let message1 = BarkMessage::builder()
        .title("Builder 模式")
        .body("使用 BarkMessage::builder() 构建")
        .level(Level::Active)
        .sound("minuet")
        .build();

    // 方式2: 使用 BarkMessage::new()
    let message2 = BarkMessage::new()
        .title("New 方法")
        .body("使用 BarkMessage::new() 构建")
        .level(Level::TimeSensitive)
        .volume(6)
        .build();

    // 方式3: 完整参数演示
    let complete_message = BarkMessage::builder()
        .title("完整参数演示")
        .subtitle("副标题")
        .body("这是一个包含所有参数的消息")
        .level(Level::Critical)
        .volume(8)
        .badge(3)
        .call(true)
        .auto_copy(false)
        .copy("自定义复制内容")
        .sound("alarm")
        .icon("https://example.com/icon.png")
        .group("演示组")
        .is_archive(true)
        .url("https://example.com")
        .action("none")
        .id("demo_message_001")
        .build();

    // 创建同步客户端来发送这些消息
    let client = SyncBarkClient::with_device_key("https://api.day.app", "QJ48vPutCAsPW2B6pE2A3a");

    println!("📤 发送消息1...");
    let response1 = client.send(&message1)?;
    println!("✅ 消息1发送成功: {}", response1.message);

    println!("📤 发送消息2...");
    let response2 = client.send(&message2)?;
    println!("✅ 消息2发送成功: {}", response2.message);

    println!("📤 发送完整消息...");
    let response3 = client.send(&complete_message)?;
    println!("✅ 完整消息发送成功: {}", response3.message);

    println!("🎉 所有消息发送完成！");

    Ok(())
}

examples/mixed_usage.rs (line 43)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔀 演示混合使用场景");

    // 创建一个消息，可以被不同的客户端使用
    let shared_message = BarkMessage::builder()
        .device_key("QJ48vPutCAsPW2B6pE2A3a")
        .title("共享消息")
        .body("这个消息可以被同步和异步客户端共用")
        .level(Level::Active)
        .sound("telegraph")
        .build();

    // 使用同步客户端发送
    let sync_client = SyncBarkClient::new("https://api.day.app");
    let sync_response = sync_client.send(&shared_message)?;
    println!("✅ 同步发送成功: {}", sync_response.message);

    // 如果启用了异步功能，演示异步发送
    #[cfg(feature = "async")]
    {
        println!("🔄 也可以在异步环境中使用...");
        let rt = tokio::runtime::Runtime::new()?;
        rt.block_on(async {
            let async_client = AsyncBarkClient::new("https://api.day.app");
            match async_client.send(&shared_message).await {
                Ok(response) => println!("✅ 异步发送成功: {}", response.message),
                Err(e) => println!("❌ 异步发送失败: {}", e),
            }
        });
    }

    #[cfg(not(feature = "async"))]
    {
        println!("ℹ️  如需异步功能，请启用 'async' feature");
    }

    // 演示消息复用
    let another_client = SyncBarkClient::with_device_key("https://api.day.app", "default_key");

    // 克隆消息并修改部分内容
    let modified_message = BarkMessage::builder()
        .title("修改后的消息")
        .body("基于原消息修改的新消息")
        .level(shared_message.level.clone().unwrap_or(Level::Active))
        .sound(
            &shared_message
                .sound
                .clone()
                .unwrap_or_else(|| "default".to_string()),
        )
        .badge(5)
        .build();

    let response = another_client.send(&modified_message)?;
    println!("✅ 修改消息发送成功: {}", response.message);

    println!("🎉 混合使用演示完成！");

    Ok(())
}

pub fn message(&self) -> SyncBarkMessageBuilder<'_>

创建消息构建器

返回一个与此客户端关联的消息构建器，支持链式调用来构建和发送消息。

返回值

返回 SyncBarkMessageBuilder 实例

示例

use bark_rs::{SyncBarkClient, Level};

let client = SyncBarkClient::with_device_key("https://api.day.app", "key");

let response = client
    .message()
    .title("标题")
    .body("内容")
    .level(Level::Active)
    .send()?;

Examples found in repository

examples/batch_push.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建同步客户端
    let client = SyncBarkClient::new("https://api.day.app");

    // 批量推送到多个设备
    let response = client
        .message()
        .device_keys(vec![
            "QJ48vPutCAsPW2B6pE2A3a".to_string(),
            "device_key_2".to_string(),
            "device_key_3".to_string(),
        ])
        .title("批量推送通知")
        .body("这是一个发送给多个设备的批量消息")
        .level(Level::TimeSensitive)
        .volume(7)
        .badge(1)
        .group("批量通知")
        .send()?;

    println!(
        "批量推送成功: code={}, message={}",
        response.code, response.message
    );

    Ok(())
}

examples/sync_client.rs (line 9)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建同步客户端（带默认设备密钥）
    let client = SyncBarkClient::with_device_key("https://api.day.app", "QJ48vPutCAsPW2B6pE2A3a");

    // 方式1: 使用客户端的链式调用
    let response = client
        .message()
        .title("同步推送")
        .body("这是同步客户端发送的消息")
        .level(Level::Active)
        .volume(7)
        .send()?;

    println!(
        "同步推送成功: code={}, message={}",
        response.code, response.message
    );

    // 方式2: 先构建消息，再发送
    let message = BarkMessage::builder()
        .title("独立构建的消息")
        .body("消息构建与发送分离")
        .level(Level::Critical)
        .sound("alarm")
        .badge(1)
        .build();

    let response = client.send(&message)?;
    println!(
        "独立消息发送成功: code={}, message={}",
        response.code, response.message
    );

    Ok(())
}

examples/error_handling.rs (line 25)

fn main() {
    println!("🚨 演示错误处理");

    // 创建没有默认设备密钥的客户端
    let client = SyncBarkClient::new("https://api.day.app");

    // 尝试发送没有设备密钥的消息
    let message_without_key = BarkMessage::builder()
        .title("错误演示")
        .body("这个消息没有设备密钥")
        .build();

    match client.send(&message_without_key) {
        Ok(_) => println!("❌ 意外成功"),
        Err(BarkError::MissingDeviceKey) => {
            println!("✅ 正确捕获到缺少设备密钥错误");
        }
        Err(e) => println!("❓ 其他错误: {}", e),
    }

    // 演示正确的错误处理模式
    let result = client
        .message()
        .device_key("QJ48vPutCAsPW2B6pE2A3a")
        .title("正确的消息")
        .body("这个消息有设备密钥")
        .send();

    match result {
        Ok(response) => {
            println!(
                "✅ 消息发送成功: code={}, message={}",
                response.code, response.message
            );
        }
        Err(BarkError::RequestError(e)) => {
            println!("❌ 网络请求错误: {}", e);
        }
        Err(BarkError::MissingDeviceKey) => {
            println!("❌ 缺少设备密钥");
        }
        Err(BarkError::SerializationError(e)) => {
            println!("❌ 序列化错误: {}", e);
        }
        Err(BarkError::InvalidUrl) => {
            println!("❌ 无效URL");
        }
    }

    println!("🎉 错误处理演示完成！");
}

pub fn send(&self, message: &BarkMessage) -> Result<BarkResponse>

发送 Bark 推送消息

根据消息是否包含多个设备密钥自动选择单个发送或批量发送。 如果消息和客户端都没有设备密钥，将返回错误。

参数

• message - 要发送的消息

返回值

成功时返回 BarkResponse，失败时返回 BarkError

错误

• BarkError::MissingDeviceKey - 缺少设备密钥
• BarkError::RequestError - 网络请求错误
• BarkError::SerializationError - 序列化错误

示例

use bark_rs::{SyncBarkClient, BarkMessage};

let client = SyncBarkClient::with_device_key("https://api.day.app", "key");
let message = BarkMessage::builder()
    .body("测试消息")
    .build();

let response = client.send(&message)?;
println!("发送成功: {}", response.message);

Examples found in repository

examples/sync_client.rs (line 30)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 创建同步客户端（带默认设备密钥）
    let client = SyncBarkClient::with_device_key("https://api.day.app", "QJ48vPutCAsPW2B6pE2A3a");

    // 方式1: 使用客户端的链式调用
    let response = client
        .message()
        .title("同步推送")
        .body("这是同步客户端发送的消息")
        .level(Level::Active)
        .volume(7)
        .send()?;

    println!(
        "同步推送成功: code={}, message={}",
        response.code, response.message
    );

    // 方式2: 先构建消息，再发送
    let message = BarkMessage::builder()
        .title("独立构建的消息")
        .body("消息构建与发送分离")
        .level(Level::Critical)
        .sound("alarm")
        .badge(1)
        .build();

    let response = client.send(&message)?;
    println!(
        "独立消息发送成功: code={}, message={}",
        response.code, response.message
    );

    Ok(())
}

examples/error_handling.rs (line 15)

fn main() {
    println!("🚨 演示错误处理");

    // 创建没有默认设备密钥的客户端
    let client = SyncBarkClient::new("https://api.day.app");

    // 尝试发送没有设备密钥的消息
    let message_without_key = BarkMessage::builder()
        .title("错误演示")
        .body("这个消息没有设备密钥")
        .build();

    match client.send(&message_without_key) {
        Ok(_) => println!("❌ 意外成功"),
        Err(BarkError::MissingDeviceKey) => {
            println!("✅ 正确捕获到缺少设备密钥错误");
        }
        Err(e) => println!("❓ 其他错误: {}", e),
    }

    // 演示正确的错误处理模式
    let result = client
        .message()
        .device_key("QJ48vPutCAsPW2B6pE2A3a")
        .title("正确的消息")
        .body("这个消息有设备密钥")
        .send();

    match result {
        Ok(response) => {
            println!(
                "✅ 消息发送成功: code={}, message={}",
                response.code, response.message
            );
        }
        Err(BarkError::RequestError(e)) => {
            println!("❌ 网络请求错误: {}", e);
        }
        Err(BarkError::MissingDeviceKey) => {
            println!("❌ 缺少设备密钥");
        }
        Err(BarkError::SerializationError(e)) => {
            println!("❌ 序列化错误: {}", e);
        }
        Err(BarkError::InvalidUrl) => {
            println!("❌ 无效URL");
        }
    }

    println!("🎉 错误处理演示完成！");
}

examples/message_builder.rs (line 47)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // 演示消息构建的各种方式
    println!("🛠️  演示消息构建功能");

    // 方式1: 使用 BarkMessage::builder()
    let message1 = BarkMessage::builder()
        .title("Builder 模式")
        .body("使用 BarkMessage::builder() 构建")
        .level(Level::Active)
        .sound("minuet")
        .build();

    // 方式2: 使用 BarkMessage::new()
    let message2 = BarkMessage::new()
        .title("New 方法")
        .body("使用 BarkMessage::new() 构建")
        .level(Level::TimeSensitive)
        .volume(6)
        .build();

    // 方式3: 完整参数演示
    let complete_message = BarkMessage::builder()
        .title("完整参数演示")
        .subtitle("副标题")
        .body("这是一个包含所有参数的消息")
        .level(Level::Critical)
        .volume(8)
        .badge(3)
        .call(true)
        .auto_copy(false)
        .copy("自定义复制内容")
        .sound("alarm")
        .icon("https://example.com/icon.png")
        .group("演示组")
        .is_archive(true)
        .url("https://example.com")
        .action("none")
        .id("demo_message_001")
        .build();

    // 创建同步客户端来发送这些消息
    let client = SyncBarkClient::with_device_key("https://api.day.app", "QJ48vPutCAsPW2B6pE2A3a");

    println!("📤 发送消息1...");
    let response1 = client.send(&message1)?;
    println!("✅ 消息1发送成功: {}", response1.message);

    println!("📤 发送消息2...");
    let response2 = client.send(&message2)?;
    println!("✅ 消息2发送成功: {}", response2.message);

    println!("📤 发送完整消息...");
    let response3 = client.send(&complete_message)?;
    println!("✅ 完整消息发送成功: {}", response3.message);

    println!("🎉 所有消息发送完成！");

    Ok(())
}

examples/mixed_usage.rs (line 20)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("🔀 演示混合使用场景");

    // 创建一个消息，可以被不同的客户端使用
    let shared_message = BarkMessage::builder()
        .device_key("QJ48vPutCAsPW2B6pE2A3a")
        .title("共享消息")
        .body("这个消息可以被同步和异步客户端共用")
        .level(Level::Active)
        .sound("telegraph")
        .build();

    // 使用同步客户端发送
    let sync_client = SyncBarkClient::new("https://api.day.app");
    let sync_response = sync_client.send(&shared_message)?;
    println!("✅ 同步发送成功: {}", sync_response.message);

    // 如果启用了异步功能，演示异步发送
    #[cfg(feature = "async")]
    {
        println!("🔄 也可以在异步环境中使用...");
        let rt = tokio::runtime::Runtime::new()?;
        rt.block_on(async {
            let async_client = AsyncBarkClient::new("https://api.day.app");
            match async_client.send(&shared_message).await {
                Ok(response) => println!("✅ 异步发送成功: {}", response.message),
                Err(e) => println!("❌ 异步发送失败: {}", e),
            }
        });
    }

    #[cfg(not(feature = "async"))]
    {
        println!("ℹ️  如需异步功能，请启用 'async' feature");
    }

    // 演示消息复用
    let another_client = SyncBarkClient::with_device_key("https://api.day.app", "default_key");

    // 克隆消息并修改部分内容
    let modified_message = BarkMessage::builder()
        .title("修改后的消息")
        .body("基于原消息修改的新消息")
        .level(shared_message.level.clone().unwrap_or(Level::Active))
        .sound(
            &shared_message
                .sound
                .clone()
                .unwrap_or_else(|| "default".to_string()),
        )
        .badge(5)
        .build();

    let response = another_client.send(&modified_message)?;
    println!("✅ 修改消息发送成功: {}", response.message);

    println!("🎉 混合使用演示完成！");

    Ok(())
}