.

1 files changed, 48 insertions, 16 deletions

diff --git a/core/src/service/cli_addition/runtime_consoles.rs b/core/src/service/cli_addition/runtime_consoles.rs
index 38d8404..c96c0f2 100644
--- a/core/src/service/cli_addition/runtime_consoles.rs
+++ b/core/src/service/cli_addition/runtime_consoles.rs
@@ -1,30 +1,37 @@
+use std::process::exit;
 use crate::service::cli_addition::utils::read_cli;
 use clap::{Command, FromArgMatches};
 use std::sync::{Arc, Mutex};
-use log::info;
-use tokio::{join, spawn};
+use std::time::Duration;
+use log::{info, warn};
+use tokio::{count, join, select, spawn};
+use tokio::signal::ctrl_c;
+use tokio::time::sleep;
 use crate::service::service_runner::NoGamepadsService;
 
-pub struct RuntimeConsole<PadService, Cmd>
-where Cmd: FromArgMatches {
+pub struct RuntimeConsole<PadService, Cmd> where Cmd: FromArgMatches {
     command: Command,
     prefix: String,
     service: Arc<Mutex<PadService>>,
     process_command: fn(Arc<Mutex<PadService>>, Cmd) -> bool,
+    check_close: fn(rt: Arc<Mutex<PadService>>) -> bool,
+    close: fn(rt: Arc<Mutex<PadService>>),
 }
 
-impl<PadService: Send + 'static, Cmd: FromArgMatches + 'static> RuntimeConsole<PadService, Cmd> {
+impl<PadService, Cmd> RuntimeConsole<PadService, Cmd>
+where PadService: Send + 'static, Cmd: FromArgMatches + 'static {
     pub fn build(command: Command,
                  prefix: String,
                  service: Arc<Mutex<PadService>>,
                  process_command: fn(Arc<Mutex<PadService>>, Cmd) -> bool,
+                 check_close: fn(rt: Arc<Mutex<PadService>>) -> bool,
+                 close: fn(rt: Arc<Mutex<PadService>>),
     ) -> RuntimeConsole<PadService, Cmd> {
-        RuntimeConsole { command, prefix, service, process_command }
+        RuntimeConsole { command, prefix, service, process_command, check_close, close }
     }
 
     pub fn build_entry(self) -> NoGamepadsService {
         let arc = Arc::new(self);
-
         let entry = async move {
             let console_main = spawn({
                 let console = Arc::clone(&arc);
@@ -43,22 +50,47 @@ impl<PadService: Send + 'static, Cmd: FromArgMatches + 'static> RuntimeConsole<P
     async fn console_main(self: Arc<RuntimeConsole<PadService, Cmd>>) {
         let prefix_uppercase = self.prefix.to_uppercase();
         let prefix_lowercase = self.prefix.to_lowercase();
+        let mut confirm_close = false;
 
         loop {
-            let option : Option<Cmd> = read_cli(
-                format!("{}> ", prefix_uppercase),
-                &prefix_lowercase,
-                self.command.clone()
-            ).await;
-            match option {
-                None => {}
-                Some(cmd) => {
-                    if !(self.process_command)(Arc::clone(&self.service), cmd) {
+            select! {
+                // Auto check
+                _ = Self::auto_check_close(self.clone()) => { break; },
+
+                // Ctrl + C
+                _ = ctrl_c() => {
+                    if !confirm_close {
+                        warn!("To close the process, press Ctrl + C again.");
+                        confirm_close = true;
+                    } else {
+                        (self.close)(self.service.clone());
                         break;
                     }
                 }
+
+                // Command Line
+                option = read_cli(
+                    format!("{}> ", prefix_uppercase),
+                    &prefix_lowercase,
+                    self.command.clone()
+                ) => {
+                    match option {
+                        None => {}
+                        Some(cmd) => {
+                            confirm_close = false;
+                            if !(self.process_command)(Arc::clone(&self.service), cmd) { break; }
+                        }
+                    }
+                }
             }
         }
         info!("[Console] Shutdown.")
     }
+
+    async fn auto_check_close(self: Arc<RuntimeConsole<PadService, Cmd>>) {
+        loop {
+            sleep(Duration::from_secs(1)).await;
+            if (self.check_close)(Arc::clone(&self.service)) { break; }
+        }
+    }
 }
\ No newline at end of file