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); }