python-audio-autotest-3.10 1.5.12rc0__py3-none-any.whl → 1.5.12rc3__py3-none-any.whl

pyaatlibs/audioworker.py

@@ -10,6 +10,7 @@ from pyaatlibs.adbutils import Adb
 from pyaatlibs.appinterface import AppInterface
 from pyaatlibs.audiofunction import DetectionStateListener
 
+
 # from Android SDK 32
 class RecordInputSrc(IntEnum):
     DEFAULT = 0
@@ -24,18 +25,21 @@ class RecordInputSrc(IntEnum):
     UNPROCESSED = auto()
     VOICE_PERFORMANCE = auto()
 
+
 # align with audioworker
 class RecordPerf(IntEnum):
     NONE = 10
     POWER_SAVING = auto()
     LOW_LATENCY = auto()
 
+
 # align with audioworker
 class RecordApi(IntEnum):
     NONE = 0
     OPENSLES = auto()
     AAUDIO = auto()
 
+
 class PlaybackStream(IntEnum):
     VOICE_CALL = 0
     SYSTEM = auto()
@@ -46,6 +50,7 @@ class PlaybackStream(IntEnum):
     DTMF = 8
     ACCESSIBILITY = 10
 
+
 class PlaybackContentType(IntEnum):
     UNKNOWN = 0
     SPEECH = auto()
@@ -54,6 +59,7 @@ class PlaybackContentType(IntEnum):
     SONIFICATION = auto()
     ULTRASOUND = 1997
 
+
 class PlaybackUsage(IntEnum):
     UNKNOWN = 0
     MEDIA = auto()
@@ -69,20 +75,23 @@ class PlaybackUsage(IntEnum):
     GAME = auto()
     ASSISTANT = auto()
 
+
 class PlaybackPerformanceMode(IntEnum):
     NOT_SET = -1
     NONE = auto()
     LOW_LATENCY = auto()
     POWER_SAVING = auto()
 
+
 class TaskIndex(IntEnum):
     ALL = -1
 
+
 class AudioWorkerApp(AppInterface):
     TAG = "AudioWorkerApp"
     APK_PATHS = [
         os.path.join(ROOT_DIR, "apk", "debug", "audioworker.apk"),
-        os.path.join(os.path.dirname(os.path.realpath(__file__)), "apk", "audioworker.apk")
+        os.path.join(os.path.dirname(os.path.realpath(__file__)), "apk", "audioworker.apk"),
     ]
     INTENT_PREFIX = "am broadcast -a"
     AUDIOWORKER_INTENT_PREFIX = "com.google.audioworker.intent."
@@ -90,7 +99,9 @@ class AudioWorkerApp(AppInterface):
     PACKAGE = "com.google.audioworker"
     MAINACTIVITY = ".activities.MainActivity"
 
-    DATA_FOLDER = "/storage/emulated/0/Google-AudioWorker-data"
+    DATA_FOLDER = (
+        "/storage/emulated/0/Android/data/com.google.audioworker/files/Google-AudioWorker-data"
+    )
 
     @staticmethod
     def get_apk_path():
@@ -98,11 +109,16 @@ class AudioWorkerApp(AppInterface):
             if os.path.exists(path):
                 return path
 
-        raise(RuntimeError("no apk file is found."))
+        raise (RuntimeError("no apk file is found."))
 
     @staticmethod
     def get_apk_version():
-        return "eb3a3d5-python-audio-autotest-v1.5.12"
+        out = subprocess.check_output(["strings", __class__.get_apk_path()], text=True)
+        for line in out.splitlines():
+            if "python-audio-autotest" not in line:
+                continue
+            return line.strip().replace("%", "")
+        return None
 
     @staticmethod
     def get_version_from_device(serialno=None):
@@ -112,16 +128,28 @@ class AudioWorkerApp(AppInterface):
 
         out, _ = Adb.execute(
             ["shell", "dumpsys package com.google.audioworker | grep versionName"],
-            serialno=serialno)
+            serialno=serialno,
+        )
+
+        version_from_device = out.strip().partition("versionName=")[-1]
+        version_from_apk = __class__.get_apk_version()
+        if version_from_device != version_from_apk:
+            __class__.log(
+                "get_version_from_device: the version got from package manager and from apk file"
+                f" don't match. (version_from_device: {version_from_device}, version_from_apk:"
+                f" {version_from_apk})"
+            )
 
