broadcast self-update info

README.md

@@ -27,10 +27,10 @@ ESSE, positioned as an engine. The engine is coded in [**Rust**](https://github.
 [Document](https://docs.cympletech.com/docs/introduction)
 
 ## Install
-### Use pre-compiled executable
+### 🚀 Use pre-compiled executable
 [Download](https://github.com/cympletech/esse/releases)
 
-### Compile from souce
+### 🚲 Compile from souce
 #### 1. Pre-installed
 - Rustup [install](https://rustup.rs/)
 - Rust (Lastest Stable version)

lib/apps/service/models.dart

@@ -14,9 +14,9 @@ const List<InnerService> INNER_SERVICES = [
   InnerService.Wallet,
   InnerService.Chat,
   InnerService.GroupChat,
-  InnerService.Dao,
+  //InnerService.Dao,
   InnerService.Domain,
-  InnerService.Cloud,
+  //InnerService.Cloud,
   InnerService.Jarvis,
 ];
 

src/apps/wallet/rpc.rs

@@ -352,6 +352,8 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let db = wallet_db(group_lock.base(), &gid)?;
             drop(group_lock);
 
+            let mut results = HandleResult::new();
+
             let pass = if pass.len() > 0 {
                 Some(pass.as_ref())
             } else {
@@ -372,6 +374,7 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             };
 
             address.insert(&db)?;
+            results.rpcs.push(address.to_rpc());
             if address.main {
                 let mut group_lock = state.group.write().await;
                 let a_db = account_db(group_lock.base())?;
@@ -379,9 +382,13 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
                 account.wallet = address.chain.update_main(&address.address, &account.wallet);
                 account.pub_height = account.pub_height + 1;
                 account.update_info(&a_db)?;
+                let user = group_lock.clone_user(&gid)?;
                 drop(group_lock);
+
+                // broadcast all friends.
+                state.layer.read().await.broadcast(user, &mut results);
             }
-            Ok(HandleResult::rpc(address.to_rpc()))
+            Ok(results)
         },
     );
 
@@ -602,12 +609,19 @@ pub(crate) fn new_rpc_handler(handler: &mut RpcHandler<RpcState>) {
             let address = Address::get(&db, &id)?;
             Address::main(&db, &id)?;
 
+            let mut results = HandleResult::new();
+
             let mut group_lock = state.group.write().await;
             let account = group_lock.account_mut(&gid)?;
             account.wallet = address.chain.update_main(&address.address, &account.wallet);
             account.pub_height = account.pub_height + 1;
             account.update_info(&a_db)?;
+            let user = group_lock.clone_user(&gid)?;
             drop(group_lock);
+
+            // broadcast all friends.
+            state.layer.read().await.broadcast(user, &mut results);
+
             Ok(HandleResult::new())
         },
     );

src/layer.rs

@@ -5,11 +5,12 @@ use std::sync::Arc;
 use tdn::types::{
     group::GroupId,
     message::SendType,
-    primitive::{Peer, PeerId, Result},
+    primitive::{HandleResult, Peer, PeerId, Result},
 };
 use tokio::sync::RwLock;
 
-use crate::apps::chat::chat_conn;
+use crate::account::User;
+use crate::apps::chat::{chat_conn, LayerEvent as ChatLayerEvent};
 use crate::apps::group::{group_conn, GROUP_ID};
 use crate::group::Group;
 use crate::session::{Session, SessionType};
@@ -168,6 +169,18 @@ impl Layer {
             false
         }
     }
+
+    pub fn broadcast(&self, user: User, results: &mut HandleResult) {
+        let gid = user.id;
+        let info = ChatLayerEvent::InfoRes(user);
+        let data = bincode::serialize(&info).unwrap_or(vec![]);
+        if let Some(running) = self.runnings.get(&gid) {
+            for (fgid, online) in &running.sessions {
+                let msg = SendType::Event(0, *online.online.addr(), data.clone());
+                results.layers.push((gid, *fgid, msg));
+            }
+        }
+    }
 }
 
 /// online info.

src/rpc.rs

@@ -348,17 +348,21 @@ fn new_rpc_handler(
 
             let mut group_lock = state.group.write().await;
             group_lock.update_account(gid, name, avatar_bytes.clone())?;
+            let user = group_lock.clone_user(&gid)?;
 
             let mut results = HandleResult::new();
             group_lock.broadcast(
                 &gid,
-                InnerEvent::UserInfo(name.to_owned(), avatar_bytes),
+                InnerEvent::UserInfo(name.to_owned(), avatar_bytes.clone()),
                 0,
                 0,
                 &mut results,
             )?;
             drop(group_lock);
 
+            // broadcast all friends.
+            state.layer.read().await.broadcast(user, &mut results);
+
             Ok(results)
         },
     );