Merge branch 'auto_device_detect' into for_webui

# Conflicts:
#	src-python/config.py

requirements.txt

@@ -16,5 +16,5 @@ psutil==5.9.8
 pykakasi==2.3.0
 pycaw==20240210
 translators @ git+https://github.com/misyaguziya/translators@5.9.2.1
-SpeechRecognition @ git+https://github.com/misyaguziya/custom_speech_recognition@3.10.4
+SpeechRecognition @ git+https://github.com/misyaguziya/custom_speech_recognition@3.10.4.1
 tinyoscquery @ git+https://github.com/cyberkitsune/tinyoscquery@0.1.2

src-python/config.py

@@ -3,7 +3,8 @@ import inspect
 from os import path as os_path, makedirs as os_makedirs
 from json import load as json_load
 from json import dump as json_dump
-from models.transcription.transcription_utils import device_manager
+
+from device_manager import device_manager
 from models.transcription.transcription_languages import transcription_lang
 from utils import generatePercentageStringsList, isUniqueStrings
 

src-python/device_manager.py

@@ -4,6 +4,7 @@ import comtypes
 from pyaudiowpatch import PyAudio, paWASAPI
 from pycaw.callbacks import MMNotificationClient
 from pycaw.utils import AudioUtilities
+from utils import printLog
 
 class Client(MMNotificationClient):
     def __init__(self):
@@ -22,8 +23,8 @@ class Client(MMNotificationClient):
     def on_device_state_changed(self, device_id, state):
         self.loop = False
 
-    def on_property_value_changed(self, device_id, key):
+    # def on_property_value_changed(self, device_id, key):
-        self.loop = False
+    #     self.loop = False
 
 class DeviceManager:
     _instance = None
@@ -39,6 +40,7 @@ class DeviceManager:
         self.default_mic_device = {"host": {"name": "NoHost"}, "device": {"name": "NoDevice"}}
         self.speaker_devices = [{"name": "NoDevice"}]
         self.default_speaker_device = {"device": {"name": "NoDevice"}}
+
         self.update()
 
         self.prev_mic_host = [host for host in self.mic_devices]
@@ -47,12 +49,19 @@ class DeviceManager:
         self.prev_speaker_devices = self.speaker_devices
         self.prev_default_speaker_device = self.default_speaker_device
 
+        self.update_flag_default_mic_device = False
+        self.update_flag_default_speaker_device = False
+        self.update_flag_host_list = False
+        self.update_flag_mic_device_list = False
+        self.update_flag_speaker_device_list = False
+
         self.callback_default_mic_device = None
         self.callback_default_speaker_device = None
         self.callback_host_list = None
         self.callback_mic_device_list = None
         self.callback_speaker_device_list = None
-        self.callback_prev_update = None
+        self.callback_process_before_update_devices = None
+        self.callback_process_after_update_devices = None
 
         self.monitoring_flag = False
         self.startMonitoring()
@@ -130,30 +139,59 @@ class DeviceManager:
         self.speaker_devices = buffer_speaker_devices
         self.default_speaker_device = buffer_default_speaker_device
 
+    def checkUpdate(self):
+        if self.prev_default_mic_device["device"]["name"] != self.default_mic_device["device"]["name"]:
+            self.update_flag_default_mic_device = True
+            self.prev_default_mic_device = self.default_mic_device
+        if self.prev_default_speaker_device["device"]["name"] != self.default_speaker_device["device"]["name"]:
+            self.update_flag_default_speaker_device = True
+            self.prev_default_speaker_device = self.default_speaker_device
+        if self.prev_mic_host != [host for host in self.mic_devices]:
+            self.update_flag_host_list = True
+            self.prev_mic_host = [host for host in self.mic_devices]
+        if {key: [device['name'] for device in devices] for key, devices in self.prev_mic_devices.items()} != {key: [device['name'] for device in devices] for key, devices in self.mic_devices.items()}:
+            self.update_flag_mic_device_list = True
+            self.prev_mic_devices = self.mic_devices
+        if [device['name'] for device in self.prev_speaker_devices] != [device['name'] for device in self.speaker_devices]:
+            self.update_flag_speaker_device_list = True
+            self.prev_speaker_devices = self.speaker_devices
+
+        update_flag = (
+            self.update_flag_default_mic_device or
+            self.update_flag_default_speaker_device or
+            self.update_flag_host_list or
+            self.update_flag_mic_device_list or
+            self.update_flag_speaker_device_list
+        )
+        return update_flag
+
     def monitoring(self):
