src/sat_ui_support/sat_ui_support.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <stdlib.h>
   4 #include <errno.h>
   5 #include <glib-object.h>
   6 #include <gio/gio.h>
   7
   8 #include <aul.h>
   9 #include <bundle.h>
  10
  11 #include "TelSat.h"
  12 #include "sat_ui_support.h"
  13
  14 static gboolean _sat_ui_support_processing_setup_menu_ind(GVariant *data)
  15 {
  16         gint rv;
  17         bundle *bundle_data = 0;
  18         gchar *encoded_data = NULL, *cmd_type = NULL;
  19         TelSatSetupMenuInfo_t setup_menu;
  20
  21         gchar *title;
  22         gint command_id, item_cnt;
  23         gboolean b_present, b_helpinfo, b_updated;
  24         GVariant *items = NULL, *icon_id, *icon_list;
  25
  26         memset(&setup_menu, 0, sizeof(TelSatSetupMenuInfo_t));
  27
  28         g_variant_get(data, "(ibs@vibb@v@v)", &command_id, &b_present, &title, &items, &item_cnt,
  29                                 &b_helpinfo, &b_updated, &icon_id, &icon_list);
  30
  31         setup_menu.commandId = command_id;
  32         setup_menu.bIsMainMenuPresent = (b_present ? 1 : 0);
  33         memcpy(setup_menu.satMainTitle, title, TAPI_SAT_DEF_TITLE_LEN_MAX+1);
  34         setup_menu.satMainMenuNum = item_cnt;
  35         if(items && item_cnt > 0){
  36                 int index = 0;
  37                 GVariant *unbox;
  38                 GVariantIter *iter;
  39
  40                 gchar *item_str;
  41                 gint item_id;
  42                 unbox = g_variant_get_variant(items);
  43                 dbg("items(%p) items type_format(%s)", items, g_variant_get_type_string(unbox));
  44
  45                 g_variant_get(unbox, "a(si)", &iter);
  46                 while(g_variant_iter_loop(iter,"(si)",&item_str, &item_id)){
  47                         setup_menu.satMainMenuItem[index].itemId = item_id;
  48                         memcpy(setup_menu.satMainMenuItem[index].itemString, item_str, TAPI_SAT_DEF_ITEM_STR_LEN_MAX + 6);
  49                         index++;
  50                 }
  51                 g_variant_iter_free(iter);
  52         }
  53         setup_menu.bIsSatMainMenuHelpInfo = (b_helpinfo ? 1 : 0);
  54         setup_menu.bIsUpdatedSatMainMenu = (b_updated ? 1 : 0);
  55
  56         cmd_type = g_strdup_printf("%d", SAT_PROATV_CMD_SETUP_MENU);
  57         encoded_data = g_base64_encode((const guchar*)&setup_menu, sizeof(TelSatSetupMenuInfo_t));
  58
  59         bundle_data = bundle_create();
  60         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
  61         bundle_add(bundle_data, "cmd_type", cmd_type);
  62         bundle_add(bundle_data, "data", encoded_data);
  63
  64         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
  65         dbg("setup menu ind (%d)", rv);
  66
  67         bundle_free(bundle_data);
  68         g_free(encoded_data);
  69         g_free(cmd_type);
  70
  71         return TRUE;
  72 }
  73
  74 static gboolean _sat_ui_support_processing_display_text_ind(GVariant *data)
  75 {
  76         gint rv;
  77         bundle *bundle_data = 0;
  78         gchar *encoded_data = NULL, *cmd_type = NULL;
  79         TelSatDisplayTextInd_t display_text;
  80
  81         gchar* text;
  82         gint command_id, text_len, duration;
  83         gboolean high_priority, user_rsp_required, immediately_rsp;
  84         GVariant *icon_id = NULL;
  85
  86         memset(&display_text, 0, sizeof(TelSatDisplayTextInd_t));
  87
  88         g_variant_get(data, "(isiibbb@v)", &command_id, &text, &text_len, &duration,
  89                 &high_priority, &user_rsp_required, &immediately_rsp, &icon_id);
  90
  91         display_text.commandId = command_id;
  92         memcpy(display_text.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
  93         display_text.text.stringLen = text_len;
  94         display_text.duration = duration;
  95         display_text.bIsPriorityHigh = (high_priority ? 1 : 0);
  96         display_text.bIsUserRespRequired = (user_rsp_required ? 1 : 0);
  97         dbg("duration(%d) user_rsp(%d)", duration, user_rsp_required);
  98
  99         cmd_type = g_strdup_printf("%d", SAT_PROATV_CMD_DISPLAY_TEXT);
 100         encoded_data = g_base64_encode((const guchar*)&display_text, sizeof(TelSatDisplayTextInd_t));
 101
 102         bundle_data = bundle_create();
 103         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
 104         bundle_add(bundle_data, "cmd_type", cmd_type);
 105         bundle_add(bundle_data, "data", encoded_data);
 106
 107         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
 108         dbg("display text ind (%d)", rv);
 109
 110         bundle_free(bundle_data);
 111         g_free(encoded_data);
 112         g_free(cmd_type);
 113
 114         return TRUE;
 115 }
 116
 117 static gboolean _sat_ui_support_processing_select_item_ind(GVariant *data)
 118 {
 119         gint rv;
 120         bundle *bundle_data = 0;
 121         gchar *encoded_data = NULL, *cmd_type = NULL;
 122         TelSatSelectItemInd_t select_item;
 123
 124         gboolean help_info ;
 125         gchar *selected_text;
 126         gint command_id, default_item_id, menu_cnt, text_len =0;
 127         GVariant *menu_items, *icon_id, *icon_list;
 128
 129         memset(&select_item, 0, sizeof(TelSatSelectItemInd_t));
 130
 131         g_variant_get(data, "(ibsiii@v@v@v)", &command_id, &help_info, &selected_text,
 132                 &text_len, &default_item_id, &menu_cnt, &menu_items, &icon_id, &icon_list);
 133
 134         select_item.commandId = command_id;
 135         select_item.bIsHelpInfoAvailable = (help_info ? 1 : 0);
 136         memcpy(select_item.text.string, selected_text, TAPI_SAT_DEF_TITLE_LEN_MAX+1);
 137         select_item.text.stringLen = text_len;
 138         select_item.defaultItemIndex = default_item_id;
 139         select_item.menuItemCount = menu_cnt;
 140         if(menu_items && menu_cnt > 0){
 141                 int index = 0;
 142                 GVariant *unbox;
 143                 GVariantIter *iter;
 144
 145                 gchar *item_str;
 146                 gint item_id, item_len;
 147                 unbox = g_variant_get_variant(menu_items);
 148                 dbg("items(%p) items type_format(%s)", menu_items, g_variant_get_type_string(unbox));
 149
 150                 g_variant_get(unbox, "a(iis)", &iter);
 151                 while(g_variant_iter_loop(iter,"(iis)",&item_id, &item_len, &item_str)){
 152                         select_item.menuItem[index].itemId = item_id;
 153                         select_item.menuItem[index].textLen = item_len;
 154                         memcpy(select_item.menuItem[index].text, item_str, TAPI_SAT_ITEM_TEXT_LEN_MAX + 1);
 155                         index++;
 156                 }
 157                 g_variant_iter_free(iter);
 158         }
 159
 160         cmd_type = g_strdup_printf("%d", SAT_PROATV_CMD_SELECT_ITEM);
 161         encoded_data = g_base64_encode((const guchar*)&select_item, sizeof(TelSatSelectItemInd_t));
 162
 163         bundle_data = bundle_create();
 164         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
 165         bundle_add(bundle_data, "cmd_type", cmd_type);
 166         bundle_add(bundle_data, "data", encoded_data);
 167
 168         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
 169         dbg("select item aul (%d)", rv);
 170
 171         bundle_free(bundle_data);
 172         g_free(encoded_data);
 173         g_free(cmd_type);
 174
 175         return TRUE;
 176 }
 177
 178 static gboolean _sat_ui_support_processing_get_inkey_ind(GVariant *data)
 179 {
 180         gint rv;
 181         bundle *bundle_data = 0;
 182         gchar *encoded_data = NULL, *cmd_type = NULL;
 183         TelSatGetInkeyInd_t get_inkey;
 184
 185         gint command_id, key_type, input_character_mode;
 186         gint text_len, duration;
 187         gboolean b_numeric, b_help_info;
 188         gchar *text;
 189         GVariant *icon_id;
 190
 191         memset(&get_inkey, 0, sizeof(TelSatGetInkeyInd_t));
 192
 193         g_variant_get(data, "(iiibbsii@v)", &command_id, &key_type, &input_character_mode,
 194                 &b_numeric,&b_help_info, &text, &text_len, &duration, &icon_id);
 195
 196         get_inkey.commandId = command_id;
 197         get_inkey.keyType = key_type;
 198         get_inkey.inputCharMode = input_character_mode;
 199         get_inkey.bIsNumeric = (b_numeric ? 1 : 0);
 200         get_inkey.bIsHelpInfoAvailable = (b_help_info ? 1 : 0);
 201         memcpy(get_inkey.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 202         get_inkey.text.stringLen = text_len;
 203         get_inkey.duration = duration;
 204
 205         cmd_type = g_strdup_printf("%d", SAT_PROATV_CMD_GET_INKEY);
 206         encoded_data = g_base64_encode((const guchar*)&get_inkey, sizeof(TelSatGetInkeyInd_t));
 207
 208         bundle_data = bundle_create();
 209         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
 210         bundle_add(bundle_data, "cmd_type", cmd_type);
 211         bundle_add(bundle_data, "data", encoded_data);
 212
 213         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
 214         dbg("get inkey aul (%d)", rv);
 215
 216         bundle_free(bundle_data);
 217         g_free(encoded_data);
 218         g_free(cmd_type);
 219
 220         return TRUE;
 221 }
 222
 223 static gboolean _sat_ui_support_processing_get_input_ind(GVariant *data)
 224 {
 225         gint rv;
 226         bundle *bundle_data = 0;
 227         gchar *encoded_data = NULL, *cmd_type = NULL;
 228         TelSatGetInputInd_t get_input;
 229
 230         gint command_id, input_character_mode;
 231         gint text_len, def_text_len, rsp_len_min, rsp_len_max;
 232         gboolean b_numeric, b_help_info, b_echo_input;
 233         gchar *text, *def_text;
 234         GVariant *icon_id;
 235
 236         memset(&get_input, 0, sizeof(TelSatGetInputInd_t));
 237
 238         g_variant_get(data, "(iibbbsiiisi@v)", &command_id, &input_character_mode, &b_numeric, &b_help_info, &b_echo_input,
 239                 &text, &text_len, &rsp_len_max, &rsp_len_min, &def_text, &def_text_len, &icon_id);
 240
 241         get_input.commandId = command_id;
 242         get_input.inputCharMode = input_character_mode;
 243         get_input.bIsNumeric = (b_numeric ? 1 : 0);
 244         get_input.bIsHelpInfoAvailable = (b_help_info ? 1 : 0);
 245         get_input.bIsEchoInput = (b_echo_input ? 1 : 0);
 246         memcpy(get_input.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 247         get_input.text.stringLen = text_len;
 248         get_input.respLen.max = rsp_len_max;
 249         get_input.respLen.min = rsp_len_min;
 250         memcpy(get_input.defaultText.string, def_text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 251         get_input.defaultText.stringLen = def_text_len;
 252
 253         cmd_type = g_strdup_printf("%d", SAT_PROATV_CMD_GET_INPUT);
 254         encoded_data = g_base64_encode((const guchar*)&get_input, sizeof(TelSatGetInputInd_t));
 255
 256         bundle_data = bundle_create();
 257         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
 258         bundle_add(bundle_data, "cmd_type", cmd_type);
 259         bundle_add(bundle_data, "data", encoded_data);
 260
 261         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
 262         dbg("get input aul (%d)", rv);
 263
 264         bundle_free(bundle_data);
 265         g_free(encoded_data);
 266         g_free(cmd_type);
 267
 268         return TRUE;
 269 }
 270
 271 static gboolean _sat_ui_support_processing_ui_info_ind(GVariant *data)
 272 {
 273         gint rv;
 274         gint cmd = 0;
 275         bundle *bundle_data = 0;
 276         gchar *encoded_data = NULL, *cmd_type = NULL;
 277         TelSatSendUiInfo_t ui_info;
 278
 279         gint command_id, text_len;
 280         gboolean user_confirm;
 281         gchar *text;
 282
 283         memset(&ui_info, 0, sizeof(TelSatSendUiInfo_t));
 284
 285         g_variant_get(data, "(isib)", &command_id, &text, &text_len, &user_confirm);
 286         dbg("command_id(%d) data(%s) len(%d) user_confirm(%d)", command_id, text, text_len, user_confirm);
 287
 288         ui_info.commandId = command_id;
 289         memcpy(ui_info.text.string, text, TAPI_SAT_DEF_TEXT_STRING_LEN_MAX+1);
 290         ui_info.text.stringLen = text_len;
 291         ui_info.user_confirm = (user_confirm ? 1 : 0);
 292
 293         cmd_type = g_strdup_printf("%d", cmd);
 294         encoded_data = g_base64_encode((const guchar*)&ui_info, sizeof(TelSatSendUiInfo_t));
 295
 296
 297         bundle_data = bundle_create();
 298         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
 299         bundle_add(bundle_data, "cmd_type", cmd_type);
 300         bundle_add(bundle_data, "data", encoded_data);
 301
 302         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
 303         dbg("ui info aul (%d)", rv);
 304
 305         bundle_free(bundle_data);
 306         g_free(encoded_data);
 307         g_free(cmd_type);
 308
 309         return TRUE;
 310 }
 311
 312 gboolean sat_ui_support_terminate_sat_ui()
 313 {
 314         gint rv;
 315         bundle *bundle_data = 0;
 316         gchar *cmd_type = NULL;
 317
 318         cmd_type = g_strdup_printf("%d", SAT_PROATV_CMD_TYPE_END_PROACTIVE_SESSION);
 319
 320         bundle_data = bundle_create();
 321         bundle_add(bundle_data, "KEY_EXEC_TYPE", "1");
 322         bundle_add(bundle_data, "cmd_type", cmd_type);
 323
 324         rv = aul_launch_app("com.samsung.sat-ui", bundle_data);
 325         dbg("session end aul (%d)", rv);
 326
 327         bundle_free(bundle_data);
 328         g_free(cmd_type);
 329
 330         return TRUE;
 331 }
 332
 333 gboolean sat_ui_support_launch_sat_ui(enum tel_sat_proactive_cmd_type cmd_type, GVariant *data)
 334 {
 335         gboolean result = FALSE;
 336         sat_ui_support_create_desktop_file("temp");
 337
 338         switch(cmd_type){
 339                 case SAT_PROATV_CMD_NONE:
 340                         result = _sat_ui_support_processing_ui_info_ind(data);
 341                 break;
 342                 case SAT_PROATV_CMD_SETUP_MENU:
 343                         result = _sat_ui_support_processing_setup_menu_ind(data);
 344                 break;
 345                 case SAT_PROATV_CMD_DISPLAY_TEXT:
 346                         result = _sat_ui_support_processing_display_text_ind(data);
 347                 break;
 348                 case SAT_PROATV_CMD_SELECT_ITEM:
 349                         result = _sat_ui_support_processing_select_item_ind(data);
 350                 break;
 351                 case SAT_PROATV_CMD_GET_INKEY:
 352                         result = _sat_ui_support_processing_get_inkey_ind(data);
 353                 break;
 354                 case SAT_PROATV_CMD_GET_INPUT:
 355                         result = _sat_ui_support_processing_get_input_ind(data);
 356                 break;
 357                 case SAT_PROATV_CMD_SETUP_EVENT_LIST:
 358                 break;
 359                 default:
 360                         dbg("does not need to launch sat-ui");
 361                 break;
 362         }
 363
 364         return result;
 365 }
 366
 367 gboolean sat_ui_support_launch_call_application(enum tel_sat_proactive_cmd_type cmd_type, GVariant *data)
 368 {
 369         gint rv;
 370         char buffer[300];
 371         bundle *bundle_data = 0;
 372
 373         dbg("launch call application by aul");
 374
 375         switch(cmd_type){
 376                 case SAT_PROATV_CMD_SETUP_CALL:{
 377                         gint command_id, call_type, text_len, duration;
 378                         gchar *text, *call_number;
 379                         GVariant *icon_id;
 380
 381                         dbg("setup call type_format(%s)", g_variant_get_type_string(data));
 382                         g_variant_get(data, "(isi@visi)", &command_id, &text, &text_len, &icon_id, &call_type, &call_number, &duration);
 383
 384                         bundle_add(bundle_data, "launch-type","SATSETUPCALL");
 385
 386                         snprintf(buffer, 300, "%d",command_id);
 387                         bundle_add(bundle_data, "cmd_id",buffer);
 388                         dbg("cmd_id(%s)",buffer);
 389
 390                         snprintf(buffer, 300, "%d",call_type);
 391                         bundle_add(bundle_data, "cmd_qual", buffer);
 392                         dbg("cmd_qual(%s)",buffer);
 393
 394                         snprintf(buffer, 300, "%s", text);
 395                         bundle_add(bundle_data, "disp_text", buffer);
 396                         dbg("disp_text(%s)",buffer);
 397
 398                         snprintf(buffer, 300, "%s", call_number);
 399                         bundle_add(bundle_data, "call_num", buffer);
 400                         dbg("call_num(%s)",buffer);
 401
 402                         snprintf(buffer, 300, "%d", duration);
 403                         bundle_add(bundle_data, "dur", buffer);
 404                         dbg("dur(%s)",buffer);
 405                 } break;
 406
 407                 default:
 408                         return FALSE;
 409                 break;
 410         }
 411
 412         rv = aul_launch_app("com.samsung.call",bundle_data);
 413         bundle_free(bundle_data);
 414
 415         return TRUE;
 416 }
 417
 418 gboolean sat_ui_support_launch_browser_application(enum tel_sat_proactive_cmd_type cmd_type, GVariant *data)
 419 {
 420         gint rv;
 421         char buffer[300];
 422         bundle *bundle_data = 0;
 423
 424         dbg("launch browser application by aul");
 425
 426         /*TODO : need to make a sync with app engineer*/
 427
 428         switch(cmd_type){
 429                 case SAT_PROATV_CMD_LAUNCH_BROWSER:{
 430                         gint command_id, call_type, text_len, duration;
 431                         gchar *text, *call_number;
 432                         GVariant *icon_id;
 433
 434                         dbg("setup call type_format(%s)", g_variant_get_type_string(data));
 435                         g_variant_get(data, "(isi@visi)", &command_id, &text, &text_len, &icon_id, &call_type, &call_number, &duration);
 436
 437                         bundle_add(bundle_data, "launch-type","SATSETUPCALL");
 438
 439                         snprintf(buffer, 300, "%d",command_id);
 440                         bundle_add(bundle_data, "cmd_id",buffer);
 441                         dbg("cmd_id(%s)",buffer);
 442
 443                         snprintf(buffer, 300, "%d",call_type);
 444                         bundle_add(bundle_data, "cmd_qual", buffer);
 445                         dbg("cmd_qual(%s)",buffer);
 446
 447                         snprintf(buffer, 300, "%s", text);
 448                         bundle_add(bundle_data, "disp_text", buffer);
 449                         dbg("disp_text(%s)",buffer);
 450
 451                         snprintf(buffer, 300, "%s", call_number);
 452                         bundle_add(bundle_data, "call_num", buffer);
 453                         dbg("call_num(%s)",buffer);
 454
 455                         snprintf(buffer, 300, "%d", duration);
 456                         bundle_add(bundle_data, "dur", buffer);
 457                         dbg("dur(%s)",buffer);
 458                 } break;
 459
 460                 default:
 461                         return FALSE;
 462                 break;
 463         }
 464
 465         rv = aul_launch_app("com.samsung.call",bundle_data);
 466         bundle_free(bundle_data);
 467
 468         return TRUE;
 469 }
 470
 471 gboolean sat_ui_support_launch_setting_application(enum tel_sat_proactive_cmd_type cmd_type, GVariant *data)
 472 {
 473         gint rv;
 474         char buffer[300];
 475         bundle *bundle_data = 0;
 476
 477         dbg("launch setting application by aul");
 478
 479         /*TODO : need to make a sync with app engineer*/
 480
 481         switch(cmd_type){
 482                 case SAT_PROATV_CMD_LANGUAGE_NOTIFICATION:{
 483                         gint command_id, call_type, text_len, duration;
 484                         gchar *text, *call_number;
 485                         GVariant *icon_id;
 486
 487                         dbg("setup call type_format(%s)", g_variant_get_type_string(data));
 488                         g_variant_get(data, "(isi@visi)", &command_id, &text, &text_len, &icon_id, &call_type, &call_number, &duration);
 489
 490                         bundle_add(bundle_data, "launch-type","SATSETUPCALL");
 491
 492                         snprintf(buffer, 300, "%d",command_id);
 493                         bundle_add(bundle_data, "cmd_id",buffer);
 494                         dbg("cmd_id(%s)",buffer);
 495
 496                         snprintf(buffer, 300, "%d",call_type);
 497                         bundle_add(bundle_data, "cmd_qual", buffer);
 498                         dbg("cmd_qual(%s)",buffer);
 499
 500                         snprintf(buffer, 300, "%s", text);
 501                         bundle_add(bundle_data, "disp_text", buffer);
 502                         dbg("disp_text(%s)",buffer);
 503
 504                         snprintf(buffer, 300, "%s", call_number);
 505                         bundle_add(bundle_data, "call_num", buffer);
 506                         dbg("call_num(%s)",buffer);
 507
 508                         snprintf(buffer, 300, "%d", duration);
 509                         bundle_add(bundle_data, "dur", buffer);
 510                         dbg("dur(%s)",buffer);
 511                 } break;
 512
 513                 case SAT_PROATV_CMD_PROVIDE_LOCAL_INFO:
 514                         break;
 515
 516                 default:
 517                         return FALSE;
 518                 break;
 519         }
 520
 521         rv = aul_launch_app("com.samsung.call",bundle_data);
 522         bundle_free(bundle_data);
 523
 524         return TRUE;
 525 }
 526
 527 gboolean sat_ui_support_create_desktop_file(const gchar *title)
 528 {
 529         int rv = 0;
 530         FILE *b_check, *f_out;
 531
 532         if(!title){
 533                 dbg("title does not exist");
 534                 return FALSE;
 535         }
 536
 537         b_check = fopen("/opt/share/applications/com.samsung.sat-ui.desktop", "r");
 538         if(b_check && !(g_strcmp0(title,"temp")) ){
 539                 dbg("desktop file aleady exist");
 540                 fclose(b_check);
 541                 return TRUE;
 542         }
 543
 544         if(b_check)
 545                 fclose(b_check);
 546
 547         f_out = fopen("/tmp/com.samsung.sat-ui.desktop", "w");
 548         if(!f_out){
 549                 dbg("fail to create sat-ui desktop file");
 550                 return FALSE;
 551         }
 552
 553         fprintf(f_out, "Package=com.samsung.sat-ui\n");
 554         fprintf(f_out, "Name=%s\n",title);
 555         fprintf(f_out, "Type=Application\n");
 556         fprintf(f_out, "Version=0.2.2\n");
 557         fprintf(f_out, "Exec=/usr/apps/com.samsung.sat-ui/bin/sat-ui KEY_EXEC_TYPE 0\n");
 558         fprintf(f_out, "Icon=com.samsung.sat-ui.png\n");
 559         fprintf(f_out, "X-Tizen-TaskManage=True\n");
 560         fprintf(f_out, "X-Tizen-Multiple=False\n");
 561         fprintf(f_out, "X-Tizen-Removable=False\n");
 562         fprintf(f_out, "Comment=SIM Application UI\n");
 563         fclose(f_out);
 564
 565         rv = system("/bin/cp /tmp/com.samsung.sat-ui.desktop /opt/share/applications/");
 566         dbg("the result to create desktop file (%d)", rv);
 567         rv = system("/bin/rm /tmp/com.samsung.sat-ui.desktop");
 568
 569         if(rv == -1 || rv == 127)
 570          return FALSE;
 571
 572         return TRUE;
 573 }
 574
 575 gboolean sat_ui_support_remove_desktop_file(void)
 576 {
 577         int rv = 0;
 578         FILE *b_check;
 579
 580         b_check = fopen("/opt/share/applications/com.samsung.sat-ui.desktop", "r");
 581         if(!b_check){
 582                 dbg("desktop file does not exist");
 583                 return TRUE;
 584         }
 585
 586         rv = system("/bin/rm /opt/share/applications/com.samsung.sat-ui.desktop");
 587         dbg("the result to remove desktop file (%d)", rv);
 588
 589         return TRUE;
 590 }