Sync

src/calls/call_util.rs

@@ -0,0 +1,151 @@
+use livekit_api::{
+    access_token::{self},
+    services::room::RoomClient,
+};
+use livekit_protocol::Room;
+use std::env;
+use std::str::FromStr;
+use std::time::Duration;
+use uuid::Uuid;
+
+use crate::{calls::call_manager::CALL_GROUPS, log, log_err, util::logger::PrintType};
+
+pub fn get_livekit() -> Result<(String, String, String), ()> {
+    let hostname = match env::var("LIVEKI_HOSTNAME") {
+        Ok(secret) => secret,
+        Err(_) => {
+            log_err!(0, PrintType::General, "LIVEKI_HOSTNAME not set!");
+            return Err(());
+        }
+    };
+    let api_key = match env::var("LIVEKIT_API_KEY") {
+        Ok(key) => key,
+        Err(_) => {
+            log_err!(0, PrintType::General, "LIVEKIT_API_KEY not set!");
+            return Err(());
+        }
+    };
+    let api_secret = match env::var("LIVEKIT_API_SECRET") {
+        Ok(secret) => secret,
+        Err(_) => {
+            log_err!(0, PrintType::General, "LIVEKIT_API_SECRET not set!");
+            return Err(());
+        }
+    };
+    Ok((hostname, api_key, api_secret))
+}
+
+pub fn create_token(user_id: u64, call_id: Uuid, has_admin: bool) -> Result<String, ()> {
+    let (_, api_key, api_secret) = get_livekit()?;
+
+    let token = access_token::AccessToken::with_api_key(&api_key, &api_secret)
+        .with_identity(&user_id.to_string())
+        .with_grants(access_token::VideoGrants {
+            room_join: true,
+            room_admin: has_admin,
+            room: call_id.to_string(),
+            ..Default::default()
+        })
+        .with_metadata(&format!("{{\"isAdmin\":{}}}", has_admin))
+        .to_jwt();
+    if let Ok(token) = token {
+        Ok(token)
+    } else {
+        Err(())
+    }
+}
+#[allow(dead_code)]
+pub async fn get_room(call_id: Uuid) -> Result<(RoomClient, Room), ()> {
+    if let Ok((hostname, api_key, api_secret)) = get_livekit() {
+        let room_service = RoomClient::with_api_key(&hostname, &api_key, &api_secret);
+        let rooms = room_service.list_rooms(Vec::new()).await;
+        if let Ok(rooms) = rooms {
+            for room in rooms {
+                if room.name == call_id.to_string() {
+                    return Ok((room_service, room));
+                }
+            }
+        }
+    }
+    return Err(());
+}
+
+pub async fn remove_participant(call_id: Uuid, user_id: u64) -> Result<(), ()> {
+    if let Ok((hostname, api_key, api_secret)) = get_livekit() {
+        let room_service = RoomClient::with_api_key(&hostname, &api_key, &api_secret);
+        if let Ok(_) = room_service
+            .remove_participant(&call_id.to_string(), &user_id.to_string())
+            .await
+        {
+            return Ok(());
+        }
+    }
+    return Err(());
+}
+
+#[allow(dead_code)]
+pub async fn get_room_metadata(call_id: Uuid) -> Result<String, ()> {
+    if let Ok((_, room)) = get_room(call_id).await {
+        Ok(room.metadata)
+    } else {
+        Err(())
+    }
+}
+
+pub async fn set_room_metadata(call_id: Uuid, metadata: String) -> Result<(), ()> {
+    if let Ok((hostname, api_key, api_secret)) = get_livekit() {
+        let room_service = RoomClient::with_api_key(&hostname, &api_key, &api_secret);
+        if let Ok(_) = room_service
+            .update_room_metadata(&call_id.to_string(), &metadata)
+            .await
+        {
+            return Ok(());
+        }
+    }
+    return Err(());
+}
+
+pub fn garbage_collect_calls() {
+    tokio::spawn(async move {
+        loop {
+            if let Ok((hostname, api_key, api_secret)) = get_livekit() {
+                let room_service = RoomClient::with_api_key(&hostname, &api_key, &api_secret);
+                clean_calls(room_service).await;
+            }
+            tokio::time::sleep(Duration::from_secs(2)).await;
+        }
+    });
+}
+pub async fn clean_calls(room_service: RoomClient) {
+    let rooms = room_service.list_rooms(Vec::new()).await.unwrap();
+    let mut call_ids: Vec<Uuid> = Vec::new();
+    let mut no_users: Vec<Uuid> = Vec::new();
+    for room in rooms {
+        if let Ok(id) = Uuid::from_str(&room.name) {
+            if room.num_participants == 0 {
+                no_users.push(id);
+            }
+            call_ids.push(id);
+        }
+    }
+    let size_pre = CALL_GROUPS.len();
+    for (id, _) in CALL_GROUPS.clone().into_iter() {
+        if !call_ids.contains(&id) {
+            CALL_GROUPS.remove(&id);
+        }
+    }
+    for (_, cg) in CALL_GROUPS.clone().into_iter() {
+        *cg.show.write().await = !no_users.contains(&cg.call_id);
+    }
+
+    let size_post = CALL_GROUPS.len();
+    if size_pre - size_post != 0 {
+        log!(
+            0,
+            PrintType::Call,
+            "Cleaned {} calls, {} remaining",
+            size_pre - size_post,
+            size_post
+        );
+    }
+}