#!/usr/bin/env python3 # # Copyright (C) 2016 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. """ Test script to automate the Bluetooth Audio Funhaus. """ from acts.keys import Config from acts_contrib.test_utils.bt.BtMetricsBaseTest import BtMetricsBaseTest from acts_contrib.test_utils.bt.bt_test_utils import bluetooth_enabled_check from acts.utils import bypass_setup_wizard from acts.utils import exe_cmd from acts.utils import sync_device_time import time import os BT_CONF_PATH = "/data/misc/bluedroid/bt_config.conf" class BtFunhausBaseTest(BtMetricsBaseTest): """ Base class for Bluetooth A2DP audio tests, this class is in charge of pushing link key to Android device so that it could be paired with remote A2DP device, pushing music to Android device, playing audio, monitoring audio play, and stop playing audio """ music_file_to_play = "" device_fails_to_connect_list = [] def __init__(self, controllers): BtMetricsBaseTest.__init__(self, controllers) self.ad = self.android_devices[0] self.dongle = self.relay_devices[0] def _pair_devices(self): self.ad.droid.bluetoothStartPairingHelper(False) self.dongle.enter_pairing_mode() self.ad.droid.bluetoothBond(self.dongle.mac_address) end_time = time.time() + 20 self.ad.log.info("Verifying devices are bonded") while time.time() < end_time: bonded_devices = self.ad.droid.bluetoothGetBondedDevices() for d in bonded_devices: if d['address'] == self.dongle.mac_address: self.ad.log.info("Successfully bonded to device.") self.log.info("Bonded devices:\n{}".format(bonded_devices)) return True self.ad.log.info("Failed to bond devices.") return False def setup_test(self): super(BtFunhausBaseTest, self).setup_test() self.dongle.setup() tries = 5 # Since we are not concerned with pairing in this test, try 5 times. while tries > 0: if self._pair_devices(): return True else: tries -= 1 return False def teardown_test(self): super(BtFunhausBaseTest, self).teardown_test() self.dongle.clean_up() return True def on_fail(self, test_name, begin_time): self.dongle.clean_up() self._collect_bluetooth_manager_dumpsys_logs(self.android_devices) super(BtFunhausBaseTest, self).on_fail(test_name, begin_time) def setup_class(self): if not super(BtFunhausBaseTest, self).setup_class(): return False for ad in self.android_devices: sync_device_time(ad) # Disable Bluetooth HCI Snoop Logs for audio tests ad.adb.shell("setprop persist.bluetooth.btsnoopenable false") if not bypass_setup_wizard(ad): self.log.debug( "Failed to bypass setup wizard, continuing test.") # Add music to the Android device return self._add_music_to_android_device(ad) def _add_music_to_android_device(self, ad): """ Add music to Android device as specified by the test config :param ad: Android device :return: True on success, False on failure """ self.log.info("Pushing music to the Android device.") music_path_str = "bt_music" android_music_path = "/sdcard/Music/" if music_path_str not in self.user_params: self.log.error("Need music for audio testcases...") return False music_path = self.user_params[music_path_str] if type(music_path) is list: self.log.info("Media ready to push as is.") elif not os.path.isdir(music_path): music_path = os.path.join( self.user_params[Config.key_config_path.value], music_path) if not os.path.isdir(music_path): self.log.error( "Unable to find music directory {}.".format(music_path)) return False if type(music_path) is list: for item in music_path: self.music_file_to_play = item ad.adb.push("{} {}".format(item, android_music_path)) else: for dirname, dirnames, filenames in os.walk(music_path): for filename in filenames: self.music_file_to_play = filename file = os.path.join(dirname, filename) # TODO: Handle file paths with spaces ad.adb.push("{} {}".format(file, android_music_path)) ad.reboot() return True def _collect_bluetooth_manager_dumpsys_logs(self, ads): """ Collect "adb shell dumpsys bluetooth_manager" logs :param ads: list of active Android devices :return: None """ for ad in ads: serial = ad.serial out_name = "{}_{}".format(serial, "bluetooth_dumpsys.txt") dumpsys_path = ''.join((ad.log_path, "/BluetoothDumpsys")) os.makedirs(dumpsys_path, exist_ok=True) cmd = ''.join( ("adb -s ", serial, " shell dumpsys bluetooth_manager > ", dumpsys_path, "/", out_name)) exe_cmd(cmd) def start_playing_music_on_all_devices(self): """ Start playing music :return: None """ self.ad.droid.mediaPlayOpen("file:///sdcard/Music/{}".format( self.music_file_to_play.split("/")[-1])) self.ad.droid.mediaPlaySetLooping(True) self.ad.log.info("Music is now playing.") def monitor_music_play_util_deadline(self, end_time, sleep_interval=1): """ Monitor music play on all devices, if a device's Bluetooth adapter is OFF or if a device is not connected to any remote Bluetooth devices, we add them to failure lists bluetooth_off_list and device_not_connected_list respectively :param end_time: The deadline in epoch floating point seconds that we must stop playing :param sleep_interval: How often to monitor, too small we may drain too much resources on Android, too big the deadline might be passed by a maximum of this amount :return: status: False iff all devices are off or disconnected otherwise True bluetooth_off_list: List of ADs that have Bluetooth at OFF state device_not_connected_list: List of ADs with no remote device connected """ device_not_connected_list = [] while time.time() < end_time: if not self.ad.droid.bluetoothCheckState(): self.ad.log.error("Device {}'s Bluetooth state is off.".format( self.ad.serial)) return False if self.ad.droid.bluetoothGetConnectedDevices() == 0: self.ad.log.error( "Bluetooth device not connected. Failing test.") time.sleep(sleep_interval) return True def play_music_for_duration(self, duration, sleep_interval=1): """ A convenience method for above methods. It starts run music on all devices, monitors the health of music play and stops playing them when time passes the duration :param duration: Duration in floating point seconds :param sleep_interval: How often to check the health of music play :return: status: False iff all devices are off or disconnected otherwise True bluetooth_off_list: List of ADs that have Bluetooth at OFF state device_not_connected_list: List of ADs with no remote device connected """ start_time = time.time() end_time = start_time + duration self.start_playing_music_on_all_devices() status = self.monitor_music_play_util_deadline(end_time, sleep_interval) self.ad.droid.mediaPlayStopAll() return status