Hello,
> reinventing the wheel could be hard and dangerous so I was thinking
> about something like yaml. On the plus side, it's easy to parse with
> libraries. On the minus side, you need to have the library on n900.
I've coded some kind of POC. It's not finished (my C is a bit
rusted...) and just print a json dump of the dbus message for the
moment.
I've only tested it on my linux workstation for the moment. You need
http://oss.metaparadigm.com/json-c/ to compile it.
If you are interested I can finish and clean it this to release it.
--- dbus-scripts.c.orig 2010-03-25 20:50:21.000000000 +0100
+++ dbus-scripts.c 2010-03-31 21:44:15.000000000 +0200
@@ -30,12 +30,15 @@
#include <unistd.h>
#include <sys/wait.h>
+#include <json.h>
#include <glib.h>
#include <glib-object.h>
#define DBUS_API_SUBJECT_TO_CHANGE 1
#include <dbus/dbus-glib-lowlevel.h>
#include <dbus/dbus.h>
+
+
#define DBUS_CONF_DIR "/etc/dbus-scripts.d"
#define DBUS_RUN_SCRIPTS ""
@@ -155,106 +158,135 @@
g_slist_foreach(script_list, (GFunc)script_file_call_if_matched, args);
}
-static void
+static struct json_object*
print_iter (DBusMessageIter *iter, dbus_bool_t literal, int depth)
{
+ json_object *my_object, *my_array;
+ my_array = json_object_new_array();
+
do {
int type = dbus_message_iter_get_arg_type (iter);
const char *str;
dbus_uint32_t uint32;
dbus_int32_t int32;
dbus_bool_t boolean;
-#if 0
+#if 1
double d;
unsigned char byte;
#endif
- if (type == DBUS_TYPE_INVALID) break;
+ if (type == DBUS_TYPE_INVALID) {
+ my_object = json_object_new_string("invalid");
+ break;
+ }
switch (type) {
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic (iter, &str);
strncpy(msgs[nmsgs], str,127);
+ my_object = json_object_new_string(str);
nmsgs++;
break;
#if 1
case DBUS_TYPE_INT32:
dbus_message_iter_get_basic (iter, &int32);
sprintf (msgsv2[nmsgsv2], "%d", int32);
+ my_object = json_object_new_int(int32);
nmsgsv2++;
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic (iter, &uint32);
sprintf (msgsv2[nmsgsv2], "%u", uint32);
+ my_object = json_object_new_int(uint32);
nmsgsv2++;
break;
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic (iter, &boolean);
sprintf (msgsv2[nmsgsv2], "%s", boolean ? "true" : "false");
+ my_object = json_object_new_boolean(boolean);
nmsgsv2++;
break;
-
#endif
-#if 0
+#if 1
case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_basic (iter, &d);
- printf ("double %g\n", d);
+ my_object = json_object_new_double(d);
break;
case DBUS_TYPE_BYTE:
dbus_message_iter_get_basic (iter, &byte);
- printf ("byte %d\n", byte);
+ my_object = json_object_new_int(byte);
break;
case DBUS_TYPE_VARIANT:
{
DBusMessageIter subiter;
-
dbus_message_iter_recurse (iter, &subiter);
-
- printf ("variant:");
- print_iter (&subiter, literal, depth);
+ my_object = print_iter (&subiter, literal, depth + 1);
break;
}
case DBUS_TYPE_ARRAY:
{
int current_type;
DBusMessageIter subiter;
+ json_object *local_object;
+ my_object = json_object_new_array();
dbus_message_iter_recurse (iter, &subiter);
- printf("[");
while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID)
{
- print_iter (&subiter, literal, depth);
+ local_object = print_iter (&subiter, literal, depth + 1);
+ json_object_array_add(my_object, local_object);
dbus_message_iter_next (&subiter);
- if (dbus_message_iter_get_arg_type (&subiter) != DBUS_TYPE_INVALID)
- printf (",");
}
- printf("]");
break;
}
case DBUS_TYPE_DICT_ENTRY:
{
DBusMessageIter subiter;
+ json_object *key, *value;
+ my_object = json_object_new_object();
dbus_message_iter_recurse (iter, &subiter);
- printf("{");
- print_iter (&subiter, literal, depth);
+ key = print_iter (&subiter, literal, depth+1);
dbus_message_iter_next (&subiter);
- print_iter (&subiter, literal, depth);
- printf("}");
+ value = print_iter (&subiter, literal, depth+1);
+ json_object_object_add(my_object, key, value);
break;
}
+
+ case DBUS_TYPE_STRUCT:
+ {
+ int current_type;
+ DBusMessageIter subiter;
+ my_object = json_object_new_array();
+
+ dbus_message_iter_recurse (iter, &subiter);
+
+ while ((current_type = dbus_message_iter_get_arg_type (&subiter)) != DBUS_TYPE_INVALID)
+ {
+ json_object *value;
+ value = print_iter (&subiter, literal, depth+1);
+ json_object_array_add(my_object, value);
+ dbus_message_iter_next (&subiter);
+ }
+ break;
+ }
+
+
#endif
default:
break;
}
+ json_object_array_add(my_array, my_object);
} while (dbus_message_iter_next (iter));
+
+ return depth == 1 ? my_array : my_object;
}
void
@@ -266,6 +298,7 @@
const char *destination;
int message_type;
int i;
+ json_object *my_object;
message_type = dbus_message_get_type (message);
sender = dbus_message_get_sender (message);
@@ -307,7 +340,8 @@
}
dbus_message_iter_init (message, &iter);
- print_iter (&iter, literal, 1);
+ my_object = print_iter (&iter, literal, 1);
+ if (debug>1) printf("my_object=%s\n", json_object_to_json_string(my_object));
if (debug) {
printf("=================================\n");
_______________________________________________
maemo-developers mailing list
[email protected]
https://lists.maemo.org/mailman/listinfo/maemo-developers
