src/framework/data-adapter/interface_item.c

   1 /*
   2  * sync-agent
   3  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
   4  *
   5  * Licensed under the Apache License, Version 2.0 (the License);
   6  * you may not use this file except in compliance with the License.
   7  * You may obtain a copy of the License at
   8  *
   9  *     http://www.apache.org/licenses/LICENSE-2.0
  10  *
  11  * Unless required by applicable law or agreed to in writing, software
  12  * distributed under the License is distributed on an "AS IS" BASIS,
  13  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14  * See the License for the specific language governing permissions and
  15  * limitations under the License.
  16  */
  17
  18 #include <pthread.h>
  19 #include <glib.h>
  20 #include <glib/gprintf.h>
  21
  22 #include "utility/sync_util.h"
  23 #include "data-adapter/agent_handler_manager.h"
  24 #include "data-adapter/agent_handler_manager_internal.h"
  25 #include "data-adapter/agent.h"
  26
  27 #include "data-adapter/interface_item.h"
  28 #include "data-adapter/changelog.h"
  29
  30 #ifndef EXPORT_API
  31 #define EXPORT_API __attribute__ ((visibility("default")))
  32 #endif
  33
  34 #ifndef SYNC_AGENT_LOG
  35 #undef LOG_TAG
  36 #define LOG_TAG "AF_DACI"
  37 #endif
  38
  39 EXPORT_API sync_agent_da_return_e sync_agent_create_item(sync_agent_da_item_s ** sync_agent_item)
  40 {
  41         _EXTERN_FUNC_ENTER;
  42
  43         *sync_agent_item = (sync_agent_da_item_s *) calloc(1, sizeof(sync_agent_da_item_s));
  44         if (*sync_agent_item == NULL) {
  45                 _DEBUG_ERROR("calloc failed !!");
  46                 return SYNC_AGENT_DA_ERRORS;
  47         }
  48
  49         _EXTERN_FUNC_EXIT;
  50
  51         return SYNC_AGENT_DA_SUCCESS;
  52 }
  53
  54 EXPORT_API sync_agent_da_return_e sync_agent_add_item(sync_agent_da_item_s * sync_agent_item, char **item_id, int use_changelog)
  55 {
  56         _EXTERN_FUNC_ENTER;
  57
  58         retvm_if(sync_agent_item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
  59
  60         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
  61
  62 //      item_id = (char **) calloc(count, sizeof(char *));
  63 //      if (item_id == NULL) {
  64 //              _DEBUG_ERROR("calloc failed !!");
  65 //      }
  66 //
  67 //      for (i; i < count; i++) {
  68 //              if (use_changelog == 1) {
  69 //                      ret = sync_agent_changelog_add_item_new(sync_agent_item, item_id);
  70 //              } else {
  71 //                      ret = sync_agent_add_item_new(sync_agent_item, count, item_id);
  72 //              }
  73 //
  74 //              if (ret != SYNC_AGENT_DA_SUCCESS) {
  75 //                      _DEBUG_ERROR("add item failed !!");
  76 //                      return ret;
  77 //              }
  78 //      }
  79
  80         if (use_changelog == 1) {
  81                 ret = sync_agent_changelog_add_item_new(sync_agent_item, item_id);
  82                 if (ret != SYNC_AGENT_DA_SUCCESS) {
  83                         _DEBUG_ERROR("da_changelog_add_item_internal() failed !!");
  84                 }
  85         } else {
  86                 ret = sync_agent_add_item_new(sync_agent_item, 1, item_id);
  87                 if (ret != SYNC_AGENT_DA_SUCCESS) {
  88                         _DEBUG_ERROR("da_add_item_internal() failed !!");
  89                 }
  90         }
  91
  92         _EXTERN_FUNC_EXIT;
  93
  94         return ret;
  95 }
  96
  97 EXPORT_API sync_agent_da_return_e sync_agent_add_bulk_item(sync_agent_da_item_s * sync_agent_item, char **item_id, int use_changelog)
  98 {
  99         _EXTERN_FUNC_ENTER;
 100
 101         retvm_if(sync_agent_item == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_item_s is NULL !!");
 102
 103         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 104
 105         if (use_changelog == 1) {
 106                 ret = sync_agent_changelog_add_item_new(sync_agent_item, item_id);
 107                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 108                         _DEBUG_ERROR("da_changelog_add_item_internal() failed !!");
 109                 }
 110         } else {
 111                 ret = sync_agent_add_item_new(sync_agent_item, 1, item_id);
 112                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 113                         _DEBUG_ERROR("da_add_item_internal() failed !!");
 114                 }
 115         }
 116
 117         _EXTERN_FUNC_EXIT;
 118         return ret;
 119 }
 120
 121 EXPORT_API sync_agent_da_return_e sync_agent_update_item(char *item_id, int use_changelog)
 122 {
 123         _EXTERN_FUNC_ENTER;
 124
 125         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 126
 127         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 128         sync_agent_da_item_s *get_item = NULL;
 129
 130         if (use_changelog == 1) {
 131                 ret = sync_agent_create_item(&get_item);
 132                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 133                         _DEBUG_ERROR("sync_agent_create_item() failed !!");
 134                         return ret;
 135                 }
 136
 137                 ret = sync_agent_get_item(item_id, &get_item);
 138                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 139                         _DEBUG_ERROR("sync_agent_get_item() failed !!");
 140                         int ret_temp = sync_agent_free_item(get_item);
 141                         if (ret_temp != SYNC_AGENT_DA_SUCCESS) {
 142                                 _DEBUG_ERROR("sync_agent_free_item() failed !!");
 143                         }
 144                         return ret;
 145                 }
 146
 147                 ret = sync_agent_changelog_update_item_new(get_item->account_id, item_id);
 148                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 149                         _DEBUG_ERROR("sync_agent_changelog_update_item_new() failed !!");
 150                 }
 151
 152                 ret = sync_agent_free_item(get_item);
 153                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 154                         _DEBUG_ERROR("sync_agent_free_item() failed !!");
 155                 }
 156         } else {
 157                 ret = SYNC_AGENT_DA_SUCCESS;
 158         }
 159
 160         _EXTERN_FUNC_EXIT;
 161
 162         return ret;
 163 }
 164
 165 EXPORT_API sync_agent_da_return_e sync_agent_delete_item(char *item_id, int use_changelog)
 166 {
 167         _EXTERN_FUNC_ENTER;
 168
 169         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 170
 171         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 172         sync_agent_da_item_s *get_item = NULL;
 173
 174         if (use_changelog == 1) {
 175                 ret = sync_agent_create_item(&get_item);
 176                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 177                         _DEBUG_ERROR("sync_agent_create_item() failed, ret[%d]", ret);
 178                         return ret;
 179                 }
 180
 181                 ret = sync_agent_get_item_account_id(item_id, &get_item);
 182                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 183                         _DEBUG_ERROR("sync_agent_get_item_account_id() failed, ret[%d]", ret);
 184                         int ret_temp = sync_agent_free_item(get_item);
 185                         if (ret_temp != SYNC_AGENT_DA_SUCCESS) {
 186                                 _DEBUG_ERROR("sync_agent_get_item_account_id() failed, ret[%d]", ret);
 187                         }
 188                         return ret;
 189                 }
 190
 191                 ret = sync_agent_changelog_delete_item_new(get_item->account_id, item_id);
 192                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 193                         _DEBUG_ERROR("da_changelog_delete_item_internal() failed, ret[%d]", ret);
 194                 }
 195
 196                 ret = sync_agent_free_item(get_item);
 197                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 198                         _DEBUG_ERROR("sync_agent_free_item() failed, ret[%d]", ret);
 199                 }
 200         } else {
 201                 ret = da_delete_item_by_item_id_internal(item_id);
 202                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 203                         _DEBUG_ERROR("da_delete_item_by_item_id_internal() failed, ret[%d]", ret);
 204                 }
 205         }
 206
 207         _EXTERN_FUNC_EXIT;
 208
 209         return ret;
 210 }
 211
 212 EXPORT_API sync_agent_da_return_e sync_agent_query_delete_item(sync_agent_da_delete_item_query_s * query)
 213 {
 214         _EXTERN_FUNC_ENTER;
 215
 216         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_delete_item_query_s is NULL !!");
 217
 218         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 219
 220         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 221         if (daci_handler == NULL) {
 222                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 223                 return SYNC_AGENT_DA_ERR_DB_HANDLER_MGR;
 224         }
 225
 226         switch (query->option) {
 227         case SYNC_AGENT_DA_DELETE_ITEM_OPTION_ITEM_TYPE_ID:
 228                 ret = da_delete_item_by_item_type_id_new(daci_handler, query->account_id, query->item_type_id);
 229                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 230                         _DEBUG_ERROR("da_delete_item_by_item_type_id() failed !!");
 231                 }
 232                 break;
 233         default:
 234                 break;
 235         }
 236
 237         _EXTERN_FUNC_EXIT;
 238
 239         return ret;
 240 }
 241
 242 EXPORT_API sync_agent_da_return_e sync_agent_get_item(char *item_id, sync_agent_da_item_s ** sync_agent_item)
 243 {
 244         _EXTERN_FUNC_ENTER;
 245
 246         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 247
 248         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 249
 250         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 251         if (daci_handler == NULL) {
 252                 _DEBUG_ERROR("[%s] no handler for key");
 253                 return ret;
 254         }
 255
 256         ret = da_get_item_new(daci_handler, item_id, sync_agent_item);
 257         if (ret != SYNC_AGENT_DA_SUCCESS) {
 258                 _DEBUG_ERROR("da_get_item() faied !!");
 259         }
 260
 261         _EXTERN_FUNC_EXIT;
 262
 263         return ret;
 264 }
 265
 266 EXPORT_API sync_agent_da_return_e sync_agent_get_item_data_store_id(char *item_id, sync_agent_da_item_s ** sync_agent_item)
 267 {
 268         _EXTERN_FUNC_ENTER;
 269
 270         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 271
 272         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 273
 274         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 275         if (daci_handler == NULL) {
 276                 _DEBUG_ERROR("[%s] no handler for key");
 277                 return ret;
 278         }
 279
 280         ret = da_get_item_data_store_id_new(daci_handler, item_id, sync_agent_item);
 281         if (ret != SYNC_AGENT_DA_SUCCESS) {
 282                 _DEBUG_ERROR("da_get_item_data_store_id_new() faied, ret[%d]", ret);
 283         }
 284
 285         _EXTERN_FUNC_EXIT;
 286         return ret;
 287 }
 288
 289 EXPORT_API sync_agent_da_return_e sync_agent_get_item_account_id(char *item_id, sync_agent_da_item_s ** sync_agent_item)
 290 {
 291         _EXTERN_FUNC_ENTER;
 292
 293         retvm_if(item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 294
 295         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 296
 297         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 298         if (daci_handler == NULL) {
 299                 _DEBUG_ERROR("[%s] no handler for key");
 300                 return ret;
 301         }
 302
 303         ret = da_get_item_account_id_new(daci_handler, item_id, sync_agent_item);
 304         if (ret != SYNC_AGENT_DA_SUCCESS) {
 305                 _DEBUG_ERROR("da_get_item_account_id_new() faied, ret[%d]", ret);
 306         }
 307
 308         _EXTERN_FUNC_EXIT;
 309         return ret;
 310 }
 311
 312 EXPORT_API sync_agent_da_return_e sync_agent_get_item_list(int account_id, sync_agent_da_get_item_list_query_s * query, GList ** list)
 313 {
 314         _EXTERN_FUNC_ENTER;
 315
 316         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_get_item_list_query_s is NULL !!");
 317
 318         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 319
 320         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 321         if (daci_handler == NULL) {
 322                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 323                 return ret;
 324         }
 325
 326         switch (query->option) {
 327         case SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_ACCOUNT_ID:
 328                 ret = da_get_item_by_account_id_new(daci_handler, account_id, query->item_type_id, list);
 329                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 330                         _DEBUG_ERROR("da_get_item_by_account_id() failed !!");
 331                 }
 332                 break;
 333         case SYNC_AGENT_DA_GET_ITEM_LIST_OPTION_SERVICE_ID_MAPPING:
 334                 retvm_if(query->item_id == NULL, SYNC_AGENT_DA_ERRORS, "item id is NULL !!");
 335
 336                 ret = da_get_item_mapping_service_id_new(daci_handler, account_id, query->item_id, list);
 337                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 338                         _DEBUG_ERROR("da_get_item_mapping_service_id() failed !!");
 339                 }
 340                 break;
 341         default:
 342                 break;
 343         }
 344
 345         _EXTERN_FUNC_EXIT;
 346
 347         return ret;
 348 }
 349
 350 EXPORT_API sync_agent_da_return_e sync_agent_get_item_id(sync_agent_da_get_item_id_query_s * query, char **item_id)
 351 {
 352         _EXTERN_FUNC_ENTER;
 353
 354         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_get_item_id_query_s is NULL !!");
 355         retvm_if(query->service_id == NULL, SYNC_AGENT_DA_ERRORS, "service id is NULL !!");
 356
 357         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 358
 359         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 360         if (daci_handler == NULL) {
 361                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 362                 return ret;
 363         }
 364
 365         ret = da_get_item_item_id_new(daci_handler, query->account_id, query->service_id, query->item_type_id, item_id);
 366         if (ret != SYNC_AGENT_DA_SUCCESS) {
 367                 _DEBUG_ERROR("da_get_item_item_id_new() failed !!");
 368         }
 369
 370         _EXTERN_FUNC_EXIT;
 371
 372         return ret;
 373 }
 374
 375 EXPORT_API sync_agent_da_return_e sync_agent_get_item_id_list(sync_agent_da_get_item_id_list_query_s * query, GList ** list)
 376 {
 377         _EXTERN_FUNC_ENTER;
 378
 379         retvm_if(query == NULL, SYNC_AGENT_DA_ERRORS, "sync_agent_da_get_item_id_list_query_s is NULL !!");
 380
 381         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 382
 383         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 384         if (daci_handler == NULL) {
 385                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 386                 return ret;
 387         }
 388
 389         switch (query->option) {
 390         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_COLUMN_NAME:
 391                 retvm_if(query->folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 392
 393                 ret = da_get_item_id_list_new(daci_handler, query->folder_id, query->column_name, list);
 394                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 395                         _DEBUG_ERROR("da_get_item_id_list_new() failed !!");
 396                 }
 397                 break;
 398         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID:
 399                 ret = da_get_item_id_list_by_operation_id_new(daci_handler, query->account_id, query->item_type_id, query->operation_id, list);
 400                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 401                         _DEBUG_ERROR("da_get_item_id_list_by_operation_id_new() failed !!");
 402                 }
 403                 break;
 404         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID_N_FOLDER_ID:
 405                 retvm_if(query->folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 406
 407                 ret = da_get_item_id_list_by_operation_id_and_folder_id_new(daci_handler, query->account_id, query->folder_id, query->item_type_id, query->operation_id, list);
 408                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 409                         _DEBUG_ERROR("da_get_item_id_list_by_operation_id_and_folder_id_new() failed !!");
 410                 }
 411                 break;
 412         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_OPERATION_ID_N_ITEM_TYPE_ID:
 413                 ret = da_get_item_info_by_item_type_id_and_operation_id_new(daci_handler, query->account_id, query->item_type_id, query->operation_id, list);
 414                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 415                         _DEBUG_ERROR("da_get_item_info_by_item_type_id_and_operation_id_new() failed !!");
 416                 }
 417                 break;
 418         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_ITEM_TYPE_ID:
 419                 ret = da_get_item_id_list_by_datastore_id_new(daci_handler, query->item_type_id, list);
 420                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 421                         _DEBUG_ERROR("da_get_item_id_list_by_datastore_id_new() failed !!");
 422                 }
 423                 break;
 424         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_ITEM_TYPE_ID_N_ACCOUNT_ID:
 425                 ret = da_get_item_id_list_by_datastore_id_with_account_id_new(daci_handler, query->account_id, query->item_type_id, list);
 426                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 427                         _DEBUG_ERROR("da_get_item_id_list_by_datastore_id_with_account_id_new() failed !!");
 428                 }
 429                 break;
 430         case SYNC_AGENT_DA_GET_ITEM_ID_LIST_OPTION_FOLDER_ID_N_ACCOUNT_ID:
 431                 retvm_if(query->folder_id == NULL, SYNC_AGENT_DA_ERRORS, "folder id is NULL !!");
 432
 433                 ret = da_get_item_id_list_by_folder_id_and_account_id(daci_handler, query->account_id, query->folder_id, list);
 434                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 435                         _DEBUG_ERROR("da_get_item_id_list_by_folder_id_and_account_id() failed !!");
 436                 }
 437                 break;
 438         default:
 439                 break;
 440         }
 441
 442         _EXTERN_FUNC_EXIT;
 443
 444         return ret;
 445 }
 446
 447 EXPORT_API sync_agent_da_return_e sync_agent_free_item(sync_agent_da_item_s * sync_agent_item)
 448 {
 449         _EXTERN_FUNC_ENTER;
 450
 451         if (sync_agent_item != NULL) {
 452                 if (sync_agent_item->item_id != NULL)
 453                         free(sync_agent_item->item_id);
 454
 455                 if (sync_agent_item->folder_id != NULL)
 456                         free(sync_agent_item->folder_id);
 457
 458                 if (sync_agent_item->service_id != NULL)
 459                         free(sync_agent_item->service_id);
 460
 461                 if (sync_agent_item->access_name != NULL)
 462                         free(sync_agent_item->access_name);
 463
 464                 free(sync_agent_item);
 465         } else {
 466                 _DEBUG_ERROR("sync_agent_item is NULL !!");
 467                 return SYNC_AGENT_DA_ERRORS;
 468         }
 469
 470         _EXTERN_FUNC_EXIT;
 471
 472         return SYNC_AGENT_DA_SUCCESS;
 473 }
 474
 475 EXPORT_API sync_agent_da_return_e sync_agent_free_item_list(GList * list)
 476 {
 477         _EXTERN_FUNC_ENTER;
 478
 479         sync_agent_da_return_e ret = SYNC_AGENT_DA_SUCCESS;
 480
 481         if (list != NULL) {
 482                 GList *iter = NULL;
 483                 sync_agent_da_item_s *iter_data;
 484
 485                 for (iter = list; iter != NULL;) {
 486                         iter_data = NULL;
 487                         iter_data = (sync_agent_da_item_s *) (iter->data);
 488
 489                         iter = g_list_next(iter);
 490                         list = g_list_remove(list, iter_data);
 491
 492                         ret = sync_agent_free_item(iter_data);
 493                         if (ret != SYNC_AGENT_DA_SUCCESS) {
 494                                 _DEBUG_ERROR("sync_agent_free_item() failed !!");
 495                                 return ret;
 496                         }
 497                 }
 498
 499                 g_list_free(list);
 500         } else {
 501                 _DEBUG_ERROR("list is NULL !!");
 502                 return SYNC_AGENT_DA_ERRORS;
 503         }
 504
 505         _EXTERN_FUNC_EXIT;
 506
 507         return ret;
 508 }
 509
 510 EXPORT_API sync_agent_da_return_e sync_agent_free_item_id(char *item_id)
 511 {
 512         _EXTERN_FUNC_ENTER;
 513
 514         if (item_id != NULL) {
 515                 free(item_id);
 516         } else {
 517                 _DEBUG_ERROR("item id is NULL !!");
 518                 return SYNC_AGENT_DA_ERRORS;;
 519         }
 520
 521         _EXTERN_FUNC_EXIT;
 522
 523         return SYNC_AGENT_DA_SUCCESS;
 524 }
 525
 526 EXPORT_API sync_agent_da_return_e sync_agent_free_item_id_list(GList * list)
 527 {
 528         _EXTERN_FUNC_ENTER;
 529
 530         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 531
 532         if (list != NULL) {
 533                 GList *iter = NULL;
 534                 char *iter_data;
 535
 536                 for (iter = list; iter != NULL;) {
 537                         iter_data = NULL;
 538                         iter_data = (char *)(iter->data);
 539
 540                         iter = g_list_next(iter);
 541                         list = g_list_remove(list, iter_data);
 542
 543                         ret = sync_agent_free_item_id(iter_data);
 544                         if (ret != SYNC_AGENT_DA_SUCCESS) {
 545                                 _DEBUG_ERROR("sync_agent_free_item_id() failed !!");
 546                                 return ret;
 547                         }
 548                 }
 549
 550                 g_list_free(list);
 551         } else {
 552                 _DEBUG_INFO("list is NULL !!");
 553                 return ret;
 554         }
 555
 556         _EXTERN_FUNC_EXIT;
 557
 558         return ret;
 559 }
 560 EXPORT_API sync_agent_da_return_e sync_agent_get_item_count(int data_store_id, int *item_count)
 561 {
 562         _EXTERN_FUNC_ENTER;
 563
 564         retvm_if(item_count == NULL, SYNC_AGENT_DA_ERRORS, "*item_count is NULL !!");
 565
 566         sync_agent_da_return_e ret = SYNC_AGENT_DA_ERRORS;
 567         int total_count = 0;
 568         GList *account_info_list = NULL;
 569
 570         SYNC_AGENT_DA_HANDLER *daci_handler = da_get_agent_handler(SYNC_AGENT_DA_GET_THREAD_ID);
 571         if (daci_handler == NULL) {
 572                 _DEBUG_ERROR("[%s] no handler for key\n", __func__);
 573                 ret = SYNC_AGENT_DA_ERRORS;
 574                 goto return_part;
 575         }
 576
 577         sync_agent_fw_account_query_s account_query;
 578         account_query.query = ACCOUNT_QUERY_BY_SERVICE_TYPE;
 579         account_query.service_type = data_store_id;
 580         sync_agent_acc_error_e acc_err = sync_agent_query_fw_account(&account_query, &account_info_list);
 581         if (acc_err != SYNC_AGENT_ACC_SUCCESS) {
 582                 _DEBUG_ERROR("sync_agent_query_fw_account is failed");
 583                 ret = SYNC_AGENT_DA_ERRORS;
 584                 goto return_part;
 585         }
 586
 587         GList *account_iter = NULL;
 588         for (account_iter = account_info_list; account_iter != NULL; account_iter = g_list_next(account_iter)) {
 589                 sync_agent_fw_account_s *fw_account = (sync_agent_fw_account_s *)account_iter->data;
 590                 int fw_account_id = fw_account->account_id;
 591                 int temp_count = 0;
 592
 593                 ret = da_get_item_count_by_datastore_id(daci_handler, data_store_id, fw_account_id, &temp_count);
 594                 if (ret != SYNC_AGENT_DA_SUCCESS) {
 595                         _DEBUG_ERROR("da_get_item_count_by_datastore_id() failed !!");
 596                 }
 597                 total_count += temp_count;
 598         }
 599
 600 return_part:
 601         *item_count = total_count;
 602         _DEBUG_INFO("item_count = %d", *item_count);
 603
 604         if(account_info_list != NULL) {
 605                 sync_agent_free_fw_account_list(account_info_list);
 606                 account_info_list = NULL;
 607         }
 608         _EXTERN_FUNC_EXIT;
 609         return ret;
 610 }