ua-api/src/ua-api.c

   1 /*
   2  * Copyright (c) 2018 Samsung Electronics Co., Ltd. All rights reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License")
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <ua-api.h>
  19 #include <ua-internal.h>
  20 #include <ua-common.h>
  21 #include <ua-event-handler.h>
  22 #include <ua-request-sender.h>
  23
  24 typedef struct {
  25         void *callback;
  26         void *user_data;
  27 } uam_callback_info_t;
  28
  29 gboolean is_uam_active = FALSE;
  30
  31 static uam_callback_info_t cb_info;
  32
  33 UAM_EXPORT_API int _uam_init(uam_event_cb cb, void *user_data)
  34 {
  35         FUNC_ENTRY;
  36         int ret;
  37         UAM_DBG("is_uam_active = %d", is_uam_active);
  38         ret = _uam_sync_enable(TRUE);
  39         if (UAM_ERROR_NONE != ret) {
  40                 UAM_ERR("_uam_sync_enable(TRUE) failed");
  41                 return ret;
  42         }
  43         is_uam_active = TRUE;
  44
  45         ret = _uam_register_event_handler(cb, user_data);
  46         if (UAM_ERROR_NONE == ret || UAM_ERROR_ALREADY_REGISTERED == ret) {
  47                 cb_info.callback = cb;
  48                 cb_info.user_data = user_data;
  49                 return UAM_ERROR_NONE;
  50         }
  51
  52         FUNC_EXIT;
  53         return ret;
  54 }
  55
  56 UAM_EXPORT_API int _uam_deinit(void)
  57 {
  58         FUNC_ENTRY;
  59         int ret;
  60
  61         ret = _uam_unregister_event_handler();
  62
  63         if (UAM_ERROR_NONE != ret && UAM_ERROR_NOT_REGISTERED != ret)
  64                 return ret;
  65
  66         ret = _uam_sync_enable(FALSE);
  67         if (UAM_ERROR_NONE != ret)
  68                 return ret;
  69
  70         FUNC_EXIT;
  71         return ret;
  72 }
  73
  74 UAM_EXPORT_API int _uam_get_available_sensors(unsigned int *bitmask)
  75 {
  76         FUNC_ENTRY;
  77         int ret;
  78
  79         UAM_VALIDATE_INPUT_PARAMETER(bitmask);
  80
  81         UAM_INIT_PARAMS();
  82         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  83
  84         ret = _uam_sync_request(UAM_REQUEST_GET_AVAILABLE_SENSORS,
  85                         in_param1, in_param2, in_param3, in_param4, &out_param);
  86         if (UAM_ERROR_NONE == ret)
  87                 *bitmask = g_array_index(out_param, unsigned int, 0);
  88
  89         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
  90
  91         FUNC_EXIT;
  92         return ret;
  93 }
  94
  95 UAM_EXPORT_API int _uam_get_registered_users(GPtrArray **user_list)
  96 {
  97         FUNC_ENTRY;
  98         int ret;
  99
 100         UAM_VALIDATE_INPUT_PARAMETER(user_list);
 101
 102         UAM_INIT_PARAMS();
 103         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 104
 105         ret = _uam_sync_request(UAM_REQUEST_GET_USERS,
 106                         in_param1, in_param2, in_param3, in_param4, &out_param);
 107         if (UAM_ERROR_NONE == ret && NULL != out_param) {
 108                 int i;
 109                 int count;
 110
 111                 count = (out_param->len)/sizeof(uam_user_info_s);
 112                 if (0 == count)
 113                         UAM_INFO("No registered users");
 114
 115                 for (i = 0; i < count; i++) {
 116                         uam_user_info_s *user_info = NULL;
 117                         uam_user_info_s *info;
 118
 119                         info = &g_array_index(out_param, uam_user_info_s, i);
 120                         user_info = g_memdup(info, sizeof(uam_user_info_s));
 121                         if (user_info)
 122                                 g_ptr_array_add(*user_list, (gpointer)user_info);
 123                 }
 124         }
 125
 126         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 127
 128         FUNC_EXIT;
 129         return ret;
 130 }
 131
 132 UAM_EXPORT_API int _uam_is_device_registered(uam_device_info_s *dev_info,
 133         gboolean *is_registered)
 134 {
 135         FUNC_ENTRY;
 136         int ret;
 137
 138         UAM_VALIDATE_INPUT_PARAMETER(dev_info);
 139
 140         UAM_INIT_PARAMS();
 141         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 142
 143         g_array_append_vals(in_param1, dev_info, sizeof(uam_device_info_s));
 144         ret = _uam_sync_request(UAM_REQUEST_IS_DEVICE_ADDED,
 145                         in_param1, in_param2, in_param3, in_param4, &out_param);
 146         if (UAM_ERROR_NONE == ret)
 147                 *is_registered = g_array_index(out_param, gboolean, 0);
 148
 149         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 150
 151         FUNC_EXIT;
 152         return ret;
 153 }
 154
 155 UAM_EXPORT_API int _uam_get_default_user(uam_user_info_s *user)
 156 {
 157         FUNC_ENTRY;
 158         int ret;
 159
 160         UAM_VALIDATE_INPUT_PARAMETER(user);
 161
 162         UAM_INIT_PARAMS();
 163         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 164
 165         ret = _uam_sync_request(UAM_REQUEST_GET_DEFAULT_USER,
 166                         in_param1, in_param2, in_param3, in_param4, &out_param);
 167
 168         if (UAM_ERROR_NONE == ret) {
 169                 if (out_param->len > 0) {
 170                         uam_user_info_s *info;
 171
 172                         info = &g_array_index(out_param, uam_user_info_s, 0);
 173                         memcpy(user, info, sizeof(uam_user_info_s));
 174                 } else {
 175                         UAM_WARN("out_param length is 0");
 176                 }
 177         }
 178
 179         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 180
 181         FUNC_EXIT;
 182         return ret;
 183 }
 184
 185 UAM_EXPORT_API int _uam_add_user(uam_user_info_s *user)
 186 {
 187         FUNC_ENTRY;
 188         int ret;
 189         char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 190         char str1[UAM_USER_NAME_MAX_STRING_LEN];
 191
 192         UAM_VALIDATE_INPUT_PARAMETER(user);
 193         UAM_VALIDATE_INPUT_PARAMETER(user->account);
 194         UAM_VALIDATE_INPUT_PARAMETER(user->name);
 195
 196         UAM_INIT_PARAMS();
 197         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 198
 199         g_strlcpy(str, user->account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 200         g_array_append_vals(in_param1, str, sizeof(str));
 201
 202         g_strlcpy(str1, user->name, UAM_USER_NAME_MAX_STRING_LEN);
 203         g_array_append_vals(in_param2, str1, sizeof(str1));
 204         ret = _uam_sync_request(UAM_REQUEST_ADD_USER,
 205                         in_param1, in_param2, in_param3, in_param4, &out_param);
 206
 207         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 208
 209         FUNC_EXIT;
 210         return ret;
 211 }
 212
 213 UAM_EXPORT_API int _uam_remove_user(char *account)
 214 {
 215         FUNC_ENTRY;
 216         int ret;
 217         char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 218
 219         UAM_VALIDATE_INPUT_PARAMETER(account);
 220
 221         UAM_INIT_PARAMS();
 222         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 223
 224         g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 225         g_array_append_vals(in_param1, str, sizeof(str));
 226         ret = _uam_sync_request(UAM_REQUEST_DELETE_USER,
 227                         in_param1, in_param2, in_param3, in_param4, &out_param);
 228
 229         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 230
 231         FUNC_EXIT;
 232         return ret;
 233 }
 234
 235 UAM_EXPORT_API int _uam_update_user(uam_user_info_s *user)
 236 {
 237         FUNC_ENTRY;
 238         int ret;
 239
 240         UAM_VALIDATE_INPUT_PARAMETER(user);
 241
 242         UAM_INIT_PARAMS();
 243         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 244
 245         g_array_append_vals(in_param1, user, sizeof(uam_user_info_s));
 246         ret = _uam_sync_request(UAM_REQUEST_UPDATE_USER,
 247                         in_param1, in_param2, in_param3, in_param4, &out_param);
 248
 249         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 250
 251         FUNC_EXIT;
 252         return ret;
 253 }
 254
 255 UAM_EXPORT_API int _uam_request_get_user_by_account(char *account,
 256         uam_user_info_s *user)
 257 {
 258         FUNC_ENTRY;
 259         int ret;
 260         char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 261
 262         UAM_VALIDATE_INPUT_PARAMETER(account);
 263         UAM_VALIDATE_INPUT_PARAMETER(user);
 264
 265         UAM_INIT_PARAMS();
 266         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 267
 268         g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 269         g_array_append_vals(in_param1, str, sizeof(str));
 270         ret = _uam_sync_request(UAM_REQUEST_GET_USER_BY_ACCOUNT,
 271                         in_param1, in_param2, in_param3, in_param4, &out_param);
 272
 273         if (UAM_ERROR_NONE == ret) {
 274                 if (out_param->len > 0) {
 275                         uam_user_info_s *info;
 276
 277                         info = &g_array_index(out_param, uam_user_info_s, 0);
 278                         memcpy(user, info, sizeof(uam_user_info_s));
 279                 } else {
 280                         UAM_WARN("out_param length is 0");
 281                 }
 282         }
 283
 284         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 285
 286         FUNC_EXIT;
 287         return ret;
 288 }
 289
 290 UAM_EXPORT_API int _uam_request_get_user_by_deviceid(char *device_id,
 291         uam_user_info_s *user)
 292 {
 293         FUNC_ENTRY;
 294         int ret;
 295         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
 296
 297         UAM_VALIDATE_INPUT_PARAMETER(device_id);
 298         UAM_VALIDATE_INPUT_PARAMETER(user);
 299
 300         UAM_INIT_PARAMS();
 301         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 302
 303         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 304         g_array_append_vals(in_param1, str, sizeof(str));
 305         ret = _uam_sync_request(UAM_REQUEST_GET_USER_BY_DEVICE_ID,
 306                         in_param1, in_param2, in_param3, in_param4, &out_param);
 307
 308         if (UAM_ERROR_NONE == ret) {
 309                 if (out_param->len > 0) {
 310                         uam_user_info_s * info;
 311
 312                         info = &g_array_index(out_param, uam_user_info_s, 0);
 313                         memcpy(user, info, sizeof(uam_user_info_s));
 314                 } else {
 315                         UAM_WARN("out_param length is 0");
 316                 }
 317         }
 318
 319         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 320
 321         FUNC_EXIT;
 322         return ret;
 323 }
 324
 325 UAM_EXPORT_API int _uam_request_get_user_by_mac(char *mac,
 326         uam_user_info_s *user)
 327 {
 328         FUNC_ENTRY;
 329         int ret;
 330         char str[UAM_MAC_ADDRESS_STRING_LEN];
 331
 332         UAM_VALIDATE_INPUT_PARAMETER(mac);
 333         UAM_VALIDATE_INPUT_PARAMETER(user);
 334
 335         UAM_INIT_PARAMS();
 336         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 337
 338         g_strlcpy(str, mac, UAM_MAC_ADDRESS_STRING_LEN);
 339         g_array_append_vals(in_param1, str, sizeof(str));
 340         ret = _uam_sync_request(UAM_REQUEST_GET_USER_BY_MAC,
 341                         in_param1, in_param2, in_param3, in_param4, &out_param);
 342
 343         if (UAM_ERROR_NONE == ret) {
 344                 if (out_param->len > 0) {
 345                         uam_user_info_s * info;
 346
 347                         info = &g_array_index(out_param, uam_user_info_s, 0);
 348                         memcpy(user, info, sizeof(uam_user_info_s));
 349                 } else {
 350                         UAM_WARN("out_param length is 0");
 351                 }
 352         }
 353
 354         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 355
 356         FUNC_EXIT;
 357         return ret;
 358 }
 359
 360 UAM_EXPORT_API int _uam_request_add_device(char *account,
 361         uam_device_info_s *device)
 362 {
 363         FUNC_ENTRY;
 364         int ret;
 365         char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 366
 367         UAM_VALIDATE_INPUT_PARAMETER(account);
 368         UAM_VALIDATE_INPUT_PARAMETER(device);
 369
 370         UAM_INIT_PARAMS();
 371         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 372
 373         g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 374         g_array_append_vals(in_param1, str, sizeof(str));
 375         g_array_append_vals(in_param2, device, sizeof(uam_device_info_s));
 376         ret = _uam_async_request(UAM_REQUEST_ADD_DEVICE, in_param1, in_param2,
 377                         in_param3, in_param4, cb_info.callback, cb_info.user_data);
 378
 379         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 380
 381         FUNC_EXIT;
 382         return ret;
 383 }
 384
 385 UAM_EXPORT_API int _uam_request_remove_device(char *account,
 386         uam_device_info_s *device)
 387 {
 388         FUNC_ENTRY;
 389         int ret;
 390         char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 391
 392         UAM_VALIDATE_INPUT_PARAMETER(account);
 393         UAM_VALIDATE_INPUT_PARAMETER(device);
 394
 395         UAM_INIT_PARAMS();
 396         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 397
 398         g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 399         g_array_append_vals(in_param1, str, sizeof(str));
 400         g_array_append_vals(in_param2, device, sizeof(uam_device_info_s));
 401         ret = _uam_sync_request(UAM_REQUEST_DELETE_DEVICE,
 402                         in_param1, in_param2, in_param3, in_param4, &out_param);
 403
 404         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 405
 406         FUNC_EXIT;
 407         return ret;
 408 }
 409
 410 UAM_EXPORT_API int _uam_request_remove_device_by_deviceid(
 411         const char *device_id, uam_tech_type_e tech_type)
 412 {
 413         FUNC_ENTRY;
 414         int ret;
 415         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
 416
 417         UAM_VALIDATE_INPUT_PARAMETER(device_id);
 418
 419         UAM_INIT_PARAMS();
 420         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 421
 422         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 423         g_array_append_vals(in_param1, str, sizeof(str));
 424         g_array_append_vals(in_param2, &tech_type, sizeof(int));
 425         ret = _uam_sync_request(UAM_REQUEST_DELETE_DEVICE_BY_DEVICE_ID,
 426                         in_param1, in_param2, in_param3, in_param4, &out_param);
 427
 428         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 429
 430         FUNC_EXIT;
 431         return ret;
 432 }
 433
 434 UAM_EXPORT_API int _uam_request_remove_device_by_mac(const char *mac)
 435 {
 436         FUNC_ENTRY;
 437         int ret;
 438         char str[UAM_MAC_ADDRESS_STRING_LEN];
 439
 440         UAM_VALIDATE_INPUT_PARAMETER(mac);
 441
 442         UAM_INIT_PARAMS();
 443         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 444
 445         g_strlcpy(str, mac, UAM_MAC_ADDRESS_STRING_LEN);
 446         g_array_append_vals(in_param1, str, sizeof(str));
 447         ret = _uam_sync_request(UAM_REQUEST_DELETE_DEVICE_BY_MAC,
 448                         in_param1, in_param2, in_param3, in_param4, &out_param);
 449
 450         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 451
 452         FUNC_EXIT;
 453         return ret;
 454 }
 455
 456 UAM_EXPORT_API int _uam_request_get_device_by_deviceid(const char *device_id,
 457                 uam_tech_type_e tech_type, uam_device_info_s *device)
 458 {
 459         FUNC_ENTRY;
 460         int ret;
 461         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
 462
 463         UAM_VALIDATE_INPUT_PARAMETER(device_id);
 464         UAM_VALIDATE_INPUT_PARAMETER(device);
 465
 466         UAM_INIT_PARAMS();
 467         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 468
 469         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
 470         g_array_append_vals(in_param1, str, sizeof(str));
 471         g_array_append_vals(in_param2, &tech_type, sizeof(int));
 472         ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_BY_DEVICE_ID,
 473                         in_param1, in_param2, in_param3, in_param4, &out_param);
 474
 475         if (UAM_ERROR_NONE == ret) {
 476                 if (out_param->len > 0) {
 477                         uam_device_info_s* info;
 478
 479                         info = &g_array_index(out_param, uam_device_info_s, 0);
 480                         memcpy(device, info, sizeof(uam_device_info_s));
 481                 } else {
 482                         UAM_WARN("out_param length is 0");
 483                 }
 484         }
 485
 486         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 487
 488         FUNC_EXIT;
 489         return ret;
 490 }
 491
 492 UAM_EXPORT_API int _uam_request_get_device_by_mac(const char *mac,
 493         uam_device_info_s *device)
 494 {
 495         FUNC_ENTRY;
 496         int ret;
 497         char str[UAM_MAC_ADDRESS_STRING_LEN];
 498
 499         UAM_VALIDATE_INPUT_PARAMETER(mac);
 500         UAM_VALIDATE_INPUT_PARAMETER(device);
 501
 502         UAM_INIT_PARAMS();
 503         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 504
 505         g_strlcpy(str, mac, sizeof(str));
 506         g_array_append_vals(in_param1, str, UAM_MAC_ADDRESS_STRING_LEN);
 507         ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_BY_MAC,
 508                         in_param1, in_param2, in_param3, in_param4, &out_param);
 509
 510         if (UAM_ERROR_NONE == ret) {
 511                 if (out_param->len > 0) {
 512                         uam_device_info_s* info;
 513
 514                         info = &g_array_index(out_param, uam_device_info_s, 0);
 515                         memcpy(device, info, sizeof(uam_device_info_s));
 516                 } else {
 517                         UAM_WARN("out_param length is 0");
 518                 }
 519         }
 520
 521         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 522
 523         FUNC_EXIT;
 524         return ret;
 525 }
 526
 527 UAM_EXPORT_API int _uam_request_get_devices(GPtrArray **devices_list)
 528 {
 529         FUNC_ENTRY;
 530         int ret;
 531
 532         UAM_VALIDATE_INPUT_PARAMETER(devices_list);
 533
 534         UAM_INIT_PARAMS();
 535         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 536
 537         ret = _uam_sync_request(UAM_REQUEST_GET_DEVICES,
 538                         in_param1, in_param2, in_param3, in_param4, &out_param);
 539         if (UAM_ERROR_NONE == ret && NULL != out_param) {
 540                 int i;
 541                 int count;
 542
 543                 count = (out_param->len)/sizeof(uam_device_info_s);
 544                 if (0 == count)
 545                         UAM_INFO("No registered device");
 546
 547                 for (i = 0; i < count; i++) {
 548                         uam_device_info_s *device_info = NULL;
 549                         uam_device_info_s *info;
 550
 551                         info = &g_array_index(out_param, uam_device_info_s, i);
 552                         device_info = g_memdup(info, sizeof(uam_device_info_s));
 553                         if (device_info)
 554                                 g_ptr_array_add(*devices_list, (gpointer)device_info);
 555                 }
 556         }
 557
 558         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 559
 560         FUNC_EXIT;
 561         return ret;
 562 }
 563
 564 UAM_EXPORT_API int _uam_request_get_user_devices(char *account,
 565         GPtrArray **devices_list)
 566 {
 567         FUNC_ENTRY;
 568         int ret;
 569         char str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 570
 571         UAM_VALIDATE_INPUT_PARAMETER(devices_list);
 572         UAM_VALIDATE_INPUT_PARAMETER(account);
 573
 574         UAM_INIT_PARAMS();
 575         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 576
 577         g_strlcpy(str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 578         g_array_append_vals(in_param1, str, sizeof(str));
 579
 580         ret = _uam_sync_request(UAM_REQUEST_GET_USER_DEVICES,
 581                         in_param1, in_param2, in_param3, in_param4, &out_param);
 582         if (UAM_ERROR_NONE == ret && NULL != out_param) {
 583                 int i;
 584                 int count;
 585
 586                 count = (out_param->len)/sizeof(uam_device_info_s);
 587                 if (0 == count)
 588                         UAM_INFO("No registered device");
 589
 590                 for (i = 0; i < count; i++) {
 591                         uam_device_info_s *device_info = NULL;
 592                         uam_device_info_s *info;
 593
 594                         info = &g_array_index(out_param, uam_device_info_s, i);
 595                         device_info = g_memdup(info, sizeof(uam_device_info_s));
 596                         if (device_info)
 597                                 g_ptr_array_add(*devices_list, (gpointer)device_info);
 598                 }
 599         }
 600
 601         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 602
 603         FUNC_EXIT;
 604         return ret;
 605 }
 606
 607 UAM_EXPORT_API int _uam_request_set_detection_threshold(
 608         unsigned int sensor_type, int presence_threshold, int absence_threshold)
 609 {
 610         FUNC_ENTRY;
 611         int ret;
 612
 613         UAM_INIT_PARAMS();
 614         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 615
 616         g_array_append_vals(in_param1, &sensor_type, sizeof(unsigned int));
 617         g_array_append_vals(in_param2, &presence_threshold, sizeof(int));
 618         g_array_append_vals(in_param3, &absence_threshold, sizeof(int));
 619
 620         ret = _uam_sync_request(UAM_REQUEST_SET_DETECTION_THRESHOLD,
 621                         in_param1, in_param2, in_param3, in_param4, &out_param);
 622
 623         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 624
 625         FUNC_EXIT;
 626         return ret;
 627 }
 628
 629 UAM_EXPORT_API int _uam_start_presence_detection(unsigned int bitmask,
 630         const char *service)
 631 {
 632         FUNC_ENTRY;
 633         int ret;
 634         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 635
 636         UAM_VALIDATE_INPUT_PARAMETER(service);
 637
 638         UAM_INIT_PARAMS();
 639         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 640
 641         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 642         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 643         g_array_append_vals(in_param2, svc_str, sizeof(svc_str));
 644
 645         ret = _uam_sync_request(UAM_REQUEST_START_PRESENCE_DETECTION,
 646                         in_param1, in_param2, in_param3, in_param4, &out_param);
 647
 648         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 649
 650         FUNC_EXIT;
 651         return ret;
 652 }
 653
 654 UAM_EXPORT_API int _uam_stop_presence_detection(unsigned int bitmask,
 655         const char *service)
 656 {
 657         FUNC_ENTRY;
 658         int ret;
 659         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 660
 661         UAM_VALIDATE_INPUT_PARAMETER(service);
 662
 663         UAM_INIT_PARAMS();
 664         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 665
 666         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 667         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 668         g_array_append_vals(in_param2, svc_str, sizeof(svc_str));
 669
 670         ret = _uam_sync_request(UAM_REQUEST_STOP_PRESENCE_DETECTION,
 671                         in_param1, in_param2, in_param3, in_param4, &out_param);
 672
 673         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 674
 675         FUNC_EXIT;
 676         return ret;
 677 }
 678
 679 UAM_EXPORT_API int _uam_start_absence_detection(unsigned int bitmask,
 680         const char *service)
 681 {
 682         FUNC_ENTRY;
 683         int ret;
 684         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 685
 686         UAM_VALIDATE_INPUT_PARAMETER(service);
 687
 688         UAM_INIT_PARAMS();
 689         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 690
 691         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 692         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 693         g_array_append_vals(in_param2, svc_str, sizeof(svc_str));
 694
 695         ret = _uam_sync_request(UAM_REQUEST_START_ABSENCE_DETECTION,
 696                         in_param1, in_param2, in_param3, in_param4, &out_param);
 697
 698         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 699
 700         FUNC_EXIT;
 701         return ret;
 702 }
 703
 704 UAM_EXPORT_API int _uam_stop_absence_detection(unsigned int bitmask,
 705         const char *service)
 706 {
 707         FUNC_ENTRY;
 708         int ret;
 709         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 710
 711         UAM_VALIDATE_INPUT_PARAMETER(service);
 712
 713         UAM_INIT_PARAMS();
 714         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 715
 716         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 717         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 718         g_array_append_vals(in_param2, svc_str, sizeof(svc_str));
 719
 720         ret = _uam_sync_request(UAM_REQUEST_STOP_ABSENCE_DETECTION,
 721                         in_param1, in_param2, in_param3, in_param4, &out_param);
 722
 723         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 724
 725         FUNC_EXIT;
 726         return ret;
 727 }
 728
 729 UAM_EXPORT_API int _uam_start_location_detection(unsigned int bitmask,
 730         const char *service)
 731 {
 732         FUNC_ENTRY;
 733         int ret;
 734         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 735
 736         UAM_VALIDATE_INPUT_PARAMETER(service);
 737
 738         UAM_INIT_PARAMS();
 739         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 740
 741         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 742         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 743         g_array_append_vals(in_param2, svc_str, sizeof(svc_str));
 744
 745         ret = _uam_sync_request(UAM_REQUEST_START_LOCATION_DETECTION,
 746                         in_param1, in_param2, in_param3, in_param4, &out_param);
 747
 748         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 749
 750         FUNC_EXIT;
 751         return ret;
 752 }
 753
 754 UAM_EXPORT_API int _uam_stop_location_detection(unsigned int bitmask,
 755         const char *service)
 756 {
 757         FUNC_ENTRY;
 758         int ret;
 759         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 760
 761         UAM_VALIDATE_INPUT_PARAMETER(service);
 762
 763         UAM_INIT_PARAMS();
 764         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 765
 766         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 767         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 768         g_array_append_vals(in_param2, svc_str, sizeof(svc_str));
 769
 770         ret = _uam_sync_request(UAM_REQUEST_STOP_LOCATION_DETECTION,
 771                         in_param1, in_param2, in_param3, in_param4, &out_param);
 772
 773         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 774
 775         FUNC_EXIT;
 776         return ret;
 777 }
 778
 779 UAM_EXPORT_API int _uam_is_sensor_ready(unsigned int sensor, gboolean* status)
 780 {
 781         FUNC_ENTRY;
 782         int ret;
 783
 784         UAM_VALIDATE_INPUT_PARAMETER(status);
 785         UAM_INIT_PARAMS();
 786         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 787
 788         g_array_append_vals(in_param1, &sensor, sizeof(unsigned int));
 789         ret = _uam_sync_request(UAM_REQUEST_IS_SENSOR_READY,
 790                         in_param1, in_param2, in_param3, in_param4, &out_param);
 791         if (UAM_ERROR_NONE == ret)
 792                 *status = g_array_index(out_param, gboolean, 0);
 793
 794         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 795
 796         FUNC_EXIT;
 797         return ret;
 798 }
 799
 800 UAM_EXPORT_API int _uam_set_low_power_mode(unsigned int sensor_bitmask,
 801         gboolean mode)
 802 {
 803         FUNC_ENTRY;
 804         int ret;
 805
 806         UAM_INIT_PARAMS();
 807         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 808
 809         UAM_INFO("sensor_bitmask [%x] mode [%d]", sensor_bitmask, mode);
 810
 811         g_array_append_vals(in_param1, &sensor_bitmask, sizeof(unsigned int));
 812         g_array_append_vals(in_param2, &mode, sizeof(gboolean));
 813         ret = _uam_sync_request(UAM_REQUEST_SET_LOW_POWER_MODE,
 814                         in_param1, in_param2, in_param3, in_param4, &out_param);
 815
 816         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 817
 818         FUNC_EXIT;
 819         return ret;
 820 }
 821
 822 UAM_EXPORT_API int _uam_get_detection_window(unsigned int *window)
 823 {
 824         FUNC_ENTRY;
 825         int ret;
 826
 827         UAM_VALIDATE_INPUT_PARAMETER(window);
 828
 829         UAM_INIT_PARAMS();
 830         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 831
 832         ret = _uam_sync_request(UAM_REQUEST_GET_DETECTION_WINDOW,
 833                         in_param1, in_param2, in_param3, in_param4, &out_param);
 834         if (UAM_ERROR_NONE == ret) {
 835                 *window = g_array_index(out_param, unsigned int, 0);
 836                 UAM_INFO("Detection window: %d", *window);
 837         }
 838
 839         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 840
 841         FUNC_EXIT;
 842         return ret;
 843 }
 844
 845 UAM_EXPORT_API int _uam_set_detection_window(unsigned int window)
 846 {
 847         FUNC_ENTRY;
 848         int ret;
 849
 850         UAM_INIT_PARAMS();
 851         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 852
 853         g_array_append_vals(in_param1, &window, sizeof(unsigned int));
 854         ret = _uam_sync_request(UAM_REQUEST_SET_DETECTION_WINDOW,
 855                         in_param1, in_param2, in_param3, in_param4, &out_param);
 856
 857         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 858
 859         FUNC_EXIT;
 860         return ret;
 861 }
 862
 863 UAM_EXPORT_API int _uam_start_search_active_devices(unsigned int bitmask,
 864         int detection_period)
 865 {
 866         FUNC_ENTRY;
 867         int ret;
 868
 869         UAM_INIT_PARAMS();
 870         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 871
 872         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 873         g_array_append_vals(in_param2, &detection_period, sizeof(int));
 874         ret = _uam_sync_request(UAM_REQUEST_START_SEARCH_ACTIVE_DEVICES,
 875                         in_param1, in_param2, in_param3, in_param4, &out_param);
 876
 877         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 878
 879         FUNC_EXIT;
 880         return ret;
 881 }
 882
 883 UAM_EXPORT_API int _uam_stop_search_active_devices(unsigned int bitmask)
 884 {
 885         FUNC_ENTRY;
 886         int ret;
 887
 888         UAM_INIT_PARAMS();
 889         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 890
 891         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
 892         ret = _uam_sync_request(UAM_REQUEST_STOP_SEARCH_ACTIVE_DEVICES,
 893                         in_param1, in_param2, in_param3, in_param4, &out_param);
 894
 895         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 896
 897         FUNC_EXIT;
 898         return ret;
 899 }
 900
 901 UAM_EXPORT_API int _uam_register_app(const char *app_id, unsigned short uid)
 902 {
 903         FUNC_ENTRY;
 904         int ret;
 905         uam_app_info_s app_info;
 906
 907         UAM_INIT_PARAMS();
 908         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 909
 910         g_strlcpy(app_info.app_id, app_id, UAM_APP_ID_MAX_STRING_LEN);
 911         app_info.uid = uid;
 912
 913         g_array_append_vals(in_param1, &app_info, sizeof(uam_app_info_s));
 914         ret = _uam_sync_request(UAM_REQUEST_REGISTER_APP,
 915                         in_param1, in_param2, in_param3, in_param4, &out_param);
 916
 917         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 918
 919         FUNC_EXIT;
 920         return ret;
 921 }
 922
 923 UAM_EXPORT_API int _uam_deregister_app(const char *app_id, unsigned short uid)
 924 {
 925         FUNC_ENTRY;
 926         int ret;
 927         uam_app_info_s app_info;
 928
 929         UAM_INIT_PARAMS();
 930         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 931
 932         g_strlcpy(app_info.app_id, app_id, UAM_APP_ID_MAX_STRING_LEN);
 933         app_info.uid = uid;
 934
 935         g_array_append_vals(in_param1, &app_info, sizeof(uam_app_info_s));
 936         ret = _uam_sync_request(UAM_REQUEST_DEREGISTER_APP,
 937                         in_param1, in_param2, in_param3, in_param4, &out_param);
 938
 939         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 940
 941         FUNC_EXIT;
 942         return ret;
 943 }
 944
 945 UAM_EXPORT_API int _uam_service_add_user(const char *service, const char *account)
 946 {
 947         FUNC_ENTRY;
 948         int ret;
 949         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 950         char account_str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 951
 952         UAM_VALIDATE_INPUT_PARAMETER(service);
 953         UAM_VALIDATE_INPUT_PARAMETER(account);
 954
 955         UAM_INIT_PARAMS();
 956         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 957
 958         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 959         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
 960
 961         g_strlcpy(account_str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 962         g_array_append_vals(in_param2, account_str, sizeof(account_str));
 963
 964         ret = _uam_sync_request(UAM_REQUEST_ADD_USER_TO_SERVICE,
 965                         in_param1, in_param2, in_param3, in_param4, &out_param);
 966
 967         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 968
 969         FUNC_EXIT;
 970         return ret;
 971 }
 972
 973 UAM_EXPORT_API int _uam_service_remove_user(const char *service,
 974         const char *account)
 975 {
 976         FUNC_ENTRY;
 977         int ret;
 978         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
 979         char account_str[UAM_USER_ACCOUNT_MAX_STRING_LEN];
 980
 981         UAM_VALIDATE_INPUT_PARAMETER(service);
 982         UAM_VALIDATE_INPUT_PARAMETER(account);
 983
 984         UAM_INIT_PARAMS();
 985         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 986
 987         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
 988         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
 989
 990         g_strlcpy(account_str, account, UAM_USER_ACCOUNT_MAX_STRING_LEN);
 991         g_array_append_vals(in_param2, account_str, sizeof(account_str));
 992
 993         ret = _uam_sync_request(UAM_REQUEST_REMOVE_USER_FROM_SERVICE,
 994                         in_param1, in_param2, in_param3, in_param4, &out_param);
 995
 996         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
 997
 998         FUNC_EXIT;
 999         return ret;
1000 }
1001
1002 UAM_EXPORT_API int _uam_service_add_device(const char *service, char *device_id,
1003         uam_tech_type_e tech_type)
1004 {
1005         FUNC_ENTRY;
1006         int ret;
1007         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1008         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
1009
1010         UAM_VALIDATE_INPUT_PARAMETER(service);
1011         UAM_VALIDATE_INPUT_PARAMETER(device_id);
1012
1013         UAM_INIT_PARAMS();
1014         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1015
1016         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1017         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1018
1019         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
1020         g_array_append_vals(in_param2, str, sizeof(str));
1021         g_array_append_vals(in_param3, &tech_type, sizeof(int));
1022
1023         ret = _uam_sync_request(UAM_REQUEST_ADD_DEVICE_TO_SERVICE,
1024                         in_param1, in_param2, in_param3, in_param4, &out_param);
1025
1026         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1027
1028         FUNC_EXIT;
1029         return ret;
1030 }
1031
1032 UAM_EXPORT_API int _uam_service_remove_device(const char *service,
1033         char *device_id, uam_tech_type_e tech_type)
1034 {
1035         FUNC_ENTRY;
1036         int ret;
1037         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1038         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
1039
1040         UAM_VALIDATE_INPUT_PARAMETER(service);
1041         UAM_VALIDATE_INPUT_PARAMETER(device_id);
1042
1043         UAM_INIT_PARAMS();
1044         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1045
1046         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1047         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1048
1049         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
1050         g_array_append_vals(in_param2, str, sizeof(str));
1051         g_array_append_vals(in_param3, &tech_type, sizeof(int));
1052
1053         ret = _uam_sync_request(UAM_REQUEST_REMOVE_DEVICE_FROM_SERVICE,
1054                         in_param1, in_param2, in_param3, in_param4, &out_param);
1055
1056         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1057
1058         FUNC_EXIT;
1059         return ret;
1060 }
1061
1062 UAM_EXPORT_API int _uam_service_set_device_discriminant(const char *service,
1063         const char *device_id, uam_tech_type_e tech_type, gboolean discriminant)
1064 {
1065         FUNC_ENTRY;
1066         int ret;
1067         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1068         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
1069
1070         UAM_VALIDATE_INPUT_PARAMETER(service);
1071         UAM_VALIDATE_INPUT_PARAMETER(device_id);
1072
1073         UAM_INIT_PARAMS();
1074         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1075
1076         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1077         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1078
1079         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
1080         g_array_append_vals(in_param2, str, sizeof(str));
1081         g_array_append_vals(in_param3, &tech_type, sizeof(int));
1082         g_array_append_vals(in_param4, &discriminant, sizeof(gboolean));
1083
1084         ret = _uam_sync_request(UAM_REQUEST_SET_DEVICE_SERVICES_DISCRIMINANT,
1085                         in_param1, in_param2, in_param3, in_param4, &out_param);
1086
1087         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1088
1089         FUNC_EXIT;
1090         return ret;
1091 }
1092
1093 UAM_EXPORT_API int _uam_service_get_device_discriminant(const char *service,
1094         const char *device_id, uam_tech_type_e tech_type, gboolean *discriminant)
1095 {
1096         FUNC_ENTRY;
1097         int ret;
1098         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1099         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
1100
1101         UAM_VALIDATE_INPUT_PARAMETER(service);
1102         UAM_VALIDATE_INPUT_PARAMETER(device_id);
1103
1104         UAM_INIT_PARAMS();
1105         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1106
1107         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1108         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1109
1110         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
1111         g_array_append_vals(in_param2, str, sizeof(str));
1112         g_array_append_vals(in_param3, &tech_type, sizeof(int));
1113
1114         ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_DISCRIMINANT,
1115                         in_param1, in_param2, in_param3, in_param4, &out_param);
1116         if (UAM_ERROR_NONE == ret) {
1117                 *discriminant = g_array_index(out_param, gboolean, 0);
1118                 UAM_INFO("Discriminant: %d for %s-%d-%s", *discriminant, device_id,
1119                 tech_type, service);
1120         }
1121         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1122
1123         FUNC_EXIT;
1124         return ret;
1125 }
1126
1127 UAM_EXPORT_API int _uam_service_get_device_last_seen(const char *service,
1128         const char *device_id, uam_tech_type_e tech_type, unsigned long long *last_seen)
1129 {
1130         FUNC_ENTRY;
1131         int ret;
1132         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1133         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
1134
1135         UAM_VALIDATE_INPUT_PARAMETER(service);
1136         UAM_VALIDATE_INPUT_PARAMETER(device_id);
1137
1138         UAM_INIT_PARAMS();
1139         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1140
1141         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1142         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1143
1144         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
1145         g_array_append_vals(in_param2, str, sizeof(str));
1146         g_array_append_vals(in_param3, &tech_type, sizeof(int));
1147
1148         ret = _uam_sync_request(UAM_REQUEST_GET_DEVICE_SERVICES_LAST_SEEN,
1149                         in_param1, in_param2, in_param3, in_param4, &out_param);
1150         if (UAM_ERROR_NONE == ret) {
1151                 *last_seen = g_array_index(out_param, unsigned long long, 0);
1152                 UAM_INFO("Last seen: %llu for %s-%d-%s", *last_seen, device_id,
1153                 tech_type, service);
1154         }
1155         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1156
1157         FUNC_EXIT;
1158         return ret;
1159 }
1160
1161
1162 UAM_EXPORT_API int _uam_set_service_detection_cycle(const char *service,
1163         unsigned int cycle)
1164 {
1165         FUNC_ENTRY;
1166         int ret;
1167         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1168
1169         UAM_VALIDATE_INPUT_PARAMETER(service);
1170
1171         UAM_INIT_PARAMS();
1172         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1173
1174         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1175         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1176         g_array_append_vals(in_param2, &cycle, sizeof(unsigned int));
1177
1178         ret = _uam_sync_request(UAM_REQUEST_SET_SERVICE_DETECTION_CYCLE,
1179                         in_param1, in_param2, in_param3, in_param4, &out_param);
1180
1181         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1182
1183         FUNC_EXIT;
1184         return ret;
1185 }
1186
1187 UAM_EXPORT_API int _uam_get_service_detection_cycle(const char *service,
1188         unsigned int *cycle)
1189 {
1190         FUNC_ENTRY;
1191         int ret;
1192         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1193
1194         UAM_VALIDATE_INPUT_PARAMETER(service);
1195
1196         UAM_INIT_PARAMS();
1197         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1198
1199         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1200         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1201
1202         ret = _uam_sync_request(UAM_REQUEST_GET_SERVICE_DETECTION_CYCLE,
1203                         in_param1, in_param2, in_param3, in_param4, &out_param);
1204         if (UAM_ERROR_NONE == ret) {
1205                 *cycle = g_array_index(out_param, unsigned int, 0);
1206                 UAM_INFO("Detection cycle: %d for %s", *cycle, service);
1207         }
1208
1209         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1210
1211         FUNC_EXIT;
1212         return ret;
1213 }
1214
1215 UAM_EXPORT_API int _uam_db_reset(void)
1216 {
1217         FUNC_ENTRY;
1218         int ret;
1219
1220         UAM_INIT_PARAMS();
1221         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1222
1223         ret = _uam_sync_request(UAM_REQUEST_RESET_DB,
1224                         in_param1, in_param2, in_param3, in_param4, &out_param);
1225
1226         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1227
1228         FUNC_EXIT;
1229         return ret;
1230 }
1231
1232 UAM_EXPORT_API int _uam_get_default_service(uam_service_info_s *service)
1233 {
1234         FUNC_ENTRY;
1235         int ret;
1236
1237
1238         UAM_VALIDATE_INPUT_PARAMETER(service);
1239
1240         UAM_INIT_PARAMS();
1241         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1242
1243         ret = _uam_sync_request(UAM_REQUEST_GET_DEFAULT_SERVICE,
1244                         in_param1, in_param2, in_param3, in_param4, &out_param);
1245
1246         if (UAM_ERROR_NONE == ret) {
1247                 if (out_param->len > 0) {
1248                         uam_service_info_s *info;
1249
1250                         info = &g_array_index(out_param, uam_service_info_s, 0);
1251                         memcpy(service, info, sizeof(uam_service_info_s));
1252                 } else {
1253                         UAM_WARN("out_param length is 0");
1254                 }
1255         }
1256
1257         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1258
1259         FUNC_EXIT;
1260         return ret;
1261 }
1262
1263 UAM_EXPORT_API int _uam_register_service(uam_service_info_s *service)
1264 {
1265         FUNC_ENTRY;
1266         int ret;
1267
1268         UAM_VALIDATE_INPUT_PARAMETER(service);
1269         UAM_VALIDATE_INPUT_PARAMETER(service->name);
1270
1271         UAM_INIT_PARAMS();
1272         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1273
1274         g_array_append_vals(in_param1, service, sizeof(uam_service_info_s));
1275         ret = _uam_sync_request(UAM_REQUEST_REGISTER_SERVICE,
1276                         in_param1, in_param2, in_param3, in_param4, &out_param);
1277
1278         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1279
1280         FUNC_EXIT;
1281         return ret;
1282 }
1283
1284 UAM_EXPORT_API int _uam_update_service(uam_service_info_s *service)
1285 {
1286         FUNC_ENTRY;
1287         int ret;
1288
1289         UAM_VALIDATE_INPUT_PARAMETER(service);
1290         UAM_VALIDATE_INPUT_PARAMETER(service->name);
1291
1292         UAM_INIT_PARAMS();
1293         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1294
1295         g_array_append_vals(in_param1, service, sizeof(uam_service_info_s));
1296         ret = _uam_sync_request(UAM_REQUEST_UPDATE_SERVICE,
1297                         in_param1, in_param2, in_param3, in_param4, &out_param);
1298
1299         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1300
1301         FUNC_EXIT;
1302         return ret;
1303 }
1304
1305 UAM_EXPORT_API int _uam_unregister_service(uam_service_info_s *service)
1306 {
1307         FUNC_ENTRY;
1308         int ret;
1309         char str1[UAM_SERVICE_MAX_STRING_LEN];
1310
1311         UAM_VALIDATE_INPUT_PARAMETER(service);
1312         UAM_VALIDATE_INPUT_PARAMETER(service->name);
1313
1314         UAM_INIT_PARAMS();
1315         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1316
1317         g_strlcpy(str1, service->name, UAM_SERVICE_MAX_STRING_LEN);
1318         g_array_append_vals(in_param1, str1, sizeof(str1));
1319         ret = _uam_sync_request(UAM_REQUEST_UNREGISTER_SERVICE,
1320                         in_param1, in_param2, in_param3, in_param4, &out_param);
1321
1322         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1323
1324         FUNC_EXIT;
1325         return ret;
1326 }
1327
1328 UAM_EXPORT_API int _uam_get_registered_services(GPtrArray **service_list)
1329 {
1330         FUNC_ENTRY;
1331         int ret;
1332
1333         UAM_VALIDATE_INPUT_PARAMETER(service_list);
1334
1335         UAM_INIT_PARAMS();
1336         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1337
1338         ret = _uam_sync_request(UAM_REQUEST_GET_SERVICES,
1339                         in_param1, in_param2, in_param3, in_param4, &out_param);
1340         if (UAM_ERROR_NONE == ret && NULL != out_param) {
1341                 int i;
1342                 int count;
1343
1344                 count = (out_param->len)/sizeof(uam_service_info_s);
1345                 if (0 == count)
1346                         UAM_INFO("No registered services");
1347
1348                 for (i = 0; i < count; i++) {
1349                         uam_service_info_s *service_info = NULL;
1350                         uam_service_info_s *info;
1351
1352                         info = &g_array_index(out_param, uam_service_info_s, i);
1353                         service_info = g_memdup(info, sizeof(uam_service_info_s));
1354                         if (service_info)
1355                                 g_ptr_array_add(*service_list, (gpointer)service_info);
1356                 }
1357         }
1358
1359         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1360
1361         FUNC_EXIT;
1362         return ret;
1363 }
1364
1365 UAM_EXPORT_API int _uam_request_get_service_devices(char *svc_name,
1366         GPtrArray **devices_list)
1367 {
1368         FUNC_ENTRY;
1369         int ret;
1370         char str[UAM_SERVICE_MAX_STRING_LEN];
1371
1372         UAM_VALIDATE_INPUT_PARAMETER(devices_list);
1373         UAM_VALIDATE_INPUT_PARAMETER(svc_name);
1374
1375         UAM_INIT_PARAMS();
1376         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1377
1378         g_strlcpy(str, svc_name, UAM_SERVICE_MAX_STRING_LEN);
1379         g_array_append_vals(in_param1, str, sizeof(str));
1380
1381         ret = _uam_sync_request(UAM_REQUEST_GET_SERVICE_DEVICES,
1382                         in_param1, in_param2, in_param3, in_param4, &out_param);
1383         if (UAM_ERROR_NONE == ret && NULL != out_param) {
1384                 int i;
1385                 int count;
1386
1387                 count = (out_param->len)/sizeof(uam_device_info_s);
1388                 if (0 == count)
1389                         UAM_INFO("No registered device");
1390
1391                 for (i = 0; i < count; i++) {
1392                         uam_device_info_s *device_info = NULL;
1393                         uam_device_info_s *info;
1394
1395                         info = &g_array_index(out_param, uam_device_info_s, i);
1396                         device_info = g_memdup(info, sizeof(uam_device_info_s));
1397                         if (device_info)
1398                                 g_ptr_array_add(*devices_list, (gpointer)device_info);
1399                 }
1400         }
1401
1402         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1403
1404         FUNC_EXIT;
1405         return ret;
1406 }
1407
1408 UAM_EXPORT_API int _uam_request_get_service_users(char *svc_name,
1409         GPtrArray **users_list)
1410 {
1411         FUNC_ENTRY;
1412         int ret;
1413         char str[UAM_SERVICE_MAX_STRING_LEN];
1414
1415         UAM_VALIDATE_INPUT_PARAMETER(users_list);
1416         UAM_VALIDATE_INPUT_PARAMETER(svc_name);
1417
1418         UAM_INIT_PARAMS();
1419         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1420
1421         g_strlcpy(str, svc_name, UAM_SERVICE_MAX_STRING_LEN);
1422         g_array_append_vals(in_param1, str, sizeof(str));
1423
1424         ret = _uam_sync_request(UAM_REQUEST_GET_SERVICE_USERS,
1425                         in_param1, in_param2, in_param3, in_param4, &out_param);
1426         if (UAM_ERROR_NONE == ret && NULL != out_param) {
1427                 int i;
1428                 int count;
1429
1430                 count = (out_param->len)/sizeof(uam_user_info_s);
1431                 if (0 == count)
1432                         UAM_INFO("No registered user for this service");
1433
1434                 for (i = 0; i < count; i++) {
1435                         uam_user_info_s *user_info = NULL;
1436                         uam_user_info_s  *info;
1437
1438                         info = &g_array_index(out_param, uam_user_info_s, i);
1439                         user_info  = g_memdup(info, sizeof(uam_user_info_s));
1440                         if (user_info)
1441                                 g_ptr_array_add(*users_list, (gpointer)user_info);
1442                 }
1443         }
1444
1445         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1446
1447         FUNC_EXIT;
1448         return ret;
1449 }
1450
1451 UAM_EXPORT_API int _uam_request_update_device(uam_device_info_s *device)
1452 {
1453         FUNC_ENTRY;
1454         int ret;
1455
1456         UAM_VALIDATE_INPUT_PARAMETER(device);
1457
1458         UAM_INIT_PARAMS();
1459         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1460
1461         g_array_append_vals(in_param1, device, sizeof(uam_device_info_s));
1462         ret = _uam_sync_request(UAM_REQUEST_UPDATE_DEVICE,
1463                         in_param1, in_param2, in_param3, in_param4, &out_param);
1464
1465         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1466
1467         FUNC_EXIT;
1468         return ret;
1469 }
1470
1471 UAM_EXPORT_API int _uam_add_ibeacon_adv_data(unsigned int adv_len, const char *ibeacon_adv)
1472 {
1473         FUNC_ENTRY;
1474         int ret;
1475         int len = adv_len;
1476         char payload_buf[UAM_IBEACON_ADV_MAX_LEN];
1477
1478         UAM_INIT_PARAMS();
1479         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1480
1481         if (adv_len >= UAM_IBEACON_ADV_MAX_LEN)
1482                 len = UAM_IBEACON_ADV_MAX_LEN;
1483
1484         memset(payload_buf, 0x00, UAM_IBEACON_ADV_MAX_LEN);
1485         memcpy(payload_buf, ibeacon_adv, len);
1486
1487         g_array_append_vals(in_param1, &len, sizeof(unsigned int));
1488         g_array_append_vals(in_param2, &payload_buf, sizeof(payload_buf));
1489         ret = _uam_sync_request(UAM_REQUEST_ADD_IBEACON_ADV,
1490                         in_param1, in_param2, in_param3, in_param4, &out_param);
1491
1492         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1493
1494         FUNC_EXIT;
1495         return ret;
1496 }
1497
1498 UAM_EXPORT_API int _uam_request_add_payload(uam_ble_payload_s *payload,
1499         char *device_id, uam_tech_type_e tech_type)
1500 {
1501         FUNC_ENTRY;
1502         int ret;
1503         char str[UAM_DEVICE_ID_MAX_STRING_LEN];
1504
1505         UAM_VALIDATE_INPUT_PARAMETER(payload);
1506         UAM_VALIDATE_INPUT_PARAMETER(device_id);
1507
1508         UAM_INIT_PARAMS();
1509         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1510
1511         g_array_append_vals(in_param1, payload, sizeof(uam_ble_payload_s));
1512         g_strlcpy(str, device_id, UAM_DEVICE_ID_MAX_STRING_LEN);
1513         g_array_append_vals(in_param2, str, sizeof(str));
1514         g_array_append_vals(in_param3, &tech_type, sizeof(int));
1515
1516         ret = _uam_sync_request(UAM_REQUEST_ADD_PAYLOAD,
1517                         in_param1, in_param2, in_param3, in_param4, &out_param);
1518
1519         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1520
1521         FUNC_EXIT;
1522         return ret;
1523 }
1524
1525 UAM_EXPORT_API int _uam_service_add_payload(const char *service,
1526         uam_ble_payload_s *payload)
1527 {
1528         FUNC_ENTRY;
1529         int ret;
1530         char svc_str[UAM_SERVICE_MAX_STRING_LEN];
1531
1532         UAM_VALIDATE_INPUT_PARAMETER(service);
1533         UAM_VALIDATE_INPUT_PARAMETER(payload);
1534
1535         UAM_INIT_PARAMS();
1536         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1537
1538         g_strlcpy(svc_str, service, UAM_SERVICE_MAX_STRING_LEN);
1539         g_array_append_vals(in_param1, svc_str, sizeof(svc_str));
1540
1541         g_array_append_vals(in_param2, payload, sizeof(uam_ble_payload_s));
1542
1543         ret = _uam_sync_request(UAM_REQUEST_ADD_PAYLOAD_TO_SERVICE,
1544                         in_param1, in_param2, in_param3, in_param4, &out_param);
1545
1546         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1547
1548         FUNC_EXIT;
1549         return ret;
1550 }
1551
1552 UAM_EXPORT_API int _uam_get_added_payloads(GPtrArray **payload_list)
1553 {
1554         FUNC_ENTRY;
1555         int ret;
1556
1557         UAM_VALIDATE_INPUT_PARAMETER(payload_list);
1558
1559         UAM_INIT_PARAMS();
1560         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1561
1562         ret = _uam_sync_request(UAM_REQUEST_GET_PAYLOADS,
1563                         in_param1, in_param2, in_param3, in_param4, &out_param);
1564         if (UAM_ERROR_NONE == ret && NULL != out_param) {
1565                 int i;
1566                 int count;
1567
1568                 count = (out_param->len)/sizeof(uam_ble_payload_s);
1569                 if (0 == count)
1570                         UAM_INFO("No registered payloads");
1571
1572                 for (i = 0; i < count; i++) {
1573                         uam_ble_payload_s *payload_info = NULL;
1574                         uam_ble_payload_s *info;
1575
1576                         info = &g_array_index(out_param, uam_ble_payload_s, i);
1577                         payload_info = g_memdup(info, sizeof(uam_ble_payload_s));
1578                         if (payload_info)
1579                                 g_ptr_array_add(*payload_list, (gpointer)payload_info);
1580                 }
1581         }
1582
1583         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1584
1585         FUNC_EXIT;
1586         return ret;
1587 }
1588
1589 UAM_EXPORT_API int _uam_request_add_sensor(unsigned int bitmask)
1590 {
1591         FUNC_ENTRY;
1592         int ret;
1593
1594         UAM_INIT_PARAMS();
1595         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1596
1597         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
1598         ret = _uam_sync_request(UAM_REQUEST_ADD_SENSOR,
1599                         in_param1, in_param2, in_param3, in_param4, &out_param);
1600
1601         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1602
1603         FUNC_EXIT;
1604         return ret;
1605 }
1606
1607 UAM_EXPORT_API int _uam_request_remove_sensor(unsigned int bitmask)
1608 {
1609         FUNC_ENTRY;
1610         int ret;
1611
1612         UAM_INIT_PARAMS();
1613         UAM_ALLOC_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1614
1615         g_array_append_vals(in_param1, &bitmask, sizeof(unsigned int));
1616         ret = _uam_sync_request(UAM_REQUEST_REMOVE_SENSOR,
1617                         in_param1, in_param2, in_param3, in_param4, &out_param);
1618
1619         UAM_FREE_PARAMS(in_param1, in_param2, in_param3, in_param4, out_param);
1620
1621         FUNC_EXIT;
1622         return ret;
1623 }