static void
handle_dbus_channel(TpSimpleHandler* /*handler*/,
TpAccount* /*account*/,
TpConnection* /*connection*/,
GList* channels,
GList* /*requests*/,
gint64 /*user_action_time*/,
TpHandleChannelsContext* context,
gpointer user_data)
{
UT_DEBUGMSG(("handle_dbus_channel()\n"));
TelepathyAccountHandler* pHandler = reinterpret_cast<TelepathyAccountHandler*>(user_data);
UT_return_if_fail(pHandler);
for (GList* chan = channels; chan; chan = chan->next)
{
TpChannel* channel = TP_CHANNEL(chan->data);
UT_continue_if_fail(channel);
UT_DEBUGMSG((">>>>> incoming dbus channel: %s\n", tp_channel_get_identifier(channel)));
if (tp_channel_get_channel_type_id(channel) != TP_IFACE_QUARK_CHANNEL_TYPE_DBUS_TUBE)
continue;
/* accept the channel */
tp_cli_channel_type_dbus_tube_call_accept(channel, -1,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST,
tube_accept_cb, user_data, NULL, NULL);
}
tp_handle_channels_context_accept(context);
}
static void
handle_channels_cb (TpSimpleHandler *handler,
TpAccount *account,
TpConnection *connection,
GList *channels,
GList *requests_satisfied,
gint64 user_action_time,
TpHandleChannelsContext *context,
gpointer user_data)
{
EmpathyStreamedMediaFactory *self = user_data;
GList *l;
for (l = channels; l != NULL; l = g_list_next (l))
{
TpChannel *channel = l->data;
EmpathyTpStreamedMedia *call;
if (tp_proxy_get_invalidated (channel) != NULL)
continue;
if (tp_channel_get_channel_type_id (channel) !=
TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA)
continue;
call = empathy_tp_streamed_media_new (account, channel);
if (empathy_tp_streamed_media_get_status (call) <= EMPATHY_TP_STREAMED_MEDIA_STATUS_READYING)
{
/* We have to wait that the TpStreamedMedia is ready as the
* call-handler rely on it. */
tp_g_signal_connect_object (call, "notify::status",
G_CALLBACK (call_status_changed_cb), self, 0);
continue;
}
create_streamed_media_handler (self, call);
g_object_unref (call);
}
tp_handle_channels_context_accept (context);
}
static gboolean
has_ongoing_calls (EmpathyCallObserver *self)
{
GList *l;
for (l = self->priv->channels; l != NULL; l = l->next)
{
TpChannel *channel = TP_CHANNEL (l->data);
GQuark type = tp_channel_get_channel_type_id (channel);
/* Check that Call channels are not ended */
if (type == TP_IFACE_QUARK_CHANNEL_TYPE_CALL &&
tp_call_channel_get_state (TP_CALL_CHANNEL (channel),
NULL, NULL, NULL) == TP_CALL_STATE_ENDED)
continue;
return TRUE;
}
return FALSE;
}
static TpChannel *
find_main_channel (GList *channels)
{
GList *l;
for (l = channels; l != NULL; l = g_list_next (l))
{
TpChannel *channel = l->data;
GQuark channel_type;
if (tp_proxy_get_invalidated (channel) != NULL)
continue;
channel_type = tp_channel_get_channel_type_id (channel);
if (channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_STREAMED_MEDIA ||
channel_type == TP_IFACE_QUARK_CHANNEL_TYPE_CALL)
return channel;
}
return NULL;
}
static void
handle_channels_cb (TpSimpleHandler *handler,
TpAccount *account,
TpConnection *connection,
GList *channels,
GList *requests_satisfied,
gint64 user_action_time,
TpHandleChannelsContext *context,
gpointer user_data)
{
EmpathyFTFactory *self = user_data;
GList *l;
for (l = channels; l != NULL; l = g_list_next (l))
{
TpChannel *channel = l->data;
EmpathyTpFile *tp_file;
if (tp_proxy_get_invalidated (channel) != NULL)
continue;
if (tp_channel_get_channel_type_id (channel) !=
TP_IFACE_QUARK_CHANNEL_TYPE_FILE_TRANSFER)
continue;
tp_file = empathy_tp_file_new (channel);
/* We handle only incoming FT */
empathy_ft_handler_new_incoming (tp_file, ft_handler_incoming_ready_cb,
self);
g_object_unref (tp_file);
}
tp_handle_channels_context_accept (context);
}
static void
tp_stream_tube_channel_constructed (GObject *obj)
{
TpStreamTubeChannel *self = (TpStreamTubeChannel *) obj;
void (*chain_up) (GObject *) =
((GObjectClass *) tp_stream_tube_channel_parent_class)->constructed;
TpChannel *chan = (TpChannel *) obj;
GHashTable *props;
GError *err = NULL;
if (chain_up != NULL)
chain_up (obj);
if (tp_channel_get_channel_type_id (chan) !=
TP_IFACE_QUARK_CHANNEL_TYPE_STREAM_TUBE)
{
GError error = { TP_DBUS_ERRORS, TP_DBUS_ERROR_INCONSISTENT,
"Channel is not a stream tube" };
DEBUG ("Channel is not a stream tube: %s", tp_channel_get_channel_type (
chan));
tp_proxy_invalidate (TP_PROXY (self), &error);
return;
}
props = _tp_channel_get_immutable_properties (TP_CHANNEL (self));
if (tp_asv_get_string (props, TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE)
== NULL)
{
GError error = { TP_DBUS_ERRORS, TP_DBUS_ERROR_INCONSISTENT,
"Tube doesn't have StreamTube.Service property" };
DEBUG ("%s", error.message);
tp_proxy_invalidate (TP_PROXY (self), &error);
return;
}
/* Tube.Parameters is immutable for incoming tubes. For outgoing ones,
* it's defined when offering the tube. */
if (!tp_channel_get_requested (TP_CHANNEL (self)))
{
GHashTable *params;
params = tp_asv_get_boxed (props,
TP_PROP_CHANNEL_INTERFACE_TUBE_PARAMETERS,
TP_HASH_TYPE_STRING_VARIANT_MAP);
if (params == NULL)
{
DEBUG ("Incoming tube doesn't have Tube.Parameters property");
self->priv->parameters = tp_asv_new (NULL, NULL);
}
else
{
self->priv->parameters = g_boxed_copy (
TP_HASH_TYPE_STRING_VARIANT_MAP, params);
}
}
tp_cli_channel_type_stream_tube_connect_to_connection_closed (
TP_CHANNEL (self), connection_closed_cb, NULL, NULL,
G_OBJECT (self), &err);
if (err != NULL)
{
DEBUG ("Failed to connect to ConnectionClosed signal: %s",
err->message);
g_error_free (err);
}
}
