src/mp-util.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 // CAPI
  19 #include <app.h>
  20 #include <sound_manager.h>
  21
  22 #include <aul.h>
  23 #include <glib.h>
  24 #include <errno.h>
  25 #include <vconf.h>
  26 #include <pmapi.h>
  27 #include <utilX.h>
  28 #include <unistd.h>
  29 #include <E_DBus.h>
  30 #include <signal.h>
  31 #include <Ecore_X.h>
  32 #include <ui-gadget.h>
  33 #include <Ecore_Evas.h>
  34 #include <vconf-keys.h>
  35
  36 #include "mp-util.h"
  37 #include "mp-video-log.h"
  38 #include "mp-util-media-service.h"
  39 #include "mp-video-type-define.h"
  40 #include "mp-video-value-define.h"
  41 #include "mp-video-string-define.h"
  42 //#include "mp-video-info-ctrl.h"
  43
  44 #define MP_LAUNCH_BLUETOOTH_PACKAGE_NAME                "org.tizen.bluetooth"
  45
  46 #define MP_UTIL_USER_AGENT_KEY                  "db/admin/uagent"
  47 //#define MP_UTIL_TEMP_USER_AGENT_VALUE "User-Agent: Mozilla/5.0 (Linux; U; Android 2.2; en-gb; GT-I9000 Build/FROYO) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1"
  48 #define MP_UTIL_TEMP_USER_AGENT_VALUE   "Mozilla/5.0 (SAMSUNG; SAMSUNG-GT-S8500/1.0; U; Bada/1.0; en-us) AppleWebKit/533.1 (KHTML, like Gecko) Dolfin/2.0 Mobile WVGA SMM-MMS/1.2.0 OPN-B"
  49 #define MP_UTIL_MMC_PATH                "/opt/storage/sdcard"
  50 #define MP_UTIL_FILE_PREFIX             "file://"
  51
  52 #define MP_UTIL_ALLSHARE_CHANGE_NOTI    "memory/allshare/status"
  53 #define MP_UTIL_ALLSHARE_NOTI_ON        1
  54 #define MP_UTIL_ALLSHARE_NOTI_OFF       0
  55
  56 #define MP_UTIL_VCONF_KEY_PREVIEW_URL_VIDEOS    "db/private/org.tizen.video-player/preview_url_videos"
  57 #define MP_UTIL_VCONF_KEY_PREVIEW_URL_RECORDS   "db/private/org.tizen.video-player/preview_url_records"
  58
  59 static bool bAlphaSet = TRUE;
  60
  61 static Ecore_X_Window pMainXwindow = 0;
  62 static Ecore_X_Display *pX11DisplayHandle = NULL;
  63
  64 static Evas_Object *pPopUpHandle = NULL;
  65 static Evas_Object *pPopupWindow = NULL;
  66
  67 static MpVideoRotateType nCurRotateValue = VIDEO_ROTATE_PORTRAIT_NORMAL;
  68
  69 /*
  70  * Callback function
  71  */
  72
  73 static void MpUtilBatteryStatusChangeCb(keynode_t *pKeyNode, void *pUserData)
  74 {
  75         VideoLogInfo("");
  76
  77         int nLowBatteryStatus = 0;
  78
  79         if (!pUserData) {
  80                 VideoLogInfo("User data is NULL.");
  81                 return;
  82         }
  83
  84         VideoAppData *pAppData = (VideoAppData *)pUserData;
  85
  86         if (!vconf_get_int
  87             (VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &nLowBatteryStatus)) {
  88                 if (nLowBatteryStatus <= VCONFKEY_SYSMAN_BAT_POWER_OFF) {
  89                         /* MpUtilNotifyPopUp(pAppData, MP_COM_BODY_LOW_BATTERY, MpUtilBatteryExitCb); */
  90                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
  91                         return;
  92                 }
  93         } else {
  94                 VideoLogInfo("Fail to get vconf");
  95         }
  96 }
  97
  98 static void MpUtilMMCStatusChangeCb(keynode_t * pKeyNode, void *pUserData)
  99 {
 100         VideoLogInfo("");
 101
 102         char szFilename[9] = { 0 };
 103
 104         if (!pUserData || !pKeyNode) {
 105                 VideoLogInfo("User data is NULL.");
 106                 return;
 107         }
 108
 109         VideoAppData *pAppData = (VideoAppData *)pUserData;
 110         char *keyname = vconf_keynode_get_name(pKeyNode);
 111         if (strcmp(keyname, VCONFKEY_FILEMANAGER_DB_STATUS) == 0) {
 112                 int nMMCState = vconf_keynode_get_int(pKeyNode);
 113                 if (nMMCState == VCONFKEY_FILEMANAGER_DB_UPDATED) {
 114                         strncpy(szFilename, pAppData->szMediaUri, sizeof(szFilename) - 1);
 115                         VideoLogInfo("FILE NAME[%s]", szFilename);
 116                         if (!strcmp(MP_UTIL_MMC_PATH, szFilename)) {
 117                                 /* MpUtilNotifyPopUp(pAppData, "MMC card is ejected", NULL); */
 118                                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 119                         }
 120                 }
 121         } else {
 122                 VideoLogInfo("Fail to get vconf");
 123         }
 124 }
 125
 126 /*
 127  * External function
 128  */
 129
 130 void MpUtilExitVideoPlayer(void)
 131 {
 132         VideoLogInfo("");
 133
 134         elm_exit();
 135 }
 136
 137 static void MpUtilDestroyMainWindow(void *pUserData, Evas_Object *pEvasObject,
 138                                     void *pEvent)
 139 {
 140         VideoLogInfo("");
 141
 142         MpUtilExitVideoPlayer();
 143 }
 144
 145 void MpUtilResetForRelaunching(void)
 146 {
 147         VideoLogInfo("");
 148
 149         pX11DisplayHandle = NULL;
 150         pPopUpHandle = NULL;
 151         pPopupWindow = NULL;
 152 }
 153
 154 void MpUtilSetAlphaOfMainWindow(bool bSetAlpha)
 155 {
 156         VideoLogInfo("");
 157
 158         if(bSetAlpha)
 159         {
 160         }
 161         else
 162         {
 163         }
 164         bAlphaSet = bSetAlpha;
 165 }
 166
 167 void *MpUtilCreateMainWindow(const char *pStrName)
 168 {
 169         VideoLogInfo("");
 170
 171         if (!pStrName) {
 172                 VideoLogInfo("[ERR] No exist pStrName.");
 173                 return NULL;
 174         }
 175
 176         if (pMainXwindow) {
 177                 evas_object_del((Evas_Object *)pMainXwindow);
 178                 pMainXwindow = 0;
 179         }
 180
 181         Evas_Object *pEvasObject;
 182
 183         pEvasObject = elm_win_add(NULL, pStrName, ELM_WIN_BASIC);
 184         if (pEvasObject) {
 185                 elm_win_title_set(pEvasObject, pStrName);
 186                 evas_object_smart_callback_add(pEvasObject, "delete,request",
 187                                                MpUtilDestroyMainWindow, NULL);
 188                 elm_win_borderless_set(pEvasObject, EINA_FALSE);
 189         }
 190
 191         Evas *pEvas = evas_object_evas_get(pEvasObject);
 192         Evas_Object *pMainRect = evas_object_rectangle_add(pEvas);
 193
 194         if (pMainRect)
 195         {
 196                 evas_object_size_hint_weight_set(pMainRect, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 197                 evas_object_color_set(pMainRect, 0, 0, 0, 0);
 198                 evas_object_render_op_set(pMainRect, EVAS_RENDER_COPY);
 199                 evas_object_show(pMainRect);
 200                 elm_win_resize_object_add(pEvasObject, pMainRect);
 201         }
 202         pMainXwindow = elm_win_xwindow_get(pEvasObject);
 203
 204         return (void *)pEvasObject;
 205 }
 206
 207 int MpUtilSetKeyGrab(const char *szKeyName, int nGrabMode)
 208 {
 209         VideoLogInfo("");
 210         if (!pX11DisplayHandle) {
 211                 pX11DisplayHandle = ecore_x_display_get();
 212         }
 213
 214         if (!pMainXwindow) {
 215                 VideoLogInfo("Not exist pMainXwindow.");
 216         }
 217
 218         utilx_grab_key(pX11DisplayHandle, pMainXwindow, szKeyName, nGrabMode);
 219         return TRUE;
 220 }
 221
 222 int MpUtilSetKeyUngrab(const char *szKeyName)
 223 {
 224         VideoLogInfo("");
 225         if (pMainXwindow && pX11DisplayHandle) {
 226                 utilx_ungrab_key(pX11DisplayHandle, pMainXwindow, szKeyName);
 227         }
 228         return TRUE;
 229 }
 230
 231
 232 bool MpUtilCheckRTSPType(char *szUriPath)
 233 {
 234         if(szUriPath == NULL) {
 235                 VideoLogInfo("ERR:");
 236                 return FALSE;
 237         }
 238
 239         //VideoLogInfo(" URI : %s", szUriPath);
 240
 241         if (strstr(szUriPath, "rtp"))
 242                 return TRUE;
 243         else if (strstr(szUriPath, "rtsp"))
 244                 return TRUE;
 245
 246         return FALSE;
 247 }
 248
 249 int MpUtilCheckUriType(char *szUriPath)
 250 {
 251         if(szUriPath == NULL) {
 252                 VideoLogInfo("ERR:");
 253                 return FALSE;
 254         }
 255
 256         VideoLogInfo(" URI : %s", szUriPath);
 257
 258         if (strstr(szUriPath, "rtp"))
 259                 return 1;
 260         else if (strstr(szUriPath, "rtsp"))
 261                 return 1;
 262         else if (strstr(szUriPath, "http"))
 263                 return 1;
 264         else if (strstr(szUriPath, "https"))
 265                 return 1;
 266
 267         return 0;
 268 }
 269
 270 bool MpUtilCheckLocalFileExist(char *uri)
 271 {
 272         VideoLogInfo("");
 273
 274         if(uri == NULL)
 275         {
 276                 VideoLogInfo("[ERR]");
 277                 return FALSE;
 278         }
 279
 280         if(strstr(uri,MP_UTIL_FILE_PREFIX))
 281         {
 282                 if (!g_file_test(uri+strlen(MP_UTIL_FILE_PREFIX), G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
 283                 {
 284                         return FALSE;
 285                 }
 286                 return TRUE;
 287         }
 288         else
 289         {
 290                 if(!g_file_test(uri, G_FILE_TEST_EXISTS | G_FILE_TEST_IS_REGULAR))
 291                 {
 292                         return FALSE;
 293                 }
 294                 return TRUE;
 295         }
 296 }
 297
 298 bool MpUtilCheckBatteryStatus(void)
 299 {
 300         VideoLogInfo("");
 301
 302         int nLowBatteryStatus = 0;
 303
 304         if (!vconf_get_int
 305             (VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, &nLowBatteryStatus)) {
 306                 if (nLowBatteryStatus <= VCONFKEY_SYSMAN_BAT_POWER_OFF) {
 307                         return FALSE;
 308                 }
 309         }
 310
 311         return TRUE;
 312 }
 313
 314 int MpUtilBatteryStatusNoti(VideoAppData *pAppData)
 315 {
 316         VideoLogInfo("");
 317
 318         if(!pAppData)
 319         {
 320                 VideoLogInfo("[ERR] No exist appdata.");
 321                 return FALSE;
 322         }
 323
 324         if(vconf_notify_key_changed(VCONFKEY_SYSMAN_BATTERY_STATUS_LOW, MpUtilBatteryStatusChangeCb, pAppData))
 325         {
 326                 VideoLogInfo("[ERR] Fail to set Battery notification.");
 327                 /* return FALSE; */
 328         }
 329
 330         return TRUE;
 331 }
 332
 333 int MpUtilBatteryStatusNotiIgnore(void)
 334 {
 335         VideoLogInfo("");
 336
 337         if (vconf_ignore_key_changed
 338             (VCONFKEY_SYSMAN_BATTERY_STATUS_LOW,
 339              MpUtilBatteryStatusChangeCb) < 0) {
 340                 VideoLogInfo("[ERR] Fail to ignore battery status.");
 341                 return FALSE;
 342         }
 343
 344         return TRUE;
 345 }
 346
 347 int MpUtilMMCstatusNoti(VideoAppData *pAppData)
 348 {
 349         VideoLogInfo("");
 350
 351         if (!pAppData) {
 352                 VideoLogInfo("[ERR] No exist appdata.");
 353                 return FALSE;
 354         }
 355
 356         if (vconf_notify_key_changed
 357             (VCONFKEY_FILEMANAGER_DB_STATUS, MpUtilMMCStatusChangeCb,
 358              pAppData) < 0) {
 359                 VideoLogInfo("[ERR] Fail to set MMC notification.");
 360                 //return FALSE;
 361         }
 362
 363         return TRUE;
 364 }
 365
 366 int MpUtilMMCstatusNotiIgnore(void)
 367 {
 368         VideoLogInfo("");
 369
 370         if (vconf_ignore_key_changed
 371             (VCONFKEY_FILEMANAGER_DB_STATUS, MpUtilMMCStatusChangeCb) < 0) {
 372                 VideoLogInfo("[ERR] Fail to ignore MMC status.");
 373                 //return FALSE;
 374         }
 375
 376         return TRUE;
 377 }
 378
 379 int MpUtilGetRotationStateFromAppcore(void)
 380 {
 381         VideoLogInfo("");
 382         int bLocked = -1;
 383
 384         if (vconf_get_bool(VCONFKEY_SETAPPL_ROTATE_LOCK_BOOL, &bLocked) != 0)
 385         {
 386                 VideoLogInfo("Get vlalue fail");
 387                 return nCurRotateValue;
 388         }
 389
 390         if(bLocked == false)
 391         {
 392                 switch(app_get_device_orientation())
 393                 {
 394                 case APP_DEVICE_ORIENTATION_0:
 395                         VideoLogInfo("VIDEO_ROTATE_PORTRAIT_NORMAL");
 396                         nCurRotateValue = VIDEO_ROTATE_PORTRAIT_NORMAL;
 397                         break;
 398
 399                 case APP_DEVICE_ORIENTATION_90:
 400                         VideoLogInfo("VIDEO_ROTATE_PORTRAIT_REVERSE");
 401                         nCurRotateValue = VIDEO_ROTATE_LANDSCAPE_REVERSE;
 402                         break;
 403
 404                 case APP_DEVICE_ORIENTATION_180:
 405                         VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_NORMAL");
 406                         nCurRotateValue = VIDEO_ROTATE_PORTRAIT_REVERSE;
 407                         break;
 408
 409                 case APP_DEVICE_ORIENTATION_270:
 410                         VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_REVERSE");
 411                         nCurRotateValue = VIDEO_ROTATE_LANDSCAPE_NORMAL;
 412                         break;
 413                 }
 414         }
 415         return nCurRotateValue;
 416 }
 417
 418 int MpUtilGetRotationState(void)
 419 {
 420         VideoLogInfo("");
 421
 422         return nCurRotateValue;
 423 }
 424
 425 void MpUtilSetRotationState(int nCurRotation)
 426 {
 427         VideoLogInfo("");
 428
 429         nCurRotateValue = nCurRotation;
 430
 431         if (pPopupWindow) {
 432                 MpUtilRotateWindow(nCurRotation, pPopupWindow);
 433         }
 434 }
 435
 436 bool MpUtilGetTitleFromFilepath(char *szFilepath, char *szTitle, int nLengthTitle)
 437 {
 438         VideoLogInfo("");
 439
 440         if (!szFilepath || !szTitle) {
 441                 VideoLogInfo("[ERR]");
 442                 return FALSE;
 443         }
 444
 445         char *szTitleName;
 446         char *szExt;
 447
 448         memset(szTitle, 0, nLengthTitle);
 449
 450         szTitleName = strrchr(szFilepath, '/');
 451
 452         if (szTitleName)
 453                 szTitleName++;
 454         else
 455                 szTitleName = szFilepath;
 456
 457         szExt = strrchr(szTitleName, '.');
 458
 459         if (szExt) {
 460                 int nTmpStringSize = szExt - szTitleName;
 461                 strncpy(szTitle, szTitleName, nTmpStringSize);
 462         } else {
 463                 strncpy(szTitle, szTitleName, STR_LEN_MAX - 1);
 464         }
 465
 466         return TRUE;
 467 }
 468
 469 void MpUtilInitSession(void)
 470 {
 471         VideoLogInfo("");
 472
 473         sound_manager_set_session_type(SOUND_SESSION_TYPE_EXCLUSIVE);
 474 }
 475
 476 void MpUtilFinishSession(void)
 477 {
 478         VideoLogInfo("");
 479         //sound_manager_set_session_type(SOUND_SESSION_TYPE_SHARE);
 480 }
 481
 482 /*
 483 void MpUtilVolumeTypeSet(void)
 484 {
 485         VideoLogInfo("");
 486
 487         sound_manager_set_volume_key_type(VOLUME_KEY_TYPE_MEDIA);
 488 }
 489
 490 void MpUtilVolumeTypeUnset(void)
 491 {
 492         VideoLogInfo("");
 493
 494          sound_manager_set_volume_key_type(VOLUME_KEY_TYPE_NONE);
 495 }
 496
 497 void MpUtilSetVolumeChangeCbUnset()
 498 {
 499         VideoLogInfo("");
 500
 501         sound_manager_unset_volume_changed_cb();
 502 }
 503 */
 504
 505 void MpUtilDeletePopupHandle(void)
 506 {
 507         VideoLogInfo("");
 508
 509         if (pPopUpHandle) {
 510                 evas_object_del(pPopUpHandle);
 511                 pPopUpHandle = NULL;
 512         } else {
 513                 VideoLogInfo("No exist popup.");
 514         }
 515
 516         if (pPopupWindow) {
 517                 evas_object_del(pPopupWindow);
 518                 pPopupWindow = NULL;
 519         } else {
 520                 VideoLogInfo("No exist popup window.");
 521         }
 522
 523         MpUtilSetAlphaOfMainWindow(TRUE);
 524 }
 525
 526 bool MpUtilNotifyPopUp(VideoAppData *pAppData, char *szContents, void *PopupButtonCallbackFunc)
 527 {
 528         VideoLogInfo("");
 529
 530         if (pAppData == NULL || szContents == NULL) {
 531                 VideoLogInfo("No have popup message or pAppData is null.");
 532                 return FALSE;
 533         }
 534
 535         MpUtilDeletePopupHandle();
 536
 537         MpUtilSetAlphaOfMainWindow(FALSE);
 538
 539         pPopUpHandle = elm_popup_add(pAppData->pMainWindow);
 540
 541         evas_object_size_hint_weight_set(pPopUpHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 542         elm_object_text_set(pPopUpHandle, szContents);
 543         elm_object_part_text_set(pPopUpHandle, "title,text", MP_COM_POP_ERROR);
 544         elm_popup_timeout_set(pPopUpHandle, 3.0);
 545
 546         if(PopupButtonCallbackFunc)
 547         {
 548                 evas_object_smart_callback_add(pPopUpHandle, "timeout", PopupButtonCallbackFunc, (void *)pAppData);
 549         }
 550
 551         if(pPopupWindow)
 552         {
 553                 MpUtilRotateWindow(MpUtilGetRotationState(), pPopupWindow);
 554         }
 555
 556         evas_object_show(pPopUpHandle);
 557
 558         return TRUE;
 559 }
 560
 561 bool MpUtilWarinigPopUp(VideoAppData *pAppData, char *szContents,
 562                        void *PopupButtonCallbackFunc)
 563 {
 564         VideoLogInfo("");
 565
 566         if (pAppData == NULL || szContents == NULL) {
 567                 VideoLogInfo("No have popup message or pAppData is null.");
 568                 return FALSE;
 569         }
 570
 571         MpUtilDeletePopupHandle();
 572
 573         MpUtilSetAlphaOfMainWindow(FALSE);
 574
 575         pPopUpHandle = elm_popup_add(pAppData->pMainWindow);
 576
 577         evas_object_size_hint_weight_set(pPopUpHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 578         elm_object_text_set(pPopUpHandle, szContents);
 579         elm_object_part_text_set(pPopUpHandle, "title,text", MP_COM_POP_ERROR);
 580         elm_popup_timeout_set(pPopUpHandle, 3.0);
 581
 582         if (PopupButtonCallbackFunc) {
 583                 evas_object_smart_callback_add(pPopUpHandle, "timeout", PopupButtonCallbackFunc, (void *)pAppData);
 584         }
 585
 586         evas_object_show(pPopUpHandle);
 587
 588         return TRUE;
 589 }
 590
 591
 592 bool MpUtilYesNoPopUp(VideoAppData *pAppData, char *szTitle, char *szContents, void *PopupYesButtonCallbackFunc, void *PopupNoButtonCallbackFunc)
 593 {
 594         VideoLogInfo("");
 595
 596         if(szTitle == NULL || szContents == NULL || pAppData == NULL)
 597         {
 598                 VideoLogInfo("No have popup message or pAppData is null.");
 599                 return FALSE;
 600         }
 601
 602         Evas_Object *pButton = NULL;
 603
 604         MpUtilDeletePopupHandle();
 605
 606         MpUtilSetAlphaOfMainWindow(FALSE);
 607
 608         pPopUpHandle = elm_popup_add(pAppData->pMainWindow);
 609
 610         evas_object_size_hint_weight_set(pPopUpHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 611         elm_object_text_set(pPopUpHandle, szContents);
 612         elm_object_part_text_set(pPopUpHandle, "title,text", szTitle);
 613
 614         pButton = elm_button_add(pPopUpHandle);
 615         elm_object_style_set ( pButton, "popup_button/default");
 616         elm_object_text_set(pButton, MP_COM_SK_YES);
 617         elm_object_part_content_set(pPopUpHandle, "button1", pButton);
 618
 619         if(PopupYesButtonCallbackFunc)
 620         {
 621                 evas_object_smart_callback_add(pButton, "clicked", PopupYesButtonCallbackFunc, (void*)pAppData);
 622         }
 623
 624         pButton = elm_button_add(pPopUpHandle);
 625         elm_object_text_set(pButton, MP_COM_SK_NO);
 626         elm_object_style_set ( pButton, "popup_button/default");
 627         elm_object_part_content_set(pPopUpHandle, "button2", pButton);
 628
 629         if(PopupNoButtonCallbackFunc)
 630         {
 631                 evas_object_smart_callback_add(pButton, "clicked", PopupNoButtonCallbackFunc, (void*)pAppData);
 632         }
 633
 634         //elm_popup_timeout_set(pPopUpHandle, 3.0);
 635
 636         evas_object_show(pPopUpHandle);
 637
 638         return TRUE;
 639 }
 640
 641 bool MpUtilRemoveQuestionPopUp(VideoAppData *pAppData, void *PopupDeleteButtonCallbackFunc, void *PopupCancelButtonCallbackFunc, void *pUserData)
 642 {
 643         VideoLogInfo("");
 644
 645         if(pAppData == NULL)
 646         {
 647                 VideoLogInfo("No have popup message or pAppData is null.");
 648                 return FALSE;
 649         }
 650
 651         Evas_Object *pButton = NULL;
 652
 653         MpUtilDeletePopupHandle();
 654
 655         MpUtilSetAlphaOfMainWindow(FALSE);
 656
 657         pPopUpHandle = elm_popup_add(pAppData->pMainWindow);
 658
 659         evas_object_size_hint_weight_set(pPopUpHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 660         elm_object_part_text_set(pPopUpHandle, "title,text", MP_COM_BODY_DELETE_Q);
 661
 662         pButton = elm_button_add(pPopUpHandle);
 663         elm_object_text_set(pButton, MP_COM_BODY_DELETE);
 664         elm_object_style_set(pButton, "sweep/delete");
 665         elm_object_part_content_set(pPopUpHandle, "button1", pButton);
 666
 667         if(PopupDeleteButtonCallbackFunc)
 668         {
 669                 evas_object_smart_callback_add(pButton, "clicked", PopupDeleteButtonCallbackFunc, pUserData);
 670         }
 671
 672         pButton = elm_button_add(pPopUpHandle);
 673         elm_object_text_set(pButton, MP_COM_BUTTON_CANCEL);
 674         elm_object_part_content_set(pPopUpHandle, "button2", pButton);
 675
 676         if(PopupCancelButtonCallbackFunc)
 677         {
 678                 evas_object_smart_callback_add(pButton, "clicked", PopupCancelButtonCallbackFunc, pUserData);
 679         }
 680
 681         //elm_popup_timeout_set(pPopUpHandle, 3.0);
 682
 683         evas_object_show(pPopUpHandle);
 684
 685         return TRUE;
 686 }
 687
 688 void MpUtilSetLabelForDetail(Evas_Object *pBox, char *szString)
 689 {
 690         VideoLogInfo("");
 691
 692         Evas_Object *pLabel = NULL;
 693
 694         pLabel = elm_label_add(pBox);
 695         elm_object_style_set(pLabel, "popup/default");
 696         elm_object_text_set(pLabel, szString);
 697         elm_label_ellipsis_set(pLabel, EINA_TRUE);
 698         elm_label_wrap_width_set(pLabel, 614 * elm_config_scale_get());
 699         evas_object_size_hint_weight_set(pLabel, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 700         evas_object_size_hint_min_set(pLabel, 614 * elm_config_scale_get(), 35 * elm_config_scale_get());
 701         elm_box_pack_end(pBox, pLabel);
 702         evas_object_show(pLabel);
 703 }
 704
 705 /*bool MpUtilDetailPopup(VideoAppData *pAppData, int nVideoItemIndex, char *szTitle, void *PopupButtonCallbackFunc)
 706 {
 707         VideoLogInfo("");
 708
 709         if(szTitle == NULL || pAppData == NULL)
 710         {
 711                 VideoLogInfo("No have popup message or pAppData is null.");
 712                 return FALSE;
 713         }
 714         char *szFilePath = NULL;
 715         char *szVideoTitle = NULL;
 716
 717         char szTmpStr[STR_LEN_MAX] = {0};
 718         char szTmpFileDate[STR_LEN_MAX] = {0};
 719         char szTmpFileExtension[STR_LEN_MAX] = {0};
 720         char szTmpFileSize[STR_LEN_MAX] = {0};
 721
 722         double nLongtitude = 0.0;
 723         double nLatitude = 0.0;
 724
 725         int nWidth = 0;
 726         int nHeight = 0;
 727
 728         Evas_Object *pBox = NULL;
 729         Evas_Object *pButton = NULL;
 730
 731         MpUtilDeletePopupHandle();
 732
 733         MpUtilSetAlphaOfMainWindow(FALSE);
 734
 735         pPopUpHandle = elm_popup_add(pAppData->pMainWindow);
 736
 737         evas_object_size_hint_weight_set(pPopUpHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 738
 739         szFilePath = MpUtilMediaSvcGetVideoUrl(nVideoItemIndex);
 740         szVideoTitle = MpUtilMediaSvcGetVideoTitle(nVideoItemIndex);
 741         nWidth = MpUtilMediaSvcGetVideoItemWidth(nVideoItemIndex);
 742         nHeight = MpUtilMediaSvcGetVideoItemHeight(nVideoItemIndex);
 743
 744         MpVideoInfoCtrlGetFileInfo(szFilePath, szTmpFileDate, STR_LEN_MAX, szTmpFileExtension, STR_LEN_MAX, szTmpFileSize, STR_LEN_MAX);
 745         MpVideoInfoCtrlGetGPS(szFilePath, &nLongtitude, &nLatitude);
 746
 747         pBox = elm_box_add(pPopUpHandle);
 748
 749         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %s </align></font_size>", MP_COM_BODY_DETAILS_TITLE, szVideoTitle);
 750         MpUtilSetLabelForDetail(pBox, szTmpStr);
 751         memset(szTmpStr, 0, STR_LEN_MAX);
 752
 753         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %s</align></font_size>", MP_COM_BODY_FORMAT, szTmpFileExtension);
 754         MpUtilSetLabelForDetail(pBox, szTmpStr);
 755         memset(szTmpStr, 0, STR_LEN_MAX);
 756
 757         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %s</align></font_size>", MP_COM_POP_DATE, szTmpFileDate);
 758         MpUtilSetLabelForDetail(pBox, szTmpStr);
 759         memset(szTmpStr, 0, STR_LEN_MAX);
 760
 761         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %s</align></font_size>", MP_COM_BODY_SIZE, szTmpFileSize);
 762         MpUtilSetLabelForDetail(pBox, szTmpStr);
 763         memset(szTmpStr, 0, STR_LEN_MAX);
 764
 765         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %d x %d</align></font_size>", MP_IDLE_BODY_RESOLUTION, nWidth, nHeight);
 766         MpUtilSetLabelForDetail(pBox, szTmpStr);
 767         memset(szTmpStr, 0, STR_LEN_MAX);
 768
 769         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %f</align></font_size>", _(MP_VPL_GPS_LATITUDE), nLatitude);
 770         MpUtilSetLabelForDetail(pBox, szTmpStr);
 771         memset(szTmpStr, 0, STR_LEN_MAX);
 772
 773         snprintf(szTmpStr, STR_LEN_MAX, "<font_size=32><align=left> %s: %f</align></font_size>", _(MP_VPL_GPS_LONGITUTD), nLongtitude);
 774         MpUtilSetLabelForDetail(pBox, szTmpStr);
 775         memset(szTmpStr, 0, STR_LEN_MAX);
 776
 777         elm_object_content_set(pPopUpHandle, pBox);
 778
 779         elm_object_part_text_set(pPopUpHandle, "title,text", szTitle);
 780         pButton = elm_button_add(pPopUpHandle);
 781         elm_object_style_set (pButton, "popup_button/default");
 782         elm_object_text_set(pButton, MP_COM_SK_BACK);
 783         elm_object_part_content_set(pPopUpHandle, "button1", pButton);
 784
 785         if(szFilePath)
 786         {
 787                 free(szFilePath);
 788                 szFilePath = NULL;
 789         }
 790
 791         if(szVideoTitle)
 792         {
 793                 free(szVideoTitle);
 794                 szVideoTitle = NULL;
 795         }
 796
 797         if(PopupButtonCallbackFunc)
 798         {
 799                 evas_object_smart_callback_add(pButton, "clicked", PopupButtonCallbackFunc, (void*)pAppData);
 800         }
 801
 802         evas_object_show(pPopUpHandle);
 803
 804         return TRUE;
 805 }*/
 806
 807 bool MpUtilProgressPopUp(VideoAppData *pAppData, char *szLabel)
 808 {
 809         VideoLogInfo("");
 810
 811         if (pAppData == NULL || szLabel == NULL) {
 812                 VideoLogInfo("No have popup message or pAppData is null.");
 813                 return FALSE;
 814         }
 815
 816         MpUtilDeletePopupHandle();
 817
 818         MpUtilSetAlphaOfMainWindow(FALSE);
 819
 820         pPopUpHandle = elm_popup_add(pAppData->pMainWindow);
 821
 822         evas_object_size_hint_weight_set(pPopUpHandle, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 823         Evas_Object *progressbar, *box, *label;
 824
 825         label = elm_label_add(pPopUpHandle);
 826         elm_object_text_set(label, szLabel);
 827         evas_object_show(label);
 828
 829         progressbar = elm_progressbar_add(pPopUpHandle);
 830         elm_object_style_set(progressbar, "pending_list");
 831         elm_progressbar_pulse(progressbar, EINA_TRUE);
 832         evas_object_size_hint_align_set(progressbar, EVAS_HINT_FILL, 0.5);
 833         evas_object_size_hint_weight_set(progressbar, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 834         elm_progressbar_pulse(progressbar, EINA_TRUE);
 835         evas_object_show(progressbar);
 836
 837         box = elm_box_add(pPopUpHandle);
 838         elm_box_pack_end(box, label);
 839         elm_box_pack_end(box, progressbar);
 840         evas_object_show(box);
 841         elm_object_content_set(pPopUpHandle, box);
 842
 843         if (pPopupWindow) {
 844         MpUtilRotateWindow(MpUtilGetRotationState(), pPopupWindow);
 845         }
 846
 847         evas_object_show(pPopUpHandle);
 848
 849         return TRUE;
 850 }
 851
 852
 853 void *MpUtilCreateButtonIcon(void *pParent, const char *szIconPath, bool bSizeUp, bool bSizeDown, int nAspectWidth, int nAspectHeight, void *pUserData, char* szButtonStyle, void *func)
 854 {
 855         VideoLogInfo("");
 856
 857         Evas_Object *pButton = NULL;
 858         Evas_Object *pIcon = NULL;
 859
 860         pButton = elm_button_add(pParent);
 861
 862         if(szIconPath)
 863         {
 864                 pIcon = elm_icon_add(pParent);
 865                 elm_image_file_set(pIcon, szIconPath, NULL);
 866                 //evas_object_size_hint_aspect_set(pIcon, EVAS_ASPECT_CONTROL_VERTICAL, nAspectWidth, nAspectHeight);
 867                 evas_object_size_hint_aspect_set(pIcon, EVAS_ASPECT_CONTROL_NEITHER, nAspectWidth, nAspectHeight);
 868                 //elm_icon_resizable_set(pIcon, bSizeUp, bSizeDown);
 869         }
 870
 871         if(szButtonStyle)
 872         {
 873                 elm_object_style_set(pButton, szButtonStyle);
 874         }
 875
 876         if(pIcon)
 877         {
 878                 elm_object_part_content_set(pButton,PART_BUTTON_ICON, pIcon);
 879         }
 880
 881         if(func)
 882         {
 883                 evas_object_smart_callback_add(pButton, "clicked", func, (void *)pUserData);
 884         }
 885
 886         elm_object_focus_allow_set(pButton, EINA_FALSE);
 887         evas_object_size_hint_weight_set(pButton, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 888         evas_object_show(pButton);
 889
 890         return (void *)pButton;
 891 }
 892
 893 void *MpUtilCreateStyleButton(void *pParent, const char* szButtonText, const void *pUserData, char* szButtonStyle, void *func)
 894 {
 895         VideoLogInfo("");
 896
 897         Evas_Object *pButton = NULL;
 898
 899         pButton = elm_button_add(pParent);
 900
 901         if(szButtonStyle)
 902         {
 903                 elm_object_style_set(pButton, szButtonStyle);
 904         }
 905
 906         if(szButtonText)
 907         {
 908                 elm_object_text_set(pButton, szButtonText);
 909         }
 910
 911         if(func)
 912         {
 913                 evas_object_smart_callback_add(pButton, "clicked", func, pUserData);
 914         }
 915
 916         elm_object_focus_allow_set(pButton, EINA_FALSE);
 917         evas_object_size_hint_weight_set(pButton, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 918         evas_object_show(pButton);
 919
 920         return (void *)pButton;
 921 }
 922
 923 void *MpUtilLoadEdjFile(Evas * pEvas, char *szEdjName, char *szGroupName)
 924 {
 925         VideoLogInfo("");
 926
 927         Evas_Object *pEdj = NULL;
 928         int nWidth = 0;
 929         int nHeight = 0;
 930
 931         pEdj = edje_object_add(pEvas);
 932         if (!edje_object_file_set(pEdj, szEdjName, szGroupName)) {
 933                 VideoLogInfo("[ERR] EDJ file error : %s | %s\n", szEdjName,
 934                              szGroupName);
 935                 return NULL;
 936         }
 937
 938         edje_object_size_min_get(pEdj, &nWidth, &nHeight);
 939         evas_object_resize(pEdj, nWidth, nHeight);
 940
 941         return (void *)pEdj;
 942 }
 943
 944 bool MpUtilIsCallOff(void)
 945 {
 946         VideoLogInfo("");
 947
 948         int nCallStatus = 0;
 949
 950         if (!vconf_get_int(VCONFKEY_CALL_STATE, &nCallStatus)) {
 951                 if (nCallStatus == VCONFKEY_CALL_OFF)
 952                 {
 953                         VideoLogInfo("Call off");
 954                         return TRUE;
 955                 }
 956                 else
 957                 {
 958                         VideoLogInfo("!!! CALL ON !!!");
 959                         return FALSE;
 960                 }
 961         }
 962
 963         return TRUE;
 964 }
 965
 966 bool MpUtilIsCameraOff(void)
 967 {
 968         VideoLogInfo("");
 969
 970         int nCameraStatus = 0;
 971
 972         if (!vconf_get_int(VCONFKEY_CAMERA_STATE, &nCameraStatus)) {
 973                 if (nCameraStatus == VCONFKEY_CAMERA_STATE_NULL)
 974                 {
 975                         VideoLogInfo("Camera off");
 976                         return TRUE;
 977                 }
 978                 else
 979                 {
 980                         VideoLogInfo("!!! CAMERA ON !!!");
 981                 }
 982         }
 983
 984         return FALSE;
 985 }
 986
 987 bool MpUtilRegisteCameraStatusCbFunc(void *pCameraStatusCb, void *pUserData)
 988 {
 989         if (!pCameraStatusCb) {
 990                 VideoLogInfo("pEarjackCb is empty.");
 991                 return FALSE;
 992         }
 993
 994         VideoLogInfo("");
 995
 996         vconf_notify_key_changed(VCONFKEY_CAMERA_STATE, pCameraStatusCb, pUserData);
 997
 998         return TRUE;
 999 }
1000
1001 bool MpUtilIsConnectEarjack(void)
1002 {
1003         VideoLogInfo("");
1004
1005         int nEarjack = 0;
1006
1007         if (!vconf_get_int(VCONFKEY_SYSMAN_EARJACK, &nEarjack)) {
1008                 if (nEarjack) {
1009                         return TRUE;
1010                 }
1011         }
1012
1013         return FALSE;
1014 }
1015
1016 bool MpUtilRegisteEarjackCbFunc(void *pEarjackCb, void *pUserData)
1017 {
1018         if (!pEarjackCb) {
1019                 VideoLogInfo("pEarjackCb is empty.");
1020                 return FALSE;
1021         }
1022
1023         VideoLogInfo("");
1024
1025         vconf_notify_key_changed(VCONFKEY_SYSMAN_EARJACK, pEarjackCb, pUserData);
1026
1027         return TRUE;
1028 }
1029
1030 bool MpUtilSetPreviewUrlVideos(char* szPreviewUrl)
1031 {
1032         if(!szPreviewUrl || strlen(szPreviewUrl) <= 0)
1033         {
1034                 VideoLogInfo("[ERR]");
1035         }
1036
1037         VideoLogInfo("szPreviewUrl : %s", szPreviewUrl);
1038
1039         bool bRet = FALSE;
1040
1041         if(vconf_set_str(MP_UTIL_VCONF_KEY_PREVIEW_URL_VIDEOS, szPreviewUrl))
1042         {
1043                 VideoLogInfo("Fail to write szPreviewUrl.");
1044                 bRet = FALSE;
1045         }
1046         else
1047         {
1048                 VideoLogInfo("Success to write it.");
1049                 bRet = TRUE;
1050         }
1051
1052         return bRet;
1053 }
1054
1055 bool MpUtilGetPreviewUrlVideos(char* szRetPreviewUrl, int nStrSize)
1056 {
1057         if(!szRetPreviewUrl)
1058         {
1059                 VideoLogInfo("[ERR]");
1060         }
1061         else
1062         {
1063                 memset(szRetPreviewUrl, 0, nStrSize);
1064         }
1065
1066         VideoLogInfo("");
1067
1068         bool bRet = FALSE;
1069         char *szPreviewUrl = NULL;
1070
1071
1072         szPreviewUrl = vconf_get_str(MP_UTIL_VCONF_KEY_PREVIEW_URL_VIDEOS);
1073         if(!szPreviewUrl || strlen(szPreviewUrl) <= 0)
1074         {
1075                 VideoLogInfo("Fail to get szPreviewUrl from vconf register.");
1076                 bRet = FALSE;
1077         }
1078         else
1079         {
1080                 VideoLogInfo("Success to get szPreviewUrl. : %s", szPreviewUrl);
1081                 strncpy(szRetPreviewUrl, szPreviewUrl, nStrSize - 1);
1082                 free(szPreviewUrl);
1083                 bRet = TRUE;
1084         }
1085
1086         return bRet;
1087 }
1088
1089 bool MpUtilSetPreviewUrlRecords(char* szPreviewUrl)
1090 {
1091         if(!szPreviewUrl || strlen(szPreviewUrl) <= 0)
1092         {
1093                 VideoLogInfo("[ERR]");
1094         }
1095
1096         VideoLogInfo("");
1097
1098         bool bRet = FALSE;
1099
1100         if(vconf_set_str(MP_UTIL_VCONF_KEY_PREVIEW_URL_RECORDS, szPreviewUrl))
1101         {
1102                 VideoLogInfo("Fail to write szPreviewUrl.");
1103                 bRet = FALSE;
1104         }
1105         else
1106         {
1107                 VideoLogInfo("Success to write it.");
1108                 bRet = TRUE;
1109         }
1110
1111         return bRet;
1112 }
1113
1114 bool MpUtilGetPreviewUrlRecords(char* szRetPreviewUrl, int nStrSize)
1115 {
1116         if(!szRetPreviewUrl)
1117         {
1118                 VideoLogInfo("[ERR]");
1119         }
1120         else
1121         {
1122                 memset(szRetPreviewUrl, 0, nStrSize);
1123         }
1124
1125         VideoLogInfo("");
1126
1127         bool bRet = FALSE;
1128         char *szPreviewUrl = NULL;
1129
1130
1131         szPreviewUrl = vconf_get_str(MP_UTIL_VCONF_KEY_PREVIEW_URL_RECORDS);
1132         if(!szPreviewUrl || strlen(szPreviewUrl) <= 0)
1133         {
1134                 VideoLogInfo("Fail to get szPreviewUrl from vconf register.");
1135                 bRet = FALSE;
1136         }
1137         else
1138         {
1139                 VideoLogInfo("Success to get szPreviewUrl. : %s", szPreviewUrl);
1140                 strncpy(szRetPreviewUrl, szPreviewUrl, nStrSize - 1);
1141                 free(szPreviewUrl);
1142                 bRet = TRUE;
1143         }
1144
1145         return bRet;
1146 }
1147
1148 unsigned int MpUtilGetMainWindowXID(void)
1149 {
1150         VideoLogInfo("");
1151         if (pMainXwindow) {
1152                 VideoLogInfo("pMainXwindow : %d", pMainXwindow);
1153                 return pMainXwindow;
1154         } else {
1155                 VideoLogInfo("No exist main window XID.");
1156         }
1157         return 0;
1158 }
1159
1160 void MpUtilRotateWindow(int nRotateMode, void *pWindowHandle)
1161 {
1162         VideoLogInfo("");
1163
1164         if (!pWindowHandle) {
1165                 return;
1166         }
1167
1168         switch (nRotateMode) {
1169         case VIDEO_ROTATE_UNKNOWN:
1170                 VideoLogInfo("VIDEO_ROTATE_UNKNOWN");
1171                 elm_win_rotation_with_resize_set(pWindowHandle, 0);
1172                 break;
1173
1174         case VIDEO_ROTATE_PORTRAIT_NORMAL:
1175                 VideoLogInfo("VIDEO_ROTATE_PORTRAIT_NORMAL");
1176                 elm_win_rotation_with_resize_set(pWindowHandle, 0);
1177                 break;
1178
1179         case VIDEO_ROTATE_LANDSCAPE_NORMAL:
1180                 VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_NORMAL");
1181                 elm_win_rotation_with_resize_set(pWindowHandle, 270);
1182                 break;
1183
1184         case VIDEO_ROTATE_PORTRAIT_REVERSE:
1185                 VideoLogInfo("VIDEO_ROTATE_PORTRAIT_REVERSE");
1186                 elm_win_rotation_with_resize_set(pWindowHandle, 180);
1187                 break;
1188
1189         case VIDEO_ROTATE_LANDSCAPE_REVERSE:
1190                 VideoLogInfo("VIDEO_ROTATE_LANDSCAPE_REVERSE");
1191                 elm_win_rotation_with_resize_set(pWindowHandle, 90);
1192                 break;
1193
1194         default:
1195                 VideoLogInfo("DEFAULT - VIDEO_ROTATE_UNKNOWN");
1196                 elm_win_rotation_with_resize_set(pWindowHandle, 0);
1197                 break;
1198         }
1199 }
1200
1201 void MpUtilGetUserAgent(VideoAppData *pAppData)
1202 {
1203         VideoLogInfo("");
1204
1205         int nWifiMode = 0;
1206
1207         char *szUserAgent = NULL;
1208         szUserAgent = vconf_get_str(VCONFKEY_ADMIN_UAGENT);
1209         if(szUserAgent)
1210         {
1211                 memset(pAppData->szUserAgent, 0, STR_LEN_MAX);
1212                 strncpy(pAppData->szUserAgent, szUserAgent, STR_LEN_MAX - 1);
1213                 free(szUserAgent);
1214         }
1215         else
1216         {
1217                 VideoLogInfo("!!!!! NO EXIST USER AGENT !!!!!");
1218         }
1219
1220 #if 0
1221         memset(pAppData->szUserAgent, 0, STR_LEN_MAX);
1222         snprintf(pAppData->szUserAgent, STR_LEN_MAX, "%s", MP_UTIL_TEMP_USER_AGENT_VALUE);
1223 #endif
1224
1225         if(!vconf_get_int(VCONFKEY_WIFI_STATE, &nWifiMode))
1226         {
1227                 VideoLogInfo("User Agent : %s, Wi-Fi : %d", pAppData->szUserAgent, nWifiMode);
1228         }
1229
1230 }
1231
1232 double MpUtilGetSysTime(void)
1233 {
1234         struct timeval tv;
1235
1236         gettimeofday(&tv, NULL);
1237         return (double)tv.tv_sec + (double)tv.tv_usec / 1E6;
1238 }
1239
1240 void MpUtilLcdNormalPowerLockForResume(void)
1241 {
1242         VideoLogInfo("");
1243
1244         pm_lock_state(LCD_NORMAL, GOTO_STATE_NOW | HOLD_KEY_BLOCK, 0);
1245 }
1246
1247 void MpUtilLcdNormalPowerUnlockForPause(void)
1248 {
1249         VideoLogInfo("");
1250
1251         pm_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
1252 }
1253
1254 void MpUtilLcdOffForPowerButton(void)
1255 {
1256         VideoLogInfo("");
1257
1258         pm_unlock_state(LCD_NORMAL, PM_RESET_TIMER);
1259 }
1260
1261 void MpUtilMultimediaKeyGrab(void)
1262 {
1263         VideoLogInfo("");
1264         MpUtilSetKeyGrab(PLAY_KEY, KEY_GRAB_OR_EXCLUSIVE);
1265         MpUtilSetKeyGrab(STOP_KEY, KEY_GRAB_OR_EXCLUSIVE);
1266         MpUtilSetKeyGrab(PAUSE_KEY, KEY_GRAB_OR_EXCLUSIVE);
1267         MpUtilSetKeyGrab(NEXT_KEY, KEY_GRAB_OR_EXCLUSIVE);
1268         MpUtilSetKeyGrab(PREV_KEY, KEY_GRAB_OR_EXCLUSIVE);
1269         MpUtilSetKeyGrab(REWIND_KEY, KEY_GRAB_OR_EXCLUSIVE);
1270         MpUtilSetKeyGrab(FORWARD_KEY, KEY_GRAB_OR_EXCLUSIVE);
1271 }
1272
1273 void MpUtilMultimediaKeyUngrab(void)
1274 {
1275         VideoLogInfo("");
1276
1277         MpUtilSetKeyUngrab(PAUSE_KEY);
1278         MpUtilSetKeyUngrab(PLAY_KEY);
1279         MpUtilSetKeyUngrab(STOP_KEY);
1280         MpUtilSetKeyUngrab(NEXT_KEY);
1281         MpUtilSetKeyUngrab(PREV_KEY);
1282         MpUtilSetKeyUngrab(FORWARD_KEY);
1283         MpUtilSetKeyUngrab(REWIND_KEY);
1284
1285 }
1286
1287 void MpUtilMultimediaVolumeKeyGrab(void)
1288 {
1289         VideoLogInfo("");
1290
1291         MpUtilSetKeyGrab(VOLUME_UP_KEY, KEY_GRAB_EXCLUSIVE);
1292         MpUtilSetKeyGrab(VOLUME_DOWN_KEY, KEY_GRAB_EXCLUSIVE);
1293
1294         int nRet = 0;
1295         nRet = vconf_set_int(VCONFKEY_STARTER_USE_VOLUME_KEY, 1);
1296         if(nRet != 0)
1297         {
1298                 VideoLogError("VCONFKEY_STARTER_USE_VOLUME_KEY set fail: %d", nRet);
1299         }
1300 }
1301 void MpUtilMultimediaVolumeKeyUngrab(void)
1302 {
1303         VideoLogInfo("");
1304
1305         MpUtilSetKeyUngrab(VOLUME_UP_KEY);
1306         MpUtilSetKeyUngrab(VOLUME_DOWN_KEY);
1307 }
1308
1309 /*
1310 bool MpUtilSbeamIsActive(void)
1311 {
1312         VideoLogInfo("bIsActiveNfcSbeam : %d", bIsActiveNfcSbeam);
1313
1314         return bIsActiveNfcSbeam;
1315 }
1316
1317 void MpUtilSbeamP2pTargetDiscoveredCb(nfc_discovered_type_e nType, nfc_p2p_target_h pTarget, void *pUserData)
1318 {
1319         if(!pUserData)
1320         {
1321                 VideoLogInfo("User data is NULL.");
1322                 return;
1323         }
1324
1325         VideoAppData *pAppData = (VideoAppData *)pUserData;
1326
1327         VideoLogInfo("");
1328
1329         if(nType == NFC_DISCOVERED_TYPE_ATTACHED)
1330         {
1331                 VideoLogInfo("NFC_DISCOVERED_TYPE_ATTACHED");
1332
1333                 if(bIsActiveNfcSbeam)
1334                 {
1335                         char szWindowId[STR_LEN_MAX] = {0};
1336
1337                         if(strlen(pAppData->szMediaUri) <= 0)
1338                         {
1339                                 VideoLogInfo("[ERR]No exist media uri.");
1340                                 return;
1341                         }
1342
1343                         service_h svc_handle;
1344                         service_create(&svc_handle);
1345                         snprintf(szWindowId, STR_LEN_MAX-1, "%d", elm_win_xwindow_get(pAppData->pMainWindow));
1346
1347                         service_set_operation(svc_handle, "http://tizen.org/appcontrol/operation/nfc_sbeam_send");
1348                         service_set_mime(svc_handle, "text/DirectShareVideos");
1349                         service_set_window(svc_handle, elm_win_xwindow_get(pAppData->pMainWindow));
1350                         service_set_uri(svc_handle, pAppData->szMediaUri);
1351                         service_send_launch_request(svc_handle, NULL, NULL);
1352                         service_destroy(svc_handle);
1353                 }
1354                 else
1355                 {
1356                         VideoLogInfo("bIsActiveNfcSbeam is NULL.");
1357                 }
1358         }
1359 }
1360
1361 void MpUtilSbeamInit(void* pUserData)
1362 {
1363         if(!pUserData)
1364         {
1365                 VideoLogInfo("User data is NULL.");
1366                 return;
1367         }
1368
1369         VideoLogInfo("");
1370
1371         int bSbeamState = VCONFKEY_NFC_SBEAM_OFF;
1372
1373         if(vconf_get_bool(VCONFKEY_NFC_SBEAM, &bSbeamState) != 0)
1374         {
1375                 VideoLogInfo("Fail to get value.");
1376         }
1377         else
1378         {
1379                 if(bSbeamState != VCONFKEY_NFC_SBEAM_ON)
1380                 {
1381                         VideoLogInfo("Off state about nfc sbeam");
1382                         return;
1383                 }
1384         }
1385
1386         if(bIsActiveNfcSbeam == FALSE)
1387         {
1388                 if(nfc_manager_initialize(NULL, NULL) != NFC_ERROR_NONE)
1389                 {
1390                         VideoLogInfo("[Err] Fail to initialize nfc manager.");
1391                         return;
1392                 }
1393
1394                 nfc_manager_set_p2p_target_discovered_cb(MpUtilSbeamP2pTargetDiscoveredCb, pUserData);
1395
1396                 bIsActiveNfcSbeam = TRUE;
1397         }
1398         else
1399         {
1400                 VideoLogInfo("Already set sbeam activation.");
1401         }
1402 }
1403
1404 void MpUtilSbeamDeinit(void)
1405 {
1406         VideoLogInfo("");
1407
1408         int bSbeamState = VCONFKEY_NFC_SBEAM_OFF;
1409
1410         if(vconf_get_bool(VCONFKEY_NFC_SBEAM, &bSbeamState) != 0)
1411         {
1412                 VideoLogInfo("Fail to get value.");
1413         }
1414         else
1415         {
1416                 if(bSbeamState != VCONFKEY_NFC_SBEAM_ON)
1417                 {
1418                         VideoLogInfo("Off state about nfc sbeam");
1419                         return;
1420                 }
1421         }
1422
1423         if(bIsActiveNfcSbeam == TRUE)
1424         {
1425                 if(nfc_manager_deinitialize() != NFC_ERROR_NONE)
1426                 {
1427                         VideoLogInfo("[Err] Fail to deinitialize nfc manager.");
1428                 }
1429
1430                 bIsActiveNfcSbeam = FALSE;
1431         }
1432         else
1433         {
1434                 VideoLogInfo("Already set sbeam unactivation.");
1435         }
1436 }
1437 */
1438
1439 char* MpUtilGetFileSize(unsigned int size)
1440 {
1441         VideoLogInfo("");
1442
1443 #define FILE_SIZE_LEN_MAX                       64
1444 #define BASIC_SIZE                                      1024    //used for file size check
1445
1446 enum VIDEO_PLAYER_FILE_SIZE_TYPE
1447 {
1448         SIZE_BYTE = 0,
1449         SIZE_KB,
1450         SIZE_MB,
1451         SIZE_GB
1452 };
1453
1454         int nCount = 0;
1455
1456         char *pTmp = (char *)calloc(1, sizeof(char) * FILE_SIZE_LEN_MAX + 1);
1457         if(pTmp == NULL)
1458         {
1459                 return NULL;
1460         }
1461
1462         while(size >= (BASIC_SIZE))
1463         {
1464                 size /= BASIC_SIZE;
1465                 nCount++;
1466         }
1467
1468         if(nCount == SIZE_BYTE)
1469         {
1470                 snprintf(pTmp, FILE_SIZE_LEN_MAX,"%zuB", size);
1471         }
1472         else if(nCount == SIZE_KB)
1473         {
1474                 snprintf(pTmp, FILE_SIZE_LEN_MAX,"%zuKB", size);
1475         }
1476         else if(nCount == SIZE_MB)
1477         {
1478                 snprintf(pTmp, FILE_SIZE_LEN_MAX,"%zuMB", size);
1479         }
1480         else if(nCount == SIZE_GB)
1481         {
1482                 snprintf(pTmp, FILE_SIZE_LEN_MAX,"%zuGB", size);
1483         }
1484         else
1485         {
1486                 snprintf(pTmp, FILE_SIZE_LEN_MAX,"%zuMB", 0);
1487         }
1488
1489         VideoLogInfo("Size=%s", pTmp);
1490
1491         return pTmp;
1492 }
1493
1494 void MpUtilConvertTime(int nVideoTime, char* szRetTime, bool bIsHideHour)
1495 {
1496 #define VIDEO_TIME_MSEC_PER_SEC         1000
1497 #define VIDEO_TIME_SEC_PER_MIN          60
1498 #define VIDEO_TIME_MIN_PER_HOUR         60
1499 #define VIDEO_TIME_SEC_PER_HOUR         (VIDEO_TIME_MIN_PER_HOUR * VIDEO_TIME_SEC_PER_MIN)
1500
1501         if(!szRetTime)
1502         {
1503                 VideoLogInfo("[ERR] No exist szRetTime pointer.");
1504                 return;
1505         }
1506         else
1507         {
1508                 memset(szRetTime, 0, STR_LEN_MAX);
1509         }
1510
1511         if(nVideoTime <= 0)
1512         {
1513                 VideoLogInfo("nVideoTime : %d", nVideoTime);
1514         }
1515
1516         int nTime = floor(nVideoTime / VIDEO_TIME_MSEC_PER_SEC);
1517         int nHour = 0;
1518         int nMin = 0;
1519         int nSec = 0;
1520         int nTmp = 0;
1521
1522         if (nTime >= VIDEO_TIME_SEC_PER_HOUR)
1523         {
1524                 nSec = nTime % VIDEO_TIME_SEC_PER_MIN;
1525                 nTmp = floor(nTime / VIDEO_TIME_SEC_PER_MIN);
1526                 nMin = nTmp % VIDEO_TIME_MIN_PER_HOUR;
1527                 nHour = floor(nTmp / VIDEO_TIME_MIN_PER_HOUR);
1528         }
1529         else if (nTime >= VIDEO_TIME_SEC_PER_MIN)
1530         {
1531                 nHour = 0;
1532                 nMin = floor(nTime / VIDEO_TIME_SEC_PER_MIN);
1533                 nSec = nTime % VIDEO_TIME_SEC_PER_MIN;
1534         }
1535         else
1536         {
1537                 nHour = 0;
1538                 nMin = 0;
1539                 nSec = nTime % VIDEO_TIME_SEC_PER_MIN;
1540         }
1541
1542         if(bIsHideHour)
1543         {
1544                 if(nHour)
1545                 {
1546                         snprintf(szRetTime, STR_LEN_MAX - 1, "%02d:%02d:%02d", nHour, nMin, nSec);
1547                 }
1548                 else
1549                 {
1550                         snprintf(szRetTime, STR_LEN_MAX - 1, "%02d:%02d", nMin, nSec);
1551                 }
1552         }
1553         else
1554         {
1555                 snprintf(szRetTime, STR_LEN_MAX - 1, "%02d:%02d:%02d", nHour, nMin, nSec);
1556         }
1557
1558         szRetTime[strlen(szRetTime)] = '\0';
1559
1560         VideoLogInfo("szRetTime : %s", szRetTime);
1561 }
1562
1563 void MpUtilLayoutVisibleOff(void *pWindowHandle)
1564 {
1565         VideoLogInfo("");
1566
1567         if(pWindowHandle == NULL)
1568         {
1569                 VideoLogError("Window handle is NULL");
1570                 return;
1571         }
1572
1573         if(pX11DisplayHandle == NULL)
1574         {
1575                 VideoLogError("Display handle is NULL");
1576                 return;
1577         }
1578
1579         if (!strcmp ("mobile", elm_win_profile_get (pWindowHandle)))
1580         {
1581                 utilx_set_fb_visible (pX11DisplayHandle, UTILX_FB_TYPE_UI, FALSE);
1582         }
1583         else
1584         {
1585                 VideoLogError("Skip for Desktop mode : %s", elm_win_profile_get (pWindowHandle));
1586         }
1587         return;
1588 }