| # Copyright 2015 The Chromium OS Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """Handler for audio extension functionality.""" |
| |
| import logging |
| |
| from autotest_lib.client.bin import utils |
| from autotest_lib.client.cros.multimedia import facade_resource |
| |
| class AudioExtensionHandlerError(Exception): |
| """Class for exceptions thrown from the AudioExtensionHandler""" |
| pass |
| |
| |
| class AudioExtensionHandler(object): |
| """Wrapper around test extension that uses chrome.audio API to get audio |
| device information |
| """ |
| def __init__(self, extension): |
| """Initializes an AudioExtensionHandler. |
| |
| @param extension: Extension got from telemetry chrome wrapper. |
| |
| """ |
| self._extension = extension |
| self._check_api_available() |
| |
| |
| def _check_api_available(self): |
| """Checks chrome.audio is available. |
| |
| @raises: AudioExtensionHandlerError if extension is not available. |
| |
| """ |
| success = utils.wait_for_value( |
| lambda: (self._extension.EvaluateJavaScript( |
| "chrome.audio") != None), |
| expected_value=True) |
| if not success: |
| raise AudioExtensionHandlerError('chrome.audio is not available.') |
| |
| |
| @facade_resource.retry_chrome_call |
| def get_audio_devices(self, device_filter=None): |
| """Gets the audio device info from Chrome audio API. |
| |
| @param device_filter: Filter for returned device nodes. |
| An optional dict that can have the following properties: |
| string array streamTypes |
| Restricts stream types that returned devices can have. |
| It should contain "INPUT" for result to include input |
| devices, and "OUTPUT" for results to include output devices. |
| If not set, returned devices will not be filtered by the |
| stream type. |
| |
| boolean isActive |
| If true, only active devices will be included in the result. |
| If false, only inactive devices will be included in the |
| result. |
| |
| The filter param defaults to {}, requests all available audio |
| devices. |
| |
| @returns: An array of audioDeviceInfo. |
| Each audioDeviceInfo dict |
| contains these key-value pairs: |
| string id |
| The unique identifier of the audio device. |
| |
| string stableDeviceId |
| The stable identifier of the audio device. |
| |
| string streamType |
| "INPUT" if the device is an input audio device, |
| "OUTPUT" if the device is an output audio device. |
| |
| string displayName |
| The user-friendly name (e.g. "Bose Amplifier"). |
| |
| string deviceName |
| The devuce name |
| |
| boolean isActive |
| True if this is the current active device. |
| |
| boolean isMuted |
| True if this is muted. |
| |
| long level |
| The output volume or input gain. |
| |
| """ |
| def filter_to_str(device_filter): |
| """Converts python dict device filter to JS object string. |
| |
| @param device_filter: Device filter dict. |
| |
| @returns: Device filter as a srting representation of a |
| JavaScript object. |
| |
| """ |
| return str(device_filter or {}).replace('True', 'true').replace( |
| 'False', 'false') |
| |
| self._extension.ExecuteJavaScript('window.__audio_devices = null;') |
| self._extension.ExecuteJavaScript( |
| "chrome.audio.getDevices(%s, function(devices) {" |
| "window.__audio_devices = devices;})" |
| % filter_to_str(device_filter)) |
| utils.wait_for_value( |
| lambda: (self._extension.EvaluateJavaScript( |
| "window.__audio_devices") != None), |
| expected_value=True) |
| return self._extension.EvaluateJavaScript("window.__audio_devices") |
| |
| |
| def _get_active_id_for_stream_type(self, stream_type): |
| """Gets active node id of the specified stream type. |
| |
| Assume there is only one active node. |
| |
| @param stream_type: 'INPUT' to get the active input device, |
| 'OUTPUT' to get the active output device. |
| |
| @returns: A string for the active device id. |
| |
| @raises: AudioExtensionHandlerError if active id is not unique. |
| |
| """ |
| nodes = self.get_audio_devices( |
| {'streamTypes': [stream_type], 'isActive': True}) |
| if len(nodes) != 1: |
| logging.error( |
| 'Node info contains multiple active nodes: %s', nodes) |
| raise AudioExtensionHandlerError('Active id should be unique') |
| |
| return nodes[0]['id'] |
| |
| |
| @facade_resource.retry_chrome_call |
| def set_active_volume(self, volume): |
| """Sets the active audio output volume using chrome.audio API. |
| |
| This method also unmutes the node. |
| |
| @param volume: Volume to set (0~100). |
| |
| """ |
| output_id = self._get_active_id_for_stream_type('OUTPUT') |
| logging.debug('output_id: %s', output_id) |
| |
| self.set_mute(False) |
| |
| self._extension.ExecuteJavaScript('window.__set_volume_done = null;') |
| self._extension.ExecuteJavaScript( |
| """ |
| chrome.audio.setProperties( |
| '%s', |
| {level: %s}, |
| function() {window.__set_volume_done = true;}); |
| """ |
| % (output_id, volume)) |
| utils.wait_for_value( |
| lambda: (self._extension.EvaluateJavaScript( |
| "window.__set_volume_done") != None), |
| expected_value=True) |
| |
| |
| @facade_resource.retry_chrome_call |
| def set_mute(self, mute): |
| """Mutes the audio output using chrome.audio API. |
| |
| @param mute: True to mute. False otherwise. |
| |
| """ |
| is_muted_string = 'true' if mute else 'false' |
| |
| self._extension.ExecuteJavaScript('window.__set_mute_done = null;') |
| |
| self._extension.ExecuteJavaScript( |
| """ |
| chrome.audio.setMute( |
| 'OUTPUT', %s, |
| function() {window.__set_mute_done = true;}); |
| """ |
| % (is_muted_string)) |
| |
| utils.wait_for_value( |
| lambda: (self._extension.EvaluateJavaScript( |
| "window.__set_mute_done") != None), |
| expected_value=True) |
| |
| |
| @facade_resource.retry_chrome_call |
| def get_mute(self): |
| """Determines whether audio output is muted. |
| |
| @returns Whether audio output is muted. |
| |
| """ |
| self._extension.ExecuteJavaScript('window.__output_muted = null;') |
| self._extension.ExecuteJavaScript( |
| "chrome.audio.getMute('OUTPUT', function(isMute) {" |
| "window.__output_muted = isMute;})") |
| utils.wait_for_value( |
| lambda: (self._extension.EvaluateJavaScript( |
| "window.__output_muted") != None), |
| expected_value=True) |
| return self._extension.EvaluateJavaScript("window.__output_muted") |
| |
| |
| @facade_resource.retry_chrome_call |
| def get_active_volume_mute(self): |
| """Gets the volume state of active audio output using chrome.audio API. |
| |
| @param returns: A tuple (volume, mute), where volume is 0~100, and mute |
| is True if node is muted, False otherwise. |
| |
| """ |
| nodes = self.get_audio_devices( |
| {'streamTypes': ['OUTPUT'], 'isActive': True}) |
| if len(nodes) != 1: |
| logging.error('Node info contains multiple active nodes: %s', nodes) |
| raise AudioExtensionHandlerError('Active id should be unique') |
| |
| return (nodes[0]['level'], self.get_mute()) |
| |
| |
| @facade_resource.retry_chrome_call |
| def set_active_node_id(self, node_id): |
| """Sets the active node by node id. |
| |
| The current active node will be disabled first if the new active node |
| is different from the current one. |
| |
| @param node_id: Node id obtained from cras_utils.get_cras_nodes. |
| Chrome.audio also uses this id to specify input/output |
| nodes. |
| Note that node id returned by cras_utils.get_cras_nodes |
| is a number, while chrome.audio API expects a string. |
| |
| @raises AudioExtensionHandlerError if there is no such id. |
| |
| """ |
| nodes = self.get_audio_devices({}) |
| target_node = None |
| for node in nodes: |
| if node['id'] == str(node_id): |
| target_node = node |
| break |
| |
| if not target_node: |
| logging.error('Node %s not found.', node_id) |
| raise AudioExtensionHandlerError('Node id not found') |
| |
| if target_node['isActive']: |
| logging.debug('Node %s is already active.', node_id) |
| return |
| |
| logging.debug('Setting active id to %s', node_id) |
| |
| self._extension.ExecuteJavaScript('window.__set_active_done = null;') |
| |
| is_input = target_node['streamType'] == 'INPUT' |
| stream_type = 'input' if is_input else 'output' |
| self._extension.ExecuteJavaScript( |
| """ |
| chrome.audio.setActiveDevices( |
| {'%s': ['%s']}, |
| function() {window.__set_active_done = true;}); |
| """ |
| % (stream_type, node_id)) |
| |
| utils.wait_for_value( |
| lambda: (self._extension.EvaluateJavaScript( |
| "window.__set_active_done") != None), |
| expected_value=True) |
