User info cache to speedup loading

src/app.rs

@@ -29,6 +29,7 @@ use backend::BKResponse;
 use backend;
 
 use types::Member;
+use types::MemberList;
 use types::Message;
 use types::Protocol;
 use types::Room;
@@ -58,14 +59,17 @@ struct TmpMsg {
 pub struct AppOp {
     pub gtk_builder: gtk::Builder,
     pub backend: Sender<backend::BKCommand>,
+
+    pub syncing: bool,
+    tmp_msgs: Vec<TmpMsg>,
+
+    pub username: String,
+    pub uid: String,
+
     pub active_room: String,
-    pub members: HashMap<String, Member>,
+    pub members: MemberList,
     pub rooms: HashMap<String, Room>,
     pub load_more_btn: gtk::Button,
-    pub username: String,
-    pub uid: String,
-    pub syncing: bool,
-    tmp_msgs: Vec<TmpMsg>,
 }
 
 #[derive(Debug)]

src/backend.rs

@@ -7,6 +7,7 @@ use self::chrono::prelude::*;
 
 use self::serde_json::Value as JsonValue;
 
+use std::collections::HashMap;
 use std::path::Path;
 use std::sync::{Arc, Mutex};
 use std::thread;
@@ -44,6 +45,9 @@ pub struct Backend {
     tx: Sender<BKResponse>,
     data: Arc<Mutex<BackendData>>,
     internal_tx: Option<Sender<BKCommand>>,
+
+    // user info cache, uid -> (name, avatar)
+    user_info_cache: HashMap<String, (String, String)>,
 }
 
 #[derive(Debug)]
@@ -150,6 +154,7 @@ impl Backend {
             tx: tx,
             internal_tx: None,
             data: Arc::new(Mutex::new(data)),
+            user_info_cache: HashMap::new(),
         }
     }
 
@@ -169,8 +174,8 @@ impl Backend {
         client_url!(&base, path, params2)
     }
 
