Syzygial/New-Alan
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Client VCData (SSRC -> UserID)

Browse Source 
Can use this to store per guild and per channel information

May also store a list of visible users/those that have talked too
while Alan was in the chat
This commit is contained in:
DavidCrompton1192@gmail.com
2023-03-14 18:53:24 -04:00
parent c7558645c2
commit 0daee61d61
1 changed files with 202 additions and 138 deletions
Download Patch File Download Diff File Expand all files Collapse all files

164
src/vc/mod.rs
View File

@@ -1,20 +1,41 @@
use std::{sync::Arc, collections::HashMap};
use std::{collections::HashMap, sync::Arc};
use serenity::{async_trait,
model::{prelude::{ChannelId, Guild}, user::User},
prelude::{Context, Mutex, RwLock, TypeMapKey}, Client};
use songbird::{EventHandler, Event, EventContext,
model::{payload::{Speaking, ClientDisconnect}, id::UserId}, ffmpeg, create_player, Call, CoreEvent, events::context_data::ConnectData};
use serenity::{
async_trait,
model::prelude::{ChannelId, Guild, GuildId},
prelude::{Context, Mutex, RwLock, TypeMapKey}, Client,
};
struct Receiver {
use songbird::{
create_player,
events::context_data::{ConnectData, DisconnectData},
ffmpeg,
model::{
id::UserId,
payload::{ClientDisconnect, Speaking},
},
Call, CoreEvent, Event, EventContext, EventHandler,
};
#[derive(Eq, Hash)]
struct CallLocation {
guild: GuildId,
channel: ChannelId
}
impl PartialEq for CallLocation {
fn eq(&self, other: &Self) -> bool {
self.guild == other.guild && self.channel == other.channel
}
}
struct VoiceData {
call: Arc<Mutex<Call>>,
users: Arc<RwLock<HashMap<u32, Option<UserId>>>>,
}
impl Receiver {
impl VoiceData {
pub fn new(call: Arc<Mutex<Call>>) -> Self {
// You can manage state here, such as a buffer of audio packet bytes so
// you can later store them in intervals.
Self {
call,
users: Arc::new(RwLock::new(HashMap::default()))
@@ -22,26 +43,49 @@ impl Receiver {
}
}
struct VCUser;
struct VCData {
loc: Arc<CallLocation>,
data: Arc<RwLock<VoiceData>>
}
impl TypeMapKey for VCUser {
type Value = Arc<RwLock<HashMap<String, VCUser>>>;
impl TypeMapKey for VCData {
type Value = Arc<RwLock<HashMap<CallLocation, VCData>>>;
}
impl VCData {
pub fn new(loc: CallLocation, data: VoiceData) -> Self {
// You can manage state here, such as a buffer of audio packet bytes so
// you can later store them in intervals.
VCData {
loc: Arc::new(loc),
data: Arc::new(RwLock::new(data))
}
}
pub fn clone(&self) -> Self {
VCData {
loc: self.loc.clone(),
data: self.data.clone()
}
}
}
pub async fn init(client: &Client) {
let mut data = client.data.write().await;
data.insert::<VCUser>(Arc::new(RwLock::new(HashMap::default())));
data.insert::<VCData>(Arc::new(RwLock::new(HashMap::default())))
}
#[async_trait]
impl EventHandler for Receiver {
impl EventHandler for VCData {
#[allow(unused_variables)]
async fn act(&self, ctx: &EventContext<'_>) -> Option<Event> {
use EventContext as Ctx;
match ctx {
Ctx::SpeakingStateUpdate(
Speaking {speaking, ssrc, user_id, ..}
) => {
Ctx::SpeakingStateUpdate(Speaking {
speaking,
ssrc,
user_id,
..
}) => {
// Discord voice calls use RTP, where every sender uses a randomly allocated
// *Synchronisation Source* (SSRC) to allow receivers to tell which audio
// stream a received packet belongs to. As this number is not derived from
@@ -54,27 +98,27 @@ impl EventHandler for Receiver {
// Using this map, you can map the `ssrc` in `voice_packet`
// to the user ID and handle their audio packets separately.
{
let mut users = self.users.write().await;
let data = self.data.write().await;
let mut users = data.users.write().await;
users.insert(ssrc.clone(), user_id.clone());
}
println!(
"\n\n\nSpeaking state update: user {:?} has SSRC {:?}, using {:?}\n\n\n",
user_id,
ssrc,
speaking,
user_id, ssrc, speaking,
);
},
}
Ctx::SpeakingUpdate(data) => {
// You can implement logic here which reacts to a user starting
// or stopping speaking, and to map their SSRC to User ID.
let users = self.users.read().await;
let vcdata = self.data.read().await;
let users = vcdata.users.read().await;
println!(
"Source {}/{:?} has {} speaking.",
data.ssrc,
users.get(&data.ssrc),
if data.speaking { "started" } else { "stopped" },
);
},
}
Ctx::VoicePacket(data) => {
// An event which fires for every received audio packet,
// containing the decoded data.
@@ -90,27 +134,30 @@ impl EventHandler for Receiver {
} else {
// println!("RTP packet, but no audio. Driver may not be configured to decode.");
}
},
}
Ctx::RtcpPacket(data) => {
// An event which fires for every received rtcp packet,
// containing the call statistics and reporting information.
// println!("RTCP packet received: {:?}", data.packet);
},
Ctx::ClientDisconnect(
ClientDisconnect {user_id, ..}
) => {
}
Ctx::ClientDisconnect(ClientDisconnect { user_id, .. }) => {
// You can implement your own logic here to handle a user who has left the
// voice channel e.g., finalise processing of statistics etc.
// You will typically need to map the User ID to their SSRC; observed when
// first speaking.
println!("Client disconnected: user {:?}", user_id);
},
Ctx::DriverConnect(
ConnectData { channel_id, ..}
) => {
}
Ctx::DriverConnect(ConnectData { channel_id, .. }) => {
println!("VoiceDriver is connected.");
},
}
Ctx::DriverDisconnect(DisconnectData {
channel_id,
guild_id,
..
}) => {
// TODO: Remove data from GuildVoiceData
}
_ => {
// We won't be registering this struct for any more event classes.
unimplemented!()
@@ -121,7 +168,7 @@ impl EventHandler for Receiver {
}
}
pub async fn playFile(call: Arc<Mutex<Call>>, file: String) {
pub async fn play_file(call: Arc<Mutex<Call>>, file: String) {
let mut call = call.lock().await;
let ff_src = ffmpeg(file).await.expect("Unable to find file.");
let (audio, handle) = create_player(ff_src);
@@ -133,48 +180,65 @@ pub async fn join(ctx: Context, guild: Guild, cid: ChannelId) -> Option<Arc<Mute
let (call, status) = manager.join(guild.id, cid).await;
match status {
Ok(_) => {
let vc_data: VCData = VCData::new(
CallLocation {
guild: guild.id,
channel: cid
}, VoiceData::new(
call.clone()
)
);
{
let data = ctx.data.read().await;
match data.get::<VCData>() {
Some(vc_guild) => {
let mut vc_guild = vc_guild.write().await;
vc_guild.insert(CallLocation {
guild: guild.id,
channel: cid
}, vc_data.clone());
}
None => {
println!("VoiceData for client hasn't been initialized");
}
}
}
let call_handle = call.clone();
{
let mut call = call.lock().await;
call.add_global_event(
CoreEvent::SpeakingStateUpdate.into(),
Receiver::new(call_handle.clone()),
vc_data.clone()
);
call.add_global_event(
CoreEvent::SpeakingUpdate.into(),
Receiver::new(call_handle.clone()),
vc_data.clone()
);
call.add_global_event(
CoreEvent::VoicePacket.into(),
Receiver::new(call_handle.clone()),
vc_data.clone()
);
call.add_global_event(
CoreEvent::RtcpPacket.into(),
Receiver::new(call_handle.clone()),
vc_data.clone()
);
call.add_global_event(
CoreEvent::ClientDisconnect.into(),
Receiver::new(call_handle.clone()),
);
call.add_global_event(
CoreEvent::ClientDisconnect.into(),
Receiver::new(call_handle.clone()),
vc_data.clone()
);
call.add_global_event(
CoreEvent::DriverConnect.into(),
Receiver::new(call_handle.clone()),
vc_data.clone()
);
}
let ding_src =
std::env::var("DING_SOUND").expect("DING not found in DING_SOUND");
playFile(call_handle, ding_src).await;
let ding_src = std::env::var("DING_SOUND").expect("DING not found in DING_SOUND");
play_file(call_handle, ding_src).await;
return Some(call);
}
Err(_err) => {