From 9ac4507f4f85228a4fb6ccaa89541ff9658c91b4 Mon Sep 17 00:00:00 2001 From: Sun Date: Thu, 13 May 2021 15:57:59 +0800 Subject: [PATCH] update group chat layer event --- src/apps/chat/layer.rs | 6 +-- src/apps/group_chat/layer.rs | 77 ++++++++++++++++++++++++++++++++---- src/apps/group_chat/rpc.rs | 20 ++++++++++ src/layer.rs | 8 +--- src/rpc.rs | 4 +- src/server.rs | 5 --- 6 files changed, 97 insertions(+), 23 deletions(-) diff --git a/src/apps/chat/layer.rs b/src/apps/chat/layer.rs index c4e3da4..e4cac94 100644 --- a/src/apps/chat/layer.rs +++ b/src/apps/chat/layer.rs @@ -53,12 +53,12 @@ pub(crate) enum LayerResponse { /// ESSE chat layer Event. #[derive(Serialize, Deserialize)] pub(crate) enum LayerEvent { + /// receiver gid, sender gid. as BaseLayerEvent. + Offline(GroupId), /// receiver gid, sender gid. as BaseLayerEvent. OnlinePing, /// receiver gid, sender gid. as BaseLayerEvent. OnlinePong, - /// receiver gid, sender gid. as BaseLayerEvent. - Offline, /// receiver gid, sender gid, message. Message(EventId, NetworkMessage), /// receiver gid, sender user. @@ -525,7 +525,7 @@ impl LayerEvent { .check_add_online(fgid, Online::Direct(addr), fid)?; results.rpcs.push(rpc::friend_online(mgid, fid, addr)); } - LayerEvent::Offline => { + LayerEvent::Offline(_) => { layer.group.write().await.status( &mgid, StatusEvent::SessionFriendOffline(fgid), diff --git a/src/apps/group_chat/layer.rs b/src/apps/group_chat/layer.rs index d2c5522..7be6879 100644 --- a/src/apps/group_chat/layer.rs +++ b/src/apps/group_chat/layer.rs @@ -9,9 +9,8 @@ use tdn::{ }, }; -use group_chat_types::{GroupConnect, GroupResult, JoinProof}; +use group_chat_types::{Event, GroupConnect, GroupResult, JoinProof, LayerEvent}; use tdn_did::Proof; -//use group_chat_types::{Event, GroupConnect, GroupEvent, GroupInfo, GroupResult, GroupType}; use crate::layer::{Layer, Online}; use crate::storage::group_chat_db; @@ -27,9 +26,7 @@ pub(crate) async fn handle( let mut results = HandleResult::new(); match msg { - RecvType::Connect(_addr, _data) => { - // Never to here. - } + RecvType::Connect(..) => {} // Never to here. RecvType::Leave(_addr) => { // } @@ -101,8 +98,10 @@ pub(crate) async fn handle( let _res: GroupResult = postcard::from_bytes(&data) .map_err(|_e| new_io_error("Deseralize result failure"))?; } - RecvType::Event(_addr, _bytes) => { - // + RecvType::Event(addr, bytes) => { + let event: LayerEvent = + postcard::from_bytes(&bytes).map_err(|_| new_io_error("serialize event error."))?; + handle_event(mgid, addr, event, layer, &mut results).await?; } RecvType::Stream(_uid, _stream, _bytes) => { // TODO stream @@ -115,6 +114,70 @@ pub(crate) async fn handle( Ok(results) } +async fn handle_event( + mgid: GroupId, + addr: PeerAddr, + event: LayerEvent, + layer: &Arc>, + results: &mut HandleResult, +) -> Result<()> { + let gid = match event { + LayerEvent::Offline(gcd) + | LayerEvent::OnlinePing(gcd) + | LayerEvent::OnlinePong(gcd) + | LayerEvent::MemberOnline(gcd, ..) + | LayerEvent::MemberOffline(gcd, ..) + | LayerEvent::Sync(gcd, ..) => layer.read().await.get_running_remote_id(&mgid, &gcd)?, + }; + + match event { + LayerEvent::Offline(_) => { + results.rpcs.push(rpc::group_offline(mgid, gid)); + } + LayerEvent::OnlinePing(gcd) => { + results.rpcs.push(rpc::group_online(mgid, gid)); + let data = postcard::to_allocvec(&LayerEvent::OnlinePong(gcd)).unwrap_or(vec![]); + let msg = SendType::Event(0, addr, data); + add_layer(results, mgid, msg); + } + + LayerEvent::OnlinePong(_) => { + results.rpcs.push(rpc::group_online(mgid, gid)); + } + LayerEvent::Sync(_gcd, _, event) => { + match event { + Event::Message => { + // + } + Event::GroupUpdate => { + // + } + Event::GroupTransfer => { + // + } + Event::UserInfo => { + // + } + Event::Close => { + // + } + } + + // save event. + + // update to UI. + } + LayerEvent::MemberOnline(_, mid, maddr) => { + results.rpcs.push(rpc::member_online(mgid, gid, mid, maddr)); + } + LayerEvent::MemberOffline(_, mid, ma) => { + results.rpcs.push(rpc::member_offline(mgid, gid, mid, ma)); + } + } + + Ok(()) +} + #[inline] fn load_group(base: &PathBuf, mgid: &GroupId, gcd: &GroupId) -> Result> { let db = group_chat_db(base, mgid)?; diff --git a/src/apps/group_chat/rpc.rs b/src/apps/group_chat/rpc.rs index 829085d..c64cb7f 100644 --- a/src/apps/group_chat/rpc.rs +++ b/src/apps/group_chat/rpc.rs @@ -36,6 +36,26 @@ pub(crate) fn group_offline(mgid: GroupId, gid: i64) -> RpcParam { rpc_response(0, "group-chat-offline", json!([gid]), mgid) } +#[inline] +pub(crate) fn member_online(mgid: GroupId, gid: i64, mid: GroupId, maddr: PeerAddr) -> RpcParam { + rpc_response( + 0, + "group-chat-member-online", + json!([gid, mid.to_hex(), maddr.to_hex()]), + mgid, + ) +} + +#[inline] +pub(crate) fn member_offline(mgid: GroupId, gid: i64, mid: GroupId, maddr: PeerAddr) -> RpcParam { + rpc_response( + 0, + "group-chat-member-offline", + json!([gid, mid.to_hex(), maddr.to_hex()]), + mgid, + ) +} + #[inline] fn group_list(groups: Vec) -> RpcParam { let mut results = vec![]; diff --git a/src/layer.rs b/src/layer.rs index dcc9d8b..951355a 100644 --- a/src/layer.rs +++ b/src/layer.rs @@ -21,12 +21,8 @@ use crate::storage::{group_chat_db, session_db, write_avatar_sync}; /// EVERY LAYER APP MUST EQUAL THE FIRST THREE FIELDS. #[derive(Serialize, Deserialize)] pub(crate) enum LayerEvent { - /// receiver gid, sender gid. - OnlinePing, - /// receiver gid, sender gid. - OnlinePong, - /// receiver gid, sender gid. - Offline, + /// offline, remote_gid. + Offline(GroupId), } /// ESSE layers. diff --git a/src/rpc.rs b/src/rpc.rs index a3c9faf..1e1881c 100644 --- a/src/rpc.rs +++ b/src/rpc.rs @@ -329,7 +329,7 @@ fn new_rpc_handler( for gid in keys { for (fgid, addr) in layer_lock.running(&gid)?.onlines() { // send a event that is offline. - let data = postcard::to_allocvec(&LayerEvent::Offline).unwrap_or(vec![]); + let data = postcard::to_allocvec(&LayerEvent::Offline(*fgid)).unwrap_or(vec![]); let msg = SendType::Event(0, *addr, data); results.layers.push((gid, *fgid, msg)); } @@ -400,7 +400,7 @@ fn new_rpc_handler( let layer_lock = state.layer.read().await; for (fgid, addr) in layer_lock.running(&gid)?.onlines() { // send a event that is offline. - let data = postcard::to_allocvec(&LayerEvent::Offline).unwrap_or(vec![]); + let data = postcard::to_allocvec(&LayerEvent::Offline(*fgid)).unwrap_or(vec![]); let msg = SendType::Event(0, *addr, data); results.layers.push((gid, *fgid, msg)); } diff --git a/src/server.rs b/src/server.rs index 97ef005..e228084 100644 --- a/src/server.rs +++ b/src/server.rs @@ -82,11 +82,6 @@ pub async fn start(db_path: String) -> Result<()> { } } ReceiveMessage::Layer(fgid, tgid, l_msg) => { - // 1. check to account is online. if not online, nothing. - if !layer.read().await.runnings.contains_key(&tgid) { - continue; - } - if let Ok(handle_result) = app_layer_handle(&layer, fgid, tgid, l_msg).await { handle(handle_result, now_rpc_uid, true, &sender).await; }