coex/functionality_tests/WlanWithHfpFunctionalityTest.py

#!/usr/bin/env python3
#
# Copyright (C) 2018 The Android Open Source Project
#
# 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.

from acts_contrib.test_utils.bt import BtEnum
from acts_contrib.test_utils.bt.bt_test_utils import clear_bonded_devices
from acts_contrib.test_utils.coex.CoexBaseTest import CoexBaseTest
from acts_contrib.test_utils.coex.coex_test_utils import connect_dev_to_headset
from acts_contrib.test_utils.coex.coex_test_utils import connect_wlan_profile
from acts_contrib.test_utils.coex.coex_test_utils import initiate_disconnect_from_hf
from acts_contrib.test_utils.coex.coex_test_utils import initiate_disconnect_call_dut
from acts_contrib.test_utils.coex.coex_test_utils import multithread_func
from acts_contrib.test_utils.coex.coex_test_utils import pair_and_connect_headset
from acts_contrib.test_utils.coex.coex_test_utils import perform_classic_discovery
from acts_contrib.test_utils.coex.coex_test_utils import toggle_screen_state
from acts_contrib.test_utils.coex.coex_test_utils import setup_tel_config
from acts_contrib.test_utils.coex.coex_test_utils import start_fping
from acts_contrib.test_utils.tel.tel_voice_utils import hangup_call
from acts_contrib.test_utils.tel.tel_voice_utils import initiate_call

BLUETOOTH_WAIT_TIME = 2


