static void create_text_channel (TpAccount *account, TpHandleType target_handle_type, const gchar *target_id, gboolean sms_channel, gint64 timestamp, GAsyncReadyCallback callback, gpointer user_data) { GHashTable *request; TpAccountChannelRequest *req; request = tp_asv_new ( TP_PROP_CHANNEL_CHANNEL_TYPE, G_TYPE_STRING, TP_IFACE_CHANNEL_TYPE_TEXT, TP_PROP_CHANNEL_TARGET_HANDLE_TYPE, G_TYPE_UINT, target_handle_type, TP_PROP_CHANNEL_TARGET_ID, G_TYPE_STRING, target_id, NULL); if (sms_channel) tp_asv_set_boolean (request, TP_PROP_CHANNEL_INTERFACE_SMS_SMS_CHANNEL, TRUE); req = tp_account_channel_request_new (account, request, timestamp); tp_account_channel_request_set_delegate_to_preferred_handler (req, TRUE); tp_account_channel_request_ensure_channel_async (req, EMPATHY_CHAT_BUS_NAME, NULL, callback ? callback : ensure_text_channel_cb, user_data); g_hash_table_unref (request); g_object_unref (req); }
/** * 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 empathy_share_my_desktop_share_with_contact (EmpathyContact *contact) { TpAccountChannelRequest *req; GHashTable *request; TpContact *tp_contact; tp_contact = empathy_contact_get_tp_contact (contact); DEBUG ("Creation of ShareMyDesktop"); if (!TP_IS_CONTACT (tp_contact)) { DEBUG ("It's not a tp contact"); return; } 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_HANDLE, G_TYPE_UINT, tp_contact_get_handle (tp_contact), TP_PROP_CHANNEL_TYPE_STREAM_TUBE_SERVICE, G_TYPE_STRING, "rfb", NULL); req = tp_account_channel_request_new (empathy_contact_get_account (contact), request, TP_USER_ACTION_TIME_CURRENT_TIME); tp_account_channel_request_create_channel_async (req, NULL, NULL, create_tube_channel_cb, NULL); g_object_unref (req); g_hash_table_unref (request); }
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; }