src/mp-video-app-ctrl.c

   1 /*
   2  * Copyright (c) [2012] Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Flora License, Version 1.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://floralicense.org/license/
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17
  18 #include <app.h>
  19 #include <player.h>
  20 #include <mm_util_imgp.h>
  21 #include <image_util.h>
  22
  23 #include "mp-util.h"
  24 #include "mp-video-log.h"
  25 #include "mp-video-app-ctrl.h"
  26 #include "mp-video-view-mgr.h"
  27 #include "mp-util-media-service.h"
  28 #include "mp-video-value-define.h"
  29 #include "mp-video-string-define.h"
  30 #include "mp-video-streaming-ctrl.h"
  31 #include "mp-external-ug.h"
  32 #include "mp-video-ctrl-mgr.h"
  33 #include "mp-video-service-ctrl.h"
  34
  35 static int nPlayerErrorType = 0;
  36 static int nPlayerInterruptType = 0;
  37 static int nBufferingRate = 0;
  38 static bool bWindowForegroundState = FALSE;
  39
  40 static MpPlayerInterrupteType   g_nCurrentInterrupt = MP_PLAYER_INTERRUPTED_COMPLETED;
  41
  42 static Ecore_Pipe       *pEcorePipeHandleForErrorMsg = NULL;
  43 static Ecore_Pipe       *pEcorePipeHandleBOF = NULL;
  44 static Ecore_Pipe       *pEcorePipeHandleEOF = NULL;
  45 static Ecore_Pipe       *pEcorePipeHandleForBuffering = NULL;
  46 static Ecore_Pipe       *pEcorePipeHandleForResumed = NULL;
  47 static Ecore_Pipe       *pEcorePipeHandleForInterruped = NULL;
  48 static Ecore_Pipe       *pEcorePipeHandlerForSeekComplete = NULL;
  49
  50
  51 static void MpVideoAppCtrlStart(VideoAppData *pAppData);
  52 static void MpVideoAppCtrlStop(VideoAppData *pAppData);
  53 static void MpVideoAppCtrlPause(VideoAppData *pAppData);
  54 static void MpVideoAppCtrlResume(VideoAppData *pAppData);
  55 static void MpVideoAppCtrlStopByAppPause(VideoAppData *pAppData);
  56 static void MpVideoAppCtrlStartByAppResume(VideoAppData *pAppData);
  57 static void MpVideoAppCtrlFFDown(VideoAppData *pAppData);
  58 static void MpVideoAppCtrlRewDown(VideoAppData *pAppData);
  59 static void MpVideoAppCtrlFFUp(VideoAppData *pAppData);
  60 static void MpVideoAppCtrlRewUp(VideoAppData *pAppData);
  61 static void MpVideoAppCtrlSpeedReset(VideoAppData *pAppData);
  62 static void MpVideoAppCtrlSpeedFF(VideoAppData *pAppData);
  63 static void MpVideoAppCtrlSpeedRew(VideoAppData *pAppData);
  64 static void MpVideoAppCtrlRotateScreen(VideoAppData *pAppData, int nRotateState);
  65 static void MpVideoAppCtrlGetPosition(VideoAppData *pAppData);
  66 static void MpVideoAppCtrlSetPosition(VideoAppData *pAppData);
  67 static void MpVideoAppCtrlHideLayout(VideoAppData *pAppData);
  68 static void MpVideoAppCtrlShowLayout(VideoAppData *pAppData);
  69 static void MpVideoAppCtrlHideFinish(VideoAppData *pAppData);
  70 static void MpVideoAppCtrlShowFinish(VideoAppData *pAppData);
  71 static void MpVideoAppCtrlGetVideoResolution(VideoAppData *pAppData);
  72 static void MpVideoAppCtrlReqDurationTime(VideoAppData *pAppData);
  73 static void MpVideoAppCtrlBeginOfStream(VideoAppData *pAppData);
  74 static void MpVideoAppCtrlEndOfStream(VideoAppData *pAppData);
  75 static void MpVideoAppCtrlExit(VideoAppData *pAppData);
  76 static void MpVideoAppCtrlStartStreaming(VideoAppData *pAppData);
  77 static void MpVideoAppCtrlReLaunching(VideoAppData *pAppData);
  78 static void MpVideoAppCtrlGetBufferingPosition(VideoAppData *pAppData);
  79 static void MpVideoAppCtrlPipeInit(VideoAppData *pAppData);
  80 static void MpVideoAppCtrlShowVolume(VideoAppData *pAppData);
  81 static void MpVideoAppCtrlHideVolume(VideoAppData *pAppData);
  82
  83
  84 /*
  85  * Callback function
  86  */
  87
  88 static void MpVideoAppCtrlUnSupportFormatErrorCb(void *pUserData, Evas_Object *pObject, void *pEventInfo)
  89 {
  90         if(!pUserData)
  91         {
  92                 VideoLogInfo("[ERR] No exist pUserData");
  93                 return;
  94         }
  95
  96         VideoLogInfo("");
  97
  98         VideoAppData *pAppData = (VideoAppData *)pUserData;
  99
 100         MpUtilLcdNormalPowerUnlockForPause();
 101
 102         MpVideoAppCtrlEndOfStream(pAppData);
 103 }
 104
 105
 106 static void MpVideoAppCtrlExitCb(void *pUserData, Evas_Object *pObject, void *pEventInfo)
 107 {
 108         if(!pUserData)
 109         {
 110                 VideoLogInfo("[ERR] No exist pUserData");
 111                 return;
 112         }
 113
 114         VideoLogInfo("");
 115
 116         VideoAppData *pAppData = (VideoAppData *)pUserData;
 117
 118         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit(pAppData);
 119 }
 120
 121 static int MpVideoAppCtrlPauseByInterrupteCb(void *pUserData)
 122 {
 123         if(!pUserData)
 124         {
 125                 VideoLogInfo("[ERR] No exist pUserData");
 126                 return 0;
 127         }
 128
 129         VideoLogInfo("");
 130
 131         VideoAppData *pAppData = (VideoAppData *)pUserData;
 132
 133         MpVideoAppCtrlPause(pAppData);
 134
 135         g_nCurrentInterrupt = nPlayerInterruptType;
 136
 137         switch(nPlayerInterruptType)
 138         {
 139         case MP_PLAYER_INTERRUPTED_COMPLETED:
 140                 VideoLogInfo("MP_PLAYER_INTERRUPTED_COMPLETED");
 141                 break;
 142
 143         case MP_PLAYER_INTERRUPTED_BY_OTHER_APP:
 144                 VideoLogInfo("MP_PLAYER_INTERRUPTED_BY_OTHER_APP");
 145                 break;
 146
 147         case MP_PLAYER_INTERRUPTED_BY_CALL:
 148                 VideoLogInfo("MP_PLAYER_INTERRUPTED_BY_CALL");
 149                 break;
 150
 151         case MP_PLAYER_INTERRUPTED_BY_EARJACK_UNPLUG:
 152                 VideoLogInfo("MP_PLAYER_INTERRUPTED_BY_EARJACK_UNPLUG");
 153                 break;
 154
 155         case MP_PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT:
 156                 VideoLogInfo("MP_PLAYER_INTERRUPTED_BY_RESOURCE_CONFLICT");
 157                 break;
 158
 159         case MP_PLAYER_INTERRUPTED_BY_ALARM:
 160                 VideoLogInfo("MP_PLAYER_INTERRUPTED_BY_ALARM");
 161                 break;
 162
 163         default:
 164                 VideoLogInfo("OTHER");
 165                 break;
 166         }
 167
 168         return 0;
 169 }
 170
 171 static int MpVideoAppCtrlBeginOfPlayCb(void *pUserData)
 172 {
 173         if(!pUserData)
 174         {
 175                 VideoLogInfo("[ERR] No exist pUserData");
 176                 return 0;
 177         }
 178
 179         VideoLogInfo("");
 180
 181         VideoAppData *pAppData = (VideoAppData *)pUserData;
 182
 183         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
 184         if(nTmpPlayerType == MP_STREAMING_PLAYER)
 185         {
 186                 MpVideoCtrlMgrMediaPlay((void *)pAppData);
 187
 188                 pAppData->bStartSeek = FALSE;
 189
 190                 if(pAppData->nSetPosition > 0)
 191                 {
 192                         VideoLogInfo("Start position time : %dms", pAppData->nSetPosition);
 193                         MpVideoAppCtrlSetPosition(pAppData);
 194                 }
 195
 196         }
 197         else
 198         {
 199                 pAppData->bStartSeek = FALSE;
 200                 if(pAppData->nSetPosition > 0)
 201                 {
 202                         VideoLogInfo("Pending seek position time : %dms", pAppData->nSetPosition);
 203                         MpVideoAppCtrlSetPosition(pAppData);
 204                         pAppData->bStartSeek = TRUE;
 205                 }
 206
 207                 if(MpVideoViewCtrlIsPauseByUser((void *)pAppData))
 208                 {
 209                         MpVideoCtrlMgrSetMute(TRUE);
 210                 }
 211
 212                 if(!pAppData->bStartSeek)
 213                 {
 214                         MpVideoCtrlMgrMediaPlay((void *)pAppData);
 215                 }
 216         }
 217
 218         MpVideoAppCtrlBeginOfStream(pAppData);
 219         MpUtilLcdNormalPowerLockForResume();
 220
 221         return 0;
 222 }
 223
 224 static int MpVideoAppCtrlEndOfPlayCb(void *pUserData)
 225 {
 226         if(!pUserData)
 227         {
 228                 VideoLogInfo("[ERR] No exist pUserData");
 229                 return 0;
 230         }
 231
 232         VideoLogInfo("");
 233
 234         VideoAppData *pAppData = (VideoAppData *)pUserData;
 235
 236         MpVideoViewCtrlPause(pAppData);
 237         MpVideoAppCtrlStop(pAppData);
 238         MpVideoCtrlMgrMediaDestroy(pAppData);
 239
 240         MpUtilLcdNormalPowerUnlockForPause();
 241
 242         MpVideoAppCtrlEndOfStream(pAppData);
 243
 244         return 0;
 245 }
 246
 247 static int MpVideoAppCtrlBufferingCb(void *pUserData)
 248 {
 249         if(!pUserData)
 250         {
 251                 VideoLogInfo("No exist pUserData");
 252                 return 0;
 253         }
 254
 255         if(nBufferingRate < 10)
 256         {
 257                 MpVideoAppCtrlShowLayout((VideoAppData *)pUserData);
 258         }
 259
 260         MpVideoViewSetBufferingRateForStreamingView(nBufferingRate, pUserData);
 261
 262         return 0;
 263 }
 264
 265 static int MpVideoAppCtrlSeekCompletePipeCb(void *pUserData)
 266 {
 267         if(!pUserData)
 268         {
 269                 VideoLogInfo("[ERR] No exist pUserData");
 270                 return 0;
 271         }
 272
 273         VideoLogInfo("");
 274
 275         VideoAppData *pAppData = (VideoAppData *)pUserData;
 276
 277         if(pAppData->bStartSeek)
 278         {
 279                 MpVideoCtrlMgrMediaPlay((void *)pAppData);
 280                 MpVideoAppCtrlBeginOfStream(pAppData);
 281                 MpUtilLcdNormalPowerLockForResume();
 282                 pAppData->bStartSeek = FALSE;
 283         }
 284
 285         pAppData->bSeekComplete = TRUE;
 286
 287         if(pAppData->nSeekPosition > 0) {
 288                 pAppData->nSetPosition = pAppData->nSeekPosition;
 289                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition(pAppData);
 290                 pAppData->nSeekPosition = 0;
 291                 MpVideoViewCtrlUpdateProgressbar((void *)pAppData);
 292                 return 0;
 293         }
 294
 295         if(pAppData->nSeekPlayerState == MP_PLAYER_STATE_PAUSE) {
 296                 VideoLogInfo("");
 297                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause(pAppData);
 298                 pAppData->nSeekPlayerState = MP_PLAYER_STATE_WAIT_FOR_RESPONSE;
 299         }
 300         else if(pAppData->nSeekPlayerState == MP_PLAYER_STATE_RESUME) {
 301                 VideoLogInfo("");
 302                 pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume(pAppData);
 303                 pAppData->nSeekPlayerState = MP_PLAYER_STATE_WAIT_FOR_RESPONSE;
 304         }
 305
 306         return 0;
 307 }
 308
 309 static void MpVideoAppCtrlSeekCompleteCb(void *pUserData)
 310 {
 311         if(!pUserData)
 312         {
 313                 VideoLogInfo("No exist pUserData");
 314                 return;
 315         }
 316
 317         VideoLogInfo("");
 318         VideoAppData *pAppData = (VideoAppData *)pUserData;
 319         if(pEcorePipeHandlerForSeekComplete)
 320         {
 321                 if(!ecore_pipe_write(pEcorePipeHandlerForSeekComplete, (void *)pAppData, sizeof(VideoAppData)))
 322                 {
 323                         VideoLogDebug("Fail to write MpVideoAppCtrlSeekCompleteCb.");
 324                 }
 325         }
 326 }
 327
 328
 329 static int MpVideoAppCtrlResumeByRewCb(void *pUserData)
 330 {
 331         if(!pUserData)
 332         {
 333                 VideoLogInfo("No exist pUserData");
 334                 return 0;
 335         }
 336
 337         VideoLogInfo("");
 338
 339         VideoAppData *pAppData = (VideoAppData *)pUserData;
 340
 341         MpVideoAppCtrlResume(pAppData);
 342
 343         return 0;
 344 }
 345
 346 static int MpVideoAppCtrlErrormsgCb(void *pUserData)
 347 {
 348         if(!pUserData)
 349         {
 350                 VideoLogInfo("No exist pUserData");
 351                 return 0;
 352         }
 353
 354         VideoLogInfo("");
 355
 356         switch(MpVideoCtrlMgrGetErrorType(nPlayerErrorType))
 357         {
 358         case MP_PLAYER_ERROR_NONE:
 359                 VideoLogInfo("MP_PLAYER_ERROR_NONE");
 360                 break;
 361
 362         case MP_PLAYER_ERROR_OUT_OF_MEMORY:
 363                 VideoLogInfo("MP_PLAYER_ERROR_OUT_OF_MEMORY");
 364                 MpUtilNotifyPopUp((VideoAppData*)pUserData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO), MpVideoAppCtrlExitCb);
 365                 break;
 366
 367         case MP_PLAYER_ERROR_INVALID_PARAMETER:
 368                 VideoLogInfo("MP_PLAYER_ERROR_INVALID_PARAMETER");
 369                 MpUtilNotifyPopUp((VideoAppData*)pUserData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO), MpVideoAppCtrlExitCb);
 370                 break;
 371
 372         case MP_PLAYER_ERROR_NO_SUCH_FILE:
 373                 VideoLogInfo("MP_PLAYER_ERROR_NO_SUCH_FILE");
 374                 MpUtilNotifyPopUp((VideoAppData*)pUserData, MP_COM_POP_FILE_NOT_FOUND, MpVideoAppCtrlExitCb);
 375                 break;
 376
 377         case MP_PLAYER_ERROR_INVALID_OPERATION:
 378                 VideoLogInfo("MP_PLAYER_ERROR_INVALID_OPERATION");
 379                 MpUtilNotifyPopUp((VideoAppData*)pUserData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO), MpVideoAppCtrlUnSupportFormatErrorCb);
 380                 break;
 381
 382         case MP_PLAYER_ERROR_SEEK_FAILED:
 383                 VideoLogInfo("MP_PLAYER_ERROR_SEEK_FAILED");
 384                 break;
 385
 386         case MP_PLAYER_ERROR_INVALID_STATE:
 387                 VideoLogInfo("MP_PLAYER_ERROR_INVALID_STATE");
 388                 break;
 389
 390         case MP_PLAYER_ERROR_NOT_SUPPORTED_FILE:
 391                 VideoLogInfo("MP_PLAYER_ERROR_NOT_SUPPORTED_FILE");
 392                 MpUtilNotifyPopUp((VideoAppData*)pUserData, _(MP_VPL_POP_UNSUPPORTED_FILE_TYPE), MpVideoAppCtrlUnSupportFormatErrorCb);
 393                 break;
 394
 395         case MP_PLAYER_ERROR_INVALID_URI:
 396                 VideoLogInfo("MP_PLAYER_ERROR_INVALID_URI");
 397                 MpUtilNotifyPopUp((VideoAppData*)pUserData, MP_COM_POP_INVALID_URL, MpVideoAppCtrlExitCb);
 398                 break;
 399
 400         case MP_PLAYER_ERROR_SOUND_POLICY:
 401                 VideoLogInfo("MP_PLAYER_ERROR_SOUND_POLICY");
 402                 break;
 403
 404         case MP_PLAYER_ERROR_CONNECTION_FAILED:
 405                 VideoLogInfo("MP_PLAYER_ERROR_CONNECTION_FAILED");
 406                 MpUtilNotifyPopUp((VideoAppData*)pUserData, MP_COM_POP_CONNECTION_FAILED, MpVideoAppCtrlExitCb);
 407                 break;
 408
 409         case MP_PLAYER_ERROR_VIDEO_CAPTURE_FAILED:
 410                 VideoLogInfo("MP_PLAYER_ERROR_VIDEO_CAPTURE_FAILED");
 411                 break;
 412
 413         default:
 414                 MpUtilNotifyPopUp((VideoAppData*)pUserData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO), MpVideoAppCtrlExitCb);
 415                 break;
 416         }
 417
 418         return 0;
 419 }
 420
 421 static void MpVideoAppCtrlPlayerPrepareCb(void *pUserData)
 422 {
 423         if(!pUserData)
 424         {
 425                 VideoLogInfo("No exist appdata.");
 426                 return;
 427         }
 428
 429         VideoLogInfo("");
 430
 431         if(pEcorePipeHandleBOF)
 432         {
 433                 if(!ecore_pipe_write(pEcorePipeHandleBOF, pUserData, sizeof(VideoAppData)))
 434                 {
 435                         VideoLogDebug("FAIL PIPE WRITE");
 436                 }
 437         }
 438 }
 439
 440 static void MpVideoAppCtrlPlayerCompletedCb(void *pUserData)
 441 {
 442         if(!pUserData)
 443         {
 444                 VideoLogInfo("No exist appdata.");
 445                 return;
 446         }
 447
 448         VideoLogInfo("");
 449
 450         if(pEcorePipeHandleEOF)
 451         {
 452                 if(!ecore_pipe_write(pEcorePipeHandleEOF, pUserData, sizeof(VideoAppData)))
 453                 {
 454                         VideoLogDebug("FAIL PIPE WRITE");
 455                 }
 456         }
 457 }
 458
 459 static void MpVideoAppCtrlPlayerInterruptedCb(player_interrupted_code_e nInterruptCode, void *pUserData)
 460 {
 461         if(!pUserData)
 462         {
 463                 VideoLogInfo("No exist appdata.");
 464                 return;
 465         }
 466
 467         VideoLogInfo("");
 468
 469         nPlayerInterruptType = nInterruptCode;
 470
 471         if(pEcorePipeHandleForInterruped)
 472         {
 473                 if(!ecore_pipe_write(pEcorePipeHandleForInterruped, pUserData, sizeof(VideoAppData)))
 474                 {
 475                         VideoLogDebug("FAIL PIPE WRITE");
 476                 }
 477         }
 478 }
 479
 480 static void MpVideoAppCtrlPlayerErrorCb(int nPlayerErrorCode, void *pUserData)
 481 {
 482         if(!pUserData)
 483         {
 484                 VideoLogInfo("No exist appdata.");
 485                 return;
 486         }
 487
 488         VideoLogInfo("");
 489
 490         nPlayerErrorType = nPlayerErrorCode;
 491
 492         if(pEcorePipeHandleForErrorMsg)
 493         {
 494                 if(!ecore_pipe_write(pEcorePipeHandleForErrorMsg, pUserData, sizeof(VideoAppData)))
 495                 {
 496                         VideoLogDebug("FAIL PIPE WRITE");
 497                 }
 498         }
 499 }
 500
 501 static void MpVideoAppCtrlPlayerBufferingCb(int nPercent, void *pUserData)
 502 {
 503         if(!pUserData)
 504         {
 505                 VideoLogInfo("No exist appdata.");
 506                 return;
 507         }
 508
 509         VideoLogInfo("Buffering : %d%% ", nPercent);
 510
 511         nBufferingRate = nPercent;
 512
 513         if(pEcorePipeHandleForBuffering)
 514         {
 515                 if(!ecore_pipe_write(pEcorePipeHandleForBuffering, pUserData, sizeof(VideoAppData)))
 516                 {
 517                         VideoLogDebug("FAIL PIPE WRITE");
 518                 }
 519         }
 520 }
 521
 522 static void MpVideoAppCtrlPlayerUpdateSubtitleCb(unsigned long nDuration, char* szText, void *pUserData)
 523 {
 524         if(!pUserData)
 525         {
 526                 VideoLogInfo("No exist appdata.");
 527                 return;
 528         }
 529
 530         VideoLogInfo("");
 531 }
 532
 533 /*
 534  * Internal function
 535  */
 536 void MpVideoAppCtrlFuncInit(VideoAppData *pAppData)
 537 {
 538         VideoLogInfo("");
 539
 540         if(!pAppData)
 541         {
 542                 VideoLogInfo("[ERR]");
 543                 return;
 544         }
 545
 546         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStart = (void *)MpVideoAppCtrlStart;
 547         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStop = (void *)MpVideoAppCtrlStop;
 548         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlPause = (void *)MpVideoAppCtrlPause;
 549         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlResume = (void *)MpVideoAppCtrlResume;
 550         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStopByAppPause = (void *)MpVideoAppCtrlStopByAppPause;
 551         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartByAppResume = (void *)MpVideoAppCtrlStartByAppResume;
 552         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlFFDown = (void *)MpVideoAppCtrlFFDown;
 553         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlRewDown = (void *)MpVideoAppCtrlRewDown;
 554         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlFFUp = (void *)MpVideoAppCtrlFFUp;
 555         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlRewUp = (void *)MpVideoAppCtrlRewUp;
 556         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedFF = (void *)MpVideoAppCtrlSpeedFF;
 557         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedRew = (void *)MpVideoAppCtrlSpeedRew;
 558         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSpeedReset = (void *)MpVideoAppCtrlSpeedReset;
 559         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlRotateScreen = (void *)MpVideoAppCtrlRotateScreen;
 560         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetPosition = (void *)MpVideoAppCtrlGetPosition;
 561         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlSetPosition = (void *)MpVideoAppCtrlSetPosition;
 562         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideLayout = (void *)MpVideoAppCtrlHideLayout;
 563         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowLayout = (void *)MpVideoAppCtrlShowLayout;
 564         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideFinish = (void *)MpVideoAppCtrlHideFinish;
 565         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowFinish = (void *)MpVideoAppCtrlShowFinish;
 566         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetVideoResolution = (void *)MpVideoAppCtrlGetVideoResolution;
 567         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlReqDurationTime = (void *)MpVideoAppCtrlReqDurationTime;
 568         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlBeginOfStream = (void *)MpVideoAppCtrlBeginOfStream;
 569         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlEndOfStream = (void *)MpVideoAppCtrlEndOfStream;
 570         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlExit = (void *)MpVideoAppCtrlExit;
 571         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlStartStreaming = (void *)MpVideoAppCtrlStartStreaming;
 572         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlReLaunching = (void *)MpVideoAppCtrlReLaunching;
 573         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlGetBufferingPosition = (void *)MpVideoAppCtrlGetBufferingPosition;
 574         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlShowVolume = (void *)MpVideoAppCtrlShowVolume;
 575         pAppData->VideoAppCtrlCallbackFunc.VideoAppCtrlHideVolume = (void *)MpVideoAppCtrlHideVolume;
 576 }
 577
 578 static void MpVideoAppCtrlGetBufferingPosition(VideoAppData *pAppData)
 579 {
 580         if(!pAppData)
 581         {
 582                 VideoLogInfo("No exist appdata.");
 583                 return;
 584         }
 585
 586         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerTypeWithoutLog();
 587         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 588                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 589                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 590                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 591                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 592         {
 593                 VideoLogInfo("Skip Normal Play mode");
 594                 return;
 595         }
 596
 597         if(MpUtilCheckRTSPType(pAppData->szMediaUri))
 598         {
 599                 return;
 600         }
 601
 602         pAppData->nBufferingPosition = MpVideoCtrlMgrGetBufferingPosition();
 603 }
 604
 605 static void MpVideoAppCtrlStart(VideoAppData *pAppData)
 606 {
 607         if(!pAppData)
 608         {
 609                 VideoLogInfo("No exist appdata.");
 610                 return;
 611         }
 612
 613         VideoLogInfo("");
 614
 615         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 616         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
 617                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
 618                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
 619                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
 620                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
 621         {
 622                 if(!MpUtilCheckLocalFileExist(pAppData->szMediaUri))
 623                 {
 624                         MpUtilNotifyPopUp(pAppData, MP_COM_POP_FILE_NOT_EXIST, MpVideoAppCtrlExitCb);
 625                         return;
 626                 }
 627
 628                 MpUtilGetTitleFromFilepath(pAppData->szMediaUri, pAppData->szVideoTitle, STR_LEN_MAX);
 629                 MpVideoViewCtrlChangeTitle(pAppData);
 630                 MpVideoCtrlMgrMediaCreate(pAppData->szMediaUri,
 631                                         (void *)MpUtilGetMainWindowXID(),
 632                                         NULL,
 633                                         pAppData->szSubtitle,
 634                                         (void *)pAppData);
 635
 636                 MpVideoCtrlMgrSetPlayerCallback(MpVideoAppCtrlPlayerCompletedCb,
 637                                                 MpVideoAppCtrlPlayerInterruptedCb,
 638                                                 MpVideoAppCtrlPlayerErrorCb,
 639                                                 MpVideoAppCtrlPlayerBufferingCb,
 640                                                 MpVideoAppCtrlPlayerUpdateSubtitleCb,
 641                                                 (void*)pAppData);
 642
 643                 if(!MpVideoCtrlMgrMediaRealizeAsync(MpVideoAppCtrlPlayerPrepareCb, (void *)pAppData))
 644                 {
 645                         MpUtilNotifyPopUp(pAppData, _(MP_VPL_UNABLE_TO_PLAY_VIDEO), MpVideoAppCtrlUnSupportFormatErrorCb);
 646                         return;
 647                 }
 648         }
 649         else if(nTmpPlayerType == MP_STREAMING_PLAYER)
 650         {
 651                 if(!MpVideoStreamingCtrlIsNetworkOn())
 652                 {
 653                         MpUtilNotifyPopUp(pAppData, MP_COM_CONNECTION_FAIL, MpVideoAppCtrlExitCb);
 654                         return;
 655                 }
 656
 657                 if(MpVideoStreamingCtrlInit((void *)pAppData))
 658                 {
 659                         VideoLogInfo("Connect to network.");
 660                         MpVideoAppCtrlStartStreaming((void *)pAppData);
 661                 }
 662         }
 663 }
 664
 665 static void MpVideoAppCtrlStop(VideoAppData *pAppData)
 666 {
 667         if(!pAppData)
 668         {
 669                 VideoLogInfo("No exist appdata.");
 670                 return;
 671         }
 672
 673         VideoLogInfo("");
 674
 675         pAppData->nCurPlayerState = MP_PLAYER_STATE_STOP;
 676         MpVideoCtrlMgrMediaStop((void *)pAppData);
 677 }
 678
 679 static void MpVideoAppCtrlPause(VideoAppData *pAppData)
 680 {
 681         if(!pAppData)
 682         {
 683                 VideoLogInfo("No exist appdata.");
 684                 return;
 685         }
 686
 687         VideoLogInfo("");
 688
 689         if(pAppData->nCurPlayerState == MP_PLAYER_STATE_PAUSE)
 690         {
 691                 VideoLogInfo("Allready Pause video player.");
 692                 return;
 693         }
 694
 695         pAppData->nCurPlayerState = MP_PLAYER_STATE_PAUSE;
 696
 697         MpVideoCtrlMgrMediaPause(pAppData);
 698         MpVideoViewCtrlPause(pAppData);
 699         MpVideoAppCtrlShowLayout(pAppData);
 700         MpUtilLcdNormalPowerUnlockForPause();
 701 }
 702
 703 static void MpVideoAppCtrlResume(VideoAppData *pAppData)
 704 {
 705         if(!pAppData)
 706         {
 707                 VideoLogInfo("No exist appdata.");
 708                 return;
 709         }
 710
 711         VideoLogInfo("");
 712
 713         if(MpVideoViewCtrlIsPauseByUser((void *)pAppData))
 714         {
 715                 return;
 716         }
 717
 718         if(pAppData->nCurPlayerState == MP_PLAYER_STATE_RESUME || pAppData->nCurPlayerState == MP_PLAYER_STATE_PLAY)
 719         {
 720                 VideoLogInfo("Allready Resume video player.");
 721                 return;
 722         }
 723
 724         pAppData->nCurPlayerState = MP_PLAYER_STATE_RESUME;
 725         MpUtilMultimediaKeyGrab();
 726
 727         MpVideoAppCtrlGetPosition(pAppData);
 728         MpVideoCtrlMgrMediaResume(pAppData);
 729         MpVideoViewCtrlResume(pAppData);
 730         MpVideoAppCtrlShowLayout(pAppData);
 731         MpUtilLcdNormalPowerLockForResume();
 732 }
 733
 734 static void MpVideoAppCtrlStopByAppPause(VideoAppData *pAppData)
 735 {
 736         if(!pAppData)
 737         {
 738                 VideoLogInfo("No exist appdata.");
 739                 return;
 740         }
 741
 742         if(!MpVideoCtrlMgrIsExistPlayerHandle())
 743         {
 744                 VideoLogInfo("Not exist Player handle.");
 745                 return;
 746         }
 747
 748         VideoLogInfo("");
 749
 750         MpVideoAppCtrlGetPosition(pAppData);
 751         pAppData->nSetPosition = pAppData->nCurPosition;
 752         VideoLogInfo("Current position time : %d", pAppData->nSetPosition);
 753         MpVideoViewCtrlPause(pAppData);
 754         MpVideoAppCtrlStop(pAppData);
 755         MpVideoCtrlMgrMediaDestroy(pAppData);
 756         MpUtilLcdNormalPowerUnlockForPause();
 757
 758         MpVideoViewCtrlResetProgressBar((void *)pAppData);
 759
 760         MpUtilMultimediaKeyUngrab();
 761
 762         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 763         if(nTmpPlayerType == MP_STREAMING_PLAYER)
 764         {
 765                 MpVideoViewSetBufferingRateForStreamingView(0, (void *)pAppData);
 766         }
 767 }
 768
 769 static void MpVideoAppCtrlStartByAppResume(VideoAppData *pAppData)
 770 {
 771         if(!pAppData)
 772         {
 773                 VideoLogInfo("No exist appdata.");
 774                 return;
 775         }
 776
 777         VideoLogInfo("");
 778
 779         if(bWindowForegroundState == FALSE)
 780         {
 781                 VideoLogInfo("The Window of the video player is hided.");
 782         }
 783
 784         MpVideoAppCtrlStart(pAppData);
 785         MpVideoViewCtrlResume(pAppData);
 786         MpVideoAppCtrlShowLayout(pAppData);
 787
 788         return;
 789 }
 790
 791 static void MpVideoAppCtrlFFDown(VideoAppData *pAppData)
 792 {
 793         VideoLogInfo("");
 794 }
 795
 796 static void MpVideoAppCtrlRewDown(VideoAppData *pAppData)
 797 {
 798         VideoLogInfo("");
 799 }
 800
 801 static void MpVideoAppCtrlFFUp(VideoAppData *pAppData)
 802 {
 803         VideoLogInfo("");
 804 }
 805
 806 static void MpVideoAppCtrlRewUp(VideoAppData *pAppData)
 807 {
 808         VideoLogInfo("");
 809 }
 810
 811 static void MpVideoAppCtrlRotateScreen(VideoAppData *pAppData, int nRotateState)
 812 {
 813         if(!pAppData)
 814         {
 815                 VideoLogInfo("No exist appdata.");
 816                 return;
 817         }
 818
 819         VideoLogInfo("");
 820
 821         if(VIDEO_ROTATE_UNKNOWN > nRotateState || VIDEO_ROTATE_LANDSCAPE_REVERSE < nRotateState)
 822         {
 823                 VideoLogInfo("Wrong rotate state. - %d", nRotateState);
 824                 return;
 825         }
 826
 827         MpVideoCtrlMgrRotateVideoScreen(nRotateState);
 828 }
 829
 830 static void MpVideoAppCtrlGetPosition(VideoAppData *pAppData)
 831 {
 832         pAppData->nCurPosition = MpVideoCtrlMgrGetPosition();
 833 }
 834
 835 static void MpVideoAppCtrlSetPosition(VideoAppData *pAppData)
 836 {
 837         if(!pAppData)
 838         {
 839                 VideoLogInfo("No exist appdata.");
 840                 return;
 841         }
 842
 843         VideoLogInfo("");
 844
 845         MpVideoCtrlMgrSetPosition(pAppData->nSetPosition, (void *)MpVideoAppCtrlSeekCompleteCb, (void *)pAppData);
 846         if(MpUtilCheckRTSPType(pAppData->szMediaUri))
 847         {
 848                 VideoLogInfo("RTSP SEEK Start");
 849                 nBufferingRate = 0;
 850                 MpVideoAppCtrlBufferingCb((void *)pAppData);
 851         }
 852 }
 853
 854 static void MpVideoAppCtrlSpeedReset(VideoAppData *pAppData)
 855 {
 856         VideoLogInfo("");
 857         MpVideoAppCtrlGetPosition(pAppData);
 858         MpVideoCtrlMgrSetPosition( pAppData->nCurPosition, (void *)MpVideoAppCtrlSeekCompleteCb, (void *)pAppData);
 859         MpVideoCtrlMgrResetPlaySpeed((void *)pAppData);
 860 }
 861
 862 static void MpVideoAppCtrlSpeedFF(VideoAppData *pAppData)
 863 {
 864         VideoLogInfo("");
 865         MpVideoCtrlMgrSetPlaySpeedUp((void *)pAppData);
 866 }
 867
 868 static void MpVideoAppCtrlSpeedRew(VideoAppData *pAppData)
 869 {
 870         VideoLogInfo("");
 871         MpVideoCtrlMgrSetPlaySpeedDown((void *)pAppData);
 872 }
 873
 874 static void MpVideoAppCtrlHideLayout(VideoAppData *pAppData)
 875 {
 876         if(!pAppData)
 877         {
 878                 VideoLogInfo("No exist appdata.");
 879                 return;
 880         }
 881
 882         VideoLogInfo("");
 883
 884         MpVideoViewHideLayout((void *)pAppData);
 885 }
 886
 887 static void MpVideoAppCtrlShowLayout(VideoAppData *pAppData)
 888 {
 889         if(!pAppData)
 890         {
 891                 VideoLogInfo("No exist appdata.");
 892                 return;
 893         }
 894
 895         VideoLogInfo("");
 896
 897         MpVideoViewShowLayout((void *)pAppData);
 898 }
 899
 900 static void MpVideoAppCtrlHideFinish(VideoAppData *pAppData)
 901 {
 902         if(!pAppData)
 903         {
 904                 VideoLogInfo("No exist appdata.");
 905                 return;
 906         }
 907
 908         VideoLogInfo("");
 909
 910         MpVideoViewCtrlHideFinish((void *)pAppData, bWindowForegroundState);
 911
 912 }
 913 static void MpVideoAppCtrlShowFinish(VideoAppData *pAppData)
 914 {
 915         if(!pAppData)
 916         {
 917                 VideoLogInfo("No exist appdata.");
 918                 return;
 919         }
 920
 921         VideoLogInfo("");
 922
 923         MpVideoViewCtrlShowFinish((void *)pAppData);
 924 }
 925
 926 static void MpVideoAppCtrlGetVideoResolution(VideoAppData *pAppData)
 927 {
 928         if(!pAppData)
 929         {
 930                 VideoLogInfo("No exist appdata.");
 931                 return;
 932         }
 933
 934         VideoLogInfo("");
 935
 936         pAppData->nVideoWidthResolution = MpVideoCtrlMgrGetVideoWidthResolution();
 937         pAppData->nVideoHeightResolution = MpVideoCtrlMgrGetVideoHeightResolution();
 938 }
 939
 940 static void MpVideoAppCtrlReqDurationTime(VideoAppData *pAppData)
 941 {
 942         if(!pAppData)
 943         {
 944                 VideoLogInfo("No exist appdata.");
 945                 return;
 946         }
 947
 948         VideoLogInfo("");
 949
 950         pAppData->nDuration = MpVideoCtrlMgrGetDuration();
 951 }
 952
 953 static void MpVideoAppCtrlBeginOfStream(VideoAppData *pAppData)
 954 {
 955         if(!pAppData)
 956         {
 957                 VideoLogInfo("No exist appdata.");
 958                 return;
 959         }
 960
 961         VideoLogInfo("");
 962
 963         MpUtilMultimediaKeyGrab();
 964
 965         MpVideoAppCtrlGetVideoResolution(pAppData);
 966         pAppData->nDuration = MpVideoCtrlMgrGetDuration();
 967
 968         MpVideoViewCtrlInitAfterBeginOfStream((void*)pAppData);
 969
 970         if(MpVideoViewCtrlIsPauseByUser((void *)pAppData))
 971         {
 972                 MpVideoAppCtrlPause(pAppData);
 973                 MpVideoCtrlMgrSetMute(FALSE);
 974         }
 975
 976         if(MpVideoCtrlMgrIsOnlyAudio())
 977         {
 978                 MpVideoViewCtrlShowNocontentImage((void*)pAppData);
 979         }
 980         else
 981         {
 982                 MpVideoViewCtrlHideNocontentImage((void*)pAppData);
 983         }
 984 }
 985
 986 static void MpVideoAppCtrlEndOfStream(VideoAppData *pAppData)
 987 {
 988         if(!pAppData)
 989         {
 990                 VideoLogInfo("No exist appdata.");
 991                 return;
 992         }
 993
 994         VideoLogInfo("");
 995
 996         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
 997         if(nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY)
 998         {
 999                 if(pAppData->nCurPosition >= 0)
1000                 {
1001                         MpUtilMediaSvcSetVideoLastPlayedTimeByUri(pAppData->szMediaUri, 0);
1002                 }
1003                 else
1004                 {
1005                         VideoLogInfo("Invalid Plaing time or duration time.");
1006                 }
1007         }
1008         MpVideoAppCtrlExit(pAppData);
1009 }
1010
1011 static void MpVideoAppCtrlExit(VideoAppData *pAppData)
1012 {
1013         if(!pAppData)
1014         {
1015                 VideoLogInfo("No exist appdata.");
1016                 return;
1017         }
1018
1019         VideoLogInfo("");
1020
1021         if(pEcorePipeHandleForErrorMsg)
1022         {
1023                 ecore_pipe_del(pEcorePipeHandleForErrorMsg);
1024                 pEcorePipeHandleForErrorMsg = NULL;
1025         }
1026
1027         if(pEcorePipeHandleBOF)
1028         {
1029                 ecore_pipe_del(pEcorePipeHandleBOF);
1030                 pEcorePipeHandleBOF = NULL;
1031         }
1032
1033         if(pEcorePipeHandleEOF)
1034         {
1035                 ecore_pipe_del(pEcorePipeHandleEOF);
1036                 pEcorePipeHandleEOF = NULL;
1037         }
1038
1039         if(pEcorePipeHandleForBuffering)
1040         {
1041                 ecore_pipe_del(pEcorePipeHandleForBuffering);
1042                 pEcorePipeHandleForBuffering = NULL;
1043         }
1044
1045         if(pEcorePipeHandleForResumed)
1046         {
1047                 ecore_pipe_del(pEcorePipeHandleForResumed);
1048                 pEcorePipeHandleForResumed = NULL;
1049         }
1050
1051         if(pEcorePipeHandleForInterruped)
1052         {
1053                 ecore_pipe_del(pEcorePipeHandleForInterruped);
1054                 pEcorePipeHandleForInterruped = NULL;
1055         }
1056
1057         if(pEcorePipeHandlerForSeekComplete)
1058         {
1059                 ecore_pipe_del(pEcorePipeHandlerForSeekComplete);
1060                 pEcorePipeHandlerForSeekComplete = NULL;
1061         }
1062
1063         MpVideoAppCtrlStop(pAppData);
1064         MpVideoCtrlMgrMediaDestroy(pAppData);
1065         MpUtilDeletePopupHandle();
1066         MpVideoViewCtrlDestroy((void *)pAppData);
1067
1068         if(MpVideoServiceCtrlGetPlayerType() == MP_STREAMING_PLAYER)
1069         {
1070                 MpVideoStreamingCtrlDestroy((void *)pAppData);
1071         }
1072
1073         MpExternalUgDestroyAll();
1074
1075         elm_win_indicator_mode_set(pAppData->pMainWindow, ELM_WIN_INDICATOR_SHOW);
1076
1077         elm_exit();
1078 }
1079
1080 static void MpVideoAppCtrlStartStreaming(VideoAppData *pAppData)
1081 {
1082         if(!pAppData)
1083         {
1084                 VideoLogInfo("No exist appdata.");
1085                 return;
1086         }
1087
1088         VideoLogInfo("");
1089
1090         char *szCookie = MpVideoServiceCtrlGetCookieForStreaming();
1091         if(szCookie)
1092         {
1093                 strncpy(pAppData->szCookie, szCookie, STR_LEN_MAX - 1);
1094         }
1095
1096         MpVideoCtrlMgrMediaCreate(pAppData->szMediaUri, (void *)MpUtilGetMainWindowXID(),
1097                                 NULL, NULL, (void *)pAppData);
1098
1099         MpVideoCtrlMgrSetPlayerCallback(MpVideoAppCtrlPlayerCompletedCb,
1100                                         MpVideoAppCtrlPlayerInterruptedCb,
1101                                         MpVideoAppCtrlPlayerErrorCb,
1102                                         MpVideoAppCtrlPlayerBufferingCb,
1103                                         MpVideoAppCtrlPlayerUpdateSubtitleCb,
1104                                         (void*)pAppData);
1105
1106         MpVideoCtrlMgrMediaRealizeAsync(MpVideoAppCtrlPlayerPrepareCb, (void *)pAppData);
1107
1108         MpVideoAppCtrlRotateScreen(pAppData, MpUtilGetRotationState());
1109 }
1110
1111 static void MpVideoAppCtrlReLaunching(VideoAppData *pAppData)
1112 {
1113         if(!pAppData)
1114         {
1115                 VideoLogInfo("No exist appdata.");
1116                 return;
1117         }
1118
1119         VideoLogInfo("");
1120
1121         MpVideoAppCtrlStop(pAppData);
1122         MpVideoCtrlMgrMediaDestroy(pAppData);
1123
1124         MpVideoViewCtrlHideVolume();
1125
1126         int nTmpPlayerType = MpVideoServiceCtrlGetPlayerType();
1127         if(nTmpPlayerType == MP_VIDEO_PLAYER ||
1128                 nTmpPlayerType == MP_VIDEO_PLAYER_SIMPLE ||
1129                 nTmpPlayerType == MP_VIDEO_PLAYER_GALLERY ||
1130                 nTmpPlayerType == MP_VIDEO_PLAYER_EMAIL ||
1131                 nTmpPlayerType == MP_VIDEO_PLAYER_MMS)
1132         {
1133                 pAppData->nSetPosition = 0;
1134                 MpVideoViewCtrlChangeTitle(pAppData);
1135         }
1136
1137         if(nTmpPlayerType == MP_STREAMING_PLAYER)
1138         {
1139                 MpVideoAppCtrlStartStreaming(pAppData);
1140         }
1141 }
1142
1143 static void MpVideoAppCtrlPipeInit(VideoAppData *pAppData)
1144 {
1145         if(!pAppData)
1146         {
1147                 VideoLogInfo("No exist appdata.");
1148                 return;
1149         }
1150
1151         VideoLogInfo("");
1152
1153         if(pEcorePipeHandlerForSeekComplete)
1154         {
1155                 ecore_pipe_del(pEcorePipeHandlerForSeekComplete);
1156                 pEcorePipeHandlerForSeekComplete = NULL;
1157         }
1158         pEcorePipeHandlerForSeekComplete = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlSeekCompletePipeCb, (void *)pAppData);
1159
1160         if(pEcorePipeHandleForErrorMsg)
1161         {
1162                 ecore_pipe_del(pEcorePipeHandleForErrorMsg);
1163                 pEcorePipeHandleForErrorMsg = NULL;
1164         }
1165
1166         pEcorePipeHandleForErrorMsg = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlErrormsgCb, (void *)pAppData);
1167
1168         if(pEcorePipeHandleBOF)
1169         {
1170                 ecore_pipe_del(pEcorePipeHandleBOF);
1171                 pEcorePipeHandleBOF = NULL;
1172         }
1173
1174         pEcorePipeHandleBOF = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlBeginOfPlayCb, (void *)pAppData);
1175
1176         if(pEcorePipeHandleEOF)
1177         {
1178                 ecore_pipe_del(pEcorePipeHandleEOF);
1179                 pEcorePipeHandleEOF = NULL;
1180         }
1181
1182         pEcorePipeHandleEOF = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlEndOfPlayCb, (void *)pAppData);
1183
1184         if(pEcorePipeHandleForBuffering)
1185         {
1186                 ecore_pipe_del(pEcorePipeHandleForBuffering);
1187                 pEcorePipeHandleForBuffering = NULL;
1188         }
1189
1190         pEcorePipeHandleForBuffering = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlBufferingCb, (void *)pAppData);
1191
1192         if(pEcorePipeHandleForResumed)
1193         {
1194                 ecore_pipe_del(pEcorePipeHandleForResumed);
1195                 pEcorePipeHandleForResumed = NULL;
1196         }
1197
1198         pEcorePipeHandleForResumed = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlResumeByRewCb, (void *)pAppData);
1199
1200         if(pEcorePipeHandleForInterruped)
1201         {
1202                 ecore_pipe_del(pEcorePipeHandleForInterruped);
1203                 pEcorePipeHandleForInterruped = NULL;
1204         }
1205
1206         pEcorePipeHandleForInterruped = ecore_pipe_add((Ecore_Pipe_Cb)MpVideoAppCtrlPauseByInterrupteCb, (void *)pAppData);
1207 }
1208
1209 static void MpVideoAppCtrlShowVolume(VideoAppData *pAppData)
1210 {
1211         VideoLogInfo("");
1212
1213         MpVideoViewCtrlShowVolume();
1214 }
1215
1216 static void MpVideoAppCtrlHideVolume(VideoAppData *pAppData)
1217 {
1218         VideoLogInfo("");
1219
1220         MpVideoViewCtrlHideVolume();
1221 }
1222
1223
1224 /*
1225  * External function
1226  */
1227 bool MpVideoAppCtrlInit(VideoAppData *pAppData)
1228 {
1229         if(!pAppData)
1230         {
1231                 VideoLogInfo("No exist appdata.");
1232                 return FALSE;
1233         }
1234
1235         VideoLogInfo("");
1236
1237         VideoLogInfo("Get rotation state from appcore. - %d", MpUtilGetRotationStateFromAppcore());
1238
1239         MpVideoAppCtrlFuncInit(pAppData);
1240         MpVideoAppCtrlPipeInit(pAppData);
1241         MpVideoViewCtrlInit(pAppData);
1242
1243         evas_object_show(pAppData->pMainWindow);
1244         elm_win_activate(pAppData->pMainWindow);
1245
1246         if(!MpUtilIsCallOff())
1247         {
1248                 MpUtilNotifyPopUp(pAppData, _(MP_VPL_BODY_UNABLE_TO_PLAY_VIDEO_DURING_CALL), MpVideoAppCtrlExitCb);
1249                 return FALSE;
1250         }
1251
1252         MpVideoAppCtrlInitCheckCallStatus();
1253
1254         if(!MpUtilCheckBatteryStatus())
1255         {
1256                 MpUtilNotifyPopUp(pAppData, MP_COM_BODY_LOW_BATTERY, MpVideoAppCtrlExitCb);
1257                 return FALSE;
1258         }
1259
1260         MpVideoAppCtrlStart(pAppData);
1261
1262         return TRUE;
1263 }
1264
1265 bool MpVideoAppCtrlResetForRelaunching(VideoAppData *pAppData)
1266 {
1267         if (!pAppData) {
1268                 VideoLogInfo("No exist appdata.");
1269                 return FALSE;
1270         }
1271
1272         VideoLogInfo("");
1273
1274         MpVideoAppCtrlStop(pAppData);
1275
1276         MpVideoCtrlMgrMediaDestroy(pAppData);
1277         MpUtilDeletePopupHandle();
1278         MpVideoViewCtrlDestroy((void *)pAppData);
1279
1280         MpUtilMediaSvcFinishSession();
1281         MpUtilBatteryStatusNotiIgnore();
1282
1283         nBufferingRate = 0;
1284         nPlayerErrorType = 0;
1285         nPlayerInterruptType = 0;
1286
1287         pAppData->nDuration = 0;
1288         pAppData->nSetPosition = 0;
1289         pAppData->nCurPosition = 0;
1290         pAppData->nBufferingPosition = 0;
1291         pAppData->nVideoWidthResolution = 0;
1292         pAppData->nVideoHeightResolution = 0;
1293
1294         memset(pAppData->szVideoTitle, 0, sizeof(char) * STR_LEN_MAX);
1295         memset(pAppData->szMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1296         memset(pAppData->szPreMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1297         memset(pAppData->szNextMediaUri, 0, sizeof(char) * STR_LEN_MAX);
1298
1299         pAppData->nPrePlayerState = MP_PLAYER_STATE_CLEAR;
1300         pAppData->nCurPlayerState = MP_PLAYER_STATE_CLEAR;
1301         pAppData->nPlayingSpeed = 0;
1302
1303         memset(pAppData->szProxyAddress, 0, sizeof(char) * STR_LEN_MAX);
1304         memset(pAppData->szUserAgent, 0, sizeof(char) * STR_LEN_MAX);
1305         memset(pAppData->szCookie, 0, sizeof(char) * STR_LEN_MAX);
1306
1307         MpUtilResetForRelaunching();
1308
1309         MpVideoAppCtrlInitCheckCallStatus();
1310
1311         return TRUE;
1312 }
1313
1314 bool MpVideoAppCtrlIsTopView(void* pUserData)
1315 {
1316         if(!pUserData)
1317         {
1318                 VideoLogInfo("No exist pUserData.");
1319                 return FALSE;
1320         }
1321
1322         VideoLogInfo("");
1323
1324         return MpVideoViewCtrlIsTopView(pUserData);
1325 }
1326
1327 bool MpVideoAppCtrlIsExistPlayerHandle(void)
1328 {
1329         VideoLogInfo("");
1330
1331         return MpVideoCtrlMgrIsExistPlayerHandle();
1332 }
1333
1334 void MpVideoAppCtrlSetForCheckingForegroundwindow(bool bForwgroundState)
1335 {
1336         VideoLogInfo("");
1337
1338         bWindowForegroundState = bForwgroundState;
1339 }
1340
1341 void MpVideoAppCtrlSetRotation(int nRotateMode, void *pUserData)
1342 {
1343         VideoLogInfo("");
1344
1345         MpVideoViewCtrlSetRotation(nRotateMode, TRUE, pUserData);
1346 }
1347
1348 bool MpVideoAppCtrlIsCheckCallStatus(void)
1349 {
1350         VideoLogInfo("");
1351
1352         bool bCheckCallStatus = FALSE;
1353
1354         if(g_nCurrentInterrupt == MP_PLAYER_INTERRUPTED_BY_CALL)
1355         {
1356                 bCheckCallStatus = TRUE;
1357         }
1358
1359         return bCheckCallStatus;
1360
1361 }
1362 void MpVideoAppCtrlInitCheckCallStatus(void)
1363 {
1364         VideoLogInfo("");
1365
1366         g_nCurrentInterrupt = MP_PLAYER_INTERRUPTED_COMPLETED;
1367 }
1368