src/agent/common/dm_common.c

   1 /*
   2  * oma-dm-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 <unistd.h>
  19
  20 /*lib*/
  21 #include <vconf.h>
  22 #include <vconf-keys.h>
  23
  24 /*sync-agent*/
  25 #include <sync_agent.h>
  26 #include <plugin/plugin_slp_sysnoti_alarm.h>
  27
  28 /*dm-agent*/
  29 #include "framework/platform-event-handler/dm_platform_event_handler.h"
  30 #include "framework/platform-event-handler/dm_platform_event_handler_internal.h"
  31 #include "framework/task/oma_dm_task_register.h"
  32 #include "framework/task/oma_dm_task_request.h"
  33 #include "common/dm_common.h"
  34 #include "common/util/util.h"
  35 #include "mo-handler/dm_mo_common.h"
  36 #include "mo-handler/dm_mo_handler.h"
  37 #include "dm-engine/bootstrap/factory_bootstrap.h"
  38 #include "dm-engine/fumo/fumo_account.h"
  39 #include "dm-engine/lawmo/lawmo_account.h"
  40 #include "dm-engine/cp/dm_cp_security.h"
  41 #include "ipc_common.h"
  42
  43 #ifndef OMADM_AGENT_LOG
  44 #undef LOG_TAG
  45 #define LOG_TAG "DM_COMMON"
  46 #endif
  47
  48 #define MAX_TRY         3
  49
  50 static DM_ERROR _create_engine_status_db();
  51
  52 char *get_new_uri(char *old_object_uri)
  53 {
  54         _EXTERN_FUNC_ENTER;
  55
  56         char *new_object_uri = NULL;
  57         retvm_if(old_object_uri == NULL, NULL, "old_object_uri is NULL!!");
  58         _DEBUG_INFO(" old_object_uri = %s ", old_object_uri);
  59         new_object_uri = g_strdup_printf("%s", old_object_uri);
  60
  61         _EXTERN_FUNC_EXIT;
  62         return new_object_uri;
  63 }
  64
  65 static DM_ERROR _create_engine_status_db()
  66 {
  67         _INNER_FUNC_ENTER;
  68
  69         DM_ERROR ret = DM_OK;
  70
  71         ret = Alloc_DB_Handler_Mgr();
  72         _DEBUG_TRACE(" Alloc DB Handler Mgr : %d\n", ret);
  73
  74         ret = DB_Open();
  75         _DEBUG_TRACE(" Done Open DB : %d\n", ret);
  76
  77         ret = DB_Create_Table();
  78         _DEBUG_TRACE(" Done Create_Table : %d\n", ret);
  79
  80         _INNER_FUNC_EXIT;
  81         return ret;
  82
  83 }
  84
  85 DM_ERROR init_dm()
  86 {
  87         _EXTERN_FUNC_ENTER;
  88
  89         DM_ERROR ret = DM_OK;
  90
  91         ret = _create_engine_status_db();
  92         _DEBUG_INFO(" Done Create_engine_status_db : %d\n", ret);
  93
  94         ret = task_register();
  95         if (ret != DM_OK) {
  96                 goto error;
  97         }
  98         /* will delete */
  99         ret = register_scheduler();
 100         if (ret == -1) {
 101                 _DEBUG_INFO("fail register alarm : %d ", ret);
 102         } else {
 103                 _DEBUG_INFO("success register alarm : %d ", ret);
 104         }
 105
 106         ret = register_network();
 107         if (ret == -1) {
 108                 _DEBUG_INFO("fail register network : %d ", ret);
 109         } else {
 110                 _DEBUG_INFO("success register network : %d ", ret);
 111         }
 112
 113         ret = register_wap_push();
 114         if (ret == -1) {
 115                 _DEBUG_INFO("fail register wap push : %d ", ret);
 116         } else {
 117                 _DEBUG_INFO("success register wap push : %d ", ret);
 118         }
 119
 120 /*
 121         ret = register_fumo_ip_push();
 122         if (ret == -1) {
 123                 _DEBUG_INFO("fail register fumo ip push : %d ", ret);
 124         } else {
 125                 _DEBUG_INFO("success register fumo ip push : %d ", ret);
 126
 127                 //todo temp code
 128                 //  will integrate notification UI
 129                 //ret = register_fota_account();
 130                 //if (ret == -1) {
 131                 //      _DEBUG_INFO("fail register fota account : %d ", ret);
 132                 //} else {
 133                 //      _DEBUG_INFO("success register fota account : %d ", ret);
 134                 //}
 135         }
 136 */
 137 /*
 138         ret = register_lawmo_samsung_account();
 139         if (ret == -1) {
 140                 _DEBUG_INFO("fail register fmm server : %d ", ret);
 141         } else {
 142                 _DEBUG_INFO("success register fmm server : %d ", ret);
 143         }
 144 */
 145         ret = register_telephony();
 146         if (ret == -1) {
 147                 _DEBUG_INFO("fail register telephony : %d ", ret);
 148         } else {
 149                 _DEBUG_INFO("success register telephony : %d ", ret);
 150         }
 151
 152         init_default_fumo_config();
 153
 154         _EXTERN_FUNC_EXIT;
 155         return ret;
 156  error:
 157         _EXTERN_FUNC_EXIT;
 158         _DEBUG_INFO(" end error : %d \n", ret);
 159         return ret;
 160 }
 161
 162 DM_ERROR end_dm()
 163 {
 164         _EXTERN_FUNC_ENTER;
 165
 166         DM_ERROR ret = DM_OK;
 167
 168         _EXTERN_FUNC_EXIT;
 169         return ret;
 170 }
 171
 172 DM_ERROR reset_dm()
 173 {
 174         _EXTERN_FUNC_ENTER;
 175
 176         DM_ERROR ret = DM_OK;
 177         _DEBUG_INFO("--------------------------------------------------------------------------------------------");
 178         /* ddf mo db reset */
 179         ret = clean_dm_mo();
 180         _DEBUG_INFO("clean_dm_mo [%d]", ret);
 181         if (ret != DM_OK)
 182                 goto error;
 183
 184         /* engine status db reset */
 185         //ret = DB_Delete_Table();
 186         ret = DB_Reset_Table();
 187         _DEBUG_INFO("DB_Reset_Table [%d]", ret);
 188         if (ret != DM_OK)
 189                 goto error;
 190
 191         /* omadm db */
 192         sync_agent_empty_agent_default_table(SYNC_AGENT_DA_TABLE_NAME_CONFIG);
 193         //sync_agent_empty_all_agent_table()
 194
 195         /*fumo, lawmo data in alarm db */
 196         _DEBUG_INFO("--------------------------------------------------------------------------------------------");
 197
 198         _EXTERN_FUNC_EXIT;
 199         return ret;
 200
 201  error:
 202         _EXTERN_FUNC_EXIT;
 203         _DEBUG_INFO(" end error : %d \n", ret);
 204         return ret;
 205 }
 206
 207 DM_ERROR auto_operate_service_engine()
 208 {
 209         _EXTERN_FUNC_ENTER;
 210
 211         DM_ERROR ret = DM_OK;
 212         engine_status *status = NULL;
 213
 214         if (IsExist_Engine_id(FUMO_SERVICE_ENGINE) != 0) {
 215                 _DEBUG_INFO("engine id VALUE : %d ", FUMO_SERVICE_ENGINE);
 216
 217                 ret = Get_Engine_Status(FUMO_SERVICE_ENGINE, &status);
 218                 if (ret != DM_OK || status == NULL)
 219                         goto error;
 220
 221                 if (status->engine_status == 0) {
 222                         ret = Delete_Engine_Status(FUMO_SERVICE_ENGINE);
 223                         if (ret != DM_OK)
 224                                 goto error;
 225                 } else {
 226                         ret = fumo_serviceEngine_task_request();
 227                         _DEBUG_INFO("fumo server engine task request : %d", ret);
 228                 }
 229                 if (status != NULL) {
 230                         Free_Memory_Engine_Status(&status, 1);
 231                 }
 232         }
 233
 234         if (IsExist_Engine_id(LAWMO_SERVICE_ENGINE) != 0) {
 235                 _DEBUG_INFO("engine id VALUE : %d ", LAWMO_SERVICE_ENGINE);
 236
 237                 ret = Get_Engine_Status(LAWMO_SERVICE_ENGINE, &status);
 238                 if (ret != DM_OK || status == NULL)
 239                         goto error;
 240
 241                 if (status->engine_status == 0) {
 242                         ret = Delete_Engine_Status(LAWMO_SERVICE_ENGINE);
 243                         if (ret != DM_OK)
 244                                 goto error;
 245                 } else {
 246                         ret = lawmo_serviceEngine_task_request();
 247                 }
 248                 if (status != NULL)
 249                         Free_Memory_Engine_Status(&status, 1);
 250         }
 251
 252         _EXTERN_FUNC_EXIT;
 253         return ret;
 254  error:
 255
 256         if (status != NULL)
 257                 Free_Memory_Engine_Status(&status, 1);
 258
 259         _EXTERN_FUNC_EXIT;
 260         return ret;
 261 }
 262
 263 int register_wap_push()
 264 {
 265         _EXTERN_FUNC_ENTER;
 266
 267         int ret = 1;
 268         int i = 0;
 269
 270         for (i = 0; i < MAX_TRY; ++i) {
 271                 sync_agent_pm_return_e err_wappush = sync_agnet_register_user_callback(6, NULL, 2, dm_wap_push_incomming_callback, dm_wap_push_operation_callback);
 272
 273                 if (err_wappush != SYNC_AGENT_PM_SUCCESS) {
 274                         _DEBUG_INFO("failed set_WAP-PUSH_Callback()");
 275                         ret = -1;
 276                         sleep(1);
 277                 } else {
 278                         _DEBUG_INFO("WAP-PUSH SUCCESS");
 279                         break;
 280                 }
 281         }
 282         _EXTERN_FUNC_EXIT;
 283
 284         return ret;
 285 }
 286
 287 int register_fumo_ip_push()
 288 {
 289         _EXTERN_FUNC_ENTER;
 290
 291         int ret = 1;
 292         int i = 0;
 293
 294         for (i = 0; i < MAX_TRY; ++i) {
 295                 sync_agent_pm_return_e err_ippush = sync_agnet_register_user_callback(2, NULL, 1, dm_ip_push_callback);
 296                 if (err_ippush != SYNC_AGENT_PM_SUCCESS) {
 297 //                      if (err_ippush == PMCI_CONNECTION_FAIL) {
 298 //                              _DEBUG_INFO("failed set_IP-PUSH_Callback() : connection failed !!");
 299 //
 300 //                      } else if (err_ippush == PMCI_REGISTRATION_FAIL) {
 301 //                              _DEBUG_INFO("failed set_IP-PUSH_Callback() : registration failed !!");
 302 //                      } else {
 303                         _DEBUG_INFO("failed set_IP-PUSH_Callback()");
 304 //                      }
 305
 306                         sleep(1);
 307                         ret = -1;
 308                 } else {
 309                         _DEBUG_INFO("IP-PUSH SUCCESS");
 310                         ret = 1;
 311                         break;
 312                 }
 313         }
 314
 315         _EXTERN_FUNC_EXIT;
 316         return ret;
 317 }
 318
 319 int register_lawmo_samsung_account()
 320 {
 321         _EXTERN_FUNC_ENTER;
 322
 323         int ret = 1;
 324         int i = 0;
 325
 326         for (i = 0; i < MAX_TRY; ++i) {
 327                 sync_agent_pm_return_e err_samsung_account = sync_agnet_register_user_callback(4, NULL, 2, register_lawmo_account, deregister_lawmo_account);
 328                 if (err_samsung_account != SYNC_AGENT_PM_SUCCESS) {
 329 //                      if (err_samsung_account == PMCI_CONNECTION_FAIL) {
 330 //                              _DEBUG_INFO("failed set_SAMSUNG_ACCOUNT_Callback() : connection failed !!");
 331 //
 332 //                      } else if (err_samsung_account == PMCI_REGISTRATION_FAIL) {
 333 //                              _DEBUG_INFO("failed set_SAMSUNG_ACCOUNT_Callback() : registration failed !!");
 334 //                      } else {
 335                         _DEBUG_INFO("failed set_SAMSUNG_ACCOUNT_Callback()");
 336 //                      }
 337
 338                         sleep(1);
 339                         ret = -1;
 340                 } else {
 341                         _DEBUG_INFO("SAMSUNG_ACCOUNT SUCCESS");
 342                         ret = 1;
 343                         break;
 344                 }
 345         }
 346
 347         _EXTERN_FUNC_EXIT;
 348         return ret;
 349 }
 350
 351 int register_telephony()
 352 {
 353         _EXTERN_FUNC_ENTER;
 354
 355         int ret = 1;
 356         int i = 0;
 357
 358         for (i = 0; i < MAX_TRY; ++i) {
 359                 sync_agent_pm_return_e err_telephony = sync_agnet_register_user_callback(5, NULL, 2, dm_telephony_incomming_callback, dm_telephony_end_callback);
 360                 if (err_telephony != SYNC_AGENT_PM_SUCCESS) {
 361                         _DEBUG_INFO("failed set_TELEPHONY_Callback()");
 362
 363                         ret = -1;
 364                         sleep(1);
 365                 } else {
 366                         _DEBUG_INFO("TELEPHONY_SUCCESS");
 367                         ret = 1;
 368                         break;
 369                 }
 370         }
 371
 372         _EXTERN_FUNC_EXIT;
 373         return ret;
 374 }
 375
 376 int register_network()
 377 {
 378         _EXTERN_FUNC_ENTER;
 379
 380         int ret = 1;
 381         int i = 0;
 382
 383         for (i = 0; i < MAX_TRY; ++i) {
 384                 sync_agent_pm_return_e err_network = sync_agnet_register_user_callback(3, NULL, 2, network_on_callback, network_off_callback, network_change_callback);
 385                 if (err_network != SYNC_AGENT_PM_SUCCESS) {
 386                         _DEBUG_INFO("failed set_network_Callback()");
 387                         ret = -1;
 388                         sleep(1);
 389                 } else {
 390                         _DEBUG_INFO("NETWORK_SUCCESS");
 391                         ret = 1;
 392                         break;
 393                 }
 394         }
 395
 396         _EXTERN_FUNC_EXIT;
 397         return ret;
 398 }
 399
 400 int register_scheduler()
 401 {
 402         _EXTERN_FUNC_ENTER;
 403
 404         int ret = 0;
 405         int i = 0;
 406
 407         for (i = 0; i < MAX_TRY; ++i) {
 408                 sync_agent_pm_return_e err_alarm = sync_agnet_register_user_callback(1, NULL, 1, alarm_callback);
 409                 if (err_alarm != SYNC_AGENT_PM_SUCCESS) {
 410                         _DEBUG_INFO("Fail PMCI_Init_Specific_Type\n");
 411                         ret = -1;
 412                         sleep(1);
 413                 } else {
 414                         _DEBUG_INFO("Success PMCI_Init_Specific_Type\n");
 415                         ret = 1;
 416                         break;
 417                 }
 418         }
 419
 420         _EXTERN_FUNC_EXIT;
 421         return ret;
 422 }
 423
 424 void network_cancel_callback(void *user_data)
 425 {
 426         _EXTERN_FUNC_ENTER;
 427
 428         int *net_session_id = (int *)(user_data);
 429         sync_agent_na_result_e error;
 430         error = sync_agent_cancel_msg(1, (*net_session_id));
 431         _DEBUG_INFO("naci cancel msg status : %d\n", error);
 432
 433         _EXTERN_FUNC_EXIT;
 434 }
 435
 436 void network_connection_delay()
 437 {
 438         _EXTERN_FUNC_ENTER;
 439
 440         int network_status = 0;
 441         int interval = 1;       //(seconds)
 442         int retry_cnt = 3;
 443
 444         char file_name[256] = { 0, };
 445         char *net_status;
 446         int snd_size;
 447         FILE *send_fp = NULL;
 448         _DEBUG_INFO("start");
 449         sleep(2);
 450
 451         network_status = sync_agent_check_network_status(interval, retry_cnt);
 452
 453         net_status = g_strdup_printf("%d", network_status);
 454         snprintf(file_name, 256, "%s", "/opt/data/network_connect_status.txt");
 455         send_fp = fopen(file_name, "w");
 456         if (send_fp != NULL) {
 457                 snd_size = fwrite(net_status, strlen(net_status), 1, send_fp);
 458                 fclose(send_fp);
 459         } else {
 460                 _DEBUG_INFO("fopen - network_connect_status - fail");
 461         }
 462
 463         if (network_status != 1) {
 464                 _DEBUG_INFO("------------------------------------------NETOWKR CONNECT FAIL------------------------------------------");
 465         }
 466
 467         _EXTERN_FUNC_EXIT;
 468 }
 469
 470 DM_ERROR set_account_registration_alarm(char *alarm_str, CONFIG_TYPE alarm_type)
 471 {
 472         _EXTERN_FUNC_ENTER;
 473
 474         DM_ERROR ret = DM_OK;
 475         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 476
 477         int count = 0;
 478         GList *list = NULL;
 479
 480         result = sync_agent_get_config_list(alarm_type, &list);
 481         if (result != SYNC_AGENT_DA_SUCCESS) {
 482                 _EXTERN_FUNC_EXIT;
 483                 return COMMON_ERR_FW_CONFIG;
 484         }
 485
 486         count = g_list_length(list);
 487
 488         _DEBUG_INFO("alarm count: %d\n", count);
 489         if (count > 0 && list != NULL) {
 490                 _EXTERN_FUNC_EXIT;
 491                 return ret;
 492         } else {
 493                 ret = add_alarm_item(INTERVAL_1DAY, alarm_str, alarm_type);
 494                 if (ret != DM_OK)
 495                         goto error;
 496         }
 497
 498         _EXTERN_FUNC_EXIT;
 499         return ret;
 500
 501  error:
 502         _EXTERN_FUNC_EXIT;
 503         return ret;
 504 }
 505
 506 void delete_account_registration_alarm(char *alarm_str, CONFIG_TYPE alarm_type)
 507 {
 508         _EXTERN_FUNC_ENTER;
 509
 510         delete_alarm_item(alarm_str, alarm_type);
 511
 512         _EXTERN_FUNC_EXIT;
 513 }
 514
 515
 516 void delete_polling_alarm_item(char *alarm_type, CONFIG_TYPE conf_type)
 517 {
 518         _EXTERN_FUNC_ENTER;
 519
 520         delete_alarm_item(alarm_type, conf_type);
 521         _EXTERN_FUNC_EXIT;
 522
 523 }
 524
 525 DM_ERROR add_alarm_item(Reminder_Interval interval, char *alarm_type, CONFIG_TYPE conf_type)
 526 {
 527         _EXTERN_FUNC_ENTER;
 528
 529         DM_ERROR ret = DM_OK;
 530         //int week[] = {DAY_SUN, DAY_MON, DAY_TUE, DAY_WED, DAY_THU, DAY_FRI, DAY_SAT};
 531
 532         time_t current_time;
 533         struct tm *struct_time;
 534         time(&current_time);
 535         struct_time = localtime(&current_time);
 536
 537         pmci_alarm_s *alarm_info = (pmci_alarm_s *) calloc(1, sizeof(pmci_alarm_s));
 538         if (alarm_info == NULL) {
 539                 _DEBUG_INFO("alloc fail");
 540                 _EXTERN_FUNC_EXIT;
 541                 return COMMON_ERR_ALLOC;
 542         }
 543
 544         alarm_info->start_alarm_time = g_strdup_printf("%02d-%02d-%02dT%02d:%02d:%02dZ", struct_time->tm_year + 1900, struct_time->tm_mon + 1, struct_time->tm_mday, struct_time->tm_hour, struct_time->tm_min, struct_time->tm_sec);
 545
 546         //REALE
 547         alarm_info->is_disposable = 0;
 548
 549         // TEST
 550         //alarm_info->is_disposable = 1;
 551
 552         switch (interval) {
 553                 /*
 554                    case INTERVAL_NONE :
 555                    {
 556                    // 1minute
 557                    alarm_info->repeat_type = REPEAT ;
 558                    //alarm_info->repeat_value = ((1*60)*60);
 559                    alarm_info->repeat_value = ((1*60)*1);
 560                    }
 561                    break;
 562                  */
 563         case INTERVAL_30MINUTES:
 564                 {
 565                         /* 30 minutes */
 566                         alarm_info->repeat_type = REPEAT;
 567                         alarm_info->repeat_value = ((1 * 30) * 60);
 568                 }
 569                 break;
 570         case INTERVAL_1HOUR:
 571                 {
 572                         /* 1 hour */
 573                         alarm_info->repeat_type = REPEAT;
 574                         alarm_info->repeat_value = ((1 * 60) * 60);
 575                         //alarm_info->repeat_value = ((1*60)*1);
 576                 }
 577                 break;
 578         case INTERVAL_3HOURS:
 579                 {
 580                         /* 4 hour */
 581                         alarm_info->repeat_type = REPEAT;
 582                         alarm_info->repeat_value = ((3 * 60) * 60);
 583                 }
 584                 break;
 585         case INTERVAL_6HOURS:
 586                 {
 587                         /* 6 hour */
 588                         alarm_info->repeat_type = REPEAT;
 589                         alarm_info->repeat_value = ((6 * 60) * 60);
 590
 591                 }
 592                 break;
 593         case INTERVAL_12HOURS:
 594                 {
 595                         /* 12 hour */
 596                         alarm_info->repeat_type = REPEAT;
 597                         alarm_info->repeat_value = ((12 * 60) * 60);
 598
 599                 }
 600                 break;
 601         case INTERVAL_1DAY:
 602                 {
 603                         /* 1 day */
 604                         alarm_info->repeat_type = REPEAT;
 605                         alarm_info->repeat_value = ((24 * 60) * 60);
 606                 }
 607                 break;
 608                 /*
 609                    case INTERVAL_7DAYS:
 610                    {
 611                    // 1 week
 612                    alarm_info->repeat_type = REPEAT_WEEKLY ;
 613                    alarm_info->repeat_value = week[struct_time->tm_wday];
 614                    }
 615                    break;
 616                  */
 617         case INTERVAL_1MONTH:
 618                 {
 619                         alarm_info->repeat_type = REPEAT_MONTHLY;
 620                         alarm_info->repeat_value = 0;
 621                 }
 622         case INTERVAL_CANCEL:
 623                 goto return_part;
 624                 break;
 625         default:
 626                 break;
 627         }
 628
 629         _DEBUG_INFO("######### Alarm Info #####################\n");
 630         _DEBUG_INFO("time = %s\n", alarm_info->start_alarm_time);
 631         _DEBUG_INFO("repeat_mode = %d, repeat_value = %d\n", alarm_info->repeat_type, alarm_info->repeat_value);
 632         _DEBUG_INFO("is_disposable = %d\n", alarm_info->is_disposable);
 633
 634 /*       if(conf_type == FUMO_INTERVAL_TYPE)
 635                  delete_alarm_item(FUMO_INTERVAL, FUMO_INTERVAL_TYPE);*/
 636
 637         int alarm_id = 0;
 638         int alarm_ret = 0;
 639         sync_agent_pm_return_e err = SYNC_AGENT_PM_SUCCESS;
 640
 641         /*add alarm service */
 642         err = sync_agent_add_service_data(1, alarm_info, &alarm_id);
 643         if (err != SYNC_AGENT_PM_SUCCESS) {
 644                 _DEBUG_INFO("Fail PMCI_Add_Item_To_Specific_Type\n");
 645                 ret = DM_ERR_FUMO_INTERNAL_SCHEDULER_ERROR;
 646         } else {
 647                 /*add framework config db */
 648                 alarm_ret = set_alarm_config_int(conf_type, alarm_type, alarm_id, alarm_type);
 649                 if (alarm_ret == 0) {
 650                         ret = DM_ERR_FUMO_INTERNAL_SCHEDULER_ERROR;
 651                 }
 652         }
 653
 654         if (alarm_info != NULL) {
 655                 str_free(&(alarm_info->start_alarm_time));
 656                 free(alarm_info);
 657                 alarm_info = NULL;
 658         }
 659
 660         _EXTERN_FUNC_EXIT;
 661         return ret;
 662
 663  return_part:
 664
 665         if (alarm_info != NULL) {
 666                 str_free(&(alarm_info->start_alarm_time));
 667                 free(alarm_info);
 668                 alarm_info = NULL;
 669         }
 670
 671         _EXTERN_FUNC_EXIT;
 672         _DEBUG_INFO("end error : %d ", ret);
 673         return ret;
 674 }
 675
 676 void delete_alarm_item(char *alarm_type, CONFIG_TYPE conf_type)
 677 {
 678         _EXTERN_FUNC_ENTER;
 679
 680         int count = 0;
 681         int before_alarm_id;
 682         int ret = 0;
 683         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 684         sync_agent_pm_return_e pm_result = SYNC_AGENT_PM_SUCCESS;
 685
 686         sync_agent_da_config_s *config = NULL;
 687
 688         GList *list = NULL;
 689
 690         result = sync_agent_get_config_list(conf_type, &list);
 691         count = g_list_length(list);
 692
 693         _DEBUG_INFO("alarm count: %d\n", count);
 694         if (count > 0 && list != 0) {
 695                 config = (sync_agent_da_config_s *) g_list_nth_data(list, 0);
 696                 _DEBUG_INFO("------------------------------------------alarm id : %s----------------------------------------------\n", config->value);
 697                 ret = chartoint(config->value, &before_alarm_id);
 698                 if (ret == 1) {
 699                         pm_result = sync_agent_remove_service_data(1, before_alarm_id);
 700                         _DEBUG_INFO("delete alarm %d", result);
 701
 702                         if (pm_result == SYNC_AGENT_PM_SUCCESS) {
 703                                 result = sync_agent_delete_config(conf_type, alarm_type);
 704                                 _DEBUG_INFO("delete alarm config %d", result);
 705                         }
 706                 } else {
 707                         _DEBUG_INFO("fail get alarm id");
 708                 }
 709         }
 710
 711         sync_agent_free_config_list(list);
 712         _EXTERN_FUNC_EXIT;
 713
 714 }
 715
 716 SERVICE_SERVER_TYPE get_service_engine_type(const char *server_id)
 717 {
 718         _EXTERN_FUNC_ENTER;
 719
 720         retvm_if(server_id == NULL, NO_ENGINE_TYPE, "server_id is NULL!!");
 721
 722         _DEBUG_INFO("get- service engine type by server id : %s", server_id);
 723         _EXTERN_FUNC_EXIT;
 724         return get_engine_type_by_serverid(server_id);
 725 }
 726
 727 DM_ERROR get_server_info(Event_Contents * pEvent_data, char **server_id, char **session_id, int *session_type)
 728 {
 729         _EXTERN_FUNC_ENTER;
 730
 731         DM_ERROR ret = DM_OK;
 732
 733         retvm_if((pEvent_data) == NULL, COMMON_ERR_INTERNAL_NOT_DEFINED, "pEvent_data is NULL!!");
 734         retvm_if((pEvent_data->server_id) == NULL, COMMON_ERR_INTERNAL_NOT_DEFINED, "server_id is NULL!!");
 735
 736         (*server_id) = strdup(pEvent_data->server_id);
 737         _DEBUG_INFO(" server id : %s\n", *server_id);
 738
 739         if (pEvent_data->session_id != NULL) {
 740                 (*session_id) = strdup(pEvent_data->session_id);
 741                 _DEBUG_INFO(" session_id : %s\n", *session_id);
 742         }
 743
 744         (*session_type) = pEvent_data->type;
 745         _DEBUG_INFO("session type  : %d\n", *session_type);
 746
 747         _EXTERN_FUNC_EXIT;
 748         return ret;
 749 }
 750
 751 void get_service_engine_id(ENGINE_ID * service_engine_id, char *ui_mode)
 752 {
 753         _EXTERN_FUNC_ENTER;
 754
 755         if (ui_mode == NULL)
 756                 return;
 757
 758         if (!strcmp(ui_mode, OMADM_FUMO_UI_TYPE) || !strcmp(ui_mode, OMADM_FUMO_NOTI_UI_TYPE)) {
 759                 *service_engine_id = FUMO_SERVICE_ENGINE;
 760                 _DEBUG_INFO("fumo service");
 761         } else {
 762                 _DEBUG_INFO("other service");
 763         }
 764
 765         _EXTERN_FUNC_EXIT;
 766 }
 767
 768 DM_ERROR fumo_service_start(Event_Contents * pEvent_data)
 769 {
 770         _EXTERN_FUNC_ENTER;
 771
 772         DM_ERROR ret = DM_OK;
 773
 774         retvm_if((pEvent_data) == NULL, COMMON_ERR_INTERNAL_NOT_DEFINED, "pEvent_data is NULL!!");
 775
 776         switch (pEvent_data->noti_type) {
 777         case NOTI_TYPE_NOT_SPECIFIED:
 778                 _DEBUG_INFO("NOTI_TYPE_NOT_SPECIFIED");
 779                 //temp version for gcf test
 780                 pEvent_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
 781                 pEvent_data->noti_type = NOTI_TYPE_BACKGRUOUND;
 782                 ret = dm_fumo_common_task_request(pEvent_data);
 783                 _DEBUG_INFO("NOTI NOTI_TYPE_BACKGRUOUND : %d", ret);
 784                 if (ret != DM_OK) {
 785                         goto error;
 786                 }
 787                 break;
 788         case NOTI_TYPE_BACKGRUOUND:
 789                 pEvent_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
 790                 ret = dm_fumo_common_task_request(pEvent_data);
 791                 _DEBUG_INFO("NOTI NOTI_TYPE_BACKGRUOUND : %d", ret);
 792                 if (ret != DM_OK) {
 793                         goto error;
 794                 }
 795                 break;
 796         case NOTI_TYPE_INFOMATIVE:
 797                 pEvent_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
 798                 ret = dm_fumo_common_task_request(pEvent_data);
 799                 _DEBUG_INFO("NOTI NOTI_TYPE_INFOMATIVE : %d", ret);
 800                 if (ret != DM_OK) {
 801                         goto error;
 802                 }
 803                 break;
 804         case NOTI_TYPE_USERINTERACTION:
 805                 pEvent_data->ui_mode = strdup(OMADM_FUMO_NOTI_UI_TYPE);
 806                 ret = dm_fumo_ui_task_request(pEvent_data);
 807                 _DEBUG_INFO("NOTI NOTI_TYPE_USERINTERACTION : %d ", ret);
 808                 if (ret != DM_OK) {
 809                         goto error;
 810                 }
 811                 break;
 812         default:
 813                 break;
 814         }
 815
 816         _EXTERN_FUNC_EXIT;
 817         return DM_OK;
 818  error:
 819         event_data_free((void *)pEvent_data);
 820         _EXTERN_FUNC_EXIT;
 821         return DM_OK;
 822
 823 }
 824
 825 DM_ERROR get_fumo_ui_mode(char **ui_mode)
 826 {
 827         _EXTERN_FUNC_ENTER;
 828
 829         DM_ERROR ret = DM_OK;
 830
 831         engine_status *status = NULL;
 832         ret = Get_Engine_Status(FUMO_SERVICE_ENGINE, &status);
 833         if (ret != DM_OK) {
 834                 if(status != NULL)
 835                         Free_Memory_Engine_Status(&status, 1);
 836
 837                 _EXTERN_FUNC_EXIT;
 838                 return ret;
 839         }
 840
 841         if (status != NULL) {
 842
 843                 if (status->ui_mode != NULL) {
 844                         (*ui_mode) = strdup(status->ui_mode);
 845
 846                         _DEBUG_INFO("==================Fumo ui : %s==================\n", *ui_mode);
 847                 } else {
 848                         _DEBUG_INFO("ui mode null");
 849                 }
 850
 851                 Free_Memory_Engine_Status(&status, 1);
 852
 853         } else {
 854                 _DEBUG_INFO("status is null");
 855         }
 856
 857         _DEBUG_INFO("end");
 858         _EXTERN_FUNC_EXIT;
 859         return ret;
 860
 861 }
 862
 863 int check_existed_fumo_reminder_interval()
 864 {
 865         _EXTERN_FUNC_ENTER;
 866
 867         int exist = 0;
 868         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 869         result = sync_agent_is_exist_config(FUMO_INTERVAL_TYPE, FUMO_INTERVAL, &exist);
 870         _DEBUG_INFO("agent is exist result : %d", result);
 871
 872         _EXTERN_FUNC_EXIT;
 873         return exist;
 874 }
 875
 876 int init_default_fumo_config()
 877 {
 878         _EXTERN_FUNC_ENTER;
 879
 880         _EXTERN_FUNC_EXIT;
 881         return set_config_int(FUMO_WIFI_ONLY_TYPE, FUMO_WIFI_ONLY_CONFIG, 0, FUMO, 1);
 882 }
 883
 884 int set_config_int(CONFIG_TYPE config_type, char *key, int value, char *accessName, int isFirst)
 885 {
 886         _EXTERN_FUNC_ENTER;
 887         int ret = 1;
 888         sync_agent_da_return_e result;
 889         sync_agent_da_config_s config;
 890         int exist = 0;
 891
 892         config.access_name = accessName;
 893         config.config_id = config_type;
 894         config.key = key;
 895         config.value = g_strdup_printf("%d", value);
 896         config.type = "int";
 897
 898         result = sync_agent_is_exist_config(config_type, key, &exist);
 899         if (result != SYNC_AGENT_DA_SUCCESS) {
 900                 _DEBUG_INFO("exist config fail : %d", result);
 901                 ret = -1;
 902         } else {
 903                 if (exist == 0 && isFirst == 1) {
 904                         _DEBUG_INFO("default add config : %s\n", key);
 905                         result = sync_agent_add_config(&config);
 906                         if (result != SYNC_AGENT_DA_SUCCESS) {
 907                                 _DEBUG_INFO("fail add : %d", result);
 908                                 ret = -1;
 909                         } else {
 910                                 _DEBUG_INFO("Success add config : %s, : %d\n", key, value);
 911                         }
 912                 } else {
 913                         result = sync_agent_update_config(&config);
 914                         //free config
 915                         if (result != SYNC_AGENT_DA_SUCCESS) {
 916                                 _DEBUG_INFO("fail update : %d", result);
 917                                 ret = -1;
 918                         } else {
 919                                 _DEBUG_INFO("Success update config : %s, : %d\n", key, value);
 920                         }
 921                 }
 922         }
 923
 924         str_free(&(config.value));
 925         _EXTERN_FUNC_EXIT;
 926
 927         return ret;
 928 }
 929
 930 int get_config_int(CONFIG_TYPE config_id, char *key)
 931 {
 932         _EXTERN_FUNC_ENTER;
 933
 934         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 935         sync_agent_da_config_s *config = NULL;
 936         int value = 1;
 937         int ret = -1;
 938
 939         result = sync_agent_create_config(&config);
 940         if (result != SYNC_AGENT_DA_SUCCESS) {
 941                 _EXTERN_FUNC_EXIT;
 942                 return -1;
 943         }
 944
 945         result = sync_agent_get_config(config_id, key, &config);
 946         _DEBUG_INFO("---------------------------result : %d-------------------------\n", result);
 947         if (result == 1) {
 948                 _DEBUG_INFO("Success get config value");
 949
 950                 ret = chartoint(config->value, &value);
 951                 _DEBUG_INFO("result : %d , key : %s value : %d\n", result, key, value);
 952
 953                 if (ret == 0) {
 954                         _DEBUG_INFO("fail get config value");
 955                         ret = -1;
 956                         goto return_part;
 957                 } else {
 958                         _DEBUG_INFO("success get config value");
 959                         ret = value;
 960                 }
 961         } else {
 962                 _DEBUG_INFO("fail get config value");
 963         }
 964
 965  return_part:
 966
 967         sync_agent_free_config(config);
 968         _EXTERN_FUNC_EXIT;
 969         return ret;
 970 }
 971
 972 int set_alarm_config_int(CONFIG_TYPE config_type, char *key, int value, char *accessName)
 973 {
 974         _EXTERN_FUNC_ENTER;
 975
 976         int ret = 0;
 977         sync_agent_da_return_e result;
 978         sync_agent_da_config_s config;
 979         int exist = 0;
 980
 981         config.access_name = accessName;
 982         config.config_id = config_type;
 983         config.key = key;
 984         config.value = g_strdup_printf("%d", value);
 985         config.type = "int";
 986
 987         result = sync_agent_is_exist_config(config_type, key, &exist);
 988         if (result != SYNC_AGENT_DA_SUCCESS)
 989                 ret = 0;
 990
 991         if (exist == 0) {
 992                 _DEBUG_INFO("default add config : %s\n", key);
 993                 result = sync_agent_add_config(&config);
 994
 995                 if (result != SYNC_AGENT_DA_SUCCESS)
 996                         ret = 0;
 997         } else {
 998                 result = sync_agent_update_config(&config);
 999                 _DEBUG_INFO("update alarm config db ");
1000         }
1001
1002         ret = 1;
1003         str_free(&(config.value));
1004         _DEBUG_INFO("end : %d", ret);
1005         _EXTERN_FUNC_EXIT;
1006         return ret;
1007 }
1008
1009 int get_wifi_only_config()
1010 {
1011         _EXTERN_FUNC_ENTER;
1012
1013         _EXTERN_FUNC_EXIT;
1014         return get_config_int(FUMO_WIFI_ONLY_TYPE, FUMO_WIFI_ONLY_CONFIG);
1015 }
1016
1017 int set_wifi_only_config(int value)
1018 {
1019         _EXTERN_FUNC_ENTER;
1020
1021         _EXTERN_FUNC_EXIT;
1022         return set_config_int(FUMO_WIFI_ONLY_TYPE, FUMO_WIFI_ONLY_CONFIG, value, FUMO, 0);
1023 }
1024
1025 DM_ERROR get_battery_state(char **battery_level)
1026 {
1027         _EXTERN_FUNC_ENTER;
1028
1029         DM_ERROR ret = DM_OK;
1030         sync_agent_dev_return_e err = SYNC_AGENT_DEV_RETURN_SUCCESS;
1031
1032         err = sync_agent_get_devinfo(2, "Battery", battery_level);
1033         if (err != SYNC_AGENT_DEV_RETURN_SUCCESS) {
1034                 goto error;
1035         }
1036         if ((*battery_level) == NULL) {
1037                 goto error;
1038         }
1039
1040         _DEBUG_INFO("\n========battery ======== %s\n", *battery_level);
1041         _EXTERN_FUNC_EXIT;
1042         return ret;
1043  error:
1044         _EXTERN_FUNC_EXIT;
1045         return DM_GET_BATTERY_ERROR;
1046 }
1047
1048 DM_ERROR get_telephony_state(int *now_calling)
1049 {
1050         _EXTERN_FUNC_ENTER;
1051
1052         DM_ERROR ret = DM_OK;
1053
1054 /*
1055  * vconf( framework )
1056  */
1057         int tel_value;
1058         if (vconf_get_int(VCONFKEY_CALL_STATE, &tel_value) != 0)
1059                 goto error;
1060
1061         switch (tel_value) {
1062         case VCONFKEY_CALL_VOICE_CONNECTING:
1063         case VCONFKEY_CALL_VOICE_ACTIVE:
1064         case VCONFKEY_CALL_VIDEO_CONNECTING:
1065         case VCONFKEY_CALL_VIDEO_ACTIVE:
1066                 (*now_calling) = 1;
1067                 break;
1068         case VCONFKEY_CALL_OFF:
1069                 (*now_calling) = 0;
1070                 break;
1071         default:
1072                 break;
1073         }
1074
1075         _EXTERN_FUNC_EXIT;
1076         return ret;
1077  error:
1078         _EXTERN_FUNC_EXIT;
1079         return DM_TELEPHONY_ERROR;
1080
1081 }
1082
1083 void network_state_callback()
1084 {
1085         _EXTERN_FUNC_ENTER;
1086
1087         /*typedef enum {
1088            NETWORK_NONE,                                                                         initial network type
1089            NETWORK_3G_ON,                                                                network UMTS on
1090            NETWORK_3G_OFF,                                                               network UMTS off
1091            NETWORK_WIFI_ON,                                                              network WIFI on
1092            NETWORK_WIFI_ON_NOT_CONNECTED,        network WIFI on but not connected
1093            NETWORK_WIFI_OFF,                                                             network WIFI off
1094            NETWORK_WIFI_3G_ON,                                                   network UMTS and WIFI on
1095            } FW_NETWORK_TYPE;
1096            #endif
1097          */
1098
1099         /*sync_agent_na_result_e err;
1100            int net_type;
1101            err = NACI_Get_Network_Type(&net_type);
1102            if(err != SYNC_AGENT_NA_SUCCESS)
1103            goto error;
1104
1105            switch(net_type)
1106            {
1107            case 1:
1108            case 3:
1109
1110            * search db
1111            * generic alert
1112            * fumo (not alarm)
1113            * lawmo( not alarm)
1114            * deregister vconf callback
1115
1116            break;
1117            case 0:
1118            case 2:
1119            case 5:
1120            case 6:
1121            break;
1122            default:
1123            break;
1124            }
1125
1126            error: */
1127         _EXTERN_FUNC_EXIT;
1128         return;
1129 }
1130
1131 DM_ERROR existed_sd_card_memory(int *existed_sd)
1132 {
1133         _EXTERN_FUNC_ENTER;
1134
1135         DM_ERROR ret = DM_OK;
1136 /*
1137  * vconf( framework )
1138  * //only one sd card
1139  */
1140         int mmc_value = 0;
1141         int err = 0;
1142
1143         err = get_mmc_state(&mmc_value);
1144         if (err == 0) {
1145                 (*existed_sd) = 0;
1146                 goto error;
1147         } else {
1148                 if (mmc_value == 1) {
1149                         (*existed_sd) = 1;
1150
1151                         /*for make empty folder */
1152                         char *downlaod_folder = NULL;
1153                         char *save_folder = NULL;
1154                         ret = get_fota_download_dir(MEMORY_SD_CARD, &downlaod_folder);
1155                         if (ret != DM_OK) {
1156                                 goto error;
1157                         }
1158                         ret = get_fota_save_dir(MEMORY_SD_CARD, &save_folder);
1159                         if (ret != DM_OK) {
1160                                 goto error;
1161                         }
1162
1163                         str_free(&downlaod_folder);
1164                         str_free(&save_folder);
1165                 } else {
1166                         (*existed_sd) = 0;
1167                 }
1168         }
1169
1170         _EXTERN_FUNC_EXIT;
1171         return ret;
1172  error:
1173
1174         _EXTERN_FUNC_EXIT;
1175         return DM_SD_CARD_ERROR;
1176 }
1177
1178 void get_roaming_state(int *roaming_state)
1179 {
1180         _EXTERN_FUNC_ENTER;
1181
1182         int roaming_config = 0;
1183
1184         if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ROAM, roaming_state) != 0) {
1185                 *roaming_state = -1;
1186                 _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1187         } else {
1188                 if (*roaming_state == 0) {
1189                         /*not roaming svc area */
1190                         _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1191                         _EXTERN_FUNC_EXIT;
1192                         return;
1193                 } else {
1194                         /*roaming svc area */
1195                         if (vconf_get_bool(VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, &roaming_config) != 0) {
1196                                 *roaming_state = -1;
1197                                 _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1198                         } else {
1199                                 if (roaming_config == 1) {
1200                                         /*
1201                                          * do service roaming service
1202                                          *      check wifi
1203                                          */
1204                                         _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1205                                         return;
1206                                 } else {
1207                                         /*don not service at roaming svc */
1208                                         *roaming_state = -1;
1209                                         _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1210                                 }
1211                         }
1212                 }
1213         }
1214         _EXTERN_FUNC_EXIT;
1215 }
1216
1217 void get_wifi_connected_state(int *wifi_state)
1218 {
1219         _EXTERN_FUNC_ENTER;
1220
1221         int wifi_connection = VCONFKEY_WIFI_OFF;
1222         int nRes_wifistatus = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_connection);
1223         *wifi_state = -1;
1224
1225         if (nRes_wifistatus != 0) {
1226                 _DEBUG_INFO("vconf_get_int get wificonnection fail\n");
1227                 *wifi_state = -1;
1228                 _EXTERN_FUNC_EXIT;
1229                 return;
1230         }
1231
1232         if(wifi_connection >= VCONFKEY_WIFI_CONNECTED) {
1233                 _DEBUG_INFO("vconf_get_int get wificonnection success\n");
1234                 *wifi_state = 0;
1235                 _EXTERN_FUNC_EXIT;
1236                 return;
1237         }
1238
1239         _EXTERN_FUNC_EXIT;
1240 }
1241
1242 void get_call_sate(int *call_state)
1243 {
1244         _EXTERN_FUNC_ENTER;
1245         /*0 : do service
1246          * 1 : dont service
1247          * 2 : ?
1248          */
1249         if (vconf_get_int(VCONFKEY_CALL_STATE, call_state) != 0) {
1250                 *call_state = -1;
1251                 _DEBUG_INFO("end, call state : %d", *call_state);
1252                 _EXTERN_FUNC_EXIT;
1253                 return;
1254         } else {
1255                 if (*call_state == 0) {
1256                         _DEBUG_INFO("end, call state : %d", *call_state);
1257                         _EXTERN_FUNC_EXIT;
1258                         return;
1259                 } else {
1260                         *call_state = -1;
1261                         _DEBUG_INFO("end, call state : %d", *call_state);
1262                         _EXTERN_FUNC_EXIT;
1263                         return;
1264                 }
1265         }
1266 }
1267
1268 int get_mmc_state(int *mmc_state)
1269 {
1270         _EXTERN_FUNC_ENTER;
1271
1272         if (vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, mmc_state) != 0)
1273                 goto error;
1274
1275         _EXTERN_FUNC_EXIT;
1276         return 1;
1277  error:
1278         _EXTERN_FUNC_EXIT;
1279         _DEBUG_INFO("end error");
1280         return 0;
1281 }
1282
1283 DM_ERROR compare_memory_space(char *memory_type, long double file_size)
1284 {
1285         _EXTERN_FUNC_ENTER;
1286
1287         int err;
1288         long double sizeFree;
1289         long double sizeTotal;
1290
1291         retvm_if((memory_type) == NULL, COMMON_ERR_IS_NULL, "memory_type is NULL!!");
1292
1293         err = sync_agent_get_fs_mem_size(memory_type, &sizeFree, &sizeTotal);
1294         if (err == 0) {
1295                 _EXTERN_FUNC_EXIT;
1296                 return DM_MEMORY_ERROR;
1297         }
1298
1299         _DEBUG_INFO("need free size [%f], memory free size [%f], total size [%f] ", file_size, sizeFree, sizeTotal);
1300         if (file_size > sizeFree) {
1301                 _EXTERN_FUNC_EXIT;
1302                 return DM_OVER_MEMORY_ERROR;
1303         }
1304
1305         //_DEBUG_INFO("below return value is test code"); // for memory not enough - testing
1306         //return DM_OVER_MEMORY_ERROR; // for memory not enough - testing
1307         _EXTERN_FUNC_EXIT;
1308
1309         return DM_OK;
1310 }
1311
1312 DM_ERROR get_fota_download_dir(MEMORY_TYPE type, char **download_folder)
1313 {
1314         _EXTERN_FUNC_ENTER;
1315
1316         sync_agent_dev_return_e dci_down_ret = SYNC_AGENT_DEV_RETURN_SUCCESS;
1317
1318         switch (type) {
1319         case MEMORY_INTERNAL:
1320                 _DEBUG_INFO("internal memory");
1321                 dci_down_ret = sync_agent_get_devinfo(2, "FOTADownDir", download_folder);
1322                 break;
1323         case MEMORY_SD_CARD:
1324                 _DEBUG_INFO("sd card memory");
1325                 dci_down_ret = sync_agent_get_devinfo(2, "FOTA_SD_DownDir", download_folder);
1326                 break;
1327         default:
1328                 _DEBUG_INFO("ERROR NOT USE MEMORY");
1329                 break;
1330         }
1331
1332         if (dci_down_ret == SYNC_AGENT_DEV_RETURN_SUCCESS) {
1333                 _DEBUG_INFO(" download : %s", *download_folder);
1334
1335                 _EXTERN_FUNC_EXIT;
1336                 return DM_OK;
1337         }
1338         _DEBUG_INFO("end error : %d ", DM_MEMORY_ERROR);
1339         _EXTERN_FUNC_EXIT;
1340         return DM_MEMORY_ERROR;
1341 }
1342
1343 DM_ERROR get_fota_save_dir(MEMORY_TYPE type, char **save_folder)
1344 {
1345         _EXTERN_FUNC_ENTER;
1346
1347         sync_agent_dev_return_e dci_down_ret = SYNC_AGENT_DEV_RETURN_SUCCESS;
1348
1349         switch (type) {
1350         case MEMORY_INTERNAL:
1351                 dci_down_ret = sync_agent_get_devinfo(2, "FOTASaveDir", save_folder);
1352                 break;
1353         case MEMORY_SD_CARD:
1354                 dci_down_ret = sync_agent_get_devinfo(2, "FOTA_SD_SaveDir", save_folder);
1355                 break;
1356         default:
1357                 _DEBUG_INFO("ERROR NOT USE MEMORY");
1358                 break;
1359         }
1360
1361         if (dci_down_ret == SYNC_AGENT_DEV_RETURN_SUCCESS) {
1362                 _DEBUG_INFO(" save_folder : %s", *save_folder);
1363
1364                 _EXTERN_FUNC_EXIT;
1365                 return DM_OK;
1366         }
1367         _DEBUG_INFO("end error : %d ", DM_MEMORY_ERROR);
1368         _EXTERN_FUNC_EXIT;
1369         return DM_MEMORY_ERROR;
1370 }
1371
1372 void delete_fumo_contents(MEMORY_TYPE memory_type)
1373 {
1374         _EXTERN_FUNC_ENTER;
1375
1376         _DEBUG_INFO("----------------------------------------------------------firmware update fail delete files-----------------------------------------------------------");
1377         char *download_folder = NULL;
1378         char *save_folder = NULL;
1379
1380         //FOTASaveDir //FOTADownDir
1381         //dci_save_ret = sync_agent_get_devinfo(2 , "FOTADownDir" , &download_folder);
1382         get_fota_download_dir(memory_type, &download_folder);
1383         sync_agent_empty_directory_contents(download_folder);
1384         //dci_save_ret = sync_agent_get_devinfo(2 , "FOTASaveDir" , &save_folder);
1385         get_fota_save_dir(memory_type, &save_folder);
1386
1387         sync_agent_empty_directory_contents(save_folder);
1388         _DEBUG_INFO("delete save folder ");
1389
1390         str_free(&save_folder);
1391         str_free(&download_folder);
1392
1393         _EXTERN_FUNC_EXIT;
1394
1395 }
1396
1397 void first_server_bootstrap(char *server_id)
1398 {
1399         _EXTERN_FUNC_ENTER;
1400
1401         DM_ERROR ret = DM_OK;
1402
1403         if (server_id == NULL) {
1404                 _DEBUG_INFO("server id null");
1405                 return;
1406         }
1407
1408         Event_Contents *ev_data = (Event_Contents *) calloc(1, sizeof(Event_Contents) + 1);
1409         if (ev_data == NULL) {
1410                 _DEBUG_INFO("alloc fail");
1411                 _EXTERN_FUNC_EXIT;
1412                 return;
1413         }
1414         ev_data->server_id = strdup(server_id);
1415         ev_data->session_id = NULL;
1416         ev_data->type = SERVER_BOOTSTRAP_EVENT;
1417         ev_data->ui_mode = NULL;
1418
1419         _DEBUG_INFO("event type server bootstrap : %d", ev_data->type);
1420         _DEBUG_INFO("session id : %s", ev_data->session_id);
1421         _DEBUG_INFO("server id : %s", ev_data->server_id);
1422
1423         /* UI CONFIRM */
1424         SERVICE_SERVER_TYPE engine_type;
1425         engine_type = get_service_engine_type(ev_data->server_id);
1426
1427         switch (engine_type) {
1428         case SAMSUNG_FUMO_TYPE:
1429         case GCF_TYPE:
1430                 {
1431                         //when using telephony
1432                         //DM_ERROR get_telephony_state(int *now_calling);
1433                         _DEBUG_INFO("engine type : %d", engine_type);
1434                         ev_data->noti_type = NOTI_TYPE_BACKGRUOUND;
1435                         ev_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
1436
1437                         _DEBUG_INFO("noti type : %d", ev_data->noti_type);
1438                         _DEBUG_INFO("ui mode : %s", ev_data->ui_mode);
1439
1440                         ret = dm_fumo_common_task_request(ev_data);
1441                         _DEBUG_INFO("dm fumo conmmon task : %d ", ret);
1442                         if (ret != DM_OK) {
1443                                 goto error;
1444                         }
1445                 }
1446                 break;
1447         case SAMSUNG_FMM_TYPE:
1448
1449                 _DEBUG_INFO("engine type : %d", engine_type);
1450                 ret = dm_lawmo_common_task_request(ev_data);
1451                 _DEBUG_INFO("dm lawmo conmmon task : %d ", ret);
1452                 if (ret != DM_OK) {
1453                         goto error;
1454                 }
1455                 break;
1456         default:
1457                 _DEBUG_INFO("dm non engine ", ret);
1458                 break;
1459         }
1460
1461         _EXTERN_FUNC_EXIT;
1462         return;
1463
1464  error:
1465         event_data_free((void *)ev_data);
1466         _EXTERN_FUNC_EXIT;
1467 }
1468
1469 int get_default_noti_type(char *ui_mode, NotI_Type noti_type)
1470 {
1471         _EXTERN_FUNC_ENTER;
1472
1473         retvm_if((ui_mode) == NULL, COMMON_ERR_IS_NULL, "ui_mode is NULL!!");
1474
1475         if (strcmp(OMADM_FUMO_UI_TYPE, ui_mode) == 0) {
1476                 _EXTERN_FUNC_EXIT;
1477                 return NOTI_UNKNOWN;    //none type
1478         } else if (strcmp(OMADM_FUMO_NOTI_UI_TYPE, ui_mode) == 0) {
1479                 switch (noti_type) {
1480                 case NOTI_TYPE_NOT_SPECIFIED:
1481                 case NOTI_TYPE_BACKGRUOUND:
1482                 case NOTI_TYPE_USERINTERACTION:
1483                         _EXTERN_FUNC_EXIT;
1484                         return NOTI_DOWNLOAD;   //none type
1485                         break;
1486                 case NOTI_TYPE_INFOMATIVE:
1487                         _EXTERN_FUNC_EXIT;
1488                         return NOTI_DOWNLOAD;   //connect to server
1489                         break;
1490                 case NOTI_TYPE_POLLINTERACTION:
1491                         _EXTERN_FUNC_EXIT;
1492                         return NOTI_POLL_INTERACTION;   //connect to server
1493                         break;
1494                 default:
1495                         return NOTI_UNKNOWN;    //none type
1496                         break;
1497                 }
1498         } else if (strcmp(OMADM_FUMO_BACKGROUND_UI_TYPE, ui_mode) == 0) {
1499                 _EXTERN_FUNC_EXIT;
1500                 return NOTI_UNKNOWN;    //none type
1501         }
1502
1503         _EXTERN_FUNC_EXIT;
1504         return NOTI_UNKNOWN;
1505 }
1506
1507 int wifi_only_config(char *config)
1508 {
1509         _EXTERN_FUNC_ENTER;
1510
1511         retvm_if((config) == NULL, COMMON_ERR_IS_NULL, "config is NULL!!");
1512
1513         if (config != NULL) {
1514                 if (strcmp(config, "1") == 0) {
1515                         _DEBUG_INFO("wifi on config");
1516                         _EXTERN_FUNC_EXIT;
1517                         return 1;
1518                 } else if (strcmp(config, "0") == 0) {
1519                         _DEBUG_INFO("wifi off config");
1520                         _EXTERN_FUNC_EXIT;
1521                         return 0;
1522                 } else {
1523                         _DEBUG_INFO("wifi config error");
1524                 }
1525         } else {
1526                 _DEBUG_INFO("wifi config error");
1527         }
1528
1529         _EXTERN_FUNC_EXIT;
1530
1531         return 0;
1532 }