src/mp-external-ug.c

   1 /*
   2  * Copyright (c) [2012] 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
  18 #include <app.h>
  19 #include <Elementary.h>
  20
  21 #include "mp-util.h"
  22 #include "mp-video-log.h"
  23 #include "video-player.h"
  24 #include "mp-external-ug.h"
  25 #include "mp-video-value-define.h"
  26 #include "mp-video-string-define.h"
  27 #include "mp-video-service-ctrl.h"
  28
  29
  30 #define UG_LIST_ITEMS_SIZE_MAX                  32
  31 #define UG_SHARE_MENU_ITEM_MAX                  6
  32
  33
  34 static ui_gadget_h pUiGadgetHandle = NULL;
  35 static Ecore_Event_Handler *pHardKeyEventHandler = NULL;
  36 static MpExternalUGType nCurUGType = MP_EXTERNAL_UG_NONE;
  37 static char **szUgItems = NULL;
  38
  39
  40 static Evas_Object      *pUGPopupHandle = NULL;
  41 static Evas_Object      *pUGGenList = NULL;
  42
  43
  44 typedef struct _External_Ug {
  45         MpExternalUGType nType;
  46         char *szUgName;
  47 } MpExternalUG;
  48
  49 MpExternalUG st_MpExternalUG[] = {
  50         {MP_EXTERNAL_UG_MESSAGE, "msg-composer-efl" },
  51         {MP_EXTERNAL_UG_EMAIL, "email-composer-efl" },
  52         {MP_EXTERNAL_UG_MYFILE_DETAIL, "myfile-detail-efl" },
  53         {MP_EXTERNAL_UG_YOUTUBE, "youtube-efl" },
  54         {MP_EXTERNAL_UG_BLUETOOTH, "setting-bluetooth-efl" },
  55         {MP_EXTERNAL_UG_FTM, "fileshare-efl" },
  56         {MP_EXTERNAL_UG_FACEBOOK, "facebook-efl" },
  57 };
  58
  59
  60
  61
  62 /*
  63  * CALLBACK FUNCTION
  64  */
  65
  66 static char *MpExternalUgGetLabelOfGenlistItemCb(const void *pUserData, Evas_Object *pObject, const char *pPart)
  67 {
  68         VideoLogInfo("");
  69
  70         int nIndex = (int)pUserData;
  71
  72         if(!strcmp(pPart, "elm.text"))
  73         {
  74                 VideoLogInfo("Index : %d", nIndex);
  75                 return strdup(szUgItems[nIndex]);
  76         }
  77
  78         return NULL;
  79 }
  80
  81
  82 static Eina_Bool MpExternalUgHardkeyDownCb(void *pUserData, int nType,
  83                                            void *pEvent)
  84 {
  85         VideoLogInfo("");
  86
  87         if (!pUserData) {
  88                 VideoLogInfo("[ERR]");
  89                 return EINA_FALSE;
  90         }
  91
  92         VideoAppData *pAppData = (VideoAppData *)pUserData;
  93
  94         MpExternalUGType nExternalUgState = MpExternalUgGetCurUgState();
  95
  96         if (nExternalUgState <= MP_EXTERNAL_UG_NONE ||
  97             nExternalUgState >= MP_EXTERNAL_UG_MAX) {
  98                 VideoLogInfo
  99                     ("Return hardkey callback function because of no UG mode.");
 100                 return EINA_FALSE;
 101         }
 102
 103         Ecore_Event_Key *pKeyEvent = (Ecore_Event_Key *) pEvent;
 104
 105         if (!strcmp(pKeyEvent->keyname, KEY_END)) {
 106                 VideoLogInfo("Bakc(End) key");
 107                 MpExternalUgUnload();
 108                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 109         }
 110         if (!strcmp(pKeyEvent->keyname, HOME_KEY)) {
 111                 VideoLogInfo("Home key");
 112                 MpExternalUgUnload();
 113                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 114         }
 115
 116         return EINA_FALSE;
 117 }
 118
 119 void MpExternalUgLayoutCb(ui_gadget_h pUiGadget, enum ug_mode nMode, void *pUserData)
 120 {
 121         VideoLogInfo("");
 122
 123         if (!pUserData) {
 124                 VideoLogInfo("[ERR]");
 125                 return;
 126         }
 127
 128         Evas_Object *pLayoutBase = NULL;
 129         Evas_Object *pWin = NULL;
 130
 131         pLayoutBase = ug_get_layout(pUiGadget);
 132         if (!pLayoutBase) {
 133                 ug_destroy(pUiGadget);
 134                 VideoLogError("[ERR]");
 135                 return;
 136         }
 137         pWin = ug_get_window();
 138
 139         switch (nMode) {
 140         case UG_MODE_FULLVIEW:
 141                 evas_object_size_hint_weight_set(pLayoutBase, EVAS_HINT_EXPAND,
 142                                                  EVAS_HINT_EXPAND);
 143                 elm_win_resize_object_add(pWin, pLayoutBase);
 144                 evas_object_show(pLayoutBase);
 145                 break;
 146
 147         default:
 148                 VideoLogInfo("[DEFAUT!!!!!!!!]");
 149                 break;
 150         }
 151 }
 152
 153 void MpExternalUgResultCb(ui_gadget_h pUiGadget, service_h pService, void *pUserData)
 154 {
 155         VideoLogInfo("");
 156
 157         if (!pUserData) {
 158                 VideoLogInfo("[ERR]");
 159                 return;
 160         }
 161 }
 162
 163 void MpExternalUgDestroyCb(ui_gadget_h pUiGadget, void *pUserData)
 164 {
 165         VideoLogInfo("");
 166
 167         if (!pUserData) {
 168                 VideoLogInfo("[ERR]");
 169                 return;
 170         }
 171
 172         VideoAppData *pAppData = (VideoAppData *)pUserData;
 173
 174         MpExternalUgUnload();
 175
 176         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowLayout(pAppData);
 177 }
 178
 179 static void MpExternalUGDestroyPopupList(void)
 180 {
 181         VideoLogInfo("");
 182         int nCount = 0;
 183         if(szUgItems)
 184         {
 185                 for(nCount = 0; nCount < MP_EXTERNAL_UG_MAX; nCount++)
 186                 {
 187                         if(szUgItems[nCount])
 188                         {
 189                                 free(szUgItems[nCount]);
 190                                 szUgItems[nCount] = NULL;
 191                         }
 192                 }
 193                 free(szUgItems);
 194                 szUgItems = NULL;
 195         }
 196
 197         if(pUGGenList)
 198         {
 199                 evas_object_del(pUGGenList);
 200                 pUGGenList = NULL;
 201         }
 202
 203         if(pUGPopupHandle) {
 204                 evas_object_del(pUGPopupHandle);
 205                 pUGPopupHandle = NULL;
 206         }
 207
 208         MpUtilSetAlphaOfMainWindow(TRUE);
 209 }
 210
 211
 212 static void MpExternalUGPopupCb(void *pUserData, Evas_Object *pObject,
 213                                      void *pEventInfo)
 214 {
 215         VideoLogInfo("");
 216
 217         if(pUserData == NULL)
 218         {
 219                 VideoLogInfo("[ERR]No have pUserData");
 220                 return;
 221         }
 222
 223         VideoAppData *pAppData = (VideoAppData *)pUserData;
 224
 225         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowLayout(pAppData);
 226
 227         MpExternalUGDestroyPopupList();
 228 }
 229
 230 static void MpExternalUgResFn(service_h pRequest, service_h pReply, service_result_e nResult, void *pUserData)
 231 {
 232         if(!pUserData)
 233 {
 234                 VideoLogInfo("[ERR]");
 235                 return;
 236         }
 237
 238         VideoLogInfo("");
 239
 240         VideoAppData *pAppData = (VideoAppData *)pUserData;
 241
 242         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowLayout(pAppData);
 243 }
 244
 245 static void MpExternalUGAppSvcLoad(MpExternalUGType nExternalUGType, void *pUserData)
 246 {
 247
 248         VideoLogInfo("");
 249
 250         if (pUserData == NULL) {
 251                 VideoLogInfo("[ERR]No have pUserData");
 252                 return;
 253         }
 254
 255         VideoAppData *pAppData = (VideoAppData *)pUserData;
 256
 257         service_h pServiceHandle = NULL;
 258         int     ret_val = 0;
 259         char    pkg_name[STR_LEN_MAX] = {0,};
 260
 261         if(service_create(&pServiceHandle) != SERVICE_ERROR_NONE)
 262         {
 263                 VideoLogInfo("[ERR]service_create(&pServiceHandle)");
 264                 return;
 265         }
 266
 267         switch(nExternalUGType)
 268         {
 269                 case MP_EXTERNAL_UG_YOUTUBE:
 270                         strncpy(pkg_name,"org.tizen.youtube",STR_LEN_MAX-1);
 271                         break;
 272
 273                 case MP_EXTERNAL_UG_FACEBOOK:
 274                         strncpy(pkg_name,"org.tizen.facebook",STR_LEN_MAX-1);
 275                         break;
 276                 default:
 277                         break;
 278         }
 279
 280         if(service_set_operation(pServiceHandle, SERVICE_OPERATION_SEND) != SERVICE_ERROR_NONE)
 281         {
 282                 if(pServiceHandle)
 283                 {
 284                         service_destroy(pServiceHandle);
 285                 }
 286
 287                 VideoLogInfo("[ERR]service_set_operation fail.");
 288                 return;
 289         }
 290
 291         if(nExternalUGType == MP_EXTERNAL_UG_YOUTUBE)
 292         {
 293                 char xwin_id_str[12] = { 0, };
 294                 Ecore_X_Window xwin_id = (Ecore_X_Window)MpUtilGetMainWindowXID();
 295                 eina_convert_itoa(xwin_id, xwin_id_str);
 296                 VideoLogInfo("For YoutTube XID : %s", xwin_id_str);
 297                 service_add_extra_data(pServiceHandle, "XWINDOW_ID", xwin_id_str);
 298         }
 299
 300         if(service_set_mime(pServiceHandle, "video/*") != SERVICE_ERROR_NONE)
 301         {
 302                 if(pServiceHandle)
 303         {
 304                         service_destroy(pServiceHandle);
 305                 }
 306
 307                 VideoLogInfo("[ERR]service_set_mime fail.");
 308                 return;
 309         }
 310
 311         if(service_set_uri(pServiceHandle, pAppData->szMediaUri) != SERVICE_ERROR_NONE)
 312         {
 313                 if(pServiceHandle)
 314                 {
 315                         service_destroy(pServiceHandle);
 316                 }
 317
 318                 VideoLogInfo("[ERR]service_set_uri fail.");
 319                 return;
 320         }
 321
 322
 323         if(service_set_package(pServiceHandle, pkg_name) != SERVICE_ERROR_NONE)
 324         {
 325                 if(pServiceHandle)
 326         {
 327                         service_destroy(pServiceHandle);
 328                 }
 329
 330                 VideoLogInfo("[ERR]service_set_package fail : %d", ret_val);
 331                 return;
 332         }
 333
 334         if(service_send_launch_request(pServiceHandle, MpExternalUgResFn, pUserData) != SERVICE_ERROR_NONE)
 335         {
 336                 if(pServiceHandle)
 337                 {
 338                         service_destroy(pServiceHandle);
 339         }
 340
 341                 VideoLogInfo("[ERR]service_send_launch_request fail : %d", ret_val);
 342                 return;
 343         }
 344
 345         service_destroy(pServiceHandle);
 346 }
 347
 348 static void MpExternalUGSelectListItem(void *pUserData,Evas_Object *pObject,void *pEventInfo)
 349 {
 350         VideoLogInfo("");
 351
 352         if(pUserData == NULL)
 353         {
 354                 VideoLogInfo("[ERR]No have pUserData");
 355                 return;
 356         }
 357
 358         Elm_Object_Item *pItem = (Elm_Object_Item *) pEventInfo;
 359
 360         if(pItem)
 361         {
 362                 int nIndex = 0;
 363                 nIndex = (int)elm_object_item_data_get(pItem);
 364
 365                 VideoLogInfo("Select Controlbar item of popup : %d", nIndex);
 366
 367                 if(!strcmp(szUgItems[nIndex], MP_SHARE_MESSAGE))
 368                 {
 369                         MpExternalUgLoad(MP_EXTERNAL_UG_MESSAGE, pUserData);
 370                 }
 371                 else if(!strcmp(szUgItems[nIndex], MP_SHARE_EMAIL))
 372                 {
 373                         MpExternalUgLoad(MP_EXTERNAL_UG_EMAIL, pUserData);
 374                 }
 375                 else if(!strcmp(szUgItems[nIndex], MP_SHARE_BLUETOOTH))
 376                 {
 377                         MpExternalUgLoad(MP_EXTERNAL_UG_BLUETOOTH, pUserData);
 378                 }
 379                 else if(!strcmp(szUgItems[nIndex], MP_SHARE_FTM))
 380                 {
 381                         MpExternalUgLoad(MP_EXTERNAL_UG_FTM, pUserData);
 382                 }
 383                 else if(!strcmp(szUgItems[nIndex], MP_SHARE_FACEBOOK))
 384                 {
 385                         MpExternalUGAppSvcLoad(MP_EXTERNAL_UG_FACEBOOK, pUserData);
 386                 }
 387                 else if(!strcmp(szUgItems[nIndex], MP_SHARE_YOUTUBE))
 388                 {
 389                         MpExternalUGAppSvcLoad(MP_EXTERNAL_UG_YOUTUBE, pUserData);
 390                 }
 391
 392         }
 393         VideoAppData *pAppData = (VideoAppData *)pUserData;
 394         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 395
 396         MpExternalUGDestroyPopupList();
 397 }
 398
 399 /*
 400  * External Function
 401  */
 402 bool MpExternalUgLoad(MpExternalUGType nExternalUGType, void *pUserData)
 403 {
 404         VideoLogInfo("");
 405
 406         if (!pUserData) {
 407                 VideoLogInfo("[ERR]");
 408                 return FALSE;
 409         }
 410
 411         VideoAppData *pAppData = (VideoAppData *)pUserData;
 412
 413         struct ug_cbs cbs = { 0, };
 414         service_h pService;  //bundle *pBundleHandle = NULL;
 415
 416
 417         cbs.layout_cb = MpExternalUgLayoutCb;
 418         cbs.result_cb = MpExternalUgResultCb;
 419         cbs.destroy_cb = MpExternalUgDestroyCb;
 420         cbs.priv = (void *)pAppData;
 421
 422         service_create(&pService); //pBundleHandle = bundle_create();
 423
 424         UG_INIT_EFL(pAppData->pMainWindow, UG_OPT_INDICATOR_ENABLE);
 425
 426         if(pUiGadgetHandle)
 427         {
 428                 MpExternalUgUnload();
 429         }
 430
 431         switch (nExternalUGType)
 432         {
 433         case MP_EXTERNAL_UG_MESSAGE:
 434                 VideoLogInfo("MP_EXTERNAL_UG_MESSAGE");
 435                 //bundle_add(pBundleHandle, "ATTACHFILE", pAppData->szMediaUri);
 436                 service_add_extra_data(pService, "ATTACHFILE", pAppData->szMediaUri);
 437                 break;
 438
 439         case MP_EXTERNAL_UG_EMAIL:
 440                 VideoLogInfo("MP_EXTERNAL_UG_EMAIL");
 441                 //bundle_add(pBundleHandle, "RUN_TYPE", "5");
 442                 service_add_extra_data(pService, "RUN_TYPE", "5");
 443                 //bundle_add(pBundleHandle, "ATTACHMENT", pAppData->szMediaUri);
 444                 service_add_extra_data(pService, "ATTACHMENT", pAppData->szMediaUri);
 445                 break;
 446
 447         case MP_EXTERNAL_UG_MYFILE_DETAIL:
 448                 VideoLogInfo("MP_EXTERNAL_UG_MYFILE_DETAIL");
 449                 //bundle_add(pBundleHandle, "Path", pAppData->szMediaUri);
 450                 service_add_extra_data(pService, "Path", pAppData->szMediaUri);
 451                 break;
 452
 453         case MP_EXTERNAL_UG_YOUTUBE:
 454                 VideoLogInfo("MP_EXTERNAL_UG_YOUTUBE");
 455                 //bundle_add(pBundleHandle, "feature", "video_upload");
 456                 service_add_extra_data(pService, "feature", "video_upload");
 457                 //bundle_add(pBundleHandle, "video", pAppData->szMediaUri);
 458                 service_add_extra_data(pService, "video", pAppData->szMediaUri);
 459                 break;
 460
 461         case MP_EXTERNAL_UG_FACEBOOK:
 462                 VideoLogInfo("MP_EXTERNAL_UG_FACEBOOK");
 463                 //bundle_add(pBundleHandle, "feature", "video_upload");
 464                 service_add_extra_data(pService, "feature", "video_upload");
 465                 //bundle_add(pBundleHandle, "video", pAppData->szMediaUri);
 466                 service_add_extra_data(pService, "video", pAppData->szMediaUri);
 467                 break;
 468
 469         case MP_EXTERNAL_UG_BLUETOOTH:
 470                 VideoLogInfo("MP_EXTERNAL_UG_BLUETOOTH");
 471                 //bundle_add(pBundleHandle, "launch-type", "send");
 472                 service_add_extra_data(pService, "launch-type", "send");
 473                 //bundle_add(pBundleHandle, "filecount", "1");
 474                 service_add_extra_data(pService, "filecount", "1");
 475                 //bundle_add(pBundleHandle, "files", pAppData->szMediaUri);
 476                 service_add_extra_data(pService, "files", pAppData->szMediaUri);
 477                 break;
 478
 479         case MP_EXTERNAL_UG_FTM:
 480                 VideoLogInfo("MP_EXTERNAL_UG_FTM");
 481                 //bundle_add(pBundleHandle, "filecount", "1");
 482                 service_add_extra_data(pService, "filecount", "1");
 483                 //bundle_add(pBundleHandle, "files", pAppData->szMediaUri);
 484                 service_add_extra_data(pService, "files", pAppData->szMediaUri);
 485                 break;
 486
 487         default:
 488                 service_destroy(pService); //bundle_free(pBundleHandle);
 489                 return FALSE;
 490         }
 491
 492         pUiGadgetHandle = ug_create(NULL, st_MpExternalUG[nExternalUGType].szUgName, UG_MODE_FULLVIEW, pService, &cbs);
 493
 494         nCurUGType = nExternalUGType;
 495
 496         service_destroy(pService); //bundle_free(pBundleHandle);
 497
 498         pHardKeyEventHandler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, (void *)MpExternalUgHardkeyDownCb, pUserData);
 499
 500         /*  !!!!!SET ROTATE STATE!!!!!  */
 501
 502         return TRUE;
 503 }
 504
 505 void MpExternalUgUnload(void)
 506 {
 507         VideoLogInfo("");
 508
 509         MpExternalUGDestroyPopupList();
 510
 511         if (pHardKeyEventHandler) {
 512                 ecore_event_handler_del(pHardKeyEventHandler);
 513                 pHardKeyEventHandler = NULL;
 514         }
 515
 516         if (pUiGadgetHandle) {
 517                 ug_destroy(pUiGadgetHandle);
 518                 pUiGadgetHandle = NULL;
 519         }
 520
 521         nCurUGType = MP_EXTERNAL_UG_NONE;
 522 }
 523
 524 void MpExternalUgDestroyAll(void)
 525 {
 526         VideoLogInfo("");
 527
 528         MpExternalUGDestroyPopupList();
 529
 530         ug_destroy_all();
 531 }
 532
 533 int MpExternalUgGetCurUgState()
 534 {
 535         VideoLogInfo("");
 536
 537         return (int)nCurUGType;
 538 }
 539
 540 void MpExternalUgSetUgState(MpExternalUGType nExternalUGType)
 541 {
 542         VideoLogInfo("");
 543
 544         nCurUGType = nExternalUGType;
 545 }
 546
 547 bool MpExternalUgShow(void *pUserData, void *pParent)
 548 {
 549         VideoLogInfo("");
 550
 551         if (!pUserData) {
 552                 VideoLogInfo("[ERR]");
 553                 return FALSE;
 554         }
 555
 556         VideoAppData *pAppData = (VideoAppData *)pUserData;
 557         Evas_Object *pButton = NULL;
 558         Evas_Object *pBox = NULL;
 559
 560         MpExternalUGDestroyPopupList();
 561
 562         MpUtilSetAlphaOfMainWindow(FALSE);
 563
 564         pUGPopupHandle = elm_popup_add(pAppData->pMainWindow);
 565         elm_object_style_set(pUGPopupHandle, "menustyle");
 566         elm_object_part_text_set(pUGPopupHandle, "title,text", MP_COM_BUTTON_SHARE);
 567         evas_object_size_hint_weight_set(pUGPopupHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 568
 569         pButton = elm_button_add(pUGPopupHandle);
 570         elm_object_style_set (pButton, "popup_button/default");
 571         elm_object_text_set(pButton, MP_COM_CLOSE);
 572         elm_object_part_content_set(pUGPopupHandle, "button1", pButton);
 573         evas_object_smart_callback_add(pButton, "clicked", MpExternalUGPopupCb, (void*)pAppData);
 574
 575         Elm_Genlist_Item_Class *st_Share_Itc = NULL;
 576
 577         st_Share_Itc = elm_genlist_item_class_new();
 578
 579         st_Share_Itc->item_style = "1text";
 580         st_Share_Itc->func.text_get = (void *)MpExternalUgGetLabelOfGenlistItemCb;
 581         st_Share_Itc->func.content_get = NULL;
 582         st_Share_Itc->func.state_get = NULL;
 583         st_Share_Itc->func.del = NULL;
 584         /* Create genlist handle */
 585         pUGGenList = elm_genlist_add(pUGPopupHandle);
 586         evas_object_size_hint_weight_set(pUGGenList, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 587         evas_object_size_hint_align_set(pUGGenList, EVAS_HINT_FILL, EVAS_HINT_FILL);
 588
 589         szUgItems = (char **)calloc(1, sizeof(char *) * MP_EXTERNAL_UG_MAX);
 590         int idx = 0;
 591         for(idx = 0; idx < MP_EXTERNAL_UG_MAX; idx++)
 592         {
 593                 szUgItems[idx] = (char *)calloc(1, STR_LEN_MAX * sizeof(char));
 594         }
 595
 596         /* Set Sound alive string */
 597         strncpy(szUgItems[MP_EXTERNAL_UG_MESSAGE], MP_SHARE_MESSAGE, STR_LEN_MAX - 1);
 598         strncpy(szUgItems[MP_EXTERNAL_UG_EMAIL], MP_SHARE_EMAIL, STR_LEN_MAX - 1);
 599         strncpy(szUgItems[MP_EXTERNAL_UG_BLUETOOTH], MP_SHARE_BLUETOOTH, STR_LEN_MAX - 1);
 600         strncpy(szUgItems[MP_EXTERNAL_UG_FTM], MP_SHARE_FTM, STR_LEN_MAX - 1);
 601         strncpy(szUgItems[MP_EXTERNAL_UG_YOUTUBE], MP_SHARE_YOUTUBE, STR_LEN_MAX - 1);
 602         strncpy(szUgItems[MP_EXTERNAL_UG_FACEBOOK], MP_SHARE_FACEBOOK, STR_LEN_MAX - 1);
 603
 604         elm_genlist_item_append(pUGGenList, st_Share_Itc, (void *)MP_EXTERNAL_UG_MESSAGE, NULL, ELM_GENLIST_ITEM_NONE, MpExternalUGSelectListItem, pAppData);
 605         elm_genlist_item_append(pUGGenList, st_Share_Itc, (void *)MP_EXTERNAL_UG_EMAIL, NULL, ELM_GENLIST_ITEM_NONE, MpExternalUGSelectListItem, pAppData);
 606         elm_genlist_item_append(pUGGenList, st_Share_Itc, (void *)MP_EXTERNAL_UG_BLUETOOTH, NULL, ELM_GENLIST_ITEM_NONE, MpExternalUGSelectListItem, pAppData);
 607
 608         elm_genlist_item_class_free(st_Share_Itc);
 609
 610         pBox = elm_box_add(pUGPopupHandle);
 611         evas_object_size_hint_min_set(pBox, 614 * elm_config_scale_get(), 338 * elm_config_scale_get());
 612
 613         elm_box_pack_end(pBox, pUGGenList);
 614         elm_object_content_set(pUGPopupHandle, pBox);
 615
 616
 617         evas_object_show(pUGGenList);
 618         evas_object_show(pUGPopupHandle);
 619
 620
 621         return TRUE;
 622 }
 623 void MpExternalUgHide()
 624 {
 625         MpExternalUGDestroyPopupList();
 626 }
 627
 628