static void _im_channel_closed_cb (IdleIMChannel *chan, gpointer user_data) { IdleIMManager *self = IDLE_IM_MANAGER (user_data); IdleIMManagerPrivate *priv = IDLE_IM_MANAGER_GET_PRIVATE (self); TpBaseChannel *base = TP_BASE_CHANNEL (chan); tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL (chan)); if (priv->channels) { TpHandle handle = tp_base_channel_get_target_handle (base); if (tp_base_channel_is_destroyed (base)) { IDLE_DEBUG ("removing channel with handle %u", handle); g_hash_table_remove (priv->channels, GUINT_TO_POINTER (handle)); } else { IDLE_DEBUG ("reopening channel with handle %u due to pending messages", handle); tp_channel_manager_emit_new_channel (self, (TpExportableChannel *) chan, NULL); } } }
static void auth_channel_closed_cb (GabbleServerSaslChannel *channel, GabbleAuthManager *self) { SavedError tmp = { NULL, NULL, 0 }; tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL (channel)); g_assert (self->priv->channel == channel); /* this is our last chance to find out why it failed */ if (gabble_server_sasl_channel_get_failure_details (channel, &tmp.name, &tmp.details, &tmp.reason)) self->priv->error = g_slice_dup (SavedError, &tmp); g_signal_handler_disconnect (self->priv->channel, self->priv->closed_id); tp_clear_object (&self->priv->channel); /* discard info we were holding in case we wanted to fall back */ g_slist_foreach (self->priv->mechanisms, (GFunc) g_free, NULL); tp_clear_pointer (&self->priv->mechanisms, g_slist_free); tp_clear_pointer (&self->priv->server, g_free); tp_clear_pointer (&self->priv->session_id, g_free); tp_clear_pointer (&self->priv->username, g_free); }
static void channel_closed_cb (ExampleEcho2Channel *chan, ExampleEcho2ImManager *self) { tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL (chan)); if (self->priv->channels != NULL) { TpHandle handle; gboolean really_destroyed; g_object_get (chan, "handle", &handle, "channel-destroyed", &really_destroyed, NULL); /* Re-announce the channel if it's not yet ready to go away (pending * messages) */ if (really_destroyed) { g_hash_table_remove (self->priv->channels, GUINT_TO_POINTER (handle)); } else { tp_channel_manager_emit_new_channel (self, TP_EXPORTABLE_CHANNEL (chan), NULL); } } }
static void roomlist_channel_closed_cb (KindlingRoomlistChannel *channel, gpointer user_data) { KindlingRoomlistManager *self = KINDLING_ROOMLIST_MANAGER(user_data); KindlingRoomlistManagerPrivate *priv = KINDLING_ROOMLIST_MANAGER_GET_PRIVATE(self); tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL(channel)); if (priv->channels != NULL) { g_ptr_array_remove (priv->channels, channel); g_object_unref (channel); } }
/** * media_channel_closed_cb: * Signal callback for when a media channel is closed. Removes the references * that #RakiaMediaManager holds to them. */ static void call_channel_closed_cb (RakiaCallChannel *chan, gpointer user_data) { RakiaMediaManager *fac = RAKIA_MEDIA_MANAGER (user_data); RakiaMediaManagerPrivate *priv = RAKIA_MEDIA_MANAGER_GET_PRIVATE (fac); tp_channel_manager_emit_channel_closed_for_object (fac, TP_EXPORTABLE_CHANNEL (chan)); if (priv->channels) { g_ptr_array_remove_fast (priv->channels, chan); } }
static void channel_closed_cb (ExampleCSHRoomChannel *chan, ExampleCSHRoomManager *self) { tp_channel_manager_emit_channel_closed_for_object (self, TP_EXPORTABLE_CHANNEL (chan)); if (self->priv->channels != NULL) { TpHandle handle; g_object_get (chan, "handle", &handle, NULL); g_hash_table_remove (self->priv->channels, GUINT_TO_POINTER (handle)); } }
/** * im_channel_closed_cb: * * Signal callback for when an IM channel is closed. Removes the references * that #GabbleConnection holds to them - unless the channel has pending * messages, in which case it is re-announced (so from the perspective of the * D-Bus API, it was replaced by an identical channel). */ static void im_channel_closed_cb (GabbleIMChannel *chan, gpointer user_data) { GabbleImFactory *self = GABBLE_IM_FACTORY (user_data); GabbleImFactoryPrivate *priv = self->priv; TpBaseChannel *base = TP_BASE_CHANNEL (chan); TpHandle contact_handle = tp_base_channel_get_target_handle (base); DEBUG ("%p, channel %p", self, chan); if (tp_base_channel_is_registered (base)) { tp_channel_manager_emit_channel_closed_for_object (self, (TpExportableChannel *) chan); } if (priv->channels != NULL) { if (tp_base_channel_is_destroyed (base)) { DEBUG ("removing channel with handle %u", contact_handle); g_hash_table_remove (priv->channels, GUINT_TO_POINTER (contact_handle)); } else if (tp_base_channel_is_respawning (base)) { DEBUG ("reopening channel with handle %u due to pending messages", contact_handle); tp_channel_manager_emit_new_channel (self, (TpExportableChannel *) chan, NULL); } else { /* this basically means tp_base_channel_disappear() must * have been called; this doesn't have any meaning in this * channel manager. */ g_assert_not_reached (); } } }