modules/audio/audio_policy.c

   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 #define LOG_TAG "audio_policy_default"
  18 //#define LOG_NDEBUG 0
  19
  20 #include <errno.h>
  21 #include <stdint.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include <hardware/hardware.h>
  26 #include <system/audio.h>
  27 #include <system/audio_policy.h>
  28 #include <hardware/audio_policy.h>
  29
  30 struct default_ap_module {
  31     struct audio_policy_module module;
  32 };
  33
  34 struct default_ap_device {
  35     struct audio_policy_device device;
  36 };
  37
  38 struct default_audio_policy {
  39     struct audio_policy policy;
  40
  41     struct audio_policy_service_ops *aps_ops;
  42     void *service;
  43 };
  44
  45 static int ap_set_device_connection_state(struct audio_policy *pol,
  46                                           audio_devices_t device,
  47                                           audio_policy_dev_state_t state,
  48                                           const char *device_address)
  49 {
  50     return -ENOSYS;
  51 }
  52
  53 static audio_policy_dev_state_t ap_get_device_connection_state(
  54                                             const struct audio_policy *pol,
  55                                             audio_devices_t device,
  56                                             const char *device_address)
  57 {
  58     return AUDIO_POLICY_DEVICE_STATE_UNAVAILABLE;
  59 }
  60
  61 static void ap_set_phone_state(struct audio_policy *pol, audio_mode_t state)
  62 {
  63 }
  64
  65 static void ap_set_ringer_mode(struct audio_policy *pol, uint32_t mode,
  66                                uint32_t mask)
  67 {
  68 }
  69
  70 static void ap_set_force_use(struct audio_policy *pol,
  71                           audio_policy_force_use_t usage,
  72                           audio_policy_forced_cfg_t config)
  73 {
  74 }
  75
  76     /* retreive current device category forced for a given usage */
  77 static audio_policy_forced_cfg_t ap_get_force_use(
  78                                                const struct audio_policy *pol,
  79                                                audio_policy_force_use_t usage)
  80 {
  81     return AUDIO_POLICY_FORCE_NONE;
  82 }
  83
  84 /* if can_mute is true, then audio streams that are marked ENFORCED_AUDIBLE
  85  * can still be muted. */
  86 static void ap_set_can_mute_enforced_audible(struct audio_policy *pol,
  87                                              bool can_mute)
  88 {
  89 }
  90
  91 static int ap_init_check(const struct audio_policy *pol)
  92 {
  93     return 0;
  94 }
  95
  96 static audio_io_handle_t ap_get_output(struct audio_policy *pol,
  97                                        audio_stream_type_t stream,
  98                                        uint32_t sampling_rate,
  99                                        uint32_t format,
 100                                        uint32_t channels,
 101                                        audio_policy_output_flags_t flags)
 102 {
 103     return 0;
 104 }
 105
 106 static int ap_start_output(struct audio_policy *pol, audio_io_handle_t output,
 107                            audio_stream_type_t stream, int session)
 108 {
 109     return -ENOSYS;
 110 }
 111
 112 static int ap_stop_output(struct audio_policy *pol, audio_io_handle_t output,
 113                           audio_stream_type_t stream, int session)
 114 {
 115     return -ENOSYS;
 116 }
 117
 118 static void ap_release_output(struct audio_policy *pol,
 119                               audio_io_handle_t output)
 120 {
 121 }
 122
 123 static audio_io_handle_t ap_get_input(struct audio_policy *pol, int inputSource,
 124                                       uint32_t sampling_rate,
 125                                       uint32_t format,
 126                                       uint32_t channels,
 127                                       audio_in_acoustics_t acoustics)
 128 {
 129     return 0;
 130 }
 131
 132 static int ap_start_input(struct audio_policy *pol, audio_io_handle_t input)
 133 {
 134     return -ENOSYS;
 135 }
 136
 137 static int ap_stop_input(struct audio_policy *pol, audio_io_handle_t input)
 138 {
 139     return -ENOSYS;
 140 }
 141
 142 static void ap_release_input(struct audio_policy *pol, audio_io_handle_t input)
 143 {
 144 }
 145
 146 static void ap_init_stream_volume(struct audio_policy *pol,
 147                                   audio_stream_type_t stream, int index_min,
 148                                   int index_max)
 149 {
 150 }
 151
 152 static int ap_set_stream_volume_index(struct audio_policy *pol,
 153                                       audio_stream_type_t stream,
 154                                       int index)
 155 {
 156     return -ENOSYS;
 157 }
 158
 159 static int ap_get_stream_volume_index(const struct audio_policy *pol,
 160                                       audio_stream_type_t stream,
 161                                       int *index)
 162 {
 163     return -ENOSYS;
 164 }
 165
 166 static uint32_t ap_get_strategy_for_stream(const struct audio_policy *pol,
 167                                            audio_stream_type_t stream)
 168 {
 169     return 0;
 170 }
 171
 172 static uint32_t ap_get_devices_for_stream(const struct audio_policy *pol,
 173                                           audio_stream_type_t stream)
 174 {
 175     return 0;
 176 }
 177
 178 static audio_io_handle_t ap_get_output_for_effect(struct audio_policy *pol,
 179                                             struct effect_descriptor_s *desc)
 180 {
 181     return 0;
 182 }
 183
 184 static int ap_register_effect(struct audio_policy *pol,
 185                               struct effect_descriptor_s *desc,
 186                               audio_io_handle_t output,
 187                               uint32_t strategy,
 188                               int session,
 189                               int id)
 190 {
 191     return -ENOSYS;
 192 }
 193
 194 static int ap_unregister_effect(struct audio_policy *pol, int id)
 195 {
 196     return -ENOSYS;
 197 }
 198
 199 static int ap_set_effect_enabled(struct audio_policy *pol, int id, bool enabled)
 200 {
 201     return -ENOSYS;
 202 }
 203
 204 static bool ap_is_stream_active(const struct audio_policy *pol, int stream,
 205                                 uint32_t in_past_ms)
 206 {
 207     return false;
 208 }
 209
 210 static int ap_dump(const struct audio_policy *pol, int fd)
 211 {
 212     return -ENOSYS;
 213 }
 214
 215 static int create_default_ap(const struct audio_policy_device *device,
 216                              struct audio_policy_service_ops *aps_ops,
 217                              void *service,
 218                              struct audio_policy **ap)
 219 {
 220     struct default_ap_device *dev;
 221     struct default_audio_policy *dap;
 222     int ret;
 223
 224     *ap = NULL;
 225
 226     if (!service || !aps_ops)
 227         return -EINVAL;
 228
 229     dap = (struct default_audio_policy *)calloc(1, sizeof(*dap));
 230     if (!dap)
 231         return -ENOMEM;
 232
 233     dap->policy.set_device_connection_state = ap_set_device_connection_state;
 234     dap->policy.get_device_connection_state = ap_get_device_connection_state;
 235     dap->policy.set_phone_state = ap_set_phone_state;
 236     dap->policy.set_ringer_mode = ap_set_ringer_mode;
 237     dap->policy.set_force_use = ap_set_force_use;
 238     dap->policy.get_force_use = ap_get_force_use;
 239     dap->policy.set_can_mute_enforced_audible =
 240         ap_set_can_mute_enforced_audible;
 241     dap->policy.init_check = ap_init_check;
 242     dap->policy.get_output = ap_get_output;
 243     dap->policy.start_output = ap_start_output;
 244     dap->policy.stop_output = ap_stop_output;
 245     dap->policy.release_output = ap_release_output;
 246     dap->policy.get_input = ap_get_input;
 247     dap->policy.start_input = ap_start_input;
 248     dap->policy.stop_input = ap_stop_input;
 249     dap->policy.release_input = ap_release_input;
 250     dap->policy.init_stream_volume = ap_init_stream_volume;
 251     dap->policy.set_stream_volume_index = ap_set_stream_volume_index;
 252     dap->policy.get_stream_volume_index = ap_get_stream_volume_index;
 253     dap->policy.get_strategy_for_stream = ap_get_strategy_for_stream;
 254     dap->policy.get_devices_for_stream = ap_get_devices_for_stream;
 255     dap->policy.get_output_for_effect = ap_get_output_for_effect;
 256     dap->policy.register_effect = ap_register_effect;
 257     dap->policy.unregister_effect = ap_unregister_effect;
 258     dap->policy.set_effect_enabled = ap_set_effect_enabled;
 259     dap->policy.is_stream_active = ap_is_stream_active;
 260     dap->policy.dump = ap_dump;
 261
 262     dap->service = service;
 263     dap->aps_ops = aps_ops;
 264
 265     *ap = &dap->policy;
 266     return 0;
 267 }
 268
 269 static int destroy_default_ap(const struct audio_policy_device *ap_dev,
 270                               struct audio_policy *ap)
 271 {
 272     free(ap);
 273     return 0;
 274 }
 275
 276 static int default_ap_dev_close(hw_device_t* device)
 277 {
 278     free(device);
 279     return 0;
 280 }
 281
 282 static int default_ap_dev_open(const hw_module_t* module, const char* name,
 283                                hw_device_t** device)
 284 {
 285     struct default_ap_device *dev;
 286
 287     *device = NULL;
 288
 289     if (strcmp(name, AUDIO_POLICY_INTERFACE) != 0)
 290         return -EINVAL;
 291
 292     dev = (struct default_ap_device *)calloc(1, sizeof(*dev));
 293     if (!dev)
 294         return -ENOMEM;
 295
 296     dev->device.common.tag = HARDWARE_DEVICE_TAG;
 297     dev->device.common.version = 0;
 298     dev->device.common.module = (hw_module_t *)module;
 299     dev->device.common.close = default_ap_dev_close;
 300     dev->device.create_audio_policy = create_default_ap;
 301     dev->device.destroy_audio_policy = destroy_default_ap;
 302
 303     *device = &dev->device.common;
 304
 305     return 0;
 306 }
 307
 308 static struct hw_module_methods_t default_ap_module_methods = {
 309     .open = default_ap_dev_open,
 310 };
 311
 312 struct default_ap_module HAL_MODULE_INFO_SYM = {
 313     .module = {
 314         .common = {
 315             .tag            = HARDWARE_MODULE_TAG,
 316             .version_major  = 1,
 317             .version_minor  = 0,
 318             .id             = AUDIO_POLICY_HARDWARE_MODULE_ID,
 319             .name           = "Default audio policy HAL",
 320             .author         = "The Android Open Source Project",
 321             .methods        = &default_ap_module_methods,
 322         },
 323     },
 324 };