-        return out.strip().partition("versionName=")[-1]
+        return version_from_device
 
     @classmethod
     def install(child, grant=False, serialno=None, tolog=True):
         super().install(grant=grant, serialno=serialno, tolog=tolog)
         __class__.log(
             "install: the installed version is '{}'".format(
-                __class__.get_version_from_device(serialno=serialno)))
+                __class__.get_version_from_device(serialno=serialno)
+            )
+        )
 
     @staticmethod
     def get_launch_component():
@@ -146,7 +174,7 @@ class AudioWorkerApp(AppInterface):
         ack_funcs = [
             __class__.playback_info,
             __class__.record_info,
-            __class__.voip_info
+            __class__.voip_info,
         ]
 
         for func in ack_funcs:
@@ -177,16 +205,25 @@ class AudioWorkerApp(AppInterface):
                 cmd_arr += ["--es", key]
             cmd_arr.append(str(value))
 
-        __class__.device_shell(
-            device=device, serialno=serialno, cmd=" ".join(cmd_arr), tolog=tolog)
+        __class__.device_shell(device=device, serialno=serialno, cmd=" ".join(cmd_arr), tolog=tolog)
 
     @staticmethod
     def playback_nonoffload(
-        device=None, serialno=None,
-        freqs=[440.], playback_id=0, file="null",
-        stream_type=PlaybackStream.MUSIC, performance_mode=PlaybackPerformanceMode.NOT_SET,
-        content_type=PlaybackContentType.MUSIC, usage=PlaybackUsage.MEDIA,
-        fs=16000, nch=2, amp=0.6, bit_depth=16, low_latency_mode=False):
+        device=None,
+        serialno=None,
+        freqs=[440.0],
+        playback_id=0,
+        file="null",
+        stream_type=PlaybackStream.MUSIC,
+        performance_mode=PlaybackPerformanceMode.NOT_SET,
+        content_type=PlaybackContentType.MUSIC,
+        usage=PlaybackUsage.MEDIA,
+        fs=16000,
+        nch=2,
+        amp=0.6,
+        bit_depth=16,
+        low_latency_mode=False,
+    ):
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "playback.start"
         configs = {
             "type": "non-offload",
@@ -201,7 +238,7 @@ class AudioWorkerApp(AppInterface):
             "stream-type": stream_type,
             "usage": usage,
             "content-type": content_type,
-            "performance-mode": performance_mode
+            "performance-mode": performance_mode,
         }
         __class__.send_intent(device, serialno, name, configs)
 
@@ -211,15 +248,25 @@ class AudioWorkerApp(AppInterface):
         configs = {
             "type": "non-offload",
             "playback-id": playback_id,
-            "seek-position-ms" : seek_position_ms
+            "seek-position-ms": seek_position_ms,
         }
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
     def playback_offload(
-        device=None, serialno=None, file="null", stream_type=PlaybackStream.MUSIC,
-        content_type=PlaybackContentType.MUSIC, usage=PlaybackUsage.MEDIA,
-        freqs=[440.], playback_id=0, fs=16000, nch=2, amp=0.6, bit_depth=16):
+        device=None,
+        serialno=None,
+        file="null",
+        stream_type=PlaybackStream.MUSIC,
+        content_type=PlaybackContentType.MUSIC,
+        usage=PlaybackUsage.MEDIA,
+        freqs=[440.0],
+        playback_id=0,
+        fs=16000,
+        nch=2,
+        amp=0.6,
+        bit_depth=16,
+    ):
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "playback.start"
         configs = {
             "type": "offload",
@@ -242,13 +289,19 @@ class AudioWorkerApp(AppInterface):
         configs = {
             "type": "offload",
             "playback-id": playback_id,
-            "seek-position-ms" : seek_position_ms
+            "seek-position-ms": seek_position_ms,
         }
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
     def _common_info(
-        device=None, serialno=None, ctype=None, controller=None, tolog=False, extra_params={}):
+        device=None,
+        serialno=None,
+        ctype=None,
+        controller=None,
+        tolog=False,
+        extra_params={},
+    ):
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "{}.info".format(ctype)
         ts = datetime.datetime.timestamp(datetime.datetime.now())
         ts = int(ts * 1000)
