lib/client/test/test.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include <libamb-client.h>
   6 #include <libamb-objects.h>
   7
   8 static void test_get_object_list()
   9 {
  10         GList *objlist;
  11         GList *item;
  12         int ret;
  13
  14         fprintf(stdout, "\n== %s ==\n", __func__);
  15
  16         ret = amb_get_object_list(&objlist);
  17         if (ret < 0) {
  18                 printf("Fail to amb_get_object_list()\n");
  19                 return ;
  20         }
  21
  22         fprintf(stdout, "  - count: %u\n", g_list_length(objlist));
  23         for (item = objlist; item != NULL; item = item->next) {
  24                 gchar *obj = item->data;
  25                 fprintf(stdout, "%s ", obj);
  26         }
  27         printf("\n");
  28
  29         amb_release_object_list(objlist);
  30 }
  31
  32 static void test_get_property_all(const char *obj_name)
  33 {
  34         GList *retlist;
  35         GList *item;
  36         int ret;
  37
  38         fprintf(stdout, "\n== %s ==\n", __func__);
  39         ret = amb_get_property_all(&retlist, obj_name);
  40         if (ret < 0) {
  41                 printf("Fail to get_property_all()\n");
  42                 return ;
  43         }
  44
  45         fprintf(stdout, "  - count: %u\n", g_list_length(retlist));
  46         for (item = retlist; item != NULL; item = item->next) {
  47                 GVariant *i = item->data;
  48                 gchar *s = g_variant_print(i, TRUE);
  49                 printf("%s\n", s);
  50                 g_free(s);
  51         }
  52
  53         amb_release_property_all(retlist);
  54 }
  55
  56 static void test_get_property_all_with_zone(const char *obj_name, int zone)
  57 {
  58         GVariant *ret;
  59         int r;
  60         gchar *s;
  61
  62         fprintf(stdout, "\n== %s ==\n", __func__);
  63         r = amb_get_property_all_with_zone(&ret, obj_name, zone);
  64         if (r < 0) {
  65                 fprintf(stderr, "Fail to get_property_all_with_zone(): %s, %d\n", obj_name, zone);
  66                 return ;
  67         }
  68
  69         s = g_variant_print(ret, TRUE);
  70         printf("%s\n", s);
  71
  72         g_free(s);
  73
  74         amb_release_property_all_with_zone(ret);
  75 }
  76
  77 static void test_set_property(const char *obj_name, const char *prop_name, int zone, GVariant *value)
  78 {
  79         GVariant *ret;
  80         gchar *s;
  81         int r;
  82
  83         fprintf(stdout, "== %s ==\n", __func__);
  84
  85         if (amb_set_property(obj_name, prop_name, zone, value) != 0) {
  86                 fprintf(stderr, "Fail to set_property()\nn");
  87                 return ;
  88         }
  89
  90         r = amb_get_property_all_with_zone(&ret, obj_name, zone);
  91         if (r < 0) {
  92                 fprintf(stderr, "Fail to get_property_all_with_zone(): %s, %d\n", obj_name, zone);
  93                 return ;
  94         }
  95
  96         s = g_variant_print(ret, TRUE);
  97         printf("%s\n", s);
  98
  99         g_free(s);
 100         amb_release_property_all_with_zone(ret);
 101 }
 102
 103 static void test_samsungcan_GearboxPosition()
 104 {
 105         struct GearboxPositionDisplayType *p;
 106         int ret = amb_get_GearboxPositionDisplay_with_zone(&p, None);
 107         if (ret != 0) {
 108                 fprintf(stderr, "Fail to %s\n", __func__);
 109                 return ;
 110         }
 111
 112         fprintf(stderr, " == GearboxPosition ==\n");
 113         fprintf(stderr, "    Time: %f\n", p->Time);
 114         fprintf(stderr, "    Zone: %d\n", p->Zone);
 115         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 116         fprintf(stderr, "    Value: ");
 117         switch(p->Value) {
 118         case PARKING:
 119                 fprintf(stderr, "PARKING\n");
 120                 break;
 121         case DRIVE:
 122                 fprintf(stderr, "DRIVE\n");
 123                 break;
 124         case NEUTRAL:
 125                 fprintf(stderr, "NEUTRAL\n");
 126                 break;
 127         case REVERSE:
 128                 fprintf(stderr, "REVERSE\n");
 129                 break;
 130         default:
 131                 fprintf(stderr, "%u (Error)\n", p->Value);
 132                 break;
 133         }
 134
 135         amb_release_data(p);
 136         return ;
 137 }
 138
 139 static void test_samsungcan_VehicleSpeed()
 140 {
 141         struct VehicleSpeedType *p;
 142         int ret = amb_get_VehicleSpeed_with_zone(&p, None);
 143         if (ret != 0) {
 144                 fprintf(stderr, "Fail to %s\n", __func__);
 145                 return ;
 146         }
 147         fprintf(stderr, " == VehicleSpeed ==\n");
 148         fprintf(stderr, "    Zone: %d\n", p->Zone);
 149         fprintf(stderr, "    Value: %d\n", p->Value);
 150         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 151         fprintf(stderr, "    Time: %f\n", p->Time);
 152
 153         amb_release_data(p);
 154         return ;
 155 }
 156
 157 static void test_LampHazardLight()
 158 {
 159         struct LampHazardLightType *p;
 160         int ret = amb_get_LampHazardLight_with_zone(&p, None);
 161         if (ret != 0) {
 162                 fprintf(stderr, "Fail to %s\n", __func__);
 163                 return ;
 164         }
 165         fprintf(stderr, " == LampHazardLight ==\n");
 166         fprintf(stderr, "    Zone: %d\n", p->Zone);
 167         fprintf(stderr, "    Value: %s\n", (p->Value) ? "Set" : "None");
 168         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 169         fprintf(stderr, "    Time: %f\n", p->Time);
 170
 171         amb_release_data(p);
 172 }
 173
 174 static void LampHazardLight_handler(const gchar *objname, gpointer data, void *user_data)
 175 {
 176         struct LampHazardLightType retdata;
 177
 178         if (!data)
 179                 return ;
 180
 181         amb_convert_LampHazardLightType(data, &retdata);
 182
 183         fprintf(stderr, " == LampHazardLight ==\n");
 184         fprintf(stderr, "    Zone: %d\n", retdata.Zone);
 185         fprintf(stderr, "    Value: %s\n", (retdata.Value) ? "Set" : "None");
 186         fprintf(stderr, "    ValueSequence: %d\n", retdata.ValueSequence);
 187         fprintf(stderr, "    Time: %f\n", retdata.Time);
 188 }
 189
 190 static void test_WarningSafetybelts()
 191 {
 192         struct WarningSafetybeltsType *p;
 193         int ret = amb_get_WarningSafetybelts_with_zone(&p, None);
 194         if (ret != 0) {
 195                 fprintf(stderr, "Fail to %s\n", __func__);
 196                 return ;
 197         }
 198         fprintf(stderr, " == WarningSafetybelt ==\n");
 199         fprintf(stderr, "    Zone: %d\n", p->Zone);
 200         fprintf(stderr, "    Value: %s\n", (p->Value) ? "Set" : "None");
 201         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 202         fprintf(stderr, "    Time: %f\n", p->Time);
 203
 204         amb_release_data(p);
 205 }
 206
 207 static void test_samsungcan_VehicleOdometer()
 208 {
 209         struct VehicleOdometerType *p;
 210         int ret = amb_get_VehicleOdometer_with_zone(&p, None);
 211         if (ret != 0) {
 212                 fprintf(stderr, "Fail to %s\n", __func__);
 213                 return ;
 214         }
 215         fprintf(stderr, " == VehicleOdometer ==\n");
 216         fprintf(stderr, "    Zone: %d\n", p->Zone);
 217         fprintf(stderr, "    Value: %d\n", p->Value);
 218         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 219         fprintf(stderr, "    Time: %f\n", p->Time);
 220
 221         amb_release_data(p);
 222         return ;
 223 }
 224
 225 static void test_TPMS_FL()
 226 {
 227         struct TPMS_FLType *p;
 228         int ret = amb_get_TPMS_FL_with_zone(&p, None);
 229         if (ret != 0) {
 230                 fprintf(stderr, "Fail to %s\n", __func__);
 231                 return ;
 232         }
 233         fprintf(stderr, " == TPMS_FL ==\n");
 234         fprintf(stderr, "    Zone: %d\n", p->Zone);
 235         fprintf(stderr, "    Value: %u\n", p->Value);
 236         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 237         fprintf(stderr, "    Time: %f\n", p->Time);
 238
 239         amb_release_data(p);
 240 }
 241
 242 static void test_FuelGage()
 243 {
 244         struct FuelGageType *p;
 245         int ret = amb_get_FuelGage_with_zone(&p, None);
 246         if (ret != 0) {
 247                 fprintf(stderr, "Fail to %s\n", __func__);
 248                 return ;
 249         }
 250         fprintf(stderr, " == FuelGage ==\n");
 251         fprintf(stderr, "    Zone: %d\n", p->Zone);
 252         fprintf(stderr, "    Value: %u\n", p->Value);
 253         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 254         fprintf(stderr, "    Time: %f\n", p->Time);
 255
 256         amb_release_data(p);
 257 }
 258
 259 static void test_OutsideTemperature()
 260 {
 261         struct OutsideTemperatureType *p;
 262         int ret = amb_get_OutsideTemperature_with_zone(&p, None);
 263         if (ret != 0) {
 264                 fprintf(stderr, "Fail to %s\n", __func__);
 265                 return ;
 266         }
 267         fprintf(stderr, " == OutsideTemperature ==\n");
 268         fprintf(stderr, "    Zone: %d\n", p->Zone);
 269         fprintf(stderr, "    Value: %f\n", p->Value);
 270         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 271         fprintf(stderr, "    Time: %f\n", p->Time);
 272
 273         amb_release_data(p);
 274 }
 275
 276 static void test_FR_KeyEvent01()
 277 {
 278         struct FR_KeyEvent01Type *p;
 279         int ret = amb_get_FR_KeyEvent01_with_zone(&p, None);
 280         if (ret != 0) {
 281                 fprintf(stderr, "Fail to %s\n", __func__);
 282                 return ;
 283         }
 284         fprintf(stderr, " == FR_KeyEvent01 ==\n");
 285         fprintf(stderr, "    Zone: %d\n", p->Zone);
 286         fprintf(stderr, "    Value: %u\n", p->Value);
 287         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 288         fprintf(stderr, "    Time: %f\n", p->Time);
 289
 290         amb_release_data(p);
 291 }
 292
 293 static void test_FR_KeyEvent02()
 294 {
 295         struct FR_KeyEvent02Type *p;
 296         int ret = amb_get_FR_KeyEvent02_with_zone(&p, None);
 297         if (ret != 0) {
 298                 fprintf(stderr, "Fail to %s\n", __func__);
 299                 return ;
 300         }
 301         fprintf(stderr, " == FR_KeyEvent02 ==\n");
 302         fprintf(stderr, "    Zone: %d\n", p->Zone);
 303         fprintf(stderr, "    Value: %u\n", p->Value);
 304         fprintf(stderr, "    ValueSequence: %d\n", p->ValueSequence);
 305         fprintf(stderr, "    Time: %f\n", p->Time);
 306
 307         amb_release_data(p);
 308 }
 309
 310 /*****************************************************************************/
 311
 312 struct user_data_test {
 313         int value;
 314         char *name;
 315 };
 316
 317 struct user_data_test *udata;
 318 struct user_data_test *udata2;
 319
 320 static int convert_VehicleOdometerType(GVariant *data, struct VehicleOdometerType *retdata)
 321 {
 322         GVariantIter *iter;
 323         gchar *key;
 324         GVariant *value;
 325         GVariant *gdata;
 326
 327         gdata = (GVariant *)data;
 328
 329
 330         g_variant_get(gdata, "a{sv}", &iter);
 331         while(g_variant_iter_loop(iter, "{sv}", &key, &value)) {
 332                 if (!g_strcmp0(key, "Zone")) {
 333                         g_variant_get(value, "i", &retdata->Zone);
 334                         fprintf(stderr, "%s: %d\n", key, retdata->Zone);
 335                 } else if (!g_strcmp0(key, "ValueSequence") || !g_strcmp0(key, "ValueSequence")) {
 336                         g_variant_get(value, "i", &retdata->ValueSequence);
 337                         fprintf(stderr, "%s: %d\n", key, retdata->ValueSequence);
 338                 } else if (!g_strcmp0(key, "Time")) {
 339                         g_variant_get(value, "d", &retdata->Time);
 340                         fprintf(stderr, "%s: %f\n", key, retdata->Time);
 341                 } else if (!g_strcmp0(key, "Value") || !g_strcmp0(key, "Vaule")) {
 342                         g_variant_get(value, "u", &retdata->Value);
 343                         fprintf(stderr, "%s: %d\n", key, retdata->Value);
 344                 }
 345         }
 346         g_variant_iter_free(iter);
 347         return 0;
 348 }
 349
 350 static void VehicleOdometer_handler(const gchar *objname, gpointer data, void *user_data)
 351 {
 352         struct VehicleOdometerType retdata;
 353         struct user_data_test *udata = (struct user_data_test *)user_data;
 354
 355         fprintf(stderr, "== User Data ==\n");
 356         fprintf(stderr, "  value: %d\n", udata->value);
 357         fprintf(stderr, "  name: %s\n", udata->name);
 358
 359
 360         if (!data)
 361                 return ;
 362
 363         convert_VehicleOdometerType(data, &retdata);
 364 }
 365
 366 static gboolean timer_callback(gpointer d)
 367 {
 368         free(udata->name);
 369         g_free(udata);
 370         exit(0);
 371
 372         return FALSE;
 373 }
 374
 375 static void test_VehicleOdometer_listen()
 376 {
 377         GMainLoop *loop;
 378         guint32 id1;
 379         guint32 id2;
 380         int rc;
 381
 382         udata = g_new0(struct user_data_test, 1);
 383         udata->value = 20;
 384         udata->name = strdup("Test Name");
 385
 386         rc = amb_register_property_changed_handler("VehicleOdometer",
 387                                         0,
 388                                         (AMB_PROPERTY_CHANGED_CALLBACK)VehicleOdometer_handler,
 389                                         (void *)udata, &id1);
 390         if (rc != 0) {
 391                 fprintf(stderr, "Fail to amb_register_property_changed_handler(): %s\n", "VehicleOdometer");
 392                 return ;
 393         }
 394
 395         udata2 = g_new0(struct user_data_test, 1);
 396         udata2->value = 100;
 397         udata2->name = strdup("Test Name2");
 398         rc = amb_register_property_changed_handler("VehicleOdometer",
 399                                         0,
 400                                         (AMB_PROPERTY_CHANGED_CALLBACK)VehicleOdometer_handler,
 401                                         (void *)udata2, &id2);
 402         if (rc != 0) {
 403                 fprintf(stderr, "Fail to amb_register_property_changed_handler(): %s\n", "VehicleOdometer");
 404                 return ;
 405         }
 406         fprintf(stderr, "id1: %u, id2: %u\n", id1, id2);
 407
 408 #if 0
 409         rc = amb_unregister_property_changed_handler("VehicleOdometer", 0, id1);
 410         if (rc != 0) {
 411                 fprintf(stderr, "Fail to amb_unregister_property_changed_handler(): %u\n", id1);
 412                 return ;
 413         }
 414 #endif
 415
 416         // g_timeout_add_seconds(10, timer_callback, "VehicleOdometer");
 417         loop = g_main_loop_new(NULL, FALSE);
 418         g_main_loop_run(loop);
 419
 420         g_main_loop_unref(loop);
 421 }
 422
 423 void test_CheckSeatHeaterL()
 424 {
 425         struct CheckSeatHeaterLType *p;
 426         int ret = amb_get_CheckSeatHeaterL_with_zone(&p, 0);
 427         if (ret != 0) {
 428                 fprintf(stderr, "Fail to %s\n", __func__);
 429                 return ;
 430         }
 431         fprintf(stderr, "Zone: %d\n", p->Zone);
 432         fprintf(stderr, "Value: %d\n", p->Value);
 433         fprintf(stderr, "ValueSequence: %d\n", p->ValueSequence);
 434         fprintf(stderr, "Time: %f\n", p->Time);
 435
 436         amb_release_data(p);
 437         return ;
 438 }
 439
 440 static void test_set_CheckSeatHeaterL(int value)
 441 {
 442         int rc;
 443
 444         rc = amb_set_CheckSeatHeaterL_with_zone(value, 0);
 445         if (rc < 0) {
 446                 fprintf(stderr, "Fail to amb_set_CheckSeatHeaterL_with_zone(): %d\n", rc);
 447                 return ;
 448         }
 449         test_CheckSeatHeaterL();
 450 }
 451
 452 void test_AirDistribution()
 453 {
 454         struct AirDistributionCIDType *p;
 455     int ret = amb_get_AirDistributionCID_with_zone(&p, 0);
 456         if (ret != 0) {
 457                 fprintf(stderr, "Fail to %s\n", __func__);
 458                 return ;
 459         }
 460         fprintf(stderr, "Zone: %d\n", p->Zone);
 461         fprintf(stderr, "Value: %d\n", p->Value);
 462         fprintf(stderr, "ValueSequence: %d\n", p->ValueSequence);
 463         fprintf(stderr, "Time: %f\n", p->Time);
 464
 465         amb_release_data(p);
 466         return ;
 467 }
 468
 469 static void test_set_AirDistribution(int value)
 470 {
 471         int rc;
 472
 473         rc = amb_set_AirDistributionCID_with_zone(value, 0);
 474         if (rc < 0) {
 475                 fprintf(stderr, "Fail to amb_set_CheckSeatHeaterL_with_zone(): %d\n", rc);
 476                 return ;
 477         }
 478
 479         test_AirDistribution();
 480 }
 481
 482 int main()
 483 {
 484         test_set_AirDistribution(2);
 485         test_set_CheckSeatHeaterL(1);
 486         test_set_CheckSeatHeaterL(2);
 487
 488         test_VehicleOdometer_listen();
 489
 490         test_FR_KeyEvent01();
 491         test_FR_KeyEvent02();
 492
 493         test_get_object_list();
 494
 495         // cansend vcan0 104#3C.00.00.00.00.00.00.00
 496         test_FuelGage();
 497
 498         // cansend vcan0 104#3C.00.00.00.00.00.00.00
 499         test_TPMS_FL();
 500
 501         // cansend vcan0 206#00.00.00.00.01.00.00.00
 502         test_LampHazardLight();
 503
 504         // cansend vcan0 206#01.00.00.00.00.00.00.00
 505         test_WarningSafetybelts();
 506         test_WarningSafetybelts_listen();
 507         test_samsungcan_VehicleOdometer();
 508         test_samsungcan_VehicleSpeed();
 509         test_samsungcan_GearboxPosition();
 510
 511 #ifdef EXAMPLE_PLUGIN
 512         test_get_property_all("ClimateControl");
 513         test_get_property_all("VehicleSpeed");
 514
 515         test_get_property_all_with_zone("ClimateControl", 5);
 516
 517         test_set_property("ClimateControl", "AirConditioning", 5, g_variant_new("b", TRUE));
 518
 519         test_samsungcan_GearboxPosition();
 520 #endif
 521
 522         return 0;
 523 }