bililive 0.1.2

A simple stream-based bilibili live client library.
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

use anyhow::Result;
use futures::StreamExt;
use log::info;
use serde_json::Value;

use bililive::{ConfigBuilder, RetryConfig};

async fn run() -> Result<()> {
    pretty_env_logger::init();

    let config = ConfigBuilder::new()
        .by_uid(1602085)
        .await?
        .fetch_conf()
        .await?
        .build()?;
    info!("room_id: {}", config.room_id());
    info!("uid: {}", config.uid());
    info!("token: {}", config.token());
    info!("servers: {:#?}", config.servers());

    #[cfg(feature = "tokio")]
    let mut stream =
        bililive::connect::tokio::connect_with_retry(config.clone(), RetryConfig::default())
            .await
            .unwrap();
    #[cfg(feature = "async-std")]
    let mut stream =
        bililive::connect::async_std::connect_with_retry(config, RetryConfig::default())
            .await
            .unwrap();

    while let Some(e) = stream.next().await {
        match e {
            Ok(packet) => {
                info!("raw: {:?}", packet);
                if let Ok(json) = packet.json::<Value>() {
                    info!("json: {:?}", json);
                }
            }
            Err(e) => {
                info!("err: {:?}", e);
            }
        }
    }

    Ok(())
}

fn main() -> Result<()> {
    #[cfg(feature = "tokio")]
    {
        let runtime = tokio::runtime::Builder::new_multi_thread()
            .enable_all()
            .build()
            .unwrap();
        return runtime.block_on(run());
    }
    #[cfg(feature = "async-std")]
    return async_std::task::block_on(run());
}