src/ico_dbus_amb_efl.c

   1 #include <E_DBus.h>
   2 #include <stdio.h>
   3
   4 #include "ico_log.h"
   5 #include "ico_dbus_amb_efl.h"
   6
   7 #define LATER1024
   8
   9 /*============================================================================*/
  10 /* global API                                                                 */
  11 /*============================================================================*/
  12 #if defined(__GNUC__) && __GNUC__ >= 4
  13 #define ICO_API __attribute__ ((visibility("default")))
  14 #else
  15 #define ICO_API
  16 #endif
  17
  18 E_DBus_Connection *conn = NULL;
  19 static const char gBUSNAME[] = "org.automotive.message.broker";
  20 static const char gAMBManagerPath[] = "org.automotive.Manager";
  21 static const char gAMBManagerIf[] = "org.automotive.Manager";
  22 static const char gAMBInterface[] = "org.automotive.";
  23 static const char gAMBPROPERTIES_IF[] = "org.freedesktop.DBus.Properties";
  24
  25 enum MethodType {
  26     METHOD_SET,
  27     METHOD_GET,
  28     METHOD_GETHISTORY,
  29     METHOD_SUBSCRIBE,
  30     METHOD_UNSUBSCRIBE,
  31     METHOD_FIND,
  32 };
  33
  34 struct _method_args {
  35     char *objectname;
  36     char *property;
  37     int zone;
  38     dbus_type dtype;
  39     union dbus_value_variant value;
  40     ico_dbus_amb_getcb getcb;
  41     ico_dbus_amb_noticb noticb;
  42     ico_dbus_amb_findcb findcb;
  43     enum MethodType mtype;
  44     void *user_data;
  45 };
  46
  47 struct _signal_handler {
  48     char *objectname;
  49     char *property;
  50     int zone;
  51     E_DBus_Signal_Handler *handler;
  52     struct _method_args *args;
  53     struct _signal_handler *next;
  54 };
  55
  56 static struct _signal_handler *signal_handler_list = NULL;
  57
  58 static int getproperty(struct _method_args *args);
  59 static void getproperty_cb(void *data, DBusMessage *msg, DBusError *error);
  60 static void set_cb(void *data, DBusMessage *msg, DBusError *error);
  61 static void get_cb(void *data, DBusMessage *msg, DBusError *error);
  62 static void subscribe_cb(void *data, DBusMessage *msg);
  63
  64 ICO_API int ico_dbus_amb_start(void) {
  65     int ret;
  66     ret =  e_dbus_init();
  67     if (ret == 0) {
  68         return -1;
  69     }
  70     conn = e_dbus_bus_get(DBUS_BUS_SYSTEM);
  71     if (conn == NULL) {
  72         return -1;
  73     }
  74     return 0;
  75 }
  76
  77 ICO_API int ico_dbus_amb_end(void) {
  78     if (conn != NULL) {
  79         e_dbus_connection_close(conn);
  80     }
  81     return 0;
  82 }
  83
  84 ICO_API int ico_dbus_amb_get(const char *objectname, const char *property, int zone, dbus_type type, ico_dbus_amb_getcb cb, void *user_data) {
  85     struct _method_args *args;
  86
  87     if (objectname == NULL || strlen(objectname) == 0) {
  88         return -1;
  89     }
  90     if (property == NULL || strlen(property) == 0) {
  91         return -1;
  92     }
  93     args = (struct _method_args*)malloc(sizeof(struct _method_args));
  94     if (args == NULL) {
  95         return -1;
  96     }
  97     args->objectname = strdup(objectname);
  98     args->property = strdup(property);
  99     args->getcb = cb;
 100     args->zone = zone;
 101     args->dtype = type;
 102     args->mtype = METHOD_GET;
 103     args->user_data = user_data;
 104
 105     return getproperty(args);
 106 }
 107
 108 #if 0
 109 ICO_API int ico_dbus_amb_set(const char *objectname, const char *property, int zone, dbus_type type, union dbus_value_variant value) {
 110     struct _method_args *args;
 111
 112     if (objectname == NULL || strlen(objectname) == 0) {
 113         return -1;
 114     }
 115     if (property == NULL || strlen(property) == 0) {
 116         return -1;
 117     }
 118     args = (struct _method_args*)malloc(sizeof(struct _method_args));
 119     if (args == NULL) {
 120         return -1;
 121     }
 122     args->objectname = strdup(objectname);
 123     args->property = strdup(property);
 124     args->zone = zone;
 125     args->dtype = type;
 126     args->mtype = METHOD_SET;
 127     args->value = value;
 128
 129     return getproperty(args);
 130 }
 131 #endif
 132
 133 ICO_API int ico_dbus_amb_subscribe(const char *objectname, const char *property, int zone, dbus_type type, ico_dbus_amb_noticb cb, void *user_data) {
 134     struct _method_args *args;
 135     struct _signal_handler *head;
 136
 137     if (objectname == NULL || strlen(objectname) == 0) {
 138         return -1;
 139     }
 140     if (property == NULL || strlen(property) == 0) {
 141         return -1;
 142     }
 143
 144     if (signal_handler_list != NULL) {
 145         head = signal_handler_list;
 146         while (head != NULL) {
 147             if (strcmp(head->property, property) == 0 && head->zone == zone && strcmp(head->objectname, objectname) == 0) {
 148                 return -2;
 149             }
 150             head = head->next;
 151         }
 152     }
 153
 154     args = (struct _method_args*)malloc(sizeof(struct _method_args));
 155     if (args == NULL) {
 156         return -1;
 157     }
 158     args->objectname = strdup(objectname);
 159     args->property = strdup(property);
 160     args->noticb = cb;
 161     args->zone = zone;
 162     args->dtype = type;
 163     args->mtype = METHOD_SUBSCRIBE;
 164     args->user_data = user_data;
 165
 166     return getproperty(args);
 167 }
 168
 169 ICO_API int ico_dbus_amb_unsubscribe(const char *objectname, const char *property, int zone) {
 170     struct _signal_handler *head, *prev;
 171
 172     if (objectname == NULL || strlen(objectname) == 0) {
 173         return -1;
 174     }
 175     if (property == NULL || strlen(property) == 0) {
 176         return -1;
 177     }
 178
 179     if (signal_handler_list != NULL) {
 180         prev = NULL;
 181         head = signal_handler_list;
 182         while (head != NULL) {
 183             if (strcmp(head->property, property) == 0 && head->zone == zone && strcmp(head->objectname, objectname) == 0) {
 184                 if (prev == NULL) {
 185                     signal_handler_list = head->next;
 186                 }
 187                 else {
 188                     prev->next = head->next;
 189                 }
 190                 e_dbus_signal_handler_del(conn, head->handler);
 191                 free(head->objectname);
 192                 free(head->property);
 193                 free(head->args->objectname);
 194                 free(head->args->property);
 195                 free(head->args);
 196                 free(head);
 197                 return 0;
 198             }
 199             prev = head;
 200             head = head->next;
 201         }
 202     }
 203     return -2;
 204 }
 205
 206 #if 0
 207 ICO_API int ico_dbus_amb_gethistory(const char *objectname, const char *property, int zone) {
 208     return 0;
 209 }
 210 #endif
 211
 212 ICO_API int ico_dbus_amb_find_property(const char *objectname,
 213                                        const char *property,
 214                                        int zone,
 215                                        dbus_type type,
 216                                        ico_dbus_amb_findcb cb,
 217                                        void *user_data)
 218 {
 219     struct _method_args *args;
 220
 221     if (objectname == NULL || strlen(objectname) == 0) {
 222         return -1;
 223     }
 224     if (property == NULL || strlen(property) == 0) {
 225         return -1;
 226     }
 227     args = (struct _method_args*)malloc(sizeof(struct _method_args));
 228     if (args == NULL) {
 229         return -1;
 230     }
 231     args->objectname = strdup(objectname);
 232     args->property = strdup(property);
 233     args->findcb = cb;
 234     args->zone = zone;
 235     args->dtype = type;
 236     args->mtype = METHOD_FIND;
 237     args->user_data = user_data;
 238
 239     return getproperty(args);
 240 }
 241
 242 int getproperty(struct _method_args *args) {
 243     DBusMessage *msg;
 244 #ifdef LATER1024
 245     msg = dbus_message_new_method_call(gBUSNAME, "/", gAMBManagerIf, "FindObjectForZone");
 246     if (msg == NULL) {
 247         return -1;
 248     }
 249     dbus_message_append_args(msg, DBUS_TYPE_STRING, &(args->objectname), DBUS_TYPE_INT32, &(args->zone), DBUS_TYPE_INVALID);
 250 #else
 251     msg = dbus_message_new_method_call(gBUSNAME, "/", gAMBManagerIf, "findProperty");
 252     if (msg == NULL) {
 253         return -1;
 254     }
 255     dbus_message_append_args(msg, DBUS_TYPE_STRING, &(args->objectname), DBUS_TYPE_INVALID);
 256 #endif
 257     e_dbus_message_send(conn, msg, getproperty_cb, -1, (void*)args);
 258     dbus_message_unref(msg);
 259     return 0;
 260 }
 261
 262 void getproperty_cb(void *data, DBusMessage *msg, DBusError *error) {
 263     struct _method_args *args;
 264     DBusError e;
 265     char *path;
 266     DBusMessage *methodmsg;
 267     char interface[128];
 268     char *interfacep;
 269     E_DBus_Signal_Handler *sighandler;
 270     struct _signal_handler *_sig_handler, *head;
 271     struct timeval tv;
 272
 273     args = (struct _method_args*)data;
 274
 275     if (!msg) {
 276         if (NULL != args && NULL != error) {
 277             ICO_ERR("FindProperty[%s]: %s : %s", args->property,
 278                     error->name, error->message);
 279             if (METHOD_FIND == args->mtype) {
 280                 ico_dbus_error_t ico_error;
 281                 ico_error.name = error->name;
 282                 ico_error.message = error->message;
 283                 if (NULL != args->findcb) {
 284                     args->findcb(args->objectname, args->property, args->dtype,
 285                                  args->user_data, &ico_error);
 286                 }
 287                 free(args->objectname);
 288                 free(args->property);
 289                 free(args);
 290             }
 291         }
 292         else {
 293             ICO_ERR("FindProperty: %s : %s", error->name, error->message);
 294         }
 295         return;
 296     }
 297     dbus_error_init(&e);
 298
 299     dbus_message_get_args(msg, &e, DBUS_TYPE_OBJECT_PATH, &path, DBUS_TYPE_INVALID);
 300     //printf("Object Path:%s\n", path);
 301     memset(interface, 0, sizeof(interface));
 302     sprintf(interface, "%s%s", gAMBInterface, args->objectname);
 303     interfacep = interface;
 304
 305     gettimeofday(&tv, NULL);
 306     printf("%d.%06d LIB FINDPROPERTY %s %s\n", (int)tv.tv_sec, (int)tv.tv_usec, args->property, path);
 307
 308     switch(args->mtype) {
 309     case METHOD_SET :
 310         methodmsg = dbus_message_new_method_call(gBUSNAME, path, gAMBPROPERTIES_IF, "Set");
 311         switch (args->dtype) {
 312         case DBUS_TYPE_BYTE :
 313             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_BYTE, &(args->value.yval), DBUS_TYPE_INVALID);
 314             break;
 315         case DBUS_TYPE_BOOLEAN :
 316             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_BOOLEAN, &(args->value.bval), DBUS_TYPE_INVALID);
 317             break;
 318         case DBUS_TYPE_INT16 :
 319             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_INT16, &(args->value.i16val), DBUS_TYPE_INVALID);
 320             break;
 321         case DBUS_TYPE_UINT16 :
 322             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_UINT16, &(args->value.ui16val), DBUS_TYPE_INVALID);
 323             break;
 324         case DBUS_TYPE_INT32 :
 325             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_INT32, &(args->value.i32val), DBUS_TYPE_INVALID);
 326             break;
 327         case DBUS_TYPE_UINT32 :
 328             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_UINT32, &(args->value.ui32val), DBUS_TYPE_INVALID);
 329             break;
 330         case DBUS_TYPE_INT64 :
 331             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_INT64, &(args->value.i64val), DBUS_TYPE_INVALID);
 332             break;
 333         case DBUS_TYPE_UINT64 :
 334             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_UINT64, &(args->value.ui64val), DBUS_TYPE_INVALID);
 335             break;
 336         case DBUS_TYPE_DOUBLE :
 337             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_DOUBLE, &(args->value.dval), DBUS_TYPE_INVALID);
 338             break;
 339         case DBUS_TYPE_STRING :
 340             dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_STRING, &(args->value.sval), DBUS_TYPE_INVALID);
 341             break;
 342         default :
 343             break;
 344         }
 345         e_dbus_message_send(conn, methodmsg, set_cb, -1, NULL);
 346         dbus_message_unref(methodmsg);
 347         free(args->objectname);
 348         free(args->property);
 349         free(args);
 350         break;
 351     case METHOD_GET :
 352         methodmsg = dbus_message_new_method_call(gBUSNAME, path, gAMBPROPERTIES_IF, "Get");
 353         dbus_message_append_args(methodmsg, DBUS_TYPE_STRING, &interfacep, DBUS_TYPE_STRING, &(args->property), DBUS_TYPE_INVALID);
 354         e_dbus_message_send(conn, methodmsg, get_cb, -1, (void*)args);
 355         dbus_message_unref(methodmsg);
 356         break;
 357     case METHOD_GETHISTORY :
 358         break;
 359     case METHOD_SUBSCRIBE :
 360         _sig_handler = (struct _signal_handler*)malloc(sizeof(struct _signal_handler));
 361         if (_sig_handler == NULL) {
 362             free(args->objectname);
 363             free(args->property);
 364             free(args);
 365             return;
 366         }
 367         sighandler = e_dbus_signal_handler_add(conn, gBUSNAME, path, gAMBPROPERTIES_IF, "PropertiesChanged", subscribe_cb, (void*)args);
 368         _sig_handler->property = strdup(args->property);
 369         _sig_handler->objectname = strdup(args->objectname);
 370         _sig_handler->zone = args->zone;
 371         _sig_handler->handler = sighandler;
 372         _sig_handler->args = args;
 373         _sig_handler->next = NULL;
 374         if (signal_handler_list == NULL) {
 375             signal_handler_list = _sig_handler;
 376         }
 377         else {
 378             head = signal_handler_list;
 379             while (head->next != NULL) {
 380                 head = head->next;
 381             }
 382             head->next = _sig_handler;
 383         }
 384         break;
 385     case METHOD_UNSUBSCRIBE :
 386         break;
 387     case METHOD_FIND :
 388         if (NULL != args->findcb) {
 389             args->findcb(args->objectname, args->property, args->dtype,
 390                          args->user_data, NULL);
 391             free(args->objectname);
 392             free(args->property);
 393             free(args);
 394         }
 395         break;
 396     default:
 397         break;
 398     }
 399 }
 400
 401 void set_cb(void *data, DBusMessage *msg, DBusError *error) {
 402     if (!msg) {
 403         if (error) {
 404             fprintf(stderr, "set_cb::DBusError [%s: %s]\n", error->name, error->message);
 405         }
 406         return;
 407     }
 408 }
 409
 410 void get_cb(void *data, DBusMessage *msg, DBusError *error) {
 411     struct _method_args *args;
 412     DBusError e;
 413     union dbus_value_variant value;
 414     DBusMessageIter iter, variant;
 415
 416     if (!msg) {
 417         if (error) {
 418             fprintf(stderr, "get_cb::DBusError [%s: %s]\n", error->name, error->message);
 419         }
 420         return;
 421     }
 422     if (!msg || !dbus_message_iter_init(msg, &iter)) {
 423         return;
 424     }
 425     dbus_error_init(&e);
 426     args = (struct _method_args*)data;
 427     dbus_message_iter_recurse(&iter, &variant);
 428
 429     switch (args->dtype) {
 430     case DBUS_TYPE_BYTE :
 431         dbus_message_iter_get_basic(&variant, &value.yval);
 432         break;
 433     case DBUS_TYPE_BOOLEAN :
 434         dbus_message_iter_get_basic(&variant, &value.bval);
 435         break;
 436     case DBUS_TYPE_INT16 :
 437         dbus_message_iter_get_basic(&variant, &value.i16val);
 438         break;
 439     case DBUS_TYPE_UINT16 :
 440         dbus_message_iter_get_basic(&variant, &value.ui16val);
 441         break;
 442     case DBUS_TYPE_INT32 :
 443         dbus_message_iter_get_basic(&variant, &value.i32val);
 444         break;
 445     case DBUS_TYPE_UINT32 :
 446         dbus_message_iter_get_basic(&variant, &value.ui32val);
 447         break;
 448     case DBUS_TYPE_INT64 :
 449         dbus_message_iter_get_basic(&variant, &value.i64val);
 450         break;
 451     case DBUS_TYPE_UINT64 :
 452         dbus_message_iter_get_basic(&variant, &value.ui64val);
 453         break;
 454     case DBUS_TYPE_DOUBLE :
 455         dbus_message_iter_get_basic(&variant, &value.dval);
 456         break;
 457     case DBUS_TYPE_STRING :
 458         dbus_message_iter_get_basic(&variant, &value.sval);
 459         break;
 460     default :
 461         break;
 462     }
 463     args->getcb(args->objectname, args->property, args->dtype, value, args->user_data);
 464     free(args->objectname);
 465     free(args->property);
 466     free(args);
 467 }
 468
 469 static void subscribe_cb(void *data, DBusMessage *msg) {
 470     struct _method_args *args;
 471     DBusError e;
 472     union dbus_value_variant value;
 473     char *propertyname;
 474     char *sequencename;
 475     char *timename;
 476     int sequenceno;
 477     double time;
 478     struct timeval tv;
 479     int time_s;
 480     int time_ms;
 481     DBusMessageIter iter, dict, entry, variant;
 482
 483     if (!msg || !dbus_message_iter_init(msg, &iter)) {
 484         return;
 485     }
 486     dbus_error_init(&e);
 487     args = (struct _method_args*)data;
 488
 489     dbus_message_iter_next(&iter);
 490     dbus_message_iter_recurse(&iter, &dict);
 491     dbus_message_iter_recurse(&dict, &entry);
 492     dbus_message_iter_get_basic(&entry, &propertyname);
 493     if (strcmp(args->property, propertyname) != 0) {
 494         return;
 495     }
 496     dbus_message_iter_next(&entry);
 497     dbus_message_iter_recurse(&entry, &variant);
 498
 499     switch (args->dtype) {
 500     case DBUS_TYPE_BYTE :
 501         dbus_message_iter_get_basic(&variant, &value.yval);
 502         break;
 503     case DBUS_TYPE_BOOLEAN :
 504         dbus_message_iter_get_basic(&variant, &value.bval);
 505         break;
 506     case DBUS_TYPE_INT16 :
 507         dbus_message_iter_get_basic(&variant, &value.i16val);
 508         break;
 509     case DBUS_TYPE_UINT16 :
 510         dbus_message_iter_get_basic(&variant, &value.ui16val);
 511         break;
 512     case DBUS_TYPE_INT32 :
 513         dbus_message_iter_get_basic(&variant, &value.i32val);
 514         break;
 515     case DBUS_TYPE_UINT32 :
 516         dbus_message_iter_get_basic(&variant, &value.ui32val);
 517         break;
 518     case DBUS_TYPE_INT64 :
 519         dbus_message_iter_get_basic(&variant, &value.i64val);
 520         break;
 521     case DBUS_TYPE_UINT64 :
 522         dbus_message_iter_get_basic(&variant, &value.ui64val);
 523         break;
 524     case DBUS_TYPE_DOUBLE :
 525         dbus_message_iter_get_basic(&variant, &value.dval);
 526         break;
 527     case DBUS_TYPE_STRING :
 528         dbus_message_iter_get_basic(&variant, &value.sval);
 529         break;
 530     default :
 531         break;
 532     }
 533     dbus_message_iter_next(&dict);
 534     dbus_message_iter_recurse(&dict, &entry);
 535     dbus_message_iter_get_basic(&entry, &sequencename);
 536     dbus_message_iter_next(&entry);
 537     dbus_message_iter_recurse(&entry, &variant);
 538     dbus_message_iter_get_basic(&variant, &sequenceno);
 539     dbus_message_iter_next(&dict);
 540     dbus_message_iter_recurse(&dict, &entry);
 541     dbus_message_iter_get_basic(&entry, &timename);
 542     dbus_message_iter_next(&entry);
 543     dbus_message_iter_recurse(&entry, &variant);
 544     dbus_message_iter_get_basic(&variant, &time);
 545     //printf("Subscribe %s, %s:%d, %s:%f\n", propertyname, sequencename, sequenceno, timename, time);
 546     time_s = (int)time;
 547     time -= time_s;
 548     time_ms = time * 1000000;
 549     tv.tv_sec = time_s;
 550     tv.tv_usec = time_ms;
 551     args->noticb(args->objectname, args->property, args->dtype, value, sequenceno, tv, args->user_data);
 552 }