def _rate_limit_charging_off(self, apk_type): """ Args: apk_type: SL4A APK type - 'Q' for android Q and 'P' for android P Returns: Result True if Pass, False if Fail. """ try: self.ad.droid.wakeUpNow() if not ensure_wifi_connected(self.log, self.ad, self.wifi_network_ssid, self.wifi_network_pass): self.ad.log.error("Failed to connect to wifi") return False """ Disable Charging """ disable_usb_charging(self.ad) if apk_type == 'P': time_delta = self.get_all_cell_info_rate_limit( CELL_INFO_UPDATE_WAIT_TIME_LOW, 'low') elif apk_type == 'Q': time_delta = self.request_cell_info_update_rate_limit( CELL_INFO_UPDATE_WAIT_TIME_LOW, 'low') """ Enable Charging """ enable_usb_charging(self.ad) if int(time_delta) == RATE_LIMIT_LOW: return True else: return False except Exception as e: self.log.error("Exception in rate_limit function:" + str(e)) return False
def _account_registration(self, ad): toggle_airplane_mode_by_adb(self.log, ad, new_state=False) for cmd in _TYCHO_VERBOSE_LOGGING_CMDS: ad.adb.shell(cmd) if hasattr(ad, "user_account"): if self.check_project_fi_activated(ad, retries=2): ad.log.info("Project Fi is activated already") return True ad.exit_setup_wizard() if not ad.is_apk_installed("com.google.android.tradefed.account" ) and self.user_params.get( "account_util"): for _ in range(2): if self._install_account_util(ad): break else: ad.log.error( "Fail to install com.google.android.tradefed.account") return False ad.force_stop_apk(_TYCHO_PKG) if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Failed to connect to wifi") return False ad.log.info("Add google account") if not self._add_google_account(ad): ad.log.error("Failed to add google account") return False ad.adb.shell( 'am instrument -w -e account "*****@*****.**" -e password ' '"%s" -e sync true -e wait-for-checkin false ' 'com.google.android.tradefed.account/.AddAccount' % (ad.user_account, ad.user_password)) ad.log.info("Enable and activate tycho apk") if not ad.is_apk_installed(_TYCHO_PKG): ad.log.info("%s is not installed", _TYCHO_PKG) return False ad.adb.shell('pm enable %s' % _TYCHO_PKG) #ad.adb.shell(_TYCHO_SERVER_LAB_OVERRIDE_CMD) for i in range(1, self.activation_attemps + 1): if i == self.activation_attemps: ad.log.info("Reboot and try Fi activation again") reboot_device(ad) self.activate_fi_account(ad) if not self.check_project_fi_activated(ad): ad.log.error("Fail to activate Fi account on attempt-%s", i) if i == self.activation_attemps: return False else: ad.log.info("Fi account is activated successfully") break elif "Fi Network" in ad.adb.getprop("gsm.sim.operator.alpha"): ad.log.error("Google account is not provided for Fi Network") return False if not ensure_phone_subscription(self.log, ad): ad.log.error("Unable to find a valid subscription!") return False refresh_droid_config(self.log, ad) return True
def _teardown_device(self, ad): try: stop_qxdm_logger(ad) except Exception as e: self.log.error("Failure with %s", e) try: ad.droid.disableDevicePassword() except Exception as e: self.log.error("Failure with %s", e) if self.user_params.get("enable_connectivity_metrics", True): if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Failed to connect to wifi") force_connectivity_metrics_upload(ad) time.sleep(300) try: if "enable_wifi_verbose_logging" in self.user_params: ad.droid.wifiEnableVerboseLogging( WIFI_VERBOSE_LOGGING_DISABLED) except Exception as e: self.log.error("Failure with %s", e) try: if self.user_params.get("build_id_override", False) and self.user_params.get( "recover_build_id", False): recover_build_id(ad) except Exception as e: self.log.error("Failure with %s", e)
def connect_to_wifi(self): if not ensure_wifi_connected(self.log, self.dut, self.wifi_network_ssid, self.wifi_network_pass): self.dut.log.error("Fail to connected to WiFi") return False else: self.dut.log.info("Connected to WiFi") return True
def _wifi_connected_set_wfc_mode_change_wfc_mode( self, initial_wfc_mode, new_wfc_mode, is_wfc_available_in_initial_wfc_mode, is_wfc_available_in_new_wfc_mode, initial_setup_wifi=True, check_volte_after_wfc_disabled=False): if initial_setup_wifi and not ensure_wifi_connected( self.log, self.ad, self.wifi_network_ssid, self.wifi_network_pass): self.log.error("Failed to connect WiFi") return False # Set to initial_wfc_mode first, then change to new_wfc_mode for (wfc_mode, is_wfc_available) in \ [(initial_wfc_mode, is_wfc_available_in_initial_wfc_mode), (new_wfc_mode, is_wfc_available_in_new_wfc_mode)]: current_wfc_status = is_wfc_enabled(self.log, self.ad) self.log.info("Current WFC: {}, Set WFC to {}".format( current_wfc_status, wfc_mode)) if not set_wfc_mode(self.log, self.ad, wfc_mode): self.log.error("Failed to set WFC mode.") return False if is_wfc_available: if current_wfc_status: # Previous is True, after set it still need to be true # wait and check if DUT WFC got disabled. if wait_for_wfc_disabled(self.log, self.ad): self.log.error("WFC is not available.") return False else: # Previous is False, after set it will be true, # wait and check if DUT WFC got enabled. if not wait_for_wfc_enabled(self.log, self.ad): self.log.error("WFC is not available.") return False else: if current_wfc_status: # Previous is True, after set it will be false, # wait and check if DUT WFC got disabled. if not wait_for_wfc_disabled(self.log, self.ad): self.log.error("WFC is available.") return False else: # Previous is False, after set it still need to be false # Wait and check if DUT WFC got enabled. if wait_for_wfc_enabled(self.log, self.ad): self.log.error("WFC is available.") return False if check_volte_after_wfc_disabled and not wait_for_volte_enabled( self.log, self.ad, MAX_WAIT_TIME_VOLTE_ENABLED): self.log.error("Device failed to acquire VoLTE service") return False return True
def _idle_baseline_wifi_connected(ad): if not toggle_airplane_mode(self.log, ad, True): self.log.error("Phone failed to turn on airplane mode.") return False if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid_2g, self.wifi_network_pass_2g): self.log.error("WiFi connect failed") return False ad.droid.goToSleepNow() return True
def _wifi_connected_enable_wfc_teardown_wfc( self, tear_down_operation, initial_setup_wifi=True, initial_setup_wfc_mode=WFC_MODE_WIFI_PREFERRED, check_volte_after_wfc_disabled=False): if initial_setup_wifi and not ensure_wifi_connected( self.log, self.ad, self.wifi_network_ssid, self.wifi_network_pass): self.log.error("Failed to connect WiFi") return False if initial_setup_wfc_mode and not set_wfc_mode(self.log, self.ad, initial_setup_wfc_mode): self.log.error("Failed to set WFC mode.") return False if not phone_idle_iwlan(self.log, self.ad): self.log.error("WFC is not available.") return False # Tear Down WFC based on tear_down_operation if tear_down_operation == self._TEAR_DOWN_OPERATION_DISCONNECT_WIFI: if not WifiUtils.wifi_toggle_state(self.log, self.ad, False): self.log.error("Failed to turn off WiFi.") return False elif tear_down_operation == self._TEAR_DOWN_OPERATION_RESET_WIFI: if not WifiUtils.wifi_reset(self.log, self.ad, False): self.log.error("Failed to reset WiFi") return False elif tear_down_operation == self._TEAR_DOWN_OPERATION_DISABLE_WFC: if not set_wfc_mode(self.log, self.ad, WFC_MODE_DISABLED): self.log.error("Failed to turn off WFC.") return False else: self.log.error("No tear down operation") return False if not wait_for_not_network_rat(self.log, self.ad, RAT_FAMILY_WLAN, voice_or_data=NETWORK_SERVICE_DATA): self.log.error("Data Rat is still iwlan.") return False if not wait_for_wfc_disabled(self.log, self.ad): self.log.error("WFC is still available after turn off WFC.") return False # If VoLTE was previous available, after tear down WFC, DUT should have # VoLTE service. if check_volte_after_wfc_disabled and not wait_for_volte_enabled( self.log, self.ad, MAX_WAIT_TIME_VOLTE_ENABLED): self.log.error("Device failed to acquire VoLTE service") return False return True
def phone_setup_iwlan_for_subscription(log, ad, sub_id, is_airplane_mode, wfc_mode, wifi_ssid=None, wifi_pwd=None): """Phone setup function for epdg call test for subscription id. Set WFC mode according to wfc_mode. Set airplane mode according to is_airplane_mode. Make sure phone connect to WiFi. (If wifi_ssid is not None.) Wait for phone to be in iwlan data network type. Wait for phone to report wfc enabled flag to be true. Args: log: Log object. ad: Android device object. sub_id: subscription id. is_airplane_mode: True to turn on airplane mode. False to turn off airplane mode. wfc_mode: WFC mode to set to. wifi_ssid: WiFi network SSID. This is optional. If wifi_ssid is None, then phone_setup_iwlan will not attempt to connect to wifi. wifi_pwd: WiFi network password. This is optional. Returns: True if success. False if fail. """ # VoLTE settings are unavailable in airplane mode toggle_airplane_mode(log, ad, False) # Now that we are out of APM, toggle VoLTE if necessary if ad.droid.imsIsEnhanced4gLteModeSettingEnabledByPlatform(): toggle_volte(log, ad, True) if not is_airplane_mode and not ensure_network_generation_for_subscription( log, ad, sub_id, GEN_4G, voice_or_data=NETWORK_SERVICE_DATA): return False if not set_wfc_mode(log, ad, wfc_mode): log.error("{} set WFC mode failed.".format(ad.serial)) return False if not toggle_airplane_mode(log, ad, is_airplane_mode): log.error("Failed to enable airplane mode on {}".format(ad.serial)) return False if wifi_ssid is not None: if not ensure_wifi_connected(log, ad, wifi_ssid, wifi_pwd): log.error("{} connect to WiFi failed.".format(ad.serial)) return False return phone_idle_iwlan_for_subscription(log, ad, sub_id)
def _setup_wifi(self, wifi): if wifi == WIFI_5G: network_ssid = self.wifi_network_ssid_5g network_pass = self.wifi_network_pass_5g else: network_ssid = self.wifi_network_ssid_2g network_pass = self.wifi_network_pass_2g if not ensure_wifi_connected( self.log, self.ad, network_ssid, network_pass, retry=3): self.log.error("Wifi %s connection fails." % wifi) return False self.log.info("WIFI %s is connected successfully." % wifi) return True
def phone_setup_iwlan_cellular_preferred(log, ad, wifi_ssid=None, wifi_pwd=None): """Phone setup function for iwlan Non-APM CELLULAR_PREFERRED test. Set WFC mode according to CELLULAR_PREFERRED. Set airplane mode according to False. Make sure phone connect to WiFi. (If wifi_ssid is not None.) Make sure phone don't report iwlan data network type. Make sure phone don't report wfc enabled flag to be true. Args: log: Log object. ad: Android device object. wifi_ssid: WiFi network SSID. This is optional. If wifi_ssid is None, then phone_setup_iwlan will not attempt to connect to wifi. wifi_pwd: WiFi network password. This is optional. Returns: True if success. False if fail. """ toggle_airplane_mode(log, ad, False, strict_checking=False) try: toggle_volte(log, ad, True) if not wait_for_network_generation( log, ad, GEN_4G, voice_or_data=NETWORK_SERVICE_DATA): if not ensure_network_generation( log, ad, GEN_4G, voice_or_data=NETWORK_SERVICE_DATA): ad.log.error("Fail to ensure data in 4G") return False except Exception as e: ad.log.error(e) ad.droid.telephonyToggleDataConnection(True) if wifi_ssid is not None: if not ensure_wifi_connected(log, ad, wifi_ssid, wifi_pwd): ad.log.error("Connect to WiFi failed.") return False if not set_wfc_mode(log, ad, WFC_MODE_CELLULAR_PREFERRED): ad.log.error("Set WFC mode failed.") return False if not wait_for_not_network_rat( log, ad, RAT_FAMILY_WLAN, voice_or_data=NETWORK_SERVICE_DATA): ad.log.error("Data rat in iwlan mode.") return False elif not wait_for_wfc_disabled(log, ad, MAX_WAIT_TIME_WFC_ENABLED): ad.log.error("Should report wifi calling disabled within %s.", MAX_WAIT_TIME_WFC_ENABLED) return False return True
def test_check_environment(self): ad = self.android_devices[0] # Check WiFi environment. # 1. Connect to WiFi. # 2. Check WiFi have Internet access. try: if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): abort_all_tests(ad.log, "WiFi connect fail") if (not wait_for_wifi_data_connection(self.log, ad, True) or not verify_internet_connection(self.log, ad)): abort_all_tests(ad.log, "Data not available on WiFi") finally: wifi_toggle_state(self.log, ad, False) # TODO: add more environment check here. return True
def _basic_connectivity_check(self): """ Set Attenuator Value for WiFi and Cell to 0 Make sure DUT get Cell Data coverage (LTE) Make sure DUT WiFi is connected """ toggle_airplane_mode(self.log, self.android_devices[0], False) if not ensure_network_generation(self.log, self.android_devices[0], GEN_4G, NETWORK_SERVICE_DATA): return False if not ensure_wifi_connected(self.log, self.android_devices[0], self.live_network_ssid, self.live_network_pwd): ad.log.error("%s connect WiFI failed") return False return True
def _basic_connectivity_check(self): """ Set Attenuator Value for WiFi and Cell to 0 Make sure DUT get Cell Data coverage (LTE) Make sure DUT WiFi is connected """ ad = self.android_devices[0] toggle_airplane_mode(self.log, ad, False) if not ensure_network_generation(self.log, ad, GEN_4G, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA): return False if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("connect WiFi failed") return False return True
def _setup_wfc(self): if not ensure_wifi_connected( self.log, self.dut, self.wifi_network_ssid, self.wifi_network_pass, retry=3): self.dut.log.error("Phone Wifi connection fails.") return False self.dut.log.info("Phone WIFI is connected successfully.") if not set_wfc_mode(self.log, self.dut, WFC_MODE_WIFI_PREFERRED): self.dut.log.error("Phone failed to enable Wifi-Calling.") return False self.dut.log.info("Phone is set in Wifi-Calling successfully.") if not phone_idle_iwlan(self.log, self.dut): self.dut.log.error("Phone is not in WFC enabled state.") return False self.dut.log.info("Phone is in WFC enabled state.") return True
def _setup_wfc(self): for ad in self.android_devices: if not ensure_wifi_connected(ad.log, ad, self.wifi_network_ssid, self.wifi_network_pass, retries=3): ad.log.error("Phone Wifi connection fails.") return False ad.log.info("Phone WIFI is connected successfully.") if not set_wfc_mode(self.log, ad, WFC_MODE_WIFI_PREFERRED): ad.log.error("Phone failed to enable Wifi-Calling.") return False ad.log.info("Phone is set in Wifi-Calling successfully.") if not phone_idle_iwlan(self.log, ad): ad.log.error("Phone is not in WFC enabled state.") return False ad.log.info("Phone is in WFC enabled state.") return True
def test_check_environment(self): ad = self.android_devices[0] # Check WiFi environment. # 1. Connect to WiFi. # 2. Check WiFi have Internet access. toggle_airplane_mode(self.log, ad, False, strict_checking=False) try: if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): self._preflight_fail("{}: WiFi connect fail.".format( ad.serial)) if (not wait_for_wifi_data_connection(self.log, ad, True) or not verify_http_connection(self.log, ad)): self._preflight_fail("{}: Data not available on WiFi.".format( ad.serial)) finally: WifiUtils.wifi_toggle_state(self.log, ad, False) # TODO: add more environment check here. return True
def test_lte_volte_wfc_wifi_preferred_to_cellular_preferred_stress(self): """Test for WiFi Calling settings: LTE + VoLTE Enabled + WiFi Connected + WiFi Preferred, change WFC to Cellular Preferred stress Steps: 1. Setup DUT Idle, LTE network type, VoLTE enabled. 2. Make sure DUT WiFi connected, WFC is set to WiFi Preferred. Verify DUT WFC available, report iwlan rat. 3. Change WFC setting to Cellular Preferred. 4. Verify DUT report WFC not available. 5. Verify DUT report VoLTE available. 6. Repeat steps 3~5 for N times. Expected Results: 2. DUT WiFi Calling feature bit return True, network rat is iwlan. 4. DUT WiFI Calling feature bit return False, network rat is not iwlan. 5. DUT report VoLTE available. """ if not phone_setup_volte(self.log, self.ad): self.log.error("Failed to setup VoLTE.") return False if not ensure_wifi_connected(self.log, self.ad, self.wifi_network_ssid, self.wifi_network_pass): self.log.error("Failed to connect WiFi") return False for i in range(1, self.stress_test_number + 1): self.log.info("Start Iteration {}.".format(i)) result = self._wifi_connected_set_wfc_mode_change_wfc_mode( WFC_MODE_WIFI_PREFERRED, WFC_MODE_CELLULAR_PREFERRED, True, False, initial_setup_wifi=False, check_volte_after_wfc_disabled=True) if not result: self.log.error("Test Failed in iteration: {}.".format(i)) return False return True
def _setup_phone_mobile_data_always_on(self, ad, phone_setup_func, connect_wifi, wifi_ssid=None, wifi_password=None, mobile_data_always_on=True): set_mobile_data_always_on(ad, mobile_data_always_on) if not phone_setup_func(self.log, ad): self.log.error("Phone failed to setup {}.".format( phone_setup_func.__name__)) return False if (connect_wifi and not ensure_wifi_connected(self.log, ad, wifi_ssid, wifi_password)): self.log.error("WiFi connect failed") return False # simulate normal user behavior -- wake up every 1 minutes and do ping # (transmit data) if not self._start_alarm(): return False ad.droid.goToSleepNow() return True
def _wifi_connected_set_wfc_mode_turn_off_apm( self, wfc_mode, is_wfc_available_after_turn_off_apm): if not ensure_wifi_connected(self.log, self.ad, self.wifi_network_ssid, self.wifi_network_pass): self.log.error("Failed to connect WiFi") return False if not set_wfc_mode(self.log, self.ad, wfc_mode): self.log.error("Failed to set WFC mode.") return False if not phone_idle_iwlan(self.log, self.ad): self.log.error("WFC is not available.") return False if not toggle_airplane_mode(self.log, self.ad, False): self.log.error("Failed to turn off airplane mode") return False is_wfc_not_available = wait_for_wfc_disabled(self.log, self.ad) if is_wfc_available_after_turn_off_apm and is_wfc_not_available: self.log.error("WFC is not available.") return False elif (not is_wfc_available_after_turn_off_apm and not is_wfc_not_available): self.log.error("WFC is available.") return False return True
def wifi_tethering_setup_teardown(log, provider, client_list, ap_band=WifiUtils.WIFI_CONFIG_APBAND_2G, check_interval=30, check_iteration=4, do_cleanup=True, ssid=None, password=None): """Test WiFi Tethering. Turn off WiFi on clients. Turn off data and reset WiFi on clients. Verify no Internet access on clients. Turn on WiFi tethering on provider. Clients connect to provider's WiFI. Verify Internet on provider and clients. Tear down WiFi tethering setup and clean up. Args: log: log object. provider: android object provide WiFi tethering. client_list: a list of clients using tethered WiFi. ap_band: setup WiFi tethering on 2G or 5G. This is optional, default value is WifiUtils.WIFI_CONFIG_APBAND_2G check_interval: delay time between each around of Internet connection check. This is optional, default value is 30 (seconds). check_iteration: check Internet connection for how many times in total. This is optional, default value is 4 (4 times). do_cleanup: after WiFi tethering test, do clean up to tear down tethering setup or not. This is optional, default value is True. ssid: use this string as WiFi SSID to setup tethered WiFi network. This is optional. Default value is None. If it's None, a random string will be generated. password: use this string as WiFi password to setup tethered WiFi network. This is optional. Default value is None. If it's None, a random string will be generated. Returns: True if no error happened. False otherwise. """ log.info("--->Start wifi_tethering_setup_teardown<---") log.info("Provider: {}".format(provider.serial)) if not provider.droid.connectivityIsTetheringSupported(): log.error("Provider does not support tethering. Stop tethering test.") return False if ssid is None: ssid = rand_ascii_str(10) if password is None: password = rand_ascii_str(8) # No password if password == "": password = None try: for client in client_list: log.info("Client: {}".format(client.serial)) WifiUtils.wifi_toggle_state(log, client, False) client.droid.telephonyToggleDataConnection(False) log.info("WiFI Tethering: Verify client have no Internet access.") for client in client_list: if verify_http_connection(log, client): log.error("Turn off Data on client fail. {}".format( client.serial)) return False log.info( "WiFI Tethering: Turn on WiFi tethering on {}. SSID: {}, password: {}".format( provider.serial, ssid, password)) if not WifiUtils.start_wifi_tethering(log, provider, ssid, password, ap_band): log.error("Provider start WiFi tethering failed.") return False time.sleep(WAIT_TIME_ANDROID_STATE_SETTLING) log.info("Provider {} check Internet connection.".format( provider.serial)) if not verify_http_connection(log, provider): return False for client in client_list: log.info( "WiFI Tethering: {} connect to WiFi and verify AP band correct.".format( client.serial)) if not ensure_wifi_connected(log, client, ssid, password): log.error("Client connect to WiFi failed.") return False wifi_info = client.droid.wifiGetConnectionInfo() if ap_band == WifiUtils.WIFI_CONFIG_APBAND_5G: if wifi_info["is_24ghz"]: log.error("Expected 5g network. WiFi Info: {}".format( wifi_info)) return False else: if wifi_info["is_5ghz"]: log.error("Expected 2g network. WiFi Info: {}".format( wifi_info)) return False log.info("Client{} check Internet connection.".format( client.serial)) if (not wait_for_wifi_data_connection(log, client, True) or not verify_http_connection(log, client)): log.error("No WiFi Data on client: {}.".format(client.serial)) return False if not tethering_check_internet_connection( log, provider, client_list, check_interval, check_iteration): return False finally: if (do_cleanup and (not wifi_tethering_cleanup(log, provider, client_list))): return False return True
def test_carrier_id_update_wifi_disconnected(self): """Carrier Id Version Test with WiFi disconnected 1. WiFi is connected 2. Perform setup steps to cleanup shared_prefs 3. Send P/H flag update to configUpdater 4. Wait for 5 mins and keep checking for version match """ try: result_flag = False time_var = 1 ad = self.android_devices[0] ad.log.info("Before - CarrierId is %s", get_carrier_id_version(ad)) # Wifi Disconnect cleanup_configupdater(ad) wifi_toggle_state(ad.log, ad, False) # Trigger Config Update ad.log.info("Triggering Config Update") ad.log.info("%s", CARRIER_ID_METADATA_URL) exe_cmd("adb -s %s shell %s" % (ad.serial, CARRIER_ID_METADATA_URL)) ad.log.info("%s", CARRIER_ID_CONTENT_URL) exe_cmd("adb -s %s shell %s" % (ad.serial, CARRIER_ID_CONTENT_URL)) # Wait for 5 mins for Carrier Id version upgrade while (time_var < WAIT_TIME_FOR_CARRIERID_CHANGE): current_version = get_carrier_id_version(ad) if current_version == CARRIER_ID_VERSION: ad.log.info("After CarrierId is %s in %s mins", current_version, time_var) return False else: ad.log.debug("Carrier Id Version Not Match") time.sleep(60) time_var += 1 time_var = 1 ad.log.info("Success - CarrierId not upgraded during WiFi OFF") # WiFi Connect if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("connect WiFi failed") return False # Wait for 5 mins for Carrier Id version upgrade while (time_var < WAIT_TIME_FOR_CARRIERID_CHANGE): current_version = get_carrier_id_version(ad) if current_version == CARRIER_ID_VERSION: ad.log.info("After CarrierId is %s in %s mins", current_version, time_var) result_flag = True break else: ad.log.debug("Carrier Id Version Not Match") time.sleep(60) time_var += 1 if not result_flag: ad.log.info("Carrier Id Failed to Update in %s mins", WAIT_TIME_FOR_CARRIERID_CHANGE) # pb file check out = ad.adb.shell("ls -l data/misc/carrierid/carrier_list.pb") if not out or "No such" in out: ad.log.error("carrier_list.pb file is missing") result_flag = False else: ad.log.info("carrier_list.pb file is present") return result_flag except Exception as e: ad.log.error(e) return False finally: carrier_id_path = os.path.join(self.log_path, self.test_name, "CarrierId_%s" % ad.serial) pull_carrier_id_files(ad, carrier_id_path)
def test_emergency_database_update_wifi_connected(self): """Emergency DB Id Version Test after WiFi Connected 1. WiFi is connected 2. Login with whitelisted gmail credentials 3. Wait for 5 mins and keep checking for version match """ try: result_flag = False time_var = 1 ad = self.android_devices[0] # Get the Emergency database Id ad.log.info("Before - Emergency DB Id is %s", get_er_db_id_version(ad)) # Connect to Wifi if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("connect WiFi failed") return False time.sleep(5) #Login with whitelisted google account if not install_googleaccountutil_apk(ad, self.path): ad.log.error("Failed to install Google Util") return False if not add_whitelisted_account(ad, self.user_account, self.user_password): ad.log.error("Failed to Login with Google Account") return False # Wait for 5 mins for Emergency database Id version upgrade while (time_var < WAIT_TIME_FOR_ER_DB_CHANGE): current_version = get_er_db_id_version(ad) if current_version == ER_DB_ID_VERSION: ad.log.info("ER DB version is %s in %s mins", current_version, time_var) result_flag = True break else: ad.log.debug("ER Database Version Id Not Match") time.sleep(60) time_var += 1 if not result_flag: ad.log.info( "ER Database version Id Failed to Update in %s mins", WAIT_TIME_FOR_ER_DB_CHANGE) return False # Verify Emerency Database content if not get_database_content(ad): ad.log.error("Emergency Number does not match") result_flag = False return False ad.log.info("Emergency Number is 54321") except Exception as e: ad.log.error(e) return False finally: return result_flag
def phone_setup_iwlan_for_subscription(log, ad, sub_id, is_airplane_mode, wfc_mode, wifi_ssid=None, wifi_pwd=None): """Phone setup function for epdg call test for subscription id. Set WFC mode according to wfc_mode. Set airplane mode according to is_airplane_mode. Make sure phone connect to WiFi. (If wifi_ssid is not None.) Wait for phone to be in iwlan data network type. Wait for phone to report wfc enabled flag to be true. Args: log: Log object. ad: Android device object. sub_id: subscription id. is_airplane_mode: True to turn on airplane mode. False to turn off airplane mode. wfc_mode: WFC mode to set to. wifi_ssid: WiFi network SSID. This is optional. If wifi_ssid is None, then phone_setup_iwlan will not attempt to connect to wifi. wifi_pwd: WiFi network password. This is optional. Returns: True if success. False if fail. """ toggle_airplane_mode(log, ad, is_airplane_mode, strict_checking=False) # check if WFC supported phones if wfc_mode != WFC_MODE_DISABLED and not ad.droid.imsIsWfcEnabledByPlatform( ): ad.log.error("WFC is not enabled on this device by checking " "ImsManager.isWfcEnabledByPlatform") return False if wifi_ssid is not None: if not ensure_wifi_connected(log, ad, wifi_ssid, wifi_pwd): ad.log.error("Fail to bring up WiFi connection on %s.", wifi_ssid) return False if not set_wfc_mode(log, ad, wfc_mode): ad.log.error("Unable to set WFC mode to %s.", wfc_mode) return False if not wait_for_wfc_enabled(log, ad, max_time=MAX_WAIT_TIME_WFC_ENABLED): ad.log.error("WFC is not enabled") return False if wait_for_network_rat_for_subscription( log, ad, sub_id, RAT_FAMILY_WLAN, voice_or_data=NETWORK_SERVICE_DATA): ad.log.info( "Data rat is in iwlan mode successfully with APM %s WFC %s", is_airplane_mode, wfc_mode) return True else: ad.log.error( "Unable to bring data rat in iwlan mode with APM %s WFC %s", is_airplane_mode, wfc_mode) return False
def change_ims_setting(self, airplane_mode, wifi_enabled, volte_enabled, wfc_enabled, wfc_mode=None): result = True self.dut.log.info( "Setting APM %s, WIFI %s, VoLTE %s, WFC %s, WFC mode %s", airplane_mode, wifi_enabled, volte_enabled, wfc_enabled, wfc_mode) toggle_airplane_mode_by_adb(self.log, self.dut, airplane_mode) if wifi_enabled: if not ensure_wifi_connected(self.log, self.dut, self.wifi_network_ssid, self.wifi_network_pass, apm=airplane_mode): self.dut.log.error("Fail to connected to WiFi") result = False else: if not wifi_toggle_state(self.log, self.dut, False): self.dut.log.error("Failed to turn off WiFi.") result = False toggle_volte(self.log, self.dut, volte_enabled) toggle_wfc(self.log, self.dut, wfc_enabled) if wfc_mode: set_wfc_mode(self.log, self.dut, wfc_mode) wfc_mode = self.dut.droid.imsGetWfcMode() if wifi_enabled or not airplane_mode: if not ensure_phone_subscription(self.log, self.dut): self.dut.log.error("Failed to find valid subscription") result = False if airplane_mode: if (CAPABILITY_WFC in self.dut_capabilities) and (wifi_enabled and wfc_enabled): if not wait_for_wfc_enabled(self.log, self.dut): result = False elif not self.check_call_in_wfc(): result = False else: if not wait_for_state( self.dut.droid.telephonyGetCurrentVoiceNetworkType, RAT_UNKNOWN): self.dut.log.error( "Voice RAT is %s not UNKNOWN", self.dut.droid.telephonyGetCurrentVoiceNetworkType()) result = False else: self.dut.log.info("Voice RAT is in UNKKNOWN") else: if (wifi_enabled and wfc_enabled) and ( wfc_mode == WFC_MODE_WIFI_PREFERRED) and ( CAPABILITY_WFC in self.dut_capabilities): if not wait_for_wfc_enabled(self.log, self.dut): result = False if not wait_for_state( self.dut.droid.telephonyGetCurrentVoiceNetworkType, RAT_UNKNOWN): self.dut.log.error( "Voice RAT is %s, not UNKNOWN", self.dut.droid.telephonyGetCurrentVoiceNetworkType()) if not self.check_call_in_wfc(): result = False else: if not wait_for_wfc_disabled(self.log, self.dut): self.dut.log.error("WFC is not disabled") result = False if volte_enabled and CAPABILITY_VOLTE in self.dut_capabilities: if not wait_for_volte_enabled(self.log, self.dut): result = False if not self.check_call_in_volte(): result = False else: if not wait_for_not_network_rat( self.log, self.dut, RAT_LTE, voice_or_data=NETWORK_SERVICE_VOICE): self.dut.log.error( "Voice RAT is %s", self.dut.droid.telephonyGetCurrentVoiceNetworkType( )) result = False if not wait_for_voice_attach(self.log, self.dut): result = False if not self.check_call(): result = False user_config_profile = get_user_config_profile(self.dut) self.dut.log.info("user_config_profile: %s ", sorted(user_config_profile.items())) return result
def wifi_cell_switching(log, ad, wifi_network_ssid, wifi_network_pass, nw_gen): """Test data connection network switching when phone on <nw_gen>. Ensure phone is on <nw_gen> Ensure WiFi can connect to live network, Airplane mode is off, data connection is on, WiFi is on. Turn off WiFi, verify data is on cell and browse to google.com is OK. Turn on WiFi, verify data is on WiFi and browse to google.com is OK. Turn off WiFi, verify data is on cell and browse to google.com is OK. Args: log: log object. ad: android object. wifi_network_ssid: ssid for live wifi network. wifi_network_pass: password for live wifi network. nw_gen: network generation the phone should be camped on. Returns: True if pass. """ try: if not ensure_network_generation_for_subscription( log, ad, get_default_data_sub_id(ad), nw_gen, MAX_WAIT_TIME_NW_SELECTION, NETWORK_SERVICE_DATA): log.error("Device failed to register in {}".format(nw_gen)) return False # Ensure WiFi can connect to live network log.info("Make sure phone can connect to live network by WIFI") if not ensure_wifi_connected(log, ad, wifi_network_ssid, wifi_network_pass): log.error("WiFi connect fail.") return False log.info("Phone connected to WIFI.") log.info("Step1 Airplane Off, WiFi On, Data On.") toggle_airplane_mode(log, ad, False) WifiUtils.wifi_toggle_state(log, ad, True) ad.droid.telephonyToggleDataConnection(True) if (not wait_for_wifi_data_connection(log, ad, True) or not verify_http_connection(log, ad)): log.error("Data is not on WiFi") return False log.info("Step2 WiFi is Off, Data is on Cell.") WifiUtils.wifi_toggle_state(log, ad, False) if (not wait_for_cell_data_connection(log, ad, True) or not verify_http_connection(log, ad)): log.error("Data did not return to cell") return False log.info("Step3 WiFi is On, Data is on WiFi.") WifiUtils.wifi_toggle_state(log, ad, True) if (not wait_for_wifi_data_connection(log, ad, True) or not verify_http_connection(log, ad)): log.error("Data did not return to WiFi") return False log.info("Step4 WiFi is Off, Data is on Cell.") WifiUtils.wifi_toggle_state(log, ad, False) if (not wait_for_cell_data_connection(log, ad, True) or not verify_http_connection(log, ad)): log.error("Data did not return to cell") return False return True finally: WifiUtils.wifi_toggle_state(log, ad, False)
def _make_phone_call(self, call_verification_func=None): ads = self.android_devices[:] if not self.single_phone_test: random.shuffle(ads) the_number = self.result_info["Call Total"] + 1 duration = random.randrange(self.min_phone_call_duration, self.max_phone_call_duration) result = True test_name = "%s_No_%s_phone_call" % (self.test_name, the_number) log_msg = "[Test Case] %s" % test_name self.log.info("%s for %s seconds begin", log_msg, duration) begin_time = get_device_epoch_time(ads[0]) for ad in self.android_devices: if self.user_params.get("turn_on_tcpdump", True): start_adb_tcpdump(ad, interface="any", mask="all") if not getattr(ad, "droid", None): ad.droid, ad.ed = ad.get_droid() ad.ed.start() else: try: if not ad.droid.is_live: ad.droid, ad.ed = ad.get_droid() ad.ed.start() else: ad.ed.clear_all_events() except Exception: ad.log.info("Create new sl4a session for phone call") ad.droid, ad.ed = ad.get_droid() ad.ed.start() ad.droid.logI("%s begin" % log_msg) start_qxdm_loggers(self.log, self.android_devices, begin_time) failure_reasons = set() self.dut_incall = True if self.single_phone_test: call_setup_result = initiate_call( self.log, self.dut, self.call_server_number, incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND ) and wait_for_in_call_active(self.dut, 60, 3) else: call_setup_result = call_setup_teardown( self.log, ads[0], ads[1], ad_hangup=None, verify_caller_func=call_verification_func, verify_callee_func=call_verification_func, wait_time_in_call=0, incall_ui_display=INCALL_UI_DISPLAY_BACKGROUND) if not call_setup_result: call_logs = ads[0].search_logcat( "ActivityManager: START u0 {act=android.intent.action.CALL", begin_time) messaging_logs = ads[0].search_logcat( "com.google.android.apps.messaging/.ui.conversation.ConversationActivity", begin_time) if call_logs and messaging_logs: if messaging_logs[-1]["datetime_obj"] - call_logs[-1]["datetime_obj"] < 5: ads[0].log.info( "Call setup failure due to simultaneous activities") self.result_info[ "Call Setup Failure With Simultaneous Activity"] += 1 return True self.log.error("%s: Setup Call failed.", log_msg) failure_reasons.add("Setup") result = False else: elapsed_time = 0 check_interval = 5 while (elapsed_time < duration): check_interval = min(check_interval, duration - elapsed_time) time.sleep(check_interval) elapsed_time += check_interval time_message = "at <%s>/<%s> second." % (elapsed_time, duration) for ad in ads: if not call_verification_func(self.log, ad): ad.log.warning("Call is NOT in correct %s state at %s", call_verification_func.__name__, time_message) if call_verification_func.__name__ == "is_phone_in_call_iwlan": if is_phone_in_call(self.log, ad): if getattr(ad, "data_rat_state_error_count", 0) < 1: setattr(ad, "data_rat_state_error_count", 1) continue failure_reasons.add("Maintenance") last_call_drop_reason(ad, begin_time) hangup_call(self.log, ads[0]) result = False else: ad.log.info("Call is in correct %s state at %s", call_verification_func.__name__, time_message) if not result: break if not hangup_call(self.log, ads[0]): failure_reasons.add("Teardown") result = False for ad in ads: if not wait_for_call_id_clearing(ad, []) or ad.droid.telecomIsInCall(): ad.log.error("Fail to hang up call") failure_reasons.add("Teardown") result = False self.result_info["Call Total"] += 1 for ad in self.android_devices: try: ad.droid.logI("%s end" % log_msg) except: pass self.log.info("%s end", log_msg) self.dut_incall = False if not result: self.log.info("%s failed", log_msg) if self.gps_log_file: gps_info = job.run( "tail %s" % self.gps_log_file, ignore_status=True) if gps_info.stdout: gps_log_path = os.path.join(self.log_path, test_name, "gps_logs.txt") utils.create_dir(gps_log_path) job.run( "tail %s > %s" % (self.gps_log_file, gps_log_path), ignore_status=True) self.log.info("gps log:\n%s", gps_info.stdout) else: self.log.warning("Fail to get gps log %s", self.user_params["gps_log_file"]) for reason in failure_reasons: self.result_info["Call %s Failure" % reason] += 1 for ad in ads: log_path = os.path.join(self.log_path, test_name, "%s_binder_logs" % ad.serial) utils.create_dir(log_path) ad.pull_files(BINDER_LOGS, log_path) try: self._take_bug_report(test_name, begin_time) except Exception as e: self.log.exception(e) for ad in ads: if ad.droid.telecomIsInCall(): hangup_call_by_adb(ad) else: self.log.info("%s test succeed", log_msg) self.result_info["Call Success"] += 1 if self.result_info["Call Total"] % 50 == 0: for ad in ads: synchronize_device_time(ad) if not check_is_wifi_connected(self.log, ad, self.wifi_network_ssid): ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass) force_connectivity_metrics_upload(ad) time.sleep(300) wifi_toggle_state(self.log, ad, False) if self.get_binder_logs: log_path = os.path.join(self.log_path, "%s_binder_logs" % test_name, "%s_binder_logs" % ad.serial) utils.create_dir(log_path) ad.pull_files(BINDER_LOGS, log_path) return result
def test_wifi_cell_switching_stress(self): """Test for data switch between WiFi and Cell. DUT go in and out WiFi coverage for multiple times. Steps: 1. Set WiFi and Cellular signal to good (attenuation value to MIN). 2. Make sure DUT get Cell data coverage (LTE) and WiFi connected. 3. Set WiFi RSSI to MAX (WiFi attenuator value to MIN). 4. Verify DUT report WiFi connected and Internet access OK. 5. Set WiFi RSSI to MIN (WiFi attenuator value to MAX). 6. Verify DUT report Cellular Data connected and Internet access OK. 7. Repeat Step 3~6 for stress number. Expected Results: 4. DUT report WiFi connected and Internet access OK. 6. DUT report Cellular Data connected and Internet access OK. 7. Stress test should pass. Returns: True if Pass. False if fail. """ WIFI_RSSI_CHANGE_STEP_SIZE = 2 WIFI_RSSI_CHANGE_DELAY_PER_STEP = 1 # Set Attenuator Value for WiFi and Cell to 0. set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI], 0, MAX_RSSI_RESERVED_VALUE) set_rssi(self.log, self.attens[ATTEN_NAME_FOR_CELL], 0, MAX_RSSI_RESERVED_VALUE) # Make sure DUT get Cell Data coverage (LTE). toggle_airplane_mode(self.log, self.android_devices[0], False) if not ensure_network_generation(self.log, self.android_devices[0], GEN_4G, NETWORK_SERVICE_DATA): return False # Make sure DUT WiFi is connected. if not ensure_wifi_connected(self.log, self.android_devices[0], self.live_network_ssid, self.live_network_pwd): self.log.error("{} connect WiFI failed".format( self.android_devices[0].serial)) return False total_iteration = self.stress_test_number self.log.info("Stress test. Total iteration = {}.".format( total_iteration)) current_iteration = 1 while (current_iteration <= total_iteration): self.log.info(">----Current iteration = {}/{}----<".format( current_iteration, total_iteration)) # Set WiFi RSSI to MAX. set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI], 0, MAX_RSSI_RESERVED_VALUE, WIFI_RSSI_CHANGE_STEP_SIZE, WIFI_RSSI_CHANGE_DELAY_PER_STEP) # Wait for DUT report WiFi connected and Internet access OK. if (not wait_for_wifi_data_connection( self.log, self.android_devices[0], True) or not verify_http_connection(self.log, self.android_devices[0])): self.log.error("Data not on WiFi") break # Set WiFi RSSI to MIN (DUT lose WiFi coverage). set_rssi(self.log, self.attens[ATTEN_NAME_FOR_WIFI], 0, MIN_RSSI_RESERVED_VALUE, WIFI_RSSI_CHANGE_STEP_SIZE, WIFI_RSSI_CHANGE_DELAY_PER_STEP) # Wait for DUT report Cellular Data connected and Internet access OK. if (not wait_for_cell_data_connection( self.log, self.android_devices[0], True) or not verify_http_connection(self.log, self.android_devices[0])): self.log.error("Data not on Cell") break self.log.info(">----Iteration : {}/{} succeed.----<".format( current_iteration, total_iteration)) current_iteration += 1 if current_iteration <= total_iteration: self.log.info(">----Iteration : {}/{} failed.----<".format( current_iteration, total_iteration)) return False else: return True
def test_carrier_config_version_after_fdr(self): """Carrier Config Version Test after FDR 1. Disable Verity, remount, push carriersettings apk 2. WiFi is connected 3. Perform FDR, and re-connect WiFi 4. Wait for 45 mins and keep checking for version match """ try: cc_version_mapping = { 'vzw': VZW_CARRIER_CONFIG_VERSION, 'Verizon': VZW_CARRIER_CONFIG_VERSION, 'att': ATT_CARRIER_CONFIG_VERSION, } result_flag = False time_var = 1 ad = self.android_devices[0] skip_setup_wizard = True # CarrierSettingsApk carriersettingsapk = self.user_params["carriersettingsapk"] if isinstance(carriersettingsapk, list): carriersettingsapk = carriersettingsapk[0] ad.log.info("Using file path %s", carriersettingsapk) if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("connect WiFi failed") return False # Setup Steps adb_disable_verity(ad) install_carriersettings_apk(ad, carriersettingsapk) # FDR ad.log.info("Performing FDR") fastboot_wipe(ad) ad.log.info("FDR Complete") if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Connect WiFi failed") # Wait for 45 mins for CC version upgrade while (time_var < WAIT_TIME_FOR_CARRIERCONFIG_CHANGE): current_version = get_carrier_config_version(ad) if current_version == cc_version_mapping[self.dut_operator]: ad.log.info("Carrier Config Version Match %s in %s mins", current_version, time_var) result_flag = True break else: ad.log.debug("Carrier Config Version Not Match") time.sleep(60) time_var += 1 if not result_flag: ad.log.info("Carrier Config Failed to Update in %s mins", WAIT_TIME_FOR_CARRIERCONFIG_CHANGE) return result_flag except Exception as e: ad.log.error(e) return False
def _setup_device(self, ad, sim_conf_file, qxdm_log_mask_cfg=None): ad.qxdm_log = getattr(ad, "qxdm_log", self.qxdm_log) ad.sdm_log = getattr(ad, "sdm_log", self.sdm_log) if self.user_params.get("enable_connectivity_metrics", False): enable_connectivity_metrics(ad) if self.user_params.get("build_id_override", False): build_postfix = self.user_params.get("build_id_postfix", "LAB_TEST") build_id_override( ad, new_build_id=self.user_params.get("build_id_override_with", None), postfix=build_postfix) if self.enable_radio_log_on: enable_radio_log_on(ad) list_of_models = ["sdm", "msm", "kon", "lit"] if any(model in ad.model for model in list_of_models): phone_mode = "ssss" if hasattr(ad, "mtp_dsds"): phone_mode = "dsds" if ad.adb.getprop("persist.radio.multisim.config") != phone_mode: ad.adb.shell("setprop persist.radio.multisim.config %s" \ % phone_mode) reboot_device(ad) stop_qxdm_logger(ad) if ad.qxdm_log: qxdm_log_mask = getattr(ad, "qxdm_log_mask", None) if qxdm_log_mask_cfg: qxdm_mask_path = self.user_params.get("qxdm_log_path", DEFAULT_QXDM_LOG_PATH) ad.adb.shell("mkdir %s" % qxdm_mask_path) ad.log.info("Push %s to %s", qxdm_log_mask_cfg, qxdm_mask_path) ad.adb.push("%s %s" % (qxdm_log_mask_cfg, qxdm_mask_path)) mask_file_name = os.path.split(qxdm_log_mask_cfg)[-1] qxdm_log_mask = os.path.join(qxdm_mask_path, mask_file_name) set_qxdm_logger_command(ad, mask=qxdm_log_mask) start_qxdm_logger(ad, utils.get_current_epoch_time()) elif ad.sdm_log: start_sdm_logger(ad) else: disable_qxdm_logger(ad) if not unlock_sim(ad): raise signals.TestAbortClass("unable to unlock the SIM") # eSIM enablement if hasattr(ad, "fi_esim"): if not ensure_wifi_connected(self.log, ad, self.wifi_network_ssid, self.wifi_network_pass): ad.log.error("Failed to connect to wifi") if check_google_fi_activated(ad): ad.log.info("Google Fi is already Activated") else: install_googleaccountutil_apk(ad, self.account_util) add_google_account(ad) install_googlefi_apk(ad, self.fi_util) if not activate_google_fi_account(ad): ad.log.error("Failed to activate Fi") check_google_fi_activated(ad) if hasattr(ad, "dsds"): sim_mode = ad.droid.telephonyGetPhoneCount() if sim_mode == 1: ad.log.info("Phone in Single SIM Mode") if not phone_switch_to_msim_mode(ad): ad.log.error("Failed to switch to Dual SIM Mode") return False elif sim_mode == 2: ad.log.info("Phone already in Dual SIM Mode") if get_sim_state(ad) in (SIM_STATE_ABSENT, SIM_STATE_UNKNOWN): ad.log.info("Device has no or unknown SIM in it") # eSIM needs activation activate_esim_using_suw(ad) ensure_phone_idle(self.log, ad) elif self.user_params.get("Attenuator"): ad.log.info("Device in chamber room") ensure_phone_idle(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) else: self.wait_for_sim_ready(ad) ensure_phone_default_state(self.log, ad) setup_droid_properties(self.log, ad, sim_conf_file) default_slot = getattr(ad, "default_slot", 0) if get_subid_from_slot_index(ad.log, ad, default_slot) != INVALID_SUB_ID: ad.log.info("Slot %s is the default slot.", default_slot) set_default_sub_for_all_services(ad, default_slot) else: ad.log.warning("Slot %s is NOT a valid slot. Slot %s will be used by default.", default_slot, 1-default_slot) set_default_sub_for_all_services(ad, 1-default_slot) # Activate WFC on Verizon, AT&T and Canada operators as per # b/33187374 & # b/122327716 activate_wfc_on_device(self.log, ad) # Sub ID setup initial_set_up_for_subid_infomation(self.log, ad) # If device is setup already, skip the following setup procedures if getattr(ad, "telephony_test_setup", None): return True try: ad.droid.wifiEnableVerboseLogging(WIFI_VERBOSE_LOGGING_ENABLED) except Exception: pass # 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 ("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, ignore_status=True) # Curl for 2016/7 devices if not getattr(ad, "curl_capable", False): try: out = ad.adb.shell("/data/curl --version") if not out or "not found" in out: if int(ad.adb.getprop("ro.product.first_api_level")) >= 25: tel_data = self.user_params.get("tel_data", "tel_data") if isinstance(tel_data, list): tel_data = tel_data[0] curl_file_path = os.path.join(tel_data, "curl") if not os.path.isfile(curl_file_path): curl_file_path = os.path.join( self.user_params[Config.key_config_path.value], curl_file_path) if os.path.isfile(curl_file_path): ad.log.info("Pushing Curl to /data dir") ad.adb.push("%s /data" % (curl_file_path)) ad.adb.shell( "chmod 777 /data/curl", ignore_status=True) else: setattr(ad, "curl_capable", True) except Exception: ad.log.info("Failed to push curl on this device") # 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