diff --git a/src/empathy-call-window.c b/src/empathy-call-window.c
index 4ad1b26..da526b5 100644
--- a/src/empathy-call-window.c
+++ b/src/empathy-call-window.c
@@ -44,6 +44,7 @@
 #include "empathy-call-window.h"
 
 #include "empathy-call-window-fullscreen.h"
+#include "empathy-event-manager.h"
 #include "empathy-sidebar.h"
 
 #define BUTTON_ID "empathy-call-dtmf-button-id"
@@ -60,8 +61,6 @@
 #define REMOTE_CONTACT_AVATAR_DEFAULT_WIDTH EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
 #define REMOTE_CONTACT_AVATAR_DEFAULT_HEIGHT EMPATHY_VIDEO_WIDGET_DEFAULT_HEIGHT
 
-#define CONNECTING_STATUS_TEXT _("Connecting...")
-
 /* If an video input error occurs, the error message will start with "v4l" */
 #define VIDEO_INPUT_ERROR_PREFIX "v4l"
 
@@ -81,6 +80,13 @@ enum {
   PROP_CALL_HANDLER = 1,
 };
 
+enum {
+  CONNECTED,
+  CONNECTING,
+  DISCONNECTED,
+  REDIALING
+};
+
 /* private structure */
 typedef struct _EmpathyCallWindowPriv EmpathyCallWindowPriv;
 
@@ -90,7 +96,7 @@ struct _EmpathyCallWindowPriv
   EmpathyCallHandler *handler;
   EmpathyContact *contact;
 
-  gboolean connected;
+  guint call_state;
 
   GtkUIManager *ui_manager;
   GtkWidget *video_output;
@@ -127,6 +133,9 @@ struct _EmpathyCallWindowPriv
      it needs to be repacked. We keep a reference on it for easier access. */
   GtkWidget *vbox;
 
+  /* Handles the outgoing ringing.  */
+  EmpathyEventManager *event_manager;
+
   gulong video_output_motion_handler_id;
 
   gdouble volume;
@@ -165,10 +174,6 @@ struct _EmpathyCallWindowPriv
   gboolean sidebar_was_visible_before_fs;
   gint original_width_before_fs;
   gint original_height_before_fs;
-
-  /* Used to indicate if we are currently redialing. If we are, as soon as the
-     channel is closed, the call is automatically re-initiated.*/
-  gboolean redialing;
 };
 
 #define GET_PRIV(o) \
@@ -650,6 +655,16 @@ empathy_call_window_setup_video_preview (EmpathyCallWindow *window)
 }
 
 static void
