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