Maemo Linux手机平台系列分析：8 Maemo平台开发之 使用Glib绑定的D-Bus

 

使用 Glib 封装过的 D-Bus

这部分的内容：

• GObject介绍
• 使用XML文件定义D-Bus接口
• 自动生成proxy/stub代码
• 创建一个简单的D-Bus对象
• 通过D-Bus发布一个GType类型
• 客户端如何使用Glib封装过的D-Bus
• D-Bus的自省功能

 

GObject 介绍

为了在运行时把 GTK+ widgets 绑定到解释语言，一些牛人就用 C 语言实现了相对难以理解的面向对象的机制。根据你个人的爱好，你可以把这种面向对象称之为 GObject 或者 GType 。 GType 是 GObject 的底层基础。 GObject/GType 是 Glib 的一部分，并且单独编译成一个库： libgobject ，对于 GObject 的详细介绍，大家可以到网上 google 一下，另外还要仔细阅读其代码，非常巧妙的实现！

这里的例子：实现一个非继承的类，类的接口去访问和修改两个私有的成员变量： value1 和 vaule2, value1 是 32 位的整数， value2 是一个 gdouble 类型的数据。

我们需要实现类构造函数和对象构造函数。这里，这两个构造函数都比较简短。如果你了解 C++, 你会发现这里怎么有两个构造函数呢？ C++ 只有一个啊！不错，这就是 GObject 别扭的地方。慢慢你就会习惯的，当你很喜欢它后，你可能觉得 C++ 是个另类。因为你了解 C++ 的构造函数比较早，这个晚了些时候。

 

使用 XML 文件定义 D-Bus 接口：

 

由于我们主要的目的是做一个可以在 D-Bus 中使用的对象，因此我们从一个最简单的地方入手，通过 dbus-binding-tool 工具，这个工具会自动由 XML 文件生成 client 和 server 端的代码。我们就是把需要的接口安装 XML 语法定义在一个 XML 文件中就行了。

定义 “ 方法 ” ，即函数：用 method 来包含，其 name 是指定这个函数的名字，这个指定的名字会拷贝到生成的 stub 代码里面；函数 method 带一个参数： new_value, 用 <arg /> 包含。其中对于参数类型 (type) 的的形式，需要参考 D-Bus 的参数类型定义。

    <!-- setvalue1(int newValue): sets value1 -->

    <method name="setvalue1">

      <arg type="i" name="new_value" direction="in"/>

    </method>

 

// direction 表示入口参数还是出口参数，in:入口； out: 出口参数,如果不指定in或者out, 默认为in；

// type 的指定要参考D-Bus的类型定义，见下表；

 

其中，最难搞的就是要严格指定参数 (arg) 的类型（ type ），正是这个 type 来定义参数的数据类型， D-Bus 定义的参数类型如下：

Conventional Name	Code	Description
INVALID	0 (ASCII NUL)	Not a valid type code, used to terminate signatures
BYTE	121 (ASCII 'y')	8-bit unsigned integer
BOOLEAN	98 (ASCII 'b')	Boolean value, 0 is FALSE and 1 is TRUE . Everything else is invalid.
INT16	110 (ASCII 'n')	16-bit signed integer
UINT16	113 (ASCII 'q')	16-bit unsigned integer
INT32	105 (ASCII 'i')	32-bit signed integer
UINT32	117 (ASCII 'u')	32-bit unsigned integer
INT64	120 (ASCII 'x')	64-bit signed integer
UINT64	116 (ASCII 't')	64-bit unsigned integer
DOUBLE	100 (ASCII 'd')	IEEE 754 double
STRING	115 (ASCII 's')	UTF-8 string (must be valid UTF-8). Must be nul terminated and contain no other nul bytes.
OBJECT_PATH	111 (ASCII 'o')	Name of an object instance
SIGNATURE	103 (ASCII 'g')	A type signature
ARRAY	97 (ASCII 'a')	Array
STRUCT	114 (ASCII 'r'), 40 (ASCII '('), 41 (ASCII ')')	Struct
VARIANT	118 (ASCII 'v')	Variant type (the type of the value is part of the value itself)
DICT_ENTRY	101 (ASCII 'e'), 123 (ASCII '{'), 125 (ASCII '}')	Entry in a dict or map (array of key-value pairs)

 

