code.delx.au - pulseaudio/blob - src/modules/reserve-wrap.c

   1 /***
   2   This file is part of PulseAudio.
   3
   4   Copyright 2009 Lennart Poettering
   5
   6   PulseAudio is free software; you can redistribute it and/or modify
   7   it under the terms of the GNU Lesser General Public License as published
   8   by the Free Software Foundation; either version 2.1 of the License,
   9   or (at your option) any later version.
  10
  11   PulseAudio is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with PulseAudio; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <errno.h>
  27
  28 #include <pulse/xmalloc.h>
  29 #include <pulse/i18n.h>
  30
  31 #include <pulsecore/core-error.h>
  32 #include <pulsecore/core-util.h>
  33 #include <pulsecore/shared.h>
  34
  35 #ifdef HAVE_DBUS
  36 #include <pulsecore/dbus-shared.h>
  37 #include "reserve.h"
  38 #include "reserve-monitor.h"
  39 #endif
  40
  41 #include "reserve-wrap.h"
  42
  43 struct pa_reserve_wrapper {
  44     PA_REFCNT_DECLARE;
  45     pa_core *core;
  46     pa_hook hook;
  47     char *shared_name;
  48 #ifdef HAVE_DBUS
  49     pa_dbus_connection *connection;
  50     struct rd_device *device;
  51 #endif
  52 };
  53
  54 struct pa_reserve_monitor_wrapper {
  55     PA_REFCNT_DECLARE;
  56     pa_core *core;
  57     pa_hook hook;
  58     char *shared_name;
  59 #ifdef HAVE_DBUS
  60     pa_dbus_connection *connection;
  61     struct rm_monitor *monitor;
  62 #endif
  63 };
  64
  65 static void reserve_wrapper_free(pa_reserve_wrapper *r) {
  66     pa_assert(r);
  67
  68 #ifdef HAVE_DBUS
  69     if (r->device)
  70         rd_release(r->device);
  71
  72     if (r->connection)
  73         pa_dbus_connection_unref(r->connection);
  74 #endif
  75
  76     pa_hook_done(&r->hook);
  77
  78     if (r->shared_name) {
  79         pa_assert_se(pa_shared_remove(r->core, r->shared_name) >= 0);
  80         pa_xfree(r->shared_name);
  81     }
  82
  83     pa_xfree(r);
  84 }
  85
  86 #ifdef HAVE_DBUS
  87 static int request_cb(rd_device *d, int forced) {
  88     pa_reserve_wrapper *r;
  89     int k;
  90
  91     pa_assert(d);
  92     pa_assert_se(r = rd_get_userdata(d));
  93     pa_assert(PA_REFCNT_VALUE(r) >= 1);
  94
  95     PA_REFCNT_INC(r);
  96
  97     k = pa_hook_fire(&r->hook, PA_INT_TO_PTR(forced));
  98     pa_log_debug("Device unlock of %s has been requested and %s.", r->shared_name, k < 0 ? "failed" : "succeeded");
  99
 100     pa_reserve_wrapper_unref(r);
 101
 102     return k < 0 ? -1 : 1;
 103 }
 104 #endif
 105
 106 pa_reserve_wrapper* pa_reserve_wrapper_get(pa_core *c, const char *device_name) {
 107     pa_reserve_wrapper *r;
 108     int k;
 109     char *t;
 110 #ifdef HAVE_DBUS
 111     DBusError error;
 112
 113     dbus_error_init(&error);
 114 #endif
 115
 116     pa_assert(c);
 117     pa_assert(device_name);
 118
 119     t = pa_sprintf_malloc("reserve-wrapper@%s", device_name);
 120
 121     if ((r = pa_shared_get(c, t))) {
 122         pa_xfree(t);
 123
 124         pa_assert(PA_REFCNT_VALUE(r) >= 1);
 125         PA_REFCNT_INC(r);
 126
 127         return r;
 128     }
 129
 130     r = pa_xnew0(pa_reserve_wrapper, 1);
 131     PA_REFCNT_INIT(r);
 132     r->core = c;
 133     pa_hook_init(&r->hook, r);
 134     r->shared_name = t;
 135
 136     pa_assert_se(pa_shared_set(c, r->shared_name, r) >= 0);
 137
 138 #ifdef HAVE_DBUS
 139     if (!(r->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
 140         pa_log_warn("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
 141
 142         /* We don't treat this as error here because we want allow PA
 143          * to run even when no session bus is available. */
 144         return r;
 145     }
 146
 147     if ((k = rd_acquire(
 148                  &r->device,
 149                  pa_dbus_connection_get(r->connection),
 150                  device_name,
 151                  _("PulseAudio Sound Server"),
 152                  0,
 153                  request_cb,
 154                  NULL)) < 0) {
 155
 156         if (k == -EBUSY) {
 157             pa_log_error("Device '%s' already locked.", device_name);
 158             goto fail;
 159         } else {
 160             pa_log_warn("Failed to acquire reservation lock on device '%s': %s", device_name, pa_cstrerror(-k));
 161             return r;
 162         }
 163     }
 164
 165     pa_log_debug("Successfully acquired reservation lock on device '%s'", device_name);
 166
 167     rd_set_userdata(r->device, r);
 168
 169     return r;
 170 fail:
 171     dbus_error_free(&error);
 172
 173     reserve_wrapper_free(r);
 174
 175     return NULL;
 176 #else
 177     return r;
 178 #endif
 179 }
 180
 181 void pa_reserve_wrapper_unref(pa_reserve_wrapper *r) {
 182     pa_assert(r);
 183     pa_assert(PA_REFCNT_VALUE(r) >= 1);
 184
 185     if (PA_REFCNT_DEC(r) > 0)
 186         return;
 187
 188     reserve_wrapper_free(r);
 189 }
 190
 191 pa_hook* pa_reserve_wrapper_hook(pa_reserve_wrapper *r) {
 192     pa_assert(r);
 193     pa_assert(PA_REFCNT_VALUE(r) >= 1);
 194
 195     return &r->hook;
 196 }
 197
 198 void pa_reserve_wrapper_set_application_device_name(pa_reserve_wrapper *r, const char *name) {
 199     pa_assert(r);
 200     pa_assert(PA_REFCNT_VALUE(r) >= 1);
 201
 202 #ifdef HAVE_DBUS
 203     rd_set_application_device_name(r->device, name);
 204 #endif
 205 }
 206
 207 static void reserve_monitor_wrapper_free(pa_reserve_monitor_wrapper *w) {
 208     pa_assert(w);
 209
 210 #ifdef HAVE_DBUS
 211     if (w->monitor)
 212         rm_release(w->monitor);
 213
 214     if (w->connection)
 215         pa_dbus_connection_unref(w->connection);
 216 #endif
 217
 218     pa_hook_done(&w->hook);
 219
 220     if (w->shared_name) {
 221         pa_assert_se(pa_shared_remove(w->core, w->shared_name) >= 0);
 222         pa_xfree(w->shared_name);
 223     }
 224
 225     pa_xfree(w);
 226 }
 227
 228 #ifdef HAVE_DBUS
 229 static void change_cb(rm_monitor *m) {
 230     pa_reserve_monitor_wrapper *w;
 231     int k;
 232
 233     pa_assert(m);
 234     pa_assert_se(w = rm_get_userdata(m));
 235     pa_assert(PA_REFCNT_VALUE(w) >= 1);
 236
 237     PA_REFCNT_INC(w);
 238
 239     if ((k = rm_busy(w->monitor)) < 0)
 240         return;
 241
 242     pa_hook_fire(&w->hook, PA_INT_TO_PTR(!!k));
 243     pa_log_debug("Device lock status of %s changed: %s", w->shared_name, k ? "busy" : "not busy");
 244
 245     pa_reserve_monitor_wrapper_unref(w);
 246 }
 247 #endif
 248
 249 pa_reserve_monitor_wrapper* pa_reserve_monitor_wrapper_get(pa_core *c, const char *device_name) {
 250     pa_reserve_monitor_wrapper *w;
 251     int k;
 252     char *t;
 253 #ifdef HAVE_DBUS
 254     DBusError error;
 255
 256     dbus_error_init(&error);
 257 #endif
 258
 259     pa_assert(c);
 260     pa_assert(device_name);
 261
 262     t = pa_sprintf_malloc("reserve-monitor-wrapper@%s", device_name);
 263
 264     if ((w = pa_shared_get(c, t))) {
 265         pa_xfree(t);
 266
 267         pa_assert(PA_REFCNT_VALUE(w) >= 1);
 268         PA_REFCNT_INC(w);
 269
 270         return w;
 271     }
 272
 273     w = pa_xnew0(pa_reserve_monitor_wrapper, 1);
 274     PA_REFCNT_INIT(w);
 275     w->core = c;
 276     pa_hook_init(&w->hook, w);
 277     w->shared_name = t;
 278
 279     pa_assert_se(pa_shared_set(c, w->shared_name, w) >= 0);
 280
 281 #ifdef HAVE_DBUS
 282     if (!(w->connection = pa_dbus_bus_get(c, DBUS_BUS_SESSION, &error)) || dbus_error_is_set(&error)) {
 283         pa_log_warn("Unable to contact D-Bus session bus: %s: %s", error.name, error.message);
 284
 285         /* We don't treat this as error here because we want allow PA
 286          * to run even when no session bus is available. */
 287         return w;
 288     }
 289
 290     if ((k = rm_watch(
 291                  &w->monitor,
 292                  pa_dbus_connection_get(w->connection),
 293                  device_name,
 294                  change_cb,
 295                  NULL)) < 0) {
 296
 297         pa_log_warn("Failed to create watch on device '%s': %s", device_name, pa_cstrerror(-k));
 298         goto fail;
 299     }
 300
 301     pa_log_debug("Successfully create reservation lock monitor for device '%s'", device_name);
 302
 303     rm_set_userdata(w->monitor, w);
 304     return w;
 305
 306 fail:
 307     dbus_error_free(&error);
 308
 309     reserve_monitor_wrapper_free(w);
 310
 311     return NULL;
 312 #else
 313     return w;
 314 #endif
 315 }
 316
 317 void pa_reserve_monitor_wrapper_unref(pa_reserve_monitor_wrapper *w) {
 318     pa_assert(w);
 319     pa_assert(PA_REFCNT_VALUE(w) >= 1);
 320
 321     if (PA_REFCNT_DEC(w) > 0)
 322         return;
 323
 324     reserve_monitor_wrapper_free(w);
 325 }
 326
 327 pa_hook* pa_reserve_monitor_wrapper_hook(pa_reserve_monitor_wrapper *w) {
 328     pa_assert(w);
 329     pa_assert(PA_REFCNT_VALUE(w) >= 1);
 330
 331     return &w->hook;
 332 }
 333
 334 pa_bool_t pa_reserve_monitor_wrapper_busy(pa_reserve_monitor_wrapper *w) {
 335     pa_assert(w);
 336
 337     pa_assert(PA_REFCNT_VALUE(w) >= 1);
 338
 339 #ifdef HAVE_DBUS
 340     return rm_busy(w->monitor) > 0;
 341 #else
 342     return FALSE;
 343 #endif
 344 }