src/purple/purple-media.c

   1 /**
   2  * @file purple-media.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include "glib.h"
  24
  25 #include "sipe-core.h"
  26
  27 //TODO: these two includes should be eliminated
  28 #include "../core/sipe.h"
  29 #include "../core/sipe-core-private.h"
  30
  31 #include "sipe-common.h"
  32 #include "sipe-media.h"
  33 #include "mediamanager.h"
  34 #include <nice/agent.h>
  35
  36 #include "request.h"
  37 #include "core-depurple.h"
  38
  39 typedef struct _sipe_purple_media {
  40         PurpleMedia *m;
  41         // Prevent infinite recursion in on_stream_info_cb
  42         gboolean        in_recursion;
  43 } sipe_purple_media;
  44
  45 gboolean sipe_initiate_media(PurpleAccount *account, const char *who,
  46                       SIPE_UNUSED_PARAMETER PurpleMediaSessionType type)
  47 {
  48         struct sipe_core_private *sipe_private = PURPLE_ACCOUNT_TO_SIPE_CORE_PRIVATE;
  49         sipe_media_initiate_call(sipe_private, who);
  50         return TRUE;
  51 }
  52
  53 PurpleMediaCaps sipe_get_media_caps(SIPE_UNUSED_PARAMETER PurpleAccount *account,
  54                                                                         SIPE_UNUSED_PARAMETER const char *who)
  55 {
  56         return PURPLE_MEDIA_CAPS_AUDIO;
  57 }
  58
  59 static PurpleMediaSessionType sipe_media_to_purple(SipeMediaType type);
  60 static PurpleMediaCandidateType sipe_candidate_type_to_purple(SipeCandidateType type);
  61 static PurpleMediaNetworkProtocol sipe_network_protocol_to_purple(SipeNetworkProtocol proto);
  62 static SipeNetworkProtocol purple_network_protocol_to_sipe(PurpleMediaNetworkProtocol proto);
  63
  64 static void
  65 on_candidates_prepared_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
  66                                                   SIPE_UNUSED_PARAMETER gchar *sessionid,
  67                                                   SIPE_UNUSED_PARAMETER gchar *participant,
  68                                                   sipe_media_call *call)
  69 {
  70         if (call->candidates_prepared_cb)
  71                 call->candidates_prepared_cb(call);
  72 }
  73
  74 static void
  75 on_state_changed_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
  76                                         PurpleMediaState state,
  77                                         gchar *sessionid,
  78                                         gchar *participant,
  79                                         sipe_media_call *call)
  80 {
  81         printf("sipe_media_state_changed_cb: %d %s %s\n", state, sessionid, participant);
  82         if (state == PURPLE_MEDIA_STATE_CONNECTED && call->media_connected_cb)
  83                 call->media_connected_cb(call);
  84 }
  85
  86 static void
  87 on_stream_info_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media,
  88                                   PurpleMediaInfoType type,
  89                                   SIPE_UNUSED_PARAMETER gchar *sessionid,
  90                                   SIPE_UNUSED_PARAMETER gchar *participant,
  91                                   gboolean local, sipe_media_call *call)
  92 {
  93         sipe_purple_media *m = call->media;
  94         if (m->in_recursion) {
  95                 m->in_recursion = FALSE;
  96                 return;
  97         }
  98
  99         if (type == PURPLE_MEDIA_INFO_ACCEPT && call->call_accept_cb)
 100                 call->call_accept_cb(call, local);
 101         else if (type == PURPLE_MEDIA_INFO_REJECT && call->call_reject_cb)
 102                 call->call_reject_cb(call, local);
 103         else if (type == PURPLE_MEDIA_INFO_HOLD && call->call_hold_cb) {
 104                 call->call_hold_cb(call, local, TRUE);
 105                 if (!local) {
 106                         m->in_recursion = TRUE;
 107                         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_HOLD, NULL, NULL, TRUE);
 108                 }
 109         } else if (type == PURPLE_MEDIA_INFO_UNHOLD && call->call_hold_cb) {
 110                 call->call_hold_cb(call, local, FALSE);
 111                 m->in_recursion = TRUE;
 112                 if (!call->local_on_hold && !call->remote_on_hold) {
 113                         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_UNHOLD, NULL, NULL, TRUE);
 114                 } else {
 115                         /* Remote side is still on hold, keep local also held to prevent sending
 116                          * unnecessary media over network */
 117                         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_HOLD, NULL, NULL, TRUE);
 118                 }
 119         } else if (type == PURPLE_MEDIA_INFO_HANGUP && call->call_hangup_cb)
 120                 call->call_hangup_cb(call, local);
 121 }
 122
 123 sipe_media *
 124 sipe_backend_media_new(sipe_media_call *call, const gchar* participant, gboolean initiator)
 125 {
 126         sipe_purple_media       *m = g_new0(sipe_purple_media, 1);
 127         struct sipe_core_private *sipe_private = call->sipe_private;
 128         struct sipe_account_data *sip = SIPE_ACCOUNT_DATA_PRIVATE;
 129         PurpleAccount           *acc = sip->account;
 130         PurpleMediaManager      *manager = purple_media_manager_get();
 131
 132         m->m = purple_media_manager_create_media(manager, acc, "fsrtpconference",
 133                                                                                          participant, initiator);
 134
 135         g_signal_connect(G_OBJECT(m->m), "candidates-prepared",
 136                                                 G_CALLBACK(on_candidates_prepared_cb), call);
 137         g_signal_connect(G_OBJECT(m->m), "stream-info",
 138                                                 G_CALLBACK(on_stream_info_cb), call);
 139         g_signal_connect(G_OBJECT(m->m), "state-changed",
 140                                                 G_CALLBACK(on_state_changed_cb), call);
 141
 142         return (sipe_media *)m;
 143 }
 144
 145 void
 146 sipe_backend_media_free(sipe_media *media)
 147 {
 148         sipe_purple_media *m = (sipe_purple_media *)media;
 149         purple_media_manager_remove_media(purple_media_manager_get(), m->m);
 150         g_free(m);
 151 }
 152
 153 gboolean
 154 sipe_backend_media_add_stream(sipe_media *media, const gchar* participant,
 155                                                           SipeMediaType type, gboolean use_nice,
 156                                                           gboolean initiator)
 157 {
 158         sipe_purple_media *m = (sipe_purple_media *)media;
 159         PurpleMediaSessionType prpl_type = sipe_media_to_purple(type);
 160         GParameter *params = NULL;
 161         guint params_cnt = 0;
 162         gchar *transmitter;
 163
 164         if (use_nice) {
 165                 transmitter = "nice";
 166                 params_cnt = 2;
 167
 168                 params = g_new0(GParameter, params_cnt);
 169                 params[0].name = "controlling-mode";
 170                 g_value_init(&params[0].value, G_TYPE_BOOLEAN);
 171                 g_value_set_boolean(&params[0].value, initiator);
 172                 params[1].name = "compatibility-mode";
 173                 g_value_init(&params[1].value, G_TYPE_UINT);
 174                 g_value_set_uint(&params[1].value, NICE_COMPATIBILITY_OC2007R2);
 175         } else {
 176                 transmitter = "rawudp";
 177         }
 178
 179         return purple_media_add_stream(m->m, "sipe-voice", participant, prpl_type,
 180                                                                    initiator, transmitter, params_cnt, params);
 181 }
 182
 183 void
 184 sipe_backend_media_add_remote_candidates(sipe_media *media, gchar* participant, GList *candidates)
 185 {
 186         sipe_purple_media *m = (sipe_purple_media *)media;
 187         purple_media_add_remote_candidates(m->m, "sipe-voice", participant, candidates);
 188 }
 189
 190 gboolean sipe_backend_media_is_initiator(sipe_media *media, gchar *participant)
 191 {
 192         sipe_purple_media *m = (sipe_purple_media *)media;
 193         return purple_media_is_initiator(m->m, "sipe-voice", participant);
 194 }
 195
 196 sipe_codec *
 197 sipe_backend_codec_new(int id, const char *name, SipeMediaType type, guint clock_rate)
 198 {
 199         return (sipe_codec *)purple_media_codec_new(id, name,
 200                                                                                 sipe_media_to_purple(type), clock_rate);
 201 }
 202
 203 void
 204 sipe_backend_codec_free(sipe_codec *codec)
 205 {
 206         if (codec)
 207                 g_object_unref(codec);
 208 }
 209
 210 int
 211 sipe_backend_codec_get_id(sipe_codec *codec)
 212 {
 213         return purple_media_codec_get_id((PurpleMediaCodec *)codec);
 214 }
 215
 216 gchar *
 217 sipe_backend_codec_get_name(sipe_codec *codec)
 218 {
 219         return purple_media_codec_get_encoding_name((PurpleMediaCodec *)codec);
 220 }
 221
 222 guint
 223 sipe_backend_codec_get_clock_rate(sipe_codec *codec)
 224 {
 225         return purple_media_codec_get_clock_rate((PurpleMediaCodec *)codec);
 226 }
 227
 228 void
 229 sipe_backend_codec_add_optional_parameter(sipe_codec *codec,
 230                                                                                   const gchar *name, const gchar *value)
 231 {
 232         purple_media_codec_add_optional_parameter((PurpleMediaCodec *)codec, name, value);
 233 }
 234
 235 GList *
 236 sipe_backend_codec_get_optional_parameters(sipe_codec *codec)
 237 {
 238         return purple_media_codec_get_optional_parameters((PurpleMediaCodec *)codec);
 239 }
 240
 241 gboolean
 242 sipe_backend_set_remote_codecs(sipe_media_call* call, gchar* participant)
 243 {
 244         sipe_purple_media       *m = (sipe_purple_media *)call->media;
 245         GList                           *codecs = call->remote_codecs;
 246
 247         return purple_media_set_remote_codecs(m->m, "sipe-voice", participant, codecs);
 248 }
 249
 250 GList*
 251 sipe_backend_get_local_codecs(sipe_media_call* call)
 252 {
 253         sipe_purple_media       *m = (sipe_purple_media *)call->media;
 254         return purple_media_get_codecs(m->m, "sipe-voice");
 255 }
 256
 257 sipe_candidate *
 258 sipe_backend_candidate_new(const gchar *foundation, SipeComponentType component,
 259                                                    SipeCandidateType type, SipeNetworkProtocol proto,
 260                                                    const gchar *ip, guint port)
 261 {
 262         return (sipe_candidate *)purple_media_candidate_new(
 263                                                                 foundation,
 264                                                                 component,
 265                                                                 sipe_candidate_type_to_purple(type),
 266                                                                 sipe_network_protocol_to_purple(proto),
 267                                                                 ip,
 268                                                                 port);
 269 }
 270
 271 void
 272 sipe_backend_candidate_free(sipe_candidate *candidate)
 273 {
 274         if (candidate)
 275                 g_object_unref(candidate);
 276 }
 277
 278 gchar *
 279 sipe_backend_candidate_get_username(sipe_candidate *candidate)
 280 {
 281         return purple_media_candidate_get_username((PurpleMediaCandidate*)candidate);
 282 }
 283
 284 gchar *
 285 sipe_backend_candidate_get_password(sipe_candidate *candidate)
 286 {
 287         return purple_media_candidate_get_password((PurpleMediaCandidate*)candidate);
 288 }
 289
 290 gchar *
 291 sipe_backend_candidate_get_foundation(sipe_candidate *candidate)
 292 {
 293         return purple_media_candidate_get_foundation((PurpleMediaCandidate*)candidate);
 294 }
 295
 296 gchar *
 297 sipe_backend_candidate_get_ip(sipe_candidate *candidate)
 298 {
 299         return purple_media_candidate_get_ip((PurpleMediaCandidate*)candidate);
 300 }
 301
 302 guint
 303 sipe_backend_candidate_get_port(sipe_candidate *candidate)
 304 {
 305         return purple_media_candidate_get_port((PurpleMediaCandidate*)candidate);
 306 }
 307
 308 guint32
 309 sipe_backend_candidate_get_priority(sipe_candidate *candidate)
 310 {
 311         return purple_media_candidate_get_priority((PurpleMediaCandidate*)candidate);
 312 }
 313
 314 void
 315 sipe_backend_candidate_set_priority(sipe_candidate *candidate, guint32 priority)
 316 {
 317         g_object_set(candidate, "priority", priority, NULL);
 318 }
 319
 320 SipeComponentType
 321 sipe_backend_candidate_get_component_type(sipe_candidate *candidate)
 322 {
 323         return purple_media_candidate_get_component_id((PurpleMediaCandidate*)candidate);
 324 }
 325
 326 SipeCandidateType
 327 sipe_backend_candidate_get_type(sipe_candidate *candidate)
 328 {
 329         return purple_media_candidate_get_candidate_type((PurpleMediaCandidate*)candidate);
 330 }
 331
 332 SipeNetworkProtocol
 333 sipe_backend_candidate_get_protocol(sipe_candidate *candidate)
 334 {
 335         PurpleMediaNetworkProtocol proto =
 336                 purple_media_candidate_get_protocol((PurpleMediaCandidate*)candidate);
 337         return purple_network_protocol_to_sipe(proto);
 338 }
 339
 340 void
 341 sipe_backend_candidate_set_username_and_pwd(sipe_candidate *candidate,
 342                                                                                         const gchar *username,
 343                                                                                         const gchar *password)
 344 {
 345         g_object_set(candidate, "username", username, "password", password, NULL);
 346 }
 347
 348 GList*
 349 sipe_backend_get_local_candidates(sipe_media_call* call, gchar* participant)
 350 {
 351         sipe_purple_media *m = (sipe_purple_media *)call->media;
 352         return purple_media_get_local_candidates(m->m, "sipe-voice", participant);
 353 }
 354
 355 void
 356 sipe_backend_media_hold(sipe_media* media, gboolean local)
 357 {
 358         sipe_purple_media *m = (sipe_purple_media *)media;
 359         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_HOLD, NULL, NULL, local);
 360 }
 361
 362 void
 363 sipe_backend_media_unhold(sipe_media* media, gboolean local)
 364 {
 365         sipe_purple_media *m = (sipe_purple_media *)media;
 366         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_UNHOLD, NULL, NULL, local);
 367 }
 368
 369 void
 370 sipe_backend_media_hangup(sipe_media* media, gboolean local)
 371 {
 372         sipe_purple_media *m = (sipe_purple_media *)media;
 373         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_HANGUP, NULL, NULL, local);
 374 }
 375
 376 void
 377 sipe_backend_media_reject(sipe_media* media, gboolean local)
 378 {
 379         sipe_purple_media *m = (sipe_purple_media *)media;
 380         purple_media_stream_info(m->m, PURPLE_MEDIA_INFO_REJECT, NULL, NULL, local);
 381 }
 382
 383 PurpleMediaSessionType sipe_media_to_purple(SipeMediaType type)
 384 {
 385         switch (type) {
 386                 case SIPE_MEDIA_AUDIO: return PURPLE_MEDIA_AUDIO;
 387                 case SIPE_MEDIA_VIDEO: return PURPLE_MEDIA_VIDEO;
 388                 default:                           return PURPLE_MEDIA_NONE;
 389         }
 390 }
 391
 392 /*SipeMediaType purple_media_to_sipe(PurpleMediaSessionType type)
 393 {
 394         switch (type) {
 395                 case PURPLE_MEDIA_AUDIO: return SIPE_MEDIA_AUDIO;
 396                 case PURPLE_MEDIA_VIDEO: return SIPE_MEDIA_VIDEO;
 397                 default:                                 return SIPE_MEDIA_AUDIO;
 398         }
 399 }*/
 400
 401 static PurpleMediaCandidateType
 402 sipe_candidate_type_to_purple(SipeCandidateType type)
 403 {
 404         switch (type) {
 405                 case SIPE_CANDIDATE_TYPE_HOST:  return PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
 406                 case SIPE_CANDIDATE_TYPE_RELAY: return PURPLE_MEDIA_CANDIDATE_TYPE_RELAY;
 407                 case SIPE_CANDIDATE_TYPE_SRFLX: return PURPLE_MEDIA_CANDIDATE_TYPE_SRFLX;
 408                 default:                                                return PURPLE_MEDIA_CANDIDATE_TYPE_HOST;
 409         }
 410 }
 411
 412 static PurpleMediaNetworkProtocol
 413 sipe_network_protocol_to_purple(SipeNetworkProtocol proto)
 414 {
 415         switch (proto) {
 416                 case SIPE_NETWORK_PROTOCOL_TCP: return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP;
 417                 case SIPE_NETWORK_PROTOCOL_UDP: return PURPLE_MEDIA_NETWORK_PROTOCOL_UDP;
 418                 default:                                                return PURPLE_MEDIA_NETWORK_PROTOCOL_TCP;
 419         }
 420 }
 421
 422 static SipeNetworkProtocol
 423 purple_network_protocol_to_sipe(PurpleMediaNetworkProtocol proto)
 424 {
 425         switch (proto) {
 426                 case PURPLE_MEDIA_NETWORK_PROTOCOL_TCP: return SIPE_NETWORK_PROTOCOL_TCP;
 427                 case PURPLE_MEDIA_NETWORK_PROTOCOL_UDP: return SIPE_NETWORK_PROTOCOL_UDP;
 428                 default:                                                                return SIPE_NETWORK_PROTOCOL_UDP;
 429         }
 430 }
 431
 432 /*
 433 void sipe_media_error_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, gchar* error, SIPE_UNUSED_PARAMETER struct sipe_account_data *sip)
 434 {
 435         printf("sipe_media_error_cb: %s\n", error);
 436 }
 437
 438 void sipe_media_codecs_changed_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, gchar* codec, SIPE_UNUSED_PARAMETER struct sipe_account_data *sip)
 439 {
 440         printf("sipe_media_codecs_changed_cb: %s\n", codec);
 441 }
 442
 443 void sipe_media_level_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, gchar* sessionid, gchar* participant, gdouble percent, SIPE_UNUSED_PARAMETER struct sipe_account_data *sip)
 444 {
 445         printf("sipe_media_level_cb: %s %s %f\n", sessionid, participant, percent);
 446 }
 447
 448 void sipe_media_new_candidate_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, gchar* sessionid, gchar* cname, PurpleMediaCandidate *candidate, SIPE_UNUSED_PARAMETER struct sipe_account_data *sip)
 449 {
 450         printf("sipe_media_new_candidate_cb: %s cname: %s %s %d\n", sessionid, cname,
 451                         purple_media_candidate_get_ip(candidate),
 452                         purple_media_candidate_get_port(candidate));
 453 }
 454
 455 void sipe_media_state_changed_cb(SIPE_UNUSED_PARAMETER PurpleMedia *media, PurpleMediaState state, gchar* sessionid, gchar* participant, SIPE_UNUSED_PARAMETER struct sipe_account_data *sip)
 456 {
 457         printf("sipe_media_state_changed_cb: %d %s %s\n", state, sessionid, participant);
 458 }
 459
 460 g_signal_connect(G_OBJECT(media), "error", G_CALLBACK(sipe_media_error_cb), call);
 461 g_signal_connect(G_OBJECT(media), "codecs-changed", G_CALLBACK(sipe_media_codecs_changed_cb), call);
 462 g_signal_connect(G_OBJECT(media), "level", G_CALLBACK(sipe_media_level_cb), call);
 463 g_signal_connect(G_OBJECT(media), "new-candidate", G_CALLBACK(sipe_media_new_candidate_cb), call);
 464 g_signal_connect(G_OBJECT(media), "state-changed", G_CALLBACK(sipe_media_state_changed_cb), call);
 465
 466 */
 467
 468 /*
 469   Local Variables:
 470   mode: c
 471   c-file-style: "bsd"
 472   indent-tabs-mode: t
 473   tab-width: 8
 474   End:
 475 */