VideoConnCount for future use

src/ipc.rs

@@ -233,6 +233,7 @@ pub enum Data {
     ControlledSessionCount(usize),
     CmErr(String),
     CheckHwcodec,
+    VideoConnCount(Option<usize>),
 }
 
 #[tokio::main(flavor = "current_thread")]
@@ -382,6 +383,15 @@ async fn handle(data: Data, stream: &mut Connection) {
                 log::info!("socks updated");
             }
         },
+        Data::VideoConnCount(None) => {
+            let n = crate::server::AUTHED_CONNS
+                .lock()
+                .unwrap()
+                .iter()
+                .filter(|x| x.1 == crate::server::AuthConnType::Remote)
+                .count();
+            allow_err!(stream.send(&Data::VideoConnCount(Some(n))).await);
+        }
         Data::Config((name, value)) => match value {
             None => {
                 let value;
@@ -905,7 +915,7 @@ pub async fn set_socks(value: config::Socks5Server) -> ResultType<()> {
 }
 
 pub fn get_proxy_status() -> bool {
-     Config::get_socks().is_some()
+    Config::get_socks().is_some()
 }
 #[tokio::main(flavor = "current_thread")]
 pub async fn test_rendezvous_server() -> ResultType<()> {

src/server/connection.rs

@@ -69,7 +69,7 @@ lazy_static::lazy_static! {
     static ref LOGIN_FAILURES: [Arc::<Mutex<HashMap<String, (i32, i32, i32)>>>; 2] = Default::default();
     static ref SESSIONS: Arc::<Mutex<HashMap<String, Session>>> = Default::default();
     static ref ALIVE_CONNS: Arc::<Mutex<Vec<i32>>> = Default::default();
-    static ref AUTHED_CONNS: Arc::<Mutex<Vec<(i32, AuthConnType)>>> = Default::default();
+    pub static ref AUTHED_CONNS: Arc::<Mutex<Vec<(i32, AuthConnType)>>> = Default::default();
     static ref SWITCH_SIDES_UUID: Arc::<Mutex<HashMap<String, (Instant, uuid::Uuid)>>> = Default::default();
     static ref WAKELOCK_SENDER: Arc::<Mutex<std::sync::mpsc::Sender<(usize, usize)>>> = Arc::new(Mutex::new(start_wakelock_thread()));
 }

src/ui_cm_interface.rs

@@ -78,8 +78,9 @@ struct IpcTaskRunner<T: InvokeUiCM> {
 
 lazy_static::lazy_static! {
     static ref CLIENTS: RwLock<HashMap<i32, Client>> = Default::default();
-    static ref CLICK_TIME: AtomicI64 = AtomicI64::new(0);
 }
+    
+static CLICK_TIME: AtomicI64 = AtomicI64::new(0);
 
 #[derive(Clone)]
 pub struct ConnectionManager<T: InvokeUiCM> {

src/ui_interface.rs

@@ -3,9 +3,7 @@ use hbb_common::password_security;
 use hbb_common::{
     allow_err,
     bytes::Bytes,
-    config::{
-        self, Config, LocalConfig, PeerConfig, CONNECT_TIMEOUT, RENDEZVOUS_PORT,
-    },
+    config::{self, Config, LocalConfig, PeerConfig, CONNECT_TIMEOUT, RENDEZVOUS_PORT},
     directories_next,
     futures::future::join_all,
     log,
@@ -22,6 +20,7 @@ use serde_derive::Serialize;
 use std::process::Child;
 use std::{
     collections::HashMap,
+    sync::atomic::{AtomicUsize, Ordering},
     sync::{Arc, Mutex},
 };
 
@@ -69,6 +68,8 @@ lazy_static::lazy_static! {
     static ref TEMPORARY_PASSWD : Arc<Mutex<String>> = Arc::new(Mutex::new("".to_owned()));
 }
 
+pub static VIDEO_CONN_COUNT: AtomicUsize = AtomicUsize::new(0);
+
 #[cfg(not(any(target_os = "android", target_os = "ios")))]
 lazy_static::lazy_static! {
     static ref OPTION_SYNCED: Arc<Mutex<bool>> = Default::default();
@@ -426,7 +427,7 @@ pub fn set_socks(proxy: String, username: String, password: String) {
 pub fn get_proxy_status() -> bool {
     #[cfg(not(any(target_os = "android", target_os = "ios")))]
     return ipc::get_proxy_status();
-    
+
     // Currently, only the desktop version has proxy settings.
     #[cfg(any(target_os = "android", target_os = "ios"))]
     return false;
@@ -723,24 +724,29 @@ pub fn change_id(id: String) {
 pub fn http_request(url: String, method: String, body: Option<String>, header: String) {
     // Respond to concurrent requests for resources
     let current_request = ASYNC_HTTP_STATUS.clone();
-    current_request.lock().unwrap().insert(url.clone()," ".to_owned());
+    current_request
+        .lock()
+        .unwrap()
+        .insert(url.clone(), " ".to_owned());
     std::thread::spawn(move || {
-          let res =  match crate::http_request_sync(url.clone(), method, body, header) {
-                Err(err) => { log::error!("{}", err); err.to_string() },
-                Ok(text) => text,
-            };
-        current_request.lock().unwrap().insert(url,res);
+        let res = match crate::http_request_sync(url.clone(), method, body, header) {
+            Err(err) => {
+                log::error!("{}", err);
+                err.to_string()
+            }
+            Ok(text) => text,
+        };
+        current_request.lock().unwrap().insert(url, res);
     });
 }
 #[inline]
 pub fn get_async_http_status(url: String) -> Option<String> {
     match ASYNC_HTTP_STATUS.lock().unwrap().get(&url) {
-        None => {None}
-        Some(_str) => {Some(_str.to_string())}
+        None => None,
+        Some(_str) => Some(_str.to_string()),
     }
 }
 
-
 #[inline]
 pub fn post_request(url: String, body: String, header: String) {
     *ASYNC_JOB_STATUS.lock().unwrap() = " ".to_owned();
@@ -1116,6 +1122,9 @@ async fn check_connect_status_(reconnect: bool, rx: mpsc::UnboundedReceiver<ipc:
                                     *TEMPORARY_PASSWD.lock().unwrap() = value;
                                 }
                             }
+                            Ok(Some(ipc::Data::VideoConnCount(Some(n)))) => {
+                                VIDEO_CONN_COUNT.store(n, Ordering::Relaxed);
+                            }
                             Ok(Some(ipc::Data::OnlineStatus(Some((mut x, _c))))) => {
                                 if x > 0 {
                                     x = 1
@@ -1145,6 +1154,7 @@ async fn check_connect_status_(reconnect: bool, rx: mpsc::UnboundedReceiver<ipc:
                         c.send(&ipc::Data::Options(None)).await.ok();
                         c.send(&ipc::Data::Config(("id".to_owned(), None))).await.ok();
                         c.send(&ipc::Data::Config(("temporary-password".to_owned(), None))).await.ok();
+                        c.send(&ipc::Data::VideoConnCount(None)).await.ok();
                     }
                 }
             }