-        comtypes.CoInitialize()
-        cb = Client()
-        enumerator = AudioUtilities.GetDeviceEnumerator()
-        enumerator.RegisterEndpointNotificationCallback(cb)
         try:
             while self.monitoring_flag is True:
                 try:
-                    while cb.loop is True:
+                    comtypes.CoInitialize()
-                        sleep(1)
-                    enumerator.UnregisterEndpointNotificationCallback(cb)
-                    self.runPrevUpdateDevices()
-                    sleep(2)
-                    self.update()
-                    self.noticeDefaultDevice()
-                except Exception:
-                    pass
-                finally:
                     cb = Client()
                     enumerator = AudioUtilities.GetDeviceEnumerator()
                     enumerator.RegisterEndpointNotificationCallback(cb)
-        except Exception:
+                    while cb.loop is True:
-            pass
+                        sleep(1)
-        comtypes.CoUninitialize()
+                    enumerator.UnregisterEndpointNotificationCallback(cb)
+                    comtypes.CoUninitialize()
+                    self.runProcessBeforeUpdateDevices()
+                    sleep(2)
+                    for _ in range(10):
+                        self.update()
+                        if self.checkUpdate():
+                            break
+                        sleep(2)
+                    self.noticeUpdateDevices()
+                    self.runProcessAfterUpdateDevices()
+                except Exception as e:
+                    printLog("Device Monitoring: ", e)
+                finally:
+                    pass
+        except Exception as e:
+            printLog("Device Monitoring End Exception: ", e)
 
     def startMonitoring(self):
         self.monitoring_flag = True
@@ -195,47 +233,57 @@ class DeviceManager:
     def clearCallbackSpeakerDeviceList(self):
         self.callback_speaker_device_list = None
 
-    def setCallbackPrevUpdateDevices(self, callback):
+    def setCallbackProcessBeforeUpdateDevices(self, callback):
-        self.callback_prev_update = callback
+        self.callback_process_before_update_devices = callback
 
-    def clearCallbackPrevUpdateDevices(self):
+    def clearCallbackProcessBeforeUpdateDevices(self):
-        self.callback_prev_update = None
+        self.callback_process_before_update_devices = None
 
-    def runPrevUpdateDevices(self):
+    def runProcessBeforeUpdateDevices(self):
-        self.callback_prev_update()
+        self.callback_process_before_update_devices()
 
-    def noticeDefaultDevice(self):
+    def setCallbackProcessAfterUpdateDevices(self, callback):
-        if self.callback_default_mic_device is not None:
+        self.callback_process_after_update_devices = callback
-            if self.prev_default_mic_device["device"]["name"] != self.default_mic_device["device"]["name"]:
-                self.callback_default_mic_device(self.default_mic_device["host"]["name"], self.default_mic_device["device"]["name"])
-                self.prev_default_mic_device = self.default_mic_device
 
-        if self.callback_default_speaker_device is not None:
+    def clearCallbackProcessAfterUpdateDevices(self):
-            if self.prev_default_speaker_device["device"]["name"] != self.default_speaker_device["device"]["name"]:
+        self.callback_process_after_update_devices = None
-                self.callback_default_speaker_device(self.default_speaker_device["device"]["name"])
-                self.prev_default_speaker_device = self.default_speaker_device
 
-        if self.callback_host_list is not None:
+    def runProcessAfterUpdateDevices(self):
-            if self.prev_mic_host != [host for host in self.mic_devices]:
+        self.callback_process_after_update_devices()
-                self.callback_host_list()
-                self.prev_mic_host = [host for host in self.mic_devices]
 
