libempathy-gtk/empathy-call-utils.c

   1 /*
   2  * Copyright (C) 2011 Collabora Ltd.
   3  *
   4  * The code contained in this file is free software; you can redistribute
   5  * it and/or modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either version
   7  * 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This file is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this code; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17  *
  18  * Authors: Emilio Pozuelo Monfort <emilio.pozuelo@collabora.co.uk>
  19  */
  20
  21 #include "config.h"
  22 #include "empathy-call-utils.h"
  23
  24 #include <glib/gi18n-lib.h>
  25 #include <gtk/gtk.h>
  26
  27 #include "empathy-request-util.h"
  28
  29 #define DEBUG_FLAG EMPATHY_DEBUG_OTHER
  30 #include "empathy-debug.h"
  31
  32 static const gchar *
  33 get_error_display_message (GError *error)
  34 {
  35   if (error->domain != TP_ERROR)
  36     return _("There was an error starting the call");
  37
  38   switch (error->code)
  39     {
  40       case TP_ERROR_NETWORK_ERROR:
  41         return _("Network error");
  42       case TP_ERROR_NOT_CAPABLE:
  43         return _("The specified contact doesn't support calls");
  44       case TP_ERROR_OFFLINE:
  45         return _("The specified contact is offline");
  46       case TP_ERROR_INVALID_HANDLE:
  47         return _("The specified contact is not valid");
  48       case TP_ERROR_EMERGENCY_CALLS_NOT_SUPPORTED:
  49         return _("Emergency calls are not supported on this protocol");
  50       case TP_ERROR_INSUFFICIENT_BALANCE:
  51         return _("You don't have enough credit in order to place this call");
  52     }
  53
  54   return _("There was an error starting the call");
  55 }
  56
  57 static void
  58 show_call_error (GError *error)
  59 {
  60   GtkWidget *dialog;
  61
  62   dialog = gtk_message_dialog_new (NULL, 0,
  63       GTK_MESSAGE_ERROR, GTK_BUTTONS_CLOSE,
  64       "%s", get_error_display_message (error));
  65
  66   g_signal_connect_swapped (dialog, "response",
  67       G_CALLBACK (gtk_widget_destroy),
  68       dialog);
  69
  70   gtk_widget_show (dialog);
  71 }
  72
  73 GHashTable *
  74 empathy_call_create_call_request (const gchar *contact,
  75     gboolean initial_audio,
  76     gboolean initial_video)
  77 {
  78   return tp_asv_new (
  79     TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
  80       TP_IFACE_CHANNEL_TYPE_CALL,
  81     TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT,
  82       TP_HANDLE_TYPE_CONTACT,
  83     TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING,
  84       contact,
  85     TP_PROP_CHANNEL_TYPE_CALL_INITIAL_AUDIO, G_TYPE_BOOLEAN,
  86       initial_audio,
  87     TP_PROP_CHANNEL_TYPE_CALL_INITIAL_VIDEO, G_TYPE_BOOLEAN,
  88       initial_video,
  89     NULL);
  90 }
  91
  92 static void
  93 create_call_channel_cb (GObject *source,
  94     GAsyncResult *result,
  95     gpointer user_data)
  96 {
  97   GError *error = NULL;
  98
  99   if (tp_account_channel_request_create_channel_finish (
 100       TP_ACCOUNT_CHANNEL_REQUEST (source), result, &error))
 101     return;
 102
 103   DEBUG ("Failed to create Call channel: %s", error->message);
 104
 105   show_call_error (error);
 106 }
 107
 108 /* Try to request a Call channel and fallback to StreamedMedia if that fails */
 109 static void
 110 call_new_with_streams (const gchar *contact,
 111     TpAccount *account,
 112     gboolean initial_audio,
 113     gboolean initial_video,
 114     gint64 timestamp)
 115 {
 116   GHashTable *call_request;
 117   TpAccountChannelRequest *call_req;
 118
 119   /* Call */
 120   call_request = empathy_call_create_call_request (contact,
 121       initial_audio,
 122       initial_video);
 123
 124   call_req = tp_account_channel_request_new (account, call_request, timestamp);
 125
 126   g_hash_table_unref (call_request);
 127
 128   tp_account_channel_request_create_channel_async (call_req,
 129       EMPATHY_CALL_BUS_NAME, NULL, create_call_channel_cb, NULL);
 130
 131   g_object_unref (call_req);
 132 }
 133
 134 void
 135 empathy_call_new_with_streams (const gchar *contact,
 136     TpAccount *account,
 137     gboolean initial_audio,
 138     gboolean initial_video,
 139     gint64 timestamp)
 140 {
 141   call_new_with_streams (contact, account, initial_audio, initial_video,
 142       timestamp);
 143 }
 144
 145 /* Copied from telepathy-yell call-channel.c */
 146 void
 147 empathy_call_channel_send_video (TpCallChannel *self,
 148     gboolean send)
 149 {
 150   GPtrArray *contents;
 151   gboolean found = FALSE;
 152   guint i;
 153
 154   g_return_if_fail (TP_IS_CALL_CHANNEL (self));
 155
 156   /* Loop over all the contents, if some of them a video set all their
 157    * streams to sending, otherwise request a video channel in case we want to
 158    * sent */
 159   contents = tp_call_channel_get_contents (self);
 160   for (i = 0 ; i < contents->len ; i++)
 161     {
 162       TpCallContent *content = g_ptr_array_index (contents, i);
 163
 164       if (tp_call_content_get_media_type (content) ==
 165               TP_MEDIA_STREAM_TYPE_VIDEO)
 166         {
 167           GPtrArray *streams;
 168           guint j;
 169
 170           found = TRUE;
 171           streams = tp_call_content_get_streams (content);
 172           for (j = 0; j < streams->len; j++)
 173             {
 174               TpCallStream *stream = g_ptr_array_index (streams, j);
 175
 176               tp_call_stream_set_sending_async (stream, send, NULL, NULL);
 177             }
 178         }
 179     }
 180
 181   if (send && !found)
 182     {
 183       tp_call_channel_add_content_async (self, "video",
 184           TP_MEDIA_STREAM_TYPE_VIDEO, TP_MEDIA_STREAM_DIRECTION_BIDIRECTIONAL,
 185           NULL, NULL);
 186     }
 187 }
 188
 189 /* Copied from telepathy-yell call-channel.c */
 190 TpSendingState
 191 empathy_call_channel_get_video_state (TpCallChannel *self)
 192 {
 193   TpSendingState result = TP_SENDING_STATE_NONE;
 194   GPtrArray *contents;
 195   guint i;
 196
 197   g_return_val_if_fail (TP_IS_CALL_CHANNEL (self), TP_SENDING_STATE_NONE);
 198
 199   contents = tp_call_channel_get_contents (self);
 200   for (i = 0 ; i < contents->len ; i++)
 201     {
 202       TpCallContent *content = g_ptr_array_index (contents, i);
 203
 204       if (tp_call_content_get_media_type (content) ==
 205               TP_MEDIA_STREAM_TYPE_VIDEO)
 206         {
 207           GPtrArray *streams;
 208           guint j;
 209
 210           streams = tp_call_content_get_streams (content);
 211           for (j = 0; j < streams->len; j++)
 212             {
 213               TpCallStream *stream = g_ptr_array_index (streams, j);
 214               TpSendingState state;
 215
 216               state = tp_call_stream_get_local_sending_state (stream);
 217               if (state != TP_SENDING_STATE_PENDING_STOP_SENDING &&
 218                   state > result)
 219                 result = state;
 220             }
 221         }
 222     }
 223
 224   return result;
 225 }