@@ -261,7 +314,8 @@ class AudioWorkerApp(AppInterface):
         retry = 10
         while retry > 0:
             out, err = __class__.device_shell(
-                None, serialno, cmd="cat {}".format(filepath), tolog=tolog)
+                None, serialno, cmd="cat {}".format(filepath), tolog=tolog
+            )
             if len(out) == 0:
                 time.sleep(0.5)
                 retry -= 1
@@ -276,8 +330,9 @@ class AudioWorkerApp(AppInterface):
             return {}
 
         import traceback
+
         try:
-            info_timestamp = float(out[0].strip().split("::")[1]) / 1000.
+            info_timestamp = float(out[0].strip().split("::")[-1]) / 1000.0
             info_t = datetime.datetime.fromtimestamp(info_timestamp)
             # if (datetime.datetime.now() - info_t).total_seconds() > 1:
             #     return None
@@ -290,7 +345,8 @@ class AudioWorkerApp(AppInterface):
     @staticmethod
     def playback_info(device=None, serialno=None, tolog=False):
         return __class__._common_info(
-            device, serialno, "playback", "PlaybackController", tolog=tolog)
+            device, serialno, "playback", "PlaybackController", tolog=tolog
+        )
 
     @staticmethod
     def playback_stop(device=None, serialno=None, tolog=False):
@@ -301,18 +357,20 @@ class AudioWorkerApp(AppInterface):
 
         for pbtype in info.keys():
             for pbid in info[pbtype].keys():
-                configs = {
-                    "type": pbtype,
-                    "playback-id": int(pbid)
-                }
+                configs = {"type": pbtype, "playback-id": int(pbid)}
                 __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
     def record_info(device=None, serialno=None, task_index=TaskIndex.ALL, tolog=False):
         task_index = int(task_index)
         info = __class__._common_info(
-            device, serialno, "record", "RecordController",
-            extra_params={"task-index": task_index}, tolog=tolog)
+            device,
+            serialno,
+            "record",
+            "RecordController",
+            extra_params={"task-index": task_index},
+            tolog=tolog,
+        )
         if info == None:
             return None
 
@@ -334,11 +392,7 @@ class AudioWorkerApp(AppInterface):
 
         task_index = int(task_index)
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "{}.detect.register".format(prefix)
-        configs = {
-            "class": dclass,
-            "params": params,
-            "task-index": task_index
-        }
+        configs = {"class": dclass, "params": params, "task-index": task_index}
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
@@ -348,10 +402,7 @@ class AudioWorkerApp(AppInterface):
 
         task_index = int(task_index)
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "{}.detect.unregister".format(prefix)
-        configs = {
-            "class-handle": chandle,
-            "task-index": task_index
-        }
+        configs = {"class-handle": chandle, "task-index": task_index}
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
@@ -375,17 +426,23 @@ class AudioWorkerApp(AppInterface):
 
         task_index = int(task_index)
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "{}.detect.setparams".format(prefix)
-        configs = {
-            "class-handle": chandle,
-            "params": params,
-            "task-index": task_index
-        }
+        configs = {"class-handle": chandle, "params": params, "task-index": task_index}
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
     def record_start(
-        device=None, serialno=None, fs=16000, nch=2, bit_depth=16, btsco_on=True,
-        perf=None, input_src=None, api=None, dump_buffer_ms=1000, task_index=0):
+        device=None,
+        serialno=None,
+        fs=16000,
+        nch=2,
+        bit_depth=16,
+        btsco_on=True,
+        perf=None,
+        input_src=None,
+        api=None,
+        dump_buffer_ms=1000,
+        task_index=0,
+    ):
         task_index = int(task_index)
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "record.start"
         configs = {
@@ -397,7 +454,7 @@ class AudioWorkerApp(AppInterface):
             "audio-perf": int(perf) if perf is not None else perf,
             "audio-api": int(api) if api is not None else api,
             "dump-buffer-ms": dump_buffer_ms,
-            "task-index" : task_index
+            "task-index": task_index,
         }
         __class__.send_intent(device, serialno, name, configs)
 
@@ -438,7 +495,8 @@ class AudioWorkerApp(AppInterface):
 
     @staticmethod
     def record_detector_set_params(
-        device=None, serialno=None, chandle=None, params={}, task_index=0):
+        device=None, serialno=None, chandle=None, params={}, task_index=0
+    ):
         __class__.tx_detector_set_params("record", device, serialno, chandle, params, task_index)
 
     @staticmethod