我用蓝色标出的是比较常用的，你要根据你参数的需要，把上述第二列的类型码写到 XML 文件中去。开始你可能不习惯，慢慢就好了。

另外， D-Bus 本身并不限制返回参数的个数，但是 C 语言只支持一个返回参数，因此如果你需要把其它需要携带回来的参数当作出口参数处理。其它的一些高级语言并不像 C 语言这样有限制。

 

下面是 D-Bus 函数所能支持的参数类型： ( 括号中是 Glib 对应的类型 ):

• b: boolean (gboolean)
• y: 8-bit unsigned integer (guint8)
• q/n: 16-bit unsigned/signed integer (guint16/gint16)
• u/i: 32-bit unsigned/signed integer (guint32/gint32)
• t/x: 64-bit unsigned/signed integer (guint64/gint64)
• d: IEEE 754 double precision floating point number (gdouble)
• s: UTF-8 encoded text string with NUL termination (only one NUL allowed) (gchar* with additional restrictions)
• a: Array of the following type specification (case-dependent)
• o/g/r/(/)/v/e/{/}: Complex types, please see the official D-Bus documentation on type signatures.

从这个列表可以看出，我们上面定义的函数： setvalue1 有一个 32 位整形参数 (new_value). 这里定义的参数名称： new_value 将会影响到所生成的 stub 代码，对于生成文档和 D-Bus 自省是非常有用的。

下面我们再定义另外一个函数： getvalue1 , 这个函数用于返回当前对象的整数成员的值，没有入口参数，只有出口参数 : cur_value 。具体定义见下：

    <!-- getvalue1(): returns the first value (int) -->

    <method name="getvalue1">

      <arg type="i" name="cur_value" direction="out"/>

    </method>

我们已经知道， D-Bus 的 method 是隶属于 interface 的，就说一个 interface 可以有 N 个 method, 在 XML 中，我们把这些 method 元素包含在 interface 元素中，借以表达这种隶属关系。这个 interface 的名字属性是可选的，你可以指定，也可以不指定，我们强烈推荐你写上这个名字，一是防止各个模块的 interface 重名，另外一个重要的功用是为了 introspection.

再进一步， method 隶属于 interface, 那么 interface 又属于谁呢？隶属于 object, 一个 object 可以有 N 个 interface. 我们把 interface 元素包含在 node 元素内。在 XML 中， node 是最顶层的元素了。我们这个例子里面，只实现了一个 interface(binding tool 会自动增加 introspection 接口的，因此不必在 XML 文件中指定 ) ，到此，我们就写完了一个最基本的 XML 文件，如下：

<?xml version="1.0" encoding="UTF-8" ?>

<node>

 <interface name="org.maemo.Value">

    <!-- getvalue1(): returns the first value (int) -->

    <method name="getvalue1">

      <arg type="i" name="cur_value" direction="out"/>

    </method>

    <!-- setvalue1(int newValue): sets value1 -->

    <method name="setvalue1">

      <arg type="i" name="new_value" direction="in"/>

    </method>

 </interface>

</node>

 

再对上面的最基本的 XML 接口定义文件做些扩充：增加 DTD 扫描，其实这个可以不用。另外还有就是增加了 2 个函数定义： get_value2, set_value2 。

如果你需要写 XML 文件，强烈建议你在一个模板基础上写，就是拿个没有基本语法错误的模板，然后增加修改你的接口，这样容易成功，不要白手起家，不要在这个 XML 文件上面做过多的纠缠。

<?xml version="1.0" encoding="UTF-8" ?>

 

