Skip to main content

active_call/
event.rs

1use crate::media::PcmBuf;
2use serde::{Deserialize, Serialize};
3use serde_with::skip_serializing_none;
4use std::{collections::HashMap, fmt::Display};
5
6#[derive(Debug, Clone, Serialize, Deserialize)]
7#[serde(rename_all = "camelCase")]
8pub struct Attendee {
9    pub username: String,
10    pub realm: String,
11    pub source: String,
12}
13
14impl From<&String> for Attendee {
15    fn from(source: &String) -> Self {
16        let uri = rsipstack::rsip::Uri::try_from(source.as_str()).unwrap_or_default();
17        Self {
18            username: uri.user().unwrap_or_default().to_string(),
19            realm: uri.host().to_string(),
20            source: source.to_string(),
21        }
22    }
23}
24
25#[skip_serializing_none]
26#[derive(Debug, Clone, Serialize, Deserialize)]
27#[serde(
28    tag = "event",
29    rename_all = "camelCase",
30    rename_all_fields = "camelCase"
31)]
32pub enum SessionEvent {
33    Incoming {
34        track_id: String,
35        timestamp: u64,
36        caller: String,
37        callee: String,
38        sdp: String,
39        headers: Option<HashMap<String, String>>,
40    },
41    Answer {
42        track_id: String,
43        timestamp: u64,
44        sdp: String,
45        refer: Option<bool>,
46    },
47    MediaReady {
48        track_id: String,
49        timestamp: u64,
50    },
51    Reject {
52        track_id: String,
53        timestamp: u64,
54        reason: String,
55        refer: Option<bool>,
56        code: Option<u32>,
57    },
58    Ringing {
59        track_id: String,
60        timestamp: u64,
61        early_media: bool,
62        refer: Option<bool>,
63    },
64    Hangup {
65        track_id: String,
66        timestamp: u64,
67        reason: Option<String>,
68        initiator: Option<String>,
69        start_time: String,
70        hangup_time: String,
71        answer_time: Option<String>,
72        ringing_time: Option<String>,
73        from: Option<Attendee>,
74        to: Option<Attendee>,
75        extra: Option<HashMap<String, serde_json::Value>>,
76        refer: Option<bool>,
77    },
78    AnswerMachineDetection {
79        // Answer machine detection
80        track_id: String,
81        timestamp: u64,
82        start_time: u64,
83        end_time: u64,
84        text: String,
85    },
86    Interrupt {
87        receiver: Option<String>,
88    },
89    FunctionCall {
90        track_id: String,
91        call_id: String,
92        name: String,
93        arguments: String,
94        timestamp: u64,
95    },
96    Speaking {
97        track_id: String,
98        timestamp: u64,
99        start_time: u64,
100        is_filler: Option<bool>,
101        confidence: Option<f32>,
102        refer: Option<bool>,
103    },
104    Silence {
105        track_id: String,
106        timestamp: u64,
107        start_time: u64,
108        duration: u64,
109        refer: Option<bool>,
110        #[serde(skip)]
111        samples: Option<PcmBuf>,
112    },
113    ///End of Utterance
114    Eou {
115        track_id: String,
116        timestamp: u64,
117        completed: bool,
118        interrupt_point: Option<String>,
119        text: Option<String>,
120        refer: Option<bool>,
121    },
122    /// Incoming RTC media stopped; informational only, never hangs up the call.
123    RtpTimeout {
124        track_id: String,
125        timestamp: u64,
126        /// Configured timeout in seconds.
127        timeout: u64,
128    },
129    ///Inactivity timeout
130    Inactivity {
131        track_id: String,
132        timestamp: u64,
133    },
134    Dtmf {
135        track_id: String,
136        timestamp: u64,
137        digit: String,
138        refer: Option<bool>,
139    },
140    Hold {
141        track_id: String,
142        timestamp: u64,
143        on_hold: bool,
144        refer: Option<bool>,
145    },
146    TransferRequest {
147        track_id: String,
148        timestamp: u64,
149        refer_to: String,
150        referred_by: Option<String>,
151        refer: Option<bool>,
152        /// Custom (`Header::Other`) headers received on the REFER, blindly
153        /// forwarded onto the transfer INVITE (e.g. `User-to-User`,
154        /// `X-ACC-Bizdata`, `X-AliyunIVR-*`). Protocol headers (Via, Route,
155        /// Call-ID, ...) are typed and never included.
156        #[serde(default, skip_serializing_if = "Option::is_none")]
157        extra_headers: Option<HashMap<String, String>>,
158        /// Session id of the leg that received the REFER (the ref call id
159        /// for refer bridge legs). Lets the actor tell the current
160        /// INVITE-mode bridge leg apart from other refer legs.
161        #[serde(default, skip_serializing_if = "Option::is_none")]
162        leg_session_id: Option<String>,
163        /// RFC 3515 implicit-subscription notifier for the REFER's parent
164        /// dialog; used to report transfer progress back to the referrer.
165        #[serde(skip)]
166        notify: Option<std::sync::Arc<crate::call::sip::ReferProgressNotifier>>,
167    },
168    Message {
169        track_id: String,
170        timestamp: u64,
171        body: String,
172        content_type: Option<String>,
173        refer: Option<bool>,
174    },
175    TrackStart {
176        track_id: String,
177        timestamp: u64,
178        play_id: Option<String>,
179    },
180    TrackEnd {
181        track_id: String,
182        timestamp: u64,
183        duration: u64,
184        ssrc: u32,
185        play_id: Option<String>,
186        /// Hangup intent carried by the track itself; when set, the call
187        /// should hang up with this reason once the track ends.
188        auto_hangup: Option<crate::callrecord::CallRecordHangupReason>,
189    },
190    Interruption {
191        track_id: String,
192        timestamp: u64,
193        play_id: Option<String>,
194        subtitle: Option<String>, // current tts text
195        position: Option<u32>,    // word index in subtitle
196        total_duration: u32,      // whole tts duration
197        current: u32,             // elapsed time since start of tts
198    },
199    AsrFinal {
200        track_id: String,
201        timestamp: u64,
202        index: u32,
203        start_time: Option<u64>,
204        end_time: Option<u64>,
205        text: String,
206        is_filler: Option<bool>,
207        confidence: Option<f32>,
208        task_id: Option<String>,
209        refer: Option<bool>,
210    },
211    AsrDelta {
212        track_id: String,
213        index: u32,
214        timestamp: u64,
215        start_time: Option<u64>,
216        end_time: Option<u64>,
217        text: String,
218        is_filler: Option<bool>,
219        confidence: Option<f32>,
220        task_id: Option<String>,
221        refer: Option<bool>,
222    },
223    Metrics {
224        timestamp: u64,
225        key: String,
226        duration: u32,
227        data: serde_json::Value,
228    },
229    Error {
230        track_id: String,
231        timestamp: u64,
232        sender: String,
233        error: String,
234        code: Option<u32>,
235    },
236    AddHistory {
237        sender: Option<String>,
238        timestamp: u64,
239        speaker: String,
240        text: String,
241    },
242    Other {
243        track_id: String,
244        timestamp: u64,
245        sender: String,
246        extra: Option<HashMap<String, String>>,
247    },
248    Binary {
249        track_id: String,
250        timestamp: u64,
251        data: Vec<u8>,
252    },
253    Ping {
254        timestamp: u64,
255        payload: Option<String>,
256    },
257    Custom {
258        timestamp: u64,
259        sender: Option<String>,
260        data: serde_json::Value,
261    },
262    RingbackState {
263        track_id: String,
264        timestamp: u64,
265        /// Current line state: "ringing", "human_voice", "busy_tone", "silence", etc.
266        state: String,
267        /// Class index from the TelcoClassifier (3=ringing, 9=human_voice, ...)
268        state_index: u32,
269        /// Confidence of the prediction
270        confidence: f32,
271        /// Previous state (None on first detection)
272        prev_state: Option<String>,
273        prev_confidence: Option<f32>,
274        refer: Option<bool>,
275        /// Whether this is the final determination
276        #[serde(default)]
277        is_final: bool,
278    },
279}
280
281impl Display for SessionEvent {
282    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
283        match self {
284            SessionEvent::Silence {
285                track_id, duration, ..
286            } => {
287                write!(f, "Silence(track_id={}, duration={})", track_id, duration)
288            }
289            SessionEvent::Binary { track_id, data, .. } => {
290                write!(f, "Silence(track_id={}, data_len={})", track_id, data.len())
291            }
292            _ => {
293                write!(f, "{:?}", self)
294            }
295        }
296    }
297}
298
299pub type EventSender = tokio::sync::broadcast::Sender<SessionEvent>;
300pub type EventReceiver = tokio::sync::broadcast::Receiver<SessionEvent>;
301
302pub fn create_event_sender() -> EventSender {
303    EventSender::new(128)
304}