static void
empathy_tube_dispatch_constructed (GObject *object)
{
EmpathyTubeDispatch *self = EMPATHY_TUBE_DISPATCH (object);
EmpathyTubeDispatchPriv *priv = GET_PRIV (self);
TpChannel *channel;
GHashTable *properties;
const gchar *service;
const gchar *channel_type;
TpTubeType type;
priv->dbus = tp_dbus_daemon_new (tp_get_bus());
channel = empathy_dispatch_operation_get_channel (priv->operation);
properties = tp_channel_borrow_immutable_properties (channel);
channel_type = tp_asv_get_string (properties,
TP_IFACE_CHANNEL ".ChannelType");
if (channel_type == NULL)
goto failed;
if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE))
{
type = TP_TUBE_TYPE_STREAM;
service = tp_asv_get_string (properties,
EMP_IFACE_CHANNEL_TYPE_STREAM_TUBE ".Service");
}
else if (!tp_strdiff (channel_type, EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE))
{
type = TP_TUBE_TYPE_DBUS;
service = tp_asv_get_string (properties,
EMP_IFACE_CHANNEL_TYPE_DBUS_TUBE ".ServiceName");
}
else
{
goto failed;
}
if (service == NULL)
goto failed;
priv->bus_name = empathy_tube_handler_build_bus_name (type, service);
priv->object_path = empathy_tube_handler_build_object_path (type, service);
priv->service = g_strdup (service);
DEBUG ("Look for tube handler %s\n", priv->bus_name);
tp_cli_dbus_daemon_call_name_has_owner (priv->dbus, -1, priv->bus_name,
empathy_tube_dispatch_name_has_owner_cb, NULL, NULL, G_OBJECT (self));
return;
failed:
empathy_tube_dispatch_set_ability (self,
EMPATHY_TUBE_DISPATCHABILITY_IMPOSSIBLE);
}
static void
chatroom_manager_observe_channel_cb (EmpathyDispatcher *dispatcher,
EmpathyDispatchOperation *operation, gpointer manager)
{
EmpathyChatroomManagerPriv *priv = GET_PRIV (manager);
EmpathyChatroom *chatroom;
TpChannel *channel;
EmpathyTpChat *chat;
const gchar *roomname;
GQuark channel_type;
TpHandleType handle_type;
EmpathyAccount *account;
TpConnection *connection;
channel_type = empathy_dispatch_operation_get_channel_type_id (operation);
/* Observe Text channels to rooms only */
if (channel_type != TP_IFACE_QUARK_CHANNEL_TYPE_TEXT)
return;
channel = empathy_dispatch_operation_get_channel (operation);
tp_channel_get_handle (channel, &handle_type);
if (handle_type != TP_HANDLE_TYPE_ROOM)
return;
chat = EMPATHY_TP_CHAT (
empathy_dispatch_operation_get_channel_wrapper (operation));
connection = empathy_tp_chat_get_connection (chat);
account = empathy_account_manager_get_account_for_connection (
priv->account_manager, connection);
roomname = empathy_tp_chat_get_id (chat);
chatroom = empathy_chatroom_manager_find (manager, account, roomname);
if (chatroom == NULL)
{
chatroom = empathy_chatroom_new_full (account, roomname, roomname,
FALSE);
empathy_chatroom_set_tp_chat (chatroom, chat);
empathy_chatroom_manager_add (manager, chatroom);
g_object_unref (chatroom);
}
else
{
empathy_chatroom_set_tp_chat (chatroom, chat);
}
/* A TpChat is always destroyed as it only gets unreffed after the channel
* has been invalidated in the dispatcher.. */
g_signal_connect (chat, "destroy",
G_CALLBACK (chatroom_manager_chat_destroyed_cb),
manager);
}
void
empathy_tube_dispatch_handle (EmpathyTubeDispatch *tube_dispatch)
{
EmpathyTubeDispatchPriv *priv = GET_PRIV (tube_dispatch);
/* Keep ourselves alive untill the dispatching is finished */
g_object_ref (tube_dispatch);
/* If we can't claim it, don't do anything */
if (!empathy_dispatch_operation_claim (priv->operation))
goto done;
if (priv->dispatchability != EMPATHY_TUBE_DISPATCHABILITY_POSSIBLE)
{
gchar *msg;
TpChannel *channel;
channel = empathy_dispatch_operation_get_channel (priv->operation);
msg = g_strdup_printf (
_("An invitation was offered for service %s, but you don't have the "
"needed application to handle it"), priv->service);
empathy_tube_dispatch_show_error (tube_dispatch, msg);
g_free (msg);
tp_cli_channel_call_close (channel, -1, NULL, NULL, NULL, NULL);
goto done;
}
else
{
empathy_tube_do_dispatch (tube_dispatch);
}
return;
done:
g_object_unref (tube_dispatch);
}
static void
empathy_tube_do_dispatch (EmpathyTubeDispatch *self)
{
EmpathyTubeDispatchPriv *priv = GET_PRIV (self);
TpChannel *channel;
TpProxy *connection;
TpProxy *thandler;
gchar *object_path;
guint handle_type;
guint handle;
channel = empathy_dispatch_operation_get_channel (priv->operation);
/* Create the proxy for the tube handler */
thandler = g_object_new (TP_TYPE_PROXY,
"dbus-connection", tp_get_bus (),
"bus-name", priv->bus_name,
"object-path", priv->object_path,
NULL);
tp_proxy_add_interface_by_id (thandler, EMP_IFACE_QUARK_TUBE_HANDLER);
/* Give the tube to the handler */
g_object_get (channel,
"connection", &connection,
"object-path", &object_path,
"handle_type", &handle_type,
"handle", &handle,
NULL);
emp_cli_tube_handler_call_handle_tube (thandler, -1,
connection->bus_name, connection->object_path,
object_path, handle_type, handle,
empathy_tube_dispatch_handle_tube_cb, NULL, NULL, G_OBJECT (self));
g_object_unref (thandler);
g_object_unref (connection);
g_free (object_path);
}