-        if self.callback_mic_device_list is not None:
+    def noticeUpdateDevices(self):
-            if {key: [device['name'] for device in devices] for key, devices in self.prev_mic_devices.items()} != {key: [device['name'] for device in devices] for key, devices in self.mic_devices.items()}:
+        if self.callback_default_mic_device is not None and self.update_flag_default_mic_device is True:
-                self.callback_mic_device_list()
+            self.setMicDefaultDevice()
-                self.prev_mic_devices = self.mic_devices
+        if self.callback_default_speaker_device is not None and self.update_flag_default_speaker_device is True:
+            self.setSpeakerDefaultDevice()
+        if self.callback_host_list is not None and self.update_flag_host_list is True:
+            self.setMicHostList()
+        if self.callback_mic_device_list is not None and self.update_flag_mic_device_list is True:
+            self.setMicDeviceList()
+        if self.callback_speaker_device_list is not None and self.update_flag_speaker_device_list is True:
+            self.setSpeakerDeviceList()
 
-        if self.callback_speaker_device_list is not None:
+        self.update_flag_default_mic_device = False
-            if [device['name'] for device in self.prev_speaker_devices] != [device['name'] for device in self.speaker_devices]:
+        self.update_flag_default_speaker_device = False
-                self.callback_speaker_device_list()
+        self.update_flag_host_list = False
-                self.prev_speaker_devices = self.speaker_devices
+        self.update_flag_mic_device_list = False
+        self.update_flag_speaker_device_list = False
 
-    def forceSetMicDefaultDevice(self):
+    def setMicDefaultDevice(self):
         self.callback_default_mic_device(self.default_mic_device["host"]["name"], self.default_mic_device["device"]["name"])
 
-    def forceSetSpeakerDefaultDevice(self):
+    def setSpeakerDefaultDevice(self):
         self.callback_default_speaker_device(self.default_speaker_device["device"]["name"])
 
+    def setMicHostList(self):
+        self.callback_host_list()
+
+    def setMicDeviceList(self):
+        self.callback_mic_device_list()
+
+    def setSpeakerDeviceList(self):
+        self.callback_speaker_device_list()
+
     def getMicDevices(self):
         return self.mic_devices
 
@@ -248,6 +296,17 @@ class DeviceManager:
     def getDefaultSpeakerDevice(self):
         return self.default_speaker_device
 
+    def forceUpdateAndSetMicDevices(self):
+        self.update()
+        self.setMicHostList()
+        self.setMicDeviceList()
+        self.setMicDefaultDevice()
+
+    def forceUpdateAndSetSpeakerDevices(self):
+        self.update()
+        self.setSpeakerDeviceList()
+        self.setSpeakerDefaultDevice()
+
 device_manager = DeviceManager()
 
 if __name__ == "__main__":

src-python/model.py

@@ -12,12 +12,15 @@ from queue import Queue
 from threading import Thread
 from requests import get as requests_get
 import webbrowser
-
 from typing import Callable
+
 from flashtext import KeywordProcessor
 from pykakasi import kakasi
+
+from device_manager import device_manager
+from config import config
+
 from models.translation.translation_translator import Translator
-from models.transcription.transcription_utils import device_manager
 from models.osc.osc_tools import sendTyping, sendMessage, receiveOscParameters, getOSCParameterValue
 from models.transcription.transcription_recorder import SelectedMicEnergyAndAudioRecorder, SelectedSpeakerEnergyAndAudioRecorder
 from models.transcription.transcription_recorder import SelectedMicEnergyRecorder, SelectedSpeakerEnergyRecorder
@@ -29,8 +32,6 @@ from models.transcription.transcription_whisper import checkWhisperWeight, downl
 from models.overlay.overlay import Overlay
 from models.overlay.overlay_image import OverlayImage
 
-from config import config
-
 class threadFnc(Thread):
     def __init__(self, fnc, end_fnc=None, daemon=True, *args, **kwargs):
         super(threadFnc, self).__init__(daemon=daemon, target=fnc, *args, **kwargs)
@@ -424,13 +425,8 @@ class Model:
         return result
 
     def startMicTranscript(self, fnc):
-        if config.AUTO_MIC_SELECT is True:
+        mic_host_name = config.SELECTED_MIC_HOST
-            default_device = device_manager.getDefaultMicDevice()
+        mic_device_name = config.SELECTED_MIC_DEVICE
-            mic_host_name = default_device["host"]["name"]
-            mic_device_name = default_device["device"]["name"]
-        else:
-            mic_host_name = config.SELECTED_MIC_HOST
-            mic_device_name = config.SELECTED_MIC_DEVICE
 
         mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}])
         selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
