def connect_dev_to_headset(pri_droid, dev_to_connect, profiles_set):
"""Connects primary android device to headset.
Args:
pri_droid: Android device initiating connection.
dev_to_connect: Third party headset mac address.
profiles_set: Profiles to be connected.
Returns:
True if Pass
False if Fail
"""
supported_profiles = bt_profile_constants.values()
for profile in profiles_set:
if profile not in supported_profiles:
pri_droid.log.info("Profile {} is not supported list {}".format(
profile, supported_profiles))
return False
paired = False
for paired_device in pri_droid.droid.bluetoothGetBondedDevices():
if paired_device['address'] == dev_to_connect:
paired = True
break
if not paired:
pri_droid.log.info("{} not paired to {}".format(pri_droid.serial,
dev_to_connect))
return False
end_time = time.time() + 10
profile_connected = set()
sec_addr = dev_to_connect
pri_droid.log.info("Profiles to be connected {}".format(profiles_set))
while (time.time() < end_time and
not profile_connected.issuperset(profiles_set)):
if (bt_profile_constants['headset_client'] not in profile_connected and
bt_profile_constants['headset_client'] in profiles_set):
if is_hfp_client_device_connected(pri_droid, sec_addr):
profile_connected.add(bt_profile_constants['headset_client'])
if (bt_profile_constants['headset'] not in profile_connected and
bt_profile_constants['headset'] in profiles_set):
profile_connected.add(bt_profile_constants['headset'])
if (bt_profile_constants['a2dp'] not in profile_connected and
bt_profile_constants['a2dp'] in profiles_set):
if is_a2dp_src_device_connected(pri_droid, sec_addr):
profile_connected.add(bt_profile_constants['a2dp'])
if (bt_profile_constants['a2dp_sink'] not in profile_connected and
bt_profile_constants['a2dp_sink'] in profiles_set):
if is_a2dp_snk_device_connected(pri_droid, sec_addr):
profile_connected.add(bt_profile_constants['a2dp_sink'])
if (bt_profile_constants['map_mce'] not in profile_connected and
bt_profile_constants['map_mce'] in profiles_set):
if is_map_mce_device_connected(pri_droid, sec_addr):
profile_connected.add(bt_profile_constants['map_mce'])
if (bt_profile_constants['map'] not in profile_connected and
bt_profile_constants['map'] in profiles_set):
if is_map_mse_device_connected(pri_droid, sec_addr):
profile_connected.add(bt_profile_constants['map'])
time.sleep(0.1)
while not profile_connected.issuperset(profiles_set):
try:
time.sleep(10)
profile_event = pri_droid.ed.pop_event(
bluetooth_profile_connection_state_changed,
bt_default_timeout + 10)
pri_droid.log.info("Got event {}".format(profile_event))
except Exception:
pri_droid.log.error("Did not get {} profiles left {}".format(
bluetooth_profile_connection_state_changed, profile_connected))
return False
profile = profile_event['data']['profile']
state = profile_event['data']['state']
device_addr = profile_event['data']['addr']
if state == bt_profile_states['connected'] and (
device_addr == dev_to_connect):
profile_connected.add(profile)
pri_droid.log.info(
"Profiles connected until now {}".format(profile_connected))
return True
def test_call_transfer_connect_disconnect_connect(self):
"""
Test that when we go from connect -> disconnect -> connect on an active
call then the call is restored on HF.
Precondition:
1. AG & HF are paired
Steps:
0. Connect AG & HF
1. Make a call from HF role
2. Accept from RE role and transition the call to Active
3. Disconnect AG & HF
4. Verify that we don't have any calls on HF
5. Connect AG & HF
6. Verify that HF gets the call back.
Returns:
Pass if True
Fail if False
Priority: 1
"""
# Now connect the devices.
if not bt_test_utils.connect_pri_to_sec(
self.hf, self.ag,
set([BtEnum.BluetoothProfile.HEADSET_CLIENT.value])):
self.log.error("Could not connect HF and AG {} {}".format(
self.hf.serial, self.ag.serial))
return False
# make a call on HF
if not car_telecom_utils.dial_number(self.log, self.hf,
self.re_phone_number):
self.hf.log.error("HF not in dialing state.")
return False
# Wait for HF, AG to be dialing and RE to be ringing
ret = True
ret &= car_telecom_utils.wait_for_dialing(self.log, self.hf)
#uncomment once sl4a code has been merged.
ret &= car_telecom_utils.wait_for_dialing(self.log, self.ag)
ret &= car_telecom_utils.wait_for_ringing(self.log, self.re)
if not ret:
self.log.error("Outgoing call did not get established")
return False
# Accept call on RE.
if not wait_and_answer_call(self.log, self.re):
self.re.log.error("Failed to accept call on re.")
return False
ret &= car_telecom_utils.wait_for_active(self.log, self.hf)
ret &= car_telecom_utils.wait_for_active(self.log, self.ag)
ret &= car_telecom_utils.wait_for_active(self.log, self.re)
if not ret:
self.log.error("Outgoing call did not transition to active")
return False
# Disconnect HF & AG
self.hf.droid.bluetoothDisconnectConnected(
self.ag.droid.bluetoothGetLocalAddress())
# We use the proxy of the Call going away as HF disconnected
if not car_telecom_utils.wait_for_not_in_call(self.log, self.hf):
self.hf.log.error("HF still in call after disconnection.")
return False
# Now connect the devices.
if not bt_test_utils.connect_pri_to_sec(
self.hf, self.ag,
set([BtEnum.BluetoothProfile.HEADSET_CLIENT.value])):
self.log.error("Could not connect HF and AG {} {}".format(
self.hf.serial, self.ag.serial))
# Additional profile connection check for b/
if not bt_test_utils.is_hfp_client_device_connected(
self.hf, self.ag.droid.bluetoothGetLocalAddress()):
self.hf.log.info(
"HFP Client connected even though connection state changed "
+ " event not found")
return False
# Check that HF is in active state
if not car_telecom_utils.wait_for_active(self.log, self.hf):
self.hf.log.error("HF not in Active state.")
return False
# Hangup the call and check all devices are clean
self.hf.droid.telecomEndCall()
ret &= car_telecom_utils.wait_for_not_in_call(self.log, self.hf)
ret &= car_telecom_utils.wait_for_not_in_call(self.log, self.ag)
ret &= car_telecom_utils.wait_for_not_in_call(self.log, self.re)
return ret
def test_connect_disconnect_paired(self):
"""
Tests if we can connect two devices over Headset, A2dp and then disconnect them with success
Precondition:
1. Devices are paired.
Steps:
1. Initiate connection over A2dp Sink and Headset client profiles.
2. Check if the connection succeeded.
Returns:
Pass if True
Fail if False
Priority: 0
"""
NUM_TEST_RUNS = 2
failure = 0
addr = self.ph.droid.bluetoothGetLocalAddress()
for i in range(NUM_TEST_RUNS):
self.log.info("Running test [" + str(i) + "/" + str(NUM_TEST_RUNS)
+ "]")
success = bt_test_utils.connect_pri_to_sec(self.car, self.ph, set(
[BtEnum.BluetoothProfile.HEADSET_CLIENT.value,
BtEnum.BluetoothProfile.A2DP_SINK.value]))
# Check if we got connected.
if not success:
self.car.log.info("Not all profiles connected.")
if (bt_test_utils.is_hfp_client_device_connected(self.car,
addr) and
bt_test_utils.is_a2dp_snk_device_connected(self.car,
addr)):
self.car.log.info(
"HFP Client or A2DP SRC connected successfully.")
else:
failure = failure + 1
continue
# Disconnect the devices.
success = bt_test_utils.disconnect_pri_from_sec(
self.car, self.ph,
[BtEnum.BluetoothProfile.HEADSET_CLIENT.value,
BtEnum.BluetoothProfile.A2DP_SINK.value])
if success is False:
self.car.log.info("Disconnect failed.")
if (bt_test_utils.is_hfp_client_device_connected(self.car,
addr) or
bt_test_utils.is_a2dp_snk_device_connected(self.car,
addr)):
self.car.log.info(
"HFP Client or A2DP SRC failed to disconnect.")
failure = failure + 1
continue
self.log.info("Failure {} total tests {}".format(failure,
NUM_TEST_RUNS))
if failure > 0:
return False
return True