class LabNfcDualPhoneBeamTransfert(LabNfcBase):
# the name of ref phone is the name in BENCH_CONFIG file
REF_PHONE = "PHONE2"
def __init__(self, tc_name, global_config):
LabNfcBase.__init__(self, tc_name, global_config)
# second phone init
self._phone_ref = DeviceManager().get_device(
LabNfcDualPhoneBeamTransfert.REF_PHONE)
self._phone_ref.connect_board()
# Check if we have the ref phone available
if self._phone_ref is not None:
if not self._phone_ref.is_available():
DeviceManager().boot_device(
LabNfcDualPhoneBeamTransfert.REF_PHONE)
self._nfc_api_phone_ref = self._phone_ref.get_uecmd(
"LocalConnectivity")
# get PhoneSystem uecmd instance for the ref phone
self._phonesystem_api_dut = self._device.get_uecmd("PhoneSystem")
self._phonesystem_api_ref = self._phone_ref.get_uecmd("PhoneSystem")
self._appmgmt_api = self._phone_ref.get_uecmd("AppMgmt")
# get file uecmd instance
self._file_api_dut = self._device.get_uecmd("File")
self._file_api_ref = self._phone_ref.get_uecmd("File")
# Get NFC Tags application package name
self._tag_app = str(self._dut_config.get("TagsAppPackageName"))
# Get Browsers application package name (need to disable in order to be able to read URI tags)
self._browser_app = str(self._dut_config.get("BrowserAppPackageName"))
self._chrome_app = str(self._dut_config.get("ChromeAppPackageName"))
# force phone 2 state unlock and display on
# for the DUT this is made in LiveNfcBase class
self._phonesystem_api_ref.display_on()
self._phonesystem_api_ref.set_phone_lock(0)
self._nfc_api_phone_ref.force_nfc_state(1)
# BE careful here we have to be sure that the file is here (setup embbeded)
self.__file_to_share = str(
self._tc_parameters.get_param_value("FILE_TO_SHARE"))
self.__beam_duration = int(
self._tc_parameters.get_param_value("BEAM_DURATION"))
self.__direction = str(
self._tc_parameters.get_param_value("DIRECTION")).upper()
self._nfc_robot_param = global_config.benchConfig.get_parameters(
"NFC_ROBOT1")
self._beam_path = self._tc_parameters.get_param_value("BEAM_PATH")
# get ref phone position
self.__ref_phone_position = self._tc_parameters.get_param_value(
"REF_PHONE_POSITION")
self._tag_up = self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "Up")
self._tag_down = self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "Down")
self._tag_X = self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "X")
# get the antenna position
antenna_position = self._device.get_config("NfcAntennaPosition")
self._tag_Y = str(
int(
self._nfc_robot_param.get_param_value(
self.__ref_phone_position + "Y")) +
int(antenna_position.split(",")[1]))
# ----------------------------------------------------------------------------------------------
def set_up(self):
LabNfcBase.set_up(self)
# dont need to check if BEAM activated because of the parameters
# self._Device is DUT
# self._phone_ref is the reference phone
# disable "Tags" and browsers built-in apps
# In DUT
self._appmgmt_api.app_enable_disable(self._tag_app, False)
self._appmgmt_api.app_enable_disable(self._browser_app, False)
self._appmgmt_api.app_enable_disable(self._chrome_app, False)
# in phone ref
self._appmgmt_api.app_enable_disable(self._tag_app, False)
self._appmgmt_api.app_enable_disable(self._browser_app, False)
self._appmgmt_api.app_enable_disable(self._chrome_app, False)
self.__size_of_file = 0
# file have to be in both device, and get its size
file_exist, result = self._file_api_dut.exist(
posixpath.join(self._device.multimedia_path, self.__file_to_share))
if file_exist:
size = self._file_api_dut.size(
posixpath.join(self._device.multimedia_path,
self.__file_to_share))
self.__size_of_file = size
else:
msg = "File to transfert missing on DUT "
raise AcsConfigException(AcsConfigException.FILE_NOT_FOUND, msg)
size = 0
file_exist, result = self._file_api_ref.exist(
posixpath.join(self._device.multimedia_path, self.__file_to_share))
if file_exist:
size = self._file_api_ref.size(
posixpath.join(self._device.multimedia_path,
self.__file_to_share))
if size != self.__size_of_file:
msg = "File to share are different size on DUT and reference phone"
raise AcsConfigException(AcsConfigException.INVALID_PARAMETER,
msg)
else:
msg = "File to transfert missing on reference phone "
raise AcsConfigException(AcsConfigException.FILE_NOT_FOUND, msg)
return Global.SUCCESS, "No errors"
# ----------------------------------------------------------------------------------------------
def run_test(self):
msg = "No errors"
# move robot to start position
self._robot_positioning(self._tag_X, self._tag_Y, self._tag_up, 'null')
# do the DUT to ref phone transfert
if "SEND" or "FULL" in self.__direction:
# starting beam sequence with DUT
self.__beam_sequence(self._device)
if not self.__is_transfert_ok(self._file_api_ref):
msg = "Error : send BEAM failed on %s sequence" % self.__direction
# clear beamed files
self.__clear_beam_sequence()
time.sleep(5)
# do the ref phone to DUT transfert
if "RECEIVE" or "FULL" in self.__direction:
# starting beam sequence with phone ref
self.__beam_sequence(self._phone_ref)
if not self.__is_transfert_ok(self._file_api_dut):
msg += "Error : receive BEAM failed on %s sequence" % self.__direction
# clear beamed files
self.__clear_beam_sequence()
if msg != "No errors":
raise DeviceException(DeviceException.OPERATION_FAILED, msg)
return Global.SUCCESS, msg
# ----------------------------------------------------------------------------------------------
def tear_down(self):
# move robot to start position
self._robot_positioning(self._tag_X, self._tag_Y, self._tag_up, 'null')
LabNfcBase.tear_down(self)
return Global.SUCCESS, "No errors"
# ----------------------------------------------------------------------------------------------
def __is_transfert_ok(self, device_system_api):
file_exist, result = device_system_api.exist(
posixpath.join(self._beam_path, self.__file_to_share))
if file_exist:
size = device_system_api.size(
posixpath.join(self._beam_path, self.__file_to_share))
if size == self.__size_of_file:
return True
else:
return False
# ----------------------------------------------------------------------------------------------
def __clear_beam_sequence(self):
# clear beamed files on both devices
self._file_api_dut.delete(
posixpath.join(self._beam_path, self.__file_to_share))
self._file_api_ref.delete(
posixpath.join(self._beam_path, self.__file_to_share))
return True
# ----------------------------------------------------------------------------------------------
def __open_image(self, device, file_to_open):
cmd = "adb shell am start -d file:%s -t image/* -a android.intent.action.VIEW -n com.google.android.gallery3d/com.android.gallery3d.app.GalleryActivity" % str(
file_to_open)
device.run_cmd(cmd, 10)
return True
# ----------------------------------------------------------------------------------------------
def __close_image(self, device):
# close image
cmd = "adb shell pm clear com.google.android.gallery3d"
device.run_cmd(cmd, 10)
time.sleep(1)
return True
# ----------------------------------------------------------------------------------------------
def __beam_sequence(self, beamer):
# first open photo on the beamer
# DEBUG try to use an uecmd instead like start_display_image
self._logger.info("Start to BEAM")
self.__open_image(
beamer, posixpath.join(beamer.multimedia_path,
self.__file_to_share))
# move nfc bot
self._robot_positioning('null', 'null', self._tag_down, 'null')
# wait a while
time.sleep(2)
if beamer.get_config("device_name") == "PHONE1":
res = self._phonesystem_api_dut.get_screen_resolution().split("x")
mres = "%dx%d" % (int(res[0]) / 2, int(res[1]) / 2)
self._nfc_api.nfc_touch_to_beam(mres, 1)
else:
res = self._phonesystem_api_ref.get_screen_resolution().split("x")
mres = "%dx%d" % (int(res[0]) / 2, int(res[1]) / 2)
self._nfc_api_phone_ref.nfc_touch_to_beam(mres, 1)
time.sleep(2)
self._robot_positioning('null', 'null', self._tag_up, 'null')
time.sleep(self.__beam_duration)
# close gallery application
self.__close_image(beamer)
class AndroidUiTestVcMt(AndroidUiTest):
"""
Android UI test mobile terminated voice call class.
This use case will permit to launch UI test on DUT.
The PHONE2 will be used in application framework level to make a voice call.
"""
def __init__(self, tc_name, global_config):
"""
Constructor
"""
# Call Android UI test use case base Init function
AndroidUiTest.__init__(self, tc_name, global_config)
#
self._phone_number = \
str(self._device.get_phone_number())
# Read callSetupTimeout from Device_Catalog.xml
self._call_setup_time = \
int(self._dut_config.get("callSetupTimeout"))
# Get UECmdLayer
self._phone2 = DeviceManager().get_device("PHONE2")
if self._phone2 is not None:
self._voice_call_api2 = self._phone2.get_uecmd("VoiceCall")
def set_up(self):
"""
Set up the test configuration
"""
# Call Android UI test use case base Setup function
verdict, msg = AndroidUiTest.set_up(self)
if verdict != Global.SUCCESS:
return verdict, msg
# Check if we have the second phone available
if self._phone2 is None:
# We are using this multi UC with only one phone
return Global.FAILURE, "Cannot run that use case with only one phone configured."
# Boot the other phone (the DUT is already booted)
if self._phone2.get_state() != "alive":
# We are using this multi UC with an phone2 is not available
return Global.FAILURE, "Ref phone not available (power off ?), please check your bench."
if not self._phone2.is_available():
self._phone2.connect_board()
return Global.SUCCESS, "No error"
def run_test(self):
"""
Execute the test
"""
self._logger.info("")
self._logger.info("%s: RunTest", self._name)
self._logger.info("")
# Phone 2 : Release any previous call (Robustness)
time.sleep(self._wait_btwn_cmd)
self._voice_call_api2.release()
# Phone2 : Dial without checking call state (Non Blocking)
time.sleep(self._wait_btwn_cmd)
self._voice_call_api2.dial(self._phone_number, False)
# Phone1 : Call AndroidUiTest run test
return AndroidUiTest.run_test(self)
class LiveSystemSleepResidencyMeasurement(SystemSleepBase):
"""
Sleep mode residency measurement class.
"""
def __init__(self, tc_name, global_config):
"""
Constructor
:type tc_name: BaseConf
:param tc_name: Configuration of the usecase
:type global_config: Dictionary
:param global_config: Global configuration of the campaign
"""
# Call UseCase base constructor
self._device = DeviceManager().get_device("PHONE1")
self.__adbConnectionTimeout = self._device.get_config(
"adbConnectTimeout", 30, float)
self._device_uptime_begin = None
self._sleep_duration = None
# If the device was disconnected before due to an error
# we must reconnect it explicitly at the beginning of the test
# else some commands will not be executed and the test will be blocked
self._system_api = self._device.get_uecmd("System")
return_code = self._system_api.wait_for_device(
self.__adbConnectionTimeout)
if not return_code:
time.sleep(30)
if not self._device.is_available():
self._device.connect_board()
# Call SystemSleepBase base Init function
SystemSleepBase.__init__(self, tc_name, global_config)
self._report_tree = global_config.campaignConfig.get(
"campaignReportTree")
self._sysdebug_apis = self._device.get_uecmd("SysDebug")
self._tc_name = os.path.basename(self.get_name())
self._tc_date = ""
attributes = {"id": self._tc_name, "date": self._tc_date}
self.__results = PnPResults(self._report_tree,
self._dut_config.get("Name"),
self._failure_file, None, attributes)
def run_test(self):
"""
Execute the test
"""
sysdbg_modules_config = self._tc_parameters.get_param_value(
"SYSDEBUG_MODULES")
self._sysdebug_apis.init(sysdbg_modules_config)
sleep_parameter = self._tc_parameters.get_param_value("SLEEP_DURATION")
if sleep_parameter is not None and sleep_parameter != "" and sleep_parameter.isdigit(
):
self._sleep_duration = int(sleep_parameter)
# Call live sleep use case base
SystemSleepBase.run_test(self)
self._tc_date = time.strftime("%Y-%m-%d %H:%M:%S")
self.__results.update({"date": self._tc_date})
while not self._sysdebug_apis.synchronize():
time.sleep(10)
adbConnectTimeout = self._device.get_config("adbConnectTimeout", 10,
float)
usbReplugRetries = self._device.get_config("usbReplugRetries", 1, int)
if self._io_card is not None:
self._device.disconnect_board()
self._sysdebug_apis.reset() # will clear mid_pmu_states
self._residency_api.clear(
self._sleep_duration) # will also clear mid_pmu_states
# but this is needed to do the fetch on this instance
self._io_card.usb_host_pc_connector(False)
# Unplug wall charger only if it is AC_CHGR
if self._device.get_default_wall_charger(
) == self._io_card.AC_CHGR:
self._io_card.wall_charger_connector(False)
# Update device uptime
updated, self._device_uptime_begin = self._device._update_device_up_state(
0)
if not updated:
self._device_uptime_begin = None
if self._sleep_duration:
self._logger.info(
"Wait for %s s before measurement (sleep duration before %s)" %
(str(self._sleep_duration), self._sleep_mode))
time.sleep(self._sleep_duration)
self._sysdebug_apis.start()
self._logger.info("Wait for %s s to enter in %s" %
(str(self._duration), self._sleep_mode))
time.sleep(self._duration)
self._sysdebug_apis.stop()
residency_spent = 0
ret_code = None
if self._io_card is not None:
for cnt in range(0, usbReplugRetries + 1):
self._logger.debug("Loop Iteration: %d" % cnt)
# plug wall charger only if it is AC_CHGR
if self._device.get_default_wall_charger(
) == self._io_card.AC_CHGR:
self._io_card.wall_charger_connector(True)
self._io_card.usb_host_pc_connector(True)
self._logger.debug("Wait for device %s seconds" %
self.__adbConnectionTimeout)
ret_code = self._system_api.wait_for_device(
self.__adbConnectionTimeout)
self._logger.debug("Wait for device return code: %s" %
ret_code)
if not ret_code:
if cnt < usbReplugRetries:
self._logger.warning(
"timeout on wait-for-device, trying to unplug/replug (try %s/%s)"
% (str(cnt + 1), str(usbReplugRetries)))
self._io_card.usb_host_pc_connector(False)
# Unplug wall charger only if it is AC_CHGR
if self._device.get_default_wall_charger(
) == self._io_card.AC_CHGR:
self._io_card.wall_charger_connector(False)
time.sleep(10)
continue
residency_spent = self._residency_api.get_value(
"residency", self._sleep_mode_api.get_sleep_mode())
self._sysdebug_apis.fetch()
self._device.connect_board()
self._logger.debug("device retrieved after %s tries" %
str(cnt + 1))
break
if not ret_code:
raise DeviceException(
DeviceException.OPERATION_FAILED,
"Could not retrieve the device after %s plug/unplug cycles"
% str(usbReplugRetries))
if residency_spent is None:
raise DeviceException(
DeviceException.INVALID_PARAMETER,
"There is no %s sleep mode for this device model" %
self._sleep_mode_api.get_sleep_mode())
# Get device uptime and raise an exception if the device rebooted
if self._device_uptime_begin:
updated, uptime = self._device._update_device_up_state(
self._device_uptime_begin)
if updated and not self._device.is_up:
self._logger.warning(
"the device uptime was %s before the measurement, %s now !"
% (str(self._device_uptime_begin), str(uptime)))
raise DeviceException(
DeviceException.OPERATION_FAILED,
"Device rebooted during the measurement")
sysreport = self._sysdebug_apis.report()
self.__results.append(sysreport)
self.__results.write()
return self._residency_verdict(residency_spent)