from multiprocessing import Process import time from acts import asserts from acts import signals from acts.base_test import BaseTestClass from acts_contrib.test_utils.gnss import gnss_test_utils as gutils from acts_contrib.test_utils.gnss import supl from acts_contrib.test_utils.gnss import gnss_defines from acts_contrib.test_utils.gnss.testtracker_util import log_testtracker_uuid from acts_contrib.test_utils.tel.tel_data_utils import http_file_download_by_sl4a from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log from acts_contrib.test_utils.tel.tel_logging_utils import stop_adb_tcpdump from acts_contrib.test_utils.tel.tel_logging_utils import get_tcpdump_log from acts_contrib.test_utils.tel.tel_test_utils import check_call_state_connected_by_adb from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call from acts_contrib.test_utils.wifi import wifi_test_utils as wutils from acts.utils import get_current_epoch_time class GnssSuplTest(BaseTestClass): def setup_class(self): super().setup_class() self.ad = self.android_devices[0] req_params = [ "pixel_lab_network", "standalone_cs_criteria", "supl_cs_criteria", "supl_ws_criteria", "supl_hs_criteria", "default_gnss_signal_attenuation", "pixel_lab_location", "qdsp6m_path", "collect_logs", "ttff_test_cycle", "supl_capabilities", "no_gnss_signal_attenuation", "set_attenuator" ] self.unpack_userparams(req_param_names=req_params) # create hashmap for SSID self.ssid_map = {} for network in self.pixel_lab_network: SSID = network["SSID"] self.ssid_map[SSID] = network self.init_device() def only_brcm_device_runs_wifi_case(self): """SUPL over wifi is only supported by BRCM devices, for QUAL device, skip the test. """ if gutils.check_chipset_vendor_by_qualcomm(self.ad): raise signals.TestSkip("Qualcomm device doesn't support SUPL over wifi") def wearable_btwifi_should_skip_mobile_data_case(self): if gutils.is_wearable_btwifi(self.ad): raise signals.TestSkip("Skip mobile data case for BtWiFi sku") def init_device(self): """Init GNSS test devices for SUPL suite.""" gutils._init_device(self.ad) gutils.disable_vendor_orbit_assistance_data(self.ad) gutils.enable_supl_mode(self.ad) self.enable_supl_over_wifi() gutils.reboot(self.ad) def enable_supl_over_wifi(self): if not gutils.check_chipset_vendor_by_qualcomm(self.ad): supl.set_supl_over_wifi_state(self.ad, turn_on=True) def setup_test(self): gutils.log_current_epoch_time(self.ad, "test_start_time") log_testtracker_uuid(self.ad, self.current_test_name) gutils.clear_logd_gnss_qxdm_log(self.ad) gutils.get_baseband_and_gms_version(self.ad) toggle_airplane_mode(self.ad.log, self.ad, new_state=False) if gutils.is_wearable_btwifi(self.ad): wutils.wifi_toggle_state(self.ad, True) gutils.connect_to_wifi_network(self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]]) else: wutils.wifi_toggle_state(self.ad, False) gutils.set_mobile_data(self.ad, state=True) if not verify_internet_connection(self.ad.log, self.ad, retries=3, expected_state=True): raise signals.TestFailure("Fail to connect to LTE network.") # Once the device is rebooted, the xtra service will be alive again # In order not to affect the supl case, disable it in setup_test. if gutils.check_chipset_vendor_by_qualcomm(self.ad): gutils.disable_qualcomm_orbit_assistance_data(self.ad) def teardown_test(self): if self.collect_logs: gutils.stop_pixel_logger(self.ad) stop_adb_tcpdump(self.ad) if self.set_attenuator: gutils.set_attenuator_gnss_signal(self.ad, self.attenuators, self.default_gnss_signal_attenuation) gutils.log_current_epoch_time(self.ad, "test_end_time") def on_fail(self, test_name, begin_time): if self.collect_logs: self.ad.take_bug_report(test_name, begin_time) gutils.get_gnss_qxdm_log(self.ad, self.qdsp6m_path) self.get_brcm_gps_xml_to_sponge() get_tcpdump_log(self.ad, test_name, begin_time) def get_brcm_gps_xml_to_sponge(self): # request from b/250506003 - to check the SUPL setting if not gutils.check_chipset_vendor_by_qualcomm(self.ad): self.ad.pull_files(gnss_defines.BCM_GPS_XML_PATH, self.ad.device_log_path) def run_ttff(self, mode, criteria): """Triggers TTFF. Args: mode: "cs", "ws" or "hs" criteria: Criteria for the test. """ return gutils.run_ttff(self.ad, mode, criteria, self.ttff_test_cycle, self.pixel_lab_location, self.collect_logs) def supl_ttff_weak_gnss_signal(self, mode, criteria): """Verify SUPL TTFF functionality under weak GNSS signal. Args: mode: "cs", "ws" or "hs" criteria: Criteria for the test. """ gutils.set_attenuator_gnss_signal(self.ad, self.attenuators, self.weak_gnss_signal_attenuation) self.run_ttff(mode, criteria) def connect_to_wifi_with_mobile_data_off(self): gutils.set_mobile_data(self.ad, False) wutils.wifi_toggle_state(self.ad, True) gutils.connect_to_wifi_network(self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]]) def connect_to_wifi_with_airplane_mode_on(self): toggle_airplane_mode(self.ad.log, self.ad, new_state=True) wutils.wifi_toggle_state(self.ad, True) gutils.connect_to_wifi_network(self.ad, self.ssid_map[self.pixel_lab_network[0]["SSID"]]) def check_position_mode(self, begin_time: int, mode: str): logcat_results = self.ad.search_logcat( matching_string="setting position_mode to", begin_time=begin_time) return all([result["log_message"].split(" ")[-1] == mode for result in logcat_results]) def test_supl_capabilities(self): """Verify SUPL capabilities. Steps: 1. Root DUT. 2. Check SUPL capabilities. Expected Results: CAPABILITIES=0x37 which supports MSA + MSB. CAPABILITIES=0x17 = ON_DEMAND_TIME | MSA | MSB | SCHEDULING """ if not gutils.check_chipset_vendor_by_qualcomm(self.ad): raise signals.TestSkip("Not Qualcomm chipset. Skip the test.") capabilities_state = str( self.ad.adb.shell( "cat vendor/etc/gps.conf | grep CAPABILITIES")).split("=")[-1] self.ad.log.info("SUPL capabilities - %s" % capabilities_state) asserts.assert_true(capabilities_state in self.supl_capabilities, "Wrong default SUPL capabilities is set. Found %s, " "expected any of %r" % (capabilities_state, self.supl_capabilities)) def test_supl_ttff_cs(self): """Verify SUPL functionality of TTFF Cold Start. Steps: 1. Kill XTRA/LTO daemon to support SUPL only case. 2. SUPL TTFF Cold Start for 10 iteration. Expected Results: All SUPL TTFF Cold Start results should be less than supl_cs_criteria. """ self.run_ttff("cs", self.supl_cs_criteria) def test_supl_ttff_ws(self): """Verify SUPL functionality of TTFF Warm Start. Steps: 1. Kill XTRA/LTO daemon to support SUPL only case. 2. SUPL TTFF Warm Start for 10 iteration. Expected Results: All SUPL TTFF Warm Start results should be less than supl_ws_criteria. """ self.run_ttff("ws", self.supl_ws_criteria) def test_supl_ttff_hs(self): """Verify SUPL functionality of TTFF Hot Start. Steps: 1. Kill XTRA/LTO daemon to support SUPL only case. 2. SUPL TTFF Hot Start for 10 iteration. Expected Results: All SUPL TTFF Hot Start results should be less than supl_hs_criteria. """ self.run_ttff("hs", self.supl_hs_criteria) def test_cs_ttff_supl_over_wifi_with_airplane_mode_on(self): """ Test supl can works through wifi with airplane mode on Test steps are executed in the following sequence. - Turn on airplane mode - Connect to wifi - Run SUPL CS TTFF """ self.only_brcm_device_runs_wifi_case() self.connect_to_wifi_with_airplane_mode_on() self.run_ttff(mode="cs", criteria=self.supl_cs_criteria) def test_ws_ttff_supl_over_wifi_with_airplane_mode_on(self): """ Test supl can works through wifi with airplane mode on Test steps are executed in the following sequence. - Turn on airplane mode - Connect to wifi - Run SUPL WS TTFF """ self.only_brcm_device_runs_wifi_case() self.connect_to_wifi_with_airplane_mode_on() self.run_ttff("ws", self.supl_ws_criteria) def test_hs_ttff_supl_over_wifi_with_airplane_mode_on(self): """ Test supl can works through wifi with airplane mode on Test steps are executed in the following sequence. - Turn on airplane mode - Connect to wifi - Run SUPL WS TTFF """ self.only_brcm_device_runs_wifi_case() self.connect_to_wifi_with_airplane_mode_on() self.run_ttff("hs", self.supl_ws_criteria) def test_ttff_gla_on(self): """ Test the turn on "Google Location Accuracy" in settings work or not. Test steps are executed in the following sequence. - Turn off airplane mode - Connect to Cellular - Turn off LTO/RTO - Turn on SUPL - Turn on GLA - Run CS TTFF Expected Results: - The position mode must be "MS_BASED" - The TTFF time should be less than 10 seconds """ begin_time = get_current_epoch_time() gutils.gla_mode(self.ad, True) self.run_ttff("cs", self.supl_cs_criteria) asserts.assert_true(self.check_position_mode(begin_time, "MS_BASED"), msg=f"Fail to enter the MS_BASED mode") def test_ttff_gla_off(self): """ Test the turn off "Google Location Accuracy" in settings work or not. Test steps are executed in the following sequence. - Turn off airplane mode - Connect to Cellular - Turn off LTO/RTO - Turn on SUPL - Turn off GLA - Run CS TTFF Expected Results: - The position mode must be "standalone" - The TTFF time must be between slower than supl_ws and faster than standalone_cs. """ begin_time = get_current_epoch_time() gutils.gla_mode(self.ad, False) ttff_data = self.run_ttff("cs", self.standalone_cs_criteria) asserts.assert_true(any(float(ttff_data[key].ttff_sec) > self.supl_ws_criteria for key in ttff_data.keys()), msg=f"One or more TTFF Cold Start are faster than \ test criteria {self.supl_ws_criteria} seconds") asserts.assert_true(self.check_position_mode(begin_time, "standalone"), msg=f"Fail to enter the standalone mode")