392     def __init__(self,  argument
397         self.serial = serial
398         self._product_type = product_type
399         self.device_command_port = None
400         self.device_callback_port = device_callback_port
401         self.log = AndroidDeviceLoggerAdapter(logging.getLogger(),
402                                               {"serial": self.serial})
404         self.log_path = os.path.join(base_log_path, "AndroidDevice%s" % serial)
405         self.adb_logcat_process = None
406         self.adb_logcat_file_path = None
407         self.vts_agent_process = None
408         self.adb = adb.AdbProxy(serial)
409         self.fastboot = fastboot.FastbootProxy(serial)
410         if not self.isBootloaderMode:
411             self.rootAdb()
412         self.host_command_port = None
413         self.host_callback_port = adb.get_available_host_port()
414         if self.device_callback_port >= 0:
415             self.adb.reverse_tcp_forward(self.device_callback_port,
416                                          self.host_callback_port)
417         self.hal = None
418         self.lib = None
419         self.shell = None
420         self.shell_default_nohup = shell_default_nohup
421         self.fatal_error = False
423     def __del__(self):  argument
424         self.cleanUp()
426     def cleanUp(self):  argument
430         self.stopServices()
431         self._StartLLKD()
432         if self.host_command_port:
433             self.adb.forward("--remove tcp:%s" % self.host_command_port,
435             self.host_command_port = None
438     def shell_default_nohup(self):  argument
440         if not getattr(self, '_shell_default_nohup'):
441             self._shell_default_nohup = False
442         return self._shell_default_nohup
445     def shell_default_nohup(self, value):  argument
447         self._shell_default_nohup = value
448         if self.shell:
449             self.shell.shell_default_nohup = value
452     def hasVbmetaSlot(self):  argument
454         if not self.isBootloaderMode:
455             self.adb.reboot_bootloader()
457         out = self.fastboot.getvar(_FASTBOOT_VAR_HAS_VBMETA).strip()
463     def isBootloaderMode(self):  argument
465         return self.serial in list_fastboot_devices()
468     def isTcpFastbootdMode(self):  argument
470         if self.serial in list_unauthorized_devices():
471             if self.fastboot.isFastbootOverTcp(self.serial):
472                 out = self.fastboot.getvar("is-userspace").strip()
478     def isAdbRoot(self):  argument
480         id_str = self.adb.shell("id -un").strip().decode("utf-8")
484     def verityEnabled(self):  argument
487             verified = self.getProp("partition.system.verified")
496     def model(self):  argument
499         if self.isBootloaderMode:
500             out = self.fastboot.getvar("product").strip()
509         model = self.getProp("ro.build.product").lower()
513             model = self.getProp("ro.product.name").lower()
517     def first_api_level(self):  argument
519         return self.getProp("ro.product.first_api_level")
522     def sdk_version(self):  argument
524         return self.getProp("ro.build.version.sdk")
526     def getLaunchApiLevel(self, strict=True):  argument
540         level_str = self.first_api_level
553         level_str = self.sdk_version
564     def kernel_version(self):  argument
577         out = self.adb.shell(cmd)
591     def vndk_version(self):  argument
593         return self.getProp("ro.vndk.version")
596     def vndk_lite(self):  argument
603         vndk_lite_str = self.getProp("ro.vndk.lite")
610     def cpu_abi(self):  argument
612         out = self.getProp("ro.product.cpu.abi")
619     def getCpuAbiList(self, bitness=""):  argument
629         out = self.getProp("ro.product.cpu.abilist" + str(bitness))
633     def is64Bit(self):  argument
635         out = self.adb.shell('uname -m')
639     def total_memory(self):  argument
646         out = self.adb.shell(total_memory_command)
675     def libPaths(self):  argument
678         if self.is64Bit:
685     def isAdbLogcatOn(self):  argument
688         if self.adb_logcat_process:
693     def mac_address(self):  argument
698             response = self.adb.shell(command)
705     def sim_state(self):  argument
708         return self.getProp('gsm.sim.state')
711     def sim_operator(self):  argument
714         return self.getProp('gsm.operator.alpha')
716     def getKernelConfig(self, config_name):  argument
732             self.adb.pull("/proc/config.gz", config_path)
746     def getBinderBitness(self):  argument
753         config_value = self.getKernelConfig("CONFIG_ANDROID_BINDER_IPC_32BIT")
761     def loadConfig(self, config):  argument
772             if hasattr(self, k):
775                     (k, self.serial))
776             setattr(self, k, v)
778     def rootAdb(self):  argument
780         if not self.isAdbRoot:
782                 self.adb.root()
783                 self.adb.wait_for_device()
789     def startAdbLogcat(self):  argument
793         if self.isAdbLogcatOn:
796                                       "another one.") % self.serial)
800         f_name = "adblog_%s_%s.txt" % (self.model, self.serial)
801         utils.create_dir(self.log_path)
802         logcat_file_path = os.path.join(self.log_path, f_name)
804             extra_params = self.adb_logcat_param
807         cmd = "adb -s %s logcat -v threadtime %s >> %s" % (self.serial,
810         self.adb_logcat_process = utils.start_standing_subprocess(cmd)
811         self.adb_logcat_file_path = logcat_file_path
814     def stopAdbLogcat(self):  argument
817         if not self.isAdbLogcatOn:
820                 % self.serial)
825             utils.stop_standing_subprocess(self.adb_logcat_process)
829         self.adb_logcat_process = None
832     def takeBugReport(self, test_name, begin_time):  argument
839         br_path = os.path.join(self.log_path, "BugReports")
841         base_name = ",%s,%s.txt" % (begin_time, self.serial)
845         self.log.info("Taking bugreport for %s on %s", test_name, self.serial)
846         self.adb.bugreport(" > %s" % full_out_path)
847         self.log.info("Bugreport for %s taken at %s", test_name, full_out_path)
849     def waitForBootCompletion(self, timeout=900):  argument
861             self.adb.wait_for_device(timeout=timeout)
867         while not self.isBootCompleted():
876     def hasBooted(self):  argument
882         return self.isBootCompleted()
884     def isBootCompleted(self):  argument
891             if (self.getProp(SYSPROP_SYS_BOOT_COMPLETED) == '1' and
892                 self.getProp(SYSPROP_DEV_BOOTCOMPLETE) == '1'):
901     def isFrameworkRunning(self, check_boot_completion=True):  argument
928         if check_boot_completion and not self.isBootCompleted():
932         res = self.adb.shell(cmd, no_except=True)
936     def startFramework(self,  argument
954         self.adb.shell("start")
957             if not self.waitForFrameworkStartComplete(
964     def start(self, start_native_server=True):  argument
973             self.startNativeServer()
974         return self.startFramework()
976     def stopFramework(self):  argument
982         self.adb.shell("stop")
983         self.setProp(SYSPROP_SYS_BOOT_COMPLETED, 0)
986     def stop(self, stop_native_server=False):  argument
994         self.stopFramework()
996             self.stopNativeServer()
998     def waitForFrameworkStartComplete(self, timeout_secs=WAIT_TIMEOUT_SEC):  argument
1011         if not self.waitForBootCompletion(timeout_secs):
1014         while not self.isFrameworkRunning(check_boot_completion=False):
1021     def startNativeServer(self):  argument
1023         self.setProp(SYSPROP_VTS_NATIVE_SERVER, "0")
1025     def stopNativeServer(self):  argument
1027         self.setProp(SYSPROP_VTS_NATIVE_SERVER, "1")
1029     def isProcessRunning(self, process_name):  argument
1041         cmd_result = self.adb.shell.Execute("ps -A")
1051     def waitForProcessStop(self, process_names, timeout_secs=WAIT_TIMEOUT_SEC):  argument
1064                 while self.isProcessRunning(process_name):
1074     def setProp(self, name, value):  argument
1098         self.adb.shell("setprop %s \"%s\"" % (name, value))
1100     def getProp(self, name, timeout=adb.DEFAULT_ADB_SHORT_TIMEOUT):  argument
1119         out = self.adb.shell("getprop %s" % name, timeout=timeout)
1122     def reboot(self, restart_services=True):  argument
1132         if self.isBootloaderMode:
1133             self.fastboot.reboot()
1136         if self.isTcpFastbootdMode:
1137             self.fastboot.reboot()
1141             has_adb_log = self.isAdbLogcatOn
1142             has_vts_agent = True if self.vts_agent_process else False
1144                 self.stopAdbLogcat()
1146                 self.stopVtsAgent()
1148         self.adb.reboot()
1149         self.waitForBootCompletion()
1150         self.rootAdb()
1154                 self.startAdbLogcat()
1156                 self.startVtsAgent()
1158     def startServices(self):  argument
1167         self.enable_vts_agent = getattr(self, "enable_vts_agent", True)
1169             self.startAdbLogcat()
1173             self.log.error(msg)
1174             self.log.exception(e)
1176         if self.enable_vts_agent:
1177             self.startVtsAgent()
1178             self.device_command_port = int(
1179                 self.adb.shell("cat /data/local/tmp/vts_tcp_server_port"))
1180             logging.debug("device_command_port: %s", self.device_command_port)
1181             if not self.host_command_port:
1182                 self.host_command_port = adb.get_available_host_port()
1183             self.adb.tcp_forward(self.host_command_port,
1184                                  self.device_command_port)
1185             self.hal = mirror_tracker.MirrorTracker(
1186                 self.host_command_port, self.host_callback_port, True)
1187             self.lib = mirror_tracker.MirrorTracker(self.host_command_port)
1188             self.shell = mirror_tracker.MirrorTracker(
1189                 host_command_port=self.host_command_port, adb=self.adb)
1190             self.shell.shell_default_nohup = self.shell_default_nohup
1191             self.resource = mirror_tracker.MirrorTracker(self.host_command_port)
1194     def Heal(self):  argument
1204         if self.shell:
1205             res &= self.shell.Heal()
1208             self.getProp("ro.build.version.sdk")
1210             if self.serial in list_adb_devices():
1211                 self.log.error(
1213             elif self.isBootloaderMode:
1214                 self.log.info("Device is in bootloader/fastbootd mode")
1216             elif self.isTcpFastbootdMode:
1217                 self.log.info("Device is in tcp fastbootd mode")
1220                 self.log.error("Device is not in adb devices!")
1221             self.fatal_error = True
1224             self.fatal_error = False
1226             self.log.error('Self diagnosis found problem')
1230     def stopServices(self):  argument
1232         if self.adb_logcat_process:
1233             self.stopAdbLogcat()
1234         if getattr(self, "enable_vts_agent", True):
1235             self.stopVtsAgent()
1236         if self.hal:
1237             self.hal.CleanUp()
1239     def _StartLLKD(self):  argument
1241         if self.fatal_error:
1242             self.log.error("Device in fatal error state, skip starting llkd")
1245             self.adb.shell('start %s' % LLKD)
1249     def _StopLLKD(self):  argument
1251         if self.fatal_error:
1252             self.log.error("Device in fatal error state, skip stop llkd")
1255             self.adb.shell('stop %s' % LLKD)
1259     def startVtsAgent(self):  argument
1265         self.log.info("Starting VTS agent")
1266         if self.vts_agent_process:
1268                 "HAL agent is already running on %s." % self.serial)
1272         self._StopLLKD()
1283             self.adb.shell("\"" + " ; ".join(cleanup_commands) + "\"")
1285             self.log.warning(
1290         log_severity = getattr(self, keys.ConfigKeys.KEY_LOG_SEVERITY, "INFO")
1291         bits = ['64', '32'] if self.is64Bit else ['32']
1295                 self.log_path, 'vts_agent_%s_%s.log' % (bitness, self.serial))
1312                        s=self.serial,
1319                 self.vts_agent_process = utils.start_standing_subprocess(
1338     def stopVtsAgent(self):  argument
1341         if not self.vts_agent_process:
1344             utils.stop_standing_subprocess(self.vts_agent_process)
1347         self.vts_agent_process = None
1350     def product_type(self):  argument
1352         return self._product_type
1354     def getPackagePid(self, package_name):  argument
1370                 out = self.adb.shell('%s | grep "S %s"' % (cmd, package_name))
1375                     self.log.info('apk %s has pid %s.', package_name, pid)
1380                     self.log.warn('Command \"%s\" returned output line: '
1383                 self.log.warn(
1386         self.log.debug("apk %s is not running", package_name)
1394     def process(self, msg, kwargs):  argument
1404         msg = "[AndroidDevice|%s] %s" % (self.extra["serial"], msg)
1407     def warn(self, msg, *args, **kwargs):  argument
1409         super(AndroidDeviceLoggerAdapter, self).warning(msg, *args, **kwargs)