relay hint msgbox

Signed-off-by: 21pages <pages21@163.com>

src/ui_session_interface.rs

@@ -1,29 +1,30 @@
 use std::collections::HashMap;
 use std::ops::{Deref, DerefMut};
 use std::str::FromStr;
-use std::sync::{Arc, Mutex, RwLock};
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
+use std::sync::{Arc, Mutex, RwLock};
+use std::time::Duration;
 
 use async_trait::async_trait;
 use bytes::Bytes;
 use rdev::{Event, EventType::*};
 use uuid::Uuid;
 
-use hbb_common::{allow_err, message_proto::*};
-use hbb_common::{fs, get_version_number, log, Stream};
 use hbb_common::config::{Config, LocalConfig, PeerConfig, RS_PUB_KEY};
 use hbb_common::rendezvous_proto::ConnType;
 use hbb_common::tokio::{self, sync::mpsc};
+use hbb_common::{allow_err, message_proto::*};
+use hbb_common::{fs, get_version_number, log, Stream};
 
-use crate::{client::Data, client::Interface};
-use crate::client::{
-    check_if_retry, FileManager, handle_hash, handle_login_error, handle_login_from_ui,
-    handle_test_delay, input_os_password, Key, KEY_MAP, load_config, LoginConfigHandler,
-    QualityStatus, send_mouse, start_video_audio_threads,
-};
 use crate::client::io_loop::Remote;
+use crate::client::{
+    check_if_retry, handle_hash, handle_login_error, handle_login_from_ui, handle_test_delay,
+    input_os_password, load_config, send_mouse, start_video_audio_threads, FileManager, Key,
+    LoginConfigHandler, QualityStatus, KEY_MAP,
+};
 use crate::common::{self, GrabState};
 use crate::keyboard;
+use crate::{client::Data, client::Interface};
 
 pub static IS_IN: AtomicBool = AtomicBool::new(false);
 
@@ -531,9 +532,13 @@ impl<T: InvokeUiSession> Session<T> {
         }
     }
 
-    pub fn reconnect(&self) {
+    pub fn reconnect(&self, force_relay: bool) {
         self.send(Data::Close);
         let cloned = self.clone();
+        // override only if true
+        if true == force_relay {
+            cloned.lc.write().unwrap().force_relay = true;
+        }
         let mut lock = self.thread.lock().unwrap();
         lock.take().map(|t| t.join());
         *lock = Some(std::thread::spawn(move || {
@@ -674,10 +679,42 @@ impl<T: InvokeUiSession> Session<T> {
     pub fn request_voice_call(&self) {
         self.send(Data::NewVoiceCall);
     }
-    
+
     pub fn close_voice_call(&self) {
         self.send(Data::CloseVoiceCall);
     }
+
+    pub fn show_relay_hint(
+        &mut self,
+        last_recv_time: tokio::time::Instant,
+        msgtype: &str,
+        title: &str,
+        text: &str,
+    ) -> bool {
+        let duration = Duration::from_secs(3);
+        let counter_interval = 3;
+        let lock = self.lc.read().unwrap();
+        let success_time = lock.success_time;
+        let direct = lock.direct.unwrap_or(false);
+        let received = lock.received;
+        drop(lock);
+        if let Some(success_time) = success_time {
+            if direct && last_recv_time.duration_since(success_time) < duration {
+                let retry_for_relay = direct && !received;
+                let retry = check_if_retry(msgtype, title, text, retry_for_relay);
+                if retry && !retry_for_relay {
+                    self.lc.write().unwrap().direct_error_counter += 1;
+                    if self.lc.read().unwrap().direct_error_counter % counter_interval == 0 {
+                        #[cfg(feature = "flutter")]
+                        return true;
+                    }
+                }
+            } else {
+                self.lc.write().unwrap().direct_error_counter = 0;
+            }
+        }
+        false
+    }
 }
 
 pub trait InvokeUiSession: Send + Sync + Clone + 'static + Sized + Default {
@@ -813,6 +850,7 @@ impl<T: InvokeUiSession> Interface for Session<T> {
                 "Connected, waiting for image...",
                 "",
             );
+            self.lc.write().unwrap().success_time = Some(tokio::time::Instant::now());
         }
         self.on_connected(self.lc.read().unwrap().conn_type);
         #[cfg(windows)]
@@ -958,7 +996,7 @@ pub async fn io_loop<T: InvokeUiSession>(handler: Session<T>) {
     let frame_count = Arc::new(AtomicUsize::new(0));
     let frame_count_cl = frame_count.clone();
     let ui_handler = handler.ui_handler.clone();
-    let (video_sender, audio_sender) = start_video_audio_threads(move |data: &mut Vec<u8> | {
+    let (video_sender, audio_sender) = start_video_audio_threads(move |data: &mut Vec<u8>| {
         frame_count_cl.fetch_add(1, Ordering::Relaxed);
         ui_handler.on_rgba(data);
     });