Struct LiveClient 

pub struct LiveClient<'a> { /* private fields */ }

直播 API 客户端。

Implementations

impl<'a> LiveClient<'a>

pub async fn area_list(&self) -> BpiResult<Vec<LiveParentArea>>

获取全部直播分区分类。

pub async fn room_info(&self, room_id: i64) -> BpiResult<RoomInfoData>

按真实房间 ID 获取公开房间信息。

Examples found in repository

examples/live_room_info.rs (line 25)

async fn main() -> BpiResult<()> {
    let room_id = room_id()?;
    let client = BpiClient::new()?;
    let info = client.live().room_info(room_id).await?;

    println!("直播间: {} ({})", info.title, info.room_id);
    println!("主播 mid: {}", info.uid);
    println!(
        "状态: live_status={} 分区={}·{}",
        info.live_status, info.parent_area_name, info.area_name
    );
    println!("在线: {} 关注: {}", info.online, info.attention);

    Ok(())
}

examples/live_web_start.rs (line 54)

async fn main() -> BpiResult<()> {
    let stop_if_live = std::env::args().any(|a| a == "--stop-if-live");
    let stop_only = std::env::args().any(|a| a == "--stop-only");
    let room_id: i64 = std::env::var("BILI_ROOM_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_ROOM_ID);
    let area_id: u64 = std::env::var("BILI_AREA_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_AREA_ID);

    let bpi = account::authenticated_client()?;

    println!("=== Rust 网页自动开播验证 ===");
    println!("room_id={room_id} area_v2={area_id}");

    let live = bpi.live();
    let info = live.room_info(room_id).await?;
    println!(
        "当前状态: live_status={} title={} area={}·{}",
        info.live_status, info.title, info.parent_area_name, info.area_name
    );

    if !mutating_enabled() {
        println!("{MUTATING_ENV}=1 未设置，只读取直播间状态，不执行开播、关播或获取推流码。");
        return Ok(());
    }

    if stop_only {
        if info.live_status == 1 {
            println!("执行关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(3)).await;
        } else {
            println!("当前未开播，跳过关播接口。");
        }

        let after = live.room_info(room_id).await?;
        println!(
            "验证: live_status={} ({})",
            after.live_status,
            if after.live_status == 0 {
                "关播成功"
            } else {
                "仍在直播中"
            }
        );
        return Ok(());
    }

    if info.live_status == 1 {
        if stop_if_live {
            println!("已在直播，--stop-if-live：先关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        } else {
            println!("已在直播中。若要完整验证开播链路，请加 --stop-if-live 或先手动关播。");
            println!("仍尝试 FetchWebUpStreamAddr（只读）...");
            let stream = live.live_fetch_web_up_stream_addr().await?;
            println!("推流地址: {}{}", stream.addr.addr, mask(&stream.addr.code));
            return Ok(());
        }
    }

    println!("\n[1/2] FetchWebUpStreamAddr...");
    let stream = live.live_fetch_web_up_stream_addr().await?;
    println!("  rtmp: {}{}", stream.addr.addr, mask(&stream.addr.code));

    println!("\n[2/2] WebLiveCenterStartLive (WBI)...");
    let start = live.live_web_center_start(room_id as u64, area_id).await?;
    println!("  status={} live_key={}", start.status, start.live_key);
    if let Some(rtmp) = &start.rtmp {
        println!("  rtmp(响应): {}{}", rtmp.addr, mask(&rtmp.code));
    } else {
        println!("  rtmp(响应): null（正常，推流码以 Fetch 为准）");
    }

    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    let after = live.room_info(room_id).await?;
    println!(
        "\n验证: live_status={} ({})",
        after.live_status,
        if after.live_status == 1 {
            "开播成功"
        } else {
            "未变为直播中（可能需 OBS 推流）"
        }
    );

    Ok(())
}

pub async fn stream( &self, cid: i64, platform: Option<&str>, quality: Option<i32>, qn: Option<i32>, ) -> BpiResult<LiveStreamData>

按真实房间 ID 获取直播流 URL。

pub async fn recommend(&self) -> BpiResult<RecommendData>

获取 Web 首页直播推荐列表。

pub async fn version(&self) -> BpiResult<PcLiveVersionData>

获取当前 PC 直播客户端版本元数据。

pub async fn gift_types(&self) -> BpiResult<Vec<GiftTypeItem>>

获取已登录账号的直播礼物类型列表。

pub async fn room_gift_list( &self, room_id: i64, area_parent_id: Option<i32>, area_id: Option<i32>, ) -> BpiResult<RoomGiftData>

获取直播间礼物面板。

pub async fn blind_gift_info(&self, gift_id: i64) -> BpiResult<BlindGiftData>

获取盲盒礼物概率详情。

pub async fn danmu_info( &self, room_id: u64, info_type: u8, ) -> BpiResult<LiveDanmuInfoData>

获取直播 WebSocket 弹幕 token 和主机信息。

pub async fn emoticons( &self, room_id: i64, platform: &str, ) -> BpiResult<EmoticonData>

获取直播间表情包。

pub async fn lottery_info(&self, room_id: i64) -> BpiResult<LotteryInfoData>

获取直播间抽奖信息。

pub async fn my_medals( &self, page: i32, page_size: i32, ) -> BpiResult<MyMedalsData>

获取当前账号的直播粉丝勋章。

pub async fn follow_up_list( &self, page: Option<i32>, page_size: Option<i32>, ignore_record: Option<i32>, hit_ab: Option<bool>, ) -> BpiResult<FollowUpLiveData>

获取已关注主播及其直播状态。

pub async fn follow_up_web_list( &self, hit_ab: Option<bool>, ) -> BpiResult<LiveWebListData>

获取当前正在直播的已关注主播。

pub async fn replay_list( &self, page: Option<i32>, page_size: Option<i32>, ) -> BpiResult<ReplayListData>

获取当前账号的直播回放列表。

pub async fn guard_list( &self, room_id: i64, ruid: i64, page: Option<i32>, page_size: Option<i32>, typ: Option<i32>, ) -> BpiResult<GuardListData>

获取直播间的大航海成员。

pub async fn silent_users( &self, params: LiveSilentUserListParams, ) -> BpiResult<SilentUserListData>

获取直播间禁言用户。

pub async fn banned_users( &self, params: LiveBannedUserListParams, ) -> BpiResult<BannedUserListData>

获取直播主播的封禁用户。

pub async fn shield_keywords( &self, params: LiveShieldKeywordListParams, ) -> BpiResult<ShieldKeywordListData>

获取直播间屏蔽关键词。

pub async fn web_heart_beat( &self, params: LiveWebHeartBeatParams, ) -> BpiResult<HeartBeatData>

发送用于直播遥测的 Web 心跳。

impl<'a> LiveClient<'a>

pub async fn live_send_danmu( &self, room_id: u64, message: &str, color: Option<u32>, font_size: Option<u32>, ) -> BpiResult<SendDanmuData>

发送直播间弹幕

参数

• room_id - 直播间 ID
• message - 弹幕内容
• color - 十进制颜色值，默认 16777215 (白色)
• font_size - 字体大小，默认 25

impl<'a> LiveClient<'a>

pub async fn live_create_room(&self) -> BpiResult<CreateRoomData>

开通直播间

pub async fn live_update_room_info( &self, room_id: u64, title: Option<&str>, area_id: Option<u64>, add_tag: Option<&str>, del_tag: Option<&str>, ) -> BpiResult<UpdateRoomData>

更新直播间信息

参数

• room_id - 直播间 ID
• title - 标题，可选
• area_id - 分区 ID，可选
• add_tag - 要添加的标签，可选
• del_tag - 要删除的标签，可选

pub async fn live_fetch_web_up_stream_addr( &self, ) -> BpiResult<WebUpStreamAddrData>

获取网页 link 中心推流地址

Examples found in repository

examples/live_web_start.rs (line 97)

async fn main() -> BpiResult<()> {
    let stop_if_live = std::env::args().any(|a| a == "--stop-if-live");
    let stop_only = std::env::args().any(|a| a == "--stop-only");
    let room_id: i64 = std::env::var("BILI_ROOM_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_ROOM_ID);
    let area_id: u64 = std::env::var("BILI_AREA_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_AREA_ID);

    let bpi = account::authenticated_client()?;

    println!("=== Rust 网页自动开播验证 ===");
    println!("room_id={room_id} area_v2={area_id}");

    let live = bpi.live();
    let info = live.room_info(room_id).await?;
    println!(
        "当前状态: live_status={} title={} area={}·{}",
        info.live_status, info.title, info.parent_area_name, info.area_name
    );

    if !mutating_enabled() {
        println!("{MUTATING_ENV}=1 未设置，只读取直播间状态，不执行开播、关播或获取推流码。");
        return Ok(());
    }

    if stop_only {
        if info.live_status == 1 {
            println!("执行关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(3)).await;
        } else {
            println!("当前未开播，跳过关播接口。");
        }

        let after = live.room_info(room_id).await?;
        println!(
            "验证: live_status={} ({})",
            after.live_status,
            if after.live_status == 0 {
                "关播成功"
            } else {
                "仍在直播中"
            }
        );
        return Ok(());
    }

    if info.live_status == 1 {
        if stop_if_live {
            println!("已在直播，--stop-if-live：先关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        } else {
            println!("已在直播中。若要完整验证开播链路，请加 --stop-if-live 或先手动关播。");
            println!("仍尝试 FetchWebUpStreamAddr（只读）...");
            let stream = live.live_fetch_web_up_stream_addr().await?;
            println!("推流地址: {}{}", stream.addr.addr, mask(&stream.addr.code));
            return Ok(());
        }
    }

    println!("\n[1/2] FetchWebUpStreamAddr...");
    let stream = live.live_fetch_web_up_stream_addr().await?;
    println!("  rtmp: {}{}", stream.addr.addr, mask(&stream.addr.code));

    println!("\n[2/2] WebLiveCenterStartLive (WBI)...");
    let start = live.live_web_center_start(room_id as u64, area_id).await?;
    println!("  status={} live_key={}", start.status, start.live_key);
    if let Some(rtmp) = &start.rtmp {
        println!("  rtmp(响应): {}{}", rtmp.addr, mask(&rtmp.code));
    } else {
        println!("  rtmp(响应): null（正常，推流码以 Fetch 为准）");
    }

    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    let after = live.room_info(room_id).await?;
    println!(
        "\n验证: live_status={} ({})",
        after.live_status,
        if after.live_status == 1 {
            "开播成功"
        } else {
            "未变为直播中（可能需 OBS 推流）"
        }
    );

    Ok(())
}

pub async fn live_web_center_start( &self, room_id: u64, area_v2: u64, ) -> BpiResult<StartLiveData>

网页 link 中心开始直播（第三方软件开播，WBI 签名）

Examples found in repository

examples/live_web_start.rs (line 108)

async fn main() -> BpiResult<()> {
    let stop_if_live = std::env::args().any(|a| a == "--stop-if-live");
    let stop_only = std::env::args().any(|a| a == "--stop-only");
    let room_id: i64 = std::env::var("BILI_ROOM_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_ROOM_ID);
    let area_id: u64 = std::env::var("BILI_AREA_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_AREA_ID);

    let bpi = account::authenticated_client()?;

    println!("=== Rust 网页自动开播验证 ===");
    println!("room_id={room_id} area_v2={area_id}");

    let live = bpi.live();
    let info = live.room_info(room_id).await?;
    println!(
        "当前状态: live_status={} title={} area={}·{}",
        info.live_status, info.title, info.parent_area_name, info.area_name
    );

    if !mutating_enabled() {
        println!("{MUTATING_ENV}=1 未设置，只读取直播间状态，不执行开播、关播或获取推流码。");
        return Ok(());
    }

    if stop_only {
        if info.live_status == 1 {
            println!("执行关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(3)).await;
        } else {
            println!("当前未开播，跳过关播接口。");
        }

        let after = live.room_info(room_id).await?;
        println!(
            "验证: live_status={} ({})",
            after.live_status,
            if after.live_status == 0 {
                "关播成功"
            } else {
                "仍在直播中"
            }
        );
        return Ok(());
    }

    if info.live_status == 1 {
        if stop_if_live {
            println!("已在直播，--stop-if-live：先关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        } else {
            println!("已在直播中。若要完整验证开播链路，请加 --stop-if-live 或先手动关播。");
            println!("仍尝试 FetchWebUpStreamAddr（只读）...");
            let stream = live.live_fetch_web_up_stream_addr().await?;
            println!("推流地址: {}{}", stream.addr.addr, mask(&stream.addr.code));
            return Ok(());
        }
    }

    println!("\n[1/2] FetchWebUpStreamAddr...");
    let stream = live.live_fetch_web_up_stream_addr().await?;
    println!("  rtmp: {}{}", stream.addr.addr, mask(&stream.addr.code));

    println!("\n[2/2] WebLiveCenterStartLive (WBI)...");
    let start = live.live_web_center_start(room_id as u64, area_id).await?;
    println!("  status={} live_key={}", start.status, start.live_key);
    if let Some(rtmp) = &start.rtmp {
        println!("  rtmp(响应): {}{}", rtmp.addr, mask(&rtmp.code));
    } else {
        println!("  rtmp(响应): null（正常，推流码以 Fetch 为准）");
    }

    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    let after = live.room_info(room_id).await?;
    println!(
        "\n验证: live_status={} ({})",
        after.live_status,
        if after.live_status == 1 {
            "开播成功"
        } else {
            "未变为直播中（可能需 OBS 推流）"
        }
    );

    Ok(())
}

pub async fn live_stop( &self, room_id: u64, platform: &str, ) -> BpiResult<StopLiveData>

关闭直播

参数

• room_id - 直播间 ID
• platform - 直播平台，如 “pc_link”

Examples found in repository

examples/live_web_start.rs (line 68)

async fn main() -> BpiResult<()> {
    let stop_if_live = std::env::args().any(|a| a == "--stop-if-live");
    let stop_only = std::env::args().any(|a| a == "--stop-only");
    let room_id: i64 = std::env::var("BILI_ROOM_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_ROOM_ID);
    let area_id: u64 = std::env::var("BILI_AREA_ID")
        .ok()
        .and_then(|s| s.parse().ok())
        .unwrap_or(DEFAULT_AREA_ID);

    let bpi = account::authenticated_client()?;

    println!("=== Rust 网页自动开播验证 ===");
    println!("room_id={room_id} area_v2={area_id}");

    let live = bpi.live();
    let info = live.room_info(room_id).await?;
    println!(
        "当前状态: live_status={} title={} area={}·{}",
        info.live_status, info.title, info.parent_area_name, info.area_name
    );

    if !mutating_enabled() {
        println!("{MUTATING_ENV}=1 未设置，只读取直播间状态，不执行开播、关播或获取推流码。");
        return Ok(());
    }

    if stop_only {
        if info.live_status == 1 {
            println!("执行关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(3)).await;
        } else {
            println!("当前未开播，跳过关播接口。");
        }

        let after = live.room_info(room_id).await?;
        println!(
            "验证: live_status={} ({})",
            after.live_status,
            if after.live_status == 0 {
                "关播成功"
            } else {
                "仍在直播中"
            }
        );
        return Ok(());
    }

    if info.live_status == 1 {
        if stop_if_live {
            println!("已在直播，--stop-if-live：先关播...");
            let stop = live.live_stop(room_id as u64, "pc").await?;
            println!("关播结果: status={}", stop.status);
            tokio::time::sleep(std::time::Duration::from_secs(2)).await;
        } else {
            println!("已在直播中。若要完整验证开播链路，请加 --stop-if-live 或先手动关播。");
            println!("仍尝试 FetchWebUpStreamAddr（只读）...");
            let stream = live.live_fetch_web_up_stream_addr().await?;
            println!("推流地址: {}{}", stream.addr.addr, mask(&stream.addr.code));
            return Ok(());
        }
    }

    println!("\n[1/2] FetchWebUpStreamAddr...");
    let stream = live.live_fetch_web_up_stream_addr().await?;
    println!("  rtmp: {}{}", stream.addr.addr, mask(&stream.addr.code));

    println!("\n[2/2] WebLiveCenterStartLive (WBI)...");
    let start = live.live_web_center_start(room_id as u64, area_id).await?;
    println!("  status={} live_key={}", start.status, start.live_key);
    if let Some(rtmp) = &start.rtmp {
        println!("  rtmp(响应): {}{}", rtmp.addr, mask(&rtmp.code));
    } else {
        println!("  rtmp(响应): null（正常，推流码以 Fetch 为准）");
    }

    tokio::time::sleep(std::time::Duration::from_secs(2)).await;
    let after = live.room_info(room_id).await?;
    println!(
        "\n验证: live_status={} ({})",
        after.live_status,
        if after.live_status == 1 {
            "开播成功"
        } else {
            "未变为直播中（可能需 OBS 推流）"
        }
    );

    Ok(())
}

pub async fn live_update_pre_live_info( &self, title: Option<&str>, cover: Option<&str>, ) -> BpiResult<UpdatePreLiveInfoData>

预更新直播间信息

参数

• title - 标题，可选
• cover - 封面 URL，可选

pub async fn live_update_room_news( &self, room_id: u64, uid: u64, content: &str, ) -> BpiResult<Value>

更新直播间公告

参数

• room_id - 直播间 ID
• uid - 用户ID
• content - 公告内容

impl<'a> LiveClient<'a>

pub async fn live_add_silent_user( &self, room_id: i64, tuid: i64, hour: i32, msg: Option<String>, ) -> BpiResult<Option<Value>>

禁言观众 tuid: 用户uid hour: -1永久 0本场直播 msg: 禁言理由，一般为禁言的弹幕，选填

pub async fn live_del_block_user( &self, roomid: i64, tuid: i64, ) -> BpiResult<Option<Value>>

解除禁言

pub async fn live_add_banned_user( &self, room_id: i64, anchor_id: i64, tuid: i64, ) -> BpiResult<Option<Value>>

拉黑观众 anchor_id：主播uid

pub async fn live_del_banned_user( &self, room_id: i64, anchor_id: i64, tuid: i64, ) -> BpiResult<Option<Value>>

解除拉黑 anchor_id：主播uid

pub async fn live_add_shield_keyword( &self, room_id: i64, keyword: String, ) -> BpiResult<Option<Value>>

添加屏蔽词

pub async fn live_del_shield_keyword( &self, room_id: i64, keyword: String, ) -> BpiResult<Option<Value>>

删除屏蔽词

Trait Implementations

impl<'a> Clone for LiveClient<'a>

fn clone(&self) -> LiveClient<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for LiveClient<'a>