static void
request_connection_cb (TpConnectionManager *cm,
const char *bus_name,
const char *object_path,
const GError *in_error,
gpointer user_data,
GObject *weak_object)
{
char **argv = (char **) user_data;
GError *error = NULL;
if (in_error) g_error ("%s", in_error->message);
conn = tp_connection_new (bus_daemon, bus_name, object_path, &error);
if (error) g_error ("%s", error->message);
tp_connection_call_when_ready (conn, conn_ready, argv);
tp_cli_connection_connect_to_status_changed (conn, status_changed_cb,
NULL, NULL, NULL, &error);
handle_error (error);
/* initiate the connection */
tp_cli_connection_call_connect (conn, -1, NULL, NULL, NULL, NULL);
}
static void
setup (Test *test,
gconstpointer data)
{
GError *error = NULL;
GQuark features[] = { TP_CONNECTION_FEATURE_CONNECTED, 0 };
tp_debug_set_flags ("all");
test->dbus = tp_tests_dbus_daemon_dup_or_die ();
test->mainloop = g_main_loop_new (NULL, FALSE);
test->error = NULL;
test->client_libdbus = dbus_bus_get_private (DBUS_BUS_STARTER, NULL);
g_assert (test->client_libdbus != NULL);
dbus_connection_setup_with_g_main (test->client_libdbus, NULL);
dbus_connection_set_exit_on_disconnect (test->client_libdbus, FALSE);
test->client_dbusglib = dbus_connection_get_g_connection (
test->client_libdbus);
dbus_g_connection_ref (test->client_dbusglib);
test->client_bus = tp_dbus_daemon_new (test->client_dbusglib);
g_assert (test->client_bus != NULL);
test->service_conn = tp_tests_object_new_static_class (
EXAMPLE_TYPE_CONTACT_LIST_CONNECTION,
"account", "*****@*****.**",
"protocol", "simple-protocol",
NULL);
test->service_conn_as_base = TP_BASE_CONNECTION (test->service_conn);
g_assert (test->service_conn != NULL);
g_assert (test->service_conn_as_base != NULL);
g_assert (tp_base_connection_register (test->service_conn_as_base, "simple",
&test->conn_name, &test->conn_path, &error));
g_assert_no_error (error);
test->cwr_ready = FALSE;
test->cwr_error = NULL;
test->conn = tp_connection_new (test->client_bus, test->conn_name,
test->conn_path, &error);
g_assert (test->conn != NULL);
g_assert_no_error (error);
tp_cli_connection_call_connect (test->conn, -1, NULL, NULL, NULL, NULL);
g_assert (!tp_proxy_is_prepared (test->conn, TP_CONNECTION_FEATURE_CORE));
g_assert (!tp_proxy_is_prepared (test->conn,
TP_CONNECTION_FEATURE_CONNECTED));
g_assert (!tp_proxy_is_prepared (test->conn, TP_CONNECTION_FEATURE_BALANCE));
tp_tests_proxy_run_until_prepared (test->conn, features);
}
static void
list_connection_names_cb (const gchar * const *bus_names,
gsize n,
const gchar * const * cms,
const gchar * const * protocols,
const GError *error,
gpointer user_data,
GObject * /*unused*/)
{
UT_DEBUGMSG(("list_connection_names_cb()\n"));
TelepathyAccountHandler* pHandler = reinterpret_cast<TelepathyAccountHandler*>(user_data);
UT_return_if_fail(pHandler);
if (error != NULL)
{
UT_DEBUGMSG(("List connectiones failed: %s", error->message));
UT_ASSERT_HARMLESS(UT_SHOULD_NOT_HAPPEN);
return;
}
TpDBusDaemon* dbus = tp_dbus_daemon_dup(NULL);
UT_return_if_fail(dbus);
UT_DEBUGMSG(("Got %d connections:\n", (int)n));
for (UT_uint32 i = 0; i < n; i++)
{
UT_DEBUGMSG(("%d: Bus name %s, connection manager %s, protocol %s\n", i+1, bus_names[i], cms[i], protocols[i]));
TpConnection* connection = tp_connection_new (dbus, bus_names[i], NULL, NULL);
UT_continue_if_fail(connection);
TpCapabilities* caps = tp_connection_get_capabilities(connection);
if (!caps)
{
GQuark features[] = { TP_CONNECTION_FEATURE_CAPABILITIES, 0 };
tp_proxy_prepare_async(connection, features, prepare_connection_cb, pHandler);
}
else
{
validate_connection(connection, pHandler);
}
}
g_object_unref(dbus);
}
static void
_empathy_account_set_connection (EmpathyAccount *account,
const gchar *path)
{
EmpathyAccountPriv *priv = GET_PRIV (account);
if (priv->connection != NULL)
{
const gchar *current;
current = tp_proxy_get_object_path (priv->connection);
if (!tp_strdiff (current, path))
return;
}
empathy_account_free_connection (account);
if (tp_strdiff ("/", path))
{
GError *error = NULL;
priv->connection = tp_connection_new (priv->dbus, NULL, path, &error);
if (priv->connection == NULL)
{
DEBUG ("Failed to create a new TpConnection: %s",
error->message);
g_error_free (error);
}
else
{
priv->connection_invalidated_id = g_signal_connect (priv->connection,
"invalidated",
G_CALLBACK (_empathy_account_connection_invalidated_cb), account);
DEBUG ("Readying connection for %s", priv->unique_name);
/* notify a change in the connection property when it's ready */
tp_connection_call_when_ready (priv->connection,
empathy_account_connection_ready_cb, account);
}
}
g_object_notify (G_OBJECT (account), "connection");
}
static void remmina_tp_channel_handler_account_ready(GObject *account, GAsyncResult *res, gpointer user_data)
{
RemminaTpChannelHandler *chandler = (RemminaTpChannelHandler *) user_data;
GError *error = NULL;
if (!tp_account_prepare_finish(TP_ACCOUNT(account), res, &error))
{
g_print("tp_account_prepare_finish: %s\n", error->message);
remmina_tp_channel_handler_free(chandler);
return;
}
chandler->connection = tp_connection_new(chandler->bus, NULL, chandler->connection_path, &error);
if (chandler->connection == NULL)
{
g_print("tp_connection_new: %s\n", error->message);
remmina_tp_channel_handler_free(chandler);
return;
}
tp_connection_call_when_ready(chandler->connection, remmina_tp_channel_handler_connection_ready, chandler);
}
static void
teardown (Test *test,
gconstpointer data G_GNUC_UNUSED)
{
TpConnection *conn;
GError *error = NULL;
g_clear_error (&test->error);
tp_clear_pointer (&test->mainloop, g_main_loop_unref);
tp_clear_object (&test->conn);
/* disconnect the connection so we don't leak it */
conn = tp_connection_new (test->dbus, test->conn_name, test->conn_path,
&error);
g_assert (conn != NULL);
g_assert_no_error (error);
tp_tests_connection_assert_disconnect_succeeds (conn);
g_assert (!tp_connection_run_until_ready (conn, FALSE, &error, NULL));
g_assert_error (error, TP_ERROR, TP_ERROR_CANCELLED);
g_clear_error (&error);
test->service_conn_as_base = NULL;
g_object_unref (test->service_conn);
g_free (test->conn_name);
g_free (test->conn_path);
g_object_unref (test->dbus);
test->dbus = NULL;
g_object_unref (test->client_bus);
test->client_bus = NULL;
dbus_g_connection_unref (test->client_dbusglib);
dbus_connection_close (test->client_libdbus);
dbus_connection_unref (test->client_libdbus);
}
