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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

//! User-centric media storage and recording APIs.
use crate::Client;
use crate::types::UserId;
use crate::utils::ToTT;
use teamtalk_sys as ffi;

/// Configuration for per-user media recording.
#[derive(Clone, Debug)]
pub struct UserRecordingOptions {
    pub folder: String,
    pub file_vars: String,
    pub format: ffi::AudioFileFormat,
    pub stop_delay_ms: i32,
}

impl UserRecordingOptions {
    pub fn new(
        folder: impl Into<String>,
        file_vars: impl Into<String>,
        format: ffi::AudioFileFormat,
    ) -> Self {
        Self {
            folder: folder.into(),
            file_vars: file_vars.into(),
            format,
            stop_delay_ms: 0,
        }
    }

    pub fn with_stop_delay(mut self, delay_ms: i32) -> Self {
        self.stop_delay_ms = delay_ms;
        self
    }
}

/// Guard that manages per-user recording configuration.
pub struct UserRecordingSession<'a> {
    client: &'a Client,
    user_id: UserId,
    active: bool,
}

impl Client {
    /// Configures per-user media recording.
    pub fn set_user_media_storage(
        &self,
        user_id: UserId,
        folder: &str,
        file_vars: &str,
        format: ffi::AudioFileFormat,
    ) -> bool {
        unsafe {
            ffi::api().TT_SetUserMediaStorageDir(
                self.ptr.0,
                user_id.0,
                folder.tt().as_ptr(),
                file_vars.tt().as_ptr(),
                format,
            ) == 1
        }
    }

    /// Configures per-user media recording with a stop delay.
    pub fn set_user_media_storage_ex(
        &self,
        user_id: UserId,
        folder: &str,
        file_vars: &str,
        format: ffi::AudioFileFormat,
        stop_delay_ms: i32,
    ) -> bool {
        unsafe {
            ffi::api().TT_SetUserMediaStorageDirEx(
                self.ptr.0,
                user_id.0,
                folder.tt().as_ptr(),
                file_vars.tt().as_ptr(),
                format,
                stop_delay_ms,
            ) == 1
        }
    }

    /// Disables per-user media recording.
    pub fn clear_user_media_storage(&self, user_id: UserId) -> bool {
        self.set_user_media_storage_ex(user_id, "", "", ffi::AudioFileFormat::AFF_NONE, 0)
    }
}

impl<'a> UserRecordingSession<'a> {
    pub fn start(
        client: &'a Client,
        user_id: UserId,
        options: UserRecordingOptions,
    ) -> Option<Self> {
        let ok = client.set_user_media_storage_ex(
            user_id,
            &options.folder,
            &options.file_vars,
            options.format,
            options.stop_delay_ms,
        );
        if ok {
            Some(Self {
                client,
                user_id,
                active: true,
            })
        } else {
            None
        }
    }

    pub fn stop(mut self) -> bool {
        let ok = self.client.clear_user_media_storage(self.user_id);
        self.active = false;
        ok
    }
}

impl Drop for UserRecordingSession<'_> {
    fn drop(&mut self) {
        if self.active {
            let _ = self.client.clear_user_media_storage(self.user_id);
        }
    }
}