code.delx.au - pulseaudio/blob - src/modules/bluetooth/module-bluetooth-policy.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2006 Lennart Poettering
   5   Copyright 2009 Canonical Ltd
   6   Copyright (C) 2012 Intel Corporation
   7
   8   PulseAudio is free software; you can redistribute it and/or modify
   9   it under the terms of the GNU Lesser General Public License as published
  10   by the Free Software Foundation; either version 2.1 of the License,
  11   or (at your option) any later version.
  12
  13   PulseAudio is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with PulseAudio; if not, write to the Free Software
  20   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  21   USA.
  22 ***/
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <pulse/xmalloc.h>
  29
  30 #include <pulsecore/core.h>
  31 #include <pulsecore/modargs.h>
  32 #include <pulsecore/source-output.h>
  33 #include <pulsecore/source.h>
  34 #include <pulsecore/core-util.h>
  35
  36 #include "module-bluetooth-policy-symdef.h"
  37
  38 PA_MODULE_AUTHOR("Frédéric Dalleau");
  39 PA_MODULE_DESCRIPTION("When a bluetooth sink or source is added, load module-loopback");
  40 PA_MODULE_VERSION(PACKAGE_VERSION);
  41 PA_MODULE_LOAD_ONCE(TRUE);
  42 PA_MODULE_USAGE(
  43         "a2dp_source=<Handle a2dp_source card profile (sink role)?> "
  44         "hfgw=<Handle hfgw card profile (headset role)?>");
  45
  46 static const char* const valid_modargs[] = {
  47     "a2dp_source",
  48     "hfgw",
  49     NULL
  50 };
  51
  52 struct userdata {
  53     bool enable_a2dp_source;
  54     bool enable_hfgw;
  55     pa_hook_slot *source_put_slot;
  56     pa_hook_slot *sink_put_slot;
  57     pa_hook_slot *port_available_changed_slot;
  58 };
  59
  60 /* When a source is created, loopback it to default sink */
  61 static pa_hook_result_t source_put_hook_callback(pa_core *c, pa_source *source, void *userdata) {
  62     struct userdata *u = userdata;
  63     const char *s;
  64     const char *role;
  65     char *args;
  66
  67     pa_assert(c);
  68     pa_assert(source);
  69
  70     /* Only consider bluetooth sinks and sources */
  71     s = pa_proplist_gets(source->proplist, PA_PROP_DEVICE_BUS);
  72     if (!s)
  73         return PA_HOOK_OK;
  74
  75     if (!pa_streq(s, "bluetooth"))
  76         return PA_HOOK_OK;
  77
  78     s = pa_proplist_gets(source->proplist, "bluetooth.protocol");
  79     if (!s)
  80         return PA_HOOK_OK;
  81
  82     if (u->enable_a2dp_source && pa_streq(s, "a2dp_source")) /* A2DP profile (we're doing sink role) */
  83         role = "music";
  84     else if (u->enable_hfgw && pa_streq(s, "hfgw")) /* HFP profile (we're doing headset role) */
  85         role = "phone";
  86     else {
  87         pa_log_debug("Profile %s cannot be selected for loopback", s);
  88         return PA_HOOK_OK;
  89     }
  90
  91     /* Load module-loopback */
  92     args = pa_sprintf_malloc("source=\"%s\" source_dont_move=\"true\" sink_input_properties=\"media.role=%s\"", source->name, role);
  93     (void) pa_module_load(c, "module-loopback", args);
  94     pa_xfree(args);
  95
  96     return PA_HOOK_OK;
  97 }
  98
  99 /* When a sink is created, loopback it to default source */
 100 static pa_hook_result_t sink_put_hook_callback(pa_core *c, pa_sink *sink, void *userdata) {
 101     struct userdata *u = userdata;
 102     const char *s;
 103     const char *role;
 104     char *args;
 105
 106     pa_assert(c);
 107     pa_assert(sink);
 108
 109     /* Only consider bluetooth sinks and sources */
 110     s = pa_proplist_gets(sink->proplist, PA_PROP_DEVICE_BUS);
 111     if (!s)
 112         return PA_HOOK_OK;
 113
 114     if (!pa_streq(s, "bluetooth"))
 115         return PA_HOOK_OK;
 116
 117     s = pa_proplist_gets(sink->proplist, "bluetooth.protocol");
 118     if (!s)
 119         return PA_HOOK_OK;
 120
 121     if (u->enable_hfgw && pa_streq(s, "hfgw")) /* HFP profile (we're doing headset role) */
 122         role = "phone";
 123     else {
 124         pa_log_debug("Profile %s cannot be selected for loopback", s);
 125         return PA_HOOK_OK;
 126     }
 127
 128     /* Load module-loopback */
 129     args = pa_sprintf_malloc("sink=\"%s\" sink_dont_move=\"true\" source_output_properties=\"media.role=%s\"", sink->name, role);
 130     (void) pa_module_load(c, "module-loopback", args);
 131     pa_xfree(args);
 132
 133     return PA_HOOK_OK;
 134 }
 135
 136 static pa_device_port* find_best_port(pa_hashmap *ports) {
 137     void *state;
 138     pa_device_port *port;
 139     pa_device_port *result = NULL;
 140
 141     PA_HASHMAP_FOREACH(port, ports, state) {
 142         if (port->available != PA_PORT_AVAILABLE_YES)
 143             continue;
 144
 145         if (result == NULL || port->priority > result->priority)
 146             result = port;
 147     }
 148
 149     return result;
 150 }
 151
 152 static void set_port_profile(pa_card *card, pa_device_port *port) {
 153     void *state;
 154     pa_card_profile *profile;
 155
 156     PA_HASHMAP_FOREACH(profile, port->profiles, state) {
 157         if (card->active_profile == profile)
 158             return;
 159
 160         pa_log_debug("Setting card '%s' to profile '%s'", card->name, profile->name);
 161
 162         if (pa_card_set_profile(card, profile->name, FALSE) != 0)
 163             pa_log_warn("Could not set profile '%s'", profile->name);
 164
 165         return;
 166     }
 167 }
 168
 169 static pa_hook_result_t port_available_hook_callback(pa_core *c, pa_device_port *port, void *userdata) {
 170     pa_card *card;
 171     const char *s;
 172     uint32_t state;
 173     pa_bool_t is_active_profile;
 174     pa_device_port *port2;
 175
 176     PA_IDXSET_FOREACH(card, c->cards, state)
 177         if (port == pa_hashmap_get(card->ports, port->name))
 178             break;
 179
 180     if (!card) {
 181         pa_log_warn("Did not find port %s in array of cards", port->name);
 182         return PA_HOOK_OK;
 183     }
 184
 185     /* Only consider bluetooth cards */
 186     s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_BUS);
 187     if (!s || !pa_streq(s, "bluetooth"))
 188         return PA_HOOK_OK;
 189
 190     /* Do not automatically switch profiles for headsets, just in case */
 191     if (pa_hashmap_get(port->profiles, "hsp") || pa_hashmap_get(port->profiles, "a2dp"))
 192         return PA_HOOK_OK;
 193
 194     is_active_profile = card->active_profile == pa_hashmap_get(port->profiles, card->active_profile->name);
 195
 196     if (is_active_profile && port->available == PA_PORT_AVAILABLE_YES)
 197         return PA_HOOK_OK;
 198
 199     if (!is_active_profile && port->available != PA_PORT_AVAILABLE_YES)
 200         return PA_HOOK_OK;
 201
 202     if ((port2 = find_best_port(card->ports)) == NULL)
 203         return PA_HOOK_OK;
 204
 205     set_port_profile(card, port2);
 206
 207     return PA_HOOK_OK;
 208 }
 209
 210 static void handle_all_ports(pa_core *core) {
 211     pa_card *card;
 212     uint32_t state;
 213
 214     PA_IDXSET_FOREACH(card, core->cards, state) {
 215         pa_device_port *port;
 216         void *state2;
 217
 218         PA_HASHMAP_FOREACH(port, card->ports, state2)
 219             port_available_hook_callback(core, port, NULL);
 220     }
 221 }
 222
 223 int pa__init(pa_module *m) {
 224     pa_modargs *ma;
 225     struct userdata *u;
 226
 227     pa_assert(m);
 228
 229     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 230         pa_log_error("Failed to parse module arguments");
 231         return -1;
 232     }
 233
 234     m->userdata = u = pa_xnew0(struct userdata, 1);
 235
 236     u->enable_a2dp_source = TRUE;
 237     if (pa_modargs_get_value_boolean(ma, "a2dp_source", &u->enable_a2dp_source) < 0) {
 238         pa_log("Failed to parse a2dp_source argument.");
 239         goto fail;
 240     }
 241
 242     u->enable_hfgw = TRUE;
 243     if (pa_modargs_get_value_boolean(ma, "hfgw", &u->enable_hfgw) < 0) {
 244         pa_log("Failed to parse hfgw argument.");
 245         goto fail;
 246     }
 247
 248     u->source_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SOURCE_PUT], PA_HOOK_NORMAL, (pa_hook_cb_t) source_put_hook_callback, u);
 249
 250     u->sink_put_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_SINK_PUT], PA_HOOK_NORMAL, (pa_hook_cb_t) sink_put_hook_callback, u);
 251
 252     u->port_available_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_PORT_AVAILABLE_CHANGED],
 253                                        PA_HOOK_NORMAL, (pa_hook_cb_t) port_available_hook_callback, u);
 254
 255     handle_all_ports(m->core);
 256
 257     pa_modargs_free(ma);
 258     return 0;
 259
 260 fail:
 261     pa_modargs_free(ma);
 262     return -1;
 263 }
 264
 265 void pa__done(pa_module *m) {
 266     struct userdata *u;
 267
 268     pa_assert(m);
 269
 270     if (!(u = m->userdata))
 271         return;
 272
 273     if (u->source_put_slot)
 274         pa_hook_slot_free(u->source_put_slot);
 275
 276     if (u->sink_put_slot)
 277         pa_hook_slot_free(u->sink_put_slot);
 278
 279     if (u->port_available_changed_slot)
 280         pa_hook_slot_free(u->port_available_changed_slot);
 281
 282     pa_xfree(u);
 283 }