@@ -451,7 +447,7 @@ class Model:
             device=mic_device,
             energy_threshold=config.MIC_THRESHOLD,
             dynamic_energy_threshold=config.MIC_AUTOMATIC_THRESHOLD,
-            record_timeout=record_timeout,
+            phrase_time_limit=record_timeout,
         )
         # self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, mic_energy_queue)
         self.mic_audio_recorder.recordIntoQueue(self.mic_audio_queue, None)
@@ -558,13 +554,8 @@ class Model:
         if isinstance(fnc, Callable):
             self.check_mic_energy_fnc = fnc
 
-        if config.AUTO_MIC_SELECT is True:
+        mic_host_name = config.SELECTED_MIC_HOST
-            default_device = device_manager.getDefaultMicDevice()
+        mic_device_name = config.SELECTED_MIC_DEVICE
-            mic_host_name = default_device["host"]["name"]
-            mic_device_name = default_device["device"]["name"]
-        else:
-            mic_host_name = config.SELECTED_MIC_HOST
-            mic_device_name = config.SELECTED_MIC_DEVICE
 
         mic_device_list = device_manager.getMicDevices().get(mic_host_name, [{"name": "NoDevice"}])
         selected_mic_device = [device for device in mic_device_list if device["name"] == mic_device_name]
@@ -600,14 +591,8 @@ class Model:
             self.mic_energy_recorder = None
 
     def startSpeakerTranscript(self, fnc):
-        if config.AUTO_SPEAKER_SELECT is True:
-            default_device = device_manager.getDefaultSpeakerDevice()
-            speaker_device_name = default_device["device"]["name"]
-        else:
-            speaker_device_name = config.SELECTED_SPEAKER_DEVICE
-
         speaker_device_list = device_manager.getSpeakerDevices()
-        selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
+        selected_speaker_device = [device for device in speaker_device_list if device["name"] == config.SELECTED_SPEAKER_DEVICE]
 
         if len(selected_speaker_device) == 0:
             return False
@@ -624,7 +609,7 @@ class Model:
             device=speaker_device,
             energy_threshold=config.SPEAKER_THRESHOLD,
             dynamic_energy_threshold=config.SPEAKER_AUTOMATIC_THRESHOLD,
-            record_timeout=record_timeout,
+            phrase_time_limit=record_timeout,
         )
         # self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, speaker_energy_queue)
         self.speaker_audio_recorder.recordIntoQueue(speaker_audio_queue, None)
@@ -692,14 +677,8 @@ class Model:
         if isinstance(fnc, Callable):
             self.check_speaker_energy_fnc = fnc
 
-        if config.AUTO_SPEAKER_SELECT is True:
-            default_device = device_manager.getDefaultSpeakerDevice()
-            speaker_device_name = default_device["device"]["name"]
-        else:
-            speaker_device_name = config.SELECTED_SPEAKER_DEVICE
-
         speaker_device_list = device_manager.getSpeakerDevices()
-        selected_speaker_device = [device for device in speaker_device_list if device["name"] == speaker_device_name]
+        selected_speaker_device = [device for device in speaker_device_list if device["name"] == config.SELECTED_SPEAKER_DEVICE]
 
         if len(selected_speaker_device) == 0:
             return False

src-python/models/transcription/transcription_recorder.py

@@ -91,10 +91,12 @@ class SelectedSpeakerEnergyRecorder(BaseEnergyRecorder):
         # self.adjustForNoise()
 
 class BaseEnergyAndAudioRecorder:
-    def __init__(self, source, energy_threshold, dynamic_energy_threshold, record_timeout):
+    def __init__(self, source, energy_threshold, dynamic_energy_threshold, phrase_time_limit, phrase_timeout, record_timeout):
         self.recorder = Recognizer()
         self.recorder.energy_threshold = energy_threshold
         self.recorder.dynamic_energy_threshold = dynamic_energy_threshold
+        self.phrase_time_limit = phrase_time_limit
+        self.phrase_timeout = phrase_timeout
         self.record_timeout = record_timeout
         self.stop = None
 
