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

   1 /*
   2   * Copyright (c) 2012, 2013 Samsung Electronics Co., Ltd.
   3   *
   4   * Licensed under the Flora License, Version 1.1 (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
  18 #include "ug-nfc-share-main.h"
  19 #include "ug-nfc-share-tag.h"
  20 #include "ug-nfc-share-popup.h"
  21
  22 #include <stdio.h>
  23 #include <Elementary.h>
  24 #include <Ecore.h>
  25 #include <bundle.h>
  26 #include <Ecore_X.h>
  27 #include <vconf.h>
  28 #include <sys/types.h>
  29 #include <sys/wait.h>
  30
  31 /* external library header */
  32 #include <assert.h>
  33 #include <glib.h>
  34
  35 #ifndef UG_MODULE_API
  36 #define UG_MODULE_API __attribute__ ((visibility("default")))
  37 #endif
  38
  39 /* nfc_handover */
  40 #define NET_NFC_SHARE_REQUEST_TYPE_BUFFER "data_buffer"
  41
  42 #define DISPLAY_STRING_MAX_SIZE         90
  43 #define ABBREVIATION_TEXT                       "..."
  44
  45 void ug_nfc_share_create_base_view(void *user_data);
  46 void ug_nfc_share_create_nfc_share_view(void *user_data);
  47 bool ug_nfc_share_check_nfc_isAvailable(void *user_data);
  48 static void ug_nfc_share_create_data(ugdata_t* ug_data);
  49
  50
  51 int _get_theme_type()
  52 {
  53         /* TODO : will be added */
  54         return 0;
  55 }
  56
  57 const char *_get_font_name(int font)
  58 {
  59         const char *name = NULL;
  60
  61         /* TODO : will be improved */
  62         if (_get_theme_type() == 0)
  63         {
  64                 switch (font)
  65                 {
  66                 case UG_FONT_LIST :
  67                         name = "Tizen";
  68                         break;
  69
  70                 case UG_FONT_SBEAM_TITLE :
  71                         name = "Tizen";
  72                         break;
  73
  74                 case UG_FONT_LIVEBOX :
  75                         name = "Tizen";
  76                         break;
  77
  78                 case UG_FONT_HELP :
  79                         name = "Tizen";
  80                         break;
  81
  82                 default :
  83                         UG_NFC_SHARE_DEBUG_ERR("unknown font type [%d]", font);
  84                         break;
  85                 }
  86         }
  87
  88         return name;
  89 }
  90
  91 uint32_t _get_font_color(int font)
  92 {
  93         uint32_t color = 0x00808080;
  94
  95         /* TODO : will be improved */
  96         if (_get_theme_type() == 0)
  97         {
  98                 switch (font)
  99                 {
 100                 case UG_FONT_LIST :
 101                         color = 0x00000000;
 102                         break;
 103
 104                 case UG_FONT_SBEAM_TITLE :
 105                         color = 0x00000000;
 106                         break;
 107
 108                 case UG_FONT_LIVEBOX :
 109                         color = 0x00FFFFFF;
 110                         break;
 111
 112                 case UG_FONT_HELP :
 113                         color = 0x00000000;
 114                         break;
 115
 116                 default :
 117                         UG_NFC_SHARE_DEBUG_ERR("unknown font type [%d]", font);
 118                         break;
 119                 }
 120         }
 121
 122         return color;
 123 }
 124
 125 int _get_font_size(int font)
 126 {
 127         int size = 0;
 128
 129         /* TODO : will be improved */
 130         if (_get_theme_type() == 0)
 131         {
 132                 switch (font)
 133                 {
 134                 case UG_FONT_LIST :
 135                         size = 28;
 136                         break;
 137
 138                 case UG_FONT_SBEAM_TITLE :
 139                         size = 38;
 140                         break;
 141
 142                 case UG_FONT_LIVEBOX :
 143                         size = 30;
 144                         break;
 145
 146                 case UG_FONT_HELP :
 147                         size = 32;
 148                         break;
 149
 150                 default :
 151                         UG_NFC_SHARE_DEBUG_ERR("unknown font type [%d]", font);
 152                         break;
 153                 }
 154         }
 155
 156         return size;
 157 }
 158
 159 const char *_get_font_style(int font)
 160 {
 161         const char *style = NULL;
 162
 163         /* TODO : will be improved */
 164         if (_get_theme_type() == 0)
 165         {
 166                 switch (font)
 167                 {
 168                 case UG_FONT_LIST :
 169                         style = "bold";
 170                         break;
 171
 172                 case UG_FONT_SBEAM_TITLE :
 173                         style = "";
 174                         break;
 175
 176                 case UG_FONT_LIVEBOX :
 177                         style = "";
 178                         break;
 179
 180                 case UG_FONT_HELP :
 181                         style = "bold";
 182                         break;
 183
 184                 default :
 185                         UG_NFC_SHARE_DEBUG_ERR("unknown font type [%d]", font);
 186                         break;
 187                 }
 188         }
 189
 190         return style;
 191 }
 192
 193 void _get_image_path(const char *image, char *path, int len)
 194 {
 195         const char *prefix = NULL;
 196
 197         switch (_get_theme_type())
 198         {
 199         /* TODO : will be improved */
 200         case 0 :
 201                 prefix = IMAGES_PATH"/white";
 202                 break;
 203
 204         default :
 205                 prefix = IMAGES_PATH"/black";
 206                 break;
 207         }
 208
 209         if (image != NULL)
 210         {
 211                 snprintf(path, len, "%s/%s", prefix, image);
 212         }
 213         else
 214         {
 215                 snprintf(path, len, "%s", prefix);
 216         }
 217 }
 218
 219 /******************* UI Functions *************/
 220 static Evas_Object *_create_button(Evas_Object *parent, void (*func)(void *data, Evas_Object *obj, void *event_info), const char *label, const char *swallow, const char *style, void *data)
 221 {
 222         Evas_Object *button;
 223
 224         retv_if(parent == NULL, NULL);
 225
 226         button = elm_button_add(parent);
 227         if (style != NULL)
 228         {
 229                 elm_object_style_set(button, style);
 230         }
 231
 232         if (label != NULL)
 233         {
 234                 elm_object_text_set(button, label);
 235         }
 236
 237         evas_object_smart_callback_add(button, "clicked", func, (void*)data);
 238         evas_object_show(button);
 239         elm_object_part_content_set(parent, swallow, button);
 240
 241         return button;
 242 }
 243
 244 static Evas_Object *_create_image(Evas_Object *parent, const char *file_path, const char *swallow, void *data)
 245 {
 246         Evas_Object *image;
 247
 248         retv_if(parent == NULL, NULL);
 249         retv_if(file_path == NULL, NULL);
 250         retv_if(swallow == NULL, NULL);
 251
 252         image = elm_image_add(parent);
 253         retv_if(image == NULL, NULL);
 254
 255         elm_image_file_set(image, file_path, NULL);
 256         elm_image_no_scale_set(image, 1);
 257         elm_image_resizable_set(image, 0, 0);
 258         elm_object_part_content_set(parent, swallow, image);
 259
 260         return image;
 261 }
 262
 263 static Evas_Object *_create_bg(Evas_Object *win)
 264 {
 265         Evas_Object *bg = elm_bg_add(win);
 266
 267         evas_object_size_hint_weight_set(bg, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 268         elm_win_resize_object_add(win, bg);
 269
 270         evas_object_show(bg);
 271
 272         return bg;
 273 }
 274
 275 static Evas_Object *_create_main_layout(Evas_Object* parent)
 276 {
 277         Evas_Object *layout;
 278
 279         if (parent == NULL)
 280                 return NULL;
 281
 282         layout = elm_layout_add(parent);
 283
 284         elm_layout_theme_set(layout, "layout", "application", "default");
 285
 286         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 287
 288         evas_object_show(layout);
 289
 290         return layout;
 291 }
 292
 293 static void _activation_completed_cb(nfc_error_e error, void *user_data)
 294 {
 295         ugdata_t *ug_data = (ugdata_t *)user_data;
 296
 297         UG_NFC_SHARE_BEGIN();
 298
 299         ret_if(ug_data == NULL);
 300
 301         /* create share view */
 302         ug_nfc_share_create_nfc_share_view(ug_data);
 303
 304         UG_NFC_SHARE_END();
 305 }
 306
 307 static void _setting_on_YesNo_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
 308 {
 309         ugdata_t *ug_data = (ugdata_t *)data;
 310         int result = (int)event_info;
 311
 312         UG_NFC_SHARE_BEGIN();
 313
 314         ret_if(ug_data == NULL);
 315
 316         switch (result)
 317         {
 318         case UG_NFC_POPUP_RESP_OK :
 319                 /* setting is on */
 320                 UG_NFC_SHARE_DEBUG("setting is on >>>>");
 321
 322                 result = nfc_manager_set_activation(true, _activation_completed_cb, ug_data);
 323                 if (result != NFC_ERROR_NONE)
 324                 {
 325                         UG_NFC_SHARE_DEBUG_ERR("nfc_manager_set_activation failed");
 326                 }
 327                 break;
 328
 329         case UG_NFC_POPUP_RESP_CANCEL :
 330                 /* destroy UG */
 331                 UG_NFC_SHARE_DEBUG("ug_destroy_me >>>>");
 332                 ug_destroy_me(ug_data->nfc_share_ug);
 333                 break;
 334
 335         default :
 336                 break;
 337         }
 338
 339         UG_NFC_SHARE_END();
 340 }
 341
 342 static void _setting_on_YesNo_popup(void *data)
 343 {
 344         ugdata_t *ug_data = (ugdata_t *)data;
 345         char popup_str[POPUP_TEXT_SIZE] = { 0, };
 346
 347         UG_NFC_SHARE_BEGIN();
 348
 349         ret_if(ug_data == NULL);
 350
 351         memcpy(popup_str, IDS_SERVICE_NOT_AVAILABLE_NFC_TURNED_OFF_TURN_ON_NFC_Q, strlen(IDS_SERVICE_NOT_AVAILABLE_NFC_TURNED_OFF_TURN_ON_NFC_Q));
 352
 353         ug_nfc_share_create_popup(ug_data, ug_data->base_layout, popup_str, IDS_YES, UG_NFC_POPUP_RESP_OK, IDS_NO, UG_NFC_POPUP_RESP_CANCEL, NULL, 0, false, false, _setting_on_YesNo_popup_response_cb);
 354
 355         UG_NFC_SHARE_END();
 356 }
 357
 358 static void _app_error_popup_response_cb(void *data, Evas_Object *obj, void *event_info)
 359 {
 360         ugdata_t *ug_data = (ugdata_t *)data;
 361         int result = (int)event_info;
 362
 363         UG_NFC_SHARE_BEGIN();
 364
 365         if (ug_data == NULL)
 366                 return;
 367
 368         switch (result)
 369         {
 370         case UG_NFC_POPUP_RESP_CLOSE :
 371                 /* destroy UG */
 372                 UG_NFC_SHARE_DEBUG("ug_destroy_me >>>>");
 373                 ug_destroy_me(ug_data->nfc_share_ug);
 374                 break;
 375
 376         default :
 377                 break;
 378         }
 379
 380         UG_NFC_SHARE_END();
 381 }
 382
 383 static void _show_app_error_popup(void *data)
 384 {
 385         ugdata_t *ug_data = (ugdata_t *)data;
 386         char popup_str[POPUP_TEXT_SIZE] = { 0, };
 387
 388         UG_NFC_SHARE_BEGIN();
 389
 390         if (ug_data == NULL)
 391                 return;
 392
 393         memcpy(popup_str, IDS_NFC_SERVICE_IS_NOT_SUPPORTED, strlen(IDS_NFC_SERVICE_IS_NOT_SUPPORTED));
 394
 395         ug_nfc_share_create_popup(ug_data, ug_data->base_layout, popup_str, IDS_CLOSE, UG_NFC_POPUP_RESP_CLOSE, NULL, 0, NULL, 0, false, false, _app_error_popup_response_cb);
 396
 397         UG_NFC_SHARE_END();
 398 }
 399
 400 static void _back_clicked_cb(void *data, Evas_Object *obj, void *event_info)
 401 {
 402         UG_NFC_SHARE_BEGIN();
 403
 404         /* destroy UG */
 405         ug_destroy_me(data);
 406
 407         UG_NFC_SHARE_END();
 408 }
 409
 410 static void _lang_changed(void *data)
 411 {
 412         UG_NFC_SHARE_BEGIN();
 413
 414         ugdata_t* ug_data = (ugdata_t*)data;
 415         ret_if(ug_data == NULL);
 416
 417         edje_object_part_text_set(elm_layout_edje_get(ug_data->layout), "title", IDS_GENTLY_TOUCH_PHONES_TOGETHER_TO_SHARE);
 418
 419         elm_object_text_set(ug_data->cancel_btn, IDS_CANCEL);
 420
 421         UG_NFC_SHARE_END();
 422 }
 423
 424 static Evas_Object *ug_nfc_share_create_layout(void *data)
 425 {
 426         ugdata_t* ug_data = (ugdata_t*)data;
 427
 428         Evas_Object *layout = NULL;
 429         Evas_Object *cancel_btn = NULL;
 430         Evas_Object *access_layout = NULL;
 431         Evas_Object *access_object = NULL;
 432         int width, height;
 433
 434         UG_NFC_SHARE_BEGIN();
 435
 436         ecore_x_window_size_get(ecore_x_window_root_first_get(), &width, &height);
 437         UG_NFC_SHARE_DEBUG("width[%d] / height[%d]", width, height);
 438
 439         /* create base layout */
 440         layout = elm_layout_add(ug_data->base_layout);
 441         retv_if(layout == NULL, NULL);
 442         ug_data->layout = layout;
 443
 444         if (width == 480) // WVGA
 445         {
 446                 elm_layout_file_set(layout, EDJ_FILE, "share_via_nfc_wvga");
 447         }
 448         else // HD
 449         {
 450                 elm_layout_file_set(layout, EDJ_FILE, "share_via_nfc");
 451         }
 452         evas_object_size_hint_weight_set(layout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 453         evas_object_size_hint_align_set(layout, EVAS_HINT_FILL, EVAS_HINT_FILL);
 454         evas_object_show(layout);
 455
 456         /* create message label */
 457         edje_object_part_text_set(elm_layout_edje_get(layout), "title", IDS_GENTLY_TOUCH_PHONES_TOGETHER_TO_SHARE);
 458
 459         /* create image */
 460         Evas_Object *image = NULL;
 461         char path[1024] = { 0, };
 462         if (width == 480) // WVGA
 463         {
 464                 _get_image_path("U05_AfterSelect_Share_help_popup.png", path, sizeof(path));
 465         }
 466         else // HD
 467         {
 468                 _get_image_path("U05_AfterSelect_Share_help.png", path, sizeof(path));
 469         }
 470         image = _create_image(layout, path, "image", ug_data);
 471         retv_if(image == NULL, NULL);
 472         evas_object_show(image);
 473
 474         /* create cancel button */
 475         cancel_btn = _create_button(layout, _back_clicked_cb, IDS_CANCEL, "cancel_btn", "style1", ug_data->nfc_share_ug);
 476         retv_if(cancel_btn == NULL, NULL);
 477         ug_data->cancel_btn = cancel_btn;
 478         evas_object_show(cancel_btn);
 479
 480         /* accessibility */
 481         access_layout = (Evas_Object *)edje_object_part_object_get(elm_layout_edje_get(layout), "access");
 482         retv_if(access_layout == NULL, NULL);
 483         access_object = elm_access_object_register(access_layout, elm_layout_edje_get(layout));
 484         retv_if(access_object == NULL, NULL);
 485         elm_access_info_set(access_object, ELM_ACCESS_INFO, IDS_GENTLY_TOUCH_PHONES_TOGETHER_TO_SHARE);
 486
 487         if (NFC_ERROR_NONE == nfc_manager_initialize(NULL, NULL))
 488         {
 489                 UG_NFC_SHARE_DEBUG("nfc_manager_initialize success");
 490                 ug_nfc_set_nfc_callback(ug_data);
 491         }
 492         else
 493         {
 494                 UG_NFC_SHARE_DEBUG_ERR("nfc_manager_initialize FAIL!!!!");
 495         }
 496
 497         return layout;
 498 }
 499
 500 /******************* UI Functions ENDZZZ*************/
 501
 502 void ug_nfc_share_create_base_view(void *user_data)
 503 {
 504         ugdata_t* ug_data = (ugdata_t*)user_data;
 505
 506         UG_NFC_SHARE_BEGIN();
 507
 508         /* create base layout */
 509         ug_data->base_layout = _create_main_layout(ug_data->ug_win_main);
 510         ug_data->bg = _create_bg(ug_data->ug_win_main);
 511         elm_object_part_content_set(ug_data->base_layout, "elm.swallow.bg", ug_data->bg);
 512         evas_object_show(ug_data->base_layout);
 513
 514         UG_NFC_SHARE_END();
 515 }
 516
 517 void ug_nfc_share_create_nfc_share_view(void *user_data)
 518 {
 519         ugdata_t* ug_data = (ugdata_t*)user_data;
 520         Evas_Object* nfc_share_layout = NULL;
 521
 522         UG_NFC_SHARE_BEGIN();
 523
 524
 525         /* create data */
 526         ug_nfc_share_create_data(ug_data);
 527
 528         /* create share layout */
 529         nfc_share_layout = ug_nfc_share_create_layout(ug_data);
 530
 531         if (nfc_share_layout == NULL)
 532         {
 533                 UG_NFC_SHARE_DEBUG_ERR("nfc_share_layout is NULL");
 534                 return;
 535         }
 536
 537         elm_object_part_content_set(ug_data->base_layout, "elm.swallow.content", nfc_share_layout);
 538
 539         UG_NFC_SHARE_END();
 540 }
 541
 542 bool ug_nfc_share_check_nfc_isAvailable(void *user_data)
 543 {
 544         ugdata_t *ug_data = (ugdata_t *)user_data;
 545         int result, on;
 546
 547         UG_NFC_SHARE_BEGIN();
 548
 549         retv_if(ug_data == NULL, false);
 550
 551         /* check if nfc is on */
 552         if ((result = vconf_get_bool(VCONFKEY_NFC_STATE, &on)) == 0)
 553         {
 554                 UG_NFC_SHARE_DEBUG("vconf_get_bool status [%d]", on);
 555                 if (!on)
 556                 {
 557                         /* show nfc on/off popup */
 558                         _setting_on_YesNo_popup(ug_data);
 559                         return false;
 560                 }
 561         }
 562         else
 563         {
 564                 UG_NFC_SHARE_DEBUG_ERR("vconf_get_bool failed");
 565                 return false;
 566         }
 567
 568         UG_NFC_SHARE_END();
 569
 570         return true;
 571 }
 572
 573 static void ug_nfc_share_create_data(ugdata_t* ug_data)
 574 {
 575         bundle *bd = ug_data->bd;
 576         int type;
 577
 578         UG_NFC_SHARE_BEGIN();
 579
 580         int result = UG_NFC_SHARE_ERROR;
 581         nfc_ndef_message_h msg = NULL;
 582         char *request_data = (char *)bundle_get_val(bd, "request_data");
 583
 584
 585         if (request_data == NULL)
 586         {
 587                 UG_NFC_SHARE_DEBUG_ERR("request_data IS NULL");
 588                 /* exit */
 589                 return;
 590         }
 591
 592         UG_NFC_SHARE_DEBUG("request_data : %s request_data strlen %d", GET_SAFE_STRING(request_data), strlen(request_data));
 593
 594         if (strlen(request_data) == 0)
 595         {
 596                 UG_NFC_SHARE_DEBUG_ERR("bundle data is wrong ");
 597                 /* exit */
 598                 return;
 599         }
 600
 601         type = ug_nfc_share_get_tag_type();
 602
 603         switch (type)
 604         {
 605         case UG_NFC_SHARE_TAG_URL :
 606                 {
 607                         /* nfc_handover now no user case of multi recored for buffered string*/
 608                         nfc_ndef_record_h record = NULL;
 609
 610                         /* make memo NDEF message */
 611                         UG_NFC_SHARE_DEBUG("data is string");
 612
 613                         result = nfc_ndef_record_create_uri(&record, request_data);
 614                         if (result != NFC_ERROR_NONE)
 615                         {
 616                                 UG_NFC_SHARE_DEBUG_ERR("nfc_ndef_record_create failed (%d)", result);
 617                                 return;
 618                         }
 619
 620                         /* create ndef msg*/
 621                         result = nfc_ndef_message_create(&msg);
 622                         if (result != NFC_ERROR_NONE)
 623                         {
 624                                 UG_NFC_SHARE_DEBUG_ERR("nfc_ndef_message_create failed (%d)", result);
 625                                 nfc_ndef_record_destroy(record);
 626                                 return;
 627                         }
 628
 629                         /* append record to ndef msg */
 630                         result = nfc_ndef_message_append_record(msg, record);
 631                         if (result != NFC_ERROR_NONE)
 632                         {
 633                                 UG_NFC_SHARE_DEBUG_ERR("nfc_ndef_message_create failed (%d)", result);
 634                                 nfc_ndef_message_destroy(msg);
 635                                 nfc_ndef_record_destroy(record);
 636                                 return;
 637                         }
 638                 }
 639                 break;
 640
 641         case UG_NFC_SHARE_TAG_MEMO :
 642                 {
 643                         /* nfc_handover now no user case of multi recored for buffered string*/
 644                         nfc_ndef_record_h record = NULL;
 645
 646                         /* make memo NDEF message */
 647                         UG_NFC_SHARE_DEBUG("UG_NFC_SHARE_TAG_MEMO");
 648
 649                         result = nfc_ndef_record_create_text(&record, request_data, "en-US", NFC_ENCODE_UTF_8);
 650                         if (result != NFC_ERROR_NONE)
 651                         {
 652                                 UG_NFC_SHARE_DEBUG_ERR("nfc_ndef_record_create failed (%d)", result);
 653                                 return;
 654                         }
 655
 656                         /* create ndef msg*/
 657                         result = nfc_ndef_message_create(&msg);
 658                         if (result != NFC_ERROR_NONE)
 659                         {
 660                                 UG_NFC_SHARE_DEBUG_ERR("nfc_ndef_message_create failed (%d)", result);
 661                                 nfc_ndef_record_destroy(record);
 662                                 return;
 663                         }
 664
 665                         /* append record to ndef msg */
 666                         result = nfc_ndef_message_append_record(msg, record);
 667                         if (result != NFC_ERROR_NONE)
 668                         {
 669                                 UG_NFC_SHARE_DEBUG_ERR("nfc_ndef_message_create failed (%d)", result);
 670                                 nfc_ndef_message_destroy(msg);
 671                                 nfc_ndef_record_destroy(record);
 672                                 return;
 673                         }
 674                 }
 675                 break;
 676
 677         default :
 678                 break;
 679         }
 680
 681         result = ug_nfc_share_set_current_ndef(ug_data, msg);
 682         if (result != UG_NFC_SHARE_OK)
 683         {
 684                 UG_NFC_SHARE_DEBUG_ERR("ug_nfc_share_set_current_ndef failed (%d)", result);
 685                 nfc_ndef_message_destroy(msg);
 686         }
 687
 688         UG_NFC_SHARE_END();
 689 }
 690
 691 static bool ug_nfc_share_parse_bundle(bundle *bd)
 692 {
 693         char *request_type = (char *)bundle_get_val(bd, "request_type");
 694         char *request_data = (char *)bundle_get_val(bd, "request_data");
 695
 696         UG_NFC_SHARE_BEGIN();
 697
 698         if (request_type == NULL || request_data == NULL)
 699         {
 700                 UG_NFC_SHARE_DEBUG_ERR("request_data or request_data IS NULL");
 701                 /* exit */
 702                 return false;
 703         }
 704
 705         UG_NFC_SHARE_DEBUG("request_type : %s, request_data : %s request_data strlen %d", GET_SAFE_STRING(request_type), GET_SAFE_STRING(request_data), strlen(request_data));
 706
 707         if (strlen(request_data) == 0)
 708         {
 709                 UG_NFC_SHARE_DEBUG_ERR("bundle data is wrong ");
 710                 /* exit */
 711                 return false;
 712         }
 713
 714         /* process data and store specific space for sharing data */
 715         if (strncmp(request_type, NET_NFC_SHARE_REQUEST_TYPE_BUFFER, strlen(NET_NFC_SHARE_REQUEST_TYPE_BUFFER)) == 0)
 716         {
 717                 if ((strncmp(request_data, "http://", strlen("http://")) == 0) || (strncmp(request_data, "https://", strlen("https://")) == 0))
 718                 {
 719                         UG_NFC_SHARE_DEBUG("data is URI");
 720
 721                         ug_nfc_share_set_tag_type(UG_NFC_SHARE_TAG_URL);
 722                 }
 723                 else
 724                 {
 725                         UG_NFC_SHARE_DEBUG("data is MEMO");
 726
 727                         ug_nfc_share_set_tag_type(UG_NFC_SHARE_TAG_MEMO);
 728                 }
 729         }
 730         else
 731         {
 732                 UG_NFC_SHARE_DEBUG_ERR("request_type is wrong ");
 733
 734                 return false;
 735         }
 736
 737         UG_NFC_SHARE_END();
 738
 739         return true;
 740 }
 741
 742 static void *__ug_nfc_share_create(ui_gadget_h ug, enum ug_mode mode, service_h service, void *priv)
 743 {
 744         ugdata_t *ug_data = (ugdata_t *)priv;
 745
 746         UG_NFC_SHARE_BEGIN();
 747
 748         /* set text domain */
 749         bindtextdomain(NFCUG_TEXT_DOMAIN, NFCUG_LOCALEDIR);
 750
 751         /* set UG data */
 752         ug_data->ug_win_main = ug_get_parent_layout(ug);
 753         ug_data->nfc_share_ug = ug;
 754 #if 0
 755         if (SERVICE_ERROR_NONE != service_export_as_bundle(service, &ug_data->bd))
 756         return NULL;
 757 #else
 758         bundle *bd = NULL;
 759         char *request_type = NULL;
 760         char *request_data = NULL;
 761
 762         bd = bundle_create();
 763         if (bd == NULL)
 764                 return NULL;
 765
 766         service_get_extra_data(service, "request_type", &request_type);
 767         service_get_extra_data(service, "request_data", &request_data);
 768
 769         bundle_add(bd, "request_type", request_type);
 770         bundle_add(bd, "request_data", request_data);
 771
 772         ug_data->bd = bd;
 773 #endif
 774
 775         /* parse pameter, and them set request type */
 776         if (!ug_nfc_share_parse_bundle(ug_data->bd))
 777                 return NULL;
 778
 779         /* create base layout */
 780         ug_nfc_share_create_base_view(ug_data);
 781
 782         /* create share view */
 783         ug_nfc_share_create_nfc_share_view(ug_data);
 784
 785         UG_NFC_SHARE_END();
 786
 787         return ug_data->base_layout;
 788 }
 789
 790 static void __ug_nfc_share_destroy(ui_gadget_h ug, service_h service, void *priv)
 791 {
 792         ugdata_t *ug_data = (ugdata_t *)priv;
 793
 794         UG_NFC_SHARE_BEGIN();
 795
 796         if (ug_data == NULL)
 797                 return;
 798
 799         /* unset callback */
 800         ug_nfc_unset_nfc_callback();
 801
 802         /* nfc deactivate */
 803         if (nfc_manager_deinitialize() != NFC_ERROR_NONE)
 804         {
 805                 UG_NFC_SHARE_DEBUG_ERR("nfc_manager_deinitialize failed");
 806         }
 807
 808         if (ug_data->bd != NULL)
 809         {
 810                 bundle_free(ug_data->bd);
 811                 ug_data->bd = NULL;
 812         }
 813
 814         evas_object_del(ug_get_layout(ug));
 815
 816         UG_NFC_SHARE_END();
 817 }
 818
 819 static void __ug_nfc_share_start(ui_gadget_h ug, service_h service, void *priv)
 820 {
 821         UG_NFC_SHARE_BEGIN();
 822
 823         ugdata_t *ug_data = (ugdata_t *)priv;
 824
 825         /* check nfc-device*/
 826         if (!nfc_manager_is_supported())
 827         {
 828                 UG_NFC_SHARE_DEBUG_ERR("It is not nfc device >>>>");
 829                 _show_app_error_popup(ug_data);
 830                 return;
 831         }
 832
 833         ug_nfc_share_check_nfc_isAvailable(ug_data);
 834
 835         UG_NFC_SHARE_END();
 836 }
 837
 838 static void __ug_nfc_share_pause(ui_gadget_h ug, service_h service, void *priv)
 839 {
 840         UG_NFC_SHARE_BEGIN();
 841
 842         UG_NFC_SHARE_END();
 843 }
 844
 845 static void __ug_nfc_share_resume(ui_gadget_h ug, service_h service, void *priv)
 846 {
 847         UG_NFC_SHARE_BEGIN();
 848
 849         UG_NFC_SHARE_END();
 850 }
 851
 852 static void __ug_nfc_share_message(ui_gadget_h ug, service_h msg, service_h service, void *priv)
 853 {
 854         UG_NFC_SHARE_BEGIN();
 855
 856         UG_NFC_SHARE_END();
 857 }
 858
 859 static void __ug_nfc_share_event(ui_gadget_h ug, enum ug_event event, service_h service, void *priv)
 860 {
 861         UG_NFC_SHARE_BEGIN();
 862
 863         ugdata_t *ug_data = (ugdata_t *)priv;
 864
 865         UG_NFC_SHARE_DEBUG("event[%d]", event);
 866
 867         switch (event) {
 868         case UG_EVENT_LOW_MEMORY:
 869                 UG_NFC_SHARE_DEBUG("UG_EVENT_LOW_MEMORY");
 870                 break;
 871         case UG_EVENT_LOW_BATTERY:
 872                 UG_NFC_SHARE_DEBUG("UG_EVENT_LOW_BATTERY");
 873                 break;
 874         case UG_EVENT_LANG_CHANGE:
 875                 UG_NFC_SHARE_DEBUG("UG_EVENT_LANG_CHANGE");
 876                 _lang_changed(ug_data);
 877                 break;
 878         case UG_EVENT_ROTATE_PORTRAIT:
 879                 elm_win_rotation_with_resize_set(ug_data->ug_win_main, 0);
 880                 UG_NFC_SHARE_DEBUG("UG_EVENT_ROTATE_PORTRAIT");
 881                 break;
 882         case UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN:
 883                 elm_win_rotation_with_resize_set(ug_data->ug_win_main, 0);
 884                 UG_NFC_SHARE_DEBUG("UG_EVENT_ROTATE_PORTRAIT_UPSIDEDOWN");
 885                 break;
 886         case UG_EVENT_ROTATE_LANDSCAPE:
 887                 UG_NFC_SHARE_DEBUG("UG_EVENT_ROTATE_LANDSCAPE");
 888                 elm_win_rotation_with_resize_set(ug_data->ug_win_main, 0);
 889                 break;
 890         case UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN:
 891                 UG_NFC_SHARE_DEBUG("UG_EVENT_ROTATE_LANDSCAPE_UPSIDEDOWN");
 892                 elm_win_rotation_with_resize_set(ug_data->ug_win_main, 0);
 893                 break;
 894         case UG_EVENT_REGION_CHANGE:
 895                 UG_NFC_SHARE_DEBUG("UG_EVENT_REGION_CHANGE");
 896                 break;
 897         default:
 898                 break;
 899         }
 900
 901         UG_NFC_SHARE_END();
 902 }
 903
 904 UG_MODULE_API int UG_MODULE_INIT(struct ug_module_ops *ops)
 905 {
 906         ugdata_t *ug_data; // User defined private data
 907
 908         UG_NFC_SHARE_BEGIN();
 909
 910         if (!ops)
 911                 return -1;
 912
 913         ug_data = (ugdata_t *)malloc(sizeof(ugdata_t));
 914         if (!ug_data)
 915                 return -1;
 916
 917         memset(ug_data, 0x00, sizeof(ugdata_t));
 918
 919         ops->create = __ug_nfc_share_create;
 920         ops->start = __ug_nfc_share_start;
 921         ops->pause = __ug_nfc_share_pause;
 922         ops->resume = __ug_nfc_share_resume;
 923         ops->destroy = __ug_nfc_share_destroy;
 924         ops->message = __ug_nfc_share_message;
 925         ops->event = __ug_nfc_share_event;
 926         ops->priv = ug_data;
 927         ops->opt = UG_OPT_INDICATOR_ENABLE;
 928
 929         UG_NFC_SHARE_END();
 930
 931         return 0;
 932 }
 933
 934 UG_MODULE_API void UG_MODULE_EXIT(struct ug_module_ops *ops)
 935 {
 936         ugdata_t *ug_data;
 937
 938         UG_NFC_SHARE_BEGIN();
 939
 940         if (!ops)
 941                 return;
 942
 943         ug_data = ops->priv;
 944
 945         if (ug_data)
 946                 free(ug_data);
 947
 948         ops->priv = NULL;
 949
 950         UG_NFC_SHARE_END();
 951 }