static void mcd_client_registry_dispose (GObject *object) { McdClientRegistry *self = MCD_CLIENT_REGISTRY (object); void (*chain_up) (GObject *) = G_OBJECT_CLASS (_mcd_client_registry_parent_class)->dispose; if (self->priv->dbus_daemon != NULL) { DBusGConnection *gconn = tp_proxy_get_dbus_connection (self->priv->dbus_daemon); DBusConnection *dconn = dbus_g_connection_get_connection (gconn); dbus_connection_remove_filter (dconn, mcd_client_registry_name_owner_filter, self); } tp_clear_object (&self->priv->dbus_daemon); if (self->priv->clients != NULL) { g_hash_table_foreach (self->priv->clients, mcd_client_registry_disconnect_client_signals, self); } tp_clear_pointer (&self->priv->clients, g_hash_table_unref); if (chain_up != NULL) chain_up (object); }
static void on_connection_future_ensure_sidecar_returned (GObject *source_object, GAsyncResult *result, gpointer user_data) { GSimpleAsyncResult *res = G_SIMPLE_ASYNC_RESULT (user_data); gchar *object_path; GError *error = NULL; g_return_if_fail (TP_IS_CONNECTION (source_object)); object_path = _tp_yts_connection_future_ensure_sidecar_finish ( TP_CONNECTION (source_object), result, NULL, &error); if (error != NULL) { g_simple_async_result_set_from_error (res, error); g_clear_error (&error); g_simple_async_result_complete_in_idle (res); g_object_unref (res); return; } g_async_initable_new_async (TP_TYPE_YTS_STATUS, G_PRIORITY_DEFAULT, NULL, on_status_new_returned, res, "dbus-daemon", tp_proxy_get_dbus_daemon (source_object), "dbus-connection", tp_proxy_get_dbus_connection (source_object), "bus-name", tp_proxy_get_bus_name (source_object), "object-path", object_path, NULL); g_free (object_path); }
static void on_content_added_cb (TpProxy *proxy, const gchar *content_path, gpointer user_data, GObject *weak_object) { TpyCallChannel *self = TPY_CALL_CHANNEL (proxy); TpyCallContent *content; DEBUG ("Content added: %s", content_path); content = g_object_new (TPY_TYPE_CALL_CONTENT, "bus-name", tp_proxy_get_bus_name (self), "dbus-daemon", tp_proxy_get_dbus_daemon (self), "dbus-connection", tp_proxy_get_dbus_connection (self), "object-path", content_path, NULL); if (content == NULL) { g_warning ("Could not create a CallContent for path %s", content_path); return; } g_ptr_array_add (self->priv->contents, content); tp_g_signal_connect_object (content, "notify::ready", G_CALLBACK (on_content_ready_cb), self, 0); g_signal_emit (self, _signals[CONTENT_ADDED], 0, content); }
static gboolean billy_idle (gpointer user_data) { DBusMessage *reply = user_data; DBusConnection *connection = dbus_g_connection_get_connection ( tp_proxy_get_dbus_connection (bus_daemon)); if (!dbus_connection_send (connection, reply, NULL)) g_error ("Out of memory"); return FALSE; }
static void empathy_presence_manager_init (EmpathyPresenceManager *self) { TpDBusDaemon *dbus; self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, EMPATHY_TYPE_PRESENCE_MANAGER, EmpathyPresenceManagerPrivate); self->priv->is_idle = FALSE; self->priv->manager = tp_account_manager_dup (); tp_account_manager_prepare_async (self->priv->manager, NULL, account_manager_ready_cb, self); tp_g_signal_connect_object (self->priv->manager, "most-available-presence-changed", G_CALLBACK (most_available_presence_changed), self, 0); dbus = tp_dbus_daemon_dup (NULL); self->priv->gs_proxy = dbus_g_proxy_new_for_name ( tp_proxy_get_dbus_connection (dbus), "org.gnome.SessionManager", "/org/gnome/SessionManager/Presence", "org.gnome.SessionManager.Presence"); if (self->priv->gs_proxy) { dbus_g_proxy_add_signal (self->priv->gs_proxy, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (self->priv->gs_proxy, "StatusChanged", G_CALLBACK (session_status_changed_cb), self, NULL); } else { DEBUG ("Failed to get gs proxy"); } g_object_unref (dbus); self->priv->connectivity = empathy_connectivity_dup_singleton (); tp_g_signal_connect_object (self->priv->connectivity, "state-change", G_CALLBACK (state_change_cb), self, 0); self->priv->connect_times = g_hash_table_new (g_direct_hash, g_direct_equal); }
static void empathy_idle_init (EmpathyIdle *idle) { EmpathyIdlePriv *priv = G_TYPE_INSTANCE_GET_PRIVATE (idle, EMPATHY_TYPE_IDLE, EmpathyIdlePriv); TpDBusDaemon *dbus; idle->priv = priv; priv->is_idle = FALSE; priv->manager = tp_account_manager_dup (); tp_account_manager_prepare_async (priv->manager, NULL, account_manager_ready_cb, idle); priv->idle_presence_changed_id = g_signal_connect (priv->manager, "most-available-presence-changed", G_CALLBACK (idle_presence_changed_cb), idle); dbus = tp_dbus_daemon_dup (NULL); priv->gs_proxy = dbus_g_proxy_new_for_name ( tp_proxy_get_dbus_connection (dbus), "org.gnome.SessionManager", "/org/gnome/SessionManager/Presence", "org.gnome.SessionManager.Presence"); if (priv->gs_proxy) { dbus_g_proxy_add_signal (priv->gs_proxy, "StatusChanged", G_TYPE_UINT, G_TYPE_INVALID); dbus_g_proxy_connect_signal (priv->gs_proxy, "StatusChanged", G_CALLBACK (idle_session_status_changed_cb), idle, NULL); } else { DEBUG ("Failed to get gs proxy"); } g_object_unref (dbus); priv->connectivity = empathy_connectivity_dup_singleton (); priv->state_change_signal_id = g_signal_connect (priv->connectivity, "state-change", G_CALLBACK (idle_state_change_cb), idle); priv->connect_times = g_hash_table_new (g_direct_hash, g_direct_equal); }
static void watch_clients (McdClientRegistry *self) { TpDBusDaemon *dbus_daemon = self->priv->dbus_daemon; DBusGConnection *gconn = tp_proxy_get_dbus_connection (dbus_daemon); DBusConnection *dconn = dbus_g_connection_get_connection (gconn); DBusError error = { 0 }; #define MATCH_ITEM(t,x) #t "='" x "'" #define NAME_OWNER_RULE \ MATCH_ITEM (type, "signal") "," \ MATCH_ITEM (sender, DBUS_SERVICE_DBUS) "," \ MATCH_ITEM (interface, DBUS_INTERFACE_DBUS) "," \ MATCH_ITEM (member, "NameOwnerChanged") #define CLIENT_MATCH_RULE \ NAME_OWNER_RULE "," \ MATCH_ITEM (arg0namespace, "org.freedesktop.Telepathy.Client") if (!dbus_connection_add_filter (dconn, mcd_client_registry_name_owner_filter, self, NULL)) g_critical ("Could not add filter for NameOwnerChanged (out of memory?)"); dbus_error_init (&error); dbus_bus_add_match (dconn, CLIENT_MATCH_RULE, &error); if (dbus_error_is_set (&error)) { DEBUG ("Could not add client names match rule (D-Bus 1.6 required): %s", error.message); dbus_error_free (&error); dbus_bus_add_match (dconn, NAME_OWNER_RULE, &error); if (dbus_error_is_set (&error)) { g_critical ("Could not add all dbus names match rule: %s", error.message); dbus_error_free (&error); } } }
void empathy_chat_manager_call_undo_closed_chat (void) { TpDBusDaemon *dbus_daemon = tp_dbus_daemon_dup (NULL); TpProxy *proxy; if (dbus_daemon == NULL) return; proxy = g_object_new (TP_TYPE_PROXY, "dbus-daemon", dbus_daemon, "dbus-connection", tp_proxy_get_dbus_connection (TP_PROXY (dbus_daemon)), "bus-name", EMPATHY_CHAT_BUS_NAME, "object-path", "/org/gnome/Empathy/ChatManager", NULL); tp_proxy_add_interface_by_id (proxy, EMP_IFACE_QUARK_CHAT_MANAGER); emp_cli_chat_manager_call_undo_closed_chat (proxy, -1, empathy_get_current_action_time (), NULL, NULL, NULL, NULL); g_object_unref (proxy); g_object_unref (dbus_daemon); }
int main (int argc, char **argv) { GError *error = NULL; GDBusConnection *gdbus = NULL; GDBusConnection *gdbus_system = NULL; DBusConnection *connection = NULL; int ret = 1; GMainLoop *teardown_loop; guint linger_time = 5; g_type_init (); g_set_application_name ("Mission Control regression tests"); mcd_debug_init (); tp_debug_set_flags (g_getenv ("MC_TP_DEBUG")); /* Not all warnings are fatal due to MC spamming warnings (fd.o #23486), * but GLib and GObject warnings are pretty serious */ g_log_set_fatal_mask ("GLib", G_LOG_FATAL_MASK | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING); g_log_set_fatal_mask ("GLib-GObject", G_LOG_FATAL_MASK | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING); gdbus = g_bus_get_sync (G_BUS_TYPE_SESSION, NULL, &error); g_assert_no_error (error); g_assert (gdbus != NULL); g_dbus_connection_set_exit_on_close (gdbus, FALSE); gdbus_system = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, &error); g_assert_no_error (error); g_assert (gdbus_system != NULL); g_dbus_connection_set_exit_on_close (gdbus_system, FALSE); bus_daemon = tp_dbus_daemon_dup (&error); g_assert_no_error (error); g_assert (bus_daemon != NULL); /* It appears that dbus-glib registers a filter that wrongly returns * DBUS_HANDLER_RESULT_HANDLED for signals, so for *our* filter to have any * effect, we need to install it as soon as possible */ connection = dbus_g_connection_get_connection ( tp_proxy_get_dbus_connection (bus_daemon)); dbus_connection_add_filter (connection, dbus_filter_function, NULL, NULL); mcd = mcd_service_new (); /* Listen for suicide notification */ g_signal_connect_after (mcd, "abort", G_CALLBACK (on_abort), NULL); /* connect */ mcd_mission_connect (MCD_MISSION (mcd)); dbus_connection_set_exit_on_disconnect (connection, FALSE); mcd_service_run (MCD_OBJECT (mcd)); ret = 0; teardown_loop = g_main_loop_new (NULL, FALSE); if (g_getenv ("MC_LINGER_TIME") != NULL) { linger_time = g_ascii_strtoull (g_getenv ("MC_LINGER_TIME"), NULL, 10); } /* Keep running in the background until it's all over. This means valgrind * and refdbg can get complete information. */ g_timeout_add_seconds_full (G_PRIORITY_DEFAULT, linger_time, the_end, teardown_loop, (GDestroyNotify) g_main_loop_unref); g_main_loop_run (teardown_loop); if (connection != NULL) { dbus_connection_flush (connection); } tp_clear_object (&gdbus); tp_clear_object (&gdbus_system); tp_clear_object (&bus_daemon); dbus_shutdown (); g_message ("Exiting with %d", ret); return ret; }
static void on_call_channel_get_all_properties_cb (TpProxy *proxy, GHashTable *properties, const GError *error, gpointer user_data, GObject *weak_object) { TpyCallChannel *self = TPY_CALL_CHANNEL (proxy); GSimpleAsyncResult *result = user_data; GHashTable *hash_table; GPtrArray *contents; guint i; if (error != NULL) { g_warning ("Could not get the channel properties: %s", error->message); g_simple_async_result_set_from_error (result, error); goto out; } self->priv->state = tp_asv_get_uint32 (properties, "CallState", NULL); self->priv->flags = tp_asv_get_uint32 (properties, "CallFlags", NULL); self->priv->initial_audio = tp_asv_get_boolean (properties, "InitialAudio", NULL); self->priv->initial_video = tp_asv_get_boolean (properties, "InitialVideo", NULL); hash_table = tp_asv_get_boxed (properties, "CallStateDetails", TP_HASH_TYPE_STRING_VARIANT_MAP); if (hash_table != NULL) self->priv->details = g_boxed_copy (TP_HASH_TYPE_STRING_VARIANT_MAP, hash_table); hash_table = tp_asv_get_boxed (properties, "CallMembers", TPY_HASH_TYPE_CALL_MEMBER_MAP); update_call_members (self, hash_table, NULL); contents = tp_asv_get_boxed (properties, "Contents", TP_ARRAY_TYPE_OBJECT_PATH_LIST); for (i = 0; i < contents->len; i++) { const gchar *content_path = g_ptr_array_index (contents, i); TpyCallContent *content; DEBUG ("Content added: %s", content_path); content = g_object_new (TPY_TYPE_CALL_CONTENT, "bus-name", tp_proxy_get_bus_name (self), "dbus-daemon", tp_proxy_get_dbus_daemon (self), "dbus-connection", tp_proxy_get_dbus_connection (self), "object-path", content_path, NULL); if (content == NULL) { g_warning ("Could not create a CallContent for path %s", content_path); g_simple_async_result_set_error (result, TP_ERRORS, TP_ERROR_CONFUSED, "Could not create a CallContent for path %s", content_path); goto out; } g_ptr_array_add (self->priv->contents, content); tp_g_signal_connect_object (content, "notify::ready", G_CALLBACK (on_content_ready_cb), self, 0); } g_signal_emit (self, _signals[MEMBERS_CHANGED], 0, self->priv->members); self->priv->properties_retrieved = TRUE; maybe_go_to_ready (self); out: /* TODO; ideally we should get rid of the ready property and complete once * all the contents have been prepared. Or maybe that should be another * feature? */ g_simple_async_result_complete (result); }