基本概念 下（C API 级别的使用观点）

通信数据的设置和获取

前篇主要是有讲一些相对高层的概念，比如 object，interface，method 之类的，对于这些“C 本来没有的东西”，如何在 DBus 中表现的确实很让我迷惑了一阵。但通信数据的发送可能比前面那些名称好理解得多。因为这些概念都是很本来就是底层的，很 C 的。

DBus 提供了一个 DBusMessageIter 的类型，使用这个类型的变量，我们就可以向 DBusMessage 中很容易地加入数据，也可以很容易地从中取出数据。

1. DBusMessage* msg;
2. DBusMessageIter args;
3.  
4. // msg...
5.  
6. dbus_message_iter_init_append(msg, &args);
7. dbus_uint32_t my_data = 10;
8. if(!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &my_data)) {
9.     printf("Out of memory\n");
10.     return RES_FAILED;
11. }
12.  
13. dbus_connection_flush(conn);
14. dbus_message_unref(msg);

第 2 行的代码声明了一个 DBusMessageIter 的对象 args，第 6 行的代码处，对 args 进行初始化，这可以让一个 DBusMessageIter 对象与对应的 DBusMessage 关联起来，后面再对 DBusMessageIter的时候（设置或者取得数据），就是对相应的 DBusMessage 进行处理。然后使用第8行的函数，将一个 uint32 的数据 my_data 追加到 msg 中了。如果还要追加新的参数的话，只需要继续调用该函数，并传入适当的参数就可以了。

1. dbus_bool_t dbus_message_iter_append_basic(DBusMessageIter * iter,
2.                                                           inttype,
3.                                            const void *      value
4.                                            )

这个函数可以用来向 DBusMessageIter 中追加一些“基本类型”（basic）的数据，所谓基本类型的数据，在 DBus 中是这么定义的：

Conventional Name	Encoding	Alignment
BYTE	A single 8-bit byte.	1
BOOLEAN	As for UINT32, but only 0 and 1 are valid values.	4
INT16	16-bit signed integer in the message's byte order.	2
UINT16	16-bit unsigned integer in the message's byte order.	2
INT32	32-bit signed integer in the message's byte order.	4
UINT32	32-bit unsigned integer in the message's byte order.	4
INT64	64-bit signed integer in the message's byte order.	8
UINT64	64-bit unsigned integer in the message's byte order.	8
DOUBLE	64-bit IEEE 754 double in the message's byte order.	8
STRING	A UINT32 indicating the string's length in bytes excluding its terminating nul, followed by non-nul string data of the given length, followed by a terminating nul byte.	4 (for the length)
OBJECT_PATH	Exactly the same as STRING except the content must be a valid object path (see below).	4 (for the length)

（参考 DBus 的在线 API 的 Marshaling (Wire Format) 一节）

有 basic type，当然也就有更复杂的不是 basic 的类型，但这和基本概念的关系不大，在这篇文章中就不多介绍了。（请参考我其它的 DBus 博文）

到现在为止，我已经知道如何把数据入到一个 DBusMessage 中了，那么，如何从一个 DBusMessage 中取出数据呢？比如，我在 A 进程使用上面的代码把 my_data 加到 DBusMessage 中了，现在 B 进程取到了 DBusMessage，如何把数据取出来呢？

1. DBusMessage* msg;
2. DBusMessageIter args;
3.  
4. // get a DBusMessage from process A
5.  
6. if(!dbus_message_iter_init(msg, &args)) {
7.     printf("dbus_message_iter_init error, msg has no arguments!\n");
8. }
9. else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)){
10.     printf("not a uint 32 type !\n");
11. }
12. else {
13.     dbus_uint32_t my_age = 0;
14.     dbus_message_iter_get_basic(&args, &my_age);
15.     printf("Got signal with value %d\n", my_age);
16. }