<!-- This maemo code example is licensed under a MIT-style license,

     that can be found in the file called "License" in the same

     directory as this file.

     Copyright (c) 2007 Nokia Corporation. All rights reserved. -->

 

<!-- If you keep the following DOCTYPE tag in your interface

     specification, xmllint can fetch the DTD over the Internet

     for validation automatically. // 自动对你定义的接口、方法、参数进行扫描，检查其合法性，如果你没有联网，就不要加这个了 -->

<!DOCTYPE node PUBLIC

 "-//freedesktop//DTD D-Bus Object Introspection 1.0//EN"

 "http://standards.freedesktop.org/dbus/1.0/introspect.dtd">

 

<!-- This file defines the D-Bus interface for a simple object, that

     will hold a simple state consisting of two values (one a 32-bit

     integer, the other a double).

 

     The interface name is "org.maemo.Value".

     One known reference implementation is provided for it by the

     "/GlobalValue" object found via a well-known name of

     "org.maemo.Platdev_ex". -->

 

<node>

 <interface name="org.maemo.Value">

 

    <!-- Method definitions -->

 

    <!-- getvalue1(): returns the first value (int) -->

    <method name="getvalue1">

      <!-- NOTE Naming arguments is not mandatory, but is recommended

                so that D-Bus introspection tools are more useful.

                Otherwise the arguments will be automatically named

                "arg0", "arg1" and so on. -->

      <arg type="i" name="cur_value" direction="out"/>

    </method>

 

    <!-- getvalue2(): returns the second value (double) -->

    <method name="getvalue2">

      <arg type="d" name="cur_value" direction="out"/>

    </method>

 

    <!-- setvalue1(int newValue): sets value1 -->

    <method name="setvalue1">

      <arg type="i" name="new_value" direction="in"/>

    </method>

 

    <!-- setvalue2(double newValue): sets value2 -->

    <method name="setvalue2">

      <arg type="d" name="new_value" direction="in"/>

    </method>

 

 </interface>

</node>

 

写完 XML 文件后，下面我们是不是可以使用 D-Bus 工具来生成代码了？别急！我们还要对 XML 文件做些自动检查。主要检查两个方面：是否符合 XML1.0 规范；验证 XML 结构（即：元素是否成对匹配）。结构验证的规则是由 DTD(Document Type Definition) 文档规定的。 D-Bus 规定的 XML 格式如下：

<!-- DTD for D-BUS Introspection data --> <!-- (C) 2005-02-02 David A. Wheeler; released under the D-BUS licenses,          GNU GPL version 2 (or greater) and AFL 1.1 (or greater) -->   <!-- see D-BUS specification for documentation -->   <!ELEMENT node (interface*,node*)> <!ATTLIST node name CDATA #REQUIRED>   <!ELEMENT interface (annotation*,method*,signal*,property*)> <!ATTLIST interface name CDATA #REQUIRED>   <!ELEMENT method (annotation*,arg*)> <!ATTLIST method name CDATA #REQUIRED>   <!ELEMENT arg EMPTY> <!ATTLIST arg name CDATA #IMPLIED> <!ATTLIST arg type CDATA #REQUIRED> <!-- Method arguments SHOULD include "direction",      while signal and error arguments SHOULD not (since there's no point).      The DTD format can't express that subtlety. --> <!ATTLIST arg direction (in|out) "in">   <!ELEMENT signal (arg,annotation)> <!ATTLIST signal name CDATA #REQUIRED>   <!ELEMENT property (annotation)> <!-- AKA "attribute" --> <!ATTLIST property name CDATA #REQUIRED> <!ATTLIST property type CDATA #REQUIRED> <!ATTLIST property access (read|write|readwrite) #REQUIRED>   <!ELEMENT annotation EMPTY> <!-- Generic metadata --> <!ATTLIST annotation name CDATA #REQUIRED> <!ATTLIST annotation value CDATA #REQUIRED>

然后根据这个模板对你定义的 XML 文档进行规则检查。

仅仅检查了 DTD 有效性，还不完美：因为 DTD 类型检查只是对语法做检查，并不能对语义 / 含义做检查。