@@ -446,8 +504,21 @@ class AudioWorkerApp(AppInterface):
         return __class__._common_info(device, serialno, "voip", "VoIPController", tolog=tolog)
 
     @staticmethod
-    def voip_start(device=None, serialno=None, rxfreq=440., rxamp=0.6, rxspkr=False, rxfile="null",
-        rxfs=8000, txfs=8000, rxnch=1, txnch=1, rxbit_depth=16, txbit_depth=16, dump_buffer_ms=0):
+    def voip_start(
+        device=None,
+        serialno=None,
+        rxfreq=440.0,
+        rxamp=0.6,
+        rxspkr=False,
+        rxfile="null",
+        rxfs=8000,
+        txfs=8000,
+        rxnch=1,
+        txnch=1,
+        rxbit_depth=16,
+        txbit_depth=16,
+        dump_buffer_ms=0,
+    ):
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "voip.start"
         configs = {
             "rx-target-freq": rxfreq,
@@ -460,7 +531,7 @@ class AudioWorkerApp(AppInterface):
             "tx-sampling-freq": txfs,
             "tx-num-channels": txnch,
             "tx-pcm-bit-width": txbit_depth,
-            "tx-dump-buffer-ms": dump_buffer_ms
+            "tx-dump-buffer-ms": dump_buffer_ms,
         }
         __class__.send_intent(device, serialno, name, configs)
 
@@ -472,9 +543,7 @@ class AudioWorkerApp(AppInterface):
     @staticmethod
     def voip_use_speaker(device=None, serialno=None, use=True):
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "voip.config"
-        configs = {
-            "rx-use-spkr": use
-        }
+        configs = {"rx-use-spkr": use}
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
@@ -484,10 +553,7 @@ class AudioWorkerApp(AppInterface):
     @staticmethod
     def voip_change_configs(device=None, serialno=None, rxfreq=-1, rxamp=-1):
         name = __class__.AUDIOWORKER_INTENT_PREFIX + "voip.config"
-        configs = {
-            "rx-target-freq": rxfreq,
-            "rx-amplitude": rxamp
-        }
+        configs = {"rx-target-freq": rxfreq, "rx-amplitude": rxamp}
         __class__.send_intent(device, serialno, name, configs)
 
     @staticmethod
@@ -530,13 +596,24 @@ from pyaatlibs.audiofunction import ToneDetectorThread, ToneDetector
 from pyaatlibs.aatapp import AATAppToneDetectorThread
 from pyaatlibs.logger import Logger
 
+
 class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
-    def __init__(self, serialno, target_freq,
-        detector_reg_func, detector_unreg_func,
-        detector_setparams_func, info_func, parse_detector_func,
-        callback=None, listener=None):
+
+    def __init__(
+        self,
+        serialno,
+        target_freq,
+        detector_reg_func,
+        detector_unreg_func,
+        detector_setparams_func,
+        info_func,
+        parse_detector_func,
+        callback=None,
+        listener=None,
+    ):
         super(AudioWorkerToneDetectorThread, self).__init__(
-            serialno=serialno, target_freq=target_freq, callback=callback)
+            serialno=serialno, target_freq=target_freq, callback=callback
+        )
         self.serialno = serialno
         self.chandle = None
         self.listener = listener
@@ -545,8 +622,11 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
         self.detector_setparams_func = detector_setparams_func
         self.info_func = info_func
         self.parse_detector_func = parse_detector_func
-        self.detector_reg_func(serialno=serialno,
-            dclass="ToneDetector", params={"target-freq": [target_freq]})
+        self.detector_reg_func(
+            serialno=serialno,
+            dclass="ToneDetector",
+            params={"target-freq": [target_freq]},
+        )
 
     def get_tag(self):
         return "AudioWorkerToneDetectorThread"
@@ -651,7 +731,9 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
         info = self.info_func(serialno=self.serialno)
         if not info:
             Logger.log(
-                "{}::get_info".format(self.get_tag()), "no active record, null info returned")
+                "{}::get_info".format(self.get_tag()),
+                "no active record, null info returned",
+            )
             return
 
         detectors = self.parse_detector_func(info)
