C++ dbus_g_connection_register_g_object函数代码示例

int
main (int    argc, 
      char **argv)
{
	DBusGConnection *connection;
	DBusGProxy *proxy;
	GError *error = NULL;
	guint32 ret;
	TestBeatlesSong *song;
	TestDpObj *dp_obj;

	g_type_init ();

	/* Get the connection and ensure the name is not used yet */
	connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
	if (connection == NULL) {
		g_warning ("Failed to make connection to session bus: %s",
			   error->message);
		g_error_free (error);
		exit(1);
	}
		
	proxy = dbus_g_proxy_new_for_name (connection, DBUS_SERVICE_DBUS,
					   DBUS_PATH_DBUS, DBUS_INTERFACE_DBUS);
	if (!org_freedesktop_DBus_request_name (proxy, TEST_NAMESPACE,
						0, &ret, &error)) {
		g_warning ("There was an error requesting the name: %s",
			   error->message);
		g_error_free (error);
		exit(1);
	}
	
	if (ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
		/* Someone else registered the name before us */
		exit(1);
	}
		
	song = test_beatles_song_new ();
		
	/* Register the app on the bus */
	dbus_g_connection_register_g_object (connection,
					     TEST_OBJECT_PATH,
					     G_OBJECT (song));

	dp_obj = test_dp_obj_new ();
	dbus_g_connection_register_g_object (connection,
					     TEST_DP_OBJECT_PATH,
					     G_OBJECT (dp_obj));

	loop = g_main_loop_new (NULL, FALSE);
	g_main_loop_run (loop);

	return 0;
}

static GObject *
constructor (GType type,
		   guint n_construct_params,
		   GObjectConstructParam *construct_params)
{
	GObject *object;
	NMPPPManagerPrivate *priv;
	DBusGConnection *connection;
	static guint32 counter = 0;

	object = G_OBJECT_CLASS (nm_ppp_manager_parent_class)->constructor (type,
	                                                                    n_construct_params,
	                                                                    construct_params);
	if (!object)
		return NULL;

	priv = NM_PPP_MANAGER_GET_PRIVATE (object);
	priv->dbus_manager = nm_dbus_manager_get ();
	if (!priv->dbus_manager) {
		g_object_unref (object);
		return NULL;
	}

	connection = nm_dbus_manager_get_connection (priv->dbus_manager);
	priv->dbus_path = g_strdup_printf (NM_DBUS_PATH "/PPP/%d", counter++);
	dbus_g_connection_register_g_object (connection, priv->dbus_path, object);

	return object;
}

static void
new_connection_cb (DBusServer    * server,
                   DBusConnection* connection,
                   gpointer        user_data)
{
  dbus_int32_t  slot = -1;
  GObject     * object;
  if (!dbus_connection_allocate_data_slot (&slot))
    {
      g_warning ("error allocating data slot for DBusConnection");
      dbus_connection_close (connection);
      return;
    }

  dbus_connection_ref (connection);

  dbus_connection_set_allow_anonymous (connection, TRUE);
  dbus_connection_setup_with_g_main (connection, NULL);

  object = g_object_new (p2p_object_get_type (), NULL);
  dbus_g_connection_register_g_object (dbus_connection_get_g_connection (connection),
                                       "/", object);
  dbus_connection_set_data (connection, slot,
                            object, g_object_unref);
}

void
nm_ap_export_to_dbus (NMAccessPoint *ap)
{
	NMAccessPointPrivate *priv;
	NMDBusManager *mgr;
	DBusGConnection *g_connection;
	static guint32 counter = 0;

	g_return_if_fail (NM_IS_AP (ap));

	priv = NM_AP_GET_PRIVATE (ap);

	if (priv->dbus_path) {
		nm_warning ("Tried to export AP %s twice.", priv->dbus_path);
		return;
	}

	mgr = nm_dbus_manager_get ();
	g_assert (mgr);

	g_connection = nm_dbus_manager_get_connection (mgr);
	g_assert (g_connection);

	priv->dbus_path = g_strdup_printf (NM_DBUS_PATH_ACCESS_POINT "/%d", counter++);
	dbus_g_connection_register_g_object (g_connection, priv->dbus_path, G_OBJECT (ap));

	g_object_unref (mgr);
}