很简单，一样的先使用 dbus_messge_iter_init 先把 DBusMessage 对象和从 DBus 总线中取到的 msg 关联起来。这样，使用第 9 行的函数先取得第一个通信数据中第一个参数的类型，如果类型无误的话可以进而使用第 14 行的函数取得参数值本身。

这样，一个简单的数据如何入到 DBusMessage 中，又如何从 DBusMessage 中取出来就明白了。那么如何将 DBusMessage 在进程之间传递呢？

消息的发送和获取

消息的发送其实比较简单，当进程 A 准备申请好一个 DBusMessage对象，设置好它的“类型”（就是各种名字），放好需要通信的数据，之后，使用下面的代码就可以将数据发送到总线上：

1. dbus_uint32_t serial = 0;
2.  
3. if(!dbus_connection_send(conn, msg, &serial)) {
4.     printf("Out of memory");
5.     return RES_FAILED;
6. }
7. dbus_connection_flush(conn);

这很简单，只是 dbus_connection_flush 这个函数有点突兀，它的作用是“Blocks until the outgoing message queue is empty.”，可以简单地理解为调用这个函数可以使用得发送进程一直等消息发送完了才能继续运行。

接受方的代码也很简单：

1. dbus_connection_read_write(conn, 0);
2. msg = dbus_connection_pop_message(conn);
3.  
4. if(NULL == msg) {
5.     sleep(1);
6.     continue;
7. }

使用 1 和 2 行的代码就可以取出发送到本进程的消息，之后就可以使用 msg （如果 msg 不是 NULL 的话）来获取通信数据了。

 

到这里，基本概念就有了。后面，应该对 DBus 的细节再深入的探索。

 

Sample 代码：

发送方进程(my_client)：

