opentalk-roomserver-module-livekit 0.0.28

OpenTalk RoomServer LiveKit signaling module
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

// SPDX-FileCopyrightText: OpenTalk GmbH <mail@opentalk.eu>
//
// SPDX-License-Identifier: EUPL-1.2

use std::{
    collections::{BTreeMap, BTreeSet},
    sync::Arc,
};

use livekit_api::services::room::RoomClient;
use livekit_protocol::TrackSource;
use opentalk_roomserver_types::connection_id::ConnectionId;
use opentalk_roomserver_types_livekit::LiveKitError;
use opentalk_types_signaling::ParticipantId;

use super::{LiveKitLoopback, update_participants_permission};
use crate::build_livekit_participant_id;

pub async fn set_screenshare_permissions(
    livekit_client: Arc<RoomClient>,
    room: String,
    sender: ParticipantId,
    participants: BTreeMap<ParticipantId, BTreeSet<ConnectionId>>,
    grant: bool,
) -> Result<LiveKitLoopback, LiveKitError> {
    let affected_participants =
        affected_participants(&livekit_client, &room, &participants).await?;

    update_participants_permission(
        &livekit_client,
        affected_participants,
        &[
            TrackSource::ScreenShare as i32,
            TrackSource::ScreenShareAudio as i32,
        ],
        grant,
        &room,
    )
    .await;

    Ok(LiveKitLoopback::ScreenSharePermissionsUpdated {
        sender,
        grant,
        participants: participants.keys().copied().collect(),
    })
}

async fn affected_participants(
    livekit_client: &Arc<RoomClient>,
    room: &str,
    participants: &BTreeMap<ParticipantId, BTreeSet<ConnectionId>>,
) -> Result<Vec<livekit_protocol::ParticipantInfo>, LiveKitError> {
    let mut all_participants = livekit_client
        .list_participants(room)
        .await
        .map_err(|err| {
            tracing::error!("failed to query participants, {err}");
            LiveKitError::LivekitUnavailable
        })?;
    let livekit_participant_ids = participants
        .iter()
        .flat_map(|(p_id, c_ids)| {
            c_ids
                .iter()
                .map(|c_id| build_livekit_participant_id(*p_id, *c_id))
        })
        .collect::<BTreeSet<String>>();

    all_participants.retain(|p| livekit_participant_ids.contains(&p.identity));
    Ok(all_participants)
}