src/mp-video-view-mgr.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
  19 #include <unistd.h>
  20 #include <fcntl.h>
  21 #include <sys/stat.h>
  22
  23 #include <app.h>
  24 #include <syspopup_caller.h>
  25
  26 #include "mp-util.h"
  27 #include "mp-video-log.h"
  28 #include "mp-external-ug.h"
  29 #include "mp-video-view-mgr.h"
  30 #include "mp-video-type-define.h"
  31 #include "mp-util-media-service.h"
  32 #include "mp-video-display-view.h"
  33 #include "mp-video-string-define.h"
  34 #include "mp-video-streaming-view.h"
  35 #include "mp-video-service-ctrl.h"
  36 #include "mp-video-volume-ctrl.h"
  37
  38 #define MULTIMEDIA_KEY_LONG_PRESS_INTERVAL              4.0
  39 #define DETAIL_POPUP_STR_LEN_MAX                                20
  40 #define LAYOUT_VISIBLE_OFF_TIMER_INTERVAL               1.0
  41
  42
  43 static Evas_Object *pMainLayout = NULL;
  44 static Evas_Object *pBackGround = NULL;
  45 static Evas_Object *pNaviFrame = NULL;
  46 static Evas_Object *pConformant = NULL;
  47 static Evas_Object *pGesture = NULL;
  48 static Evas_Object *pEventRect = NULL;
  49 static Evas_Object *pDisplayViewVolume = NULL;
  50
  51 static MpVideoRotateType nVideoRotateType = VIDEO_ROTATE_PORTRAIT_NORMAL;
  52
  53 static Ecore_Event_Handler *pHWKeyEventDownHandler = NULL;
  54 static Ecore_Event_Handler *pHWKeyEventUpHandler = NULL;
  55
  56 static bool bIsLongPressForward = FALSE;
  57 static bool bIsKeyCancle = FALSE;
  58 static bool bShowLayout = FALSE;
  59
  60 static Ecore_Timer *pLongPressSpeedPlayingTimer = NULL;
  61 static Ecore_Timer *pLongPressVolumeKeyTimer = NULL;
  62 static Ecore_Timer *pLayoutVisibleOffTimer = NULL;
  63
  64 static void MpVideoVideoViewCtrlLongpressSpeedKeyUp(void *pUserData);
  65 static void MpVideoVideoViewCtrlLongpressSpeedKeyDown(void *pUserData);
  66 static void MpVideoViewCtrlChangeViewCb(int nChangePlayerView, void *pUserData);
  67
  68 /*
  69  * Callback function.
  70  */
  71 static Eina_Bool MpVideoViewCtrlLayoutVisibleOffTimerCb(void *pUserData)
  72 {
  73         if(!pUserData)
  74         {
  75                 VideoLogInfo("[ERR]");
  76                 return EINA_FALSE;
  77         }
  78
  79         VideoLogInfo("");
  80
  81         if(pLayoutVisibleOffTimer)
  82         {
  83                 ecore_timer_del(pLayoutVisibleOffTimer);
  84                 pLayoutVisibleOffTimer = NULL;
  85         }
  86
  87         VideoAppData *pAppData = (VideoAppData *)pUserData;
  88
  89         MpUtilLayoutVisibleOff(pAppData->pMainWindow);
  90
  91         return EINA_FALSE;
  92 }
  93
  94 static Eina_Bool MpVideoViewCtrlVolumeKeyDownTimerCb(void *pUserData)
  95 {
  96         if(!pUserData)
  97         {
  98                 VideoLogInfo("[ERR]");
  99                 return EINA_FALSE;
 100         }
 101
 102         VideoLogInfo("");
 103
 104         MpVideoViewCtrlShowVolume();
 105         int nVol;
 106         nVol = MpVideoVolumeCtrlGetVolume() - 1;
 107         MpVideoVolumeCtrlSetVolume(nVol);
 108
 109         return EINA_TRUE;
 110 }
 111
 112 static Eina_Bool MpVideoViewCtrlVolumeKeyUpTimerCb(void *pUserData)
 113 {
 114         if(!pUserData)
 115         {
 116                 VideoLogInfo("[ERR]");
 117                 return EINA_FALSE;
 118         }
 119
 120         VideoLogInfo("");
 121
 122         MpVideoViewCtrlShowVolume();
 123         int nVol;
 124         nVol = MpVideoVolumeCtrlGetVolume() + 1;
 125         MpVideoVolumeCtrlSetVolume(nVol);
 126
 127         return EINA_TRUE;
 128 }
 129
 130
 131 static Eina_Bool MpVideoViewCtrlHardkeyDownCb(void *pUserData, int nType, void *pEvent)
 132 {
 133         if(!pUserData)
 134         {
 135                 VideoLogInfo("[ERR]");
 136                 return EINA_FALSE;
 137         }
 138
 139         VideoLogInfo("");
 140
 141         Ecore_Event_Key *pKeyEvent = (Ecore_Event_Key *) pEvent;
 142         VideoAppData *pAppData = (VideoAppData *)pUserData;
 143
 144         VideoLogInfo("Key down : %s", pKeyEvent->keyname);
 145
 146         if(!strcmp(pKeyEvent->keyname, END_KEY))
 147         {
 148                 VideoLogInfo("Back(End) key");
 149         }
 150         else if(!strcmp(pKeyEvent->keyname, HOME_KEY))
 151         {
 152                 VideoLogInfo("Home key");
 153         }
 154         else if(!strcmp(pKeyEvent->keyname, VOLUME_DOWN_KEY))
 155                                 {
 156                 MpVideoViewCtrlShowVolume();
 157                 int nVol;
 158                 nVol = MpVideoVolumeCtrlGetVolume() - 1;
 159                 MpVideoVolumeCtrlSetVolume(nVol);
 160
 161                 if(pLongPressVolumeKeyTimer)
 162                                         {
 163                         ecore_timer_del(pLongPressVolumeKeyTimer);
 164                         pLongPressVolumeKeyTimer = NULL;
 165                                 }
 166                 pLongPressVolumeKeyTimer = ecore_timer_add(0.3, MpVideoViewCtrlVolumeKeyDownTimerCb, (void *)pAppData);
 167                                         }
 168         else if(!strcmp(pKeyEvent->keyname, VOLUME_UP_KEY))
 169                                         {
 170                 MpVideoViewCtrlShowVolume();
 171                 int nVol;
 172                 nVol = MpVideoVolumeCtrlGetVolume() + 1;
 173                 MpVideoVolumeCtrlSetVolume(nVol);
 174
 175                 if(pLongPressVolumeKeyTimer)
 176                                 {
 177                         ecore_timer_del(pLongPressVolumeKeyTimer);
 178                         pLongPressVolumeKeyTimer = NULL;
 179                                 }
 180
 181                 pLongPressVolumeKeyTimer = ecore_timer_add(0.3, MpVideoViewCtrlVolumeKeyUpTimerCb, (void *)pAppData);
 182                         }
 183         else if(!strcmp(pKeyEvent->keyname, POWER_KEY))
 184                 {
 185                 VideoLogInfo("Power key");
 186
 187                         MpUtilLcdOffForPowerButton();
 188                 }
 189         else if(!strcmp(pKeyEvent->keyname, PAUSE_KEY))
 190         {
 191                 VideoLogInfo("Pause key down");
 192         }
 193         else if(!strcmp(pKeyEvent->keyname, PLAY_KEY))
 194         {
 195                 VideoLogInfo("Play key down");
 196         }
 197         else if(!strcmp(pKeyEvent->keyname, STOP_KEY))
 198         {
 199                 VideoLogInfo("Stop key down");
 200         }
 201         else if(!strcmp(pKeyEvent->keyname, NEXT_KEY))
 202         {
 203                 VideoLogInfo("Next key down");
 204         }
 205         else if(!strcmp(pKeyEvent->keyname, PREV_KEY))
 206         {
 207                 VideoLogInfo("Prev key down");
 208         }
 209         else if(!strcmp(pKeyEvent->keyname, FORWARD_KEY))
 210         {
 211                 VideoLogInfo("Forward key down");
 212                 bIsLongPressForward = TRUE;
 213                 MpVideoVideoViewCtrlLongpressSpeedKeyDown(pUserData);
 214         }
 215         else if(!strcmp(pKeyEvent->keyname, REWIND_KEY))
 216         {
 217                 VideoLogInfo("Rewind key down");
 218                 bIsLongPressForward = FALSE;
 219                 MpVideoVideoViewCtrlLongpressSpeedKeyDown(pUserData);
 220         }
 221         else if(!strcmp(pKeyEvent->keyname, KEY_CANCLE))
 222         {
 223                 VideoLogInfo("Cancel key down");
 224                 bIsKeyCancle = TRUE;
 225         }
 226
 227         return EINA_FALSE;
 228 }
 229
 230 static Eina_Bool MpVideoViewCtrlHardkeyUpCb(void *pUserData, int nType, void *pEvent)
 231 {
 232         if(!pUserData)
 233         {
 234                 VideoLogInfo("[ERR]");
 235                 return EINA_FALSE;
 236         }
 237
 238         VideoLogInfo("");
 239
 240         Ecore_Event_Key *pKeyEvent = (Ecore_Event_Key *) pEvent;
 241
 242         VideoAppData *pAppData = (VideoAppData *)pUserData;
 243
 244         VideoLogInfo("Key Up : %s", pKeyEvent->keyname);
 245
 246         if(bIsKeyCancle)
 247         {
 248                 VideoLogInfo("KEY CANCLE.");
 249                 if(pLongPressVolumeKeyTimer)
 250                 {
 251                         ecore_timer_del(pLongPressVolumeKeyTimer);
 252                         pLongPressVolumeKeyTimer = NULL;
 253                 }
 254                 bIsKeyCancle = FALSE;
 255                 return EINA_FALSE;
 256         }
 257
 258         if(!strcmp(pKeyEvent->keyname, END_KEY))
 259         {
 260                 VideoLogInfo("End key up");
 261                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 262         }
 263         else if(!strcmp(pKeyEvent->keyname, VOLUME_DOWN_KEY))
 264         {
 265                 if(pLongPressVolumeKeyTimer)
 266                 {
 267                         ecore_timer_del(pLongPressVolumeKeyTimer);
 268                         pLongPressVolumeKeyTimer = NULL;
 269                 }
 270         }
 271         else if(!strcmp(pKeyEvent->keyname, VOLUME_UP_KEY))
 272         {
 273                 if(pLongPressVolumeKeyTimer)
 274                 {
 275                         ecore_timer_del(pLongPressVolumeKeyTimer);
 276                         pLongPressVolumeKeyTimer = NULL;
 277                 }
 278         }
 279         else if(!strcmp(pKeyEvent->keyname, HOME_KEY))
 280         {
 281                 VideoLogInfo("Home key up");
 282
 283                 int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 284                 if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 285                         nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 286                         nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 287                         nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 288                         nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 289                 {
 290                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 291         }
 292
 293                 MpVideoServiceCtrlSetPrevPlayerType(MpVideoServiceCtrlGetPlayerType());
 294         }
 295         else if(!strcmp(pKeyEvent->keyname, POWER_KEY))
 296         {
 297                 VideoLogInfo("Power key up");
 298         }
 299         else if(!strcmp(pKeyEvent->keyname, PAUSE_KEY))
 300         {
 301                 VideoLogInfo("Pause key up");
 302                 if(pAppData->nCurPlayerState == MP_PLAYER_STATE_PLAY || pAppData->nCurPlayerState == MP_PLAYER_STATE_RESUME)
 303                 {
 304                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 305                 }
 306                 else if(pAppData->nCurPlayerState == MP_PLAYER_STATE_PAUSE)
 307                 {
 308                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 309                 }
 310         }
 311         else if(!strcmp(pKeyEvent->keyname, PLAY_KEY))
 312         {
 313                 VideoLogInfo("Play key up");
 314                 if(pAppData->nCurPlayerState == MP_PLAYER_STATE_PLAY || pAppData->nCurPlayerState == MP_PLAYER_STATE_RESUME)
 315                 {
 316                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 317                 }
 318                 else if(pAppData->nCurPlayerState == MP_PLAYER_STATE_PAUSE)
 319                 {
 320                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 321                 }
 322         }
 323         else if(!strcmp(pKeyEvent->keyname, STOP_KEY))
 324         {
 325                 VideoLogInfo("Stop key up");
 326                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 327         }
 328         else if(!strcmp(pKeyEvent->keyname, NEXT_KEY))
 329         {
 330                 VideoLogInfo("Next key up");
 331         }
 332         else if(!strcmp(pKeyEvent->keyname, PREV_KEY))
 333         {
 334                 VideoLogInfo("Prev key up");
 335         }
 336         else if(!strcmp(pKeyEvent->keyname, FORWARD_KEY))
 337         {
 338                 VideoLogInfo("Forward key up");
 339                 MpVideoVideoViewCtrlLongpressSpeedKeyUp(pUserData);
 340         }
 341         else if(!strcmp(pKeyEvent->keyname, REWIND_KEY))
 342         {
 343                 VideoLogInfo("Rewind key up");
 344                 MpVideoVideoViewCtrlLongpressSpeedKeyUp(pUserData);
 345         }
 346         else
 347         {
 348         }
 349
 350         return EINA_FALSE;
 351 }
 352
 353 static Evas_Event_Flags MpVideoViewCtrlGestureNTabStartCb(void *pUserData , void *pEventInfo)
 354 {
 355         VideoLogInfo("");
 356
 357         return EVAS_EVENT_FLAG_NONE;
 358 }
 359
 360
 361 static Evas_Event_Flags MpVideoViewCtrlGestureNTabEndCb(void *pUserData , void *pEventInfo)
 362 {
 363         VideoLogInfo("");
 364
 365         Elm_Gesture_Taps_Info *p = (Elm_Gesture_Taps_Info *) pEventInfo;
 366         if(p->n == 1) {
 367                 VideoAppData *pAppData = (VideoAppData *)pUserData;
 368
 369                 if(bShowLayout) {
 370                         int nWidth = 0;
 371                         int nHeight = 0;
 372                         int nMinY = 0;
 373                         int nMaxY = 0;
 374
 375                         evas_object_geometry_get(pMainLayout, NULL, NULL, &nWidth, &nHeight);
 376
 377                         if(MpUtilGetRotationState() == VIDEO_ROTATE_PORTRAIT_NORMAL ||
 378                                 MpUtilGetRotationState() == VIDEO_ROTATE_PORTRAIT_REVERSE)
 379                         {
 380                                 nMinY = (elm_config_scale_get() * 223);
 381                                 nMaxY = nHeight - ( elm_config_scale_get() * 215);
 382                         }
 383                         else
 384                         {
 385                                 nMinY = (elm_config_scale_get() * 223);
 386                                 nMaxY = nHeight - ( elm_config_scale_get() * 204);
 387                         }
 388
 389                         if(p->y > nMinY && p->y < nMaxY)
 390                         {
 391                                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideLayout(pAppData);
 392                         }
 393                 } else {
 394                         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowLayout(pAppData);
 395                 }
 396         }
 397
 398         return EVAS_EVENT_FLAG_NONE;
 399 }
 400
 401
 402 static Evas_Event_Flags MpVideoViewCtrlGestureNTabAbortCb(void *pUserData , void *pEventInfo)
 403 {
 404         VideoLogInfo("");
 405
 406         return EVAS_EVENT_FLAG_NONE;
 407 }
 408
 409 /*
 410  * Internal function.
 411  */
 412 static void MpVideoViewCtrlScreenRotationInit(int nRotateMode, void *pUserData)
 413 {
 414         if(!pUserData)
 415         {
 416                 VideoLogInfo("[ERR] No exist pUserData.");
 417                 return;
 418         }
 419
 420         VideoLogInfo("");
 421
 422         VideoAppData *pAppData = (VideoAppData *)pUserData;
 423
 424         MpUtilRotateWindow(nRotateMode, pAppData->pMainWindow);
 425         nVideoRotateType = nRotateMode;
 426         MpVideoViewCtrlSetRotation(nVideoRotateType, FALSE, pUserData);
 427 }
 428
 429 static Evas_Object *MpVideoViewCtrlCreateBg(Evas_Object *pWindow)
 430 {
 431         if(!pWindow)
 432         {
 433                 VideoLogError("[ERR]");
 434                 return NULL;
 435         }
 436
 437         VideoLogInfo("");
 438
 439         return NULL;
 440 }
 441
 442 void* MpVideoViewCtrlCreateConformant(void *pParent)
 443 {
 444         if(!pParent)
 445         {
 446                 VideoLogInfo("[ERR]");
 447                 return NULL;
 448         }
 449
 450         VideoLogInfo("");
 451
 452         Evas_Object *pTmpConform = NULL;
 453
 454         pTmpConform = elm_conformant_add(pParent);
 455         evas_object_size_hint_weight_set(pTmpConform, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 456         elm_win_conformant_set(pParent, EINA_TRUE);
 457         elm_win_resize_object_add(pParent, pTmpConform);
 458         evas_object_show(pTmpConform);
 459
 460         pConformant = pTmpConform;
 461
 462         return pTmpConform;
 463 }
 464
 465 static Evas_Object *MpVideoViewCtrlCreateMainLayout(Evas_Object *pParent)
 466 {
 467         if(!pParent)
 468         {
 469                 VideoLogInfo("[ERR]");
 470                 return NULL;
 471         }
 472
 473         VideoLogInfo("");
 474
 475         if(pMainLayout)
 476         {
 477                 evas_object_del(pMainLayout);
 478                 pMainLayout = NULL;
 479         }
 480
 481         pMainLayout = elm_layout_add(pParent);
 482
 483         elm_layout_theme_set(pMainLayout, "layout", "application", "video_no_indicator");
 484         evas_object_size_hint_weight_set(pMainLayout, EVAS_HINT_EXPAND, EVAS_HINT_EXPAND);
 485         elm_object_content_set(pParent, pMainLayout);
 486         pBackGround = MpVideoViewCtrlCreateBg(pParent);
 487         evas_object_show(pMainLayout);
 488
 489         return pMainLayout;
 490 }
 491
 492 static void MpVideoViewCtrlCreateEventRect(void *pUserData, Evas_Object *pParent)
 493 {
 494         if(!pUserData)
 495         {
 496                 VideoLogInfo("[ERR]");
 497                 return;
 498         }
 499
 500         if(!pParent)
 501         {
 502                 VideoLogInfo("[ERR]");
 503                 return;
 504 }
 505
 506         VideoLogInfo("");
 507
 508         pEventRect = evas_object_rectangle_add(evas_object_evas_get(pParent));
 509         evas_object_color_set(pEventRect, 0, 0, 0, 0);
 510
 511         elm_object_part_content_set(pParent, "elm.swallow.event", pEventRect);
 512
 513         pGesture = elm_gesture_layer_add(pEventRect);
 514
 515         elm_gesture_layer_cb_set(pGesture, ELM_GESTURE_N_TAPS, ELM_GESTURE_STATE_START, MpVideoViewCtrlGestureNTabStartCb, pUserData);
 516         elm_gesture_layer_cb_set(pGesture, ELM_GESTURE_N_TAPS, ELM_GESTURE_STATE_END, MpVideoViewCtrlGestureNTabEndCb, pUserData);
 517         elm_gesture_layer_cb_set(pGesture, ELM_GESTURE_N_TAPS, ELM_GESTURE_STATE_ABORT, MpVideoViewCtrlGestureNTabAbortCb, pUserData);
 518
 519         evas_object_repeat_events_set(pEventRect, EINA_TRUE);
 520
 521         elm_gesture_layer_attach(pGesture, pEventRect);
 522
 523         evas_object_show(pEventRect);
 524
 525
 526 }
 527 static Evas_Object *MpVideoViewCtrlCreateVolume(void *pUserData, Evas_Object *pParent)
 528 {
 529         if(!pParent)
 530         {
 531                 VideoLogInfo("[ERR]");
 532                 return NULL;
 533         }
 534
 535         VideoLogInfo("");
 536
 537         if(pDisplayViewVolume)
 538         {
 539                 evas_object_del(pDisplayViewVolume);
 540                 pDisplayViewVolume = NULL;
 541         }
 542
 543         pDisplayViewVolume = MpVideoVolumeCtrlInit(pParent, pUserData);
 544
 545         return pDisplayViewVolume;
 546 }
 547
 548 static void MpVideoViewCtrlShowNaviFrame(void)
 549 {
 550         VideoLogInfo("");
 551
 552         if(pNaviFrame)
 553         {
 554                 elm_object_part_content_set(pMainLayout, "elm.swallow.content", pNaviFrame);
 555                 evas_object_show(pNaviFrame);
 556         }
 557         }
 558
 559 static Evas_Object *MpVideoViewCtrlCreateNaviFrame(Evas_Object *pParent, void* pUserData)
 560 {
 561         if(!pParent)
 562         {
 563                 VideoLogInfo("[ERR]");
 564                 return NULL;
 565         }
 566
 567         VideoLogInfo("");
 568
 569         if(pNaviFrame)
 570         {
 571                 evas_object_del(pNaviFrame);
 572                 pNaviFrame = NULL;
 573         }
 574
 575         pNaviFrame = elm_naviframe_add(pParent);
 576
 577         elm_object_part_content_set(pParent, "elm.swallow.content", pNaviFrame);
 578
 579         elm_naviframe_prev_btn_auto_pushed_set(pNaviFrame, EINA_FALSE);
 580
 581         evas_object_show(pNaviFrame);
 582
 583         return pNaviFrame;
 584 }
 585
 586 static void MpVideoViewCtrlSetVideoViews(VideoAppData *pAppData, int nPlayerType)
 587 {
 588         VideoLogInfo("%p",pAppData);
 589
 590         MpVideoServiceCtrlSetPlayerType(nPlayerType);
 591
 592         switch(nPlayerType)
 593         {
 594         case MP_VIDEO_PLAYER:
 595                 VideoLogInfo("MP_VIDEO_PLAYER");
 596                 MpUtilMultimediaVolumeKeyGrab();
 597                 MpVideoDisplayViewPush((void *)pNaviFrame, nPlayerType, (void *)pAppData, MpVideoViewCtrlChangeViewCb);
 598                 break;
 599
 600         case MP_VIDEO_PLAYER_SIMPLE:
 601                 VideoLogInfo("MP_VIDEO_PLAYER_SIMPLE");
 602                 MpUtilMultimediaVolumeKeyGrab();
 603                 MpVideoDisplayViewPush((void *)pNaviFrame, nPlayerType, (void *)pAppData, MpVideoViewCtrlChangeViewCb);
 604                 break;
 605
 606         case MP_VIDEO_PLAYER_EMAIL:
 607                 VideoLogInfo("MP_VIDEO_PLAYER_EMAIL");
 608                 MpUtilMultimediaVolumeKeyGrab();
 609                 MpVideoDisplayViewPush((void *)pNaviFrame, nPlayerType, (void *)pAppData, MpVideoViewCtrlChangeViewCb);
 610                 break;
 611
 612         case MP_VIDEO_PLAYER_MMS:
 613                 VideoLogInfo("MP_VIDEO_PLAYER_MMS");
 614                 MpUtilMultimediaVolumeKeyGrab();
 615                 MpVideoDisplayViewPush((void *)pNaviFrame, nPlayerType, (void *)pAppData, MpVideoViewCtrlChangeViewCb);
 616                 break;
 617
 618         case MP_VIDEO_PLAYER_GALLERY:
 619                 VideoLogInfo("MP_VIDEO_PLAYER_GALLERY");
 620                 MpUtilMultimediaVolumeKeyGrab();
 621                 MpVideoDisplayViewPush((void *)pNaviFrame, nPlayerType, (void *)pAppData, MpVideoViewCtrlChangeViewCb);
 622                 break;
 623
 624         case MP_STREAMING_PLAYER:
 625                 VideoLogInfo("MP_STREAMING_PLAYER");
 626                 MpUtilMultimediaVolumeKeyGrab();
 627                 MpVideoStreamingViewPush((void *)pNaviFrame, nPlayerType, (void *)pAppData, MpVideoViewCtrlChangeViewCb);
 628                 break;
 629
 630         default:
 631                 VideoLogInfo("[ERR] No exist player tpye.");
 632                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 633         }
 634 }
 635
 636 static Eina_Bool MpVideoVideoViewCtrlSpeedKeyLongPressCb(void *pUserData)
 637 {
 638         if(!pUserData)
 639         {
 640                 VideoLogInfo("[ERR]");
 641                 return EINA_FALSE;
 642         }
 643
 644         VideoLogInfo("");
 645
 646         VideoAppData *pAppData = (VideoAppData *)pUserData;
 647
 648         if(pAppData->nPlayingSpeed > MP_PLAYING_SPEED_MAX)
 649         {
 650                 if(pLongPressSpeedPlayingTimer)
 651                 {
 652                         ecore_timer_del(pLongPressSpeedPlayingTimer);
 653                         pLongPressSpeedPlayingTimer = NULL;
 654                 }
 655
 656                 return EINA_FALSE;
 657         }
 658
 659         ++pAppData->nPlayingSpeed;
 660
 661         if(bIsLongPressForward)
 662         {
 663                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedFF(pAppData);
 664         }
 665         else
 666         {
 667                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedRew(pAppData);
 668         }
 669
 670         return EINA_TRUE;
 671 }
 672
 673 static void MpVideoVideoViewCtrlLongpressSpeedKeyDown(void *pUserData)
 674 {
 675         if(!pUserData)
 676         {
 677                 VideoLogInfo("No exist pUserData.");
 678                 return;
 679         }
 680
 681         VideoLogInfo("");
 682
 683         VideoAppData *pAppData = (VideoAppData *)pUserData;
 684
 685         pAppData->nPlayingSpeed = MP_PLAYING_SPEED_2X;
 686
 687         if(bIsLongPressForward)
 688         {
 689                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedFF(pAppData);
 690         }
 691         else
 692         {
 693                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedRew(pAppData);
 694         }
 695
 696         if(pLongPressSpeedPlayingTimer)
 697         {
 698                 ecore_timer_del(pLongPressSpeedPlayingTimer);
 699                 pLongPressSpeedPlayingTimer = NULL;
 700         }
 701
 702         pLongPressSpeedPlayingTimer = ecore_timer_add(MULTIMEDIA_KEY_LONG_PRESS_INTERVAL, MpVideoVideoViewCtrlSpeedKeyLongPressCb, (void *)pAppData);
 703 }
 704
 705 static void MpVideoVideoViewCtrlLongpressSpeedKeyUp(void *pUserData)
 706 {
 707         if(!pUserData)
 708         {
 709                 VideoLogInfo("No exist pUserData.");
 710                 return;
 711         }
 712
 713         VideoLogInfo("");
 714
 715         VideoAppData *pAppData = (VideoAppData *)pUserData;
 716
 717         bIsLongPressForward = FALSE;
 718
 719         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedReset(pAppData);
 720
 721         if(pLongPressSpeedPlayingTimer)
 722         {
 723                 ecore_timer_del(pLongPressSpeedPlayingTimer);
 724                 pLongPressSpeedPlayingTimer = NULL;
 725         }
 726 }
 727
 728 static void MpVideoViewCtrlChangeViewCb(int nChangePlayerView, void *pUserData)
 729 {
 730         if(!pUserData)
 731         {
 732                 VideoLogInfo("[ERR]");
 733                 return;
 734         }
 735
 736         VideoLogInfo("");
 737
 738         VideoAppData *pAppData = (VideoAppData *)pUserData;
 739
 740         MpVideoViewCtrlHideVolume();
 741
 742         MpVideoViewCtrlSetVideoViews((VideoAppData*)pUserData, nChangePlayerView);
 743
 744                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlReLaunching(pAppData);
 745         }
 746
 747 /*
 748  * External function.
 749  */
 750 bool MpVideoViewCtrlInit(VideoAppData *pAppData)
 751 {
 752         if(!pAppData)
 753         {
 754                 VideoLogInfo("[ERR]");
 755                 return FALSE;
 756         }
 757
 758         VideoLogInfo("");
 759
 760         if(pHWKeyEventDownHandler)
 761         {
 762                 ecore_event_handler_del(pHWKeyEventDownHandler);
 763                 pHWKeyEventDownHandler = NULL;
 764         }
 765
 766         if(pHWKeyEventUpHandler)
 767         {
 768                 ecore_event_handler_del(pHWKeyEventUpHandler);
 769                 pHWKeyEventUpHandler = NULL;
 770         }
 771
 772         pHWKeyEventDownHandler = ecore_event_handler_add(ECORE_EVENT_KEY_DOWN, (void *)MpVideoViewCtrlHardkeyDownCb, (void *)pAppData);
 773         pHWKeyEventUpHandler = ecore_event_handler_add(ECORE_EVENT_KEY_UP, (void *)MpVideoViewCtrlHardkeyUpCb, (void *)pAppData);
 774
 775         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
 776
 777         MpVideoViewCtrlCreateConformant(pAppData->pMainWindow);
 778         MpVideoViewCtrlCreateMainLayout(pConformant);
 779         MpVideoViewCtrlCreateEventRect((void *)pAppData, pMainLayout);
 780         MpVideoViewCtrlCreateVolume(pAppData, pMainLayout);
 781         MpVideoViewCtrlCreateNaviFrame(pMainLayout, (void*)pAppData);
 782         MpVideoViewCtrlSetVideoViews(pAppData, MpVideoServiceCtrlGetPlayerType());
 783         MpVideoViewCtrlScreenRotationInit(MpUtilGetRotationState(), (void *)pAppData);
 784
 785         return TRUE;
 786 }
 787
 788 void MpVideoViewCtrlDestroy(void *pUserData)
 789 {
 790         if(!pUserData)
 791         {
 792                 VideoLogInfo("[ERR]");
 793                 return;
 794         }
 795
 796         VideoLogInfo("");
 797
 798         MpExternalUgUnload();
 799
 800         MpVideoVolumeCtrlDestroy();
 801
 802         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 803
 804         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 805                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 806                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 807                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 808                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 809         {
 810                 MpVideoDisplayViewDestroy(pUserData);
 811         }
 812         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 813         {
 814                 MpVideoStreamingViewDestroy(pUserData);
 815         }
 816
 817         if(pGesture)
 818         {
 819                 evas_object_del(pGesture);
 820                 pGesture = NULL;
 821         }
 822
 823         if(pEventRect)
 824         {
 825                 evas_object_del(pEventRect);
 826                 pEventRect = NULL;
 827         }
 828
 829         if(pHWKeyEventDownHandler)
 830         {
 831                 ecore_event_handler_del(pHWKeyEventDownHandler);
 832                 pHWKeyEventDownHandler = NULL;
 833         }
 834
 835         if(pHWKeyEventUpHandler)
 836         {
 837                 ecore_event_handler_del(pHWKeyEventUpHandler);
 838                 pHWKeyEventUpHandler = NULL;
 839         }
 840
 841         if(pMainLayout)
 842         {
 843                 evas_object_del(pMainLayout);
 844                 pMainLayout = NULL;
 845         }
 846
 847         if(pLongPressSpeedPlayingTimer)
 848         {
 849                 ecore_timer_del(pLongPressSpeedPlayingTimer);
 850                 pLongPressSpeedPlayingTimer = NULL;
 851         }
 852
 853         if(pLongPressVolumeKeyTimer)
 854         {
 855                 ecore_timer_del(pLongPressVolumeKeyTimer);
 856                 pLongPressVolumeKeyTimer = NULL;
 857         }
 858
 859         if(pLayoutVisibleOffTimer)
 860         {
 861                 ecore_timer_del(pLayoutVisibleOffTimer);
 862                 pLayoutVisibleOffTimer = NULL;
 863         }
 864
 865         if(pDisplayViewVolume)
 866         {
 867                 evas_object_del(pDisplayViewVolume);
 868                 pDisplayViewVolume = NULL;
 869         }
 870
 871         if(pBackGround)
 872         {
 873                 evas_object_del(pBackGround);
 874                 pBackGround = NULL;
 875         }
 876
 877         bIsLongPressForward = FALSE;
 878         bIsKeyCancle = FALSE;
 879
 880         nVideoRotateType = VIDEO_ROTATE_PORTRAIT_NORMAL;
 881 }
 882
 883 void MpVideoViewCtrlSetRotation(int nRotateMode, bool bLayoutHide, void *pUserData)
 884 {
 885         if(!pUserData)
 886         {
 887                 VideoLogInfo("[ERR] No exist pUserData.");
 888                 return;
 889         }
 890
 891         VideoLogInfo("");
 892
 893         VideoAppData *pAppData = (VideoAppData *)pUserData;
 894
 895         if(nRotateMode == VIDEO_ROTATE_UNKNOWN)
 896         {
 897                 nRotateMode = MpUtilGetRotationState();
 898         }
 899
 900         nVideoRotateType = nRotateMode;
 901
 902         MpUtilSetRotationState(nVideoRotateType);
 903
 904         if(MpVideoVolumeCtrlGetShowStatus())
 905         {
 906                 MpVideoViewCtrlHideVolume();
 907         }
 908
 909         if(nVideoRotateType == VIDEO_ROTATE_PORTRAIT_NORMAL || nVideoRotateType == VIDEO_ROTATE_PORTRAIT_REVERSE)
 910         {
 911                 edje_object_signal_emit(_EDJ(pMainLayout), SIGNAL_VOLUME_PORTRAIT_MODE, "*");
 912         }
 913         else if(nVideoRotateType == VIDEO_ROTATE_LANDSCAPE_NORMAL || nVideoRotateType == VIDEO_ROTATE_LANDSCAPE_REVERSE)
 914         {
 915                 edje_object_signal_emit(_EDJ(pMainLayout), SIGNAL_VOLUME_LANDSCAPE_MODE, "*");
 916         }
 917
 918         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 919
 920         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 921                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 922                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 923                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 924                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 925         {
 926                 if(nVideoRotateType == VIDEO_ROTATE_PORTRAIT_NORMAL || nVideoRotateType == VIDEO_ROTATE_PORTRAIT_REVERSE)
 927                 {
 928                         MpVideoDisplayViewPortrate(bLayoutHide, pUserData);
 929                 }
 930                 else if(nVideoRotateType == VIDEO_ROTATE_LANDSCAPE_NORMAL || nVideoRotateType == VIDEO_ROTATE_LANDSCAPE_REVERSE)
 931                 {
 932                         MpVideoDisplayViewLandscape(bLayoutHide, pUserData);
 933                 }
 934         }
 935         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 936         {
 937                 MpVideoStreamingViewRotation((void *)pAppData, nVideoRotateType, bLayoutHide);
 938         }
 939
 940         MpUtilRotateWindow(nVideoRotateType, pAppData->pMainWindow);
 941
 942         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlRotateScreen(pAppData, nVideoRotateType);
 943 }
 944
 945 void MpVideoViewCtrlInitAfterBeginOfStream(void *pUserData)
 946 {
 947         if(!pUserData)
 948         {
 949                 VideoLogInfo("[ERR]");
 950                 return;
 951         }
 952
 953         VideoLogInfo("");
 954
 955         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 956
 957         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 958                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 959                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 960                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 961                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 962         {
 963                 MpVideoDisplayViewInitAfterBeginOfStream(pUserData);
 964         }
 965         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 966         {
 967                 MpVideoStreamingViewInitAfterBeginOfStream(pUserData);
 968         }
 969 }
 970
 971 void MpVideoViewCtrlPause(void *pUserData)
 972 {
 973         if(!pUserData)
 974         {
 975                 VideoLogInfo("[ERR]");
 976                 return;
 977         }
 978
 979         VideoLogInfo("");
 980
 981         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 982
 983         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 984                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 985                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 986                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 987                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 988         {
 989                 MpVideoDisplayViewUpdatePauseKey();
 990         }
 991         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 992         {
 993                 MpVideoStreamingViewUpdatePauseKey();
 994         }
 995 }
 996
 997 void MpVideoViewCtrlResume(void *pUserData)
 998 {
 999         if(!pUserData)
1000         {
1001                 VideoLogInfo("[ERR]");
1002                 return;
1003         }
1004
1005         VideoLogInfo("");
1006
1007         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1008
1009         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1010                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1011                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1012                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1013                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1014         {
1015                 MpVideoDisplayViewUpdateResumeKey();
1016         }
1017         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1018         {
1019                 MpVideoStreamingViewUpdateResumeKey();
1020         }
1021 }
1022
1023 void MpVideoViewShowLayout(void *pUserData)
1024 {
1025         if(!pUserData)
1026         {
1027                 VideoLogInfo("[ERR]");
1028                 return;
1029         }
1030
1031         VideoLogInfo("");
1032
1033         VideoAppData *pAppData = (VideoAppData *)pUserData;
1034
1035         if(pLayoutVisibleOffTimer)
1036         {
1037                 ecore_timer_del(pLayoutVisibleOffTimer);
1038                 pLayoutVisibleOffTimer = NULL;
1039         }
1040
1041         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1042
1043         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1044                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1045                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1046                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1047                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1048         {
1049                 edje_object_signal_emit(_EDJ(pMainLayout), SIGNAL_LAYOUT_INDICATOR_SHOW, "*");
1050                         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
1051                         MpVideoViewCtrlShowNaviFrame();
1052                         bShowLayout = TRUE;
1053
1054                         MpVideoDisplayViewActivate();
1055                         MpVideoDisplayViewShowControlPanel(pUserData);
1056                 }
1057         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1058         {
1059                 edje_object_signal_emit(_EDJ(pMainLayout), SIGNAL_LAYOUT_INDICATOR_SHOW, "*");
1060                         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
1061                         MpVideoViewCtrlShowNaviFrame();
1062                         bShowLayout = TRUE;
1063
1064                 MpVideoStreamingViewActivate();
1065                 MpVideoStreamingViewShowControlPanel(pUserData);
1066         }
1067 }
1068
1069 void MpVideoViewHideLayout(void *pUserData)
1070 {
1071         if(!pUserData)
1072         {
1073                 VideoLogInfo("[ERR]");
1074                 return;
1075         }
1076
1077         VideoLogInfo("");
1078
1079         VideoAppData *pAppData = (VideoAppData *)pUserData;
1080
1081         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1082
1083         if(nTmpPlayerType == MP_STREAMING_PLAYER)
1084         {
1085                 if(MpVideoStreamingViewGetBufferingState())
1086                 {
1087                         VideoLogInfo("skip for Buffering");
1088                         return;
1089                 }
1090         }
1091
1092         edje_object_signal_emit(_EDJ(pMainLayout), SIGNAL_LAYOUT_INDICATOR_HIDE, "*");
1093         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_HIDE);
1094
1095         bShowLayout = FALSE;
1096
1097         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1098                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1099                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1100                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1101                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1102         {
1103                 MpVideoDisplayViewHideControlPanel(pUserData);
1104         }
1105         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1106         {
1107                 MpVideoStreamingViewHideControlPanel(pUserData);
1108         }
1109 }
1110 void MpVideoViewCtrlShowFinish(void *pUserData)
1111 {
1112         VideoLogInfo("");
1113
1114 }
1115
1116 void MpVideoViewCtrlHideFinish(void *pUserData, bool bLayoutOff)
1117 {
1118         if(!pUserData)
1119         {
1120                 VideoLogError("[ERR]");
1121                 return;
1122         }
1123
1124         VideoLogInfo("");
1125
1126         VideoAppData *pAppData = (VideoAppData *)pUserData;
1127
1128         if(pNaviFrame)
1129         {
1130                 elm_object_part_content_unset(pMainLayout, "elm.swallow.content");
1131                 evas_object_hide(pNaviFrame);
1132         }
1133
1134         if(pLayoutVisibleOffTimer)
1135         {
1136                 ecore_timer_del(pLayoutVisibleOffTimer);
1137                 pLayoutVisibleOffTimer = NULL;
1138         }
1139
1140         if(bLayoutOff)
1141         {
1142                 pLayoutVisibleOffTimer = ecore_timer_add(LAYOUT_VISIBLE_OFF_TIMER_INTERVAL, MpVideoViewCtrlLayoutVisibleOffTimerCb, (void *)pAppData);
1143         }
1144
1145
1146 }
1147
1148 void MpVideoViewSetBufferingRateForStreamingView(int nSetBufferingRate, void *pUserData)
1149 {
1150         if(!pUserData)
1151         {
1152                 VideoLogInfo("[ERR]");
1153                 return;
1154         }
1155
1156 //      VideoLogInfo("");
1157
1158         VideoAppData *pAppData = (VideoAppData *)pUserData;
1159
1160         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
1161
1162         if(nTmpPlayerType == MP_STREAMING_PLAYER)
1163         {
1164                 if(MpUtilCheckRTSPType(pAppData->szMediaUri))
1165                 {
1166                         if(nSetBufferingRate == 0)
1167                         {
1168                                 MpVideoStreamingViewSetBufferingRate(-1);
1169                         }
1170                         else
1171                         {
1172                                 MpVideoStreamingViewSetBufferingRate(nSetBufferingRate);
1173                         }
1174                 }
1175                 else
1176                 {
1177                         if(nSetBufferingRate >= 0)
1178                         {
1179                                 MpVideoStreamingViewSetBufferingRate(nSetBufferingRate);
1180                         }
1181                 }
1182         }
1183 }
1184
1185 void MpVideoViewCtrlChangeTitle(void *pUserData)
1186 {
1187         if(!pUserData)
1188         {
1189                 VideoLogInfo("[ERR]");
1190                 return;
1191         }
1192
1193         VideoLogInfo("");
1194
1195         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1196
1197         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1198                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1199                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1200                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1201                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1202         {
1203                 VideoAppData *pAppData = (VideoAppData *)pUserData;
1204
1205                 memset(pAppData->szSubtitle, 0, sizeof(char) * STR_LEN_MAX);
1206
1207                 MpVideoDisplayViewChangeNaviFrameTitle(pUserData);
1208         }
1209 }
1210
1211 bool MpVideoViewCtrlIsTopView(void *pUserData)
1212 {
1213         if(!pUserData)
1214         {
1215                 VideoLogInfo("[ERR]");
1216                 return FALSE;
1217         }
1218
1219         VideoLogInfo("");
1220
1221         bool bIstopView = FALSE;
1222
1223         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1224
1225         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1226                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1227                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1228                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1229                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1230         {
1231                 VideoLogInfo("VIDEO PLAYER");
1232                 bIstopView = MpVideoDisplayViewIsTopView();
1233         }
1234         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1235         {
1236                 VideoLogInfo("STREAMING PLAYER");
1237                 bIstopView = MpVideoStreamingViewIsTopView();
1238         }
1239
1240         return bIstopView;
1241 }
1242
1243 void MpVideoViewCtrlShowNocontentImage(void *pUserData)
1244 {
1245         if(!pUserData)
1246         {
1247                 VideoLogInfo("[ERR]");
1248                 return;
1249         }
1250
1251         VideoLogInfo("");
1252
1253         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1254
1255         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1256                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1257                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1258                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1259                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1260         {
1261                 MpVideoDisplayViewShowNocontentImage(pUserData);
1262         }
1263         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1264         {
1265                 MpVideoStreamingViewShowNocontentImage(pUserData);
1266         }
1267 }
1268
1269 void MpVideoViewCtrlHideNocontentImage(void *pUserData)
1270 {
1271         if(!pUserData)
1272         {
1273                 VideoLogInfo("[ERR]");
1274                 return;
1275         }
1276
1277         VideoLogInfo("");
1278
1279         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1280
1281         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1282                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1283                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1284                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1285                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1286         {
1287                 MpVideoDisplayViewHideNocontentImage();
1288         }
1289         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1290         {
1291                 MpVideoStreamingViewHideNocontentImage();
1292         }
1293 }
1294
1295 void MpVideoViewCtrlResetProgressBar(void *pUserData)
1296 {
1297         VideoLogInfo("");
1298
1299         MpVideoDisplayViewResetProgressBar(pUserData);
1300 }
1301
1302 void MpVideoViewCtrlUpdateProgressbar(void *pUserData)
1303 {
1304         if(!pUserData)
1305         {
1306                 VideoLogInfo("No exist pUserData.");
1307                 return;
1308         }
1309         VideoLogInfo("");
1310         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1311
1312         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1313                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1314                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1315                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1316                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1317         {
1318                 VideoLogInfo("VIDEO PLAYER");
1319                 MpVideoDisplayViewUpdateProgressBar(pUserData);
1320         }
1321         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
1322         {
1323                 VideoLogInfo("STREAMING PLAYER");
1324                 MpVideoStreamingViewUpdateProgressBar(pUserData);
1325         }
1326 }
1327
1328
1329 bool MpVideoViewCtrlIsPauseByUser(void *pUserData)
1330 {
1331         if(!pUserData)
1332 {
1333                 VideoLogInfo("[ERR]");
1334                 return FALSE;
1335         }
1336
1337         VideoLogInfo("");
1338
1339         return MpVideoDisplayViewIsPauseByUser();
1340 }
1341
1342 void MpVideoViewCtrlShowVolume()
1343 {
1344         VideoLogInfo("");
1345
1346         if(MpVideoVolumeCtrlGetShowStatus())
1347         {
1348                 return;
1349         }
1350
1351         elm_object_part_content_set(pMainLayout, "elm.swallow.volume", pDisplayViewVolume);
1352
1353         MpVideoVolumeCtrlShow();
1354
1355 }
1356 void MpVideoViewCtrlHideVolume()
1357 {
1358         VideoLogInfo("");
1359
1360         if(pLongPressVolumeKeyTimer)
1361         {
1362                 ecore_timer_del(pLongPressVolumeKeyTimer);
1363                 pLongPressVolumeKeyTimer = NULL;
1364         }
1365
1366         elm_object_part_content_unset(pMainLayout, "elm.swallow.volume");
1367
1368         MpVideoVolumeCtrlHide();
1369
1370 }