My_Client.cpp

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <dbus/dbus.h>
4. #include <unistd.h>
5.  
6. const int RES_SUCCESS = -1;
7. const int RES_FAILED  = 0;
8.  
9. int my_dbus_initialization(char const * _bus_name, DBusConnection ** _conn) {
10.     DBusError err;
11.  
12.     int ret;
13.  
14.     dbus_error_init(&err);
15.  
16.     *_conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
17.     if(dbus_error_is_set(&err)) {
18.         printf("Connection Error\n");
19.         dbus_error_free(&err);
20.         return RES_FAILED;
21.     }
22.  
23.     ret = dbus_bus_request_name(*_conn, _bus_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
24.     if(dbus_error_is_set(&err)){
25.         printf("Requece name error \n");
26.         dbus_error_free(&err);
27.         return RES_FAILED;
28.     }
29.  
30.     if(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
31.         return RES_FAILED;
32.     }
33.  
34.     return RES_SUCCESS;
35. }
36.  
37. int my_dbus_send_sigal(DBusConnection * conn) {
38.     dbus_uint32_t serial = 0;
39.     DBusMessage* msg;
40.     DBusMessageIter args;
41.     char sigvalue[20] = "liyiwen";
42.  
43.     msg = dbus_message_new_signal("/test/signal/Object",  // object name
44.         "test.signal.Type",     // interface name
45.         "Test");                // name of signal
46.  
47.     if (NULL == msg) {
48.         printf("Message Null");
49.         return RES_FAILED;
50.     }
51.  
52.     dbus_message_iter_init_append(msg, &args);
53.  
54.     printf("%s\n", sigvalue);
55.     dbus_uint32_t my_age = 10;
56.     if(!dbus_message_iter_append_basic(&args, DBUS_TYPE_UINT32, &my_age)) {
57.         printf("Out of memory\n");
58.         return RES_FAILED;
59.     }
60.  
61.     if(!dbus_connection_send(conn, msg, &serial)) {
62.         printf("Out of memory");
63.         return RES_FAILED;
64.     }
65.     dbus_connection_flush(conn);
66.  
67.     dbus_message_unref(msg);
68.  
69.     return RES_SUCCESS;
70.  
71. }
72.  
73. int main(int agrc, char** argv)
74. {
75.     DBusConnection * conn;
76.  
77.     printf("Start\n");
78.     if (RES_FAILED == my_dbus_initialization("test.method.client", &conn)) {
79.         exit(1);
80.     }
81.     my_dbus_send_sigal(conn);
82.  
83.     while(1){sleep(10);}
84.  
85.     return 0;
86. }

接收方进程（my_server.cpp）

My_Server.cpp

1. #include <stdio.h>
2. #include <stdlib.h>
3. #include <dbus/dbus.h>
4. #include <unistd.h>
5.  
6. const int RES_SUCCESS = -1;
7. const int RES_FAILED  = 0;
8.  
9. int my_dbus_initialization(char const * _bus_name, DBusConnection **_conn) {
10.     DBusError err;
11.     int ret;
12.  
13.     dbus_error_init(&err);
14.  
15.     *_conn = dbus_bus_get(DBUS_BUS_SESSION, &err);
16.     if(dbus_error_is_set(&err)) {
17.         printf("Connection Error(%s) \n", err.message);
18.         dbus_error_free(&err);
19.         return RES_FAILED;
20.     }
21.  
22.     ret = dbus_bus_request_name(*_conn, _bus_name, DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
23.     if(dbus_error_is_set(&err)){
24.         printf("Requece name error(%s) \n", err.message);
25.         dbus_error_free(&err);
26.         return RES_FAILED;
27.     }
28.     if(DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER != ret) {
29.         return RES_FAILED;
30.     }
31.     return RES_SUCCESS;
32. }
33.  
34. int main(int agrc, char** argv)
35. {
36.  
37.     DBusError err;
38.     DBusMessage* msg;
39.     DBusMessageIter args;
40.  
41.     dbus_error_init(&err);
42.     DBusConnection *conn;
43.     if (RES_FAILED == my_dbus_initialization("test.method.server", &conn)) {
44.         exit(1);
45.     }
46.  
47.     dbus_bus_add_match(conn, "type='signal', interface='test.signal.Type'", &err);
48.  
49.     dbus_connection_flush(conn);
50.     if(dbus_error_is_set(&err)) {
51.         printf("dbus_bus_add_match err (%s)", err.message);
52.         return RES_FAILED;
53.     }
54.  
55.     while(1) {
56.         dbus_connection_read_write(conn, 0);
57.         msg = dbus_connection_pop_message(conn);
58.  
59.         if(NULL == msg) {
60.             sleep(1);
61.             continue;
62.         }
63.  
64.         if(dbus_message_is_signal(msg, "test.signal.Type", "Test")) {
65.             if(!dbus_message_iter_init(msg, &args)) {
66.                 printf("dbus_message_iter_init error, msg has no arguments!\n");
67.             }
68.             else if (DBUS_TYPE_UINT32 != dbus_message_iter_get_arg_type(&args)){
69.                 printf("not a uint 32 type !\n");
70.             }
71.             else {
72.                 dbus_uint32_t my_age = 0;
73.                 dbus_message_iter_get_basic(&args, &my_age);
74.                 printf("Got signal with value %d\n", my_age);
75.             }
76.         }
77.  
78.         dbus_message_unref(msg);
79.  
80.     }
81.  
82.     return 0;
83. }

参考资料：

1. http://dbus.freedesktop.org/doc/dbus-specification.html  这当然是最权威最重要的资料，但我觉得不是一个很好的入门资料。
2. http://dbus.freedesktop.org/doc/dbus-tutorial.html 这里面有一些不错的例子，对Names 的解释也很好，但用的是 glib 的 binding，不能探究更底层的动作一度还是让我云里雾里。
3. http://dbus.freedesktop.org/doc/api/html/group__DBusMessage.html  DBus 的 C 编程接口的在线文档，非常棒也非常有用
4. http://dbus.freedesktop.org/doc/dbus/libdbus-tutorial.html 如何用 C API 层面的 DBus ，相见恨晚。

转自博客园唐风：http://www.cnblogs.com/muxue/archive/2012/12/09/2810638.html