service signals and methods re worked plus removed dbus-menu-manager.c and h and moved what was needed into the sound-service-dbus

9 files changed, 165 insertions, 132 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index f880662..667293f 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -87,8 +87,6 @@ indicator_sound_service_SOURCES = \
 	common-defs.h \
   sound-service.h \
   sound-service.c \
-  dbus-menu-manager.c \
-  dbus-menu-manager.h \
   pulse-manager.h \
   pulse-manager.c \
   sound-service-dbus.h \
diff --git a/src/common-defs.h b/src/common-defs.h
index c7d497a..5b5c418 100644
--- a/src/common-defs.h
+++ b/src/common-defs.h
@@ -24,6 +24,18 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 #define SIGNAL_SINK_MUTE_UPDATE                 "SinkMuteUpdate"
 #define SIGNAL_SINK_AVAILABLE_UPDATE            "SinkAvailableUpdate"
 
+typedef enum {
+  MUTED,
+  ZERO_LEVEL,
+  LOW_LEVEL,
+  MEDIUM_LEVEL,
+  HIGH_LEVEL,
+  BLOCKED,
+  UNAVAILABLE,
+  AVAILABLE
+}SoundState;
+
+
 #define DBUSMENU_PROPERTY_EMPTY                 -1
 
 /* DBUS Custom Items */
@@ -54,4 +66,4 @@ with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 #define DBUSMENU_PLAYLISTS_MENUITEM_TYPE        "x-canonical-sound-menu-player-playlists-type"
 #define DBUSMENU_PLAYLISTS_MENUITEM_TITLE       "x-canonical-sound-menu-player-playlists-title"
-#define DBUSMENU_PLAYLISTS_MENUITEM_PLAYLISTS   "x-canonical-sound-menu-player-playlists-playlists"
\ No newline at end of file
+#define DBUSMENU_PLAYLISTS_MENUITEM_PLAYLISTS   "x-canonical-sound-menu-player-playlists-playlists"
diff --git a/src/dbus-menu-manager.c b/src/dbus-menu-manager.c
index 7de5844..2a2982e 100644
--- a/src/dbus-menu-manager.c
+++ b/src/dbus-menu-manager.c
@@ -157,21 +157,6 @@ void dbus_menu_manager_update_volume(gdouble  volume)
 }
 
 
-/**
-show_sound_settings_dialog:
-Bring up the gnome volume preferences dialog
-**/
-static void show_sound_settings_dialog (DbusmenuMenuitem *mi,
-                                        gpointer user_data)
-{
-  GError * error = NULL;
-  if (!g_spawn_command_line_async("gnome-volume-control --page=applications", &error) &&
-      !g_spawn_command_line_async("xfce4-mixer", &error)) 
-  {
-    g_warning("Unable to show dialog: %s", error->message);
-    g_error_free(error);
-  }
-}
 
 /**
 TODO: what are you doing with this
diff --git a/src/metadata-widget.c b/src/metadata-widget.c
index 09365d5..d37c39f 100644
--- a/src/metadata-widget.c
+++ b/src/metadata-widget.c
@@ -397,7 +397,6 @@ metadata_widget_button_press_event (GtkWidget *menuitem,
   return FALSE;
 }
 
-// TODO: Manage empty/mangled music details <unknown artist> etc.
 static void 
 metadata_widget_property_update(DbusmenuMenuitem* item, gchar* property, 
                                        GVariant* value, gpointer userdata)
diff --git a/src/mute-menu-item.c b/src/mute-menu-item.c
index 9e79dd1..2c5af6d 100644
--- a/src/mute-menu-item.c
+++ b/src/mute-menu-item.c
@@ -93,7 +93,6 @@ handle_event (DbusmenuMenuitem * mi,
   }
   
   gboolean mute_input = g_variant_get_boolean(input);
-  // TODO: use the pulse wrapper directly
   toggle_global_mute (mute_input);
   g_variant_unref (input); 
 }
diff --git a/src/pulse-manager.c b/src/pulse-manager.c
index 15a449b..21b78b2 100644
--- a/src/pulse-manager.c
+++ b/src/pulse-manager.c
@@ -75,7 +75,7 @@ void establish_pulse_activities(SoundServiceDbus *service)
 
   // Establish event callback registration
   pa_context_set_state_callback (pulse_context, context_state_callback, NULL);
-  dbus_menu_manager_update_pa_state (FALSE, FALSE, FALSE, 0);
+  sound_service_dbus_update_pa_state (dbus_service, FALSE, FALSE, 0);
   pa_context_connect (pulse_context, NULL, PA_CONTEXT_NOFAIL, NULL);
 }
 
@@ -199,7 +199,7 @@ static void check_sink_input_while_muted_event(gint sink_index)
   /*    g_debug("SINKINPUTWHILEMUTED SIGNAL EVENT TO BE SENT FROM PA MANAGER - check trace for value");*/
 
   if (default_sink_is_muted(sink_index) == TRUE) {
-    sound_service_dbus_sink_input_while_muted (dbus_service, TRUE);
+    sound_service_dbus_sink_input_while_muted(dbus_service, TRUE);
   } else {
     sound_service_dbus_sink_input_while_muted(dbus_service, FALSE);
   }
