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