@@ -117,20 +119,29 @@ class BaseEnergyAndAudioRecorder:
         self.stop, self.pause, self.resume = self.recorder.listen_energy_and_audio_in_background(
             source=self.source,
             callback=audioRecordCallback,
-            phrase_time_limit=self.record_timeout,
+            phrase_time_limit=self.phrase_time_limit,
-            callback_energy=energyRecordCallback if energy_queue is not None else None)
+            callback_energy=energyRecordCallback if energy_queue is not None else None,
+            phrase_timeout=self.phrase_timeout,
+            record_timeout=self.record_timeout)
 
 class SelectedMicEnergyAndAudioRecorder(BaseEnergyAndAudioRecorder):
-    def __init__(self, device, energy_threshold, dynamic_energy_threshold, record_timeout):
+    def __init__(self, device, energy_threshold, dynamic_energy_threshold, phrase_time_limit, phrase_timeout:int=1, record_timeout:int=5):
         source=Microphone(
             device_index=device['index'],
             sample_rate=int(device["defaultSampleRate"]),
         )
-        super().__init__(source=source, energy_threshold=energy_threshold, dynamic_energy_threshold=dynamic_energy_threshold, record_timeout=record_timeout)
+        super().__init__(
+            source=source,
+            energy_threshold=energy_threshold,
+            dynamic_energy_threshold=dynamic_energy_threshold,
+            phrase_time_limit=phrase_time_limit,
+            phrase_timeout=phrase_timeout,
+            record_timeout=record_timeout,
+        )
         # self.adjustForNoise()
 
 class SelectedSpeakerEnergyAndAudioRecorder(BaseEnergyAndAudioRecorder):
-    def __init__(self, device, energy_threshold, dynamic_energy_threshold, record_timeout):
+    def __init__(self, device, energy_threshold, dynamic_energy_threshold, phrase_time_limit, phrase_timeout:int=1, record_timeout:int=5):
 
         source = Microphone(speaker=True,
             device_index= device["index"],
@@ -138,5 +149,12 @@ class SelectedSpeakerEnergyAndAudioRecorder(BaseEnergyAndAudioRecorder):
             chunk_size=get_sample_size(paInt16),
             channels=device["maxInputChannels"]
         )
-        super().__init__(source=source, energy_threshold=energy_threshold, dynamic_energy_threshold=dynamic_energy_threshold, record_timeout=record_timeout)
+        super().__init__(
+            source=source,
+            energy_threshold=energy_threshold,
+            dynamic_energy_threshold=dynamic_energy_threshold,
+            phrase_time_limit=phrase_time_limit,
+            phrase_timeout=phrase_timeout,
+            record_timeout=record_timeout,
+        )
         # self.adjustForNoise()

src-python/webui_controller.py

@@ -3,16 +3,16 @@ from time import sleep
 from subprocess import Popen
 from threading import Thread
 import re
+from device_manager import device_manager
 from config import config
 from model import model
 from utils import isUniqueStrings, printLog
-from models.transcription.transcription_utils import device_manager
 
 class Controller:
     def __init__(self) -> None:
         self.run_mapping = {}
         self.run = None
-        self.transcription_access_status = True
+        self.device_access_status = True
 
     def setRunMapping(self, run_mapping:dict) -> None:
         self.run_mapping = run_mapping
@@ -56,11 +56,25 @@ class Controller:
             model.getListSpeakerDevice(),
         )
 
-    def prevUpdateSelectedDevices(self) -> None:
+    def restartAccessDevices(self) -> None:
         if config.ENABLE_TRANSCRIPTION_SEND is True:
-            model.stopMicTranscript()
+            self.startThreadingTranscriptionSendMessage()
         if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
-            model.stopSpeakerTranscript()
+            self.startThreadingTranscriptionReceiveMessage()
+        if config.ENABLE_CHECK_ENERGY_SEND is True:
+            model.startCheckMicEnergy(
+                self.progressBarMicEnergy,
+            )
+        if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
+            model.startCheckSpeakerEnergy(
+                self.progressBarSpeakerEnergy,
+            )
+
+    def stopAccessDevices(self) -> None:
+        if config.ENABLE_TRANSCRIPTION_SEND is True:
+            self.stopThreadingTranscriptionSendMessage()
+        if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
+            self.stopThreadingTranscriptionReceiveMessage()
         if config.ENABLE_CHECK_ENERGY_SEND is True:
             model.stopCheckMicEnergy()
         if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
