static void
on_channel_request_create_and_handle_channel_returned (GObject *source,
GAsyncResult *result, gpointer user_data)
{
GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data);
TpAccountChannelRequest *channel_request =
TP_ACCOUNT_CHANNEL_REQUEST (source);
TpChannel *channel;
GError *error = NULL;
channel = tp_account_channel_request_create_and_handle_channel_finish (
channel_request, result, NULL, &error);
if (error == NULL)
{
g_simple_async_result_set_op_res_gpointer (res, channel, g_object_unref);
}
else
{
g_simple_async_result_set_from_error (res, error);
g_clear_error (&error);
}
g_simple_async_result_complete (res);
g_object_unref (channel_request);
}
void muc_channel_ready_cb(GObject* source_object, GAsyncResult* result, gpointer user_data)
{
UT_DEBUGMSG(("muc_channel_ready_cb()\n"));
TelepathyChatroom* pChatroom = reinterpret_cast<TelepathyChatroom*>(user_data);
UT_return_if_fail(pChatroom);
TelepathyAccountHandler* pHandler = pChatroom->getHandler();
UT_return_if_fail(pHandler);
GError* error = NULL;
TpChannel * channel = tp_account_channel_request_create_and_handle_channel_finish(
TP_ACCOUNT_CHANNEL_REQUEST(source_object), result, NULL, &error);
if (!channel)
{
UT_DEBUGMSG(("Error creating MUC channel: %s\n", error->message));
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return;
}
// store the channel for safe-keeping
pChatroom->setChannel(channel);
// offer the tube to the members we want to invite into the room
// TODO: drop this call when TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS is usable
pChatroom->offerTube();
}
static void
channel_request_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
TpAccountChannelRequest *req = TP_ACCOUNT_CHANNEL_REQUEST (source);
ChVisitor *self = (ChVisitor*) user_data;
GPtrArray *channels;
TpChannel *channel;
GError *error = NULL;
TpHandleChannelsContext *ctx;
if (!tp_account_channel_request_ensure_and_handle_channel_finish (req, result, &ctx, &error)) {
g_printerr ("error opening channel: %s\n", error->message);
ch_visitor_decref (self);
return;
}
g_object_get (ctx, "channels", &channels, NULL);
for (unsigned int i = 0; i < channels->len; i++) {
channel = g_ptr_array_index (channels, i);
if (self->visit_channel) {
self->visit_channel (self, channel);
}
}
ch_visitor_decref (self);
}
static void
ensure_text_channel_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
if (!tp_account_channel_request_ensure_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (source), result, &error))
{
DEBUG ("Failed to ensure text channel: %s", error->message);
g_error_free (error);
}
}
static void
create_call_channel_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
if (tp_account_channel_request_create_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (source), result, &error))
return;
DEBUG ("Failed to create Call channel: %s", error->message);
show_call_error (error);
}
static void
create_channel_cb (GObject *acr,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
CreateTubeData *data;
GError *error = NULL;
data = g_simple_async_result_get_op_res_gpointer (simple);
data->channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (acr), res, NULL, &error);
if (!TP_IS_STREAM_TUBE_CHANNEL (data->channel))
{
tp_clear_object (&data->channel);
if (error == NULL)
error = g_error_new_literal (TP_ERRORS, TP_ERROR_NOT_IMPLEMENTED,
"Not supported channel type");
create_tube_complete (simple, error);
g_clear_error (&error);
g_object_unref (simple);
return;
}
g_signal_connect (data->channel, "invalidated",
G_CALLBACK (create_tube_channel_invalidated_cb), simple);
g_signal_connect_data (data->channel, "incoming",
G_CALLBACK (create_tube_incoming_cb),
g_object_ref (simple), (GClosureNotify) g_object_unref, 0);
tp_stream_tube_channel_offer_async (TP_STREAM_TUBE_CHANNEL (data->channel),
NULL, create_tube_offer_cb, g_object_ref (simple));
g_object_unref (simple);
}
static void
ft_handler_create_channel_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyFTHandler *handler = user_data;
EmpathyFTHandlerPriv *priv = handler->priv;
GError *error = NULL;
TpChannel *channel;
DEBUG ("Dispatcher create channel CB");
channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (source), result, NULL, &error);
if (channel == NULL)
DEBUG ("Failed to request FT channel: %s", error->message);
else
g_cancellable_set_error_if_cancelled (priv->cancellable, &error);
if (error != NULL)
{
emit_error_signal (handler, error);
g_clear_object (&channel);
g_error_free (error);
return;
}
priv->channel = TP_FILE_TRANSFER_CHANNEL (channel);
tp_g_signal_connect_object (priv->channel, "notify::state",
G_CALLBACK (ft_transfer_state_cb), handler, 0);
tp_g_signal_connect_object (priv->channel, "notify::transferred-bytes",
G_CALLBACK (ft_transfer_transferred_bytes_cb), handler, 0);
tp_file_transfer_channel_provide_file_async (priv->channel, priv->gfile,
ft_transfer_provide_cb, handler);
}
static void
ft_handler_create_channel_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyFTHandler *handler = user_data;
EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
GError *error = NULL;
TpChannel *channel = NULL;
DEBUG ("Dispatcher create channel CB");
channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (source), result, NULL, &error);
if (channel == NULL)
DEBUG ("Failed to request FT channel: %s", error->message);
else
g_cancellable_set_error_if_cancelled (priv->cancellable, &error);
if (error != NULL)
{
emit_error_signal (handler, error);
g_error_free (error);
goto out;
}
priv->tpfile = empathy_tp_file_new (channel);
empathy_tp_file_offer (priv->tpfile, priv->gfile, priv->cancellable,
ft_transfer_progress_callback, handler,
ft_transfer_operation_callback, handler);
out:
tp_clear_object (&channel);
}
static void
empathy_call_handler_request_cb (GObject *source,
GAsyncResult *result,
gpointer user_data)
{
EmpathyCallHandler *self = EMPATHY_CALL_HANDLER (user_data);
EmpathyCallHandlerPriv *priv = GET_PRIV (self);
TpChannel *channel;
GError *error = NULL;
TpAccountChannelRequest *req = TP_ACCOUNT_CHANNEL_REQUEST (source);
channel = tp_account_channel_request_create_and_handle_channel_finish (req,
result, NULL, &error);
if (channel == NULL)
{
DEBUG ("Failed to create the channel: %s", error->message);
g_error_free (error);
return;
}
if (!TP_IS_CALL_CHANNEL (channel))
{
DEBUG ("The channel is not a Call channel!");
return;
}
priv->call = TP_CALL_CHANNEL (channel);
tp_g_signal_connect_object (priv->call, "state-changed",
G_CALLBACK (on_call_state_changed_cb), self, 0);
tp_g_signal_connect_object (priv->call, "invalidated",
G_CALLBACK (on_call_invalidated_cb), self, 0);
g_object_notify (G_OBJECT (self), "call-channel");
empathy_call_handler_start_tpfs (self);
tp_call_channel_accept_async (priv->call, on_call_accepted_cb, NULL);
}
static void
create_channel_cb (GObject *acr,
GAsyncResult *res,
gpointer user_data)
{
GSimpleAsyncResult *simple = user_data;
CreateTubeData *data;
GSocketListener *listener = NULL;
gchar *dir;
GSocket *socket = NULL;
GSocketAddress *socket_address = NULL;
GValue *address;
GHashTable *parameters;
GError *error = NULL;
data = g_simple_async_result_get_op_res_gpointer (simple);
if (g_cancellable_is_cancelled (data->op_cancellable))
{
g_object_unref (simple);
return;
}
data->channel = tp_account_channel_request_create_and_handle_channel_finish (
TP_ACCOUNT_CHANNEL_REQUEST (acr), res, NULL, &error);
if (data->channel == NULL)
goto OUT;
data->invalidated_id = g_signal_connect (data->channel, "invalidated",
G_CALLBACK (create_tube_channel_invalidated_cb), simple);
/* We are client side, but we have to offer a socket... So we offer an unix
* socket on which the service side can connect. We also create an IPv4 socket
* on which the ssh client can connect. When both sockets are connected,
* we can forward all communications between them. */
listener = g_socket_listener_new ();
/* Create temporary file for our unix socket */
dir = g_build_filename (g_get_tmp_dir (), "telepathy-ssh-XXXXXX", NULL);
dir = mkdtemp (dir);
data->unix_path = g_build_filename (dir, "unix-socket", NULL);
g_free (dir);
/* Create the unix socket, and listen for connection on it */
socket = g_socket_new (G_SOCKET_FAMILY_UNIX, G_SOCKET_TYPE_STREAM,
G_SOCKET_PROTOCOL_DEFAULT, &error);
if (socket == NULL)
goto OUT;
socket_address = g_unix_socket_address_new (data->unix_path);
if (!g_socket_bind (socket, socket_address, FALSE, &error))
goto OUT;
if (!g_socket_listen (socket, &error))
goto OUT;
if (!g_socket_listener_add_socket (listener, socket, NULL, &error))
goto OUT;
g_socket_listener_accept_async (listener, data->op_cancellable,
create_tube_socket_connected_cb, g_object_ref (simple));
/* Offer the socket */
address = tp_address_variant_from_g_socket_address (socket_address,
TP_SOCKET_ADDRESS_TYPE_UNIX, &error);
if (address == NULL)
goto OUT;
parameters = g_hash_table_new (NULL, NULL);
data->offer_call = tp_cli_channel_type_stream_tube_call_offer (data->channel,
-1,
TP_SOCKET_ADDRESS_TYPE_UNIX, address,
TP_SOCKET_ACCESS_CONTROL_LOCALHOST, parameters,
create_tube_offer_cb, g_object_ref (simple), g_object_unref, NULL);
tp_g_value_slice_free (address);
g_hash_table_unref (parameters);
OUT:
if (error != NULL)
create_tube_complete (simple, error);
tp_clear_object (&listener);
tp_clear_object (&socket);
tp_clear_object (&socket_address);
g_clear_error (&error);
g_object_unref (simple);
}