+empathy_call_window_set_state_connecting (EmpathyCallWindow *window)
+{
+  EmpathyCallWindowPriv *priv = GET_PRIV (window);
+
+  empathy_call_window_status_message (window, _("Connecting..."));
+  priv->call_state = CONNECTING;
+  empathy_event_manager_start_outgoing_ring (priv->event_manager);
+}
+
+static void
 empathy_call_window_init (EmpathyCallWindow *self)
 {
   EmpathyCallWindowPriv *priv = GET_PRIV (self);
@@ -661,6 +676,8 @@ empathy_call_window_init (EmpathyCallWindow *self)
   GstBus *bus;
   gchar *filename;
 
+  priv->event_manager = empathy_event_manager_dup_singleton ();
+
   filename = empathy_file_lookup ("empathy-call-window.ui", "src");
   gui = empathy_builder_get_file (filename,
     "call_window_vbox", &top_vbox,
@@ -778,7 +795,7 @@ empathy_call_window_init (EmpathyCallWindow *self)
   g_signal_connect (G_OBJECT (self), "key-press-event",
       G_CALLBACK (empathy_call_window_key_press_cb), self);
 
-  empathy_call_window_status_message (self, CONNECTING_STATUS_TEXT);
+  empathy_call_window_set_state_connecting (self);
 
   priv->timer = g_timer_new ();
 
@@ -1180,7 +1197,11 @@ empathy_call_window_disconnected (EmpathyCallWindow *self)
   EmpathyCallWindowPriv *priv = GET_PRIV (self);
   gboolean could_reset_pipeline = empathy_call_window_reset_pipeline (self);
 
-  priv->connected = FALSE;
+  if (priv->call_state == CONNECTING)
+      empathy_event_manager_stop_outgoing_ring (priv->event_manager);
+
+  if (priv->call_state != REDIALING)
+    priv->call_state = DISCONNECTED;
 
   if (could_reset_pipeline)
     {
@@ -1232,11 +1253,8 @@ empathy_call_window_channel_closed_cb (TfChannel *channel, gpointer user_data)
   EmpathyCallWindow *self = EMPATHY_CALL_WINDOW (user_data);
   EmpathyCallWindowPriv *priv = GET_PRIV (self);
 
-  if (empathy_call_window_disconnected (self) && priv->redialing)
-    {
+  if (empathy_call_window_disconnected (self) && priv->call_state == REDIALING)
       empathy_call_window_restart_call (self);
-      priv->redialing = FALSE;
-    }
 }
 
 /* Called with global lock held */
@@ -1377,11 +1395,12 @@ empathy_call_window_src_added_cb (EmpathyCallHandler *handler,
 
   g_mutex_lock (priv->lock);
 
-  if (priv->connected == FALSE)
+  if (priv->call_state != CONNECTED)
     {
       g_timer_start (priv->timer);
       priv->timer_id = g_idle_add  (empathy_call_window_connected, self);
-      priv->connected = TRUE;
+      priv->call_state = CONNECTED;
+      empathy_event_manager_stop_outgoing_ring (priv->event_manager);
     }
 
   switch (media_type)
@@ -1623,6 +1642,9 @@ empathy_call_window_delete_cb (GtkWidget *widget, GdkEvent*event,
   if (priv->pipeline != NULL)
     gst_element_set_state (priv->pipeline, GST_STATE_NULL);
 
+  if (priv->call_state == CONNECTING)
+      empathy_event_manager_stop_outgoing_ring (priv->event_manager);
+
   return FALSE;
 }
 
@@ -1790,7 +1812,7 @@ empathy_call_window_camera_toggled_cb (GtkToggleToolButton *toggle,
   EmpathyCallWindowPriv *priv = GET_PRIV (window);
   gboolean active;
 
-  if (!priv->connected)
+  if (priv->call_state != CONNECTED)
     return;
 
   active = (gtk_toggle_tool_button_get_active (toggle));
@@ -1809,7 +1831,7 @@ empathy_call_window_send_video_toggled_cb (GtkToggleAction *toggle,
   EmpathyCallWindowPriv *priv = GET_PRIV (window);
   gboolean active;
 
-  if (!priv->connected)
+  if (priv->call_state != CONNECTED)
     return;
 
   active = (gtk_toggle_action_get_active (toggle));
@@ -1922,7 +1944,8 @@ empathy_call_window_restart_call (EmpathyCallWindow *window)
   if (!empathy_call_handler_has_initial_video (priv->handler))
     gtk_widget_hide (priv->self_user_output_frame);
 
-  empathy_call_window_status_message (window, CONNECTING_STATUS_TEXT);
+  empathy_call_window_set_state_connecting (window);
+
   priv->call_started = TRUE;
   empathy_call_handler_start_call (priv->handler);
   empathy_call_window_setup_avatars (window, priv->handler);
@@ -1938,12 +1961,12 @@ empathy_call_window_redial_cb (gpointer object,
 {
   EmpathyCallWindowPriv *priv = GET_PRIV (window);
 
-  if (priv->connected)
-    priv->redialing = TRUE;
+  if (priv->call_state == CONNECTED)
+    priv->call_state = REDIALING;
 
   empathy_call_handler_stop_call (priv->handler);
 
-  if (!priv->connected)
+  if (priv->call_state != CONNECTED)
     empathy_call_window_restart_call (window);
 }
 
diff --git a/src/empathy-event-manager.c b/src/empathy-event-manager.c
index 81d98ef..a0afae2 100644
--- a/src/empathy-event-manager.c
+++ b/src/empathy-event-manager.c
@@ -75,8 +75,11 @@ typedef struct {
   GSList *approvals;
 
   /* voip ringing sound */
-  guint voip_timeout;
-  gint ringing;
+  guint incoming_ringing_timeout;
+  gint incoming_ringing;
+  guint outgoing_ringing_timeout;
+  gint outgoing_ringing;
+
 } EmpathyEventManagerPriv;
 
 typedef struct _EventPriv EventPriv;
@@ -91,6 +94,14 @@ struct _EventPriv {
   gpointer user_data;
 };
 
+typedef struct _RingingInfoPriv RingingInfoPriv;
+
+struct _RingingInfoPriv {
+  gint ringing_sound;
+  guint *ringing_timeout;
+  gint *ringing;
+};
+
 enum {
   EVENT_ADDED,
   EVENT_REMOVED,
@@ -167,14 +178,13 @@ static void event_manager_ringing_finished_cb (ca_context *c, guint id,
 static gboolean
 event_manager_ringing_timeout_cb (gpointer data)
 {
-  EmpathyEventManager *manager = EMPATHY_EVENT_MANAGER (data);
-  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
+  RingingInfoPriv *ringing_info = data;
 
-  priv->voip_timeout = 0;
+  *(ringing_info->ringing_timeout) = 0;
 
   empathy_sound_play_full (empathy_main_window_get (),
-      EMPATHY_SOUND_PHONE_INCOMING, event_manager_ringing_finished_cb,
-      manager);
+      ringing_info->ringing_sound, event_manager_ringing_finished_cb,
+      data);
 
   return FALSE;
 }
@@ -182,12 +192,13 @@ event_manager_ringing_timeout_cb (gpointer data)
 static gboolean
 event_manager_ringing_idle_cb (gpointer data)
 {
-  EmpathyEventManager *manager = EMPATHY_EVENT_MANAGER (data);
-  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
+  RingingInfoPriv *ringing_info = data;
 
-  if (priv->ringing > 0)
-    priv->voip_timeout = g_timeout_add (500, event_manager_ringing_timeout_cb,
-      data);
+  if (*(ringing_info->ringing) > 0)
+    {
+      *(ringing_info->ringing_timeout) = g_timeout_add (500,
+          event_manager_ringing_timeout_cb, data);
+    }
 
   return FALSE;
 }
@@ -203,39 +214,64 @@ event_manager_ringing_finished_cb (ca_context *c, guint id, int error_code,
 }
 
 static void
-event_manager_start_ringing (EmpathyEventManager *manager)
+event_manager_start_ringing (RingingInfoPriv *ringing_info)
 {
-  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
-
-  priv->ringing++;
+  (*(ringing_info->ringing))++;
 
-  if (priv->ringing == 1)
+  if (*(ringing_info->ringing) == 1)
     {
       empathy_sound_play_full (empathy_main_window_get (),
-        EMPATHY_SOUND_PHONE_INCOMING, event_manager_ringing_finished_cb,
-        manager);
+        ringing_info->ringing_sound, event_manager_ringing_finished_cb,
+        ringing_info);
     }
 }
 
 static void
-event_manager_stop_ringing (EmpathyEventManager *manager)
+event_manager_stop_ringing (RingingInfoPriv *ringing_info)
 {
-  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
-
-  priv->ringing--;
+  if (*(ringing_info->ringing) > 0)
+    {
+      (*(ringing_info->ringing))--;
 
-  if (priv->ringing > 0)
-    return;
+      if (*(ringing_info->ringing) > 0)
+        return;
+    }
 
-  empathy_sound_stop (EMPATHY_SOUND_PHONE_INCOMING);
+  empathy_sound_stop (ringing_info->ringing_sound);
 
-  if (priv->voip_timeout != 0)
+  if (*(ringing_info->ringing_timeout) != 0)
     {
-      g_source_remove (priv->voip_timeout);
-      priv->voip_timeout = 0;
+      g_source_remove (*(ringing_info->ringing_timeout));
+      *(ringing_info->ringing_timeout) = 0;
     }
 }
 
+void
+empathy_event_manager_start_outgoing_ring (EmpathyEventManager *manager)
+{
+  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
+  RingingInfoPriv *ringing_info = g_slice_new (RingingInfoPriv);
+
+  ringing_info->ringing_sound = EMPATHY_SOUND_PHONE_OUTGOING;
+  ringing_info->ringing_timeout = &priv->outgoing_ringing_timeout;
+  ringing_info->ringing = &priv->outgoing_ringing;
+
+  event_manager_start_ringing (ringing_info);
+}
+
+void
+empathy_event_manager_stop_outgoing_ring (EmpathyEventManager *manager)
+{
+  EmpathyEventManagerPriv *priv = GET_PRIV (manager);
+  RingingInfoPriv *ringing_info = g_slice_new (RingingInfoPriv);
+
+  ringing_info->ringing_sound = EMPATHY_SOUND_PHONE_OUTGOING;
+  ringing_info->ringing_timeout = &priv->outgoing_ringing_timeout;
+  ringing_info->ringing = &priv->outgoing_ringing;
+
+  event_manager_stop_ringing (ringing_info);
+}
+
 static void
 event_remove (EventPriv *event)
 {
@@ -457,7 +493,12 @@ event_manager_approval_done (EventManagerApproval *approval)
           approval->operation);
       if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
         {
-          event_manager_stop_ringing (approval->manager);
+          RingingInfoPriv *ringing_info = g_slice_new (RingingInfoPriv);
+          ringing_info->ringing_sound = EMPATHY_SOUND_PHONE_INCOMING;
+          ringing_info->ringing_timeout = &priv->incoming_ringing_timeout;
+          ringing_info->ringing = &priv->incoming_ringing;
+
+          event_manager_stop_ringing (ringing_info);
         }
     }
 
@@ -503,6 +544,8 @@ static void
 event_manager_media_channel_got_contact (EventManagerApproval *approval)
 {
   gchar *header;
+  EmpathyEventManagerPriv *priv = GET_PRIV (approval->manager);
+  RingingInfoPriv *ringing_info = g_slice_new (RingingInfoPriv);
 
   header = g_strdup_printf (_("Incoming call from %s"),
     empathy_contact_get_name (approval->contact));
@@ -512,7 +555,12 @@ event_manager_media_channel_got_contact (EventManagerApproval *approval)
     approval, event_channel_process_voip_func, NULL);
 
   g_free (header);
-  event_manager_start_ringing (approval->manager);
+
+  ringing_info->ringing_sound = EMPATHY_SOUND_PHONE_INCOMING;
+  ringing_info->ringing_timeout = &priv->incoming_ringing_timeout;
+  ringing_info->ringing = &priv->incoming_ringing;
+
+  event_manager_start_ringing (ringing_info);
 }
 
 static void
diff --git a/src/empathy-event-manager.h b/src/empathy-event-manager.h
index 42fd0c0..d862a02 100644
--- a/src/empathy-event-manager.h
+++ b/src/empathy-event-manager.h
@@ -29,7 +29,8 @@
 
 G_BEGIN_DECLS
 
-#define EMPATHY_TYPE_EVENT_MANAGER         (empathy_event_manager_get_type ())
+#define EMPATHY_TYPE_EVENT_MANAGER \
+    (empathy_event_manager_get_type ())
 #define EMPATHY_EVENT_MANAGER(o)           (G_TYPE_CHECK_INSTANCE_CAST ((o), EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManager))
 #define EMPATHY_EVENT_MANAGER_CLASS(k)     (G_TYPE_CHECK_CLASS_CAST((k), EMPATHY_TYPE_EVENT_MANAGER, EmpathyEventManagerClass))
 #define EMPATHY_IS_EVENT_MANAGER(o)        (G_TYPE_CHECK_INSTANCE_TYPE ((o), EMPATHY_TYPE_EVENT_MANAGER))
@@ -61,6 +62,8 @@ EmpathyEvent *       empathy_event_manager_get_top_event (EmpathyEventManager *m
 GSList *             empathy_event_manager_get_events    (EmpathyEventManager *manager);
 void                 empathy_event_activate              (EmpathyEvent        *event);
 void                 empathy_event_inhibit_updates       (EmpathyEvent        *event);
+void		     empathy_event_manager_start_outgoing_ring (EmpathyEventManager *manager);
+void		     empathy_event_manager_stop_outgoing_ring  (EmpathyEventManager *manager);
 
 G_END_DECLS
 