@@ -69,10 +83,6 @@ class Controller:
     def updateSelectedMicDevice(self, host, device) -> None:
         config.SELECTED_MIC_HOST = host
         config.SELECTED_MIC_DEVICE = device
-        if config.ENABLE_TRANSCRIPTION_SEND is True:
-            model.startMicTranscript()
-        if config.ENABLE_CHECK_ENERGY_SEND is True:
-            model.startCheckMicEnergy()
         self.run(
             200,
             self.run_mapping["selected_mic_device"],
@@ -81,10 +91,6 @@ class Controller:
 
     def updateSelectedSpeakerDevice(self, device) -> None:
         config.SELECTED_SPEAKER_DEVICE = device
-        if config.ENABLE_TRANSCRIPTION_RECEIVE is True:
-            model.startSpeakerTranscript()
-        if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
-            model.startCheckSpeakerEnergy()
         self.run(
             200,
             self.run_mapping["selected_speaker_device"],
@@ -599,16 +605,17 @@ class Controller:
 
     def setEnableAutoMicSelect(self, *args, **kwargs) -> dict:
         config.AUTO_MIC_SELECT = True
-        device_manager.setCallbackPrevUpdateDevices(self.prevUpdateSelectedDevices)
+        device_manager.setCallbackProcessBeforeUpdateDevices(self.stopAccessDevices)
         device_manager.setCallbackDefaultMicDevice(self.updateSelectedMicDevice)
-        device_manager.noticeDefaultDevice()
+        device_manager.setCallbackProcessAfterUpdateDevices(self.restartAccessDevices)
-        device_manager.forceSetMicDefaultDevice()
+        device_manager.forceUpdateAndSetMicDevices()
         return {"status":200, "result":config.AUTO_MIC_SELECT}
 
     @staticmethod
     def setDisableAutoMicSelect(*args, **kwargs) -> dict:
-        device_manager.clearCallbackPrevUpdateDevices()
+        device_manager.clearCallbackProcessBeforeUpdateDevices()
         device_manager.clearCallbackDefaultMicDevice()
+        device_manager.clearCallbackProcessAfterUpdateDevices()
         config.AUTO_MIC_SELECT = False
         return {"status":200, "result":config.AUTO_MIC_SELECT}
 
@@ -616,13 +623,12 @@ class Controller:
     def getSelectedMicHost(*args, **kwargs) -> dict:
         return {"status":200, "result":config.SELECTED_MIC_HOST}
 
-    @staticmethod
+    def setSelectedMicHost(self, data, *args, **kwargs) -> dict:
-    def setSelectedMicHost(data, *args, **kwargs) -> dict:
         config.SELECTED_MIC_HOST = data
         config.SELECTED_MIC_DEVICE = model.getMicDefaultDevice()
         if config.ENABLE_CHECK_ENERGY_SEND is True:
-            model.stopCheckMicEnergy()
+            self.stopThreadingCheckMicEnergy()
-            model.startCheckMicEnergy()
+            self.startThreadingTranscriptionSendMessage()
         return {"status":200,
                 "result":{
                     "host":config.SELECTED_MIC_HOST,
@@ -634,12 +640,11 @@ class Controller:
     def getSelectedMicDevice(*args, **kwargs) -> dict:
         return {"status":200, "result":config.SELECTED_MIC_DEVICE}
 
-    @staticmethod
+    def setSelectedMicDevice(self, data, *args, **kwargs) -> dict:
-    def setSelectedMicDevice(data, *args, **kwargs) -> dict:
         config.SELECTED_MIC_DEVICE = data
         if config.ENABLE_CHECK_ENERGY_SEND is True:
-            model.stopCheckMicEnergy()
+            self.stopThreadingCheckMicEnergy()
-            model.startCheckMicEnergy()
+            self.startThreadingTranscriptionSendMessage()
         return {"status":200, "result": config.SELECTED_MIC_DEVICE}
 
     @staticmethod
@@ -784,16 +789,18 @@ class Controller:
 
     def setEnableAutoSpeakerSelect(self, *args, **kwargs) -> dict:
         config.AUTO_SPEAKER_SELECT = True
-        device_manager.setCallbackPrevUpdateDevices(self.prevUpdateSelectedDevices)
+        device_manager.setCallbackProcessBeforeUpdateDevices(self.stopAccessDevices)
         device_manager.setCallbackDefaultSpeakerDevice(self.updateSelectedSpeakerDevice)
-        device_manager.noticeDefaultDevice()
+        device_manager.setCallbackProcessAfterUpdateDevices(self.restartAccessDevices)
-        device_manager.forceSetSpeakerDefaultDevice()
+        device_manager.forceUpdateAndSetSpeakerDevices()
+
         return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
 
     @staticmethod
     def setDisableAutoSpeakerSelect(*args, **kwargs) -> dict:
-        device_manager.clearCallbackPrevUpdateDevices()
+        device_manager.clearCallbackProcessBeforeUpdateDevices()
         device_manager.clearCallbackDefaultSpeakerDevice()
+        device_manager.clearCallbackProcessAfterUpdateDevices()
         config.AUTO_SPEAKER_SELECT = False
         return {"status":200, "result":config.AUTO_SPEAKER_SELECT}
 
@@ -801,12 +808,11 @@ class Controller:
     def getSelectedSpeakerDevice(*args, **kwargs) -> dict:
         return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE}
 
-    @staticmethod
+    def setSelectedSpeakerDevice(self, data, *args, **kwargs) -> dict:
-    def setSelectedSpeakerDevice(data, *args, **kwargs) -> dict:
         config.SELECTED_SPEAKER_DEVICE = data
         if config.ENABLE_CHECK_ENERGY_RECEIVE is True:
-            model.stopCheckSpeakerEnergy()
+            self.stopThreadingCheckSpeakerEnergy()
-            model.startCheckSpeakerEnergy()
+            self.startThreadingTranscriptionReceiveMessage()
         return {"status":200, "result":config.SELECTED_SPEAKER_DEVICE}
 
     @staticmethod
@@ -1264,28 +1270,22 @@ class Controller:
         return {"status":200, "result":config.VRC_MIC_MUTE_SYNC}
 
     def setEnableCheckSpeakerThreshold(self, *args, **kwargs) -> dict:
-        model.startCheckSpeakerEnergy(
+        self.startThreadingCheckSpeakerEnergy()
-            self.progressBarSpeakerEnergy,
-        )
         config.ENABLE_CHECK_ENERGY_RECEIVE = True
         return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE}
 
-    @staticmethod
+    def setDisableCheckSpeakerThreshold(self, *args, **kwargs) -> dict:
-    def setDisableCheckSpeakerThreshold(*args, **kwargs) -> dict:
+        self.stopThreadingCheckSpeakerEnergy()
-        model.stopCheckSpeakerEnergy()
         config.ENABLE_CHECK_ENERGY_RECEIVE = False
         return {"status":200, "result":config.ENABLE_CHECK_ENERGY_RECEIVE}
 
     def setEnableCheckMicThreshold(self, *args, **kwargs) -> dict:
-        model.startCheckMicEnergy(
+        self.startThreadingCheckMicEnergy()
-            self.progressBarMicEnergy,
-        )
         config.ENABLE_CHECK_ENERGY_SEND = True
         return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND}
 
-    @staticmethod
+    def setDisableCheckMicThreshold(self, *args, **kwargs) -> dict:
-    def setDisableCheckMicThreshold(*args, **kwargs) -> dict:
+        self.stopThreadingCheckMicEnergy()
-        model.stopCheckMicEnergy()
         config.ENABLE_CHECK_ENERGY_SEND = False
         return {"status":200, "result":config.ENABLE_CHECK_ENERGY_SEND}
 
@@ -1399,11 +1399,11 @@ class Controller:
         self.run(200, self.run_mapping["translation_engines"], "CTranslate2")
 
     def startTranscriptionSendMessage(self) -> None:
-        while self.transcription_access_status is False:
+        while self.device_access_status is False:
             sleep(1)
-        self.transcription_access_status = False
+        self.device_access_status = False
         model.startMicTranscript(self.micMessage)
-        self.transcription_access_status = True
+        self.device_access_status = True
 
     @staticmethod
     def stopTranscriptionSendMessage() -> None:
@@ -1421,11 +1421,11 @@ class Controller:
         th_stopTranscriptionSendMessage.join()
 
     def startTranscriptionReceiveMessage(self) -> None:
-        while self.transcription_access_status is False:
+        while self.device_access_status is False:
             sleep(1)
-        self.transcription_access_status = False
+        self.device_access_status = False
         model.startSpeakerTranscript(self.speakerMessage)
-        self.transcription_access_status = True
+        self.device_access_status = True
 
     @staticmethod
     def stopTranscriptionReceiveMessage() -> None:
@@ -1491,6 +1491,48 @@ class Controller:
         self.run(200, self.run_mapping["selected_translation_engines"], config.SELECTED_TRANSLATION_ENGINES)
         self.run(200, self.run_mapping["translation_engines"], engines)
 
+    def startCheckMicEnergy(self) -> None:
+        while self.device_access_status is False:
+            sleep(1)
+        self.device_access_status = False
+        model.startCheckMicEnergy(self.progressBarMicEnergy)
+        self.device_access_status = True
+
+    def startThreadingCheckMicEnergy(self) -> None:
+        th_startCheckMicEnergy = Thread(target=self.startCheckMicEnergy)
+        th_startCheckMicEnergy.daemon = True
+        th_startCheckMicEnergy.start()
+
+    def stopCheckMicEnergy(self) -> None:
+        model.stopCheckMicEnergy()
+
+    def stopThreadingCheckMicEnergy(self) -> None:
+        th_stopCheckMicEnergy = Thread(target=self.stopCheckMicEnergy)
+        th_stopCheckMicEnergy.daemon = True
+        th_stopCheckMicEnergy.start()
+        th_stopCheckMicEnergy.join()
+
+    def startCheckSpeakerEnergy(self) -> None:
+        while self.device_access_status is False:
+            sleep(1)
+        self.device_access_status = False
+        model.startCheckSpeakerEnergy(self.progressBarSpeakerEnergy)
+        self.device_access_status = True
+
+    def startThreadingCheckSpeakerEnergy(self) -> None:
+        th_startCheckSpeakerEnergy = Thread(target=self.startCheckSpeakerEnergy)
+        th_startCheckSpeakerEnergy.daemon = True
+        th_startCheckSpeakerEnergy.start()
+
+    def stopCheckSpeakerEnergy(self) -> None:
+        model.stopCheckSpeakerEnergy()
+
+    def stopThreadingCheckSpeakerEnergy(self) -> None:
+        th_stopCheckSpeakerEnergy = Thread(target=self.stopCheckSpeakerEnergy)
+        th_stopCheckSpeakerEnergy.daemon = True
+        th_stopCheckSpeakerEnergy.start()
+        th_stopCheckSpeakerEnergy.join()
+
     @staticmethod
     def startThreadingDownloadCtranslate2Weight(callback:Callable[[float], None]) -> None:
         th_download = Thread(target=model.downloadCTranslate2ModelWeight, args=(callback,))
@@ -1556,6 +1598,10 @@ class Controller:
             model.startCheckMuteSelfStatus()
 
         # init Auto device selection
+        device_manager.setCallbackHostList(self.updateMicHostList)
+        device_manager.setCallbackMicDeviceList(self.updateMicDeviceList)
+        device_manager.setCallbackSpeakerDeviceList(self.updateSpeakerDeviceList)
+
         printLog("Init Auto Device Selection")
         if config.AUTO_MIC_SELECT is True:
             self.setEnableAutoMicSelect()
@@ -1563,8 +1609,4 @@ class Controller:
         if config.AUTO_SPEAKER_SELECT is True:
             self.setEnableAutoSpeakerSelect()
 
-        device_manager.setCallbackHostList(self.updateMicHostList)
-        device_manager.setCallbackMicDeviceList(self.updateMicDeviceList)
-        device_manager.setCallbackSpeakerDeviceList(self.updateSpeakerDeviceList)
-
         printLog("End Initialization")