@@ -664,7 +746,8 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
             if chandle:
                 Logger.log(
                     "{}::get_info".format(self.get_tag()),
-                    "found detector handle: {} for target {} Hz".format(chandle, self.target_freq))
+                    "found detector handle: {} for target {} Hz".format(chandle, self.target_freq),
+                )
 
         if not chandle:
             Logger.log("{}::get_info".format(self.get_tag()), "no detector handle!")
@@ -678,14 +761,22 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
             return
 
         self.detector_setparams_func(
-            serialno=self.serialno, chandle=self.chandle,
-            params={"dump-history": str(enable).lower()})
+            serialno=self.serialno,
+            chandle=self.chandle,
+            params={"dump-history": str(enable).lower()},
+        )
 
     def set_target_frequency(self, target_freq):
         self.target_freq = target_freq
         self.detector_setparams_func(
-            serialno=self.serialno, chandle=self.chandle,
-            params={"target-freq": [target_freq], "clear-target": "false", "dump-history": "true"})
+            serialno=self.serialno,
+            chandle=self.chandle,
+            params={
+                "target-freq": [target_freq],
+                "clear-target": "false",
+                "dump-history": "true",
+            },
+        )
         self.shared_vars["msg"] = None
 
     def run(self):
@@ -695,7 +786,7 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
             "last_state": None,
             "msg": None,
             "tictoc": TicToc(),
-            "state_keep_ms": 0
+            "state_keep_ms": 0,
         }
 
         self.extra = {}
@@ -709,15 +800,14 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
         def freq_cb(msg):
             line = msg.splitlines()[0].strip()
             strs = line.split()
-            t = datetime.datetime.fromtimestamp(float(strs[0][:-1]) / 1000.)
+            t = datetime.datetime.fromtimestamp(float(strs[0][:-1]) / 1000.0)
             freq = float(strs[1])
 
             if not self.target_detected(freq):
-                self.push_to_dump(
-                    "the frequency {} Hz is not the target".format(freq))
+                self.push_to_dump("the frequency {} Hz is not the target".format(freq))
                 return
 
-            active = (strs[2].lower() == "active")
+            active = strs[2].lower() == "active"
 
             if not self.shared_vars["start_time"]:
                 self.shared_vars["start_time"] = t
@@ -725,7 +815,9 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
             if active != self.shared_vars["last_state"]:
                 self.push_to_dump(
                     "the detection state has been changed from {} to {}".format(
-                        self.shared_vars["last_state"], active))
+                        self.shared_vars["last_state"], active
+                    )
+                )
                 self.shared_vars["last_state"] = active
                 self.shared_vars["start_time"] = t
                 self.shared_vars["tictoc"].toc()
@@ -736,14 +828,19 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
 
             self.shared_vars["state_keep_ms"] += self.shared_vars["tictoc"].toc()
             if self.shared_vars["state_keep_ms"] > 200:
-                event = \
+                event = (
                     ToneDetector.Event.TONE_DETECTED if active else ToneDetector.Event.TONE_MISSING
+                )
                 if self.shared_vars["last_event"] != event:
                     self.shared_vars["last_event"] = event
-                    Logger.log(self.get_tag(),
+                    Logger.log(
+                        self.get_tag(),
                         "send_cb({}, {}) on {} Hz".format(
-                            t_str, "TONE_DETECTED" if active \
-                            else "TONE_MISSING", self.target_freq))
+                            t_str,
+                            "TONE_DETECTED" if active else "TONE_MISSING",
+                            self.target_freq,
+                        ),
+                    )
                     if self.cb != None:
                         self.cb((t_str, event))
                     if isinstance(self.listener, DetectionStateListener):
@@ -761,15 +858,20 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
 
             adb_tictoc.tic()
             msg_in_device, _ = Adb.execute(
-                cmd=["shell",
-                    "cat /storage/emulated/0/Google-AudioWorker-data/{}.txt".format(self.chandle)],
-                serialno=self.serialno, tolog=False)
+                cmd=[
+                    "shell",
+                    "cat {}/{}.txt".format(AudioWorkerApp.DATA_FOLDER, self.chandle),
+                ],
+                serialno=self.serialno,
+                tolog=False,
+            )
             elapsed = adb_tictoc.toc()
 
             msg_in_device = map(lambda x: x.strip(), msg_in_device.splitlines())
             msg_in_device = [x for x in msg_in_device if self.target_detected(float(x.split()[1]))]