为了检查语义，我们使用另外一个工具： checkxml, 把它写到你的 makefile 中：

# One extra target (which requires xmllint, from package libxml2-utils)

# is available to verify the well-formedness and the structure of the

# interface definition xml file.

#

# Use the 'checkxml' target to run the interface XML through xmllint

# verification. You'll need to be connected to the Internet in order

# for xmllint to retrieve the DTD from fd.o (unless you setup local

# catalogs, which are not covered here).

 

# ... Listing cut for brevity ...

 

# Interface XML name (used in multiple targets)

interface_xml := value-dbus-interface.xml

 

# ... Listing cut for brevity ...

 

# Special target to run DTD validation on the interface XML. Not run

# automatically (since xmllint isn't always available and also needs

# Internet connectivity).

checkxml: $(interface_xml)

      @xmllint --valid --noout $<

      @echo $< checks out ok

检查语义：

 

[sbox-CHINOOK_X86: ~/glib-dbus-sync] > make checkxml

value-dbus-interface.xml checks out ok

 

为了验证 DTD/checkxml 能否起到作用，我们简单修改一下上面的 XML 文件，增加一个 DTD 中没有规定的节点 </invalidElement> , 并且去掉一个 method 开始标签，看看效果：

[sbox-CHINOOK_X86: ~/glib-dbus-sync] > make checkxml

value-dbus-interface.xml:36: element invalidElement: validity error :

 No declaration for element invalidElement

    </invalidElement>

              ^

value-dbus-interface.xml:53: parser error :

 Opening and ending tag mismatch: method line 39 and interface

 </interface>

              ^

value-dbus-interface.xml:54: parser error :

 Opening and ending tag mismatch: interface line 22 and node

</node>

       ^

value-dbus-interface.xml:55: parser error :

 Premature end of data in tag node line 21

 

^

make: *** [checkxml] Error 1

上面，第一个被发现的错误 ( 验证错误 ) ，是由于 XML 文件不符合 DTD 的规定导致的。第二个 ( 解析错误 ) 则是没有正确的书写 XML 。

完成 XML 文件的两方面的检查后，我们开始生成代码。这个生成的代码我们叫它“ glue” 代码，什么意思呢？ glue 的本意是粘合，就是通过 glue 代码完成从 Glib 到 D-Bus 的映射关系:

图：

由 XML 文件，运行 dbus-binding-tool 命令，辅以不同的参数，可以生成 client 侧和 sever 侧的 stub 代码，生成的 client stub 和 server stub 代码正好构成了 Client/Server 结构。由这两个 stub 来完成 Glib 与 D-Bus 的互通，由于应用程序使用 Glib ，进而完成应用程序与 D-Bus 的互通。我们把 makefile 改写一下：

# Define a list of generated files so that they can be cleaned as well

cleanfiles := value-client-stub.h /

              value-server-stub.h

 

# ... Listing cut for brevity ...

 

# If the interface XML changes, the respective stub interfaces will be

# automatically regenerated. Normally this would also mean that your

# builds would fail after this since you'd be missing implementation

# code.

# 这里的—prefix前缀会反映到你的stub代码中，会在生成的结构变量和函数名称中添加这个前缀，这个前缀大家不要省略，因为这里仅仅是生成头文件，实际的实现代码需要我们自己写，但是我们需要拷贝这里的声明到.c文件中，如果不指定这个前缀，并且有多个模块的话，会冲突的；

 

# mode 指定为glib-server就生成server stub代码；指定为glib-client

# 则生成client stub代码

 

# 生成sever stub代码

value-server-stub.h: $(interface_xml)

      dbus-binding-tool --prefix=value_object --mode=glib-server /

       $< > $@

 

# 生成client stub代码

value-client-stub.h: $(interface_xml)

      dbus-binding-tool --prefix=value_object --mode=glib-client /

       $< > $@

 

# ... Listing cut for brevity ...

 

