teamtalk 6.0.0

TeamTalk SDK for Rust
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

use std::collections::HashMap;
use std::time::{Duration, Instant};

use teamtalk::Event;
use teamtalk::types::{Subscriptions, UserId};

#[derive(Debug, Default)]
struct VoiceState {
    active: bool,
    last_sample_index: Option<u32>,
    last_block_at: Option<Instant>,
}

fn main() -> teamtalk::Result<()> {
    let client = teamtalk::Client::new()?;
    let mut states: HashMap<UserId, VoiceState> = HashMap::new();
    let silence_timeout = Duration::from_millis(800);

    loop {
        if let Some((event, message)) = client.poll(100) {
            match event {
                Event::UserJoined => {
                    if let Some(user) = message.user() {
                        let _ = client.subscribe(
                            user.id,
                            Subscriptions::from_raw(
                                Subscriptions::VOICE | Subscriptions::MEDIAFILE,
                            ),
                        );
                        let _ =
                            client.enable_audio_block_event(user.id, Subscriptions::VOICE, true);
                        states.entry(user.id).or_default();
                    }
                }
                Event::UserLeft => {
                    if let Some(user) = message.user() {
                        let _ =
                            client.enable_audio_block_event(user.id, Subscriptions::VOICE, false);
                        states.remove(&user.id);
                    }
                }
                Event::UserFirstVoiceStreamPacket => {
                    if let Some(user) = message.user() {
                        let state = states.entry(user.id).or_default();
                        if !state.active {
                            state.active = true;
                            println!(
                                "segment start (first packet): user_id={}, stream_id={}",
                                user.id.0,
                                message.source()
                            );
                        }
                    }
                }
                Event::AudioBlock => {
                    if let Some(user) = message.user()
                        && let Some(ptr) =
                            client.acquire_user_audio_block(Subscriptions::VOICE, user.id)
                    {
                        let block = unsafe { &*ptr };
                        let sample_index = block.uSampleIndex;
                        let now = Instant::now();

                        let state = states.entry(user.id).or_default();
                        if !state.active {
                            state.active = true;
                            println!(
                                "segment start (first block): user_id={}, sample_index={sample_index}",
                                user.id.0
                            );
                        } else if let Some(last) = state.last_sample_index
                            && sample_index == 0
                            && last > 0
                        {
                            println!(
                                "segment restart: user_id={}, sample_index={sample_index}",
                                user.id.0
                            );
                        }

                        state.last_sample_index = Some(sample_index);
                        state.last_block_at = Some(now);

                        unsafe {
                            let _ = client.release_user_audio_block(ptr);
                        }
                    }
                }
                Event::ConnectionLost | Event::ConnectFailed => break,
                _ => {}
            }
        }

        let now = Instant::now();
        for (user_id, state) in &mut states {
            if state.active
                && let Some(last) = state.last_block_at
                && now.duration_since(last) >= silence_timeout
            {
                state.active = false;
                state.last_sample_index = None;
                println!("segment end (silence timeout): user_id={}", user_id.0);
            }
        }
    }

    Ok(())
}