-            self.shared_vars["msg"] = \
+            self.shared_vars["msg"] = (
                 msg_in_device[-1] if len(msg_in_device) > 0 else self.shared_vars["msg"]
+            )
 
             if elapsed > self.extra["adb-read-prop-max-elapsed"]:
                 self.extra["adb-read-prop-max-elapsed"] = elapsed
@@ -777,11 +879,14 @@ class AudioWorkerToneDetectorThread(AATAppToneDetectorThread):
             if self.shared_vars["msg"]:
                 try:
                     self.push_to_dump(
-                        "{} (adb-shell elapsed: {} ms)".format(self.shared_vars["msg"], elapsed))
+                        "{} (adb-shell elapsed: {} ms)".format(self.shared_vars["msg"], elapsed)
+                    )
                     freq_cb(self.shared_vars["msg"])
                 except Exception as e:
                     Logger.log(
-                        self.get_tag(), "crashed in freq_cb('{}')".format(self.shared_vars["msg"]))
+                        self.get_tag(),
+                        "crashed in freq_cb('{}')".format(self.shared_vars["msg"]),
+                    )
                     Logger.log(self.get_tag(), str(e))
 
                 elapsed = freq_cb_tictoc.toc()

pyaatlibs/logcatlistener.py

@@ -14,7 +14,9 @@ try:
 except ImportError:
     import Queue as queue
 
+
 class LogcatOutputThread(threading.Thread):
+
     def __init__(self, serialno, buffername):
         super(LogcatOutputThread, self).__init__()
         self.serialno = serialno
@@ -44,9 +46,12 @@ class LogcatOutputThread(threading.Thread):
         preexec_fn = None if platform.system() == "Windows" else os.setsid
         cmd = ["adb", "-s", self.serialno, "logcat"]
         cmd = cmd + ["-b", self.buffername] if self.buffername else cmd
-        Logger.log("LogcatOutputThread", "threadloop is listening with the command '{}'".format(cmd))
-        self.proc = subprocess.Popen(cmd,
-            stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=preexec_fn)
+        Logger.log(
+            "LogcatOutputThread", "threadloop is listening with the command '{}'".format(cmd)
+        )
+        self.proc = subprocess.Popen(
+            cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, preexec_fn=preexec_fn
+        )
         while not self.stoprequest.isSet():
             if self.proc.poll() != None:
                 break
@@ -56,9 +61,9 @@ class LogcatOutputThread(threading.Thread):
             if sys.version_info.major > 2:
                 line = line.decode("utf-8", errors="ignore")
 
-            if not self.lasttime_update_timer.is_alive(): # start for the first time
+            if not self.lasttime_update_timer.is_alive():  # start for the first time
                 self.lasttime_update_timer.start()
-            else: # reset for the followings
+            else:  # reset for the followings
                 self.lasttime_update_timer.reset()
             self._handle_logcat_msg(line)
 
@@ -74,11 +79,14 @@ class LogcatOutputThread(threading.Thread):
             if pattern in msg:
                 self.listeners[pattern].cb(pattern=pattern, msg=msg)
 
+
 class LogcatEvent(object):
+
     def __init__(self, pattern=None, cb=None):
         self.pattern = pattern
         self.cb = cb
 
+
 class LogcatListener(object):
     WORK_THREADS = {}
 
@@ -88,8 +96,10 @@ class LogcatListener(object):
 
         for threadname, th in LogcatListener.WORK_THREADS.items():
             Logger.log("LogcatListener::dump", "thread[{}]".format(threadname))
-            Logger.log("LogcatListener::dump",
-                "    - Last time processing: {} ms ago".format(th.lasttime_update_timer.get_time()))
+            Logger.log(
+                "LogcatListener::dump",
+                "    - Last time processing: {} ms ago".format(th.lasttime_update_timer.get_time()),
+            )
             for event_pattern in th.listeners.keys():
                 Logger.log("LogcatListener::dump", "    - pattern '{}'".format(event_pattern))
 
@@ -119,7 +129,8 @@ class LogcatListener(object):
         threadname = "{}-{}".format(serialno, buffername)
         if threadname in LogcatListener.WORK_THREADS.keys():
             Logger.log(
-                "LogcatListener", "there is an existing running thread ({}).".format(threadname))
+                "LogcatListener", "there is an existing running thread ({}).".format(threadname)
+            )
             if not flush:
                 Logger.log("LogcatListener", "skip the initialization.")
                 return