static void
ft_transfer_state_cb (TpFileTransferChannel *channel,
GParamSpec *pspec,
EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv = handler->priv;
TpFileTransferStateChangeReason reason;
TpFileTransferState state = tp_file_transfer_channel_get_state (
channel, &reason);
(void)pspec; /* suppress unused-parameter warning */
if (state == TP_FILE_TRANSFER_STATE_COMPLETED)
{
priv->is_completed = TRUE;
g_signal_emit (handler, signals[TRANSFER_DONE], 0, channel);
tp_channel_close_async (TP_CHANNEL (channel), NULL, NULL);
if (empathy_ft_handler_is_incoming (handler) && priv->use_hash)
{
check_hash_incoming (handler);
}
}
else if (state == TP_FILE_TRANSFER_STATE_CANCELLED)
{
GError *error = error_from_state_change_reason (reason);
emit_error_signal (handler, error);
g_clear_error (&error);
}
}
static void
on_call_state_changed_cb (TpCallChannel *call,
TpCallState state,
TpCallFlags flags,
TpCallStateReason *reason,
GHashTable *details,
EmpathyCallHandler *handler)
{
EmpathyCallHandlerPriv *priv = handler->priv;
/* Clean up the TfChannel before bubbling the state-change signal
* further up. This ensures that the conference-removed signal is
* emitted before state-changed so that the client gets a chance
* to remove the conference from the pipeline before resetting the
* pipeline itself.
*/
if (state == TP_CALL_STATE_ENDED)
{
tp_channel_close_async (TP_CHANNEL (call), NULL, NULL);
priv->accept_when_initialised = FALSE;
tp_clear_object (&priv->call);
tp_clear_object (&priv->tfchannel);
}
g_signal_emit (handler, signals[STATE_CHANGED], 0, state,
reason->dbus_reason);
if (state == TP_CALL_STATE_INITIALISED &&
priv->accept_when_initialised)
{
tp_call_channel_accept_async (priv->call, on_call_accepted_cb, NULL);
priv->accept_when_initialised = FALSE;
}
}
static void
mex_telepathy_channel_on_hangup (MxAction *action,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
tp_channel_close_async (self->priv->channel, NULL, NULL);
}
static void
mex_telepathy_channel_on_video_closed (ClutterActor *actor,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
tp_channel_close_async (self->priv->channel, NULL, NULL);
}
void
empathy_uoa_auth_handler_start (EmpathyUoaAuthHandler *self,
TpChannel *channel,
TpAccount *tp_account)
{
const GValue *id_value;
AgAccountId id;
AgAccount *account;
GList *l = NULL;
AgAccountService *service;
AuthContext *ctx;
g_return_if_fail (TP_IS_CHANNEL (channel));
g_return_if_fail (TP_IS_ACCOUNT (tp_account));
g_return_if_fail (empathy_uoa_auth_handler_supports (self, channel,
tp_account));
DEBUG ("Start UOA auth for account: %s",
tp_proxy_get_object_path (tp_account));
id_value = tp_account_get_storage_identifier (tp_account);
id = g_value_get_uint (id_value);
account = ag_manager_get_account (self->priv->manager, id);
if (account != NULL)
l = ag_account_list_services_by_type (account, TPAW_UOA_SERVICE_TYPE);
if (l == NULL)
{
DEBUG ("Couldn't find IM service for AgAccountId %u", id);
g_object_unref (account);
tp_channel_close_async (channel, NULL, NULL);
return;
}
/* Assume there is only one IM service */
service = ag_account_service_new (account, l->data);
ag_service_list_free (l);
g_object_unref (account);
ctx = auth_context_new (channel, service);
if (ctx->session == NULL)
{
/* This (usually?) means we never stored credentials for this account.
* To ask user to type his password SSO needs a SignonIdentity bound to
* our account. Let's store an empty password. */
DEBUG ("Couldn't create a signon session");
tpaw_keyring_set_account_password_async (tp_account, "", FALSE,
set_account_password_cb, ctx);
}
else
{
/* All is fine! Query UOA for more info */
signon_identity_query_info (ctx->identity,
identity_query_info_cb, ctx);
}
g_object_unref (service);
}
static void
tp_yts_client_dispose (GObject *object)
{
TpYtsClient *self = TP_YTS_CLIENT (object);
TpChannel *channel;
while (!g_queue_is_empty (&self->priv->incoming_channels))
{
channel = g_queue_pop_head (&self->priv->incoming_channels);
tp_channel_close_async (channel, on_channel_close_returned, channel);
}
G_OBJECT_CLASS (tp_yts_client_parent_class)->dispose(object);
}
static void
mex_telepathy_channel_on_call_state_changed (TpyCallChannel *channel,
TpyCallState state,
TpyCallFlags flags,
GValueArray *state_reason,
GHashTable *state_details,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
if (state == TPY_CALL_STATE_ENDED)
{
tp_channel_close_async (self->priv->channel, NULL, NULL);
}
}
/**
* empathy_ft_handler_cancel_transfer:
* @handler: an #EmpathyFTHandler
*
* Cancels an ongoing handler operation. Note that this doesn't destroy
* the object, which will keep all the properties, altough it won't be able
* to do any more I/O.
*/
void
empathy_ft_handler_cancel_transfer (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv;
g_return_if_fail (EMPATHY_IS_FT_HANDLER (handler));
priv = handler->priv;
/* if we don't have a channel, we are hashing, so
* we can just cancel the GCancellable to stop it.
*/
if (priv->channel == NULL)
g_cancellable_cancel (priv->cancellable);
else
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
}
static void
do_dispose (GObject *object)
{
EmpathyFTHandler *self = EMPATHY_FT_HANDLER (object);
EmpathyFTHandlerPriv *priv = self->priv;
if (priv->dispose_run)
return;
priv->dispose_run = TRUE;
if (priv->account != NULL) {
g_object_unref (priv->account);
priv->account = NULL;
}
if (priv->contact != NULL) {
g_object_unref (priv->contact);
priv->contact = NULL;
}
if (priv->gfile != NULL) {
g_object_unref (priv->gfile);
priv->gfile = NULL;
}
if (priv->channel != NULL) {
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
g_object_unref (priv->channel);
priv->channel = NULL;
}
if (priv->cancellable != NULL) {
g_object_unref (priv->cancellable);
priv->cancellable = NULL;
}
if (priv->request != NULL)
{
g_hash_table_unref (priv->request);
priv->request = NULL;
}
G_OBJECT_CLASS (empathy_ft_handler_parent_class)->dispose (object);
}
static void
mex_telepathy_channel_on_content_added (TfChannel *channel,
TfContent *content,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
MexTelepathyChannelPrivate *priv = self->priv;
GstPad *srcpad, *sinkpad;
FsMediaType mtype;
GstElement *element;
GstStateChangeReturn ret;
MEX_DEBUG ("Content added");
g_object_get (content,
"sink-pad", &sinkpad,
"media-type", &mtype,
NULL);
switch (mtype)
{
case FS_MEDIA_TYPE_AUDIO:
MEX_DEBUG ("Audio content added");
element = gst_parse_bin_from_description (
"autoaudiosrc ! audioresample ! audioconvert ! volume name=micvolume", TRUE, NULL);
priv->outgoing_mic = element;
priv->mic_volume = gst_bin_get_by_name (GST_BIN (priv->outgoing_mic), "micvolume");
break;
case FS_MEDIA_TYPE_VIDEO:
MEX_DEBUG ("Video content added");
element = mex_telepathy_channel_setup_video_source (self, content);
break;
default:
MEX_WARNING ("Unknown media type");
g_object_unref (sinkpad);
return;
}
g_signal_connect (content, "src-pad-added",
G_CALLBACK (mex_telepathy_channel_on_src_pad_added), self);
gst_bin_add (GST_BIN (priv->pipeline), element);
srcpad = gst_element_get_pad (element, "src");
if (GST_PAD_LINK_FAILED (gst_pad_link (srcpad, sinkpad)))
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
MEX_WARNING ("Couldn't link source pipeline !?");
return;
}
ret = gst_element_set_state (element, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE)
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
MEX_WARNING ("source pipeline failed to start!?");
return;
}
g_object_unref (srcpad);
g_object_unref (sinkpad);
}
static void
mex_telepathy_channel_on_src_pad_added (TfContent *content,
TpHandle handle,
FsStream *stream,
GstPad *pad,
FsCodec *codec,
gpointer user_data)
{
MexTelepathyChannel *self = MEX_TELEPATHY_CHANNEL (user_data);
MexTelepathyChannelPrivate *priv = self->priv;
gchar *cstr = fs_codec_to_string (codec);
FsMediaType mtype;
GstPad *sinkpad;
GstElement *element;
GstStateChangeReturn ret;
/* Upon pad added, clear the "in progress" box+padding */
clutter_actor_hide (CLUTTER_ACTOR (priv->busy_box));
clutter_actor_show (CLUTTER_ACTOR (priv->full_frame) );
MEX_DEBUG ("New src pad: %s", cstr);
g_object_get (content, "media-type", &mtype, NULL);
switch (mtype)
{
case FS_MEDIA_TYPE_AUDIO:
element = gst_parse_bin_from_description (
"audioconvert ! audioresample ! audioconvert ! autoaudiosink",
TRUE, NULL);
break;
case FS_MEDIA_TYPE_VIDEO:
element = priv->incoming_sink;
break;
default:
MEX_WARNING ("Unknown media type");
return;
}
if (!gst_bin_add (GST_BIN (priv->pipeline), element))
{
MEX_WARNING ("Failed to add sink element to pipeline");
}
sinkpad = gst_element_get_pad (element, "sink");
ret = gst_element_set_state (element, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE)
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
MEX_WARNING ("Failed to start tee sink pipeline !?");
return;
}
if (GST_PAD_LINK_FAILED (gst_pad_link (pad, sinkpad)))
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
MEX_WARNING ("Couldn't link sink pipeline !?");
return;
}
g_object_unref (sinkpad);
/* Start in FULL mode */
mex_telepathy_channel_set_tool_mode (self, TOOL_MODE_FULL, 100);
}
static void
mex_telepathy_channel_initialize_channel (MexTelepathyChannel *self)
{
MexTelepathyChannelPrivate *priv = self->priv;
GstBus *bus;
GstElement *pipeline;
GstStateChangeReturn ret;
gboolean ready;
TpHandle contactHandle = tp_channel_get_handle (priv->channel, NULL);
TpContactFeature features[] = { TP_CONTACT_FEATURE_ALIAS,
TP_CONTACT_FEATURE_AVATAR_DATA,
TP_CONTACT_FEATURE_AVATAR_TOKEN};
MEX_INFO ("New channel");
if (contactHandle)
tp_connection_get_contacts_by_handle (
priv->connection, 1, &contactHandle, 1,
features,
mex_telepathy_channel_on_contact_fetched,
self, NULL, NULL);
pipeline = gst_pipeline_new (NULL);
ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
if (ret == GST_STATE_CHANGE_FAILURE)
{
tp_channel_close_async (TP_CHANNEL (priv->channel), NULL, NULL);
g_object_unref (pipeline);
MEX_WARNING ("Failed to start an empty pipeline !?");
return;
}
priv->pipeline = pipeline;
bus = gst_pipeline_get_bus (GST_PIPELINE (pipeline));
priv->buswatch = gst_bus_add_watch (bus, mex_telepathy_channel_on_bus_watch,
self);
g_object_unref (bus);
tf_channel_new_async (priv->channel, mex_telepathy_channel_new_tf_channel,
self);
tpy_cli_channel_type_call_call_accept (TP_PROXY (priv->channel), -1,
NULL, NULL, NULL, NULL);
priv->channel = g_object_ref (priv->channel);
g_signal_connect (priv->channel, "notify::ready",
G_CALLBACK (mex_telepathy_channel_on_ready),
self);
g_signal_connect (priv->channel, "invalidated",
G_CALLBACK (mex_telepathy_channel_on_proxy_invalidated),
self);
g_signal_connect (TPY_CALL_CHANNEL (priv->channel), "state-changed",
G_CALLBACK (mex_telepathy_channel_on_call_state_changed),
self);
g_object_get (priv->channel, "ready", &ready, NULL);
if (ready)
mex_telepathy_channel_on_ready (TPY_CALL_CHANNEL (priv->channel), NULL, self);
}
static void
auth_context_done (AuthContext *ctx)
{
tp_channel_close_async (ctx->channel, NULL, NULL);
auth_context_free (ctx);
}
