中间件 DBus - DBusWatch方式处理消息

DBus其他方式的处理消息并不复杂，但是看了半天文档，也没看懂DBusWatch方式。网上关于如何使用DBusWatch方式的文章也很少，还好发现一位大侠贴出了一个sample，再次记录下来！
DBusWatch似乎提供了更细力度的控制，而且可以实现异步处理，glib中的绑定也是使用该方式。
引自： http://blog.csdn.net/cuijpus/archive/2008/05/25/2478825.aspx

1. /* compile with:
2.    gcc `pkg-config dbus-1 --cflags --libs` own-mainloop.c -o own-
3. mainloop
4. */
6. #include <stdio.h>
7. #include <unistd.h>
8. #include <string.h>
9. #include <sys/poll.h>
10. #include <dbus/dbus.h>
12. #define MAX_WATCHES 100
14. static DBusConnection *conn;
15. static struct pollfd pollfds[MAX_WATCHES];
16. static DBusWatch *watches[MAX_WATCHES];
17. static int max_i;
18. static char *progname;
20. static DBusHandlerResult
21. filter_func(DBusConnection *c, DBusMessage *m, void *data)
22. {
23.         printf("[%s] if: %s, member: %s, path: %s/n", progname,
24.                dbus_message_get_interface(m),
25.                dbus_message_get_member(m),
26.                dbus_message_get_path(m));
27.         return DBUS_HANDLER_RESULT_HANDLED;
28. }
30. static dbus_bool_t add_watch(DBusWatch *watch, void *data)
31. {
32.         short cond = POLLHUP | POLLERR;
33.         int fd;
34.         unsigned int flags;
36.         printf("[%s] add watch %p/n", progname, (void*)watch);
37.         fd = dbus_watch_get_fd(watch);
38.         flags = dbus_watch_get_flags(watch);
39.        
40.         if (flags & DBUS_WATCH_READABLE)
41.                 cond |= POLLIN;
42.         if (flags & DBUS_WATCH_WRITABLE)
43.                 cond |= POLLOUT;
45.         ++max_i;
46.         pollfds[max_i].fd = fd;
47.         pollfds[max_i].events = cond;
48.         watches[max_i] = watch;
50.         return 1;
51. }
53. static void remove_watch(DBusWatch *watch, void *data)
54. {
55.         int i, found = 0;
57.         printf("[%s] remove watch %p/n", progname, (void*)watch);
58.         for (i = 0; i <= max_i; ++i) {
59.                 if (watches[i] == watch) {
60.                         found = 1;
61.                         break;
62.                 }
63.         }
64.         if (!found) {
65.                 printf("watch %p not found/n", (void*)watch);
66.                 return;
67.         }
69.         memset(&pollfds[i], 0, sizeof(pollfds[i]));
70.         watches[i] = NULL;
72.         if (i == max_i && max_i > 0) --max_i;
73. }
75. static void fd_handler(short events, DBusWatch *watch)
76. {
77.         unsigned int flags = 0;
79.         if (events & POLLIN) 
80.                 flags |= DBUS_WATCH_READABLE;
81.         if (events & POLLOUT)
82.                 flags |= DBUS_WATCH_WRITABLE;
83.         if (events & POLLHUP)
84.                 flags |= DBUS_WATCH_HANGUP;
85.         if (events & POLLERR)
86.                 flags |= DBUS_WATCH_ERROR;
88.         while (!dbus_watch_handle(watch, flags)) {
89.                 printf("dbus_watch_handle needs more memory/n");
90.                 sleep(1);
91.         }
92.        
93.         dbus_connection_ref(conn);
94.         while (dbus_connection_dispatch(conn) ==
95. DBUS_DISPATCH_DATA_REMAINS);
96.         dbus_connection_unref(conn);
97. }
99. int main(int argc, char *argv[])
100. {
101.         DBusError error;
103.         progname = argv[0];
104.         dbus_error_init(&error);
105.         conn = dbus_bus_get(DBUS_BUS_SYSTEM, &error);
106.         if (conn == NULL) {
107.                 printf("Error when connecting to the bus: %s/n",
108.                        error.message);
109.                 return 1;
110.         }
112.         if (!dbus_connection_set_watch_functions(conn, add_watch,
113.                      remove_watch, NULL, NULL, NULL)) {
114.                 printf("dbus_connection_set_watch_functions failed/n");
115.                 return 1;
116.         }
118.         if (!dbus_connection_add_filter(conn, filter_func, NULL, NULL))
119. {
120.                 printf("Failed to register signal handler callback/n");
121.                 return 1;
122.         }
123.         dbus_bus_add_match(conn, "type='signal'", NULL);
124.         dbus_bus_add_match(conn, "type='method_call'", NULL);
126.         while (1) {
127.                 struct pollfd fds[MAX_WATCHES];
128.                 DBusWatch *watch[MAX_WATCHES];
129.                 int nfds, i;
131.                 for (nfds = i = 0; i <= max_i; ++i) {
132.                         if (pollfds[i].fd == 0 ||
133.                             !dbus_watch_get_enabled(watches[i])) {
134.                                 continue;
135.                         }
137.                         fds[nfds].fd = pollfds[i].fd;
138.                         fds[nfds].events = pollfds[i].events;
139.                         fds[nfds].revents = 0;
140.                         watch[nfds] = watches[i];
141.                         ++nfds;
142.                 }
144.                 if (poll(fds, nfds, -1) <= 0) {
145.                         perror("poll");
146.                         break;
147.                 }
149.                 for (i = 0; i < nfds; ++i) {
150.                         if (fds[i].revents) {
151.                                 fd_handler(fds[i].revents, watch[i]);
152.                         }
153.                 }
154.         }
155.         return 0;
156. }