1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
|
// Copyright 2013 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// The <code>chrome.audio</code> API is provided to allow users to
// get information about and control the audio devices attached to the
// system.
// This API is currently only available in kiosk mode for ChromeOS.
namespace audio {
// Type of stream an audio device provides.
enum StreamType {
INPUT,
OUTPUT
};
// Available audio device types.
enum DeviceType {
HEADPHONE,
MIC,
USB,
BLUETOOTH,
HDMI,
INTERNAL_SPEAKER,
INTERNAL_MIC,
FRONT_MIC,
REAR_MIC,
KEYBOARD_MIC,
HOTWORD,
LINEOUT,
POST_MIX_LOOPBACK,
POST_DSP_LOOPBACK,
ALSA_LOOPBACK,
OTHER
};
dictionary AudioDeviceInfo {
// The unique identifier of the audio device.
DOMString id;
// Stream type associated with this device.
StreamType streamType;
// Type of the device.
DeviceType deviceType;
// The user-friendly name (e.g. "USB Microphone").
DOMString displayName;
// Device name.
DOMString deviceName;
// True if this is the current active device.
boolean isActive;
// The sound level of the device, volume for output, gain for input.
long level;
// The stable/persisted device id string when available.
DOMString? stableDeviceId;
};
dictionary DeviceFilter {
// If set, only audio devices whose stream type is included in this list
// will satisfy the filter.
StreamType[]? streamTypes;
// If set, only audio devices whose active state matches this value will
// satisfy the filter.
boolean? isActive;
};
dictionary DeviceProperties {
// <p>
// The audio device's desired sound level. Defaults to the device's
// current sound level.
// </p>
// <p>If used with audio input device, represents audio device gain.</p>
// <p>If used with audio output device, represents audio device volume.</p>
long? level;
};
dictionary DeviceIdLists {
// <p>List of input devices specified by their ID.</p>
// <p>To indicate input devices should be unaffected, leave this property
// unset.</p>
DOMString[]? input;
// <p>List of output devices specified by their ID.</p>
// <p>To indicate output devices should be unaffected, leave this property
// unset.</p>
DOMString[]? output;
};
dictionary MuteChangedEvent {
// The type of the stream for which the mute value changed. The updated mute
// value applies to all devices with this stream type.
StreamType streamType;
// Whether or not the stream is now muted.
boolean isMuted;
};
dictionary LevelChangedEvent {
// ID of device whose sound level has changed.
DOMString deviceId;
// The device's new sound level.
long level;
};
callback GetDevicesCallback = void(AudioDeviceInfo[] devices);
callback GetMuteCallback = void(boolean value);
callback EmptyCallback = void();
interface Functions {
// Gets a list of audio devices filtered based on |filter|.
// |filter|: Device properties by which to filter the list of returned
// audio devices. If the filter is not set or set to <code>{}</code>,
// returned device list will contain all available audio devices.
// |callback|: Reports the requested list of audio devices.
static void getDevices(
optional DeviceFilter filter,
GetDevicesCallback callback);
// Sets lists of active input and/or output devices.
// |ids|: <p>Specifies IDs of devices that should be active. If either the
// input or output list is not set, devices in that category are
// unaffected.
// </p>
// <p>It is an error to pass in a non-existent device ID.</p>
static void setActiveDevices(
DeviceIdLists ids,
EmptyCallback callback);
// Sets the properties for the input or output device.
static void setProperties(
DOMString id,
DeviceProperties properties,
EmptyCallback callback);
// Gets the system-wide mute state for the specified stream type.
// |streamType|: Stream type for which mute state should be fetched.
// |callback|: Callback reporting whether mute is set or not for specified
// stream type.
static void getMute(
StreamType streamType,
GetMuteCallback callback);
// Sets mute state for a stream type. The mute state will apply to all audio
// devices with the specified audio stream type.
// |streamType|: Stream type for which mute state should be set.
// |isMuted|: New mute value.
static void setMute(
StreamType streamType,
boolean isMuted,
optional EmptyCallback callback);
};
interface Events {
// Fired when sound level changes for an active audio device.
static void onLevelChanged(LevelChangedEvent event);
// Fired when the mute state of the audio input or output changes.
// Note that mute state is system-wide and the new value applies to every
// audio device with specified stream type.
static void onMuteChanged(MuteChangedEvent event);
// Fired when audio devices change, either new devices being added, or
// existing devices being removed.
// |devices|: List of all present audio devices after the change.
static void onDeviceListChanged(AudioDeviceInfo[] devices);
};
};
|
