/*------------------------------------------------------------------------
* Does this client support Voice and Video?
*/
gboolean mxit_video_enabled(void)
{
PurpleMediaManager *manager = purple_media_manager_get();
PurpleMediaCaps caps = purple_media_manager_get_ui_caps(manager);
return (caps & PURPLE_MEDIA_CAPS_VIDEO);
}
void
jabber_google_session_parse(JabberStream *js, const char *from,
JabberIqType type, const char *iq_id,
xmlnode *session_node)
{
GoogleSession *session = NULL;
GoogleSessionId id;
xmlnode *desc_node;
GList *iter = NULL;
if (type != JABBER_IQ_SET)
return;
id.id = (gchar*)xmlnode_get_attrib(session_node, "id");
if (!id.id)
return;
id.initiator = (gchar*)xmlnode_get_attrib(session_node, "initiator");
if (!id.initiator)
return;
iter = purple_media_manager_get_media_by_account(
purple_media_manager_get(),
purple_connection_get_account(js->gc));
for (; iter; iter = g_list_delete_link(iter, iter)) {
GoogleSession *gsession =
purple_media_get_prpl_data(iter->data);
if (google_session_id_equal(&(gsession->id), &id)) {
session = gsession;
break;
}
}
if (iter != NULL) {
g_list_free(iter);
}
if (session) {
google_session_parse_iq(js, session, session_node, iq_id);
return;
}
/* If the session doesn't exist, this has to be an initiate message */
if (strcmp(xmlnode_get_attrib(session_node, "type"), "initiate"))
return;
desc_node = xmlnode_get_child(session_node, "description");
if (!desc_node)
return;
session = g_new0(GoogleSession, 1);
session->id.id = g_strdup(id.id);
session->id.initiator = g_strdup(id.initiator);
session->state = UNINIT;
session->js = js;
session->remote_jid = g_strdup(session->id.initiator);
session->session_data = g_new0(GoogleAVSessionData, 1);
google_session_handle_initiate(js, session, session_node, iq_id);
}
static void
purple_media_set_property (GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
PurpleMedia *media;
g_return_if_fail(PURPLE_IS_MEDIA(object));
media = PURPLE_MEDIA(object);
switch (prop_id) {
case PROP_MANAGER:
media->priv->manager = g_value_dup_object(value);
break;
case PROP_ACCOUNT:
media->priv->account = g_value_get_pointer(value);
break;
case PROP_CONFERENCE_TYPE:
media->priv->conference_type =
g_value_dup_string(value);
media->priv->backend = g_object_new(
purple_media_manager_get_backend_type(
purple_media_manager_get()),
"conference-type",
media->priv->conference_type,
"media", media,
NULL);
g_signal_connect(media->priv->backend,
"active-candidate-pair",
G_CALLBACK(
purple_media_candidate_pair_established_cb),
media);
g_signal_connect(media->priv->backend,
"candidates-prepared",
G_CALLBACK(
purple_media_candidates_prepared_cb),
media);
g_signal_connect(media->priv->backend,
"codecs-changed",
G_CALLBACK(
purple_media_codecs_changed_cb),
media);
g_signal_connect(media->priv->backend,
"new-candidate",
G_CALLBACK(
purple_media_new_local_candidate_cb),
media);
break;
case PROP_INITIATOR:
media->priv->initiator = g_value_get_boolean(value);
break;
case PROP_PRPL_DATA:
media->priv->prpl_data = g_value_get_pointer(value);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
void
pidgin_medias_init(void)
{
#ifdef USE_VV
PurpleMediaManager *manager = purple_media_manager_get();
PurpleMediaElementInfo *default_video_src =
g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "pidgindefaultvideosrc",
"name", "Pidgin Default Video Source",
"type", PURPLE_MEDIA_ELEMENT_VIDEO
| PURPLE_MEDIA_ELEMENT_SRC
| PURPLE_MEDIA_ELEMENT_ONE_SRC
| PURPLE_MEDIA_ELEMENT_UNIQUE,
"create-cb", create_default_video_src, NULL);
PurpleMediaElementInfo *default_video_sink =
g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "pidgindefaultvideosink",
"name", "Pidgin Default Video Sink",
"type", PURPLE_MEDIA_ELEMENT_VIDEO
| PURPLE_MEDIA_ELEMENT_SINK
| PURPLE_MEDIA_ELEMENT_ONE_SINK,
"create-cb", create_default_video_sink, NULL);
PurpleMediaElementInfo *default_audio_src =
g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "pidgindefaultaudiosrc",
"name", "Pidgin Default Audio Source",
"type", PURPLE_MEDIA_ELEMENT_AUDIO
| PURPLE_MEDIA_ELEMENT_SRC
| PURPLE_MEDIA_ELEMENT_ONE_SRC
| PURPLE_MEDIA_ELEMENT_UNIQUE,
"create-cb", create_default_audio_src, NULL);
PurpleMediaElementInfo *default_audio_sink =
g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "pidgindefaultaudiosink",
"name", "Pidgin Default Audio Sink",
"type", PURPLE_MEDIA_ELEMENT_AUDIO
| PURPLE_MEDIA_ELEMENT_SINK
| PURPLE_MEDIA_ELEMENT_ONE_SINK,
"create-cb", create_default_audio_sink, NULL);
g_signal_connect(G_OBJECT(manager), "init-media",
G_CALLBACK(pidgin_media_new_cb), NULL);
purple_media_manager_set_ui_caps(manager,
PURPLE_MEDIA_CAPS_AUDIO |
PURPLE_MEDIA_CAPS_AUDIO_SINGLE_DIRECTION |
PURPLE_MEDIA_CAPS_VIDEO |
PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION |
PURPLE_MEDIA_CAPS_AUDIO_VIDEO);
purple_debug_info("gtkmedia", "Registering media element types\n");
purple_media_manager_set_active_element(manager, default_video_src);
purple_media_manager_set_active_element(manager, default_video_sink);
purple_media_manager_set_active_element(manager, default_audio_src);
purple_media_manager_set_active_element(manager, default_audio_sink);
#endif
}
static gboolean
plugin_unload(PurplePlugin *plugin)
{
PurpleMediaManager *manager = purple_media_manager_get();
purple_media_manager_set_active_element(manager, old_video_src);
purple_media_manager_set_active_element(manager, old_video_sink);
purple_media_manager_set_active_element(manager, old_audio_src);
purple_media_manager_set_active_element(manager, old_audio_sink);
return TRUE;
}
static void
set_element_info_cond(PurpleMediaElementInfo *old_info,
PurpleMediaElementInfo *new_info, const gchar *id)
{
gchar *element_id = purple_media_element_info_get_id(old_info);
if (!strcmp(element_id, id))
purple_media_manager_set_active_element(
purple_media_manager_get(), new_info);
g_free(element_id);
}
static gboolean
google_session_handle_initiate(JabberStream *js, GoogleSession *session, xmlnode *sess, const char *iq_id)
{
const gchar *xmlns;
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
if (session->state != UNINIT) {
purple_debug_error("jabber", "Received initiate for active session.\n");
return FALSE;
}
session->description = xmlnode_copy(xmlnode_get_child(sess, "description"));
xmlns = xmlnode_get_namespace(session->description);
if (purple_strequal(xmlns, NS_GOOGLE_SESSION_PHONE))
session_data->video = FALSE;
else if (purple_strequal(xmlns, NS_GOOGLE_SESSION_VIDEO))
session_data->video = TRUE;
else {
purple_debug_error("jabber", "Received initiate with "
"invalid namespace %s.\n", xmlns);
return FALSE;
}
session_data->media = purple_media_manager_create_media(
purple_media_manager_get(),
purple_connection_get_account(js->gc),
"fsrtpconference", session->remote_jid, FALSE);
purple_media_set_prpl_data(session_data->media, session);
g_signal_connect_swapped(G_OBJECT(session_data->media),
"candidates-prepared",
G_CALLBACK(google_session_ready), session);
g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed",
G_CALLBACK(google_session_ready), session);
g_signal_connect(G_OBJECT(session_data->media), "state-changed",
G_CALLBACK(google_session_state_changed_cb), session);
g_signal_connect(G_OBJECT(session_data->media), "stream-info",
G_CALLBACK(google_session_stream_info_cb), session);
session->iq_id = g_strdup(iq_id);
if (js->google_relay_host && js->google_relay_token) {
jabber_google_do_relay_request(js, session,
jabber_google_relay_response_session_handle_initiate_cb);
} else {
jabber_google_relay_response_session_handle_initiate_cb(session, NULL,
0, 0, 0, NULL, NULL);
}
return TRUE;
}
static void
jabber_google_relay_response_session_initiate_cb(GoogleSession *session,
const gchar *relay_ip, guint relay_udp, guint relay_tcp, guint relay_ssltcp,
const gchar *relay_username, const gchar *relay_password)
{
GParameter *params;
guint num_params;
JabberStream *js = session->js;
GoogleAVSessionData *session_data =
(GoogleAVSessionData *) session->session_data;
session_data->media = purple_media_manager_create_media(
purple_media_manager_get(),
purple_connection_get_account(js->gc),
"fsrtpconference", session->remote_jid, TRUE);
purple_media_set_prpl_data(session_data->media, session);
g_signal_connect_swapped(G_OBJECT(session_data->media),
"candidates-prepared",
G_CALLBACK(google_session_ready), session);
g_signal_connect_swapped(G_OBJECT(session_data->media), "codecs-changed",
G_CALLBACK(google_session_ready), session);
g_signal_connect(G_OBJECT(session_data->media), "state-changed",
G_CALLBACK(google_session_state_changed_cb), session);
g_signal_connect(G_OBJECT(session_data->media), "stream-info",
G_CALLBACK(google_session_stream_info_cb), session);
params =
jabber_google_session_get_params(js, relay_ip, relay_udp, relay_tcp,
relay_ssltcp, relay_username, relay_password, &num_params);
if (purple_media_add_stream(session_data->media, "google-voice",
session->remote_jid, PURPLE_MEDIA_AUDIO,
TRUE, "nice", num_params, params) == FALSE ||
(session_data->video && purple_media_add_stream(
session_data->media, "google-video",
session->remote_jid, PURPLE_MEDIA_VIDEO,
TRUE, "nice", num_params, params) == FALSE)) {
purple_media_error(session_data->media, "Error adding stream.");
purple_media_end(session_data->media, NULL, NULL);
g_free(params);
} else {
session_data->added_streams = TRUE;
}
g_free(params);
}
void Media::init()
{
#ifdef HAVE_VIDEO
GError *error = NULL;
if((gstreamer_init_failed = !gst_init_check(NULL, NULL, &error)))
{
b_log[W_ERR] << "Unable to initialize GStreamer: " << (error ? error->message : "");
if(error)
g_free(error);
return;
}
PurpleMediaManager *manager = purple_media_manager_get();
PurpleMediaElementInfo *default_video_src =
(PurpleMediaElementInfo*)g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "minbifdefaultvideosrc",
"name", "minbif Default Video Source",
"type", PURPLE_MEDIA_ELEMENT_VIDEO
| PURPLE_MEDIA_ELEMENT_SRC
| PURPLE_MEDIA_ELEMENT_ONE_SRC
| PURPLE_MEDIA_ELEMENT_UNIQUE,
"create-cb", create_default_video_src, NULL);
PurpleMediaElementInfo *default_video_sink =
(PurpleMediaElementInfo*)g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "minbifdefaultvideosink",
"name", "minbif Default Video Sink",
"type", PURPLE_MEDIA_ELEMENT_VIDEO
| PURPLE_MEDIA_ELEMENT_SINK
| PURPLE_MEDIA_ELEMENT_ONE_SINK,
"create-cb", create_default_video_sink, NULL);
g_signal_connect(G_OBJECT(manager), "init-media",
G_CALLBACK(media_new_cb), NULL);
purple_media_manager_set_ui_caps(manager, (PurpleMediaCaps)(
PURPLE_MEDIA_CAPS_VIDEO |
PURPLE_MEDIA_CAPS_VIDEO_SINGLE_DIRECTION));
purple_media_manager_set_active_element(manager, default_video_sink);
purple_media_manager_set_active_element(manager, default_video_src);
#endif /* HAVE_VIDEO */
}
/*------------------------------------------------------------------------
* Initiate a voice/video session with a contact.
*
* @param account The MXit account object
* @param who The username of the contact.
* @param type The type of media session to initiate
* @return TRUE if session was initiated
*/
gboolean mxit_media_initiate(PurpleAccount *account, const char *who, PurpleMediaSessionType type)
{
gchar* transmitter = "rawudp";
PurpleMedia* media = NULL;
purple_debug_info(MXIT_PLUGIN_ID, "mxit_media_initiate: buddy '%s'\n", who);
media = purple_media_manager_create_media(
purple_media_manager_get(),
account,
"fsrtpconference",
who,
TRUE
);
if (!media) {
purple_debug_info(MXIT_PLUGIN_ID, "mxit_media_initiate: could not create media session\n");
return FALSE;
}
/* attach callbacks */
g_signal_connect(G_OBJECT(media), "candidates-prepared", G_CALLBACK(mxit_candidates_prepared_cb), NULL);
g_signal_connect(G_OBJECT(media), "stream-info", G_CALLBACK(mxit_stream_info_cb), NULL);
g_signal_connect(G_OBJECT(media), "state-changed", G_CALLBACK(mxit_state_changed_cb), NULL);
/* initiate audio session */
if ((type & PURPLE_MEDIA_AUDIO) &&
(!purple_media_add_stream(media, "audio", who, PURPLE_MEDIA_AUDIO, TRUE, transmitter, 0, NULL))) {
purple_media_end(media, NULL, NULL);
return FALSE;
}
/* initiate video session */
if ((type & PURPLE_MEDIA_VIDEO) &&
(!purple_media_add_stream(media, "video", who, PURPLE_MEDIA_VIDEO, TRUE, transmitter, 0, NULL))) {
purple_media_end(media, NULL, NULL);
return FALSE;
}
return TRUE;
}
struct sipe_backend_media *
sipe_backend_media_new(struct sipe_core_public *sipe_public,
struct sipe_media_call *call,
const gchar *participant,
gboolean initiator)
{
struct sipe_backend_media *media = g_new0(struct sipe_backend_media, 1);
struct sipe_backend_private *purple_private = sipe_public->backend_private;
PurpleMediaManager *manager = purple_media_manager_get();
GstElement *pipeline;
media->m = purple_media_manager_create_media(manager,
purple_private->account,
"fsrtpconference",
participant, initiator);
g_signal_connect(G_OBJECT(media->m), "candidates-prepared",
G_CALLBACK(on_candidates_prepared_cb), call);
g_signal_connect(G_OBJECT(media->m), "codecs-changed",
G_CALLBACK(on_codecs_changed_cb), call);
g_signal_connect(G_OBJECT(media->m), "stream-info",
G_CALLBACK(on_stream_info_cb), call);
g_signal_connect(G_OBJECT(media->m), "error",
G_CALLBACK(on_error_cb), call);
g_signal_connect(G_OBJECT(media->m), "state-changed",
G_CALLBACK(on_state_changed_cb), call);
/* On error, the pipeline is no longer in PLAYING state and libpurple
* will not switch it back to PLAYING, preventing any more calls until
* application restart. We switch the state ourselves here to negate
* effect of any error in previous call (if any). */
pipeline = purple_media_manager_get_pipeline(manager);
gst_element_set_state(pipeline, GST_STATE_PLAYING);
return media;
}
void
capture_pipeline(const gchar *label) {
PurpleMediaManager *manager = purple_media_manager_get();
GstElement *pipeline = purple_media_manager_get_pipeline(manager);
GST_DEBUG_BIN_TO_DOT_FILE_WITH_TS(GST_BIN(pipeline), GST_DEBUG_GRAPH_SHOW_ALL, label);
}
static gboolean
plugin_load(PurplePlugin *plugin)
{
PurpleMediaManager *manager;
PurpleMediaElementInfo *video_src, *video_sink,
*audio_src, *audio_sink;
/* Disable the plugin if the UI doesn't support VV */
if (purple_media_manager_get_ui_caps(purple_media_manager_get()) ==
PURPLE_MEDIA_CAPS_NONE)
return FALSE;
purple_prefs_add_none("/plugins/core/vvconfig");
purple_prefs_add_none("/plugins/core/vvconfig/audio");
purple_prefs_add_none("/plugins/core/vvconfig/audio/src");
purple_prefs_add_string("/plugins/core/vvconfig/audio/src/plugin", "");
purple_prefs_add_string("/plugins/core/vvconfig/audio/src/device", "");
purple_prefs_add_none("/plugins/core/vvconfig/audio/sink");
purple_prefs_add_string("/plugins/core/vvconfig/audio/sink/plugin", "");
purple_prefs_add_string("/plugins/core/vvconfig/audio/sink/device", "");
purple_prefs_add_none("/plugins/core/vvconfig/video");
purple_prefs_add_none("/plugins/core/vvconfig/video/src");
purple_prefs_add_string("/plugins/core/vvconfig/video/src/plugin", "");
purple_prefs_add_string("/plugins/core/vvconfig/video/src/device", "");
purple_prefs_add_none("/plugins/gtk/vvconfig");
purple_prefs_add_none("/plugins/gtk/vvconfig/video");
purple_prefs_add_none("/plugins/gtk/vvconfig/video/sink");
purple_prefs_add_string("/plugins/gtk/vvconfig/video/sink/plugin", "");
purple_prefs_add_string("/plugins/gtk/vvconfig/video/sink/device", "");
video_src = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "vvconfig-videosrc",
"name", "VV Conf Plugin Video Source",
"type", PURPLE_MEDIA_ELEMENT_VIDEO
| PURPLE_MEDIA_ELEMENT_SRC
| PURPLE_MEDIA_ELEMENT_ONE_SRC
| PURPLE_MEDIA_ELEMENT_UNIQUE,
"create-cb", create_video_src, NULL);
video_sink = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "vvconfig-videosink",
"name", "VV Conf Plugin Video Sink",
"type", PURPLE_MEDIA_ELEMENT_VIDEO
| PURPLE_MEDIA_ELEMENT_SINK
| PURPLE_MEDIA_ELEMENT_ONE_SINK,
"create-cb", create_video_sink, NULL);
audio_src = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "vvconfig-audiosrc",
"name", "VV Conf Plugin Audio Source",
"type", PURPLE_MEDIA_ELEMENT_AUDIO
| PURPLE_MEDIA_ELEMENT_SRC
| PURPLE_MEDIA_ELEMENT_ONE_SRC
| PURPLE_MEDIA_ELEMENT_UNIQUE,
"create-cb", create_audio_src, NULL);
audio_sink = g_object_new(PURPLE_TYPE_MEDIA_ELEMENT_INFO,
"id", "vvconfig-audiosink",
"name", "VV Conf Plugin Audio Sink",
"type", PURPLE_MEDIA_ELEMENT_AUDIO
| PURPLE_MEDIA_ELEMENT_SINK
| PURPLE_MEDIA_ELEMENT_ONE_SINK,
"create-cb", create_audio_sink, NULL);
purple_debug_info("gtkmedia", "Registering media element types\n");
manager = purple_media_manager_get();
old_video_src = purple_media_manager_get_active_element(manager,
PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SRC);
old_video_sink = purple_media_manager_get_active_element(manager,
PURPLE_MEDIA_ELEMENT_VIDEO | PURPLE_MEDIA_ELEMENT_SINK);
old_audio_src = purple_media_manager_get_active_element(manager,
PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SRC);
old_audio_sink = purple_media_manager_get_active_element(manager,
PURPLE_MEDIA_ELEMENT_AUDIO | PURPLE_MEDIA_ELEMENT_SINK);
set_element_info_cond(old_video_src, video_src, "pidgindefaultvideosrc");
set_element_info_cond(old_video_sink, video_sink, "pidgindefaultvideosink");
set_element_info_cond(old_audio_src, audio_src, "pidgindefaultaudiosrc");
set_element_info_cond(old_audio_sink, audio_sink, "pidgindefaultaudiosink");
return TRUE;
}
