import json import logging import time from .core import EventLog from .core.abstract_input_event import EventType from .input_policy import POLICY_NONE, POLICY_MEMORY_GUIDED, POLICY_MANUAL, MemoryGuidedPolicy, NoneInputPolicy, ManualPolicy from .traffic_monitor import TrafficMonitor from .exceptions import FATAL_EXCEPTIONS, InputInterruptedException, AppCrashException, AppNeedUpdateException, AppLaunchErrorException DEFAULT_POLICY = POLICY_MEMORY_GUIDED DEFAULT_EVENT_INTERVAL = 1 DEFAULT_EVENT_COUNT = 100000000 DEFAULT_TIMEOUT = -1 WARMUP_STEPS = 10 STALL_STEPS_LIMIT = 33 STOP_STALL_STEPS_LIMIT = 3 * STALL_STEPS_LIMIT MIN_EXPLORATION_STEPS = 300 MAX_EXPLORATION_STEPS = 750 BLOCK_MIN_EXPLORATION_STEPS = 100 BLOCK_MAX_EXPLORATION_STEPS = 300 APP_CRASH_CYCLE_LIMIT = 3 # 闪退检测: 连续关闭->拉起失败的次数阈值 GOOGLE_PLAY_RECOVER_LIMIT = 3 GOOGLE_PLAY_STABLE_STEP_LIMIT = 3 REDIRECT_PULL_BACK_LIMIT = 3 class InputManager(object): """ This class manages all events to send during app running """ def __init__(self, device, policy_name, random_input, event_count, event_interval, profiling_method=None, replay_output=None, enable_guiagent=False, app_name=None, pcap_callback=None, enable_app_block=False): """ manage input event sent to the target device :param device: instance of Device (device internally manages app) :param policy_name: policy of ting events, string :param pcap_callback: callback to push pcap file :param enable_app_block: whether traffic blocking is enabled for this task :return: """ self.logger = logging.getLogger('InputEventManager') self.enabled = True self.device = device self.policy_name = policy_name self.random_input = random_input self.events = [] self.policy = None self.event_count = event_count self.event_interval = event_interval self.replay_output = replay_output self.enable_guiagent = enable_guiagent self.app_name = app_name self.profiling_method = profiling_method self.pcap_callback = pcap_callback self.enable_app_block = enable_app_block # Initialize TrafficMonitor and step counters (must be before get_input_policy) self.traffic_monitor = TrafficMonitor(device, device.app_identifier, pcap_callback=self.pcap_callback) self.total_exploring_steps = 0 self.current_stall_steps = 0 self.steps_since_last_stall_check = 0 self._force_stop = False # 用户手动中断标志（KeyboardInterrupt） self.user_interrupted = False # GuiAgent execution flag - skip foreground check and step counting during agent execution self.is_guiagent_executing = False # 闪退检测: 追踪连续关闭->拉起失败的循环次数 self._crash_cycle_count = 0 self._awaiting_restart_result = False # 标记是否正在等待重启结果 # Google Play 拉回恢复状态 self._google_play_recover_attempts = 0 self._google_play_stable_steps = 0 # 跳转目标包名记录 self._last_redirect_package = None self._redirect_pull_back_count = 0 # Initialize policy (uses traffic_monitor) self.policy = self.get_input_policy(device) def _reset_google_play_recovery(self): self._google_play_recover_attempts = 0 self._google_play_stable_steps = 0 def _handle_google_play_redirect(self): self._google_play_recover_attempts += 1 self._google_play_stable_steps = 0 self.logger.warning( f"检测到 Google Play Store，尝试拉回 " f"({self._google_play_recover_attempts}/{GOOGLE_PLAY_RECOVER_LIMIT})" ) if self.device.pull_back_to_app(): self.logger.info("Google Play Store 拉回成功，进入稳定观察") else: self.logger.warning("Google Play Store 拉回失败") time.sleep(1) if self._google_play_recover_attempts >= GOOGLE_PLAY_RECOVER_LIMIT: self.logger.error( f"连续 {GOOGLE_PLAY_RECOVER_LIMIT} 次从 Google Play Store 拉回仍未稳定，判定为需更新" ) raise AppNeedUpdateException("应用反复跳转 Google Play Store，需更新") def _mark_google_play_recovered(self): if self._google_play_recover_attempts == 0: return self._google_play_stable_steps += 1 if self._google_play_stable_steps < GOOGLE_PLAY_STABLE_STEP_LIMIT: self.logger.info( f"Google Play Store 拉回后稳定观察 " f"({self._google_play_stable_steps}/{GOOGLE_PLAY_STABLE_STEP_LIMIT})" ) return self.logger.info("Google Play Store 拉回后已稳定，清空恢复状态") self._reset_google_play_recovery() def get_input_policy(self, device): if self.policy_name == POLICY_NONE: input_policy = NoneInputPolicy(device, enable_guiagent=self.enable_guiagent) elif self.policy_name == POLICY_MEMORY_GUIDED: input_policy = MemoryGuidedPolicy(device, self.random_input, enable_guiagent=self.enable_guiagent, app_name=self.app_name, traffic_monitor=self.traffic_monitor) elif self.policy_name == POLICY_MANUAL: input_policy = ManualPolicy(device, enable_guiagent=self.enable_guiagent) else: self.logger.warning("No valid input policy specified. Using policy \"none\".") input_policy = None return input_policy def add_event(self, event): """ add one event to the event list :param event: the event to be added, should be subclass of AppEvent :return: """ if event is None: return # 如果GuiAgent正在执行，跳过前台检查和步数累计，只执行事件 if self.is_guiagent_executing: self.logger.debug(f"[GuiAgent执行中] 直接执行事件: {event.event_type}") self.events.append(event) event_log = EventLog(self.device, self.device._app, event, self.profiling_method) event_log.start() event_log.stop() return # 1. 基础限制检查 max_steps = BLOCK_MAX_EXPLORATION_STEPS if self.enable_app_block else MAX_EXPLORATION_STEPS min_steps = BLOCK_MIN_EXPLORATION_STEPS if self.enable_app_block else MIN_EXPLORATION_STEPS if self.total_exploring_steps >= max_steps: self.logger.info(f"Reached max exploration steps ({max_steps}), stopping collection.") raise InputInterruptedException() # 2. 前台状态与采集终止检查 is_kill_app = hasattr(event, 'event_type') and event.event_type == EventType.KILL_APP if not is_kill_app: curr_in_foreground = self.device.is_foreground() if not curr_in_foreground: # C10: Web平台简化处理，无app_store/launcher概念 if self.device.get_platform_name() == "web": self.logger.info("Web平台: 检测到离站，尝试拉回") self.device.pull_back_to_app() return redirect_info = self.device.get_redirect_target_info() redirect_type = redirect_info.get("type") if redirect_info else "unknown" redirect_target = redirect_info.get("target") if redirect_info else None # 情况1: 跳转到 Google Play Store -> 需连续检测确认 if redirect_type == "app_store": self._handle_google_play_redirect() return # 情况2: 跳转到桌面 -> 闪退逻辑 if redirect_type in {"launcher", "unknown"}: self._last_redirect_package = None self._redirect_pull_back_count = 0 if self.total_exploring_steps >= min_steps and self._force_stop: self.logger.info(f"App out of foreground and total steps ({self.total_exploring_steps}) >= min exploration steps ({min_steps}) with _force_stop. Ending.") raise InputInterruptedException() else: self.logger.info(f"App out of foreground (launcher) but not reached min exploration steps ({self.total_exploring_steps}/{min_steps}). Pulling back.") pull_back_success = self.device.pull_back_to_app() if not pull_back_success: if self._awaiting_restart_result: self._crash_cycle_count += 1 self.logger.warning(f"应用重启后再次失败，闪退循环计数: {self._crash_cycle_count}/{APP_CRASH_CYCLE_LIMIT}") if self._crash_cycle_count >= APP_CRASH_CYCLE_LIMIT: if self.enable_app_block: self.logger.warning(f"Block任务检测到连续闪退 {self._crash_cycle_count} 次，重置计数并继续尝试（流量阻塞可能导致正常闪退）") self._crash_cycle_count = 0 self._awaiting_restart_result = False else: self.logger.error(f"检测到应用闪退！连续 {self._crash_cycle_count} 次关闭->拉起失败循环") raise AppCrashException(f"应用闪退：连续 {self._crash_cycle_count} 次关闭并重启后仍无法运行") self.logger.warning("前台拉回失败，将关闭应用并重启") from .core import PlatformFactory CloseAppEvent = PlatformFactory.get_event_class(self.device.get_platform_name(), 'kill_app') if CloseAppEvent: event = CloseAppEvent(app=self.device.app_identifier) self._awaiting_restart_result = True time.sleep(10) # 情况3: 跳转到其他应用 -> 记录目标并尝试拉回 else: self._last_redirect_package = redirect_target self.logger.warning(f"应用跳转到其他应用: {redirect_target}，尝试拉回") pull_back_success = self.device.pull_back_to_app() if pull_back_success: self._redirect_pull_back_count = 0 self._last_redirect_package = None self.logger.info(f"成功拉回到目标应用") else: self._redirect_pull_back_count += 1 self.logger.warning(f"拉回失败 ({self._redirect_pull_back_count}/{REDIRECT_PULL_BACK_LIMIT})，跳转目标: {self._last_redirect_package}") if self._redirect_pull_back_count >= REDIRECT_PULL_BACK_LIMIT: self.logger.error(f"连续 {REDIRECT_PULL_BACK_LIMIT} 次拉回失败，判定为启动异常，跳转目标: {self._last_redirect_package}") raise AppLaunchErrorException(f"启动异常：跳转至 {self._last_redirect_package}") else: if self._force_stop: self.logger.info("App is in foreground, resetting _force_stop.") self._force_stop = False if self._awaiting_restart_result: self.logger.info("应用重启成功，重置闪退检测计数") self._crash_cycle_count = 0 self._awaiting_restart_result = False self._mark_google_play_recovered() self._last_redirect_package = None self._redirect_pull_back_count = 0 # 3. 统计当前步 self.total_exploring_steps += 1 self.current_stall_steps += 1 self.steps_since_last_stall_check += 1 # 4. 流量监控与 停滞处理 has_new = False if self.total_exploring_steps >= WARMUP_STEPS: self.traffic_monitor.update() has_new, new_count = self.traffic_monitor.has_new_features() if self.steps_since_last_stall_check >= STALL_STEPS_LIMIT: # 监控环境健康检查 self.traffic_monitor.check_monitor_health() self.logger.info(f"Steps reached {STALL_STEPS_LIMIT}, checking for new features...") if not has_new: from .core import PlatformFactory if self.current_stall_steps >= STOP_STALL_STEPS_LIMIT: if self.device.check_network(): self.logger.info("Network check success, force stop") self._force_stop = True else: self.logger.warning("Network check failed, retry") self._force_stop = False self.logger.info(f"No new features for {self.current_stall_steps} steps. Generating KillAppEvent.") KillAppEvent = PlatformFactory.get_event_class(self.device.get_platform_name(), 'kill_app') if KillAppEvent: event = KillAppEvent(app=self.device.app_identifier) self.current_stall_steps = 0 else: # 总步数达标，标志停止 if self.total_exploring_steps >= min_steps: if self.device.check_network(): self.logger.info("Network check success, force stop") self._force_stop = True else: self.logger.warning("Network check failed, retry") self._force_stop = False self.logger.info(f"No new features detected. Overriding with BACK event.") KeyEvent = PlatformFactory.get_event_class(self.device.get_platform_name(), 'key') if KeyEvent: event = KeyEvent(key_name="BACK") # 重置单次 check 计数，以便下一次 loop 继续 check self.steps_since_last_stall_check = 0 else: self.logger.info(f"New features found ({new_count}). Resetting stall counters.") self.current_stall_steps = 0 self.steps_since_last_stall_check = 0 self._force_stop = False # 5. 执行事件 self.logger.info(f"Step {self.total_exploring_steps}: sending {event.event_type} (stall: {self.current_stall_steps}/{STOP_STALL_STEPS_LIMIT}, check: {self.steps_since_last_stall_check}/{STALL_STEPS_LIMIT})") self.events.append(event) event_log = EventLog(self.device, self.device._app, event, self.profiling_method) event_log.start() event_log.stop() def start(self): """ start sending event """ self.logger.info("start sending events, policy is %s" % self.policy_name) try: if self.policy is not None: self.policy.start(self) elif self.policy_name == POLICY_NONE: self.device.start_app() if self.event_count == 0: return while self.enabled: time.sleep(1) elif self.policy_name == POLICY_MANUAL: self.device.start_app() while self.enabled: keyboard_input = input("press ENTER to save current state, type q to exit...") if keyboard_input.startswith('q'): break state = self.device.get_current_state() if state is not None: state.save2dir() except KeyboardInterrupt: # 记录用户手动中断标志，并向上传播 self.user_interrupted = True raise except FATAL_EXCEPTIONS: raise except Exception as e: self.logger.error(f'Non-fatal exception in input_manager: {e}') import traceback traceback.print_exc() finally: # 探索结束后，一次性完成所有文件写入（无论正常结束还是异常退出） if self.policy and hasattr(self.policy, 'utg'): self.policy.utg.finalize() self.stop() self.logger.info("Finish sending events") def stop(self): """ stop sending event """ self.enabled = False