Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2011 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | |
| 18 | #ifndef ANDROID_AUDIO_POLICY_INTERFACE_H |
| 19 | #define ANDROID_AUDIO_POLICY_INTERFACE_H |
| 20 | |
| 21 | #include <stdint.h> |
| 22 | #include <sys/cdefs.h> |
| 23 | #include <sys/types.h> |
| 24 | |
| 25 | #include <hardware/hardware.h> |
| 26 | |
Dima Zavin | aa21172 | 2011-05-11 14:15:53 -0700 | [diff] [blame] | 27 | #include <system/audio.h> |
Dima Zavin | 1199865 | 2011-06-13 18:00:30 -0700 | [diff] [blame] | 28 | #include <system/audio_policy.h> |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 29 | |
| 30 | __BEGIN_DECLS |
| 31 | |
| 32 | /** |
| 33 | * The id of this module |
| 34 | */ |
| 35 | #define AUDIO_POLICY_HARDWARE_MODULE_ID "audio_policy" |
| 36 | |
| 37 | /** |
| 38 | * Name of the audio devices to open |
| 39 | */ |
| 40 | #define AUDIO_POLICY_INTERFACE "policy" |
| 41 | |
| 42 | /* ---------------------------------------------------------------------------- */ |
| 43 | |
| 44 | /* |
| 45 | * The audio_policy and audio_policy_service_ops structs define the |
| 46 | * communication interfaces between the platform specific audio policy manager |
| 47 | * and Android generic audio policy manager. |
| 48 | * The platform specific audio policy manager must implement methods of the |
| 49 | * audio_policy struct. |
| 50 | * This implementation makes use of the audio_policy_service_ops to control |
| 51 | * the activity and configuration of audio input and output streams. |
| 52 | * |
| 53 | * The platform specific audio policy manager is in charge of the audio |
| 54 | * routing and volume control policies for a given platform. |
| 55 | * The main roles of this module are: |
| 56 | * - keep track of current system state (removable device connections, phone |
| 57 | * state, user requests...). |
| 58 | * System state changes and user actions are notified to audio policy |
| 59 | * manager with methods of the audio_policy. |
| 60 | * |
| 61 | * - process get_output() queries received when AudioTrack objects are |
| 62 | * created: Those queries return a handler on an output that has been |
| 63 | * selected, configured and opened by the audio policy manager and that |
| 64 | * must be used by the AudioTrack when registering to the AudioFlinger |
| 65 | * with the createTrack() method. |
| 66 | * When the AudioTrack object is released, a release_output() query |
| 67 | * is received and the audio policy manager can decide to close or |
| 68 | * reconfigure the output depending on other streams using this output and |
| 69 | * current system state. |
| 70 | * |
| 71 | * - similarly process get_input() and release_input() queries received from |
| 72 | * AudioRecord objects and configure audio inputs. |
| 73 | * - process volume control requests: the stream volume is converted from |
| 74 | * an index value (received from UI) to a float value applicable to each |
| 75 | * output as a function of platform specific settings and current output |
| 76 | * route (destination device). It also make sure that streams are not |
| 77 | * muted if not allowed (e.g. camera shutter sound in some countries). |
| 78 | */ |
| 79 | |
| 80 | /* XXX: this should be defined OUTSIDE of frameworks/base */ |
| 81 | struct effect_descriptor_s; |
| 82 | |
| 83 | struct audio_policy { |
| 84 | /* |
| 85 | * configuration functions |
| 86 | */ |
| 87 | |
| 88 | /* indicate a change in device connection status */ |
| 89 | int (*set_device_connection_state)(struct audio_policy *pol, |
| 90 | audio_devices_t device, |
| 91 | audio_policy_dev_state_t state, |
| 92 | const char *device_address); |
| 93 | |
Eric Laurent | ca20b17 | 2011-12-09 17:10:40 -0800 | [diff] [blame] | 94 | /* retrieve a device connection status */ |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 95 | audio_policy_dev_state_t (*get_device_connection_state)( |
| 96 | const struct audio_policy *pol, |
| 97 | audio_devices_t device, |
| 98 | const char *device_address); |
| 99 | |
| 100 | /* indicate a change in phone state. Valid phones states are defined |
| 101 | * by audio_mode_t */ |
Glenn Kasten | 6df641e | 2012-01-09 10:41:30 -0800 | [diff] [blame] | 102 | void (*set_phone_state)(struct audio_policy *pol, audio_mode_t state); |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 103 | |
Glenn Kasten | 080a802 | 2012-01-18 15:15:07 -0800 | [diff] [blame] | 104 | /* deprecated, never called (was "indicate a change in ringer mode") */ |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 105 | void (*set_ringer_mode)(struct audio_policy *pol, uint32_t mode, |
| 106 | uint32_t mask); |
| 107 | |
| 108 | /* force using a specific device category for the specified usage */ |
| 109 | void (*set_force_use)(struct audio_policy *pol, |
| 110 | audio_policy_force_use_t usage, |
| 111 | audio_policy_forced_cfg_t config); |
| 112 | |
Eric Laurent | ca20b17 | 2011-12-09 17:10:40 -0800 | [diff] [blame] | 113 | /* retrieve current device category forced for a given usage */ |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 114 | audio_policy_forced_cfg_t (*get_force_use)(const struct audio_policy *pol, |
| 115 | audio_policy_force_use_t usage); |
| 116 | |
| 117 | /* if can_mute is true, then audio streams that are marked ENFORCED_AUDIBLE |
| 118 | * can still be muted. */ |
| 119 | void (*set_can_mute_enforced_audible)(struct audio_policy *pol, |
| 120 | bool can_mute); |
| 121 | |
| 122 | /* check proper initialization */ |
| 123 | int (*init_check)(const struct audio_policy *pol); |
| 124 | |
| 125 | /* |
| 126 | * Audio routing query functions |
| 127 | */ |
| 128 | |
Glenn Kasten | 0cacd8d | 2012-02-10 13:42:44 -0800 | [diff] [blame] | 129 | /* request an output appropriate for playback of the supplied stream type and |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 130 | * parameters */ |
| 131 | audio_io_handle_t (*get_output)(struct audio_policy *pol, |
| 132 | audio_stream_type_t stream, |
| 133 | uint32_t samplingRate, |
Glenn Kasten | fe79eb3 | 2012-01-12 14:55:57 -0800 | [diff] [blame] | 134 | audio_format_t format, |
Glenn Kasten | a635449 | 2012-06-19 12:16:04 -0700 | [diff] [blame] | 135 | audio_channel_mask_t channelMask, |
Eric Laurent | da4b0b2 | 2012-04-18 13:58:44 -0700 | [diff] [blame] | 136 | audio_output_flags_t flags); |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 137 | |
| 138 | /* indicates to the audio policy manager that the output starts being used |
| 139 | * by corresponding stream. */ |
| 140 | int (*start_output)(struct audio_policy *pol, |
| 141 | audio_io_handle_t output, |
| 142 | audio_stream_type_t stream, |
| 143 | int session); |
| 144 | |
| 145 | /* indicates to the audio policy manager that the output stops being used |
| 146 | * by corresponding stream. */ |
| 147 | int (*stop_output)(struct audio_policy *pol, |
| 148 | audio_io_handle_t output, |
| 149 | audio_stream_type_t stream, |
| 150 | int session); |
| 151 | |
| 152 | /* releases the output. */ |
| 153 | void (*release_output)(struct audio_policy *pol, audio_io_handle_t output); |
| 154 | |
Glenn Kasten | ae2e42b | 2012-01-26 16:47:25 -0800 | [diff] [blame] | 155 | /* request an input appropriate for record from the supplied device with |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 156 | * supplied parameters. */ |
Glenn Kasten | ae2e42b | 2012-01-26 16:47:25 -0800 | [diff] [blame] | 157 | audio_io_handle_t (*get_input)(struct audio_policy *pol, audio_source_t inputSource, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 158 | uint32_t samplingRate, |
Glenn Kasten | fe79eb3 | 2012-01-12 14:55:57 -0800 | [diff] [blame] | 159 | audio_format_t format, |
Glenn Kasten | a635449 | 2012-06-19 12:16:04 -0700 | [diff] [blame] | 160 | audio_channel_mask_t channelMask, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 161 | audio_in_acoustics_t acoustics); |
| 162 | |
| 163 | /* indicates to the audio policy manager that the input starts being used */ |
| 164 | int (*start_input)(struct audio_policy *pol, audio_io_handle_t input); |
| 165 | |
| 166 | /* indicates to the audio policy manager that the input stops being used. */ |
| 167 | int (*stop_input)(struct audio_policy *pol, audio_io_handle_t input); |
| 168 | |
| 169 | /* releases the input. */ |
| 170 | void (*release_input)(struct audio_policy *pol, audio_io_handle_t input); |
| 171 | |
| 172 | /* |
| 173 | * volume control functions |
| 174 | */ |
| 175 | |
| 176 | /* initialises stream volume conversion parameters by specifying volume |
Eric Laurent | ca20b17 | 2011-12-09 17:10:40 -0800 | [diff] [blame] | 177 | * index range. The index range for each stream is defined by AudioService. */ |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 178 | void (*init_stream_volume)(struct audio_policy *pol, |
| 179 | audio_stream_type_t stream, |
| 180 | int index_min, |
| 181 | int index_max); |
| 182 | |
| 183 | /* sets the new stream volume at a level corresponding to the supplied |
Eric Laurent | ca20b17 | 2011-12-09 17:10:40 -0800 | [diff] [blame] | 184 | * index. The index is within the range specified by init_stream_volume() */ |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 185 | int (*set_stream_volume_index)(struct audio_policy *pol, |
| 186 | audio_stream_type_t stream, |
| 187 | int index); |
| 188 | |
Eric Laurent | ca20b17 | 2011-12-09 17:10:40 -0800 | [diff] [blame] | 189 | /* retrieve current volume index for the specified stream */ |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 190 | int (*get_stream_volume_index)(const struct audio_policy *pol, |
| 191 | audio_stream_type_t stream, |
| 192 | int *index); |
| 193 | |
Eric Laurent | ca20b17 | 2011-12-09 17:10:40 -0800 | [diff] [blame] | 194 | /* sets the new stream volume at a level corresponding to the supplied |
| 195 | * index for the specified device. |
| 196 | * The index is within the range specified by init_stream_volume() */ |
| 197 | int (*set_stream_volume_index_for_device)(struct audio_policy *pol, |
| 198 | audio_stream_type_t stream, |
| 199 | int index, |
| 200 | audio_devices_t device); |
| 201 | |
| 202 | /* retrieve current volume index for the specified stream for the specified device */ |
| 203 | int (*get_stream_volume_index_for_device)(const struct audio_policy *pol, |
| 204 | audio_stream_type_t stream, |
| 205 | int *index, |
| 206 | audio_devices_t device); |
| 207 | |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 208 | /* return the strategy corresponding to a given stream type */ |
| 209 | uint32_t (*get_strategy_for_stream)(const struct audio_policy *pol, |
| 210 | audio_stream_type_t stream); |
| 211 | |
| 212 | /* return the enabled output devices for the given stream type */ |
Eric Laurent | 83c62ce | 2012-03-08 13:44:18 -0800 | [diff] [blame] | 213 | audio_devices_t (*get_devices_for_stream)(const struct audio_policy *pol, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 214 | audio_stream_type_t stream); |
| 215 | |
| 216 | /* Audio effect management */ |
| 217 | audio_io_handle_t (*get_output_for_effect)(struct audio_policy *pol, |
Glenn Kasten | 48915ac | 2012-02-20 12:08:57 -0800 | [diff] [blame^] | 218 | const struct effect_descriptor_s *desc); |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 219 | |
| 220 | int (*register_effect)(struct audio_policy *pol, |
Glenn Kasten | 48915ac | 2012-02-20 12:08:57 -0800 | [diff] [blame^] | 221 | const struct effect_descriptor_s *desc, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 222 | audio_io_handle_t output, |
| 223 | uint32_t strategy, |
| 224 | int session, |
| 225 | int id); |
| 226 | |
| 227 | int (*unregister_effect)(struct audio_policy *pol, int id); |
| 228 | |
Eric Laurent | 78d2c69 | 2011-08-10 20:15:48 -0700 | [diff] [blame] | 229 | int (*set_effect_enabled)(struct audio_policy *pol, int id, bool enabled); |
| 230 | |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 231 | bool (*is_stream_active)(const struct audio_policy *pol, |
Glenn Kasten | 5161a84 | 2012-01-12 14:56:21 -0800 | [diff] [blame] | 232 | audio_stream_type_t stream, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 233 | uint32_t in_past_ms); |
| 234 | |
| 235 | /* dump state */ |
| 236 | int (*dump)(const struct audio_policy *pol, int fd); |
| 237 | }; |
| 238 | |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 239 | /* audio hw module handle used by load_hw_module(), open_output_on_module() |
| 240 | * and open_input_on_module() */ |
| 241 | typedef int audio_module_handle_t; |
| 242 | |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 243 | struct audio_policy_service_ops { |
| 244 | /* |
| 245 | * Audio output Control functions |
| 246 | */ |
| 247 | |
| 248 | /* Opens an audio output with the requested parameters. |
| 249 | * |
| 250 | * The parameter values can indicate to use the default values in case the |
| 251 | * audio policy manager has no specific requirements for the output being |
| 252 | * opened. |
| 253 | * |
| 254 | * When the function returns, the parameter values reflect the actual |
| 255 | * values used by the audio hardware output stream. |
| 256 | * |
| 257 | * The audio policy manager can check if the proposed parameters are |
| 258 | * suitable or not and act accordingly. |
| 259 | */ |
| 260 | audio_io_handle_t (*open_output)(void *service, |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 261 | audio_devices_t *pDevices, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 262 | uint32_t *pSamplingRate, |
Glenn Kasten | fe79eb3 | 2012-01-12 14:55:57 -0800 | [diff] [blame] | 263 | audio_format_t *pFormat, |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 264 | audio_channel_mask_t *pChannelMask, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 265 | uint32_t *pLatencyMs, |
Eric Laurent | da4b0b2 | 2012-04-18 13:58:44 -0700 | [diff] [blame] | 266 | audio_output_flags_t flags); |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 267 | |
| 268 | /* creates a special output that is duplicated to the two outputs passed as |
| 269 | * arguments. The duplication is performed by |
| 270 | * a special mixer thread in the AudioFlinger. |
| 271 | */ |
| 272 | audio_io_handle_t (*open_duplicate_output)(void *service, |
| 273 | audio_io_handle_t output1, |
| 274 | audio_io_handle_t output2); |
| 275 | |
| 276 | /* closes the output stream */ |
| 277 | int (*close_output)(void *service, audio_io_handle_t output); |
| 278 | |
| 279 | /* suspends the output. |
| 280 | * |
| 281 | * When an output is suspended, the corresponding audio hardware output |
| 282 | * stream is placed in standby and the AudioTracks attached to the mixer |
| 283 | * thread are still processed but the output mix is discarded. |
| 284 | */ |
| 285 | int (*suspend_output)(void *service, audio_io_handle_t output); |
| 286 | |
| 287 | /* restores a suspended output. */ |
| 288 | int (*restore_output)(void *service, audio_io_handle_t output); |
| 289 | |
| 290 | /* */ |
| 291 | /* Audio input Control functions */ |
| 292 | /* */ |
| 293 | |
| 294 | /* opens an audio input */ |
| 295 | audio_io_handle_t (*open_input)(void *service, |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 296 | audio_devices_t *pDevices, |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 297 | uint32_t *pSamplingRate, |
Glenn Kasten | fe79eb3 | 2012-01-12 14:55:57 -0800 | [diff] [blame] | 298 | audio_format_t *pFormat, |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 299 | audio_channel_mask_t *pChannelMask, |
Glenn Kasten | 114c2fd | 2012-01-27 12:51:17 -0800 | [diff] [blame] | 300 | audio_in_acoustics_t acoustics); |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 301 | |
| 302 | /* closes an audio input */ |
| 303 | int (*close_input)(void *service, audio_io_handle_t input); |
| 304 | |
| 305 | /* */ |
| 306 | /* misc control functions */ |
| 307 | /* */ |
| 308 | |
| 309 | /* set a stream volume for a particular output. |
| 310 | * |
| 311 | * For the same user setting, a given stream type can have different |
| 312 | * volumes for each output (destination device) it is attached to. |
| 313 | */ |
| 314 | int (*set_stream_volume)(void *service, |
| 315 | audio_stream_type_t stream, |
| 316 | float volume, |
| 317 | audio_io_handle_t output, |
| 318 | int delay_ms); |
| 319 | |
| 320 | /* reroute a given stream type to the specified output */ |
| 321 | int (*set_stream_output)(void *service, |
| 322 | audio_stream_type_t stream, |
| 323 | audio_io_handle_t output); |
| 324 | |
| 325 | /* function enabling to send proprietary informations directly from audio |
| 326 | * policy manager to audio hardware interface. */ |
| 327 | void (*set_parameters)(void *service, |
| 328 | audio_io_handle_t io_handle, |
| 329 | const char *kv_pairs, |
| 330 | int delay_ms); |
| 331 | |
| 332 | /* function enabling to receive proprietary informations directly from |
| 333 | * audio hardware interface to audio policy manager. |
| 334 | * |
| 335 | * Returns a pointer to a heap allocated string. The caller is responsible |
Glenn Kasten | 0cacd8d | 2012-02-10 13:42:44 -0800 | [diff] [blame] | 336 | * for freeing the memory for it using free(). |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 337 | */ |
| 338 | |
| 339 | char * (*get_parameters)(void *service, audio_io_handle_t io_handle, |
| 340 | const char *keys); |
| 341 | |
| 342 | /* request the playback of a tone on the specified stream. |
| 343 | * used for instance to replace notification sounds when playing over a |
| 344 | * telephony device during a phone call. |
| 345 | */ |
| 346 | int (*start_tone)(void *service, |
| 347 | audio_policy_tone_t tone, |
| 348 | audio_stream_type_t stream); |
| 349 | |
| 350 | int (*stop_tone)(void *service); |
| 351 | |
| 352 | /* set down link audio volume. */ |
| 353 | int (*set_voice_volume)(void *service, |
| 354 | float volume, |
| 355 | int delay_ms); |
| 356 | |
| 357 | /* move effect to the specified output */ |
| 358 | int (*move_effects)(void *service, |
| 359 | int session, |
| 360 | audio_io_handle_t src_output, |
| 361 | audio_io_handle_t dst_output); |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 362 | |
| 363 | /* loads an audio hw module. |
| 364 | * |
| 365 | * The module name passed is the base name of the HW module library, e.g "primary" or "a2dp". |
| 366 | * The function returns a handle on the module that will be used to specify a particular |
| 367 | * module when calling open_output_on_module() or open_input_on_module() |
| 368 | */ |
| 369 | audio_module_handle_t (*load_hw_module)(void *service, |
| 370 | const char *name); |
| 371 | |
| 372 | /* Opens an audio output on a particular HW module. |
| 373 | * |
| 374 | * Same as open_output() but specifying a specific HW module on which the output must be opened. |
| 375 | */ |
| 376 | audio_io_handle_t (*open_output_on_module)(void *service, |
| 377 | audio_module_handle_t module, |
| 378 | audio_devices_t *pDevices, |
| 379 | uint32_t *pSamplingRate, |
| 380 | audio_format_t *pFormat, |
| 381 | audio_channel_mask_t *pChannelMask, |
| 382 | uint32_t *pLatencyMs, |
Eric Laurent | da4b0b2 | 2012-04-18 13:58:44 -0700 | [diff] [blame] | 383 | audio_output_flags_t flags); |
Eric Laurent | c65a2fe | 2012-03-28 11:10:51 -0700 | [diff] [blame] | 384 | |
| 385 | /* Opens an audio input on a particular HW module. |
| 386 | * |
| 387 | * Same as open_input() but specifying a specific HW module on which the input must be opened. |
| 388 | * Also removed deprecated acoustics parameter |
| 389 | */ |
| 390 | audio_io_handle_t (*open_input_on_module)(void *service, |
| 391 | audio_module_handle_t module, |
| 392 | audio_devices_t *pDevices, |
| 393 | uint32_t *pSamplingRate, |
| 394 | audio_format_t *pFormat, |
| 395 | audio_channel_mask_t *pChannelMask); |
| 396 | |
Dima Zavin | f1504db | 2011-03-11 11:20:49 -0800 | [diff] [blame] | 397 | }; |
| 398 | |
| 399 | /**********************************************************************/ |
| 400 | |
| 401 | /** |
| 402 | * Every hardware module must have a data structure named HAL_MODULE_INFO_SYM |
| 403 | * and the fields of this data structure must begin with hw_module_t |
| 404 | * followed by module specific information. |
| 405 | */ |
| 406 | typedef struct audio_policy_module { |
| 407 | struct hw_module_t common; |
| 408 | } audio_policy_module_t; |
| 409 | |
| 410 | struct audio_policy_device { |
| 411 | struct hw_device_t common; |
| 412 | |
| 413 | int (*create_audio_policy)(const struct audio_policy_device *device, |
| 414 | struct audio_policy_service_ops *aps_ops, |
| 415 | void *service, |
| 416 | struct audio_policy **ap); |
| 417 | |
| 418 | int (*destroy_audio_policy)(const struct audio_policy_device *device, |
| 419 | struct audio_policy *ap); |
| 420 | }; |
| 421 | |
| 422 | /** convenience API for opening and closing a supported device */ |
| 423 | |
| 424 | static inline int audio_policy_dev_open(const hw_module_t* module, |
| 425 | struct audio_policy_device** device) |
| 426 | { |
| 427 | return module->methods->open(module, AUDIO_POLICY_INTERFACE, |
| 428 | (hw_device_t**)device); |
| 429 | } |
| 430 | |
| 431 | static inline int audio_policy_dev_close(struct audio_policy_device* device) |
| 432 | { |
| 433 | return device->common.close(&device->common); |
| 434 | } |
| 435 | |
| 436 | |
| 437 | __END_DECLS |
| 438 | |
| 439 | #endif // ANDROID_AUDIO_POLICY_INTERFACE_H |