clean:

      $(RM) $(targets) $(cleanfiles) *.o

这里生成的 client 侧的代码是想通过 Glib 去访问对象的实现，而 server 侧代码则是实现对象。

生成两个头文件 :

[sbox-CHINOOK_X86: ~/glib-dbus-sync] > make value-server-stub.h value-client-stub.h

dbus-binding-tool --prefix=value_object --mode=glib-server /

 value-dbus-interface.xml > value-server-stub.h

dbus-binding-tool --prefix=value_object --mode=glib-client /

 value-dbus-interface.xml > value-client-stub.h

[sbox-CHINOOK_X86: ~/glib-dbus-sync] > ls -la value*stub.h

-rw-rw-r-- 1 user user 5184 Nov 21 14:02 value-client-stub.h

-rw-rw-r-- 1 user user 10603 Nov 21 14:02 value-server-stub.h

在开始实现实际的对象之前，我们先来瞄一眼生成的代码，看看到底什么妖蛾子。先看看 server 侧的 stub 文件：

/* Generated by dbus-binding-tool; do not edit! */

 

 /*... Listing cut for brevity ...*/

 

#include <dbus/dbus-glib.h>

static const DBusGMethodInfo dbus_glib_value_object_methods[] = {

 { (GCallback) value_object_getvalue1,

    dbus_glib_marshal_value_object_BOOLEAN__POINTER_POINTER, 0 },

 { (GCallback) value_object_getvalue2,

    dbus_glib_marshal_value_object_BOOLEAN__POINTER_POINTER, 47 },

 { (GCallback) value_object_setvalue1,

    dbus_glib_marshal_value_object_BOOLEAN__INT_POINTER, 94 },

 { (GCallback) value_object_setvalue2,

    dbus_glib_marshal_value_object_BOOLEAN__DOUBLE_POINTER, 137 },

} ;

 

const DBusGObjectInfo dbus_glib_value_object_object_info = {

 0,

 dbus_glib_value_object_methods,

  4,

"org.maemo.Value /0 getvalue1 /0 S /0 cur_value /0 O /0F/0 N /0 i /0/0 "

"org.maemo.Value /0 getvalue2 /0 S /0 cur_value /0 O /0F/0 N /0 d /0/0 "

"org.maemo.Value /0 setvalue1 /0 S /0 new_value /0 I /0 i /0/0 "

"org.maemo.Value /0 setvalue2 /0 S /0 new_value /0 I /0 d /0/0/0 " ,

" /0 " ,

" /0 "

} ;

[ The method table and object introspection data (glib-dbus-sync/value-server-stub.h) ]

在这个头文件中，生成的 4 个函数： value_object_getvalue1 , value_object_getvalue2 , value_object_setvalue1 value_object_setvalue2 . 需要我们去实现；在函数表 dbus_glib_value_object_methods ，由函数地址； marshalling 函数（用于在 Glib 和 D-Bus 之间 marshal 数据）组成。

Marshaling 的作用就是参数从一种形式转换为另外一种形式，主要是为了两种不同参数能互相兼容地传递。 Marshalling 技术是在大多数 RPC 中运用的。由于 Glib 和 D-Bus 各自有不同的类型系统，如果我们手动去写这种转换代码，是很乏味和无聊的。 Binding tool 可以帮忙解决这个问题。

上述头文件中还有一个比较有意思的东西： xxx_object_info 结构变量，这个结构变量是要注册给 D-Bus daemon 的，并且把它发布在通道 (bus) 中 ( 然后 client 侧才能发现并调用其函数 ) ，这个过程其实和我们的生活很贴近，比如公交车上的电视广告：厂家把商品 ( 看作 object) 的广告，送到广告发布商那里，广告商把该广告投放到公交车 ( 看作 D-Bus daemon) 的电视中 , 消费者 ( 看作 client) 看到了该广告，可能购买这个产品 ( 调用 object 的函数 ) 。 上面很长的字符串将会安装 interface 规范的样式进行压缩编码，对于函数名、参数等也是按照这样编码的。在这个头文件中还有很多自省的代码，这也是非常重要的部分，最后再解释。