class WlanWithHfpFunctionalityTest(CoexBaseTest):

    def setup_class(self):
        super().setup_class()

        req_params = ["sim_conf_file", "fping_drop_tolerance"]
        self.unpack_userparams(req_params)
        self.ag_phone_number, self.re_phone_number = setup_tel_config(
            self.pri_ad, self.sec_ad, self.sim_conf_file)

    def setup_test(self):
        super().setup_test()
        self.audio_receiver.enter_pairing_mode()
        if not pair_and_connect_headset(
                self.pri_ad, self.audio_receiver.mac_address,
                set([BtEnum.BluetoothProfile.HEADSET.value])):
            self.log.error("Failed to pair and connect to headset.")
            return False

    def teardown_test(self):
        clear_bonded_devices(self.pri_ad)
        super().teardown_test()
        self.audio_receiver.clean_up()

    def call_from_sec_ad_to_pri_ad(self):
        """Initiates the call from secondary device and accepts the call
        from HF.

        Steps:
        1. Initiate call from secondary device to primary device.
        2. Accept the call from HF.
        3. Hangup the call from primary device.

        Returns:
            True if successful, False otherwise.
        """
        if not initiate_call(self.log, self.sec_ad, self.ag_phone_number):
            self.log.error("Failed to initiate call")
            return False
        if not self.audio_receiver.press_accept_call():
            self.log.error("Failed to answer call from HF.")
            return False
        if not hangup_call(self.log, self.pri_ad):
            self.log.error("Failed to hangup call.")
            return False
        return False

    def connect_to_headset_when_turned_off_with_iperf(self):
        """Wrapper function to start iperf and test connection to headset
        when it is turned off.

        Returns:
            True if successful, False otherwise.
        """
        self.run_iperf_and_get_result()
        self.audio_receiver.clean_up()
        if not connect_dev_to_headset(
                self.pri_ad, self.audio_receiver.mac_address,
                set([BtEnum.BluetoothProfile.HEADSET.value])):
            self.log.error("Failed to connect to headset.")
            return True
        return False

    def check_headset_reconnection_with_iperf(self):
        """Wrapper function to start iperf and check behaviour of hfp
        reconnection."""
        self.run_iperf_and_get_result()
        self.audio_receiver.clean_up()
        self.audio_receiver.power_on()
        if not self.pri_ad.droid.bluetoothIsDeviceConnected(
                self.audio_receiver.mac_address):
            self.log.error("Device not found in connected list")
            return False
        return self.teardown_result()

    def initiate_call_from_hf_with_iperf(self):
        """Wrapper function to start iperf and initiate call"""
        self.run_iperf_and_get_result()
        if not initiate_disconnect_from_hf(self.audio_receiver, self.pri_ad,
                                           self.sec_ad, self.iperf["duration"]):
            return False
        return self.teardown_result()

    def initiate_call_from_hf_bt_discovery_with_iperf(self):
        """Wrapper function to start iperf, initiate call and perform classic
        discovery.
        """
        self.run_iperf_and_get_result()
        tasks = [(initiate_disconnect_from_hf,
                  (self.audio_receiver, self.pri_ad, self.sec_ad,
                   self.iperf["duration"])),
                 (perform_classic_discovery,
                  (self.pri_ad, self.iperf["duration"], self.json_file,
                   self.dev_list))]
        if not multithread_func(self.log, tasks):
            return False
        return self.teardown_result()

    def initiate_call_associate_ap_with_iperf(self):
        """Wrapper function to initiate call from primary device and associate
        with access point and start iperf traffic."""
        args = [
            lambda: initiate_disconnect_call_dut(self.pri_ad, self.sec_ad, self.iperf["duration"], self.re_phone_number)
        ]
        self.run_thread(args)
        if not connect_wlan_profile(self.pri_ad, self.network):
            return False
        self.run_iperf_and_get_result()
        return self.teardown_result()

    def test_hfp_call_with_tcp_ul(self):
        """Starts TCP-uplink traffic with hfp connection.

        This test is to start TCP-uplink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call.

        Steps:.
        1. Start TCP-uplink traffic.
        2. Initiate call from HF and disconnect call from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_042
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_call_with_tcp_dl(self):
        """Starts TCP-downlink traffic with hfp connection.

        This test is to start TCP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call.

        Steps:.
        1. Start TCP-downlink traffic.
        2. Initiate call from HF and disconnect call from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_043
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_call_with_udp_ul(self):
        """Starts UDP-uplink traffic with hfp connection.

        This test is to start UDP-uplink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call.

        Steps:.
        1. Start UDP-uplink traffic.
        2. Initiate call from HF and disconnect call from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_044
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_call_with_udp_dl(self):
        """Starts UDP-downlink traffic with hfp connection.

        This test is to start UDP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call.

        Steps:.
        1. Start UDP-downlink traffic.
        2. Initiate call from HF and disconnect call from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_045
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_call_bluetooth_discovery_with_tcp_ul(self):
        """Starts TCP-uplink traffic with hfp connection and bluetooth
        discovery.

        This test is to start TCP-uplink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call and bluetooth discovery.

        Steps:.
        1. Start TCP-uplink traffic.
        2. Initiate call from HF and disconnect call from primary device.
        3. Start bluetooth discovery.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_046
        """
        if not self.initiate_call_from_hf_bt_discovery_with_iperf():
            return False
        return True

    def test_hfp_call_bluetooth_discovery_with_tcp_dl(self):
        """Starts TCP-downlink traffic with hfp connection and bluetooth
        discovery.

        This test is to start TCP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call and bluetooth discovery.

        Steps:.
        1. Start TCP-downlink traffic.
        2. Initiate call from HF and disconnect call from primary device.
        3. Start bluetooth discovery.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_047
        """
        if not self.initiate_call_from_hf_bt_discovery_with_iperf():
            return False
        return True

    def test_hfp_call_bluetooth_discovery_with_udp_ul(self):
        """Starts UDP-uplink traffic with hfp connection and bluetooth
        discovery.

        This test is to start UDP-uplink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call and bluetooth discovery.

        Steps:.
        1. Start UDP-uplink traffic.
        2. Initiate call from HF and disconnect call from primary device.
        3. Start bluetooth discovery.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_048
        """
        if not self.initiate_call_from_hf_bt_discovery_with_iperf():
            return False
        return True

    def test_hfp_call_bluetooth_discovery_with_udp_dl(self):
        """Starts UDP-downlink traffic with hfp connection and bluetooth
        discovery.

        This test is to start UDP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        and call and bluetooth discovery.

        Steps:.
        1. Start UDP-downlink traffic.
        2. Initiate call from HF and disconnect call from primary device.
        3. Start bluetooth discovery.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_049
        """
        if not self.initiate_call_from_hf_bt_discovery_with_iperf():
            return False
        return True

    def test_hfp_call_and_associate_ap_with_tcp_ul(self):
        """Starts TCP-uplink traffic with hfp call.

        This test is to start TCP-uplink traffic between host machine and
        android device and test functional behaviour of hfp call connection
        while associating with AP.

        Steps:
        1. Initiate call from HF and disconnect call from primary device.
        2. Associate with AP.
        3. Start TCP-uplink traffic.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_050
        """
        if not self.initiate_call_associate_ap_with_iperf():
            return False
        return True

    def test_hfp_call_and_associate_ap_with_tcp_dl(self):
        """Starts TCP-downlink traffic with hfp call.

        This test is to start TCP-downlink traffic between host machine and
        android device and test functional behaviour of hfp call connection
        while associating with AP.

        Steps:
        1. Initiate call from HF and disconnect call from primary device.
        2. Associate with AP.
        3. Start TCP-downlink traffic.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_051
        """
        if not self.initiate_call_associate_ap_with_iperf():
            return False
        return True

    def test_hfp_call_and_associate_ap_with_udp_ul(self):
        """Starts UDP-uplink traffic with hfp call.

        This test is to start UDP-uplink traffic between host machine and
        android device and test functional behaviour of hfp call connection
        while associating with AP.

        Steps:
        1. Initiate call from HF and disconnect call from primary device.
        2. Associate with AP.
        3. Start UDP-uplink traffic.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_052
        """
        if not self.initiate_call_associate_ap_with_iperf():
            return False
        return True

    def test_hfp_call_and_associate_ap_with_udp_dl(self):
        """Starts UDP-downlink traffic with hfp call.

        This test is to start UDP-downlink traffic between host machine and
        android device and test functional behaviour of hfp call connection
        while associating with AP.

        Steps:
        1. Initiate call from HF and disconnect call from primary device.
        2. Associate with AP.
        3. Start UDP-downlink traffic.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_053
        """
        if not self.initiate_call_associate_ap_with_iperf():
            return False
        return True

    def test_hfp_redial_with_tcp_ul(self):
        """Starts TCP-uplink traffic with hfp connection.

        This test is to start TCP-uplink traffic between host machine and
        android device with hfp connection.

        Steps:
        1. Start TCP-uplink traffic.
        2. Initiate call from HF(last dialed number) and disconnect call
        from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_054
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_redial_with_tcp_dl(self):
        """Starts TCP-downlink traffic with hfp connection.

        This test is to start TCP-downlink traffic between host machine and
        android device with hfp connection.

        Steps:
        1. Start TCP-downlink traffic.
        2. Initiate call from HF(last dialed number) and disconnect call
        from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_055
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_redial_with_udp_ul(self):
        """Starts UDP-uplink traffic with hfp connection.

        This test is to start UDP-uplink traffic between host machine and
        android device with hfp connection.

        Steps:
        1. Start UDP-uplink traffic.
        2. Initiate call from HF(last dialed number) and disconnect call
        from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_056
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_redial_with_udp_dl(self):
        """Starts UDP-downlink traffic with hfp connection.

        This test is to start TCP-downlink traffic between host machine and
        android device with hfp connection.

        Steps:
        1. Start UDP-downlink traffic.
        2. Initiate call from HF(last dialed number) and disconnect call
        from primary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_057
        """
        if not self.initiate_call_from_hf_with_iperf():
            return False
        return True

    def test_hfp_reconnection_with_tcp_ul(self):
        """Starts TCP-uplink traffic with hfp reconnection.

        This test is to start TCP-uplink traffic between host machine and
        android device and test the functional behaviour of hfp reconnection.

        Steps:.
        1. Start TCP-uplink traffic.
        2. Connect HF to DUT.
        3. Disconnect HF from DUT.
        4. Switch off the headset and turn ON HF to reconnect.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_062
        """
        if not self.check_headset_reconnection_with_iperf():
            return False
        return True

    def test_hfp_reconnection_with_tcp_dl(self):
        """Starts TCP-downlink traffic with hfp reconnection.

        This test is to start TCP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp reconnection.

        Steps:.
        1. Start TCP-downlink traffic.
        2. Connect HF to DUT.
        3. Disconnect HF from DUT.
        4. Switch off the headset and turn ON HF to reconnect.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_063
        """
        if not self.check_headset_reconnection_with_iperf():
            return False
        return True

    def test_hfp_reconnection_with_udp_ul(self):
        """Starts UDP-uplink traffic with hfp reconnection.

        This test is to start UDP-uplink traffic between host machine and
        android device and test the functional behaviour of hfp reconnection.

        Steps:.
        1. Start UDP-uplink traffic.
        2. Connect HF to DUT.
        3. Disconnect HF from DUT.
        4. Switch off the headset and turn ON HF to reconnect.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_064
        """
        if not self.check_headset_reconnection_with_iperf():
            return False
        return True

    def test_hfp_reconnection_with_udp_dl(self):
        """Starts UDP-downlink traffic with hfp reconnection.

        This test is to start UDP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp reconnection.

        Steps:.
        1. Start UDP-downlink traffic.
        2. Connect HF to DUT.
        3. Disconnect HF from DUT.
        4. Switch off the headset and turn ON HF to reconnect.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_065
        """
        if not self.check_headset_reconnection_with_iperf():
            return False
        return True

    def test_hfp_connection_when_hf_turned_off_with_tcp_ul(self):
        """Starts TCP-uplink traffic with hfp connection.

        This test is to start TCP-Uplink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        when device is off.

        Steps:
        1. Start TCP-uplink traffic.
        2. Make sure headset is turned off.
        3. Initiate hfp connection to headset from DUT.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_072
        """
        if not self.connect_to_headset_when_turned_off_with_iperf():
            return False
        return self.teardown_result()

    def test_hfp_connection_when_hf_turned_off_with_tcp_dl(self):
        """Starts TCP-downlink traffic with hfp connection.

        This test is to start TCP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        when device is off.

        Steps:
        1. Start TCP-downlink traffic.
        2. Make sure headset is turned off.
        3. Initiate hfp connection to headset from DUT.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_073
        """
        if not self.connect_to_headset_when_turned_off_with_iperf():
            return False
        return self.teardown_result()

    def test_hfp_connection_when_hf_turned_off_with_udp_ul(self):
        """Starts UDP-uplink traffic with hfp connection.

        This test is to start UDP-Uplink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        when device is off.

        Steps:
        1. Start UDP-uplink traffic.
        2. Make sure headset is turned off.
        3. Initiate hfp connection to headset from DUT.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_074
        """
        if not self.connect_to_headset_when_turned_off_with_iperf():
            return False
        return self.teardown_result()

    def test_hfp_connection_when_hf_turned_off_with_udp_dl(self):
        """Starts UDP-downlink traffic with hfp connection.

        This test is to start UDP-downlink traffic between host machine and
        android device and test the functional behaviour of hfp connection
        when device is off.

        Steps:
        1. Start UDP-downlink traffic.
        2. Make sure headset is turned off.
        3. Initiate hfp connection to headset from DUT.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_075
        """
        if not self.connect_to_headset_when_turned_off_with_iperf():
            return False
        return self.teardown_result()

    def test_hfp_call_with_fping(self):
        """Starts fping with hfp call connection.

        This test is to start fping between host machine and android device
        and test the functional behaviour of hfp call.

        Steps:
        1. Start fping from AP backend to android device.
        1. Initiate call from headset to secondary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_078
        """
        tasks = [(start_fping, (self.pri_ad, self.iperf["duration"],
                                self.fping_drop_tolerance)),
                 (initiate_disconnect_from_hf,
                  (self.audio_receiver, self.pri_ad, self.sec_ad,
                   self.iperf["duration"]))]
        if not multithread_func(self.log, tasks):
            return False
        return True

    def test_hfp_call_toggle_screen_state_with_fping(self):
        """Starts fping with hfp call connection.

        This test is to start fping between host machine and android device
        and test the functional behaviour of hfp call when toggling the
        screen state.

        Steps:
        1. Start fping from AP backend.
        1. Initiate call from primary device headset to secondary device.

        Returns:
            True if successful, False otherwise.

        Test Id: Bt_CoEx_081
        """
        tasks = [(start_fping, (self.pri_ad, self.iperf["duration"],
                                self.fping_drop_tolerance)),
                 (initiate_disconnect_from_hf,
                  (self.audio_receiver, self.pri_ad, self.sec_ad,
                   self.iperf["duration"])), (toggle_screen_state,
                                              (self.pri_ad, self.iterations))]
        if not multithread_func(self.log, tasks):
            return False
        return True