-    pub fn command_recv(&self, cmd: Result<BKCommand, RecvError>) -> bool {
-        let tx = &self.tx;
+    pub fn command_recv(&mut self, cmd: Result<BKCommand, RecvError>) -> bool {
+        let tx = self.tx.clone();
 
         match cmd {
             Ok(BKCommand::Login(user, passwd, server)) => {
@@ -654,23 +659,28 @@ impl Backend {
         Ok(())
     }
 
-    pub fn get_user_info_async(&self,
+    pub fn get_user_info_async(&mut self,
                                uid: &str,
                                tx: Sender<(String, String)>)
                                -> Result<(), Error> {
         let baseu = self.get_base_url()?;
 
         let u = String::from(uid);
-        thread::spawn(move || {
-            match get_user_avatar(&baseu, &u) {
-                Ok(info) => {
-                    tx.send(info).unwrap();
-                }
-                Err(_) => {
-                    tx.send((String::new(), String::new())).unwrap();
-                }
-            };
-        });
+
+        if let Some(info) = self.user_info_cache.get(&u) {
+            tx.send(info.clone()).unwrap();
+            return Ok(())
+        }
+
+        match get_user_avatar(&baseu, &u) {
+            Ok(info) => {
+                tx.send(info.clone()).unwrap();
+                self.user_info_cache.insert(u.clone(), info);
+            }
+            Err(_) => {
+                tx.send((String::new(), String::new())).unwrap();
+            }
+        };
 
         Ok(())
     }

src/main.rs

@@ -6,6 +6,7 @@ mod widgets;
 mod error;
 mod types;
 mod backend;
+mod model;
 mod app;
 
 use app::App;

src/model/event.rs

@@ -0,0 +1,12 @@
+extern crate serde_json;
+
+use self::serde_json::Value as JsonValue;
+
+#[derive(Debug)]
+pub struct Event {
+    pub sender: String,
+    pub stype: String,
+    pub room: String,
+    pub id: String,
+    pub content: JsonValue,
+}

src/model/member.rs

@@ -0,0 +1,20 @@
+use std::collections::HashMap;
+
+#[derive(Debug)]
+pub struct Member {
+    pub alias: String,
+    pub uid: String,
+    pub avatar: String,
+}
+
+impl Member {
+    pub fn get_alias(&self) -> String {
+        match self.alias {
+            ref a if a.is_empty() => self.uid.clone(),
+            ref a => a.clone(),
+        }
+    }
+}
+
+// hashmap userid -> Member
+pub type MemberList = HashMap<String, Member>;

src/model/message.rs

@@ -0,0 +1,32 @@
+extern crate chrono;
+
+use self::chrono::prelude::*;
+
+#[derive(Debug)]
+#[derive(PartialEq, PartialOrd)]
+pub struct Message {
+    pub sender: String,
+    pub mtype: String,
+    pub body: String,
+    pub date: DateTime<Local>,
+    pub room: String,
+    pub thumb: String,
+    pub url: String,
+    pub id: String,
+}
+
+impl Clone for Message {
+    fn clone(&self) -> Message {
+        Message {
+            sender: self.sender.clone(),
+            mtype: self.mtype.clone(),
+            body: self.body.clone(),
+            date: self.date.clone(),
+            room: self.room.clone(),
+            thumb: self.thumb.clone(),
+            url: self.url.clone(),
+            id: self.id.clone(),
+        }
+    }
+}
+

src/model/mod.rs

@@ -0,0 +1,5 @@
+pub mod member;
+pub mod room;
+pub mod protocol;
+pub mod event;
+pub mod message;

src/model/protocol.rs

@@ -0,0 +1,5 @@
+#[derive(Debug)]
+pub struct Protocol {
+    pub id: String,
+    pub desc: String,
+}

src/model/room.rs

@@ -0,0 +1,44 @@
+#[derive(Debug)]
+pub struct Room {
+    pub id: String,
+    pub avatar: String,
+    pub name: String,
+    pub topic: String,
+    pub alias: String,
+    pub guest_can_join: bool,
+    pub world_readable: bool,
+    pub members: i32,
+    pub notifications: i32,
+}
+
+impl Room {
+    pub fn new(id: String, name: String) -> Room {
+        Room {
+            id: id,
+            name: name,
+            avatar: String::new(),
+            topic: String::new(),
+            alias: String::new(),
+            guest_can_join: true,
+            world_readable: true,
+            members: 0,
+            notifications: 0,
+        }
+    }
+}
+
+impl Clone for Room {
+    fn clone(&self) -> Room {
+        Room {
+            id: self.id.clone(),
+            name: self.name.clone(),
+            avatar: self.avatar.clone(),
+            topic: self.topic.clone(),
+            alias: self.alias.clone(),
+            guest_can_join: self.guest_can_join,
+            world_readable: self.world_readable,
+            members: self.members,
+            notifications: self.notifications,
+        }
+    }
+}

src/types.rs

@@ -1,109 +1,6 @@
-extern crate chrono;
-extern crate serde_json;
-
-use self::chrono::prelude::*;
-use self::serde_json::Value as JsonValue;
-
-#[derive(Debug)]
-#[derive(PartialEq, PartialOrd)]
-pub struct Message {
-    pub sender: String,
-    pub mtype: String,
-    pub body: String,
-    pub date: DateTime<Local>,
-    pub room: String,
-    pub thumb: String,
-    pub url: String,
-    pub id: String,
-}
-
-impl Clone for Message {
-    fn clone(&self) -> Message {
-        Message {
-            sender: self.sender.clone(),
-            mtype: self.mtype.clone(),
-            body: self.body.clone(),
-            date: self.date.clone(),
-            room: self.room.clone(),
-            thumb: self.thumb.clone(),
-            url: self.url.clone(),
-            id: self.id.clone(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Member {
-    pub alias: String,
-    pub uid: String,
-    pub avatar: String,
-}
-
-impl Member {
-    pub fn get_alias(&self) -> String {
-        match self.alias {
-            ref a if a.is_empty() => self.uid.clone(),
-            ref a => a.clone(),
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Protocol {
-    pub id: String,
-    pub desc: String,
-}
-
-#[derive(Debug)]
-pub struct Room {
-    pub id: String,
-    pub avatar: String,
-    pub name: String,
-    pub topic: String,
-    pub alias: String,
-    pub guest_can_join: bool,
-    pub world_readable: bool,
-    pub members: i32,
-    pub notifications: i32,
-}
-
-impl Room {
-    pub fn new(id: String, name: String) -> Room {
-        Room {
-            id: id,
-            name: name,
-            avatar: String::new(),
-            topic: String::new(),
-            alias: String::new(),
-            guest_can_join: true,
-            world_readable: true,
-            members: 0,
-            notifications: 0,
-        }
-    }
-}
-
-impl Clone for Room {
-    fn clone(&self) -> Room {
-        Room {
-            id: self.id.clone(),
-            name: self.name.clone(),
-            avatar: self.avatar.clone(),
-            topic: self.topic.clone(),
-            alias: self.alias.clone(),
-            guest_can_join: self.guest_can_join,
-            world_readable: self.world_readable,
-            members: self.members,
-            notifications: self.notifications,
-        }
-    }
-}
-
-#[derive(Debug)]
-pub struct Event {
-    pub sender: String,
-    pub stype: String,
-    pub room: String,
-    pub id: String,
-    pub content: JsonValue,
-}
+pub use model::event::Event;
+pub use model::room::Room;
+pub use model::protocol::Protocol;
+pub use model::message::Message;
+pub use model::member::Member;
+pub use model::member::MemberList;