正如头文件的第一句提示：这是 dbus-binding-tool 自动生成的代码，请不要编辑它。因为每次编译都回自动生成这个文件，你如果修改了这里的头文件，会被覆盖掉的。所以最好不要修改。那如何使用这里的代码呢，你只要拷贝粘帖这里的代码到 .c 文件中就行了。

下面我们就继续：实现在 server stub 函数表中调用的具体函数。 We'll next continue with the server implementation for the functions that are called via the method table.

 

定义一个对象，这个过程就是 GObject 的八股文：

/* This defines the per-instance state.

 

   Each GObject must start with the 'parent' definition so that common

   operations that all GObjects support can be called on it. */

typedef struct {

 /* The parent class object state. */

 GObject parent; // 要继承自GObject,这样才能用GObject的便利

 /* Our first per-object state variable. */

 gint value1;

 /* Our second per-object state variable. */

 gdouble value2;

} ValueObject;

 

/* Per class state.

 

   For the first Value implementation we only have the bare minimum,

   that is, the common implementation for any GObject class. */

typedef struct {

 /* The parent class state. */

 GObjectClass parent;

} ValueObjectClass;

下面接着定义一些宏，全是用 G_TYPE_ 开头的，你不必知道的太多，会套用就行，如果想知道的很详细，可以参考： http://maemo.org/api_refs/4.0/gobject/index.html.

/* Forward declaration of the function that will return the GType of

   the Value implementation. Not used in this program since we only

   need to push this over the D-Bus. */

GType value_object_get_type(void);

 

/* Macro for the above. It is common to define macros using the

   naming convention (seen below) for all GType implementations,

   and that's why we're going to do that here as well. */

 

/* 下面这些定义其实就是“八股文”，固定的格式，你只要套用就行，等熟悉了后，你也不会一个个写，而是拷贝模板。

*/

#define VALUE_TYPE_OBJECT (value_object_get_type())

 

#define VALUE_OBJECT(object) /

        (G_TYPE_CHECK_INSTANCE_CAST((object), /

         VALUE_TYPE_OBJECT, ValueObject))

#define VALUE_OBJECT_CLASS(klass) /

        (G_TYPE_CHECK_CLASS_CAST((klass), /

         VALUE_TYPE_OBJECT, ValueObjectClass))

#define VALUE_IS_OBJECT(object) /

        (G_TYPE_CHECK_INSTANCE_TYPE((object), /

         VALUE_TYPE_OBJECT))

#define VALUE_IS_OBJECT_CLASS(klass) /

        (G_TYPE_CHECK_CLASS_TYPE((klass), /

         VALUE_TYPE_OBJECT))

#define VALUE_OBJECT_GET_CLASS(obj) /

        (G_TYPE_INSTANCE_GET_CLASS((obj), /

         VALUE_TYPE_OBJECT, ValueObjectClass))

 

/* Utility macro to define the value_object GType structure. */

G_DEFINE_TYPE ( ValueObject, value_object, G_TYPE_OBJECT)

宏定义完成后，下面我们就着手实现实例初始化和类初始化，类的初始化中我们调用了 D-Bus 的接口函数，把我们的对象信息注册给了 D-Bus 了，就是暴露在通道（ bus ）中了，这样，客户端就能找到这个对象了。

/**

 * Since the stub generator will reference the functions from a call

 * table, the functions must be declared before the stub is included.

 */

gboolean value_object_getvalue1(ValueObject* obj, gint* value_out,

                                                  GError** error);

gboolean value_object_getvalue2(ValueObject* obj, gdouble* value_out,

                                                  GError** error);

gboolean value_object_setvalue1(ValueObject* obj, gint value_in,

                                                  GError** error);

gboolean value_object_setvalue2(ValueObject* obj, gdouble value_in,

                                                  GError** error);

 