static GObject *
odccm_device_manager_constructor (GType type, guint n_props,
                                  GObjectConstructParam *props)
{
  GObject *obj;
  OdccmDeviceManagerPrivate *priv;

  obj = G_OBJECT_CLASS (odccm_device_manager_parent_class)->
    constructor (type, n_props, props);

  priv = ODCCM_DEVICE_MANAGER_GET_PRIVATE (obj);

  priv->server = gnet_server_new (NULL, 990, client_connected_cb, obj);
#ifdef ENABLE_LEGACY_SUPPORT
  priv->legacy_server = gnet_server_new (NULL, 5679, client_connected_cb, obj);
#endif

  dbus_g_connection_register_g_object (_odccm_get_dbus_conn (),
                                       DEVICE_MANAGER_OBJECT_PATH, obj);

  init_hal (ODCCM_DEVICE_MANAGER (obj));
  init_udev (ODCCM_DEVICE_MANAGER (obj));

  return obj;
}

static void dbus_server_init()
{
	DBusGConnection *connection;
	DBusError error;
	GError *gerror = NULL;

	dbus_error_init(&error);
	if (dbus_bus_request_name(glob_dbus_conn, POWERMAN_SERVICE,
				  DBUS_NAME_FLAG_DO_NOT_QUEUE, &error)
	    != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER) {
		if (dbus_error_is_set(&error)) {
			print_debug("%s\n",
				    error.message);
			dbus_error_free(&error);
		} else {
			print_debug("%s is busy\n", POWERMAN_SERVICE);
		}
		exit(0);
	}
	print_debug("registered %s", POWERMAN_SERVICE);
	g_type_init();
	connection = dbus_g_bus_get(DBUS_BUS_SYSTEM, &gerror);
	if (gerror != NULL) {
		print_debug("Unable to connect to dbus: %s\n", gerror->message);
		g_error_free(gerror);
		return;
	}

	xpm_manager_install_info();
	dbus_g_connection_register_g_object(
		connection,  POWERMAN_PATH,
		G_OBJECT(g_object_new(XPM_TYPE_MANAGER, NULL)));
}

LifereaDBus*
liferea_dbus_new (void)
{
	LifereaDBus *obj = NULL;
	DBusGConnection *bus;
	DBusGProxy *bus_proxy;
	GError *error = NULL;
	guint request_name_result;
	
	bus = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
	if (!bus)
		return NULL;

	bus_proxy = dbus_g_proxy_new_for_name (bus, "org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus");

	if (!dbus_g_proxy_call (bus_proxy, "RequestName", &error,
				G_TYPE_STRING, LF_DBUS_SERVICE, G_TYPE_UINT, 0, G_TYPE_INVALID,
				G_TYPE_UINT, &request_name_result, G_TYPE_INVALID))
		return NULL;

	obj = (LifereaDBus*)g_object_new(LIFEREA_DBUS_TYPE, NULL);
	dbus_g_connection_register_g_object (bus, LF_DBUS_PATH, G_OBJECT (obj));
	
	return obj;
}

void
nm_wimax_nsp_export_to_dbus (NMWimaxNsp *self)
{
	NMWimaxNspPrivate *priv;
	NMDBusManager *mgr;
	DBusGConnection *g_connection;
	static guint32 counter = 0;

	g_return_if_fail (NM_IS_WIMAX_NSP (self));

	priv = GET_PRIVATE (self);

	g_return_if_fail (priv->dbus_path == NULL);

	mgr = nm_dbus_manager_get ();
	g_assert (mgr);

	g_connection = nm_dbus_manager_get_connection (mgr);
	g_assert (g_connection);

	priv->dbus_path = g_strdup_printf (NM_DBUS_PATH_WIMAX_NSP "/%d", counter++);
	dbus_g_connection_register_g_object (g_connection, priv->dbus_path, G_OBJECT (self));

	g_object_unref (mgr);
}

static gint
calc_server_init (CalcServer * server)
{
  GError *error = NULL;
  DBusGProxy *driver_proxy;
  CalcServerClass *klass = CALC_SERVER_GET_CLASS (server);
  guint request_ret;
  gint retcode = 1;

  /* Register DBUS path */
  dbus_g_connection_register_g_object (klass->connection,
				       CALC_SERVICE_OBJECT_PATH,
				       G_OBJECT (server));

  driver_proxy = dbus_g_proxy_new_for_name (klass->connection,
					    DBUS_SERVICE_DBUS,
					    DBUS_PATH_DBUS,
					    DBUS_INTERFACE_DBUS);

  if (!org_freedesktop_DBus_request_name (driver_proxy, CALC_SERVICE_NAME, 0, &request_ret,&error))
    {
      g_warning ("Unable to register service: %s", error->message);
      g_error_free (error);
      retcode = 0;
    }
  g_object_unref (driver_proxy);

  return (retcode);
}

