下载编译dbus
下载https://dbus.freedesktop.org/releases/dbus/
dbussrc1.14.0-Linux文档类资源-CSDN下载
dbus-1.14.0.tar.xz
xz -d dbus-1.14.0.tar.xz
tar xvf dbus-1.14.0.tar
2.配置编译
./configure --prefix=/data/opensrc/dbus #--prefix=/data/opensrc/dbus 指定输出目录
make
sudo make install3
cd /data/opensrc/dbus/include/dbus-1.0/dbus #/data/opensrc/dbus 是编译产物目录
sudo cp ../../../lib/dbus-1.0/include/dbus/dbus-arch-deps.h ./
把/usr/local/lib/dbus-1.0/include/dbus/dbus-arch-deps.h拷贝到/usr/include/dbus
测试代码：
/* server.c */
#include <dbus/dbus.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
static DBusHandlerResult
filter_func(DBusConnection *connection, DBusMessage *message, void *usr_data)
{
dbus_bool_t handled = false;
char *word = NULL;
DBusError dberr;
if (dbus_message_is_signal(message, "client.signal.Type", "Test")) {
dbus_error_init(&dberr);
dbus_message_get_args(message, &dberr, DBUS_TYPE_STRING,
&word, DBUS_TYPE_INVALID);
if (dbus_error_is_set(&dberr)) {
dbus_error_free(&dberr);
} else {
printf("receive message %s\n", word);
handled = true;
}
}
return (handled ? DBUS_HANDLER_RESULT_HANDLED : DBUS_HANDLER_RESULT_NOT_YET_HANDLED);
}
int main(int argc, char *argv[])
{
DBusError dberr;
DBusConnection *dbconn;
dbus_error_init(&dberr);
dbconn = dbus_bus_get(DBUS_BUS_SESSION, &dberr);
if (dbus_error_is_set(&dberr)) {
dbus_error_free(&dberr);
return -1;
}
if (!dbus_connection_add_filter(dbconn, filter_func, NULL, NULL)) {
return -1;
}
dbus_bus_add_match(dbconn, "type='signal',interface='client.signal.Type'", &dberr);
if (dbus_error_is_set(&dberr)) {
dbus_error_free(&dberr);
return -1;
}
while(dbus_connection_read_write_dispatch(dbconn, -1)) {
/* loop */
}
return 0;
} gcc -o server -I /data/opensrc/dbus/include/dbus-1.0 -L /data/opensrc/dbus/lib server.cc -l dbus-1
其中：指定头文件目录：data/opensrc/dbus/include/dbus-1.0
执行库目录：/data/opensrc/dbus/lib
链接库： dbus-1
编译成功
#include <dbus/dbus.h>
#include <stdbool.h>
#include <unistd.h>
#include <stdio.h>
#include <stdlib.h>
int db_send(DBusConnection *dbconn)
{
DBusMessage *dbmsg;
char *word;
int i;
dbmsg = dbus_message_new_signal("/client/signal/Object", // object name of the signal
"client.signal.Type", // interface name of the signal
"Test"); // name of the signal
if (!dbmsg) {
return -1;
}
word = "hello world";
if (!dbus_message_append_args(dbmsg, DBUS_TYPE_STRING, &word, DBUS_TYPE_INVALID)) {
return -1;
}
if (!dbus_connection_send(dbconn, dbmsg, NULL)) {
return -1;
}
dbus_connection_flush(dbconn);
printf("send message %s\n", word);
dbus_message_unref(dbmsg);
return 0;
}
int main(int argc, char *argv[])
{
DBusError dberr;
DBusConnection *dbconn;
int i;
dbus_error_init(&dberr);
dbconn = dbus_bus_get(DBUS_BUS_SESSION, &dberr);
if (dbus_error_is_set(&dberr)) {
return -1;
}
db_send(dbconn);
dbus_connection_unref(dbconn);
return 0;
}gcc -o client -I /data/opensrc/dbus/include/dbus-1.0 -L /data/opensrc/dbus/lib client.cc -l dbus-1
测试：
测试工具安装
sudo apt-get install d-feetDBUS基础知识
DBus作为一个轻量级的IPC被越来越多的平台接受，用于进程间通信或进程与内核的通信。
DBus进程间通信主要有三层架构：
1.底层接口层：主要是通过libdbus这个函数库，给予系统使用DBus的能力。
2.总线层：主 要Message bus daemon这个总线守护进程提供的，在Linux系统启动时运行，负责进程间的消息路由和传递，其中包括Linux内核和Linux桌面环境的消息传 递。总线守护进程可同时与多个应用程序相连，并能把来自一个应用程序的消息路由到0或者多个其他程序。
3.应用封装层：通过一系列基于特定应用程序框架将DBus的底层接口封装成友好的Wrapper库，供不同开发人员使用。比如libdbus-glib, libdbus-python.
如上图所示，Bus Daemon Process是运行在linux系统中的一个后台守护进程，dbus-daemon运行时会调用libdus的库。Application Process1代表的就是应用程序进程，通过调用特定的应用程序框架的Wrapper库与dbus-daemon进行通信。
从上图也可以看出来Application和Daemon中其实还是通过socket进行通行。
DBus的三大优点：低延迟，低开销，高可用性。
*低延迟：DBus一开始就是用来设计成避免来回传递和允许异步操作的。因此虽然在Application和Daemon之间是通过socket实现的，但是又去掉了socket的循环等待，保证了操作的实时高效。
*低开销：DBus使用一个二进制的协议，不需要转化成像XML这样的文本格式。因为DBus是主要用来机器内部的IPC,而不是为了网络上的IPC机制而准备的.所以它才能够在本机内部达到最优效果。
*高可用性：DBus是基于消息机制而不是字节流机制。它能自动管理一大堆困难的IPC问题。同样的，DBus库被设计来让程序员能够使用他们已经写好的代码。而不会让他们放弃已经写好的代码，被迫通过学习新的IPC机制来根据新的IPC特性重写这些代码。
下面根据上图介绍一下DBus中的一些基本概念。
会话总线（Session Buses）普通进程创建，可同时存在多条。会话总线属于某个进程私有，它用于进程间传递消息。
系统总线（System Bus）在引导时就会启动，它由操作系统和后台进程使用，安全性非常好，以使得任意的应用程序不能欺骗系统事件。当然，如果一个应用程序需要接受来自系统总线的消息，他也可以直接连接到系统总线中，但是他能发送的消息是受限的。
Bus Name按字面理解为总线名称貌似不是很贴切，应该是一个连接名称，主要是用来标识一个应用和消息总线的连接。从上图可以看出来，总线名称主要分为两类
"org.kde.StatusNotifierWatcher"这种形式的称为公共名（well-knownname）
":1.3"这种形式的称为唯一名（Unique Name）
公共名提供众所周知的服务。其他应用通过这个名称来使用名称对应的服务。可能有多个连接要求提供同个公共名的服 务，即多个应用连接到消息总线，要求提供同个公共名的服务。消息总线会把这些连接排在链表中，并选择一个连接提供公共名代表的服务。可以说这个提供服务的 连接拥有了这个公共名。如果这个连接退出了，消息总线会从链表中选择下一个连接提供服务。
唯一名以“:”开头，“:”后面通常是圆点分隔的两个数字，例如“:1.0”。每个连接都有一个唯一名。在一个 消息总线的生命期内，不会有两个连接有相同的唯一名。拥有公众名的连接同样有唯一名，例如在前面的图 中，“org.kde.StatusNotifierWatcher”的唯一名是“:1.51”。
每个连接都有一个唯一名，但不一定有公共名。
只有唯一名而没有公共名叫做私有连接，因为它们没有提供可以通过公共名访问的服务。
Object Paths
“org.kde.StatusNotifierWatcher”这个连接中有三个Object Paths，标识这个连接中提供了三个不同的服务，每个Object Paths表示一个服务。这个路径在连接中是唯一的。
Interfaces
在每个Object Paths下都包含有多个接口（Interfaces），举例如下接口：
org.freedesktop.DBus.Introspectable
org.freedesktop.DBus.Properties
org.kde.StatusNotifierWatcher
红色的两个是消息总线提供的标准接口，而剩下的一个是需要具体的应用去实现的。
Methods和Signals
Methods表示可以被具体调用的方法
Signals则表示的是信号，此信号可以被广播，而连接了这个信号的对象在接收到信号时就可以进行相应的处理。和Qt中的信号应该是一个意思。
技术实现
进程1（Process1）需先连接到总线（dbus_bus_get），其次构造消息（dbus_message_new_signal），然后发送消息（dbus_connection_send）到后台进程。后台进程接收消息，然后根据消息类型对消息进行不同处理（bus_dispatch_matches）。
进程2（Process2）接收消息前需要连接到总线，并告知总线自己希望得到的消息类型（dbus_bus_add_match），然后等待接收消息（dbus_connection_pop_message）。进程2（Process2）收到总线转发的消息时会根据消息类型，做不同的处理（若是信号类型则不需要发送返回值给总线）。
连接到总线
进程间通信前，需要连接到总线。调用dbus_bus_get函数连接进程到总线，建立进程和总线之间的连接（DBusConnection）。建立连接后，需要为这个连接注册名称，方便后面对这个连接进行操作，调用dbus_bus_request_name函数对连接进行注册名称。
建立连接和注册名称是在程序开始时执行，程序结束时，调用dbus_connection_close函数关闭一个连接
DBusConnection *dbus_bus_get (DBusBusType type, DBusError *error) /* 建立和总线的连接 */
int dbus_bus_request_name (DBusConnection *connection, const char *name, unsigned int flags, DBusError *error) /* 注册连接名称 */
void dbus_connection_close (DBusConnection *connection) /* 关闭连接 */信号的创建和接收
DBUS中信号是一种广播的消息，当发出一个信号，所有连接到 DBUS 总线上并注册了接受对应信号的进程，都会收到该信号。
进程发出一个信号前，需要创建一个 DBusMessage 对象来代表信号，然后追加上一些需要发出的参数，就可以发向总线了。发完之后需要释放消息对象
DBusMessage *dbus_message_new_signal (const char *path, const char *iface, const char *name) /* 创建信号类型消息 */
void dbus_message_iter_init_append ( DBusMessage *message, DBusMessageIter *iter) /* 加入参数到信号 */
dbus_bool_t dbus_connection_send ( DBusConnection *connection, DBusMessage *message, dbus_uint32_t *serial) /* 发送信号到总线 */
void dbus_message_unref (DBusMessage *message) /* 释放消息 */进程接收信号时，需先告知总线进程感兴趣的消息，然后等待接收消息
void dbus_bus_add_match ( DBusConnection *connection, const char *rule, DBusError *error) /* 告知总线感兴趣的消息 */
DBusMessage * dbus_connection_pop_message ( DBusConnection *connection) /* 接收消息 */
dbus_bool_t dbus_message_is_signal (DBusMessage *message, const char *iface, const char *signal_name) /* 判断消息是否为信号 */send_signal.cc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <unistd.h>
int send_a_signal(char *sigvalue)
{
DBusError err;
DBusConnection *connection;
DBusMessage *msg;
DBusMessageIter arg;
dbus_uint32_t serial = 0;
int ret;
//步骤1:建立与D-Bus后台的连接
dbus_error_init(&err);// initialise the errors
connection = dbus_bus_get(DBUS_BUS_SESSION, &err );// connect to the bus
if(dbus_error_is_set(&err)){
fprintf(stderr, "ConnectionErr : %s\n", err.message);
dbus_error_free(&err);
}
if(connection == NULL)
return -1;
//步骤2:给连接名分配一个well-known的名字作为Bus name，这个步骤不是必须的，可以用if 0来注释着一段代码，我们可以用这个名字来检查，是否已经开启了这个应用的另外的进程。
#if 1
ret = dbus_bus_request_name(connection, "test.singal.source", DBUS_NAME_FLAG_REPLACE_EXISTING, &err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Name Err :%s\n", err.message);
dbus_error_free(&err);
}
if(ret != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
return -1;
#endif
//步骤3:发送一个信号
//根据图，我们给出这个信号的路径（即可以指向对象），接口，以及信号名，创建一个Message
if((msg = dbus_message_new_signal("/test/signal/Object", "test.signal.Type", "Test"))== NULL){
fprintf(stderr, "MessageNULL\n");
return -1;
}
//给这个信号（messge）具体的内容
dbus_message_iter_init_append(msg, &arg);
if(!dbus_message_iter_append_basic(&arg, DBUS_TYPE_STRING, &sigvalue)){
fprintf(stderr, "Out OfMemory!\n");
return -1;
}
//步骤4: 将信号从连接中发送
if(!dbus_connection_send(connection, msg, &serial)){
fprintf(stderr, "Out of Memory!\n");
return -1;
}
dbus_connection_flush(connection);
printf("Signal Send\n");
//步骤5: 释放相关的分配的内存。
dbus_message_unref(msg);
return 0;
}
int main( int argc, char **argv){
send_a_signal("Hello,world!");
while(1);
return 0;
}
revice_signal.cc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <unistd.h>
void listen_signal()
{
DBusMessage * msg;
DBusMessageIter arg;
DBusConnection * connection;
DBusError err;
int ret;
char * sigvalue;
//步骤1:建立与D-Bus后台的连接
dbus_error_init(&err);
connection =dbus_bus_get(DBUS_BUS_SESSION, &err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"ConnectionError %s\n",err.message);
dbus_error_free(&err);
}
if(connection == NULL)
return;
//步骤2:给连接名分配一个可记忆名字test.singal.dest作为Bus name，这个步骤不是必须的,但推荐这样处理
ret =dbus_bus_request_name(connection,"test.singal.dest",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Name Error%s\n",err.message);
dbus_error_free(&err);
}
if(ret !=DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
return;
//步骤3:通知D-Bus daemon，希望监听来行接口test.signal.Type的信号
dbus_bus_add_match(connection,"type='signal',interface='test.signal.Type'",&err);
//实际需要发送东西给daemon来通知希望监听的内容，所以需要flush
dbus_connection_flush(connection);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Match Error%s\n",err.message);
dbus_error_free(&err);
}
//步骤4:在循环中监听，每隔开1秒，就去试图自己的连接中获取这个信号。这里给出的是中连接中获取任何消息的方式，所以获取后去检查一下这个消息是否我们期望的信号，并获取内容。我们也可以通过这个方式来获取method call消息。
while(1){
dbus_connection_read_write(connection,0);
msg =dbus_connection_pop_message (connection);
if(msg == NULL){
sleep(1);
continue;
}
if(dbus_message_is_signal(msg,"test.signal.Type","Test")){
if(!dbus_message_iter_init(msg,&arg))
fprintf(stderr,"MessageHas no Param");
else if(dbus_message_iter_get_arg_type(&arg)!= DBUS_TYPE_STRING)
printf("Param isnot string");
else
dbus_message_iter_get_basic(&arg,&sigvalue);
printf("Got Singal withvalue : %s\n",sigvalue);
}
dbus_message_unref(msg);
}//End of while
}
int main( int argc , char ** argv){
listen_signal();
return 0;
} 下图显示的是dbus_bus_request_name 分配的名称
函数调用和提供函数调用
dbus-1/dbus-example.c at master · duslabo/dbus-1 · GitHub
调用一个远程函数与发送一个信号原理类似，需要先创建一个消息（DBusMessage），然后通过注册在 DBUS上的名称指定发送的对象。然后追加相应的参数，调用方法分为两种，一种是阻塞式的，另一种为异步调用。异步调用的时候会得到一个“DBusMessage *” 类型的返回消息，从这个返回消息中可以获取一些返回的参数
DBusMessage *dbus_message_new_method_call (const char *destination, const char *path, const char *iface,
const char *method) /* 创建一个函数调用消息 */
void dbus_message_iter_init_append (DBusMessage *message, DBusMessageIter *iter) /* 为消息添加参数 */
dbus_bool_t dbus_connection_send_with_reply (DBusConnection *connection, DBusMessage *message,
DBusPendingCall **pending_return, int timeout_milliseconds) /* 发送消息 */
void dbus_pending_call_block (DBusPendingCall *pending) /* 阻塞等待返回值 */
DBusMessage * dbus_pending_call_steal_reply (DBusPendingCall *pending) /* 获得返回消息 */
dbus_bool_t dbus_message_iter_init (DBusMessage *message, DBusMessageIter *iter) /* 获取参数 */提供远程函数调用，首先需告知总线进程感兴趣的消息，其次从总线获取消息并判定消息是方法调用。然后从消息中获取参数进行函数执行，最后创建返回消息，并发送消息至总线，由总线转发至调用的进程。
void dbus_bus_add_match ( DBusConnection *connection, const char *rule, DBusError *error) /* 请求获取调用消息 */
DBusMessage * dbus_connection_pop_message ( DBusConnection *connection) /* 从总线获取消息 */
dbus_bool_t dbus_message_is_method_call (DBusMessage *message, const char *iface, const char *method) /* 判定消息是方法调用 */
dbus_bool_t dbus_message_iter_init (DBusMessage *message, DBusMessageIter *iter) /* 获取参数 */
DBusMessage * dbus_message_new_method_return (DBusMessage *method_call) /* 创建返回消息 */
void dbus_message_iter_init_append ( DBusMessage *message, DBusMessageIter *iter) /* 在消息中填入参数 */
dbus_bool_t dbus_connection_send ( DBusConnection *connection,DBusMessage *message,
dbus_uint32_t *serial) /* 发送返回消息 */send_method.cc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <unistd.h>
//建立与session D-Bus daemo的连接，并设定连接的名字，相关的代码已经多次使用过了
DBusConnection * connect_dbus(){
DBusError err;
DBusConnection * connection;
int ret;
//Step 1: connecting session bus
dbus_error_init(&err);
connection =dbus_bus_get(DBUS_BUS_SESSION, &err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"ConnectionErr : %s\n",err.message);
dbus_error_free(&err);
}
if(connection == NULL)
return NULL;
//step 2: 设置BUS name，也即连接的名字。
ret =dbus_bus_request_name(connection,"test.wei.source",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Name Err :%s\n",err.message);
dbus_error_free(&err);
}
if(ret !=DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
return NULL;
return connection;
}
void send_a_method_call(DBusConnection * connection,char * param)
{
DBusError err;
DBusMessage * msg;
DBusMessageIter arg;
DBusPendingCall * pending;
dbus_bool_t * stat;
dbus_uint32_t * level;
dbus_error_init(&err);
//针对目的地地址，请参考图，创建一个method call消息。// create a new method call and check for errors
msg =dbus_message_new_method_call ("test.wei.dest",// target for the method call
"/test/method/Object",// object to call on
"test.method.Type", //interface to call on
"Method"); // method name
if(msg == NULL){
printf("MessageNULL");
return;
}
//为消息添加参数。Appendarguments
dbus_message_iter_init_append(msg, &arg);
if(!dbus_message_iter_append_basic(&arg, DBUS_TYPE_STRING,¶m)){
printf("Out of Memory!");
exit(1);
}
//发送消息并获得reply的handle。Queues a message to send, as withdbus_connection_send() , but also returns aDBusPendingCall used to receive a reply to the message.
if(!dbus_connection_send_with_reply (connection, msg,&pending, -1)){
printf("Out of Memory!");
exit(1);
}
if(pending == NULL){
printf("Pending CallNULL: connection is disconnected ");
dbus_message_unref(msg);
return;
}
dbus_connection_flush(connection);
dbus_message_unref(msg);
//waiting a reply，在发送的时候，已经获取了methodreply的handle，类型为DBusPendingCall。
// block until we recieve a reply， Block until the pendingcall is completed.
dbus_pending_call_block (pending);
//get the reply message，Gets thereply, or returns NULL if none has been received yet.
msg =dbus_pending_call_steal_reply (pending);
if (msg == NULL) {
fprintf(stderr, "ReplyNull\n");
exit(1);
}
// free the pendingmessage handle
dbus_pending_call_unref(pending);
// read the parameters
if(!dbus_message_iter_init(msg, &arg))
fprintf(stderr, "Message hasno arguments!\n");
else if (dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_BOOLEAN)
fprintf(stderr, "Argument isnot boolean!\n");
else
dbus_message_iter_get_basic(&arg, &stat);
if (!dbus_message_iter_next(&arg))
fprintf(stderr, "Message hastoo few arguments!\n");
else if (dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_UINT32 )
fprintf(stderr, "Argument isnot int!\n");
else
dbus_message_iter_get_basic(&arg, &level);
printf("Got Reply: %d,%d\n", stat, level);
dbus_message_unref(msg);
}
int main( int argc , char ** argv){
DBusConnection * connection;
connection = connect_dbus();
if(connection == NULL)
return -1;
send_a_method_call(connection,"Hello, D-Bus");
return 0;
}
receive_method.cc
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dbus/dbus.h>
#include <unistd.h>
void reply_to_method_call(DBusMessage * msg, DBusConnection * conn){
DBusMessage * reply;
DBusMessageIter arg;
char * param = NULL;
dbus_bool_t stat = TRUE;
dbus_uint32_t level = 2010;
dbus_uint32_t serial = 0;
//从msg中读取参数，这个在上一次学习中学过
if(!dbus_message_iter_init(msg,&arg))
printf("Message has noargs\n");
else if(dbus_message_iter_get_arg_type(&arg)!= DBUS_TYPE_STRING)
printf("Arg is notstring!\n");
else
dbus_message_iter_get_basic(&arg,& param);
if(param == NULL) return;
//创建返回消息reply
reply = dbus_message_new_method_return(msg);
//在返回消息中填入两个参数，和信号加入参数的方式是一样的。这次我们将加入两个参数。
dbus_message_iter_init_append(reply,&arg);
if(!dbus_message_iter_append_basic(&arg,DBUS_TYPE_BOOLEAN,&stat)){
printf("Out ofMemory!\n");
exit(1);
}
if(!dbus_message_iter_append_basic(&arg,DBUS_TYPE_UINT32,&level)){
printf("Out ofMemory!\n");
exit(1);
}
//发送返回消息
if( !dbus_connection_send(conn, reply,&serial)){
printf("Out of Memory\n");
exit(1);
}
dbus_connection_flush (conn);
dbus_message_unref (reply);
}
void listen_dbus()
{
DBusMessage * msg;
DBusMessageIter arg;
DBusConnection * connection;
DBusError err;
int ret;
char * sigvalue;
dbus_error_init(&err);
//创建于session D-Bus的连接
connection =dbus_bus_get(DBUS_BUS_SESSION, &err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"ConnectionError %s\n",err.message);
dbus_error_free(&err);
}
if(connection == NULL)
return;
//设置一个BUS name：test.wei.dest
ret =dbus_bus_request_name(connection,"test.wei.dest",DBUS_NAME_FLAG_REPLACE_EXISTING,&err);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Name Error%s\n",err.message);
dbus_error_free(&err);
}
if(ret !=DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER)
return;
//要求监听某个singal：来自接口test.signal.Type的信号
dbus_bus_add_match(connection,"type='signal',interface='test.signal.Type'",&err);
dbus_connection_flush(connection);
if(dbus_error_is_set(&err)){
fprintf(stderr,"Match Error%s\n",err.message);
dbus_error_free(&err);
}
while(true){
dbus_connection_read_write(connection,0);
msg =dbus_connection_pop_message (connection);
if(msg == NULL){
sleep(1);
continue;
}
if(dbus_message_is_signal(msg,"test.signal.Type","Test")){
if(!dbus_message_iter_init(msg,&arg))
fprintf(stderr,"Message Has no Param");
else if(dbus_message_iter_get_arg_type(&arg) != DBUS_TYPE_STRING)
printf("Param isnot string");
else
dbus_message_iter_get_basic(&arg,&sigvalue);
}else if(dbus_message_is_method_call(msg,"test.method.Type","Method")){
//我们这里面先比较了接口名字和方法名字，实际上应当现比较路径
if(strcmp(dbus_message_get_path(msg),"/test/method/Object") == NULL)
reply_to_method_call(msg,connection);
}
dbus_message_unref(msg);
}
}
int main( int argc , char ** argv){
listen_dbus();
return 0;
}
dbus-send
dbus-send [--system | --session | --address=ADDRESS ]
[--address=ADDRESS]
[--dest=NAME]
[--print-reply [=literal]]
[--reply-timeout=MSEC]
[--type=TYPE]
OBJECT_PATH INTERFACE.MEMBER [CONTENTS...]
3441
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