@@ -223,10 +223,8 @@ static void mute_each_sink(gpointer key, gpointer value, gpointer user_data)
   if (GPOINTER_TO_INT(user_data) == 1) {
     sound_service_dbus_update_sink_mute(dbus_service, TRUE);
   } else {
-    dbus_menu_manager_update_volume(get_default_sink_volume());
+    sound_service_dbus_update_volume(dbus_service, get_default_sink_volume());
   }
-
-  /*    g_debug("in the pulse manager: mute each sink %i", GPOINTER_TO_INT(user_data));*/
 }
 
 void toggle_global_mute(gboolean mute_value)
@@ -309,14 +307,17 @@ static void pulse_sink_info_callback(pa_context *c, const pa_sink_info *sink, in
 
     gboolean device_available = determine_sink_availability();
     if (device_available == TRUE) {
-      dbus_menu_manager_update_pa_state(TRUE,
-                                        device_available,
-                                        default_sink_is_muted(),
-                                        get_default_sink_volume());
+      sound_service_dbus_update_pa_state( dbus_service,
+                                         device_available,
+                                         default_sink_is_muted(),
+                                         get_default_sink_volume() );
     } else {
       //Update the indicator to show PA either is not ready or has no available sink
       g_warning("Cannot find a suitable default sink ...");
-      dbus_menu_manager_update_pa_state(FALSE, device_available, default_sink_is_muted(), get_default_sink_volume());
+      sound_service_dbus_update_pa_state( dbus_service,
+                                         device_available,
+                                         default_sink_is_muted(),
+                                         get_default_sink_volume() );
     }
   } else {
     /*        g_debug("About to add an item to our hash");*/
@@ -346,7 +347,10 @@ static void pulse_default_sink_info_callback(pa_context *c, const pa_sink_info *
     if (position < 0) {
       pa_operation_unref(pa_context_get_sink_info_list(c, pulse_sink_info_callback, NULL));
     } else {
-      dbus_menu_manager_update_pa_state(TRUE, determine_sink_availability(), default_sink_is_muted(), get_default_sink_volume());
+      sound_service_dbus_update_pa_state(dbus_service,
+                                        determine_sink_availability(),
+                                        default_sink_is_muted(),
+                                        get_default_sink_volume());
     }
   }
 }
@@ -408,18 +412,17 @@ static void update_sink_info(pa_context *c, const pa_sink_info *info, int eol, v
         pa_volume_t vol = pa_cvolume_max(&s->volume);
         gdouble volume_percent = ((gdouble) vol * 100) / PA_VOLUME_NORM;
         /*                g_debug("Updating volume from PA manager with volume = %f", volume_percent);*/
-        dbus_menu_manager_update_volume(volume_percent);
+        sound_service_dbus_update_volume(dbus_service, volume_percent);
       }
 
       if (mute_changed == TRUE) {
         /*                g_debug("Updating Mute from PA manager with mute = %i", s->mute);*/
         sound_service_dbus_update_sink_mute(dbus_service, s->mute);
-        dbus_menu_manager_update_mute(s->mute);
         if (s->mute == FALSE) {
           pa_volume_t vol = pa_cvolume_max(&s->volume);
           gdouble volume_percent = ((gdouble) vol * 100) / PA_VOLUME_NORM;
-          /*                    g_debug("Updating volume from PA manager with volume = %f", volume_percent);*/
-          dbus_menu_manager_update_volume(volume_percent);
+          /*                    g_debug("Updating volume from PA manager with volume = %f", volume_percent);*/                 
+          sound_service_dbus_update_volume(dbus_service, volume_percent);
         }
       }
     }
