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         if (ret != DM_OK)
 181                 goto error;
 182
 183         /* engine status db reset */
 184         //ret = DB_Delete_Table();
 185         ret = DB_Reset_Table();
 186         if (ret != DM_OK)
 187                 goto error;
 188
 189         /* omadm db */
 190         sync_agent_empty_agent_default_table(SYNC_AGENT_DA_TABLE_NAME_CONFIG);
 191         //sync_agent_empty_all_agent_table()
 192
 193         /*fumo, lawmo data in alarm db */
 194         _DEBUG_INFO("--------------------------------------------------------------------------------------------");
 195
 196         _EXTERN_FUNC_EXIT;
 197         return ret;
 198
 199  error:
 200         _EXTERN_FUNC_EXIT;
 201         _DEBUG_INFO(" end error : %d \n", ret);
 202         return ret;
 203 }
 204
 205 DM_ERROR auto_operate_service_engine()
 206 {
 207         _EXTERN_FUNC_ENTER;
 208
 209         DM_ERROR ret = DM_OK;
 210         engine_status *status = NULL;
 211
 212         if (IsExist_Engine_id(FUMO_SERVICE_ENGINE) != 0) {
 213                 printf("engine id VALUE : %d ", FUMO_SERVICE_ENGINE);
 214                 _DEBUG_INFO("engine id VALUE : %d ", FUMO_SERVICE_ENGINE);
 215
 216                 ret = Get_Engine_Status(FUMO_SERVICE_ENGINE, &status);
 217                 if (ret != DM_OK || status == NULL)
 218                         goto error;
 219
 220                 if (status->engine_status == 0) {
 221                         ret = Delete_Engine_Status(FUMO_SERVICE_ENGINE);
 222                         if (ret != DM_OK)
 223                                 goto error;
 224                 } else {
 225                         ret = fumo_serviceEngine_task_request();
 226                         _DEBUG_INFO("fumo server engine task request : %d", ret);
 227                 }
 228                 if (status != NULL) {
 229                         Free_Memory_Engine_Status(&status, 1);
 230                 }
 231         }
 232
 233         if (IsExist_Engine_id(LAWMO_SERVICE_ENGINE) != 0) {
 234                 printf("engine id VALUE : %d ", LAWMO_SERVICE_ENGINE);
 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_1HOUR:
 564                 {
 565                         /* 1 hour */
 566                         alarm_info->repeat_type = REPEAT;
 567                         alarm_info->repeat_value = ((1 * 60) * 60);
 568                         //alarm_info->repeat_value = ((1*60)*1);
 569                 }
 570                 break;
 571         case INTERVAL_3HOURS:
 572                 {
 573                         /* 4 hour */
 574                         alarm_info->repeat_type = REPEAT;
 575                         alarm_info->repeat_value = ((3 * 60) * 60);
 576                 }
 577                 break;
 578         case INTERVAL_6HOURS:
 579                 {
 580                         /* 6 hour */
 581                         alarm_info->repeat_type = REPEAT;
 582                         alarm_info->repeat_value = ((6 * 60) * 60);
 583
 584                 }
 585                 break;
 586         case INTERVAL_12HOURS:
 587                 {
 588                         /* 12 hour */
 589                         alarm_info->repeat_type = REPEAT;
 590                         alarm_info->repeat_value = ((12 * 60) * 60);
 591
 592                 }
 593                 break;
 594         case INTERVAL_1DAY:
 595                 {
 596                         /* 1 day */
 597                         alarm_info->repeat_type = REPEAT;
 598                         alarm_info->repeat_value = ((24 * 60) * 60);
 599                 }
 600                 break;
 601                 /*
 602                    case INTERVAL_7DAYS:
 603                    {
 604                    // 1 week
 605                    alarm_info->repeat_type = REPEAT_WEEKLY ;
 606                    alarm_info->repeat_value = week[struct_time->tm_wday];
 607                    }
 608                    break;
 609                  */
 610         case INTERVAL_1MONTH:
 611                 {
 612                         alarm_info->repeat_type = REPEAT_MONTHLY;
 613                         alarm_info->repeat_value = 0;
 614                 }
 615         case INTERVAL_CANCEL:
 616                 goto return_part;
 617                 break;
 618         default:
 619                 break;
 620         }
 621
 622         _DEBUG_INFO("######### Alarm Info #####################\n");
 623         _DEBUG_INFO("time = %s\n", alarm_info->start_alarm_time);
 624         _DEBUG_INFO("repeat_mode = %d, repeat_value = %d\n", alarm_info->repeat_type, alarm_info->repeat_value);
 625         _DEBUG_INFO("is_disposable = %d\n", alarm_info->is_disposable);
 626
 627 /*       if(conf_type == FUMO_INTERVAL_TYPE)
 628                  delete_alarm_item(FUMO_INTERVAL, FUMO_INTERVAL_TYPE);*/
 629
 630         int alarm_id = 0;
 631         int alarm_ret = 0;
 632         sync_agent_pm_return_e err = SYNC_AGENT_PM_SUCCESS;
 633
 634         /*add alarm service */
 635         err = sync_agent_add_service_data(1, alarm_info, &alarm_id);
 636         if (err != SYNC_AGENT_PM_SUCCESS) {
 637                 _DEBUG_INFO("Fail PMCI_Add_Item_To_Specific_Type\n");
 638                 ret = DM_ERR_FUMO_INTERNAL_SCHEDULER_ERROR;
 639         } else {
 640                 /*add framework config db */
 641                 alarm_ret = set_alarm_config_int(conf_type, alarm_type, alarm_id, alarm_type);
 642                 if (alarm_ret == 0) {
 643                         ret = DM_ERR_FUMO_INTERNAL_SCHEDULER_ERROR;
 644                 }
 645         }
 646
 647         if (alarm_info != NULL) {
 648                 str_free(&(alarm_info->start_alarm_time));
 649                 free(alarm_info);
 650                 alarm_info = NULL;
 651         }
 652
 653         _EXTERN_FUNC_EXIT;
 654         return ret;
 655
 656  return_part:
 657
 658         if (alarm_info != NULL) {
 659                 str_free(&(alarm_info->start_alarm_time));
 660                 free(alarm_info);
 661                 alarm_info = NULL;
 662         }
 663
 664         _EXTERN_FUNC_EXIT;
 665         _DEBUG_INFO("end error : %d ", ret);
 666         return ret;
 667 }
 668
 669 void delete_alarm_item(char *alarm_type, CONFIG_TYPE conf_type)
 670 {
 671         _EXTERN_FUNC_ENTER;
 672
 673         int count = 0;
 674         int before_alarm_id;
 675         int ret = 0;
 676         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 677         sync_agent_pm_return_e pm_result = SYNC_AGENT_PM_SUCCESS;
 678
 679         sync_agent_da_config_s *config = NULL;
 680
 681         GList *list = NULL;
 682
 683         result = sync_agent_get_config_list(conf_type, &list);
 684         count = g_list_length(list);
 685
 686         _DEBUG_INFO("alarm count: %d\n", count);
 687         if (count > 0 && list != 0) {
 688                 config = (sync_agent_da_config_s *) g_list_nth_data(list, 0);
 689                 _DEBUG_INFO("------------------------------------------alarm id : %s----------------------------------------------\n", config->value);
 690                 ret = chartoint(config->value, &before_alarm_id);
 691                 if (ret == 1) {
 692                         pm_result = sync_agent_remove_service_data(1, before_alarm_id);
 693                         _DEBUG_INFO("delete alarm %d", result);
 694
 695                         if (pm_result == SYNC_AGENT_PM_SUCCESS) {
 696                                 result = sync_agent_delete_config(conf_type, alarm_type);
 697                                 _DEBUG_INFO("delete alarm config %d", result);
 698                         }
 699                 } else {
 700                         _DEBUG_INFO("fail get alarm id");
 701                 }
 702         }
 703
 704         sync_agent_free_config_list(list);
 705         _EXTERN_FUNC_EXIT;
 706
 707 }
 708
 709 SERVICE_SERVER_TYPE get_service_engine_type(const char *server_id)
 710 {
 711         _EXTERN_FUNC_ENTER;
 712
 713         retvm_if(server_id == NULL, NO_ENGINE_TYPE, "server_id is NULL!!");
 714
 715         _DEBUG_INFO("get- service engine type by server id : %s", server_id);
 716         _EXTERN_FUNC_EXIT;
 717         return get_engine_type_by_serverid(server_id);
 718 }
 719
 720 DM_ERROR get_server_info(Event_Contents * pEvent_data, char **server_id, char **session_id, int *session_type)
 721 {
 722         _EXTERN_FUNC_ENTER;
 723
 724         DM_ERROR ret = DM_OK;
 725
 726         retvm_if((pEvent_data) == NULL, COMMON_ERR_INTERNAL_NOT_DEFINED, "pEvent_data is NULL!!");
 727         retvm_if((pEvent_data->server_id) == NULL, COMMON_ERR_INTERNAL_NOT_DEFINED, "server_id is NULL!!");
 728
 729         (*server_id) = strdup(pEvent_data->server_id);
 730         _DEBUG_INFO(" server id : %s\n", *server_id);
 731
 732         if (pEvent_data->session_id != NULL) {
 733                 (*session_id) = strdup(pEvent_data->session_id);
 734                 _DEBUG_INFO(" session_id : %s\n", *session_id);
 735         }
 736
 737         (*session_type) = pEvent_data->type;
 738         _DEBUG_INFO("session type  : %d\n", *session_type);
 739
 740         _EXTERN_FUNC_EXIT;
 741         return ret;
 742 }
 743
 744 void get_service_engine_id(ENGINE_ID * service_engine_id, char *ui_mode)
 745 {
 746         _EXTERN_FUNC_ENTER;
 747
 748         if (ui_mode == NULL)
 749                 return;
 750
 751         if (!strcmp(ui_mode, OMADM_FUMO_UI_TYPE) || !strcmp(ui_mode, OMADM_FUMO_NOTI_UI_TYPE)) {
 752                 *service_engine_id = FUMO_SERVICE_ENGINE;
 753                 _DEBUG_INFO("fumo service");
 754         } else {
 755                 _DEBUG_INFO("other service");
 756         }
 757
 758         _EXTERN_FUNC_EXIT;
 759 }
 760
 761 DM_ERROR fumo_service_start(Event_Contents * pEvent_data)
 762 {
 763         _EXTERN_FUNC_ENTER;
 764
 765         DM_ERROR ret = DM_OK;
 766
 767         retvm_if((pEvent_data) == NULL, COMMON_ERR_INTERNAL_NOT_DEFINED, "pEvent_data is NULL!!");
 768
 769         switch (pEvent_data->noti_type) {
 770         case NOTI_TYPE_NOT_SPECIFIED:
 771                 _DEBUG_INFO("NOTI_TYPE_NOT_SPECIFIED");
 772                 //temp version for gcf test
 773                 pEvent_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
 774                 pEvent_data->noti_type = NOTI_TYPE_BACKGRUOUND;
 775                 ret = dm_fumo_common_task_request(pEvent_data);
 776                 _DEBUG_INFO("NOTI NOTI_TYPE_BACKGRUOUND : %d", ret);
 777                 if (ret != DM_OK) {
 778                         goto error;
 779                 }
 780                 break;
 781         case NOTI_TYPE_BACKGRUOUND:
 782                 pEvent_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
 783                 ret = dm_fumo_common_task_request(pEvent_data);
 784                 _DEBUG_INFO("NOTI NOTI_TYPE_BACKGRUOUND : %d", ret);
 785                 if (ret != DM_OK) {
 786                         goto error;
 787                 }
 788                 break;
 789         case NOTI_TYPE_INFOMATIVE:
 790                 pEvent_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
 791                 ret = dm_fumo_common_task_request(pEvent_data);
 792                 _DEBUG_INFO("NOTI NOTI_TYPE_INFOMATIVE : %d", ret);
 793                 if (ret != DM_OK) {
 794                         goto error;
 795                 }
 796                 break;
 797         case NOTI_TYPE_USERINTERACTION:
 798                 pEvent_data->ui_mode = strdup(OMADM_FUMO_NOTI_UI_TYPE);
 799                 ret = dm_fumo_ui_task_request(pEvent_data);
 800                 _DEBUG_INFO("NOTI NOTI_TYPE_USERINTERACTION : %d ", ret);
 801                 if (ret != DM_OK) {
 802                         goto error;
 803                 }
 804                 break;
 805         default:
 806                 break;
 807         }
 808
 809         _EXTERN_FUNC_EXIT;
 810         return DM_OK;
 811  error:
 812         event_data_free((void *)pEvent_data);
 813         _EXTERN_FUNC_EXIT;
 814         return DM_OK;
 815
 816 }
 817
 818 DM_ERROR get_fumo_ui_mode(char **ui_mode)
 819 {
 820         _EXTERN_FUNC_ENTER;
 821
 822         DM_ERROR ret = DM_OK;
 823
 824         engine_status *status = NULL;
 825         ret = Get_Engine_Status(FUMO_SERVICE_ENGINE, &status);
 826         if (ret != DM_OK) {
 827                 if(status != NULL)
 828                         Free_Memory_Engine_Status(&status, 1);
 829
 830                 _EXTERN_FUNC_EXIT;
 831                 return ret;
 832         }
 833
 834         if (status != NULL) {
 835
 836                 if (status->ui_mode != NULL) {
 837                         (*ui_mode) = strdup(status->ui_mode);
 838
 839                         _DEBUG_INFO("==================Fumo ui : %s==================\n", *ui_mode);
 840                 } else {
 841                         _DEBUG_INFO("ui mode null");
 842                 }
 843
 844                 Free_Memory_Engine_Status(&status, 1);
 845
 846         } else {
 847                 _DEBUG_INFO("status is null");
 848         }
 849
 850         _DEBUG_INFO("end");
 851         _EXTERN_FUNC_EXIT;
 852         return ret;
 853
 854 }
 855
 856 int check_existed_fumo_reminder_interval()
 857 {
 858         _EXTERN_FUNC_ENTER;
 859
 860         int exist = 0;
 861         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 862         result = sync_agent_is_exist_config(FUMO_INTERVAL_TYPE, FUMO_INTERVAL, &exist);
 863         _DEBUG_INFO("agent is exist result : %d", result);
 864
 865         _EXTERN_FUNC_EXIT;
 866         return exist;
 867 }
 868
 869 int init_default_fumo_config()
 870 {
 871         _EXTERN_FUNC_ENTER;
 872
 873         _EXTERN_FUNC_EXIT;
 874         return set_config_int(FUMO_WIFI_ONLY_TYPE, FUMO_WIFI_ONLY_CONFIG, 0, FUMO, 1);
 875 }
 876
 877 int set_config_int(CONFIG_TYPE config_type, char *key, int value, char *accessName, int isFirst)
 878 {
 879         _EXTERN_FUNC_ENTER;
 880         int ret = 1;
 881         sync_agent_da_return_e result;
 882         sync_agent_da_config_s config;
 883         int exist = 0;
 884
 885         config.access_name = accessName;
 886         config.config_id = config_type;
 887         config.key = key;
 888         config.value = g_strdup_printf("%d", value);
 889         config.type = "int";
 890
 891         result = sync_agent_is_exist_config(config_type, key, &exist);
 892         if (result != SYNC_AGENT_DA_SUCCESS) {
 893                 _DEBUG_INFO("exist config fail : %d", result);
 894                 ret = -1;
 895         } else {
 896                 if (exist == 0 && isFirst == 1) {
 897                         _DEBUG_INFO("default add config : %s\n", key);
 898                         result = sync_agent_add_config(&config);
 899                         if (result != SYNC_AGENT_DA_SUCCESS) {
 900                                 _DEBUG_INFO("fail add : %d", result);
 901                                 ret = -1;
 902                         } else {
 903                                 _DEBUG_INFO("Success add config : %s, : %d\n", key, value);
 904                         }
 905                 } else {
 906                         result = sync_agent_update_config(&config);
 907                         //free config
 908                         if (result != SYNC_AGENT_DA_SUCCESS) {
 909                                 _DEBUG_INFO("fail update : %d", result);
 910                                 ret = -1;
 911                         } else {
 912                                 _DEBUG_INFO("Success update config : %s, : %d\n", key, value);
 913                         }
 914                 }
 915         }
 916
 917         str_free(&(config.value));
 918         _EXTERN_FUNC_EXIT;
 919
 920         return ret;
 921 }
 922
 923 int get_config_int(CONFIG_TYPE config_id, char *key)
 924 {
 925         _EXTERN_FUNC_ENTER;
 926
 927         sync_agent_da_return_e result = SYNC_AGENT_DA_SUCCESS;
 928         sync_agent_da_config_s *config = NULL;
 929         int value = 1;
 930         int ret = -1;
 931
 932         result = sync_agent_create_config(&config);
 933         if (result != SYNC_AGENT_DA_SUCCESS) {
 934                 _EXTERN_FUNC_EXIT;
 935                 return -1;
 936         }
 937
 938         result = sync_agent_get_config(config_id, key, &config);
 939         _DEBUG_INFO("---------------------------result : %d-------------------------\n", result);
 940         if (result == 1) {
 941                 _DEBUG_INFO("Success get config value");
 942
 943                 ret = chartoint(config->value, &value);
 944                 _DEBUG_INFO("result : %d , key : %s value : %d\n", result, key, value);
 945
 946                 if (ret == 0) {
 947                         _DEBUG_INFO("fail get config value");
 948                         ret = -1;
 949                         goto return_part;
 950                 } else {
 951                         _DEBUG_INFO("success get config value");
 952                         ret = value;
 953                 }
 954         } else {
 955                 _DEBUG_INFO("fail get config value");
 956         }
 957
 958  return_part:
 959
 960         sync_agent_free_config(config);
 961         _EXTERN_FUNC_EXIT;
 962         return ret;
 963 }
 964
 965 int set_alarm_config_int(CONFIG_TYPE config_type, char *key, int value, char *accessName)
 966 {
 967         _EXTERN_FUNC_ENTER;
 968
 969         int ret = 0;
 970         sync_agent_da_return_e result;
 971         sync_agent_da_config_s config;
 972         int exist = 0;
 973
 974         config.access_name = accessName;
 975         config.config_id = config_type;
 976         config.key = key;
 977         config.value = g_strdup_printf("%d", value);
 978         config.type = "int";
 979
 980         result = sync_agent_is_exist_config(config_type, key, &exist);
 981         if (result != SYNC_AGENT_DA_SUCCESS)
 982                 ret = 0;
 983
 984         if (exist == 0) {
 985                 _DEBUG_INFO("default add config : %s\n", key);
 986                 result = sync_agent_add_config(&config);
 987
 988                 if (result != SYNC_AGENT_DA_SUCCESS)
 989                         ret = 0;
 990         } else {
 991                 result = sync_agent_update_config(&config);
 992                 _DEBUG_INFO("update alarm config db ");
 993         }
 994
 995         ret = 1;
 996         str_free(&(config.value));
 997         _DEBUG_INFO("end : %d", ret);
 998         _EXTERN_FUNC_EXIT;
 999         return ret;
1000 }
1001
1002 int get_wifi_only_config()
1003 {
1004         _EXTERN_FUNC_ENTER;
1005
1006         _EXTERN_FUNC_EXIT;
1007         return get_config_int(FUMO_WIFI_ONLY_TYPE, FUMO_WIFI_ONLY_CONFIG);
1008 }
1009
1010 int set_wifi_only_config(int value)
1011 {
1012         _EXTERN_FUNC_ENTER;
1013
1014         _EXTERN_FUNC_EXIT;
1015         return set_config_int(FUMO_WIFI_ONLY_TYPE, FUMO_WIFI_ONLY_CONFIG, value, FUMO, 0);
1016 }
1017
1018 DM_ERROR get_battery_state(char **battery_level)
1019 {
1020         _EXTERN_FUNC_ENTER;
1021
1022         DM_ERROR ret = DM_OK;
1023         sync_agent_dev_return_e err = SYNC_AGENT_DEV_RETURN_SUCCESS;
1024
1025         err = sync_agent_get_devinfo(2, "Battery", battery_level);
1026         if (err != SYNC_AGENT_DEV_RETURN_SUCCESS) {
1027                 goto error;
1028         }
1029         if ((*battery_level) == NULL) {
1030                 goto error;
1031         }
1032
1033         _DEBUG_INFO("\n========battery ======== %s\n", *battery_level);
1034         _EXTERN_FUNC_EXIT;
1035         return ret;
1036  error:
1037         _EXTERN_FUNC_EXIT;
1038         return DM_GET_BATTERY_ERROR;
1039 }
1040
1041 DM_ERROR get_telephony_state(int *now_calling)
1042 {
1043         _EXTERN_FUNC_ENTER;
1044
1045         DM_ERROR ret = DM_OK;
1046
1047 /*
1048  * vconf( framework )
1049  */
1050         int tel_value;
1051         if (vconf_get_int(VCONFKEY_CALL_STATE, &tel_value) != 0)
1052                 goto error;
1053
1054         switch (tel_value) {
1055         case VCONFKEY_CALL_VOICE_CONNECTING:
1056         case VCONFKEY_CALL_VOICE_ACTIVE:
1057         case VCONFKEY_CALL_VIDEO_CONNECTING:
1058         case VCONFKEY_CALL_VIDEO_ACTIVE:
1059                 (*now_calling) = 1;
1060                 break;
1061         case VCONFKEY_CALL_OFF:
1062                 (*now_calling) = 0;
1063                 break;
1064         default:
1065                 break;
1066         }
1067
1068         _EXTERN_FUNC_EXIT;
1069         return ret;
1070  error:
1071         _EXTERN_FUNC_EXIT;
1072         return DM_TELEPHONY_ERROR;
1073
1074 }
1075
1076 void network_state_callback()
1077 {
1078         _EXTERN_FUNC_ENTER;
1079
1080         /*typedef enum {
1081            NETWORK_NONE,                                                                         initial network type
1082            NETWORK_3G_ON,                                                                network UMTS on
1083            NETWORK_3G_OFF,                                                               network UMTS off
1084            NETWORK_WIFI_ON,                                                              network WIFI on
1085            NETWORK_WIFI_ON_NOT_CONNECTED,        network WIFI on but not connected
1086            NETWORK_WIFI_OFF,                                                             network WIFI off
1087            NETWORK_WIFI_3G_ON,                                                   network UMTS and WIFI on
1088            } FW_NETWORK_TYPE;
1089            #endif
1090          */
1091
1092         /*sync_agent_na_result_e err;
1093            int net_type;
1094            err = NACI_Get_Network_Type(&net_type);
1095            if(err != SYNC_AGENT_NA_SUCCESS)
1096            goto error;
1097
1098            switch(net_type)
1099            {
1100            case 1:
1101            case 3:
1102
1103            * search db
1104            * generic alert
1105            * fumo (not alarm)
1106            * lawmo( not alarm)
1107            * deregister vconf callback
1108
1109            break;
1110            case 0:
1111            case 2:
1112            case 5:
1113            case 6:
1114            break;
1115            default:
1116            break;
1117            }
1118
1119            error: */
1120         _EXTERN_FUNC_EXIT;
1121         return;
1122 }
1123
1124 DM_ERROR existed_sd_card_memory(int *existed_sd)
1125 {
1126         _EXTERN_FUNC_ENTER;
1127
1128         DM_ERROR ret = DM_OK;
1129 /*
1130  * vconf( framework )
1131  * //only one sd card
1132  */
1133         int mmc_value = 0;
1134         int err = 0;
1135
1136         err = get_mmc_state(&mmc_value);
1137         if (err == 0) {
1138                 (*existed_sd) = 0;
1139                 goto error;
1140         } else {
1141                 if (mmc_value == 1) {
1142                         (*existed_sd) = 1;
1143
1144                         /*for make empty folder */
1145                         char *downlaod_folder = NULL;
1146                         char *save_folder = NULL;
1147                         ret = get_fota_download_dir(MEMORY_SD_CARD, &downlaod_folder);
1148                         if (ret != DM_OK) {
1149                                 goto error;
1150                         }
1151                         ret = get_fota_save_dir(MEMORY_SD_CARD, &save_folder);
1152                         if (ret != DM_OK) {
1153                                 goto error;
1154                         }
1155
1156                         str_free(&downlaod_folder);
1157                         str_free(&save_folder);
1158                 } else {
1159                         (*existed_sd) = 0;
1160                 }
1161         }
1162
1163         _EXTERN_FUNC_EXIT;
1164         return ret;
1165  error:
1166
1167         _EXTERN_FUNC_EXIT;
1168         return DM_SD_CARD_ERROR;
1169 }
1170
1171 void get_roaming_state(int *roaming_state)
1172 {
1173         _EXTERN_FUNC_ENTER;
1174
1175         int roaming_config = 0;
1176
1177         if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ROAM, roaming_state) != 0) {
1178                 *roaming_state = -1;
1179                 _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1180         } else {
1181                 if (*roaming_state == 0) {
1182                         /*not roaming svc area */
1183                         _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1184                         _EXTERN_FUNC_EXIT;
1185                         return;
1186                 } else {
1187                         /*roaming svc area */
1188                         if (vconf_get_bool(VCONFKEY_SETAPPL_STATE_DATA_ROAMING_BOOL, &roaming_config) != 0) {
1189                                 *roaming_state = -1;
1190                                 _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1191                         } else {
1192                                 if (roaming_config == 1) {
1193                                         /*
1194                                          * do service roaming service
1195                                          *      check wifi
1196                                          */
1197                                         _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1198                                         return;
1199                                 } else {
1200                                         /*don not service at roaming svc */
1201                                         *roaming_state = -1;
1202                                         _DEBUG_INFO("end , roaming state : %d", *roaming_state);
1203                                 }
1204                         }
1205                 }
1206         }
1207         _EXTERN_FUNC_EXIT;
1208 }
1209
1210 void get_wifi_connected_state(int *wifi_state)
1211 {
1212         _EXTERN_FUNC_ENTER;
1213
1214         int wifi_connection = VCONFKEY_WIFI_OFF;
1215         int nRes_wifistatus = vconf_get_int(VCONFKEY_WIFI_STATE, &wifi_connection);
1216         *wifi_state = -1;
1217
1218         if (nRes_wifistatus != 0) {
1219                 _DEBUG_INFO("vconf_get_int get wificonnection fail\n");
1220                 *wifi_state = -1;
1221                 _EXTERN_FUNC_EXIT;
1222                 return;
1223         }
1224
1225         if(wifi_connection >= VCONFKEY_WIFI_CONNECTED) {
1226                 _DEBUG_INFO("vconf_get_int get wificonnection success\n");
1227                 *wifi_state = 0;
1228                 _EXTERN_FUNC_EXIT;
1229                 return;
1230         }
1231
1232         _EXTERN_FUNC_EXIT;
1233 }
1234
1235 void get_call_sate(int *call_state)
1236 {
1237         _EXTERN_FUNC_ENTER;
1238         /*0 : do service
1239          * 1 : dont service
1240          * 2 : ?
1241          */
1242         if (vconf_get_int(VCONFKEY_TELEPHONY_CALL_STATE, call_state) != 0) {
1243                 *call_state = -1;
1244                 _DEBUG_INFO("end, call state : %d", *call_state);
1245                 _EXTERN_FUNC_EXIT;
1246                 return;
1247         } else {
1248                 if (*call_state == 0) {
1249                         _DEBUG_INFO("end, call state : %d", *call_state);
1250                         _EXTERN_FUNC_EXIT;
1251                         return;
1252                 } else {
1253                         *call_state = -1;
1254                         _DEBUG_INFO("end, call state : %d", *call_state);
1255                         _EXTERN_FUNC_EXIT;
1256                         return;
1257                 }
1258         }
1259 }
1260
1261 int get_mmc_state(int *mmc_state)
1262 {
1263         _EXTERN_FUNC_ENTER;
1264
1265         if (vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, mmc_state) != 0)
1266                 goto error;
1267
1268         _EXTERN_FUNC_EXIT;
1269         return 1;
1270  error:
1271         _EXTERN_FUNC_EXIT;
1272         _DEBUG_INFO("end error");
1273         return 0;
1274 }
1275
1276 DM_ERROR compare_memory_space(char *memory_type, long double file_size)
1277 {
1278         _EXTERN_FUNC_ENTER;
1279
1280         int err;
1281         long double sizeFree;
1282         long double sizeTotal;
1283
1284         retvm_if((memory_type) == NULL, COMMON_ERR_IS_NULL, "memory_type is NULL!!");
1285
1286         err = sync_agent_get_fs_mem_size(memory_type, &sizeFree, &sizeTotal);
1287         if (err == 0) {
1288                 _EXTERN_FUNC_EXIT;
1289                 return DM_MEMORY_ERROR;
1290         }
1291
1292         _DEBUG_INFO("need free size [%f], memory free size [%f], total size [%f] ", file_size, sizeFree, sizeTotal);
1293         if (file_size > sizeFree) {
1294                 _EXTERN_FUNC_EXIT;
1295                 return DM_OVER_MEMORY_ERROR;
1296         }
1297
1298         //_DEBUG_INFO("below return value is test code"); // for memory not enough - testing
1299         //return DM_OVER_MEMORY_ERROR; // for memory not enough - testing
1300         _EXTERN_FUNC_EXIT;
1301
1302         return DM_OK;
1303 }
1304
1305 DM_ERROR get_fota_download_dir(MEMORY_TYPE type, char **download_folder)
1306 {
1307         _EXTERN_FUNC_ENTER;
1308
1309         sync_agent_dev_return_e dci_down_ret = SYNC_AGENT_DEV_RETURN_SUCCESS;
1310
1311         switch (type) {
1312         case MEMORY_INTERNAL:
1313                 _DEBUG_INFO("internal memory");
1314                 dci_down_ret = sync_agent_get_devinfo(2, "FOTADownDir", download_folder);
1315                 break;
1316         case MEMORY_SD_CARD:
1317                 _DEBUG_INFO("sd card memory");
1318                 dci_down_ret = sync_agent_get_devinfo(2, "FOTA_SD_DownDir", download_folder);
1319                 break;
1320         default:
1321                 _DEBUG_INFO("ERROR NOT USE MEMORY");
1322                 break;
1323         }
1324
1325         if (dci_down_ret == SYNC_AGENT_DEV_RETURN_SUCCESS) {
1326                 _DEBUG_INFO(" download : %s", *download_folder);
1327
1328                 _EXTERN_FUNC_EXIT;
1329                 return DM_OK;
1330         }
1331         _DEBUG_INFO("end error : %d ", DM_MEMORY_ERROR);
1332         _EXTERN_FUNC_EXIT;
1333         return DM_MEMORY_ERROR;
1334 }
1335
1336 DM_ERROR get_fota_save_dir(MEMORY_TYPE type, char **save_folder)
1337 {
1338         _EXTERN_FUNC_ENTER;
1339
1340         sync_agent_dev_return_e dci_down_ret = SYNC_AGENT_DEV_RETURN_SUCCESS;
1341
1342         switch (type) {
1343         case MEMORY_INTERNAL:
1344                 dci_down_ret = sync_agent_get_devinfo(2, "FOTASaveDir", save_folder);
1345                 break;
1346         case MEMORY_SD_CARD:
1347                 dci_down_ret = sync_agent_get_devinfo(2, "FOTA_SD_SaveDir", save_folder);
1348                 break;
1349         default:
1350                 _DEBUG_INFO("ERROR NOT USE MEMORY");
1351                 break;
1352         }
1353
1354         if (dci_down_ret == SYNC_AGENT_DEV_RETURN_SUCCESS) {
1355                 _DEBUG_INFO(" save_folder : %s", *save_folder);
1356
1357                 _EXTERN_FUNC_EXIT;
1358                 return DM_OK;
1359         }
1360         _DEBUG_INFO("end error : %d ", DM_MEMORY_ERROR);
1361         _EXTERN_FUNC_EXIT;
1362         return DM_MEMORY_ERROR;
1363 }
1364
1365 void delete_fumo_contents(MEMORY_TYPE memory_type)
1366 {
1367         _EXTERN_FUNC_ENTER;
1368
1369         _DEBUG_INFO("----------------------------------------------------------firmware update fail delete files-----------------------------------------------------------");
1370         char *download_folder = NULL;
1371         char *save_folder = NULL;
1372
1373         //FOTASaveDir //FOTADownDir
1374         //dci_save_ret = sync_agent_get_devinfo(2 , "FOTADownDir" , &download_folder);
1375         get_fota_download_dir(memory_type, &download_folder);
1376         sync_agent_empty_directory_contents(download_folder);
1377         //dci_save_ret = sync_agent_get_devinfo(2 , "FOTASaveDir" , &save_folder);
1378         get_fota_save_dir(memory_type, &save_folder);
1379
1380         sync_agent_empty_directory_contents(save_folder);
1381         _DEBUG_INFO("delete save folder ");
1382
1383         str_free(&save_folder);
1384         str_free(&download_folder);
1385
1386         _EXTERN_FUNC_EXIT;
1387
1388 }
1389
1390 void first_server_bootstrap(char *server_id)
1391 {
1392         _EXTERN_FUNC_ENTER;
1393
1394         DM_ERROR ret = DM_OK;
1395
1396         if (server_id == NULL) {
1397                 _DEBUG_INFO("server id null");
1398                 return;
1399         }
1400
1401         Event_Contents *ev_data = (Event_Contents *) calloc(1, sizeof(Event_Contents) + 1);
1402         if (ev_data == NULL) {
1403                 _DEBUG_INFO("alloc fail");
1404                 _EXTERN_FUNC_EXIT;
1405                 return;
1406         }
1407         ev_data->server_id = strdup(server_id);
1408         ev_data->session_id = NULL;
1409         ev_data->type = SERVER_BOOTSTRAP_EVENT;
1410         ev_data->ui_mode = NULL;
1411
1412         _DEBUG_INFO("event type server bootstrap : %d", ev_data->type);
1413         _DEBUG_INFO("session id : %s", ev_data->session_id);
1414         _DEBUG_INFO("server id : %s", ev_data->server_id);
1415
1416         /* UI CONFIRM */
1417         SERVICE_SERVER_TYPE engine_type;
1418         engine_type = get_service_engine_type(ev_data->server_id);
1419
1420         switch (engine_type) {
1421         case SAMSUNG_FUMO_TYPE:
1422         case GCF_TYPE:
1423                 {
1424                         //when using telephony
1425                         //DM_ERROR get_telephony_state(int *now_calling);
1426                         _DEBUG_INFO("engine type : %d", engine_type);
1427                         ev_data->noti_type = NOTI_TYPE_BACKGRUOUND;
1428                         ev_data->ui_mode = strdup(OMADM_FUMO_BACKGROUND_UI_TYPE);
1429
1430                         _DEBUG_INFO("noti type : %d", ev_data->noti_type);
1431                         _DEBUG_INFO("ui mode : %s", ev_data->ui_mode);
1432
1433                         ret = dm_fumo_common_task_request(ev_data);
1434                         _DEBUG_INFO("dm fumo conmmon task : %d ", ret);
1435                         if (ret != DM_OK) {
1436                                 goto error;
1437                         }
1438                 }
1439                 break;
1440         case SAMSUNG_FMM_TYPE:
1441
1442                 _DEBUG_INFO("engine type : %d", engine_type);
1443                 ret = dm_lawmo_common_task_request(ev_data);
1444                 _DEBUG_INFO("dm lawmo conmmon task : %d ", ret);
1445                 if (ret != DM_OK) {
1446                         goto error;
1447                 }
1448                 break;
1449         default:
1450                 _DEBUG_INFO("dm non engine ", ret);
1451                 break;
1452         }
1453
1454         _EXTERN_FUNC_EXIT;
1455         return;
1456
1457  error:
1458         event_data_free((void *)ev_data);
1459         _EXTERN_FUNC_EXIT;
1460 }
1461
1462 int get_default_noti_type(char *ui_mode, NotI_Type noti_type)
1463 {
1464         _EXTERN_FUNC_ENTER;
1465
1466         retvm_if((ui_mode) == NULL, COMMON_ERR_IS_NULL, "ui_mode is NULL!!");
1467
1468         if (strcmp(OMADM_FUMO_UI_TYPE, ui_mode) == 0) {
1469                 _EXTERN_FUNC_EXIT;
1470                 return NOTI_UNKNOWN;    //none type
1471         } else if (strcmp(OMADM_FUMO_NOTI_UI_TYPE, ui_mode) == 0) {
1472                 switch (noti_type) {
1473                 case NOTI_TYPE_NOT_SPECIFIED:
1474                 case NOTI_TYPE_BACKGRUOUND:
1475                 case NOTI_TYPE_USERINTERACTION:
1476                         _EXTERN_FUNC_EXIT;
1477                         return NOTI_DOWNLOAD;   //none type
1478                         break;
1479                 case NOTI_TYPE_INFOMATIVE:
1480                         _EXTERN_FUNC_EXIT;
1481                         return NOTI_DOWNLOAD;   //connect to server
1482                         break;
1483                 case NOTI_TYPE_POLLINTERACTION:
1484                         _EXTERN_FUNC_EXIT;
1485                         return NOTI_POLL_INTERACTION;   //connect to server
1486                         break;
1487                 default:
1488                         return NOTI_UNKNOWN;    //none type
1489                         break;
1490                 }
1491         } else if (strcmp(OMADM_FUMO_BACKGROUND_UI_TYPE, ui_mode) == 0) {
1492                 _EXTERN_FUNC_EXIT;
1493                 return NOTI_UNKNOWN;    //none type
1494         }
1495
1496         _EXTERN_FUNC_EXIT;
1497         return NOTI_UNKNOWN;
1498 }
1499
1500 int wifi_only_config(char *config)
1501 {
1502         _EXTERN_FUNC_ENTER;
1503
1504         retvm_if((config) == NULL, COMMON_ERR_IS_NULL, "config is NULL!!");
1505
1506         if (config != NULL) {
1507                 if (strcmp(config, "1") == 0) {
1508                         _DEBUG_INFO("wifi on config");
1509                         _EXTERN_FUNC_EXIT;
1510                         return 1;
1511                 } else if (strcmp(config, "0") == 0) {
1512                         _DEBUG_INFO("wifi off config");
1513                         _EXTERN_FUNC_EXIT;
1514                         return 0;
1515                 } else {
1516                         _DEBUG_INFO("wifi config error");
1517                 }
1518         } else {
1519                 _DEBUG_INFO("wifi config error");
1520         }
1521
1522         _EXTERN_FUNC_EXIT;
1523
1524         return 0;
1525 }