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