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 *profile_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_card_profile *find_best_profile(pa_card *card) {
 137     void *state;
 138     pa_card_profile *profile;
 139     pa_card_profile *result = card->active_profile;
 140     pa_card_profile *off;
 141
 142     pa_assert_se(off = pa_hashmap_get(card->profiles, "off"));
 143
 144     PA_HASHMAP_FOREACH(profile, card->profiles, state) {
 145         if (profile->available == PA_AVAILABLE_NO || profile == off)
 146             continue;
 147
 148         if (result == NULL ||
 149             (profile->available == PA_AVAILABLE_YES && result->available == PA_AVAILABLE_UNKNOWN) ||
 150             (profile->available == result->available && profile->priority > result->priority))
 151             result = profile;
 152     }
 153
 154     return result ? result : off;
 155 }
 156
 157 static pa_hook_result_t profile_available_hook_callback(pa_core *c, pa_card_profile *profile, void *userdata) {
 158     pa_card *card;
 159     const char *s;
 160     bool is_active_profile;
 161     pa_card_profile *selected_profile;
 162
 163     pa_assert(c);
 164     pa_assert(profile);
 165     pa_assert_se((card = profile->card));
 166
 167     /* Only consider bluetooth cards */
 168     s = pa_proplist_gets(card->proplist, PA_PROP_DEVICE_BUS);
 169     if (!s || !pa_streq(s, "bluetooth"))
 170         return PA_HOOK_OK;
 171
 172     /* Do not automatically switch profiles for headsets, just in case */
 173     if (pa_streq(profile->name, "hsp") || pa_streq(profile->name, "a2dp"))
 174         return PA_HOOK_OK;
 175
 176     is_active_profile = card->active_profile == profile;
 177
 178     if (profile->available == PA_AVAILABLE_YES) {
 179         if (is_active_profile)
 180             return PA_HOOK_OK;
 181
 182         if (card->active_profile->available == PA_AVAILABLE_YES && card->active_profile->priority >= profile->priority)
 183             return PA_HOOK_OK;
 184
 185         selected_profile = profile;
 186     } else {
 187         if (!is_active_profile)
 188             return PA_HOOK_OK;
 189
 190         pa_assert_se((selected_profile = find_best_profile(card)));
 191
 192         if (selected_profile == card->active_profile)
 193             return PA_HOOK_OK;
 194     }
 195
 196     pa_log_debug("Setting card '%s' to profile '%s'", card->name, selected_profile->name);
 197
 198     if (pa_card_set_profile(card, selected_profile, false) != 0)
 199         pa_log_warn("Could not set profile '%s'", selected_profile->name);
 200
 201     return PA_HOOK_OK;
 202 }
 203
 204 static void handle_all_profiles(pa_core *core) {
 205     pa_card *card;
 206     uint32_t state;
 207
 208     PA_IDXSET_FOREACH(card, core->cards, state) {
 209         pa_card_profile *profile;
 210         void *state2;
 211
 212         PA_HASHMAP_FOREACH(profile, card->profiles, state2)
 213             profile_available_hook_callback(core, profile, NULL);
 214     }
 215 }
 216
 217 int pa__init(pa_module *m) {
 218     pa_modargs *ma;
 219     struct userdata *u;
 220
 221     pa_assert(m);
 222
 223     if (!(ma = pa_modargs_new(m->argument, valid_modargs))) {
 224         pa_log_error("Failed to parse module arguments");
 225         return -1;
 226     }
 227
 228     m->userdata = u = pa_xnew0(struct userdata, 1);
 229
 230     u->enable_a2dp_source = true;
 231     if (pa_modargs_get_value_boolean(ma, "a2dp_source", &u->enable_a2dp_source) < 0) {
 232         pa_log("Failed to parse a2dp_source argument.");
 233         goto fail;
 234     }
 235
 236     u->enable_hfgw = true;
 237     if (pa_modargs_get_value_boolean(ma, "hfgw", &u->enable_hfgw) < 0) {
 238         pa_log("Failed to parse hfgw argument.");
 239         goto fail;
 240     }
 241
 242     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);
 243
 244     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);
 245
 246     u->profile_available_changed_slot = pa_hook_connect(&m->core->hooks[PA_CORE_HOOK_CARD_PROFILE_AVAILABLE_CHANGED],
 247                                                         PA_HOOK_NORMAL, (pa_hook_cb_t) profile_available_hook_callback, u);
 248
 249     handle_all_profiles(m->core);
 250
 251     pa_modargs_free(ma);
 252     return 0;
 253
 254 fail:
 255     pa_modargs_free(ma);
 256     return -1;
 257 }
 258
 259 void pa__done(pa_module *m) {
 260     struct userdata *u;
 261
 262     pa_assert(m);
 263
 264     if (!(u = m->userdata))
 265         return;
 266
 267     if (u->source_put_slot)
 268         pa_hook_slot_free(u->source_put_slot);
 269
 270     if (u->sink_put_slot)
 271         pa_hook_slot_free(u->sink_put_slot);
 272
 273     if (u->profile_available_changed_slot)
 274         pa_hook_slot_free(u->profile_available_changed_slot);
 275
 276     pa_xfree(u);
 277 }