| #!/usr/bin/env python3.4 |
| # |
| # Copyright 2017 - Google |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); |
| # you may not use this file except in compliance with the License. |
| # You may obtain a copy of the License at |
| # |
| # http://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, |
| # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| # See the License for the specific language governing permissions and |
| # limitations under the License. |
| """ |
| Test Script for Telephony Pre Check In Sanity |
| """ |
| |
| import re |
| import time |
| from acts import signals |
| from acts.utils import get_current_epoch_time |
| from acts_contrib.test_utils.tel.TelephonyBaseTest import TelephonyBaseTest |
| from acts_contrib.test_utils.tel.tel_bootloader_utils import reset_device_password |
| from acts_contrib.test_utils.tel.tel_phone_setup_utils import ensure_phone_default_state |
| from acts_contrib.test_utils.tel.tel_test_utils import abort_all_tests |
| from acts_contrib.test_utils.tel.tel_test_utils import get_operator_name |
| from acts_contrib.test_utils.tel.tel_test_utils import get_service_state_by_adb |
| from acts_contrib.test_utils.tel.tel_test_utils import is_sim_lock_enabled |
| from acts_contrib.test_utils.tel.tel_test_utils import toggle_airplane_mode_by_adb |
| from acts_contrib.test_utils.tel.tel_test_utils import unlock_sim |
| from acts_contrib.test_utils.tel.tel_test_utils import verify_internet_connection |
| from acts_contrib.test_utils.tel.tel_data_utils import wait_for_cell_data_connection |
| from acts_contrib.test_utils.tel.tel_voice_utils import call_setup_teardown |
| from acts_contrib.test_utils.tel.tel_voice_utils import dumpsys_last_call_info |
| from acts_contrib.test_utils.tel.tel_voice_utils import dumpsys_last_call_number |
| from acts_contrib.test_utils.tel.tel_voice_utils import dumpsys_new_call_info |
| from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call_by_adb |
| from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call |
| from acts_contrib.test_utils.tel.tel_voice_utils import initiate_emergency_dialer_call_by_adb |
| from acts_contrib.test_utils.tel.tel_voice_utils import last_call_drop_reason |
| |
| CARRIER_OVERRIDE_CMD = ( |
| "am broadcast -a com.google.android.carrier.action.LOCAL_OVERRIDE -n " |
| "com.google.android.carrier/.ConfigOverridingReceiver --ez") |
| IMS_FIRST = "carrier_use_ims_first_for_emergency_bool" |
| ALLOW_NON_EMERGENCY_CALL = "allow_non_emergency_calls_in_ecm_bool" |
| BLOCK_DURATION_CMD = "duration_blocking_disabled_after_emergency_int" |
| BLOCK_DURATION = 300 |
| |
| |
| class TelLiveEmergencyBase(TelephonyBaseTest): |
| def setup_class(self): |
| TelephonyBaseTest.setup_class(self) |
| self.number_of_devices = 1 |
| fake_number = self.user_params.get("fake_emergency_number", "411") |
| self.fake_emergency_number = fake_number.strip("+").replace("-", "") |
| self.my_devices = self.android_devices[:] |
| |
| for ad in self.android_devices: |
| if not is_sim_lock_enabled(ad): |
| self.setup_dut(ad) |
| return True |
| self.log.error("No device meets SIM READY or LOADED requirement") |
| raise signals.TestAbortClass("No device meets SIM requirement") |
| |
| def setup_dut(self, ad): |
| self.dut = ad |
| output = self.dut.adb.shell("dumpsys carrier_config") |
| self.default_settings = {} |
| for setting in (IMS_FIRST, ALLOW_NON_EMERGENCY_CALL, |
| BLOCK_DURATION_CMD): |
| values = re.findall(r"%s = (\S+)" % setting, output) |
| if values: |
| self.default_settings[setting] = values[-1] |
| else: |
| self.default_settings[setting] = "" |
| self.dut.adb.shell(" ".join( |
| [CARRIER_OVERRIDE_CMD, BLOCK_DURATION_CMD, |
| "%s" % BLOCK_DURATION])) |
| self.dut_operator = get_operator_name(self.log, ad) |
| if self.dut_operator == "tmo": |
| self.fake_emergency_number = "611" |
| elif self.dut_operator == "vzw": |
| self.fake_emergency_number = "922" |
| elif self.dut_operator == "spt": |
| self.fake_emergency_number = "526" |
| if len(self.my_devices) > 1: |
| self.android_devices.remove(ad) |
| self.android_devices.insert(0, ad) |
| |
| def teardown_class(self): |
| self.android_devices = self.my_devices |
| TelephonyBaseTest.teardown_class(self) |
| |
| def setup_test(self): |
| if not unlock_sim(self.dut): |
| abort_all_tests(self.dut.log, "unable to unlock SIM") |
| self.expected_call_result = True |
| |
| def teardown_test(self): |
| self.dut.ensure_screen_on() |
| self.dut.exit_setup_wizard() |
| reset_device_password(self.dut, None) |
| output = self.dut.adb.shell("dumpsys carrier_config") |
| for setting, state in self.default_settings.items(): |
| values = re.findall(r"%s = (\S+)" % setting, output) |
| if values and values[-1] != state: |
| self.dut.adb.shell(" ".join( |
| [CARRIER_OVERRIDE_CMD, setting, state])) |
| ensure_phone_default_state(self.log, self.dut) |
| |
| def change_emergency_number_list(self): |
| test_number = "%s:%s" % (self.fake_emergency_number, |
| self.fake_emergency_number) |
| output = self.dut.adb.getprop("ril.test.emergencynumber") |
| if output != test_number: |
| cmd = "setprop ril.test.emergencynumber %s" % test_number |
| self.dut.log.info(cmd) |
| self.dut.adb.shell(cmd) |
| for _ in range(5): |
| existing = self.dut.adb.getprop("ril.ecclist") |
| self.dut.log.info("Existing ril.ecclist is: %s", existing) |
| if self.fake_emergency_number in existing: |
| return True |
| emergency_numbers = "%s,%s" % (existing, |
| self.fake_emergency_number) |
| cmd = "setprop ril.ecclist %s" % emergency_numbers |
| self.dut.log.info(cmd) |
| self.dut.adb.shell(cmd) |
| # After some system events, ril.ecclist might change |
| # wait sometime for it to settle |
| time.sleep(10) |
| if self.fake_emergency_number in existing: |
| return True |
| return False |
| |
| def change_qcril_emergency_source_mcc_table(self): |
| # This will add the fake number into emergency number list for a mcc |
| # in qcril. Please note, the fake number will be send as an emergency |
| # number by modem and reach the real 911 by this |
| qcril_database_path = self.dut.adb.shell("find /data -iname qcril.db") |
| if not qcril_database_path: return |
| mcc = self.dut.droid.telephonyGetNetworkOperator() |
| mcc = mcc[:3] |
| self.dut.log.info("Add %s mcc %s in qcril_emergency_source_mcc_table") |
| self.dut.adb.shell( |
| "sqlite3 %s \"INSERT INTO qcril_emergency_source_mcc_table VALUES('%s','%s','','')\"" |
| % (qcril_database_path, mcc, self.fake_emergency_number)) |
| |
| def fake_emergency_call_test(self, by_emergency_dialer=True, attemps=3): |
| self.dut.log.info("ServiceState is in %s", |
| get_service_state_by_adb(self.log, self.dut)) |
| if by_emergency_dialer: |
| dialing_func = initiate_emergency_dialer_call_by_adb |
| callee = self.fake_emergency_number |
| else: |
| dialing_func = initiate_call |
| # Initiate_call method has to have "+" in front |
| # otherwise the number will be in dialer without dial out |
| # with sl4a fascade. Need further investigation |
| callee = "+%s" % self.fake_emergency_number |
| for i in range(attemps): |
| begin_time = get_current_epoch_time() |
| result = True |
| if not self.change_emergency_number_list(): |
| self.dut.log.error("Unable to add number to ril.ecclist") |
| return False |
| time.sleep(1) |
| last_call_number = dumpsys_last_call_number(self.dut) |
| call_result = dialing_func(self.log, self.dut, callee) |
| time.sleep(3) |
| hangup_call_by_adb(self.dut) |
| if not call_result: |
| last_call_drop_reason(self.dut, begin_time) |
| self.dut.send_keycode("BACK") |
| self.dut.send_keycode("BACK") |
| if not dumpsys_new_call_info(self.dut, last_call_number): |
| result = False |
| if call_result == self.expected_call_result: |
| self.dut.log.info("Call to %s returns %s as expected", callee, |
| self.expected_call_result) |
| else: |
| self.dut.log.info("Call to %s returns %s", callee, |
| not self.expected_call_result) |
| result = False |
| if result: |
| return True |
| ecclist = self.dut.adb.getprop("ril.ecclist") |
| self.dut.log.info("ril.ecclist = %s", ecclist) |
| if self.fake_emergency_number in ecclist: |
| if i == attemps - 1: |
| self.dut.log.error("%s is in ril-ecclist, but call failed", |
| self.fake_emergency_number) |
| else: |
| self.dut.log.warning( |
| "%s is in ril-ecclist, but call failed, try again", |
| self.fake_emergency_number) |
| else: |
| if i == attemps - 1: |
| self.dut.log.error("Fail to write %s to ril-ecclist", |
| self.fake_emergency_number) |
| else: |
| self.dut.log.info("%s is not in ril-ecclist", |
| self.fake_emergency_number) |
| self.dut.log.info("fake_emergency_call_test result is %s", result) |
| return result |
| |
| def set_ims_first(self, state): |
| output = self.dut.adb.shell( |
| "dumpsys carrier_config | grep %s | tail -1" % IMS_FIRST) |
| self.dut.log.info(output) |
| if state in output: return |
| cmd = " ".join([CARRIER_OVERRIDE_CMD, IMS_FIRST, state]) |
| self.dut.log.info(cmd) |
| self.dut.adb.shell(cmd) |
| self.dut.log.info( |
| self.dut.adb.shell( |
| "dumpsys carrier_config | grep %s | tail -1" % IMS_FIRST)) |
| |
| def set_allow_non_emergency_call(self, state): |
| output = self.dut.adb.shell( |
| "dumpsys carrier_config | grep %s | tail -1" % |
| ALLOW_NON_EMERGENCY_CALL) |
| self.dut.log.info(output) |
| if state in output: return |
| cmd = " ".join([CARRIER_OVERRIDE_CMD, ALLOW_NON_EMERGENCY_CALL, state]) |
| self.dut.log.info(cmd) |
| self.dut.adb.shell(cmd) |
| self.dut.log.info( |
| self.dut.adb.shell("dumpsys carrier_config | grep %s | tail -1" % |
| ALLOW_NON_EMERGENCY_CALL)) |
| |
| def check_emergency_call_back_mode(self, |
| by_emergency_dialer=True, |
| non_emergency_call_allowed=True, |
| attemps=3): |
| state = "true" if non_emergency_call_allowed else "false" |
| self.set_allow_non_emergency_call(state) |
| result = True |
| for _ in range(attemps): |
| if not self.change_emergency_number_list(): |
| self.dut.log.error("Unable to add number to ril.ecclist") |
| return False |
| last_call_number = dumpsys_last_call_number(self.dut) |
| self.dut.log.info("Hung up fake emergency call in ringing") |
| if by_emergency_dialer: |
| initiate_emergency_dialer_call_by_adb( |
| self.log, self.dut, self.fake_emergency_number, timeout=0) |
| else: |
| callee = "+%s" % self.fake_emergency_number |
| self.dut.droid.telecomCallNumber(callee) |
| time.sleep(3) |
| hangup_call_by_adb(self.dut) |
| ecclist = self.dut.adb.getprop("ril.ecclist") |
| self.dut.log.info("ril.ecclist = %s", ecclist) |
| if self.fake_emergency_number in ecclist: |
| break |
| call_info = dumpsys_new_call_info(self.dut, last_call_number) |
| if not call_info: |
| return False |
| call_tech = call_info.get("callTechnologies", "") |
| if "CDMA" in call_tech: |
| expected_ecbm = True |
| expected_data = False |
| expected_call = non_emergency_call_allowed |
| elif "GSM" in call_tech: |
| expected_ecbm = True |
| expected_data = True |
| expected_call = True |
| else: |
| expected_ecbm = False |
| expected_data = True |
| expected_call = True |
| last_call_number = dumpsys_last_call_number(self.dut) |
| begin_time = get_current_epoch_time() |
| self.dut.ensure_screen_on() |
| self.dut.exit_setup_wizard() |
| reset_device_password(self.dut, None) |
| call_check = call_setup_teardown( |
| self.log, self.dut, self.android_devices[1], ad_hangup=self.dut) |
| if call_check != expected_call: |
| self.dut.log.error("Regular phone call is %s, expecting %s", |
| call_check, expected_call) |
| result = False |
| call_info = dumpsys_new_call_info(self.dut, last_call_number) |
| if not call_info: |
| self.dut.log.error("New call is not in dumpsys telecom") |
| return False |
| if expected_ecbm: |
| if "ecbm" in call_info["callProperties"]: |
| self.dut.log.info("New call is in ecbm.") |
| else: |
| self.dut.log.error( |
| "New call is not in emergency call back mode.") |
| result = False |
| else: |
| if "ecbm" in call_info["callProperties"]: |
| self.dut.log.error("New call is in emergency call back mode") |
| result = False |
| if not expected_data: |
| if self.dut.droid.telephonyGetDataConnectionState(): |
| self.dut.log.info( |
| "Data connection is off as expected in ECB mode") |
| self.dut.log.info("Wait for getting out of ecbm") |
| if not wait_for_cell_data_connection(self.log, self.dut, True, |
| 400): |
| self.dut.log.error( |
| "Data connection didn't come back after 5 minutes") |
| result = False |
| #if not self.dut.droid.telephonyGetDataConnectionState(): |
| # self.dut.log.error( |
| # "Data connection is not coming back") |
| # result = False |
| elif not verify_internet_connection(self.log, self.dut): |
| self.dut.log.error( |
| "Internet connection check failed after getting out of ECB" |
| ) |
| result = False |
| |
| else: |
| self.dut.log.error("Data connection is not off in ECB mode") |
| if not verify_internet_connection(self.log, self.dut, False): |
| self.dut.log.error("Internet connection is not off") |
| result = False |
| else: |
| if self.dut.droid.telephonyGetDataConnectionState(): |
| self.dut.log.info("Data connection is on as expected") |
| if not verify_internet_connection(self.log, self.dut): |
| self.dut.log.error("Internet connection check failed") |
| result = False |
| else: |
| self.dut.log.error("Data connection is off, expecting on") |
| result = False |
| if expected_call: |
| return result |
| elapsed_time = (get_current_epoch_time() - begin_time) / 1000 |
| if elapsed_time < BLOCK_DURATION: |
| time.sleep(BLOCK_DURATION - elapsed_time + 10) |
| if not call_setup_teardown( |
| self.log, self.dut, self.android_devices[1], |
| ad_hangup=self.dut): |
| self.dut.log.error("Regular phone call failed after out of ecbm") |
| result = False |
| return result |
| |
| def check_normal_call(self): |
| result = True |
| if "wfc" not in self.test_name: |
| toggle_airplane_mode_by_adb(self.log, self.dut, False) |
| self.dut.ensure_screen_on() |
| self.dut.exit_setup_wizard() |
| reset_device_password(self.dut, None) |
| begin_time = get_current_epoch_time() |
| if not call_setup_teardown( |
| self.log, |
| self.android_devices[1], |
| self.dut, |
| ad_hangup=self.android_devices[1]): |
| self.dut.log.error("Regular MT phone call fails") |
| self.dut.log.info("call_info = %s", dumpsys_last_call_info( |
| self.dut)) |
| result = False |
| if not call_setup_teardown( |
| self.log, self.dut, self.android_devices[1], |
| ad_hangup=self.dut): |
| self.dut.log.error("Regular MO phone call fails") |
| self.dut.log.info("call_info = %s", dumpsys_last_call_info( |
| self.dut)) |
| result = False |
| return result |
