2 * empathy-sound-manager.c - Various sound related utility functions.
3 * Copyright (C) 2009-2010 Collabora Ltd.
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
21 #include "empathy-sound-manager.h"
23 #include <glib/gi18n-lib.h>
25 #include "empathy-gsettings.h"
26 #include "empathy-presence-manager.h"
27 #include "empathy-utils.h"
29 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
30 #include "empathy-debug.h"
33 EmpathySound sound_id;
34 const char * event_ca_id;
35 const char * event_ca_description;
43 guint replay_timeout_id;
44 EmpathySoundManager *self;
45 } EmpathyRepeatableSound;
47 /* NOTE: these entries MUST be in the same order than EmpathySound enum */
48 static EmpathySoundEntry sound_entries[LAST_EMPATHY_SOUND] = {
49 { EMPATHY_SOUND_MESSAGE_INCOMING, "message-new-instant",
50 N_("Received an instant message"), EMPATHY_PREFS_SOUNDS_INCOMING_MESSAGE } ,
51 { EMPATHY_SOUND_MESSAGE_OUTGOING, "message-sent-instant",
52 N_("Sent an instant message"), EMPATHY_PREFS_SOUNDS_OUTGOING_MESSAGE } ,
53 { EMPATHY_SOUND_CONVERSATION_NEW, "message-new-instant",
54 N_("Incoming chat request"), EMPATHY_PREFS_SOUNDS_NEW_CONVERSATION },
55 { EMPATHY_SOUND_CONTACT_CONNECTED, "service-login",
56 N_("Contact connected"), EMPATHY_PREFS_SOUNDS_CONTACT_LOGIN },
57 { EMPATHY_SOUND_CONTACT_DISCONNECTED, "service-logout",
58 N_("Contact disconnected"), EMPATHY_PREFS_SOUNDS_CONTACT_LOGOUT },
59 { EMPATHY_SOUND_ACCOUNT_CONNECTED, "service-login",
60 N_("Connected to server"), EMPATHY_PREFS_SOUNDS_SERVICE_LOGIN },
61 { EMPATHY_SOUND_ACCOUNT_DISCONNECTED, "service-logout",
62 N_("Disconnected from server"), EMPATHY_PREFS_SOUNDS_SERVICE_LOGOUT },
63 { EMPATHY_SOUND_PHONE_INCOMING, "phone-incoming-call",
64 N_("Incoming voice call"), NULL },
65 { EMPATHY_SOUND_PHONE_OUTGOING, "phone-outgoing-calling",
66 N_("Outgoing voice call"), NULL },
67 { EMPATHY_SOUND_PHONE_HANGUP, "phone-hangup",
68 N_("Voice call ended"), NULL },
71 G_DEFINE_TYPE (EmpathySoundManager, empathy_sound_manager, G_TYPE_OBJECT)
73 struct _EmpathySoundManagerPrivate
75 /* A hash table containing currently repeating sounds. The format is the
77 * Key: An EmpathySound
78 * Value : The EmpathyRepeatableSound associated with that EmpathySound. */
79 GHashTable *repeating_sounds;
80 GSettings *gsettings_sound;
84 empathy_sound_manager_dispose (GObject *object)
86 EmpathySoundManager *self = (EmpathySoundManager *) object;
88 tp_clear_pointer (&self->priv->repeating_sounds, g_hash_table_unref);
89 tp_clear_object (&self->priv->gsettings_sound);
91 G_OBJECT_CLASS (empathy_sound_manager_parent_class)->dispose (object);
95 empathy_sound_manager_class_init (EmpathySoundManagerClass *cls)
97 GObjectClass *object_class = G_OBJECT_CLASS (cls);
99 object_class->dispose = empathy_sound_manager_dispose;
101 g_type_class_add_private (cls, sizeof (EmpathySoundManagerPrivate));
105 empathy_sound_widget_destroyed_cb (GtkWidget *widget,
108 EmpathyRepeatableSound *repeatable_sound = user_data;
110 /* The sound must be stopped... If it is waiting for replay, remove
111 * it from hash table to cancel. Otherwise playing_finished_cb will be
112 * called with an error. */
113 if (repeatable_sound->replay_timeout_id != 0)
115 g_hash_table_remove (repeatable_sound->self->priv->repeating_sounds,
116 GINT_TO_POINTER (repeatable_sound->sound_id));
121 repeating_sounds_item_delete (gpointer data)
123 EmpathyRepeatableSound *repeatable_sound = data;
125 if (repeatable_sound->replay_timeout_id != 0)
126 g_source_remove (repeatable_sound->replay_timeout_id);
128 if (repeatable_sound->widget != NULL)
130 g_signal_handlers_disconnect_by_func (repeatable_sound->widget,
131 empathy_sound_widget_destroyed_cb, repeatable_sound);
134 g_object_unref (repeatable_sound->self);
136 g_slice_free (EmpathyRepeatableSound, repeatable_sound);
140 empathy_sound_manager_init (EmpathySoundManager *self)
142 self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self,
143 EMPATHY_TYPE_SOUND_MANAGER, EmpathySoundManagerPrivate);
145 self->priv->repeating_sounds = g_hash_table_new_full (NULL, NULL,
146 NULL, repeating_sounds_item_delete);
148 self->priv->gsettings_sound = g_settings_new (EMPATHY_PREFS_SOUNDS_SCHEMA);
151 EmpathySoundManager *
152 empathy_sound_manager_dup_singleton (void)
154 static EmpathySoundManager *manager = NULL;
156 if (G_LIKELY (manager != NULL))
157 return g_object_ref (manager);
159 manager = g_object_new (EMPATHY_TYPE_SOUND_MANAGER, NULL);
161 g_object_add_weak_pointer (G_OBJECT (manager), (gpointer *) &manager);
166 empathy_check_available_state (void)
168 TpConnectionPresenceType presence;
169 EmpathyPresenceManager *presence_mgr;
171 presence_mgr = empathy_presence_manager_dup_singleton ();
172 presence = empathy_presence_manager_get_state (presence_mgr);
173 g_object_unref (presence_mgr);
175 if (presence != TP_CONNECTION_PRESENCE_TYPE_AVAILABLE &&
176 presence != TP_CONNECTION_PRESENCE_TYPE_UNSET)
183 empathy_sound_pref_is_enabled (EmpathySoundManager *self,
184 EmpathySound sound_id)
186 EmpathySoundEntry *entry;
188 entry = &(sound_entries[sound_id]);
189 g_return_val_if_fail (entry->sound_id == sound_id, FALSE);
191 if (entry->key == NULL)
194 if (! g_settings_get_boolean (self->priv->gsettings_sound,
195 EMPATHY_PREFS_SOUNDS_ENABLED))
198 if (!empathy_check_available_state ())
200 if (g_settings_get_boolean (self->priv->gsettings_sound,
201 EMPATHY_PREFS_SOUNDS_DISABLED_AWAY))
205 return g_settings_get_boolean (self->priv->gsettings_sound, entry->key);
209 * empathy_sound_manager_stop:
210 * @self: a #EmpathySoundManager
211 * @sound_id: The #EmpathySound to stop playing.
213 * Stop playing a sound. If it has been stated in loop with
214 * empathy_sound_start_playing(), it will also stop replaying.
217 empathy_sound_manager_stop (EmpathySoundManager *self,
218 EmpathySound sound_id)
220 EmpathySoundEntry *entry;
221 EmpathyRepeatableSound *repeatable_sound;
223 g_return_if_fail (sound_id < LAST_EMPATHY_SOUND);
225 entry = &(sound_entries[sound_id]);
226 g_return_if_fail (entry->sound_id == sound_id);
228 repeatable_sound = g_hash_table_lookup (self->priv->repeating_sounds,
229 GINT_TO_POINTER (sound_id));
230 if (repeatable_sound != NULL)
232 /* The sound must be stopped... If it is waiting for replay, remove
233 * it from hash table to cancel. Otherwise we'll cancel the sound
235 if (repeatable_sound->replay_timeout_id != 0)
237 g_hash_table_remove (self->priv->repeating_sounds,
238 GINT_TO_POINTER (sound_id));
243 ca_context_cancel (ca_gtk_context_get (), entry->sound_id);
247 empathy_sound_play_internal (GtkWidget *widget, EmpathySound sound_id,
248 ca_finish_callback_t callback, gpointer user_data)
250 EmpathySoundEntry *entry;
252 ca_proplist *p = NULL;
254 entry = &(sound_entries[sound_id]);
255 g_return_val_if_fail (entry->sound_id == sound_id, FALSE);
257 c = ca_gtk_context_get ();
258 ca_context_cancel (c, entry->sound_id);
260 DEBUG ("Play sound \"%s\" (%s)",
262 entry->event_ca_description);
264 if (ca_proplist_create (&p) < 0)
267 if (ca_proplist_sets (p, CA_PROP_EVENT_ID, entry->event_ca_id) < 0)
270 if (ca_proplist_sets (p, CA_PROP_EVENT_DESCRIPTION,
271 gettext (entry->event_ca_description)) < 0)
276 if (ca_gtk_proplist_set_for_widget (p, widget) < 0)
280 ca_context_play_full (ca_gtk_context_get (), entry->sound_id, p, callback,
283 ca_proplist_destroy (p);
289 ca_proplist_destroy (p);
295 * empathy_sound_manager_play_full:
296 * @self: a #EmpathySoundManager
297 * @widget: The #GtkWidget from which the sound is originating.
298 * @sound_id: The #EmpathySound to play.
299 * @callback: The #ca_finish_callback_t function that will be called when the
300 * sound has stopped playing.
301 * @user_data: user data to pass to the function.
305 * Returns %TRUE if the sound has successfully started playing, otherwise
306 * returning %FALSE and @callback won't be called.
308 * This function returns %FALSE if the sound is already playing in loop using
309 * %empathy_sound_start_playing.
311 * This function returns %FALSE if the sound is disabled in empathy preferences.
313 * Return value: %TRUE if the sound has successfully started playing, %FALSE
317 empathy_sound_manager_play_full (EmpathySoundManager *self,
319 EmpathySound sound_id,
320 ca_finish_callback_t callback,
323 g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), FALSE);
324 g_return_val_if_fail (sound_id < LAST_EMPATHY_SOUND, FALSE);
326 if (!empathy_sound_pref_is_enabled (self, sound_id))
329 /* The sound might already be playing repeatedly. If it's the case, we
330 * immediadely return since there's no need to make it play again */
331 if (g_hash_table_lookup (self->priv->repeating_sounds,
332 GINT_TO_POINTER (sound_id)) != NULL)
335 return empathy_sound_play_internal (widget, sound_id, callback, user_data);
339 * empathy_sound_manager_play:
340 * @self: a #EmpathySoundManager
341 * @widget: The #GtkWidget from which the sound is originating.
342 * @sound_id: The #EmpathySound to play.
344 * Plays a sound. See %empathy_sound_manager_play_full for details.'
346 * Return value: %TRUE if the sound has successfully started playing, %FALSE
350 empathy_sound_manager_play (EmpathySoundManager *self,
352 EmpathySound sound_id)
354 g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), FALSE);
355 g_return_val_if_fail (sound_id < LAST_EMPATHY_SOUND, FALSE);
357 return empathy_sound_manager_play_full (self, widget, sound_id, NULL, NULL);
360 static void playing_finished_cb (ca_context *c, guint id, int error_code,
364 playing_timeout_cb (gpointer data)
366 EmpathyRepeatableSound *repeatable_sound = data;
369 repeatable_sound->replay_timeout_id = 0;
371 playing = empathy_sound_play_internal (repeatable_sound->widget,
372 repeatable_sound->sound_id, playing_finished_cb, data);
376 DEBUG ("Failed to replay sound, stop repeating");
377 g_hash_table_remove (repeatable_sound->self->priv->repeating_sounds,
378 GINT_TO_POINTER (repeatable_sound->sound_id));
385 playing_finished_cb (ca_context *c, guint id, int error_code,
388 EmpathyRepeatableSound *repeatable_sound = user_data;
390 if (error_code != CA_SUCCESS)
392 DEBUG ("Error: %s", ca_strerror (error_code));
393 g_hash_table_remove (repeatable_sound->self->priv->repeating_sounds,
394 GINT_TO_POINTER (repeatable_sound->sound_id));
398 repeatable_sound->replay_timeout_id = g_timeout_add (
399 repeatable_sound->play_interval, playing_timeout_cb, user_data);
403 * empathy_sound_manager_start_playing:
404 * @self: a #EmpathySoundManager
405 * @widget: The #GtkWidget from which the sound is originating.
406 * @sound_id: The #EmpathySound to play.
407 * @timeout_before_replay: The amount of time, in milliseconds, between two
410 * Start playing a sound in loop. To stop the sound, call empathy_call_stop ()
411 * by passing it the same @sound_id. Note that if you start playing a sound
412 * multiple times, you'll have to call %empathy_sound_stop the same number of
415 * Return value: %TRUE if the sound has successfully started playing.
418 empathy_sound_manager_start_playing (EmpathySoundManager *self,
420 EmpathySound sound_id,
421 guint timeout_before_replay)
423 EmpathyRepeatableSound *repeatable_sound;
424 gboolean playing = FALSE;
426 g_return_val_if_fail (widget == NULL || GTK_IS_WIDGET (widget), FALSE);
427 g_return_val_if_fail (sound_id < LAST_EMPATHY_SOUND, FALSE);
429 if (!empathy_sound_pref_is_enabled (self, sound_id))
432 if (g_hash_table_lookup (self->priv->repeating_sounds,
433 GINT_TO_POINTER (sound_id)) != NULL)
435 /* The sound is already playing in loop. No need to continue. */
439 repeatable_sound = g_slice_new0 (EmpathyRepeatableSound);
440 repeatable_sound->widget = widget;
441 repeatable_sound->sound_id = sound_id;
442 repeatable_sound->play_interval = timeout_before_replay;
443 repeatable_sound->replay_timeout_id = 0;
444 repeatable_sound->self = g_object_ref (self);
446 g_hash_table_insert (self->priv->repeating_sounds, GINT_TO_POINTER (sound_id),
451 g_signal_connect (G_OBJECT (widget), "destroy",
452 G_CALLBACK (empathy_sound_widget_destroyed_cb),
456 playing = empathy_sound_play_internal (widget, sound_id, playing_finished_cb,
460 g_hash_table_remove (self->priv->repeating_sounds,
461 GINT_TO_POINTER (sound_id));