ug-nfc-setting-efl/src/ug-nfc-setting-main.c

   1 /*
   2   * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3   *
   4   * Licensed under the Flora License, Version 1.0 (the "License");
   5   * you may not use this file except in compliance with the License.
   6   * You may obtain a copy of the License at
   7
   8   *     http://floralicense.org/license/
   9   *
  10   * Unless required by applicable law or agreed to in writing, software
  11   * distributed under the License is distributed on an "AS IS" BASIS,
  12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13   * See the License for the specific language governing permissions and
  14   * limitations under the License.
  15   */
  16
  17 #include <efl_assist.h>
  18 #include <notification.h>
  19
  20 #include "ug-nfc-setting-main.h"
  21 #include "ug-nfc-setting-popup.h"
  22 #include "ug-nfc-setting-db.h"
  23
  24 #ifndef UG_MODULE_API
  25 #define UG_MODULE_API __attribute__ ((visibility("default")))
  26 #endif
  27
  28 #define SETTING_IMG_NFC \
  29         "/usr/apps/com.samsung.setting/res/icons/settings_nfc.png"
  30
  31 static Elm_Genlist_Item_Class itc_sep;
  32 static Elm_Genlist_Item_Class itc_sep_help;
  33 static Elm_Genlist_Item_Class itc_helptext;
  34 static Elm_Genlist_Item_Class itc_2text1con;
  35 static Elm_Genlist_Item_Class itc_2text;
  36 static Elm_Genlist_Item_Class itc_onoff;
  37
  38 static Elm_Object_Item *pd_item;
  39 static Elm_Object_Item *ss_item;
  40
  41 static bool pending_status = false;
  42 static Eina_Bool rotate_flag = EINA_FALSE;
  43
  44 static void __nfc_activation_completed_cb(nfc_error_e error, void *user_data);
  45 static void __nfc_activation_changed_cb(bool activated , void *user_data);
  46
  47 static void __show_app_error_popup_response_cb(void *data,
  48         Evas_Object *obj, void *event_info)
  49 {
  50         ugdata_t *ug_data = (ugdata_t *)data;
  51         int result = (int)event_info;
  52
  53         if (!ug_data) {
  54                 LOGE("invalid parameter");
  55                 return;
  56         }
  57
  58         switch (result) {
  59         case UG_NFC_POPUP_RESP_CANCEL :
  60                 /* destroy UG */
  61                 LOGD("ug_destroy_me >>>>", __FUNCTION__, __LINE__);
  62                 ug_destroy_me(ug_data->nfc_setting_ug);
  63                 break;
  64
  65         default :
  66                 break;
  67         }
  68 }
  69
  70 static void __show_app_error_popup(void *data)
  71 {
  72         ugdata_t *ug_data = (ugdata_t *)data;
  73         char popup_str[POPUP_TEXT_SIZE] = { 0, };
  74
  75         if (ug_data == NULL)
  76                 return;
  77
  78         memcpy(popup_str, IDS_NFC_SERVICE_IS_NOT_SUPPORTED,
  79                 strlen(IDS_NFC_SERVICE_IS_NOT_SUPPORTED));
  80
  81         /* To do: popup_title */
  82         ug_nfc_setting_create_popup(ug_data,
  83                 ug_data->base_layout,
  84                 NULL,
  85                 popup_str,
  86                 IDS_CLOSE, UG_NFC_POPUP_RESP_CANCEL,
  87                 NULL, 0,
  88                 NULL, 0,
  89                 false, false,
  90                 __show_app_error_popup_response_cb);
  91 }
  92
  93 static void __nfc_activation_failed_popup_res_cb(void *data,
  94         Evas_Object *obj, void *event_info)
  95 {
  96
  97 }
  98
  99 static void __nfc_activation_failed_popup_lang_changed_cb(void *data,
 100         Evas_Object *obj, void *event_info)
 101 {
 102         Evas_Object *button;
 103
 104         if (obj == NULL)
 105                 return;
 106
 107         elm_object_part_text_set(obj, "title,text", IDS_FAILED_TO_TURN_ON_NFC);
 108         elm_object_text_set(obj, IDS_AN_ERROR_OCCURRED_WHILE_TURNING_ON_NFC_TRY_AGAIN);
 109
 110         button = elm_object_part_content_get(obj, "button1");
 111         elm_object_text_set(button, IDS_OK);
 112 }
 113
 114 static void __nfc_activation_failed_popup(void *data)
 115 {
 116         ugdata_t *ug_data = (ugdata_t *)data;
 117         Evas_Object *popup;
 118
 119         g_assert(ug_data != NULL);
 120
 121         popup = ug_nfc_setting_create_popup(ug_data,
 122                 ug_data->base_layout,
 123                 IDS_FAILED_TO_TURN_ON_NFC,
 124                 IDS_AN_ERROR_OCCURRED_WHILE_TURNING_ON_NFC_TRY_AGAIN,
 125                 IDS_OK, UG_NFC_POPUP_RESP_OK,
 126                 NULL, 0,
 127                 NULL, 0,
 128                 false, false, __nfc_activation_failed_popup_res_cb);
 129
 130         evas_object_smart_callback_add(popup, "language,changed",
 131                 __nfc_activation_failed_popup_lang_changed_cb, NULL);
 132 }
 133
 134 static char * __get_text_turned_on_popup(void *data)
 135 {
 136         ugdata_t *ug_data = (ugdata_t *)data;
 137         char *text = NULL;
 138         int boolval = 0;
 139
 140         if (!ug_data) {
 141                 LOGE("invalid parameter");
 142                 return NULL;
 143         }
 144
 145         if (ug_data->menu_type == MENU_NFC) {
 146                 if (!vconf_get_bool(VCONFKEY_NFC_STATE, &boolval)) {
 147                         if (boolval)
 148                                 text = strdup(IDS_NFC_TURNED_ON);
 149                 }
 150         }
 151
 152         return text;
 153 }
 154
 155 static bool __get_pending_status(void)
 156 {
 157         return pending_status;
 158 }
 159
 160 static void __set_pending_status(bool status)
 161 {
 162         pending_status = status;
 163 }
 164
 165 static bool __reply_to_launch_request(app_control_h service, app_control_result_e result)
 166 {
 167         app_control_h reply;
 168         char *operation = NULL;
 169         bool ret = false;
 170         LOGD("BEGIN >>>>");
 171
 172         if(service != NULL)
 173         {
 174                 app_control_create(&reply);
 175                 app_control_get_operation(service, &operation);
 176
 177                 if (operation != NULL)
 178                 {
 179                         LOGD("reply to launch request : operation %s", operation);
 180                         app_control_reply_to_launch_request(reply, service, result);
 181                         ret = true;
 182                 }
 183
 184                 app_control_destroy(reply);
 185         }
 186
 187         LOGD("END >>>>");
 188
 189         return ret;
 190 }
 191
 192 static Eina_Bool __back_clicked_cb(void *data, Elm_Object_Item *it)
 193 {
 194         ugdata_t *ug_data = (ugdata_t *)data;
 195
 196         LOGD("BEGIN >>>>");
 197
 198         if(!ug_data) {
 199                 LOGE("data is null");
 200                 return EINA_FALSE;
 201         }
 202
 203         __reply_to_launch_request(ug_data->service, APP_CONTROL_RESULT_FAILED);
 204
 205         _ug_nfc_setting_db_close();
 206         ug_destroy_me(ug_data->nfc_setting_ug);
 207
 208         LOGD("END >>>>");
 209
 210         return EINA_FALSE;
 211 }
 212
 213 static void __update_title_onoff_obj(void *data)
 214 {
 215         ugdata_t *ug_data = (ugdata_t *)data;
 216         int boolval;
 217
 218         if (!ug_data)
 219                 return;
 220
 221         if (__get_pending_status()) {
 222                 elm_object_disabled_set(ug_data->ns_on_off, EINA_TRUE);
 223                 return;
 224         }
 225
 226         elm_object_disabled_set(ug_data->ns_on_off, EINA_FALSE);
 227         if (ug_data->menu_type == MENU_NFC) {
 228                 if (!vconf_get_bool(VCONFKEY_NFC_STATE, &boolval) &&
 229                         boolval) {
 230                         elm_check_state_set(ug_data->ns_on_off, EINA_TRUE);
 231                 } else {
 232                         elm_check_state_set(ug_data->ns_on_off, EINA_FALSE);
 233                 }
 234         }
 235 }
 236
 237 static void __change_nfc_onoff_setting(void *data)
 238 {
 239         ugdata_t *ug_data = (ugdata_t *)data;
 240         int result, boolval;
 241
 242         if (!ug_data)
 243                 return;
 244
 245         if (!vconf_get_bool(VCONFKEY_NFC_STATE, &boolval)) {
 246                 LOGD("vconf_get_bool status [%d]", boolval);
 247
 248                 if (NFC_ERROR_NONE == nfc_manager_initialize()) {
 249
 250                         /* Register activation changed callback */
 251                         nfc_manager_set_activation_changed_cb(
 252                                 __nfc_activation_changed_cb, ug_data);
 253
 254                         result = nfc_manager_set_activation(!boolval,
 255                                 __nfc_activation_completed_cb, ug_data);
 256                         if (result != NFC_ERROR_NONE) {
 257                                 LOGE("nfc_manager_set_activation failed");
 258                                 return;
 259                         }
 260
 261                         __set_pending_status(true);
 262                 } else {
 263                         LOGE("nfc_manager_initialize FAIL!!!!");
 264                 }
 265
 266
 267         } else {
 268                 LOGE("vconf_get_bool failed");
 269         }
 270
 271         __update_title_onoff_obj(ug_data);
 272 }
 273
 274 void __change_predefined_item_onoff_setting(void *data)
 275 {
 276         ugdata_t *ug_data = (ugdata_t *)data;
 277         int boolval;
 278
 279         if (!ug_data)
 280                 return;
 281
 282         if (!vconf_get_bool(VCONFKEY_NFC_PREDEFINED_ITEM_STATE, &boolval)) {
 283                 LOGD("vconf_get_bool status [%d]", boolval);
 284
 285                 if (boolval) {
 286                         if (vconf_set_bool(
 287                                 VCONFKEY_NFC_PREDEFINED_ITEM_STATE,
 288                                 VCONFKEY_NFC_PREDEFINED_ITEM_OFF))
 289                                 LOGE("vconf_set_bool failed");
 290                 } else {
 291                         if (vconf_set_bool(
 292                                 VCONFKEY_NFC_PREDEFINED_ITEM_STATE,
 293                                 VCONFKEY_NFC_PREDEFINED_ITEM_ON))
 294                                 LOGE("vconf_set_bool failed");
 295                 }
 296         } else {
 297                 LOGE("vconf_get_bool failed");
 298         }
 299
 300
 301 }
 302
 303 static void __nfc_activation_completed_cb(nfc_error_e error,
 304         void *user_data)
 305 {
 306         ugdata_t *ug_data = (ugdata_t *)user_data;
 307
 308         g_assert(ug_data != NULL);
 309
 310         if (error != NFC_ERROR_NONE) {
 311                 LOGE("__nfc_activation_completed_cb failed");
 312
 313                 /* show failure popup */
 314                 __nfc_activation_failed_popup(ug_data);
 315         }
 316 }
 317
 318 static void __nfc_activation_changed_cb(bool activated , void *user_data)
 319 {
 320         ugdata_t *ug_data = (ugdata_t *)user_data;
 321
 322         LOGD("nfc mode %s ", activated ? "ON" : "OFF");
 323
 324         nfc_manager_unset_activation_changed_cb();
 325
 326         /* nfc setting ui updated */
 327         __set_pending_status(false);
 328
 329         __update_title_onoff_obj(ug_data);
 330
 331         if(__reply_to_launch_request(ug_data->service, APP_CONTROL_RESULT_SUCCEEDED) == true)
 332                 ug_destroy_me(ug_data->nfc_setting_ug);
 333 }
 334
 335 static void __title_ns_on_off_clicked_cb(void *data, Evas_Object *obj,
 336         void *event_info)
 337 {
 338         gl_item_data *item_data = (gl_item_data *)data;
 339         ugdata_t *ug_data = item_data->data;
 340
 341         if (ug_data == NULL) {
 342                 LOGE("data is null");
 343                 return;
 344         }
 345
 346         if (__get_pending_status())
 347                 return;
 348
 349         if (ug_data->menu_type == MENU_NFC) {
 350                 __change_nfc_onoff_setting(ug_data);
 351         }
 352 }
 353
 354 static void __ug_layout_cb(ui_gadget_h ug, enum ug_mode mode, void *priv)
 355 {
 356         Evas_Object *base;
 357
 358         if (ug == NULL) {
 359                 LOGE("data is null");
 360                 return;
 361         }
 362
 363         base = ug_get_layout(ug);
 364         if (!base) {
 365                 LOGE("ug_get_layout() return NULL");
 366                 ug_destroy(ug);
 367                 return;
 368         }
 369
 370         evas_object_size_hint_weight_set(base, EVAS_HINT_EXPAND,
 371                 EVAS_HINT_EXPAND);
 372         evas_object_show(base);
 373 }
 374
 375 static void __ug_destroy_cb(ui_gadget_h ug, void *data)
 376 {
 377         if (ug == NULL) {
 378                 LOGE("data is null");
 379                 return;
 380         }
 381         ug_destroy(ug);
 382
 383         ea_theme_style_set(EA_THEME_STYLE_DARK);
 384 }
 385
 386 static void __popup_del_cb(void *data, Evas *e, Evas_Object *obj,
 387         void *event_info)
 388 {
 389         evas_object_event_callback_del(obj, EVAS_CALLBACK_DEL, __popup_del_cb);
 390 }
 391
 392 static void __popup_back_cb(void *data, Evas_Object *obj,
 393         void *event_info)
 394 {
 395         evas_object_del(obj);
 396 }
 397
 398 static void __popup_check_changed_cb(void *data, Evas_Object *obj,
 399         void *event_info)
 400 {
 401         Evas_Object *check = obj;
 402         Eina_Bool boolval;
 403
 404         boolval = elm_check_state_get(check);
 405
 406         if(vconf_set_bool(SECURE_STORAGE_FIRST_TIME_POPUP_SHOW_KEY,
 407                 (const int)!boolval))
 408                 LOGE("vconf_set_bool failed");
 409 }
 410
 411 static void __ok_btn_clicked_cb(void *data, Evas_Object *obj,
 412         void *event_info)
 413 {
 414         ugdata_t *ug_data = (ugdata_t *)data;
 415
 416         if(!ug_data)
 417                 return;
 418
 419         if (ug_data->popup)
 420                 evas_object_del(ug_data->popup);
 421
 422         _ug_nfc_secure_storage_create(ug_data);
 423 }
 424
 425 static void __create_secure_storage_comfirm_popup(void *data)
 426 {
 427         ugdata_t *ug_data = (ugdata_t *)data;
 428         Evas_Object *layout, *popup, *check, *label, *btn1;
 429
 430
 431         if (!ug_data)
 432                 return;
 433
 434         ug_data->popup = popup = elm_popup_add(ug_data->base_layout);
 435         evas_object_event_callback_add(popup, EVAS_CALLBACK_DEL,
 436                 __popup_del_cb, NULL);
 437         ea_object_event_callback_add(popup, EA_CALLBACK_BACK,
 438                 __popup_back_cb, NULL);
 439
 440         elm_object_part_text_set(popup, "title,text",
 441                 IDS_NFC_SECURE_STORAGE_BODY);
 442
 443         label = elm_label_add(popup);
 444         elm_label_line_wrap_set(label, ELM_WRAP_MIXED);
 445         elm_object_text_set(label, IDS_NFC_SECURE_STORAGE_TIPS);
 446         evas_object_size_hint_weight_set(label, EVAS_HINT_EXPAND, 0.0);
 447         evas_object_size_hint_align_set(label, EVAS_HINT_FILL, EVAS_HINT_FILL);
 448         evas_object_show(label);
 449
 450         layout = elm_layout_add(ug_data->base_layout);
 451         if(!layout) {
 452                 LOGE("layout is NULL");
 453                 return;
 454         }
 455
 456         elm_layout_file_set(layout, EDJ_FILE, "popup_with_check");
 457         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND,
 458                 EVAS_HINT_EXPAND);
 459
 460         check = elm_check_add(popup);
 461 //      elm_object_style_set(check, "multiline");
 462         elm_object_text_set(check, IDS_NFC_DO_NOT_SHOW_AGAIN);
 463         elm_check_state_set(check, EINA_FALSE);
 464         evas_object_size_hint_align_set(check, EVAS_HINT_FILL, EVAS_HINT_FILL);
 465         evas_object_size_hint_weight_set(check, EVAS_HINT_EXPAND,
 466                 EVAS_HINT_EXPAND);
 467         evas_object_smart_callback_add(check, "changed",
 468                 __popup_check_changed_cb, NULL);
 469         evas_object_show(check);
 470
 471         elm_object_part_content_set(layout, "elm.swallow.content", label);
 472         elm_object_part_content_set(layout, "elm.swallow.end", check);
 473
 474         evas_object_show(layout);
 475         elm_object_content_set(popup, layout);
 476         btn1 = elm_button_add(popup);
 477         elm_object_style_set(btn1, "popup");
 478         elm_object_text_set(btn1, IDS_OK);
 479         elm_object_part_content_set(popup, "button1", btn1);
 480         evas_object_smart_callback_add(btn1, "clicked", __ok_btn_clicked_cb,
 481                 ug_data);
 482
 483         evas_object_show(popup);
 484 }
 485
 486 static void __pd_onoff_changed_cb(void *data, Evas_Object *obj,
 487         void *event_info)
 488 {
 489         gl_item_data *item_data = (gl_item_data *)data;
 490
 491         if (item_data->type == NFC_PREDEFINED_ITEM) {
 492                 __change_predefined_item_onoff_setting(item_data->data);
 493
 494                 if (pd_item != NULL)
 495                         elm_genlist_item_update(pd_item);
 496         } else {
 497                 LOGE("item_data->type error");
 498         }
 499 }
 500
 501 // get the state of item
 502 static Eina_Bool __gl_state_get(void *data, Evas_Object *obj, const char *part)
 503 {
 504         Eina_Bool result = EINA_FALSE;
 505
 506         gl_item_data *item_data = (gl_item_data *)data;
 507
 508         if (!item_data) {
 509                 LOGE("invalid parameter");
 510                 return EINA_FALSE;
 511         }
 512
 513         return result;
 514 }
 515
 516 // callback for 'deletion'
 517 static void __gl_del(void *data, Evas_Object *obj)
 518 {
 519         gl_item_data *item_data = (gl_item_data *)data;
 520
 521         if (item_data != NULL)
 522                 free(item_data);
 523 }
 524
 525 static void __gl_sel_activation(void *data, Evas_Object *obj,
 526         void *event_info)
 527 {
 528         Elm_Object_Item *item = (Elm_Object_Item *)event_info;
 529         gl_item_data *item_data = (gl_item_data *)data;
 530         ugdata_t *ug_data;
 531
 532
 533         elm_genlist_item_selected_set(item, 0);
 534
 535         if (!item || !item_data) {
 536                 LOGE("invalid parameter");
 537                 return;
 538         }
 539
 540         ug_data = item_data->data;
 541         if (!ug_data) {
 542                 LOGE("invalid parameter");
 543                 return;
 544         }
 545
 546         if (item_data->type == NFC_PREDEFINED_ITEM) {
 547                 _ug_nfc_predefined_item_create(ug_data);
 548         } else if (item_data->type == NFC_SECURE_STORAGE) {
 549                 int boolval;
 550
 551                 if (!vconf_get_bool(SECURE_STORAGE_FIRST_TIME_POPUP_SHOW_KEY,
 552                         &boolval)) {
 553                         if (boolval)
 554                                 __create_secure_storage_comfirm_popup(ug_data);
 555                         else
 556                                 _ug_nfc_secure_storage_create(ug_data);
 557                 }
 558         }
 559 }
 560
 561 static Evas_Object *__gl_content_get(void *data, Evas_Object *obj,
 562         const char *part)
 563 {
 564         gl_item_data *item_data = (gl_item_data *)data;
 565         ugdata_t *ug_data;
 566         Evas_Object *content = NULL;
 567         int boolval;
 568
 569         //LOGD("part:%s", part);
 570
 571         if (!item_data) {
 572                 LOGE("invalid parameter");
 573                 return NULL;
 574         }
 575
 576         ug_data = item_data->data;
 577         if (!ug_data) {
 578                 LOGE("invalid parameter");
 579                 return NULL;
 580         }
 581
 582         if (!strcmp(part, "elm.icon")) {
 583                 if (item_data->type == NFC_PREDEFINED_ITEM) {
 584                         content = elm_check_add(obj);
 585                         evas_object_propagate_events_set(content, EINA_FALSE);
 586                         evas_object_smart_callback_add(content, "changed",
 587                                 __pd_onoff_changed_cb, item_data);
 588
 589                         if (!vconf_get_bool(VCONFKEY_NFC_PREDEFINED_ITEM_STATE,
 590                                 &boolval) && boolval) {
 591                                 elm_check_state_set(content, EINA_TRUE);
 592                         } else {
 593                                 elm_check_state_set(content, EINA_FALSE);
 594                         }
 595
 596                         elm_object_style_set(content, "on&off");
 597                         return content;
 598                 }
 599         }
 600         else if (!strncmp(part, "elm.icon.2", strlen(part))) {
 601                 Evas_Object *tg = NULL;
 602
 603                 content = elm_layout_add(obj);
 604                 elm_layout_theme_set(content, "layout", "list/C/type.3", "default");
 605                 tg = elm_check_add(content);
 606
 607                 int boolval = false;
 608                 int ret = vconf_get_bool(VCONFKEY_NFC_STATE, &boolval);
 609
 610                 if (boolval == false){
 611                         elm_check_state_set(tg, EINA_FALSE);
 612                 } else {
 613                         elm_check_state_set(tg, EINA_TRUE);
 614                 }
 615
 616                 elm_object_style_set(tg, "on&off");
 617                 evas_object_propagate_events_set(tg, EINA_FALSE);
 618                 evas_object_smart_callback_add(tg, "changed", __title_ns_on_off_clicked_cb, item_data);
 619
 620                 evas_object_show(tg);
 621
 622                 elm_layout_content_set(content, "elm.swallow.content", tg);
 623                 ug_data->ns_on_off = tg;
 624
 625                 __update_title_onoff_obj(ug_data);
 626
 627                 return content;
 628         }
 629
 630         return content;
 631 }
 632
 633 static char *__gl_text_get(void *data, Evas_Object *obj,
 634         const char *part)
 635 {
 636         gl_item_data *item_data = (gl_item_data *)data;
 637         char *text = NULL;
 638         int intval;
 639
 640         //LOGD("part:%s", part);
 641
 642         // label for 'elm.text' part
 643         if (!item_data) {
 644                 LOGE("invalid parameter");
 645                 return NULL;
 646         }
 647
 648         if (!strcmp(part, "elm.text.1")) {
 649                 if (item_data->type == NFC_PREDEFINED_ITEM) {
 650                         text = strdup(IDS_USE_NFC_IN_HOME);
 651                 } else if (item_data->type == NFC_SECURE_STORAGE) {
 652                         text = strdup(IDS_NFC_SECURE_STORAGE_BODY);
 653                 }
 654         } else if (!strcmp(part, "elm.text.2")) {
 655                 if (item_data->type == NFC_PREDEFINED_ITEM) {
 656                         app_info_h app_info = NULL;
 657                         char *app_id = NULL;
 658
 659                         app_id = vconf_get_str(VCONFKEY_NFC_PREDEFINED_ITEM);
 660                         if (!app_id) {
 661                                 return NULL;
 662                         }
 663
 664                         if (APP_MANAGER_ERROR_NONE == app_info_create(app_id,
 665                                 &app_info)) {
 666                                 if (APP_MANAGER_ERROR_NONE !=
 667                                         app_info_get_label(app_info, &text))
 668                                         _ug_nfc_setting_db_get_pkgName(app_id, &text);
 669                         } else {
 670                                 _ug_nfc_setting_db_get_pkgName(app_id, &text);
 671                         }
 672
 673                         if (app_info)
 674                                 app_info_destroy(app_info);
 675                         free(app_id);
 676                 } else if (item_data->type == NFC_SECURE_STORAGE) {
 677                         if (! vconf_get_int(VCONFKEY_NFC_WALLET_MODE, &intval)){
 678                                 if (intval == VCONFKEY_NFC_WALLET_MODE_MANUAL)
 679                                         text = strdup(IDS_NFC_SECURE_STORAGE_ITEM_MAN);
 680                                 else
 681                                         text = strdup(IDS_NFC_SECURE_STORAGE_ITEM_AUTO);
 682                         } else {
 683                                 LOGE("vconf_get_int failed");
 684                                 text = strdup(IDS_NFC_SECURE_STORAGE_ITEM_MAN);
 685                         }
 686                 }
 687         }
 688         else if (!strncmp(part, "elm.text.main.left", strlen(part))) {
 689                  text = strdup(IDS_NFC_NFC);
 690         }
 691
 692         return text;
 693 }
 694
 695 static char *__gl_text_get_des(void *data, Evas_Object *obj,
 696         const char *part)
 697 {
 698         int index = (int) data;
 699         char *text = NULL;
 700
 701         //LOGD("index:%d", index);
 702
 703         if (index == 0) {
 704                 text = strdup(IDS_NFC_DESCRIPTION_MSG);
 705         } else if (index == 1) {
 706                 text = strdup(IDS_PREDEFINED_ITEM_DESCRIPTION_MSG);
 707         } else if (index == 2) {
 708                 text = strdup(IDS_NFC_S_BEAM_DESCRIPTION_MSG);
 709         }
 710
 711         return text;
 712 }
 713 static void __nfc_sel(void *data, Evas_Object *obj, void *event_info)
 714 {
 715         __title_ns_on_off_clicked_cb(data, obj, event_info);
 716
 717         elm_genlist_item_selected_set((Elm_Object_Item *)event_info, EINA_FALSE);
 718 }
 719
 720 static Evas_Object *__create_nfc_setting_list(void *data)
 721 {
 722         ugdata_t *ug_data = (ugdata_t *)data;
 723         Evas_Object *genlist = NULL;
 724         Elm_Object_Item* separator = NULL;
 725         int boolval;
 726
 727
 728         /* make genlist */
 729         genlist = elm_genlist_add(ug_data->base_naviframe);
 730         if (genlist == NULL) {
 731                 LOGE("genlist is null");
 732                 return NULL;
 733         }
 734         elm_genlist_mode_set(genlist, ELM_LIST_COMPRESS);
 735
 736         itc_sep.item_style = "dialogue/separator";
 737         itc_sep.func.text_get = NULL;
 738         itc_sep.func.content_get = NULL;
 739         itc_sep.func.state_get = NULL;
 740         itc_sep.func.del = NULL;
 741
 742         itc_sep_help.item_style = "dialogue/separator.2";
 743         itc_sep_help.func.text_get = NULL;
 744         itc_sep_help.func.content_get = NULL;
 745         itc_sep_help.func.state_get = NULL;
 746         itc_sep_help.func.del = NULL;
 747
 748         itc_helptext.item_style = "multiline_sub";
 749         itc_helptext.func.text_get = __gl_text_get_des;
 750         itc_helptext.func.content_get = NULL;
 751         itc_helptext.func.state_get = NULL;
 752         itc_helptext.func.del = NULL;
 753
 754         itc_2text1con.item_style = "dialogue/2text.1icon.10";
 755         itc_2text1con.func.text_get = __gl_text_get;
 756         itc_2text1con.func.content_get = __gl_content_get;
 757         itc_2text1con.func.state_get = __gl_state_get;
 758         itc_2text1con.func.del = __gl_del;
 759
 760         itc_2text.item_style = "dialogue/2text";
 761         itc_2text.func.text_get = __gl_text_get;
 762         itc_2text.func.content_get = NULL;
 763         itc_2text.func.state_get = NULL;
 764         itc_2text.func.del = __gl_del;
 765
 766         itc_onoff.item_style = "1line";
 767         itc_onoff.func.text_get = __gl_text_get;
 768         itc_onoff.func.content_get = __gl_content_get;
 769         itc_onoff.func.state_get = NULL;
 770         itc_onoff.func.del = __gl_del;
 771
 772         gl_item_data *item_data = NULL;
 773         static Elm_Object_Item *onoff_item;
 774
 775         item_data = (gl_item_data *)g_malloc0((gint)sizeof(gl_item_data));
 776
 777         if (!item_data)
 778                 return NULL;
 779
 780         item_data->data = ug_data;
 781         onoff_item = elm_genlist_item_append(genlist, &itc_onoff,
 782                                 (void *) item_data, NULL, ELM_GENLIST_ITEM_NONE,
 783                                 __nfc_sel, (void *) item_data);
 784         elm_object_item_signal_emit(onoff_item, "elm,state,top", "");
 785
 786
 787         /* NFC Help Text + SEPARATOR */
 788         static Elm_Object_Item *help_item;
 789         help_item = elm_genlist_item_append(genlist, &itc_helptext, (void *)0,
 790                 NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 791         elm_genlist_item_select_mode_set(help_item,
 792                 ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 793         elm_object_item_access_unregister(help_item);
 794
 795         /* NFC Secure storage */
 796         /*
 797         if (csc_feature_get_bool(CSC_FEATURE_DEF_BOOL_NFC_CARD_ESE_DISABLE)
 798                 != CSC_FEATURE_BOOL_TRUE) {
 799                 gl_item_data *item_data = NULL;
 800
 801                 LOGD("NFC Secure storage added");
 802                 item_data = (gl_item_data *)g_malloc0((gint)sizeof(gl_item_data));
 803                 if (!item_data)
 804                         return NULL;
 805                 item_data->data = ug_data;
 806                 item_data->type = NFC_SECURE_STORAGE;
 807                 ss_item = elm_genlist_item_append(genlist, &itc_2text,
 808                         (void *) item_data, NULL, ELM_GENLIST_ITEM_NONE,
 809                         __gl_sel_activation, (void *) item_data);
 810         }
 811         */
 812
 813         /* Predefined item setting + SEPARATOR */
 814         if (_ug_nfc_check_predefined_item_available()) {
 815                 gl_item_data *item_data = NULL;
 816
 817                 LOGD("NFC predefined item added");
 818                 item_data = (gl_item_data *)g_malloc0((gint)sizeof(gl_item_data));
 819                 if (!item_data)
 820                         return NULL;
 821                 item_data->type = NFC_PREDEFINED_ITEM;
 822                 item_data->data = ug_data;
 823                 pd_item = elm_genlist_item_append(genlist,
 824                         &itc_2text1con,
 825                         (void *)item_data,
 826                         NULL, ELM_GENLIST_ITEM_NONE,
 827                         __gl_sel_activation, (void *)item_data);
 828
 829                 /* SEPARATOR.2 */
 830                 separator = elm_genlist_item_append(genlist, &itc_sep_help,
 831                         NULL, NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 832                 elm_genlist_item_select_mode_set(separator,
 833                         ELM_OBJECT_SELECT_MODE_DISPLAY_ONLY);
 834                 elm_object_item_access_unregister(separator);
 835
 836                 /* Help Text*/
 837                 elm_genlist_item_append(genlist, &itc_helptext, (void *)1,
 838                         NULL, ELM_GENLIST_ITEM_NONE, NULL, NULL);
 839         }
 840
 841         /* set the visibility of predefine and storage item */
 842         if (!vconf_get_bool(VCONFKEY_NFC_STATE, &boolval) && !boolval) {
 843                 if (vconf_set_bool(VCONFKEY_NFC_PREDEFINED_ITEM_STATE,
 844                         VCONFKEY_NFC_PREDEFINED_ITEM_OFF)) {
 845                         LOGE("vconf_set_bool failed");
 846                 }
 847
 848                 if (pd_item != NULL)
 849                         elm_object_item_disabled_set(pd_item, EINA_TRUE);
 850                 if (ss_item != NULL)
 851                         elm_object_item_disabled_set(ss_item, EINA_TRUE);
 852         }
 853
 854         evas_object_show(genlist);
 855
 856         return genlist;
 857 }
 858
 859 static Evas_Object *__create_bg(Evas_Object *parent, char *style)
 860 {
 861         Evas_Object *bg = elm_bg_add(parent);
 862
 863         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 864
 865         if (style)
 866                 elm_object_style_set(bg, style);
 867
 868         elm_win_resize_object_add(parent, bg);
 869
 870         evas_object_show(bg);
 871
 872         return bg;
 873 }
 874
 875 static Evas_Object *__create_main_layout(Evas_Object *parent)
 876 {
 877         Evas_Object *layout;
 878
 879         if (parent == NULL)
 880                 return NULL;
 881
 882         layout = elm_layout_add(parent);
 883
 884         elm_layout_theme_set(layout, "layout", "application", "default");
 885
 886         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 887
 888         evas_object_show(layout);
 889
 890         return layout;
 891 }
 892
 893 static void *__ug_nfc_setting_create(ui_gadget_h ug, enum ug_mode mode,
 894         app_control_h service, void *priv)
 895 {
 896         ugdata_t *ug_data = (ugdata_t *)priv;
 897         Evas_Object *parent = NULL;
 898         Evas_Object *nfc_setting_list = NULL;
 899         Evas_Object *l_button = NULL;
 900         char *type = NULL;
 901         char *keyword = NULL;
 902
 903         LOGD("BEGIN >>>>");
 904
 905         /* set text domain */
 906         bindtextdomain(NFCUG_TEXT_DOMAIN, NFCUG_LOCALEDIR);
 907
 908         /* create base view */
 909         parent = ug_get_parent_layout(ug);
 910         if (!parent)
 911                 return NULL;
 912         ug_data->ug_win_main = parent;
 913         evas_object_show(ug_data->ug_win_main);
 914         ug_data->nfc_setting_ug = ug;
 915
 916         ug_data->base_layout = __create_main_layout(ug_data->ug_win_main);
 917         ug_data->bg = __create_bg(ug_data->ug_win_main, "group_list");
 918         elm_object_part_content_set(ug_data->base_layout, "elm.swallow.bg",
 919                 ug_data->bg);
 920
 921         ug_data->base_naviframe = elm_naviframe_add(ug_data->base_layout);
 922         elm_object_part_content_set(ug_data->base_layout, "elm.swallow.content",
 923                 ug_data->base_naviframe);
 924         evas_object_show(ug_data->base_naviframe);
 925
 926         ug_data->service = service;
 927
 928         /* parse parameter */
 929         app_control_get_extra_data(service, "type", &type);
 930         app_control_get_extra_data(service, "keyword", &keyword);
 931
 932         if (type) {
 933                 LOGD("type [%s]", type);
 934
 935                 if (strncmp(type, "nfc", strlen("nfc")) == 0) {
 936                         _ug_nfc_setting_db_open();
 937                         nfc_setting_list = __create_nfc_setting_list(ug_data);
 938                         ug_data->menu_type = MENU_NFC;
 939                 }
 940         } else if (keyword) {
 941                 LOGD("keyword [%s]", keyword);
 942
 943                 if (strncmp(keyword, "IDS_NFC_BODY_NFC", strlen("IDS_NFC_BODY_NFC")) == 0 ||
 944                     strncmp(keyword, "IDS_NFC_MBODY_NFC_SECURE_STORAGE",
 945                                 strlen("IDS_NFC_MBODY_NFC_SECURE_STORAGE"))){
 946                         _ug_nfc_setting_db_open();
 947                         nfc_setting_list = __create_nfc_setting_list(ug_data);
 948                         ug_data->menu_type = MENU_NFC;
 949                 }
 950         }
 951
 952         if (nfc_setting_list == NULL) {
 953                 LOGE("wrong type");
 954                 return NULL;
 955         }
 956
 957         ug_data->ns_genlist = nfc_setting_list;
 958
 959         /* Push navifreme */
 960         l_button = elm_button_add(ug_data->base_naviframe);
 961         elm_object_style_set(l_button, "naviframe/back_btn/default");
 962         ea_object_event_callback_add(ug_data->base_naviframe, EA_CALLBACK_BACK,
 963                 ea_naviframe_back_cb, NULL);
 964
 965         if (ug_data->menu_type == MENU_NFC) {
 966                 ug_data->base_navi_it = elm_naviframe_item_push(
 967                         ug_data->base_naviframe,
 968                         IDS_NFC_NFC,
 969                         l_button,
 970                         NULL,
 971                         nfc_setting_list,
 972                         NULL);
 973         }
 974         elm_naviframe_item_pop_cb_set(ug_data->base_navi_it, __back_clicked_cb,
 975                 ug_data);
 976
 977         LOGD("END >>>>");
 978
 979         return ug_data->base_layout;
 980 }
 981
 982 static void __ug_nfc_setting_destroy(ui_gadget_h ug, app_control_h service,
 983         void *priv)
 984 {
 985         ugdata_t *ug_data = (ugdata_t *)priv;
 986
 987         LOGD("BEGIN >>>>");
 988
 989         if ((ug_data == NULL) || (ug == NULL))
 990                 return;
 991
 992         if (nfc_manager_deinitialize() != NFC_ERROR_NONE)
 993                 LOGE("nfc_manager_deinitialize failed");
 994
 995         evas_object_del(ug_get_layout(ug));
 996
 997         LOGD("END >>>>");
 998 }
 999
1000 static void __ug_nfc_setting_start(ui_gadget_h ug, app_control_h service,
1001         void *priv)
1002 {
1003         ugdata_t *ug_data = (ugdata_t *)priv;
1004
1005         LOGD("BEGIN >>>>");
1006
1007         /* check nfc-device*/
1008         if (!nfc_manager_is_supported()) {
1009                 LOGE("It is not nfc device >>>>");
1010                 __show_app_error_popup(ug_data);
1011         }
1012
1013         if (NFC_ERROR_NONE != nfc_manager_initialize())
1014                 LOGE("nfc_manager_initialize FAIL!!!!");
1015
1016         LOGD("END >>>>");
1017 }
1018
1019 static void __ug_nfc_setting_pause(ui_gadget_h ug, app_control_h service,
1020         void *priv)
1021 {
1022         LOGD("BEGIN >>>>");
1023         LOGD("END >>>>");
1024 }
1025
1026 static void __ug_nfc_setting_resume(ui_gadget_h ug, app_control_h service,
1027         void *priv)
1028 {
1029         LOGD("BEGIN >>>>");
1030         LOGD("END >>>>");
1031 }
1032
1033
1034 static void __ug_nfc_setting_message(ui_gadget_h ug, app_control_h msg,
1035         app_control_h service, void *priv)
1036 {
1037         LOGD("BEGIN >>>>");
1038         LOGD("END >>>>");
1039 }
1040
1041 static void __ug_nfc_setting_event(ui_gadget_h ug, enum ug_event event,
1042         app_control_h service, void *priv)
1043 {
1044         LOGD("BEGIN >>>>");
1045         LOGD("END >>>>");
1046 }
1047
1048 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
1049 {
1050         ugdata_t *ug_data; // User defined private data
1051
1052         LOGD("UG_MODULE_INIT!!");
1053
1054         if (!ops)
1055                 return -1;
1056
1057         ug_data = (ugdata_t *)g_malloc0((gint)sizeof(ugdata_t));
1058         if (!ug_data)
1059                 return -1;
1060
1061         ops->create = __ug_nfc_setting_create;
1062         ops->start = __ug_nfc_setting_start;
1063         ops->pause = __ug_nfc_setting_pause;
1064         ops->resume = __ug_nfc_setting_resume;
1065         ops->destroy = __ug_nfc_setting_destroy;
1066         ops->message = __ug_nfc_setting_message;
1067         ops->event = __ug_nfc_setting_event;
1068         ops->priv = ug_data;
1069         ops->opt = UG_OPT_INDICATOR_ENABLE;
1070
1071         return 0;
1072 }
1073
1074 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
1075 {
1076         ugdata_t *ug_data;
1077
1078         LOGD("UG_MODULE_EXIT!!");
1079
1080         if (!ops)
1081                 return;
1082
1083         ug_data = ops->priv;
1084
1085         if (ug_data)
1086                 free(ug_data);
1087
1088         ops->priv = NULL;
1089 }