/**

 * Pull in the stub for the server side.

 */

#include "value-server-stub.h"

 

 /*... Listing cut for brevity ...*/

 

/**

 * Per object initializer

 *

 * Only sets up internal state (both values set to zero)

 */

static void value_object_init(ValueObject* obj) {

 dbg("Called");

 

 g_assert(obj != NULL);

 

 obj->value1 = 0;

 obj->value2 = 0.0;

}

 

/**

 * Per class initializer

 *

 * Registers the type into the GLib/D-Bus wrapper so that it may add

 * its own magic.

 */

static void value_object_class_init(ValueObjectClass* klass) {

 

 dbg("Called");

 

 g_assert(klass != NULL);

 

 dbg("Binding to GLib/D-Bus");

 

 /* Time to bind this GType into the GLib/D-Bus wrappers.

     NOTE: This is not yet "publishing" the object on the D-Bus, but

           since it is only allowed to do this once per class

           creation, the safest place to put it is in the class

           initializer.

           Specifically, this function adds "method introspection

           data" to the class so that methods can be called over

           the D-Bus. */

 dbus_g_object_type_install_info(VALUE_TYPE_OBJECT,

                                 &dbus_glib_value_object_object_info);

 

 dbg("Done");

 /* All done. Class is ready to be used for instantiating objects */

}

 

下面我们实现具体的 get /set 函数，也就是 object 提供的 methods 。请注意：函数名和参数都要和 stub 头文件中的一模一样 :

/**

 * Function that gets called when someone tries to execute "setvalue1"

 * over the D-Bus. (Actually the marshaling code from the stubs gets

 * executed first, but they will eventually execute this function.)

 *

 * NOTE: If you change the name of this function, the generated

 *       stubs will no longer find it! On the other hand, if you

 *       decide to modify the interface XML, this is one of the places

 *       that you'll have to modify as well.

 *       This applies to the next four functions (including this one).

 */

gboolean value_object_setvalue1(ValueObject* obj, gint valueIn,

                                                  GError** error) {

 

 dbg("Called (valueIn=%d)", valueIn);

 

 g_assert(obj != NULL);

 

 /* Change the value. */

 obj->value1 = valueIn;

 

 /* Return success to GLib/D-Bus wrappers. In this case we don't need

     to touch the supplied error pointer-pointer. */

 return TRUE;

}

 

/**

 * Function that gets executed on "setvalue2".

 * Other than this function operating with different type input

 * parameter (and different internal value), all the comments from

 * set_value1 apply here as well.

 */

gboolean value_object_setvalue2(ValueObject* obj, gdouble valueIn,

                                                  GError** error) {

 

 dbg("Called (valueIn=%.3f)", valueIn);

 

 g_assert(obj != NULL);

 

 obj->value2 = valueIn;

 

 return TRUE;

}

 

/**

 * Function that gets executed on "getvalue1".

 */

gboolean value_object_getvalue1(ValueObject* obj, gint* valueOut,

                                                  GError** error) {

 

 dbg("Called (internal value1 is %d)", obj->value1);

 

 g_assert(obj != NULL);

 

 /* Check that the target pointer is not NULL.

     Even is the only caller for this will be the GLib-wrapper code,

     we cannot trust the stub generated code and should handle the

     situation. We will terminate with an error in this case.

 

     Another option would be to create a new GError, and store

     the error condition there. */

 g_assert(valueOut != NULL);

 

 /* Copy the current first value to caller specified memory. */

 *valueOut = obj->value1;

 

 /* Return success. */

 return TRUE;

}

 

/**

 * Function that gets executed on "getvalue2".

 * (Again, similar to "getvalue1").

 */

gboolean value_object_getvalue2(ValueObject* obj, gdouble* valueOut,

                                                  GError** error) {

 

 dbg("Called (internal value2 is %.3f)", obj->value2);

 

 g_assert(obj != NULL);

 g_assert(valueOut != NULL);

 

  *valueOut = obj->value2;

 return TRUE;

}