@@ -434,7 +437,7 @@ static void update_sink_info(pa_context *c, const pa_sink_info *info, int eol, v
     value->base_volume = info->base_volume;
     g_hash_table_insert(sink_hash, GINT_TO_POINTER(value->index), value);
     /*        g_debug("pulse-manager:update_sink_info -> After adding a new sink to our hash");*/
-    sound_service_dbus_update_sink_availability(dbus_service, TRUE);
+    sound_service_dbus_update_sound_state(dbus_service, TRUE);
   }
 }
 
@@ -463,7 +466,7 @@ static void pulse_server_info_callback(pa_context *c,
   pa_operation *operation;
   if (info == NULL) {
     g_warning("No server - get the hell out of here");
-    dbus_menu_manager_update_pa_state(FALSE, FALSE, TRUE, 0);
+    sound_service_dbus_update_pa_state(dbus_service, FALSE, TRUE, 0);
     pa_server_available = FALSE;
     return;
   }
@@ -548,10 +551,10 @@ static void context_state_callback(pa_context *c, void *userdata)
   case PA_CONTEXT_FAILED:
     g_warning("PA_CONTEXT_FAILED - Is PulseAudio Daemon running ?");
     pa_server_available = FALSE;
-    dbus_menu_manager_update_pa_state(TRUE,
-                                      pa_server_available,
-                                      default_sink_is_muted(),
-                                      get_default_sink_volume());
+    sound_service_dbus_update_pa_state( dbus_service,
+                                        pa_server_available,
+                                        default_sink_is_muted(),
+                                        get_default_sink_volume() );
       
     if (reconnect_idle_id == 0){
       reconnect_idle_id = g_timeout_add_seconds (RECONNECT_DELAY,
diff --git a/src/sound-service-dbus.c b/src/sound-service-dbus.c
index f14e7c6..c0e02ab 100644
--- a/src/sound-service-dbus.c
+++ b/src/sound-service-dbus.c
@@ -3,7 +3,6 @@
  *
  * Authors:
  *     Conor Curran <conor.curran@canonical.com>
- *     Ted Gould <ted.gould@canonical.com>
  *
  * This program is free software: you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 3, as published
@@ -23,6 +22,8 @@
 #endif
 
 #include <gio/gio.h>
+#include <unistd.h>
+#include <glib/gi18n.h>
 #include <libindicator/indicator-service.h>
 #include <libdbusmenu-glib/server.h>
 #include <libdbusmenu-glib/client.h>
@@ -36,7 +37,6 @@
 #include "slider-menu-item.h"
 #include "mute-menu-item.h"
 
-
 // DBUS methods
 static void bus_method_call (GDBusConnection * connection,
                              const gchar * sender,
@@ -58,16 +58,15 @@ typedef struct _SoundServiceDbusPrivate SoundServiceDbusPrivate;
 
 struct _SoundServiceDbusPrivate {
         GDBusConnection*    connection;
-        gboolean            mute;
-        gboolean            sink_availability;
         DbusmenuMenuitem*   root_menuitem;
         SliderMenuItem*     volume_slider_menuitem;
         MuteMenuItem*       mute_menuitem;
+        SoundState          current_sound_state;
 };
 
 static GDBusNodeInfo *            node_info = NULL;
 static GDBusInterfaceInfo *       interface_info = NULL;
-
+static gboolean                   b_startup = TRUE;
 #define SOUND_SERVICE_DBUS_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), SOUND_SERVICE_DBUS_TYPE, SoundServiceDbusPrivate))
 
 static void sound_service_dbus_class_init (SoundServiceDbusClass *klass);
@@ -75,6 +74,15 @@ static void sound_service_dbus_init       (SoundServiceDbus *self);
 static void sound_service_dbus_dispose    (GObject *object);
 static void sound_service_dbus_finalize   (GObject *object);
 
+static void sound_service_dbus_build_sound_menu ( SoundServiceDbus* root,
+                                                  gboolean mute_update,
+                                                  gboolean availability,
+                                                  gdouble volume );
+static void show_sound_settings_dialog (DbusmenuMenuitem *mi,
+                                        gpointer user_data);
+static void sound_service_dbus_set_state_from_volume (SoundServiceDbus* self);
+
+
 G_DEFINE_TYPE (SoundServiceDbus, sound_service_dbus, G_TYPE_OBJECT);
 
 static void
@@ -118,8 +126,7 @@ sound_service_dbus_init (SoundServiceDbus *self)
 
   priv->connection = NULL;
 
-  priv->mute = FALSE;
-  priv->sink_availability = FALSE;
+  priv->current_sound_state = UNAVAILABLE;
 
   /* Fetch the session bus */
   priv->connection = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error);
@@ -144,7 +151,7 @@ sound_service_dbus_init (SoundServiceDbus *self)
 	}
 }
 
-DbusmenuMenuitem* sound_service_dbus_construct_menu (SoundServiceDbus* self)
+DbusmenuMenuitem* sound_service_dbus_create_root_item (SoundServiceDbus* self)
 {
   SoundServiceDbusPrivate * priv = SOUND_SERVICE_DBUS_GET_PRIVATE(self);
   priv->root_menuitem = dbusmenu_menuitem_new();
@@ -155,6 +162,89 @@ DbusmenuMenuitem* sound_service_dbus_construct_menu (SoundServiceDbus* self)
   return priv->root_menuitem;
 }
 
+static void sound_service_dbus_build_sound_menu ( SoundServiceDbus* self,
+                                                  gboolean mute_update,
+                                                  gboolean availability,
+                                                  gdouble volume )
+{
+  SoundServiceDbusPrivate * priv = SOUND_SERVICE_DBUS_GET_PRIVATE(self);
+
+  // Mute button
+  priv->mute_menuitem = mute_menu_item_new ( mute_update, availability);
+  dbusmenu_menuitem_child_append (priv->root_menuitem, DBUSMENU_MENUITEM(priv->mute_menuitem));
+
+  // Slider
+  priv->volume_slider_menuitem = slider_menu_item_new ( availability, volume );
+  dbusmenu_menuitem_child_append (priv->root_menuitem, DBUSMENU_MENUITEM ( priv->volume_slider_menuitem ));
+
+  // Separator
+  DbusmenuMenuitem* separator = dbusmenu_menuitem_new();
+  dbusmenu_menuitem_property_set( separator,
+                                  DBUSMENU_MENUITEM_PROP_TYPE,
+                                  DBUSMENU_CLIENT_TYPES_SEPARATOR);
+  dbusmenu_menuitem_child_append(priv->root_menuitem, separator);
+
+  // Sound preferences dialog
+  DbusmenuMenuitem* settings_mi = dbusmenu_menuitem_new();
+  dbusmenu_menuitem_property_set( settings_mi,
+                                  DBUSMENU_MENUITEM_PROP_LABEL,
+                                  _("Sound Preferences..."));
+  dbusmenu_menuitem_child_append(priv->root_menuitem, settings_mi);
+  g_signal_connect(G_OBJECT(settings_mi), DBUSMENU_MENUITEM_SIGNAL_ITEM_ACTIVATED,
+                   G_CALLBACK(show_sound_settings_dialog), NULL);
+}
+
+/**
+show_sound_settings_dialog:
+Bring up the gnome volume preferences dialog
+**/
+static void show_sound_settings_dialog (DbusmenuMenuitem *mi,
+                                        gpointer user_data)
+{
+  GError * error = NULL;
+  if (!g_spawn_command_line_async("gnome-volume-control --page=applications", &error) &&
+      !g_spawn_command_line_async("xfce4-mixer", &error)) 
+  {
+    g_warning("Unable to show dialog: %s", error->message);
+    g_error_free(error);
+  }
+}
+
+void sound_service_dbus_update_pa_state ( SoundServiceDbus* self,
+                                          gboolean availability,
+                                          gboolean mute_update,
+                                          gdouble volume )
+{
+  g_debug("update pa state with availability of %i, mute value of %i and a volume percent is %f", availability, mute_update, volume);
+  SoundServiceDbusPrivate * priv = SOUND_SERVICE_DBUS_GET_PRIVATE(self);
+
+  if (b_startup == TRUE) {
+    sound_service_dbus_build_sound_menu ( self,
+                                          mute_update,
+                                          availability,
+                                          volume );
+    b_startup = FALSE;
+    return;
+  }
+
+  mute_menu_item_update ( priv->mute_menuitem,
+                          mute_update );
+  slider_menu_item_update ( priv->volume_slider_menuitem,
+                            volume );
+
+  mute_menu_item_enable ( priv->mute_menuitem, availability);
+  slider_menu_item_enable ( priv->volume_slider_menuitem, 
+                            availability );
+
+  // Emit the signals after the menus are setup/torn down
+  // preserve ordering !
+  /*sound_service_dbus_update_sink_availability(dbus_interface, sink_available);
+  dbus_menu_manager_update_volume(percent);
+  sound_service_dbus_update_sink_mute(dbus_interface, sink_muted);
+  dbus_menu_manager_update_mute_ui(b_all_muted);*/
+}
+
+
 static void
 sound_service_dbus_dispose (GObject *object)
 {
@@ -183,97 +273,41 @@ bus_method_call (GDBusConnection * connection,
 { 
   SoundServiceDbus* service = SOUND_SERVICE_DBUS(user_data); 
   g_return_if_fail ( IS_SOUND_SERVICE_DBUS(service) );
-  GVariant * retval = NULL;
-  SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (service);
-  
-  if (g_strcmp0(method, "GetSinkMute") == 0) {
-    g_debug("Get sink mute - sound service dbus!,about to send over mute_value of  %i", priv->mute);
-    retval =  g_variant_new ( "(b)", priv->mute);    
-  } 
-  else if (g_strcmp0(method, "GetSinkAvailability") == 0) {
-    g_debug("Get sink availability - sound service dbus!, about to send over availability_value of  %i", priv->sink_availability);
-    retval =  g_variant_new ( "(b)", priv->sink_availability);
-  }
-  else {
-    g_warning("Calling method '%s' on the sound service but it's unknown", method); 
-  }
-  g_dbus_method_invocation_return_value(invocation, retval);
+  //GVariant * retval = NULL;
+  //SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (service);
+  // TODO we will need to implement the black_list and state fetch.  
 }
 
-
-/**
-SIGNALS
-Utility methods to emit signals from the service into the ether.
-**/
-void sound_service_dbus_sink_input_while_muted(SoundServiceDbus* obj,
-                                               gboolean block_value)
+// TODO until the pulsemanager has been refactored keep in place the consistent api 
+// for it to talk to the UI.
+void sound_service_dbus_update_volume(SoundServiceDbus* obj,
+                                      gdouble  volume)
 {
-  g_debug("Emitting signal: SINK_INPUT_WHILE_MUTED, with  block_value: %i",
-           block_value);
   SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (obj);
-  GVariant* v_output = g_variant_new("(b)", block_value);
-
-  GError * error = NULL;
-
-  g_dbus_connection_emit_signal( priv->connection,
-                                 NULL,
-                                 INDICATOR_SOUND_MENU_DBUS_OBJECT_PATH,
-                                 INDICATOR_SOUND_DBUS_INTERFACE,
-                                 INDICATOR_SOUND_SIGNAL_SINK_INPUT_WHILE_MUTED,
-                                  v_output,
-                                  &error );
-  if (error != NULL) {
-    g_error("Unable to emit signal 'sinkinputwhilemuted' because : %s", error->message);
-    g_error_free(error);
-    return;
-  }
+  slider_menu_item_update (priv->volume_slider_menuitem, volume);
 }
 
 void sound_service_dbus_update_sink_mute(SoundServiceDbus* obj,
-                                         gboolean sink_mute)
+                                         gboolean mute_update)
 {
-  g_debug("Emitting signal: SINK_MUTE_UPDATE, with sink mute %i", sink_mute);
   SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (obj);
-  priv->mute = sink_mute;
+  mute_menu_item_update (priv->mute_menuitem, mute_update);
+}
+// TODO: this will be a bit messy until the pa_manager is sorted.
+void sound_service_dbus_update_sound_state (SoundServiceDbus* self,
+                                            SoundState new_state)
+{
+  SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (self);
 
-  GVariant* v_output = g_variant_new("(b)", sink_mute);
-  GError * error = NULL;
-  g_dbus_connection_emit_signal( priv->connection,
-                                 NULL,
-                                 INDICATOR_SOUND_SERVICE_DBUS_OBJECT_PATH,
-                                 INDICATOR_SOUND_DBUS_INTERFACE,
-                                 INDICATOR_SOUND_SIGNAL_SINK_MUTE_UPDATE,
-                                  v_output,
-                                  &error );
-  if (error != NULL) {
-    g_error("Unable to emit signal 'sinkmuteupdate' because : %s", error->message);
-    g_error_free(error);
-    return;
+  if (new_state == AVAILABLE &&
+      dbusmenu_menuitem_property_get_bool (priv->mute_menuitem, DBUSMENU_MUTE_MENUITEM_VALUE) == FALSE){
+      sound_service_dbus_set_state_from_volume (self);
   }
 }
 
-void sound_service_dbus_update_sink_availability(SoundServiceDbus* obj,
-                                                 gboolean sink_availability)
+static void sound_service_dbus_set_state_from_volume (SoundServiceDbus* self)
 {
-  g_debug("Emitting signal: SinkAvailableUpdate, with  %i", sink_availability);
-  SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (obj);
-  priv->sink_availability = sink_availability;
-  
-  GVariant* v_output = g_variant_new("(b)", priv->sink_availability);
-  GError * error = NULL;
-  
-  g_dbus_connection_emit_signal( priv->connection,
-                                 NULL,
-                                 INDICATOR_SOUND_SERVICE_DBUS_OBJECT_PATH,
-                                 INDICATOR_SOUND_DBUS_INTERFACE,
-                                 INDICATOR_SOUND_SIGNAL_SINK_AVAILABLE_UPDATE,
-                                  v_output,
-                                  &error );
-  if (error != NULL) {
-    g_error("Unable to emit signal 'SinkAvailableUpdate' because : %s", error->message);
-    g_error_free(error);
-    return;
-  }
+  //SoundServiceDbusPrivate *priv = SOUND_SERVICE_DBUS_GET_PRIVATE (self);
 }
 
 
diff --git a/src/sound-service-dbus.h b/src/sound-service-dbus.h
index b0e6dd3..127ede2 100644
--- a/src/sound-service-dbus.h
+++ b/src/sound-service-dbus.h
@@ -52,11 +52,14 @@ struct _SoundServiceDbusClass {
 
 GType sound_service_dbus_get_type  (void) G_GNUC_CONST;
 
-// Utility methods to get the SIGNAL messages across into the sound-service-dbus
-void sound_service_dbus_sink_input_while_muted (SoundServiceDbus* obj, gboolean block_value);
-void sound_service_dbus_update_sink_mute(SoundServiceDbus* obj, gboolean sink_mute);
-void sound_service_dbus_update_sink_availability(SoundServiceDbus* obj, gboolean sink_availibity);
-DbusmenuMenuitem* sound_service_dbus_construct_menu (SoundServiceDbus* self);
+DbusmenuMenuitem* sound_service_dbus_create_root_item (SoundServiceDbus* self);
+void sound_service_dbus_update_sound_state (SoundServiceDbus* self, SoundState new_state);
+void sound_service_dbus_update_sink_mute(SoundServiceDbus* self, gboolean sink_mute);
+void sound_service_dbus_update_volume(SoundServiceDbus* self, gdouble  volume);
+void sound_service_dbus_update_pa_state ( SoundServiceDbus* root,
+                                          gboolean availability,
+                                          gboolean mute_update,
+                                          gdouble volume );
 
 G_END_DECLS
 
diff --git a/src/sound-service.c b/src/sound-service.c
index 73b03b6..e72a917 100644
--- a/src/sound-service.c
+++ b/src/sound-service.c
@@ -66,7 +66,7 @@ main (int argc, char ** argv)
 
   SoundServiceDbus* sound_service = g_object_new(SOUND_SERVICE_DBUS_TYPE, NULL);
   
-  DbusmenuMenuitem* root_menuitem = sound_service_dbus_construct_menu(sound_service);
+  DbusmenuMenuitem* root_menuitem = sound_service_dbus_create_root_item(sound_service);
   MusicPlayerBridge* server = music_player_bridge_new();
   music_player_bridge_set_root_menu_item(server, root_menuitem);