/**
* tp_yts_client_request_channel_async:
* @self: The client object
* @target_contact: The contact to open the channel to
* @target_service: The Ytstenut service to open the channel to
* @request_type: The type of request to send
* @request_attributes: A table of Ytstenut attributes, or %NULL
* @request_body: A UTF-8 encoded XML Ytstenut message, or %NULL
* @cancellable: Used to cancel this operation
* @callback: Called when the operation completes
* @user_data: Data to pass to the callback
*
* Start an operation to request a new Ytstenut channel.
*
* The new channel will have a Ytstenut request message ready to send. The
* message is assembled from the arguments specified here.
*/
void
tp_yts_client_request_channel_async (TpYtsClient *self,
TpContact *target_contact,
const gchar *target_service,
TpYtsRequestType request_type,
GHashTable *request_attributes,
const gchar *request_body,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
TpAccountChannelRequest *channel_request;
GSimpleAsyncResult *res;
GHashTable *request_properties;
TpHandle target_handle;
g_return_if_fail (TP_IS_YTS_CLIENT (self));
g_return_if_fail (TP_IS_CONTACT (target_contact));
g_return_if_fail (tp_dbus_check_valid_interface_name (target_service, NULL));
if (!request_body)
request_body = "";
g_return_if_fail (g_utf8_validate (request_body, -1, NULL));
target_handle = tp_contact_get_handle (target_contact);
g_return_if_fail (target_handle);
res = g_simple_async_result_new (G_OBJECT (self), callback, user_data,
tp_yts_client_request_channel_async);
request_properties = tp_asv_new (
TP_IFACE_CHANNEL ".ChannelType", G_TYPE_STRING, TP_YTS_IFACE_CHANNEL,
TP_IFACE_CHANNEL ".TargetHandleType", G_TYPE_UINT, TP_HANDLE_TYPE_CONTACT,
TP_IFACE_CHANNEL ".TargetHandle", G_TYPE_UINT, target_handle,
TP_YTS_IFACE_CHANNEL ".TargetService", G_TYPE_STRING, target_service,
TP_YTS_IFACE_CHANNEL ".InitiatorService", G_TYPE_STRING,
self->priv->service_name,
TP_YTS_IFACE_CHANNEL ".RequestType", G_TYPE_UINT, request_type,
TP_YTS_IFACE_CHANNEL ".RequestBody", G_TYPE_STRING, request_body,
NULL);
if (request_attributes)
tp_asv_set_boxed (request_properties,
TP_YTS_IFACE_CHANNEL ".RequestAttributes",
TP_HASH_TYPE_STRING_STRING_MAP, request_attributes);
channel_request = tp_account_channel_request_new (self->priv->account,
request_properties, 0);
tp_account_channel_request_create_and_handle_channel_async (channel_request,
cancellable, on_channel_request_create_and_handle_channel_returned, res);
g_hash_table_unref (request_properties);
}
void
empathy_call_handler_start_call (EmpathyCallHandler *handler,
gint64 timestamp)
{
EmpathyCallHandlerPriv *priv = GET_PRIV (handler);
TpAccountChannelRequest *req;
TpAccount *account;
GHashTable *request;
if (priv->call != NULL)
{
empathy_call_handler_start_tpfs (handler);
if (tp_channel_get_requested (TP_CHANNEL (priv->call)))
{
/* accept outgoing channels immediately */
tp_call_channel_accept_async (priv->call,
on_call_accepted_cb, NULL);
}
else
{
/* accepting incoming channels when they are INITIALISED */
if (tp_call_channel_get_state (priv->call, NULL, NULL, NULL) ==
TP_CALL_STATE_INITIALISED)
tp_call_channel_accept_async (priv->call,
on_call_accepted_cb, NULL);
else
priv->accept_when_initialised = TRUE;
}
return;
}
/* No TpCallChannel (we are redialing). Request a new call channel */
g_assert (priv->contact != NULL);
account = empathy_contact_get_account (priv->contact);
request = empathy_call_create_call_request (
empathy_contact_get_id (priv->contact),
priv->initial_audio, priv->initial_video);
req = tp_account_channel_request_new (account, request, timestamp);
tp_account_channel_request_create_and_handle_channel_async (req, NULL,
empathy_call_handler_request_cb, handler);
g_object_unref (req);
g_hash_table_unref (request);
}
static void
ft_handler_push_to_dispatcher (EmpathyFTHandler *handler)
{
EmpathyFTHandlerPriv *priv = handler->priv;
TpAccountChannelRequest *req;
DEBUG ("Pushing request to the dispatcher");
req = tp_account_channel_request_new (priv->account, priv->request,
priv->user_action_time);
tp_account_channel_request_create_and_handle_channel_async (req, NULL,
ft_handler_create_channel_cb, handler);
g_object_unref (req);
}
static void
ft_handler_push_to_dispatcher (EmpathyFTHandler *handler)
{
TpAccount *account;
EmpathyFTHandlerPriv *priv = GET_PRIV (handler);
TpAccountChannelRequest *req;
DEBUG ("Pushing request to the dispatcher");
account = empathy_contact_get_account (priv->contact);
req = tp_account_channel_request_new (account, priv->request,
TP_USER_ACTION_TIME_NOT_USER_ACTION);
tp_account_channel_request_create_and_handle_channel_async (req, NULL,
ft_handler_create_channel_cb, handler);
g_object_unref (req);
}
void
_client_create_tube_async (TpAccount *account,
const gchar *contact_id,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
CreateTubeData *data;
GHashTable *request;
TpAccountChannelRequest *acr;
simple = g_simple_async_result_new (NULL, callback, user_data,
_client_create_tube_finish);
data = g_slice_new0 (CreateTubeData);
g_simple_async_result_set_op_res_gpointer (simple, data,
(GDestroyNotify) create_tube_data_free);
request = tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
TP_IFACE_CHANNEL_TYPE_STREAM_TUBE,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT,
TP_HANDLE_TYPE_CONTACT,
TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING,
contact_id,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE, G_TYPE_STRING,
TUBE_SERVICE,
NULL);
acr = tp_account_channel_request_new (account, request, G_MAXINT64);
tp_account_channel_request_create_and_handle_channel_async (acr,
NULL, create_channel_cb, simple);
g_hash_table_unref (request);
g_object_unref (acr);
}
void
_client_create_tube_async (const gchar *account_path,
const gchar *contact_id,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GSimpleAsyncResult *simple;
CreateTubeData *data;
GHashTable *request;
TpDBusDaemon *dbus;
TpAccount *account = NULL;
TpAccountChannelRequest *acr;
GError *error = NULL;
if (g_cancellable_is_cancelled (cancellable))
{
g_simple_async_report_error_in_idle (NULL, callback,
user_data, G_IO_ERROR, G_IO_ERROR_CANCELLED,
"Operation has been cancelled");
return;
}
dbus = tp_dbus_daemon_dup (&error);
if (dbus != NULL)
account = tp_account_new (dbus, account_path, &error);
if (account == NULL)
{
g_simple_async_report_gerror_in_idle (NULL, callback, user_data, error);
g_clear_error (&error);
tp_clear_object (&dbus);
return;
}
simple = g_simple_async_result_new (NULL, callback, user_data,
_client_create_tube_finish);
data = g_slice_new0 (CreateTubeData);
data->op_cancellable = g_cancellable_new ();
if (cancellable != NULL)
{
data->global_cancellable = g_object_ref (cancellable);
data->cancelled_id = g_cancellable_connect (data->global_cancellable,
G_CALLBACK (create_tube_cancelled_cb), simple, NULL);
}
g_simple_async_result_set_op_res_gpointer (simple, data,
(GDestroyNotify) create_tube_data_free);
request = tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING,
TP_IFACE_CHANNEL_TYPE_STREAM_TUBE,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT,
TP_HANDLE_TYPE_CONTACT,
TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING,
contact_id,
TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE, G_TYPE_STRING,
TUBE_SERVICE,
NULL);
acr = tp_account_channel_request_new (account, request, G_MAXINT64);
tp_account_channel_request_create_and_handle_channel_async (acr,
data->op_cancellable, create_channel_cb, simple);
g_hash_table_unref (request);
g_object_unref (dbus);
g_object_unref (account);
g_object_unref (acr);
}
bool TelepathyAccountHandler::startSession(PD_Document* pDoc, const std::vector<std::string>& vAcl, AbiCollab** pSession)
{
UT_DEBUGMSG(("TelepathyAccountHandler::startSession()\n"));
UT_return_val_if_fail(pDoc, false);
AbiCollabSessionManager* pManager = AbiCollabSessionManager::getManager();
UT_return_val_if_fail(pManager, false);
// generate a unique session id to use
UT_UTF8String sSessionId;
UT_UUID* pUUID = XAP_App::getApp()->getUUIDGenerator()->createUUID();
pUUID->toString(sSessionId);
DELETEP(pUUID);
// start the session already, while we'll continue to setup a
// MUC asynchronously below
// TODO: we should fill in the in the master buddy descriptor so we can do
// proper author coloring and session takeover; we can't do that however, since
// the following bugs needs to be fixed first:
//
// https://bugs.freedesktop.org/show_bug.cgi?id=37631
*pSession = pManager->startSession(pDoc, sSessionId, this, true, NULL, "");
// create a chatroom to hold the session information
TelepathyChatroomPtr pChatroom = boost::shared_ptr<TelepathyChatroom>(new TelepathyChatroom(this, NULL, pDoc, sSessionId));
m_chatrooms.push_back(pChatroom);
// add the buddies in the acl list to the room invitee list
/*
std::vector<TelepathyBuddyPtr> buddies = _getBuddies(vAcl);
gchar** invitee_ids = reinterpret_cast<gchar**>(malloc(sizeof(gchar*) * vAcl.size()+1));
int i = 0;
for (std::vector<TelepathyBuddyPtr>::iterator it = buddies.begin(); it != buddies.end(); it++)
{
UT_continue_if_fail(*it);
invitee_ids[i] = strdup(tp_contact_get_identifier((*it)->getContact()));
UT_DEBUGMSG(("Added %s to the invite list\n", invitee_ids[i]));
}
invitee_ids[vAcl.size()] = NULL;
*/
_inviteBuddies(pChatroom, vAcl); // use the above code when TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS is usable
// a quick hack to determine the account to offer the request on
TpAccountManager* manager = tp_account_manager_dup();
UT_return_val_if_fail(manager, false);
GList* accounts = tp_account_manager_get_valid_accounts(manager);
UT_return_val_if_fail(accounts, false);
// TODO: make sure the accounts are ready
TpAccount* selected_account = NULL;
for (GList* account = accounts; account; account = account->next)
{
selected_account = TP_ACCOUNT(account->data);
break;
}
UT_return_val_if_fail(selected_account, false);
g_list_free(accounts);
// determine the room target id
std::string target_id = sSessionId.utf8_str();
std::string conference_server = getProperty("conference_server");
if (conference_server != "")
target_id += "@" + conference_server;
UT_DEBUGMSG(("Using room target ID: %s\n", target_id.c_str()));
// create a anonymous MUC channel request
GHashTable* props = tp_asv_new (
TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_DBUS_TUBE,
TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, TP_TYPE_HANDLE, TP_HANDLE_TYPE_ROOM,
TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING, target_id.c_str(),
TP_PROP_CHANNEL_TYPE_DBUS_TUBE_SERVICE_NAME, G_TYPE_STRING, INTERFACE,
/*
* Enable TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS if you want to use
* anonymous MUCs. We can't use it right now, anonymous DBUS_TUBE MUCs are not implemented yet.
* Remove the HANDLE_TYPE and TARGET_ID when you enable this.
*
* See https://bugs.freedesktop.org/show_bug.cgi?id=37630 for details.
*
* TP_PROP_CHANNEL_INTERFACE_CONFERENCE_INITIAL_INVITEE_IDS, G_TYPE_STRV, invitee_ids,
*/
NULL);
TpAccountChannelRequest * channel_request = tp_account_channel_request_new(selected_account, props, TP_USER_ACTION_TIME_NOT_USER_ACTION);
UT_return_val_if_fail(channel_request, false);
g_hash_table_destroy (props);
// TODO: free invitee_ids
tp_account_channel_request_create_and_handle_channel_async(channel_request, NULL, muc_channel_ready_cb, pChatroom.get());
return true;
}
