Skip to content

W
ws-rst
Commit a3538879 by qlintonger xeno
Options

所有额外消息处理完毕

parent 384cc267
Showing with 365 additions and 3 deletions
src/deport.rs
......@@ -34,7 +34,7 @@ pub async fn handle_ws_msg(
}
// 通话类消息直接托管给对应句柄即可
"Call" | "CancelCall" | "Refuse" | "EndMeeting" | "Hangup" | "Connect" | "Mute"
| "MuteAll" | "KickOut" | "MuteSelf" => {
| "MuteAll" | "KickOut" | "MuteSelf" | "UnMuteSelf" => {
handle_agora_call(
&client_message_data,
&from_id,
......
src/handles/handle_agora_call.rs
......@@ -1422,8 +1422,370 @@ pub async fn handle_agora_call(
}
}
}
// 处理静音
"Mute" => {}
// 处理踢出用户
"KickOut" => {
println!("step - KickOut - 1 收到踢出通知");
// 判断当前用户是否是主持人
let user_found = { ONLINE_USERS.get(from_id) };
if let Some(user_found) = user_found {
let user_split = user_found.split(",").collect::<Vec<_>>();
if user_split[6] == "1" {
// 先存储一下channel_id
let current_cid = user_split[1].to_string();
// 释放资源
drop(user_split);
drop(user_found);
println!("step - KickOut - 2 释放资源");
// 获取同channelId的人
let current_chatters = {
ONLINE_USERS
.iter()
.filter(|entry| {
let entry_split = entry.value().split(",").collect::<Vec<_>>();
entry_split[1] == current_cid
})
.map(|entry| entry.key().clone())
.collect::<Vec<String>>()
};
println!("step - KickOut - 3 获取同channelId的人");
// 对应sender-which发送消息即可
for user_id in current_chatters {
if let Some(target_sender_which) = {
CLIENT_SENDERS
.iter()
.find(|entry| entry.key().0 == user_id)
.map(|entry| entry.key().clone())
}{
// 如果该user_id和to_id一样，则发送CmdHangup，否则向其他人员广播CmdKickOut即可
if user_id == client_message_data.to_id {
println!("tep - KickOut 4 --踢出对应消息的人");
// 使该sender-which发送消息CmdHangup
// 注意，需要修改其用户数据
let kicked_user = ONLINE_USERS.get(&user_id);
if let Some(kicked_user) = kicked_user {
let mut kicked_user_data = kicked_user.split(",").collect::<Vec<_>>();
kicked_user_data[0] ="idle";
kicked_user_data[1] = "";
kicked_user_data[6] = "0";
println!("准备修改资源");
let data_joined = kicked_user_data.join(",");
drop(kicked_user_data);
drop(kicked_user);
ONLINE_USERS.insert(user_id.to_string(), data_joined.to_string());
println!("修改资源成功！");
// 开启线程修改redis数据
let cloned_user_id = user_id.to_string();
let data_p = data_joined.to_string();
tokio::spawn(
async move {
if let Err(e) = update_client_redis_data(&cloned_user_id, data_p).await {
println!("修改redis数据失败：{:?}", e);
} else {
println!("修改redis数据成功！");
}
}
);
// 释放资源
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": "CmdHangup",
"msgData": {
"channelID": current_cid,
"rtcToken": ""
},
"fromID" : "0",
"fromName": "Server",
"toID": user_id
}).to_string(),
false,
)) {
println!("发送给用户id {} 独立消息失败：{:?}", user_id, e);
} else {
println!("发送给用户id {} 独立消息成功 CmdHangup", user_id);
}
}
} else {
// 只发从CmdKickOut即可，注意一下fromID是上面这个人的id，也就是上面的to_id
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": "CmdKickOut",
"msgData": {
"channelID": current_cid,
"rtcToken": ""
},
"toID" : client_message_data.to_id,
"fromName": "Server",
"fromID": "0"
}).to_string(), false
)) {
println!("发送给用户id {} 独立消息失败：{:?}", user_id, e);
} else {
println!("发送给用户id {} 独立消息成功 CmdHangup", user_id);
}
}
}
}
// 成功踢出之后，需要通知所有用户更新在线用户列表，使用线程执行
tokio::spawn(
async move {
notify_all_clients_to_update_online_users().await;
}
);
} else {
println!("step - KickOut - 2 不是主持人");
drop(user_split);
drop(user_found);
// 不是主持人，发送错误消息
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": "Error",
"msgData": "只有主持人才能踢出用户",
"fromID" : "0",
"fromName": "Server",
"toID": from_id
})
.to_string(),
false,
)) {
println!("发送给用户id {} 独立消息失败：{:?}", from_id, e);
} else {
println!("发送给用户id {} 独立消息成功 Error", from_id);
}
}
}
},
// 处理单个静音消息，这个只供服务器转发，不做实际上的静音处理
"Mute" => {
println!("step - Mute - 1 收到静音通知");
// 取出to_id，然后直接转发，不需要在这里做出额外处理
let to_id = client_message_data.to_id.clone();
if to_id.is_empty() {
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": "Error",
"msgData": "必须传递to_id",
"fromID" : "0",
"fromName": "Server",
"toID": from_id
})
.to_string(),
false,
)) {
println!("发送给用户id {} 独立消息失败：{:?}", from_id, e);
} else {
println!("发送给用户id {} 独立消息成功", from_id);
}
} else {
// 直接找到对应to_id的sender-which，然后发送消息即可
// 目前只有主持人可以静音他人
let user_found = { ONLINE_USERS.get(from_id) };
if let Some(user_found) = user_found {
let user_data_now = user_found.split(",").collect::<Vec<_>>();
if user_data_now[6] == "1" {
let channel_id = user_data_now[2].to_string();
// 释放锁
drop(user_data_now);
drop(user_found);
let json_str = serde_json::json!({
"msgType": "CmdMute",
"msgData": {},
"fromID" : to_id,
"fromName": "Server",
"toID": to_id
})
.to_string();
// 针对同channel_id，并且处于通话状态中的用户，发送上述消息
let all_chatters_id = {
ONLINE_USERS.iter().filter(|entry| {
let user_data_now = entry.split(",").collect::<Vec<_>>();
user_data_now[1] == channel_id
}).map(|entry| entry.key().clone()).collect::<Vec<String>>()
};
// 根据chatters_id，找到对应sender-which
for user_id in all_chatters_id {
if let Some(target_sender_which) = {
CLIENT_SENDERS
.iter()
.find(|entry| entry.key().0 == user_id)
.map(|entry| entry.key().clone())
} {
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
json_str.clone(),
false,
)) {
println!(
"发送给用户id {} 独立消息失败：{:?}",
user_id, e
);
} else {
println!("发送给用户id {} 独立消息成功", user_id);
}
}
}
} else {
drop(user_found);
// 不是主持人，不允许静音他人
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": "Error",
"msgData": "您不是主持人，无法静音他人",
"fromID" : "0",
"fromName": "Server",
"toID": from_id
})
.to_string(),
false,
)) {
println!("发送给用户id {} 独立消息失败：{:?}", from_id, e);
} else {
println!("发送给用户id {} 独立消息成功", from_id);
}
}
}
}
}
// 处理全部人员静音，只有主持人有操作权限！
"MuteAll" => {
println!("step - MuteAll - 1 收到静音全部通知");
let user_found = { ONLINE_USERS.get(from_id) };
if let Some(user_found) = user_found {
let current_user_data = user_found.split(",").collect::<Vec<_>>();
println!("step - MuteAll -2 拆解数据");
if current_user_data[6] == "1" {
println!("step - MuteAll -3 静音全部可以，具备权限");
// 获取所有channelId
let current_channel_id = current_user_data[1].to_string();
// 筛选过滤所有channelId下的所有用户
let all_users_in_channel = {
ONLINE_USERS
.iter()
.filter(|entry| {
let entry_split = entry.value().split(",").collect::<Vec<_>>();
entry_split[1] == current_channel_id
})
.map(|entry| entry.key().clone())
.collect::<Vec<String>>()
};
// 提前释放
drop(current_user_data);
drop(user_found);
println!("step - MuteAll -4 筛选出所有channelId下的所有用户");
// 对他们每个人发送消息CmdMuteAll即可，没有后续操作
for user_id in all_users_in_channel {
// 找到对应sender
let target_sender_which = {
CLIENT_SENDERS
.iter()
.find(|entry| entry.key().0 == user_id)
.map(|entry| entry.key().clone())
};
// 发送消息
if let Some(target_sender_which) = target_sender_which {
let json_str = serde_json::json!({
"msgType": "CmdMuteAll",
"msgData": {
"channelID": current_channel_id,
"rtcToken": ""
},
"fromID" : "0",
"fromName": "Server",
"toID": user_id
})
.to_string();
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
json_str,
false,
)) {
println!("发送给用户id {} 独立消息失败：{:?}", user_id, e);
} else {
println!("发送给用户id {} 独立消息成功 CmdMuteAll", user_id);
}
drop(target_sender_which);
}
}
} else {
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": "Error",
"msgData": "只有主持人才有操作权限",
"fromID" : "0",
"fromName": "Server",
"toID": from_id
})
.to_string(),
false,
)) {
println!("发送给用户id {} 独立消息失败：{:?}", from_id, e);
} else {
println!("发送给用户id {} 独立消息成功", from_id);
}
// 关闭并且释放内存和锁
drop(current_user_data);
drop(user_found);
}
}
}
// 处理开关静音，这里服务器不对这种消息做任何处理，只是全频道广播一下
"MuteSelf" | "UnMuteSelf" => {
println!("step - MuteSelf-UN - 1 收到开关静音自己通知");
// 直接以fromId为基准，找到对应channel ID数据即可
let user_found = { ONLINE_USERS.get(from_id) };
if let Some(user_found) = user_found {
let data_split = user_found.split(",").collect::<Vec<_>>();
let channel_id = data_split[1].to_string();
// 释放资源
drop(data_split);
drop(user_found);
// 根据channelid查询所有用户
let chatting_id_set = {
ONLINE_USERS.iter()
.filter(|entry| {
let d_split = entry.value().split(",").collect::<Vec<_>>();
d_split[1] == channel_id
})
.map(|s| s.key().clone())
.collect::<Vec<String>>()
};
println!("step -2 -Mute-orNot 准备广播消息");
for chatting_id in chatting_id_set {
// 找到对应sender-which即可
let target_sender_which = {
CLIENT_SENDERS
.iter()
.find(|entry| entry.key().0 == chatting_id)
.map(|entry| entry.key().clone())
};
if let Some(target_sender_which) = target_sender_which {
if let Err(e) = event_sender.send(Event::SendClientMessage(
target_sender_which.clone(),
serde_json::json!({
"msgType": client_message_data.msg_type.as_str(),
"msgData": {},
"fromID" : from_id,
"fromName": "Unknown",
"toID": chatting_id
})
.to_string(),
false,
)) {
println!(
"发送给用户id {} 独立消息失败：{:?}",
chatting_id, e
);
}
}
}
}
}
_ => {}
}
}
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment