def on_fail(self, test_name, begin_time):
result = True
if not super(BluetoothCarHfpBaseTest, self).on_fail(
test_name, begin_time):
result = False
ensure_phones_default_state(self.log, self.android_devices[1:])
return result
def teardown_class(self):
try:
ensure_phones_default_state(self.log, self.android_devices)
for ad in self.android_devices:
ad.droid.telephonyAdjustPreciseCallStateListenLevel(
PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND, False)
ad.droid.telephonyAdjustPreciseCallStateListenLevel(
PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING, False)
ad.droid.telephonyAdjustPreciseCallStateListenLevel(
PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND, False)
if "enable_wifi_verbose_logging" in self.user_params:
ad.droid.wifiEnableVerboseLogging(
WIFI_VERBOSE_LOGGING_DISABLED)
finally:
for ad in self.android_devices:
try:
toggle_airplane_mode(self.log,
ad,
True,
strict_checking=False)
except BrokenPipeError:
# Broken Pipe, can not call SL4A API to turn on Airplane Mode.
# Use adb command to turn on Airplane Mode.
if not force_airplane_mode(ad, True):
self.log.error(
"Can not turn on airplane mode on:{}".format(
ad.serial))
return True
def test_smoke_wfc_call_sms(self):
ads = self.android_devices
sms_idle_result = False
sms_incall_result = False
call_result = False
self.log.info("--------start test_smoke_wfc_call_sms--------")
for ad in [ads[0], ads[1]]:
if not ad.droid.imsIsWfcEnabledByPlatform():
self.log.info("WFC not supported by platform.")
return True
try:
ensure_phones_default_state(self.log, ads)
tasks = [(phone_setup_iwlan,
(self.log, ads[0], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass)),
(phone_setup_iwlan,
(self.log, ads[1], True, WFC_MODE_WIFI_PREFERRED,
self.wifi_network_ssid, self.wifi_network_pass))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up WiFI Calling.")
return False
self.log.info("1. Verify SMS in idle.")
if sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(50)]):
sms_idle_result = True
self.log.info("2. Setup WiFi Call.")
if not call_setup_teardown(
self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_iwlan,
verify_callee_func=is_phone_in_call_iwlan):
self.log.error("Setup WiFi Call Failed.")
self.log.info("sms_idle_result:{}".format(sms_idle_result))
return False
self.log.info("3. Verify SMS in call.")
if sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(51)]):
sms_incall_result = True
self.log.info("4. Verify Call not drop and hangup.")
if (is_phone_in_call_iwlan(self.log, ads[0])
and is_phone_in_call_iwlan(self.log, ads[1])
and hangup_call(self.log, ads[0])):
call_result = True
return (call_result and sms_idle_result and sms_incall_result)
finally:
self.log.info(
"Summary for test run. Testbed:<{}>. <WFC> SMS idle: {}, "
"SMS in call: {}, Voice Call: {}".format(
getattr(self, Config.ikey_testbed_name.value),
sms_idle_result, sms_incall_result, call_result))
def setup_test(self):
if getattr(self, "diag_logger", None):
for logger in self.diag_logger:
self.log.info("Starting a diagnostic session %s", logger)
self.logger_sessions.append((logger, logger.start()))
if self.skip_reset_between_cases:
ensure_phones_idle(self.log, self.android_devices)
ensure_phones_default_state(self.log, self.android_devices)
def test_smoke_data_airplane_mode_network_switch_tethering(self):
try:
ads = self.android_devices
apm_result = False
nw_switch_result = False
tethering_result = False
self.log.info("--------start test_smoke_data_airplane_mode_network"
"_switch_tethering--------")
ensure_phones_default_state(self.log, ads)
self.log.info("1. Verify toggle airplane mode.")
apm_result = airplane_mode_test(self.log, ads[0])
self.log.info("2. Verify LTE-WiFi network switch.")
nw_switch_result = wifi_cell_switching(self.log, ads[0],
self.wifi_network_ssid,
self.wifi_network_pass,
GEN_4G)
if ads[0].droid.carrierConfigIsTetheringModeAllowed(
TETHERING_MODE_WIFI,
MAX_WAIT_TIME_TETHERING_ENTITLEMENT_CHECK):
self.log.info("3. Verify WiFi Tethering.")
if ads[0].droid.wifiIsApEnabled():
WifiUtils.stop_wifi_tethering(self.log, ads[0])
tethering_result = wifi_tethering_setup_teardown(
self.log,
ads[0], [ads[1]],
ap_band=WifiUtils.WIFI_CONFIG_APBAND_2G,
check_interval=10,
check_iteration=4)
# check_interval=10, check_iteration=4: in this Smoke test,
# check tethering connection for 4 times, each time delay 10s,
# to provide a reasonable check_time (10*4=40s) and also reduce test
# execution time. In regular test, check_iteration is set to 10.
else:
self.log.info("3. Skip WiFi Tethering."
"Tethering not allowed on SIM.")
tethering_result = SKIP
return (apm_result and nw_switch_result and
((tethering_result is True) or (tethering_result == SKIP)))
finally:
self.log.info(
"Summary for test run. Testbed:<{}>. <Data> Airplane Mode: {}, "
"WiFi-Cell Network Switch: {}, Tethering: {}".format(
getattr(self, Config.ikey_testbed_name.value), apm_result,
nw_switch_result, tethering_result))
def setup_test(self):
for ad in self.android_devices:
refresh_droid_config(self.log, ad)
if getattr(self, "diag_logger", None):
for logger in self.diag_logger:
self.log.info(
"Starting a diagnostic session {}".format(logger))
self.logger_sessions.append((logger, logger.start()))
return ensure_phones_default_state(self.log, self.android_devices)
def _test_setup(self,
apm=False,
rat=None,
volte=False,
wifi=None,
wfc=False,
mobile_data_always_on=False,
periodic_ping=False,
active_call=False):
if not ensure_phones_default_state(self.log, self.android_devices):
self.log.error("Fail to set phones in default state")
return False
else:
self.log.info("Set phones in default state successfully")
if apm and not self._setup_apm(): return False
if rat and not self._setup_rat(rat, volte): return False
if wifi and not self._setup_wifi(wifi): return False
if wfc and not self._setup_wfc(): return False
if mobile_data_always_on: set_mobile_data_always_on(self.ad, True)
if periodic_ping and not self._start_alarm(): return False
if active_call and not self._setup_phone_active_call(): return False
self.ad.droid.goToSleepNow()
return True
def test_smoke_volte_call_data_sms(self):
try:
ads = self.android_devices
sms_idle_result = False
sms_incall_result = False
data_idle_result = False
data_incall_result = False
call_result = False
self.log.info(
"--------start test_smoke_volte_call_data_sms--------")
ensure_phones_default_state(self.log, ads)
tasks = [(phone_setup_volte, (self.log, ads[0])),
(phone_setup_volte, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up VoLTE.")
return False
# This is to reduce call fail in VoLTE mode.
# TODO: b/26338170 remove sleep, use proper API to check DUT status.
time.sleep(10)
self.log.info("1. SMS in LTE idle.")
sms_idle_result = sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(50)])
self.log.info("2. Data in LTE idle.")
if (wait_for_cell_data_connection(self.log, ads[0], True)
and verify_http_connection(self.log, ads[0])):
data_idle_result = True
self.log.info("3. Setup VoLTE Call.")
if not call_setup_teardown(
self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_volte,
verify_callee_func=is_phone_in_call_volte,
wait_time_in_call=WAIT_TIME_IN_CALL_FOR_IMS):
self.log.error("Setup VoLTE Call Failed.")
return False
self.log.info("4. Verify SMS in call.")
sms_incall_result = sms_send_receive_verify(
self.log, ads[0], ads[1], [rand_ascii_str(51)])
self.log.info("5. Verify Data in call.")
if (wait_for_cell_data_connection(self.log, ads[0], True)
and verify_http_connection(self.log, ads[0])):
data_incall_result = True
self.log.info("6. Verify Call not drop and hangup.")
if (is_phone_in_call_volte(self.log, ads[0])
and is_phone_in_call_volte(self.log, ads[1])
and hangup_call(self.log, ads[0])):
call_result = True
return (sms_idle_result and data_idle_result and call_result
and sms_incall_result and data_incall_result)
finally:
self.log.info(
"Summary for test run. Testbed:<{}>. <VoLTE> SMS idle: {}, "
"Data idle: {}, SMS in call: {}, Data in call: {}, "
"Voice Call: {}".format(
getattr(self, Config.ikey_testbed_name.value),
sms_idle_result, data_idle_result, sms_incall_result,
data_incall_result, call_result))
def test_smoke_3g_call_data_sms(self):
try:
ads = self.android_devices
sms_idle_result = False
sms_incall_result = False
data_idle_result = False
data_incall_result = False
call_result = False
self.log.info("--------start test_smoke_3g_call_data_sms--------")
ensure_phones_default_state(self.log, ads)
tasks = [(phone_setup_voice_3g, (self.log, ads[0])),
(phone_setup_voice_3g, (self.log, ads[1]))]
if not multithread_func(self.log, tasks):
self.log.error("Phone Failed to Set Up 3G.")
return False
self.log.info("1. SMS in 3G idle.")
sms_idle_result = sms_send_receive_verify(self.log, ads[0], ads[1],
[rand_ascii_str(50)])
self.log.info("2. Data in 3G idle.")
if (wait_for_cell_data_connection(self.log, ads[0], True)
and verify_http_connection(self.log, ads[0])):
data_idle_result = True
self.log.info("3. Setup 3G Call.")
if not call_setup_teardown(self.log,
ads[0],
ads[1],
ad_hangup=None,
verify_caller_func=is_phone_in_call_3g,
verify_callee_func=is_phone_in_call_3g):
self.log.error("Setup 3G Call Failed.")
return False
self.log.info("4. Verify SMS in call.")
sms_incall_result = sms_send_receive_verify(
self.log, ads[0], ads[1], [rand_ascii_str(51)])
self.log.info("5. Verify Data in call.")
if is_rat_svd_capable(
get_network_rat(self.log, ads[0], NETWORK_SERVICE_VOICE)):
if (wait_for_cell_data_connection(self.log, ads[0], True)
and verify_http_connection(self.log, ads[0])):
data_incall_result = True
else:
self.log.info("Data in call not supported on current RAT."
"Skip Data verification.")
data_incall_result = SKIP
self.log.info("6. Verify Call not drop and hangup.")
if (is_phone_in_call_3g(self.log, ads[0])
and is_phone_in_call_3g(self.log, ads[1])
and hangup_call(self.log, ads[0])):
call_result = True
return (sms_idle_result and data_idle_result and call_result
and sms_incall_result and ((data_incall_result is True) or
(data_incall_result == SKIP)))
finally:
self.log.info(
"Summary for test run. Testbed:<{}>. <3G> SMS idle: {}, "
"Data idle: {}, SMS in call: {}, Data in call: {}, "
"Voice Call: {}".format(
getattr(self, Config.ikey_testbed_name.value),
sms_idle_result, data_idle_result, sms_incall_result,
data_incall_result, call_result))
def teardown_test(self):
if not super(BluetoothCarHfpBaseTest, self).teardown_test():
return False
return ensure_phones_default_state(self.log, self.android_devices[1:])
def test_pre_flight_check(self):
return ensure_phones_default_state(self.log, self.android_devices)
def setup_class(self):
sim_conf_file = self.user_params.get("sim_conf_file")
if not sim_conf_file:
self.log.info("\"sim_conf_file\" is not provided test bed config!")
else:
# If the sim_conf_file is not a full path, attempt to find it
# relative to the config file.
if not os.path.isfile(sim_conf_file):
sim_conf_file = os.path.join(
self.user_params[Config.key_config_path], sim_conf_file)
if not os.path.isfile(sim_conf_file):
self.log.error("Unable to load user config %s ",
sim_conf_file)
return False
setattr(
self, "diag_logger",
self.register_controller(acts.controllers.diag_logger,
required=False))
if not self.user_params.get("Attenuator"):
ensure_phones_default_state(self.log, self.android_devices)
else:
ensure_phones_idle(self.log, self.android_devices)
for ad in self.android_devices:
setup_droid_properties(self.log, ad, sim_conf_file)
# Setup VoWiFi MDN for Verizon. b/33187374
build_id = ad.build_info["build_id"]
if "vzw" in [
sub["operator"] for sub in ad.cfg["subscription"].values()
] and ad.is_apk_installed("com.google.android.wfcactivation"):
ad.log.info("setup VoWiFi MDN per b/33187374")
ad.adb.shell("setprop dbg.vzw.force_wfc_nv_enabled true")
ad.adb.shell("am start --ei EXTRA_LAUNCH_CARRIER_APP 0 -n "
"\"com.google.android.wfcactivation/"
".VzwEmergencyAddressActivity\"")
# Start telephony monitor
if not ad.is_apk_running("com.google.telephonymonitor"):
ad.log.info("TelephonyMonitor is not running, start it now")
ad.adb.shell(
'am broadcast -a '
'com.google.gservices.intent.action.GSERVICES_OVERRIDE -e '
'"ce.telephony_monitor_enable" "true"')
# Sub ID setup
initial_set_up_for_subid_infomation(self.log, ad)
if "enable_wifi_verbose_logging" in self.user_params:
ad.droid.wifiEnableVerboseLogging(WIFI_VERBOSE_LOGGING_ENABLED)
# If device is setup already, skip the following setup procedures
if getattr(ad, "telephony_test_setup", None):
continue
# Disable Emergency alerts
# Set chrome browser start with no-first-run verification and
# disable-fre. Give permission to read from and write to storage.
for cmd in (
"am start -n com.google.android.setupwizard/."
"SetupWizardExitActivity",
"pm disable com.android.cellbroadcastreceiver",
"pm grant com.android.chrome "
"android.permission.READ_EXTERNAL_STORAGE",
"pm grant com.android.chrome "
"android.permission.WRITE_EXTERNAL_STORAGE",
"rm /data/local/chrome-command-line",
"am set-debug-app --persistent com.android.chrome",
'echo "chrome --no-default-browser-check --no-first-run '
'--disable-fre" > /data/local/tmp/chrome-command-line'):
ad.adb.shell(cmd)
# Ensure that a test class starts from a consistent state that
# improves chances of valid network selection and facilitates
# logging.
try:
if not set_phone_screen_on(self.log, ad):
self.log.error("Failed to set phone screen-on time.")
return False
if not set_phone_silent_mode(self.log, ad):
self.log.error("Failed to set phone silent mode.")
return False
ad.droid.telephonyAdjustPreciseCallStateListenLevel(
PRECISE_CALL_STATE_LISTEN_LEVEL_FOREGROUND, True)
ad.droid.telephonyAdjustPreciseCallStateListenLevel(
PRECISE_CALL_STATE_LISTEN_LEVEL_RINGING, True)
ad.droid.telephonyAdjustPreciseCallStateListenLevel(
PRECISE_CALL_STATE_LISTEN_LEVEL_BACKGROUND, True)
except Exception as e:
self.log.error("Failure with %s", e)
setattr(ad, "telephony_test_setup", True)
return True