int
main (int argc, char *argv[])
{
  DBusGConnection *connection;  // A connection to the main application
  GObject *object;              // An object we're registering

  // Set up GTK
  gtk_init (&argc, &argv);

  // Create the connection
  connection = glim_dbus_create_service ("edu.grinnell.glimmer.dbe");
  if (connection == NULL)
    return 1;

  // Create the object we're trying to register.  
  object = G_OBJECT (glim_dbe_new ());
  if (object == NULL)
    {
      g_printerr ("Error: Failed to create object to register.\n");
      return 1;
    }
  
  // Register that object
  dbus_g_connection_register_g_object (connection, 
                                       "/edu/grinnell/glimmer/dbe",
                                       object);

  // Wait for requests
  gtk_main ();

  // And we're done
  return 0;
} // main

static gboolean
register_mechanism (GConfDefaults *mechanism)
{
        GError *error = NULL;

        mechanism->priv->auth = polkit_authority_get ();

        error = NULL;
        mechanism->priv->system_bus_connection = dbus_g_bus_get (DBUS_BUS_SYSTEM, &error);
        if (mechanism->priv->system_bus_connection == NULL) {
                if (error != NULL) {
                        g_critical ("error getting system bus: %s", error->message);
                        g_error_free (error);
                }
                goto error;
        }

        dbus_g_connection_register_g_object (mechanism->priv->system_bus_connection, "/",
                                             G_OBJECT (mechanism));

        mechanism->priv->system_bus_proxy = dbus_g_proxy_new_for_name (mechanism->priv->system_bus_connection,
                                                                      DBUS_SERVICE_DBUS,
                                                                      DBUS_PATH_DBUS,
                                                                      DBUS_INTERFACE_DBUS);

        start_killtimer ();

        return TRUE;

error:
        return FALSE;
}

/**
 * Build a new counter.
 * TODO: Add error checking.
 */
gboolean
glim_counter_factory_build (GlimCounterFactory *factory,
                            gchar **name, GError **error_p)
{
  char *counter_name = g_strdup_printf ("Counter%d", (factory->count)++);
  char *path = 
    g_strconcat ("/edu/grinnell/glimmer/counter/", counter_name, NULL);
  GlimCounter *counter = glim_counter_new (counter_name);
  GError *error;                // Error returned by call
  DBusGConnection *connection;  // A connection to the main application

  // Create the connection
  error = NULL;
  connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
  if ((! connection) || error)
    {
      *error_p = error;
      return FALSE;
    }

  // Register the object
  dbus_g_connection_register_g_object (connection,
                                       path, 
                                       G_OBJECT (counter));
  g_free (path);

  *name = counter_name;
  return TRUE;
} // glim_counter_factory_build

static void
gui_dbus_service_init (Gimp *gimp)
{
  GError  *error = NULL;

  g_return_if_fail (GIMP_IS_GIMP (gimp));
  g_return_if_fail (dbus_connection == NULL);

  dbus_connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);

  if (dbus_connection)
    {
      GObject *service = gimp_dbus_service_new (gimp);

      dbus_bus_request_name (dbus_g_connection_get_connection (dbus_connection),
                             GIMP_DBUS_SERVICE_NAME, 0, NULL);

      dbus_g_connection_register_g_object (dbus_connection,
                                           GIMP_DBUS_SERVICE_PATH, service);
    }
  else
    {
      g_printerr ("%s\n", error->message);
      g_error_free (error);
    }
}

static gboolean
register_manager (GsmManager *manager)
{
    GError *error = NULL;

    error = NULL;
    manager->priv->connection = dbus_g_bus_get (DBUS_BUS_SESSION, &error);
    if (manager->priv->connection == NULL) {
        if (error != NULL) {
            g_critical ("error getting session bus: %s", error->message);
            g_error_free (error);
        }
        return FALSE;
    }

    manager->priv->bus_proxy = dbus_g_proxy_new_for_name (manager->priv->connection,
                               DBUS_SERVICE_DBUS,
                               DBUS_PATH_DBUS,
                               DBUS_INTERFACE_DBUS);
    dbus_g_proxy_add_signal (manager->priv->bus_proxy,
                             "NameOwnerChanged",
                             G_TYPE_STRING,
                             G_TYPE_STRING,
                             G_TYPE_STRING,
                             G_TYPE_INVALID);
    dbus_g_proxy_connect_signal (manager->priv->bus_proxy,
                                 "NameOwnerChanged",
                                 G_CALLBACK (bus_name_owner_changed),
                                 manager,
                                 NULL);

    dbus_g_connection_register_g_object (manager->priv->connection, GSM_MANAGER_DBUS_PATH, G_OBJECT (manager));

    return TRUE;
}

void mpris_root_init(MprisRoot * object)
{
    dbus_g_object_type_install_info(mpris_root_get_type(), &dbus_glib_mpris_root_object_info);

    // Register DBUS path
    dbus_g_connection_register_g_object(dbus_conn, AUDACIOUS_DBUS_PATH_MPRIS_ROOT, G_OBJECT(object));
}