src/VpVideoPlayerPresentationModel.cpp

   1 //
   2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
   3 //
   4 // Licensed under the Flora License, Version 1.1 (the License);
   5 // you may not use this file except in compliance with the License.
   6 // You may obtain a copy of the License at
   7 //
   8 //     http://floralicense.org/license/
   9 //
  10 // Unless required by applicable law or agreed to in writing, software
  11 // distributed under the License is distributed on an AS IS BASIS,
  12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 // See the License for the specific language governing permissions and
  14 // limitations under the License.
  15 //
  16
  17 /**
  18  * @file                VpVideoPlayerPresentationModel.cpp
  19  * @brief               This is the implementation file for VideoPlayerPresentationModel class.
  20  */
  21
  22 #include <FIo.h>
  23 #include "VpAppResourceId.h"
  24 #include "VpTypes.h"
  25 #include "VpVideoPlayerApp.h"
  26 #include "VpVideoPlayerPresentationModel.h"
  27
  28 using namespace Tizen::App;
  29 using namespace Tizen::Base;
  30 using namespace Tizen::Base::Collection;
  31 using namespace Tizen::Base::Runtime;
  32 using namespace Tizen::Base::Utility;
  33 using namespace Tizen::Content;
  34 using namespace Tizen::Graphics;
  35 using namespace Tizen::Io;
  36 using namespace Tizen::Media;
  37 using namespace Tizen::Ui::Controls;
  38
  39 static const int PROGRESS_TIMER_DURATION = 250;
  40 static const int LONGKEY_TIMER_DURATION = 200;
  41
  42 static const int MILLISECOND = 1000;
  43 static const int TEN_SEC = 10;
  44 static const int TWO_SEC = 2;
  45 static const int START_TIME = 0;
  46
  47 static const int INIT_CONTENT_INDEX = 0;
  48 static const int MULTI_CONTENT_COUNT = 2;
  49 static const int MAX_PROGRESS_RANGE = 100;
  50
  51 static const int MESSAGEBOX_DISPLAY_TIMEOUT = 3000;
  52
  53 VideoPlayerPresentationModel*
  54 VideoPlayerPresentationModel::__pVideoPlayerPresentationModel = null;
  55
  56 VideoPlayerPresentationModel::VideoPlayerPresentationModel(void)
  57         : __pPlayer(null)
  58         , __pVideoPlayerEventListener(null)
  59         , __pOverlayPanel(null)
  60         , __pMediaPathArrayList(null)
  61         , __launchType(L"")
  62         , __pTimer(null)
  63         , __pFastForwardTimer(null)
  64         , __pFastRewindTimer(null)
  65         , __pCurrentPlayContentPath(null)
  66         , __playerSeekCompleted(true)
  67         , __playerLastSeekCompleted(false)
  68         , __stateAfterSeek(PLAYER_STATE_ERROR)
  69         , __mediaWidth(0)
  70         , __mediaHeight(0)
  71         , __currentMediaIndex(INIT_CONTENT_INDEX)
  72         , __repeatMode(REPEAT_TYPE_OFF)
  73         , __pFileEventMgr(null)
  74 {
  75 }
  76
  77 VideoPlayerPresentationModel::~VideoPlayerPresentationModel(void)
  78 {
  79         DeleteTimer();
  80         if (__pPlayer != null)
  81         {
  82                 __pPlayer->Stop();
  83                 __pPlayer->Close();
  84                 delete __pPlayer;
  85         }
  86
  87         if (__pMediaPathArrayList != null)
  88         {
  89                 __pMediaPathArrayList->RemoveAll(true);
  90                 delete __pMediaPathArrayList;
  91                 __pMediaPathArrayList = null;
  92         }
  93
  94         delete __pCurrentPlayContentPath;
  95         delete __pFileEventMgr;
  96 }
  97
  98 VideoPlayerPresentationModel*
  99 VideoPlayerPresentationModel::GetInstance(void)
 100 {
 101         AppLogDebug("GetInstance");
 102
 103         if (__pVideoPlayerPresentationModel == null)
 104         {
 105                 CreateInstance();
 106         }
 107
 108         return __pVideoPlayerPresentationModel;
 109 }
 110
 111 result
 112 VideoPlayerPresentationModel::Construct(void)
 113 {
 114         result r = E_FAILURE;
 115         __pCurrentPlayContentPath = new (std::nothrow) String(L"");
 116
 117         r = SetMediaPathArray();
 118         SetLaunchType();
 119         InitTimer();
 120
 121         return r;
 122 }
 123
 124 void
 125 VideoPlayerPresentationModel::CreateInstance(void)
 126 {
 127         AppLogDebug("CreateInstance");
 128
 129         __pVideoPlayerPresentationModel = new (std::nothrow) VideoPlayerPresentationModel();
 130         result r = __pVideoPlayerPresentationModel->Construct();
 131
 132         if (IsFailed(r))
 133         {
 134                 delete __pVideoPlayerPresentationModel;
 135                 __pVideoPlayerPresentationModel = null;
 136         }
 137 }
 138
 139 void
 140 VideoPlayerPresentationModel::DestroyInstance(void)
 141 {
 142         delete __pVideoPlayerPresentationModel;
 143         __pVideoPlayerPresentationModel = null;
 144 }
 145
 146 Rectangle
 147 VideoPlayerPresentationModel::GetVideoInfoN(const String& mediaLocalPath)
 148 {
 149         Rectangle rect;
 150         result r = E_FAILURE;
 151
 152         const IList* pInfoList = null;
 153         const VideoStreamInfo* pInfo = null;
 154         MediaStreamInfo* pStreamInfo = null;
 155
 156         if (GetState() == PLAYER_STATE_PLAYING)
 157         {
 158                 pStreamInfo = __pPlayer->GetCurrentMediaStreamInfoN();
 159                 TryCatch(pStreamInfo != null, r = E_FAILURE, "__pPlayer->GetCurrentMediaStreamInfoN() is null");
 160
 161                 pInfoList = pStreamInfo->GetVideoStreamInfoList();
 162                 TryCatch(pInfoList != null, r = E_FAILURE, "pStreamInfo->GetVideoStreamInfoList() is null");
 163
 164                 pInfo = (const VideoStreamInfo*)pInfoList->GetAt(0);
 165                 TryCatch(pInfo != null, r = E_FAILURE, "pInfoList->GetAt() is null");
 166
 167                 rect.width = pInfo->GetWidth();
 168                 rect.height = pInfo->GetHeight();
 169
 170                 __mediaWidth = pInfo->GetWidth();
 171                 __mediaHeight = pInfo->GetHeight();
 172
 173                 delete pStreamInfo;
 174         }
 175         else
 176         {
 177                 rect.width = __mediaWidth;
 178                 rect.height = __mediaHeight;
 179         }
 180
 181         return rect;
 182
 183 CATCH:
 184         delete pStreamInfo;
 185
 186         rect.width = __mediaWidth;
 187         rect.height = __mediaHeight;
 188
 189         return rect;
 190 }
 191
 192 result
 193 VideoPlayerPresentationModel::ConstructPlayerInstanceWithBufferInfo(void)
 194 {
 195         result r = E_FAILURE;
 196         BufferInfo bufferInfo;
 197
 198         r = __pOverlayPanel->GetBackgroundBufferInfo(bufferInfo);
 199         TryCatch(r == E_SUCCESS,, "__pOverlayRegion->GetBackgroundBufferInfo() failed:%s", GetErrorMessage(r));
 200
 201         delete __pPlayer;
 202         __pPlayer = new (std::nothrow) Player();
 203         AppLogDebug("__pPlayer [%x]", __pPlayer);
 204
 205         r = __pPlayer->Construct(*this, &bufferInfo);
 206         TryCatch(r == E_SUCCESS,, "__pPlayer->Construct failed:%s", GetErrorMessage(r));
 207
 208         return r;
 209
 210 CATCH:
 211         delete __pPlayer;
 212         __pPlayer = null;
 213         return r;
 214 }
 215
 216 result
 217 VideoPlayerPresentationModel::SeekTo(long msTime)
 218 {
 219         result r = E_FAILURE;
 220
 221         PlayerState playState = GetState();
 222
 223         TryCatch(__pPlayer != null,, "__pPlayer is null");
 224
 225         switch (playState)
 226         {
 227         case PLAYER_STATE_PLAYING:
 228                 // fall through
 229         case PLAYER_STATE_PAUSED:
 230                 {
 231                         r = __pPlayer->SeekTo(msTime);
 232                         TryCatch(r == E_SUCCESS,, "__pPlayer->SeekTo failed:%s", GetErrorMessage(r));
 233                         __playerSeekCompleted = false;
 234                 }
 235                 break;
 236
 237         default:
 238                 break;
 239         }
 240
 241         return r;
 242
 243 CATCH:
 244         return r;
 245 }
 246
 247 void
 248 VideoPlayerPresentationModel::OnPlayerSeekCompleted(result r)
 249 {
 250         AppLogDebug("OnPlayerSeekCompleted");
 251
 252         __playerSeekCompleted = true;
 253
 254         if (__playerLastSeekCompleted == true)
 255         {
 256                 if (__stateAfterSeek == PLAYER_STATE_PLAYING)
 257                 {
 258                         StartPlay();
 259                         __stateAfterSeek = PLAYER_STATE_ERROR;
 260                 }
 261
 262                 __playerLastSeekCompleted = false;
 263         }
 264
 265         if (__stateAfterSeek == PLAYER_STATE_PAUSED)
 266         {
 267                 PausePlay();
 268                 __stateAfterSeek = PLAYER_STATE_ERROR;
 269         }
 270
 271         __pVideoPlayerEventListener->OnPlaySeekCompleted(r);
 272 }
 273
 274 void
 275 VideoPlayerPresentationModel::SetPlayerBuffer(const BufferInfo& bufferInfo)
 276 {
 277         result r = E_FAILURE;
 278         TryReturnVoid(__pPlayer != null, "__pPlayer is null");
 279
 280         r = __pPlayer->SetRenderingBuffer(bufferInfo);
 281         TryReturnVoid(r == E_SUCCESS, "__pPlayer->SetRenderingBuffer failed:%s", GetErrorMessage(r));
 282 }
 283
 284 result
 285 VideoPlayerPresentationModel::StartPlay(void)
 286 {
 287         result r = E_FAILURE;
 288         String mediaPath;
 289         String mediaName;
 290         String delim = L"/";
 291
 292         PlayerState playState = GetState();
 293         AppLogDebug("StartPlay : %d", playState);
 294
 295         TryCatch(__pPlayer != null,, "__pPlayer is null");
 296
 297         switch (playState)
 298         {
 299         case PLAYER_STATE_INITIALIZED:
 300                 // fall through
 301         case PLAYER_STATE_CLOSED:
 302                 {
 303                         mediaPath = GetMediaPathName();
 304                         __pCurrentPlayContentPath->Clear();
 305                         __pCurrentPlayContentPath->Append(mediaPath);
 306
 307                         StringTokenizer strTok(mediaPath, delim);
 308
 309                         while (strTok.HasMoreTokens())
 310                         {
 311                                 strTok.GetNextToken(mediaName);
 312                         }
 313
 314                         if (mediaPath.StartsWith(L"http://", 0) == true
 315                                 || mediaPath.StartsWith(L"https://", 0) == true
 316                                 || mediaPath.StartsWith(L"rtsp://", 0) == true
 317                                 || mediaPath.StartsWith(L"rtp://", 0) == true)
 318                         {
 319                 r = E_FAILURE;
 320                         }
 321                         else
 322                         {
 323                                 r = __pPlayer->OpenFile(mediaPath);
 324                         }
 325
 326                         if (r != E_SUCCESS)
 327                         {
 328                                 AppResource* pAppResource = Application::GetInstance()->GetAppResource();
 329                                 String messageBoxString;
 330                                 pAppResource->GetString(IDS_COM_POP_UNSUPPORTED_FILE_TYPE, messageBoxString);
 331                                 MessageBox messageBox;
 332                                 messageBox.Construct(L"", messageBoxString, MSGBOX_STYLE_NONE, MESSAGEBOX_DISPLAY_TIMEOUT);
 333                                 int modalResult = 0;
 334                                 messageBox.ShowAndWait(modalResult);
 335
 336                                 UiApp* pApp = UiApp::GetInstance();
 337                                 pApp->Terminate();
 338                         }
 339                         else
 340                         {
 341                                 delete __pFileEventMgr;
 342                            __pFileEventMgr = new (std::nothrow) FileEventManager();
 343                                 __pFileEventMgr->Construct(*this);
 344                                 __pFileEventMgr->AddPath(mediaPath, FILE_EVENT_TYPE_DELETE_SELF | FILE_EVENT_TYPE_MOVE_SELF | FILE_EVENT_TYPE_ATTRIBUTE);
 345
 346                                 r = __pPlayer->Play();
 347                                 TryCatch(r == E_SUCCESS,, "__pPlayer->Play() failed:%s", GetErrorMessage(r));
 348
 349                                 if (__pMediaPathArrayList->GetCount() >= MULTI_CONTENT_COUNT)
 350                                 {
 351                                         mediaName.Append(L"(");
 352                                         mediaName.Append(__currentMediaIndex + 1);
 353                                         mediaName.Append(L"/");
 354                                         mediaName.Append(__pMediaPathArrayList->GetCount());
 355                                         mediaName.Append(L")");
 356                                 }
 357                                 else if (__pMediaPathArrayList->GetCount() < MULTI_CONTENT_COUNT)
 358                                 {
 359                                         mediaName.Append(L"(");
 360                                         mediaName.Append(L"1");
 361                                         mediaName.Append(L"/");
 362                                         mediaName.Append(L"1");
 363                                         mediaName.Append(L")");
 364                                 }
 365
 366                                 CallOnPlayContentChanged(mediaName);
 367
 368                                 r = __pTimer->Start(PROGRESS_TIMER_DURATION);
 369                                 TryCatch(r == E_SUCCESS,, "__pTimer->Start() failed:%s", GetErrorMessage(r));
 370                         }
 371                 }
 372                 break;
 373
 374         case PLAYER_STATE_ENDOFCLIP:
 375                 {
 376                         mediaPath = GetMediaPathName();
 377
 378                         if (__pMediaPathArrayList->GetCount() < MULTI_CONTENT_COUNT)
 379                         {
 380                                 r = InitializePlayer();
 381                                 TryCatch(r == E_SUCCESS,, "InitializePlayer() failed : %s", GetErrorMessage(r));
 382
 383                                 r = __pPlayer->OpenFile(mediaPath);
 384                                 TryCatch(r == E_SUCCESS,, "__pPlayer->OpenFile() failed:%s", GetErrorMessage(r));
 385
 386                                 r = __pPlayer->Play();
 387                                 TryCatch(r == E_SUCCESS,, "__pPlayer->Play() failed:%s", GetErrorMessage(r));
 388                         }
 389                         else
 390                         {
 391                                 __pCurrentPlayContentPath->Clear();
 392                                 __pCurrentPlayContentPath->Append(mediaPath);
 393
 394                                 StringTokenizer strTok(mediaPath, delim);
 395
 396                                 while (strTok.HasMoreTokens())
 397                                 {
 398                                         strTok.GetNextToken(mediaName);
 399                                 }
 400
 401                                 if (GetRepeatMode() != REPEAT_TYPE_ONE)
 402                                 {
 403                                         r = InitializePlayer();
 404                                         TryCatch(r == E_SUCCESS,, "InitializePlayer() failed : %s", GetErrorMessage(r));
 405
 406                                         r = __pPlayer->OpenFile(mediaPath);
 407                                         TryCatch(r == E_SUCCESS,, "__pPlayer->OpenFile() failed:%s", GetErrorMessage(r));
 408                                 }
 409
 410                                 r = __pPlayer->Play();
 411                                 TryCatch(r == E_SUCCESS,, "__pPlayer->Play() failed:%s", GetErrorMessage(r));
 412
 413                                 mediaName.Append(L"(");
 414                                 mediaName.Append(__currentMediaIndex + 1);
 415                                 mediaName.Append(L"/");
 416                                 mediaName.Append(__pMediaPathArrayList->GetCount());
 417                                 mediaName.Append(L")");
 418
 419                                 CallOnPlayContentChanged(mediaName);
 420                         }
 421
 422                         __pTimer->Start(PROGRESS_TIMER_DURATION);
 423
 424                 }
 425                 break;
 426
 427         case PLAYER_STATE_PAUSED:
 428                 {
 429                         r = __pPlayer->Play();
 430                         TryCatch(r == E_SUCCESS,, "__pPlayer->Play() failed:%s", GetErrorMessage(r));
 431
 432                         __pTimer->Start(PROGRESS_TIMER_DURATION);
 433                 }
 434                 break;
 435
 436         default:
 437                 break;
 438         }
 439
 440         CallOnPlayStateChanged(GetState());
 441
 442 CATCH:
 443         return r;
 444 }
 445
 446 result
 447 VideoPlayerPresentationModel::StopPlay(void)
 448 {
 449         result r = E_FAILURE;
 450
 451         PlayerState playState = GetState();
 452         AppLogDebug("StopPlay : %d", playState);
 453
 454         switch (playState)
 455         {
 456         case PLAYER_STATE_PLAYING:
 457                 // fall through
 458         case PLAYER_STATE_PAUSED:
 459                 {
 460                         r = __pPlayer->Stop();
 461                         TryCatch(r == E_SUCCESS,, "__pPlayer->Stop() failed:%s", GetErrorMessage(r));
 462                 }
 463                 break;
 464
 465         default:
 466                 break;
 467         }
 468
 469 CATCH:
 470         return r;
 471 }
 472
 473 result
 474 VideoPlayerPresentationModel::PausePlay(void)
 475 {
 476         result r = E_SUCCESS;
 477         PlayerState playState = GetState();
 478         AppLogDebug("PausePlay : %d", playState);
 479
 480         if (__playerSeekCompleted == true)
 481         {
 482                 if (playState == PLAYER_STATE_PLAYING)
 483                 {
 484                         r = __pPlayer->Pause();
 485                         TryCatch(r == E_SUCCESS,, "__pPlayer->Pause() failed:%s", GetErrorMessage(r));
 486                 }
 487         }
 488         else
 489         {
 490                 __stateAfterSeek = PLAYER_STATE_PAUSED;
 491         }
 492
 493         CallOnPlayStateChanged(GetState());
 494
 495 CATCH:
 496         return r;
 497 }
 498
 499 result
 500 VideoPlayerPresentationModel::ClosePlay(void)
 501 {
 502         result r = E_FAILURE;
 503         PlayerState playState = GetState();
 504
 505         switch (playState)
 506         {
 507         case PLAYER_STATE_OPENED:
 508                 // fall through
 509         case PLAYER_STATE_STOPPED:
 510                 // fall through
 511         case PLAYER_STATE_ENDOFCLIP:
 512                 {
 513                         r = __pPlayer->Close();
 514                         TryCatch(r == E_SUCCESS,, "__pPlayer->Close() failed:%s", GetErrorMessage(r));
 515                 }
 516                 break;
 517
 518         default:
 519                 break;
 520         }
 521
 522 CATCH:
 523         return r;
 524 }
 525
 526 PlayerState
 527 VideoPlayerPresentationModel::GetState(void) const
 528 {
 529         TryReturn(__pPlayer != null, PLAYER_STATE_ERROR, "__pPlayer is null");
 530
 531         return __pPlayer->GetState();
 532 }
 533
 534 long
 535 VideoPlayerPresentationModel::GetDuration(void) const
 536 {
 537         TryReturn(__pPlayer != null, 0, "__pPlayer is null");
 538
 539         return __pPlayer->GetDuration();
 540 }
 541
 542 long
 543 VideoPlayerPresentationModel::GetPosition(void) const
 544 {
 545         TryReturn(__pPlayer != null, 0, "__pPlayer is null");
 546
 547         return __pPlayer->GetPosition();
 548 }
 549
 550 void
 551 VideoPlayerPresentationModel::SetVideoPlayerEventListener(IVideoPlayerEventListener* pPlayerListener)
 552 {
 553         __pVideoPlayerEventListener = pPlayerListener;
 554 }
 555
 556 void
 557 VideoPlayerPresentationModel::SetOverlayPanel(OverlayPanel* pOverlay)
 558 {
 559         __pOverlayPanel = pOverlay;
 560 }
 561
 562 void
 563 VideoPlayerPresentationModel::SetRenderingBuffer(void)
 564 {
 565         BufferInfo bufferInfo;
 566         result r = E_SUCCESS;
 567         r = __pOverlayPanel->GetBackgroundBufferInfo(bufferInfo);
 568         if (r == E_SUCCESS)
 569         {
 570                 __pPlayer->SetRenderingBuffer(bufferInfo);
 571         }
 572 }
 573
 574 Tizen::Base::String
 575 VideoPlayerPresentationModel::GetLaunchType(void) const
 576 {
 577         return __launchType;
 578 }
 579
 580 void
 581 VideoPlayerPresentationModel::SetLaunchType()
 582 {
 583         VideoPlayerApp* pVideoPlayerApp = static_cast<VideoPlayerApp*>(VideoPlayerApp::GetInstance());
 584         TryReturnVoid(pVideoPlayerApp != null, "pVideoPlayerApp is null");
 585
 586         const IMap* pArguments = pVideoPlayerApp->GetAppControlArguments();
 587
 588         if (pArguments != null)
 589         {
 590                 const String* pType = static_cast<const String*>(pArguments->GetValue(String(APPCONTROL_KEY_TYPE)));
 591
 592                 if (pType != null)
 593                 {
 594                         __launchType = *pType;
 595                 }
 596         }
 597 }
 598
 599 void
 600 VideoPlayerPresentationModel::OnPlayerOpened(result r)
 601 {
 602         AppLogDebug("OnPlayerOpened");
 603         __pVideoPlayerEventListener->OnPlayOpened(r);
 604 }
 605
 606 void
 607 VideoPlayerPresentationModel::OnPlayerEndOfClip(void)
 608 {
 609         bool playNextContent = false;
 610         String* pFilePath = null;
 611         result r = E_SUCCESS;
 612
 613         AppLogDebug("OnPlayerEndOfClip");
 614
 615         __pTimer->Cancel();
 616         __pFastForwardTimer->Cancel();
 617         __pFastRewindTimer->Cancel();
 618
 619         __playerLastSeekCompleted = false;
 620         __playerSeekCompleted = true;
 621
 622         switch (GetRepeatMode())
 623         {
 624         case REPEAT_TYPE_OFF:
 625                 {
 626                         if (__pMediaPathArrayList->GetCount() < MULTI_CONTENT_COUNT)
 627                         {
 628                                 __currentMediaIndex = INIT_CONTENT_INDEX;
 629                                 playNextContent = false;
 630                         }
 631                         else
 632                         {
 633                                 IEnumerator* pEnum = __pMediaPathArrayList->GetEnumeratorN();
 634                                 r = pEnum->Reset();
 635
 636                                 for (int index = 0; index < __pMediaPathArrayList->GetCount(); index++)
 637                                 {
 638                                         if (__currentMediaIndex == (__pMediaPathArrayList->GetCount() - 1))
 639                                         {
 640                                                 __currentMediaIndex = INIT_CONTENT_INDEX;
 641                                                 playNextContent = false;
 642                                                 break;
 643                                         }
 644                                         r = pEnum->MoveNext();
 645
 646                                         if (r == E_SUCCESS)
 647                                         {
 648                                                 pFilePath = static_cast<String*>(pEnum->GetCurrent());
 649
 650                                                 if (pFilePath->Equals(*__pCurrentPlayContentPath) == false)
 651                                                 {
 652                                                         __currentMediaIndex++;
 653                                                         playNextContent = true;
 654                                                         r = pEnum->Reset();
 655                                                         break;
 656                                                 }
 657                                         }
 658                                 }
 659                         }
 660                 }
 661                 break;
 662
 663         case REPEAT_TYPE_ONE:
 664                 {
 665                         // Empty Statement
 666                 }
 667                 break;
 668
 669         case REPEAT_TYPE_ALL:
 670                 {
 671                         if (__pMediaPathArrayList->GetCount() < MULTI_CONTENT_COUNT)
 672                         {
 673                                 __currentMediaIndex = INIT_CONTENT_INDEX;
 674                         }
 675                         else
 676                         {
 677                                 IEnumerator* pEnum = __pMediaPathArrayList->GetEnumeratorN();
 678                                 r = pEnum->Reset();
 679
 680                                 for (int index = 0; index < __pMediaPathArrayList->GetCount(); index++)
 681                                 {
 682                                         if (__currentMediaIndex == (__pMediaPathArrayList->GetCount() - 1))
 683                                         {
 684                                                 __currentMediaIndex = INIT_CONTENT_INDEX;
 685                                                 break;
 686                                         }
 687                                         r = pEnum->MoveNext();
 688
 689                                         if (r == E_SUCCESS)
 690                                         {
 691                                                 pFilePath = static_cast<String*>(pEnum->GetCurrent());
 692
 693                                                 if (pFilePath->Equals(*__pCurrentPlayContentPath) == false)
 694                                                 {
 695                                                         __currentMediaIndex++;
 696                                                         r = pEnum->Reset();
 697                                                         break;
 698                                                 }
 699                                         }
 700                                 }
 701                         }
 702                 }
 703                 break;
 704
 705         default:
 706                 break;
 707         }
 708
 709         __pVideoPlayerEventListener->OnPlayEndOfClip(playNextContent, __repeatMode, __pMediaPathArrayList->GetCount());
 710 }
 711
 712 void
 713 VideoPlayerPresentationModel::OnPlayerBuffering(int percent)
 714 {
 715         AppLogDebug("OnPlayerBuffering");
 716         __pVideoPlayerEventListener->OnPlayBuffering(percent);
 717 }
 718
 719 void
 720 VideoPlayerPresentationModel::OnPlayerErrorOccurred(PlayerErrorReason r)
 721 {
 722         AppLogDebug("OnPlayerErrorOccurred");
 723
 724         __pTimer->Cancel();
 725         __pVideoPlayerEventListener->OnPlayErrorOccurred(r);
 726 }
 727
 728 void
 729 VideoPlayerPresentationModel::OnPlayerInterrupted(void)
 730 {
 731         AppLogDebug("OnPlayerInterrupted");
 732         __pVideoPlayerEventListener->OnPlayInterrupted();
 733
 734         CallOnPlayStateChanged(GetState());
 735 }
 736
 737 void
 738 VideoPlayerPresentationModel::OnPlayerAudioFocusChanged(void)
 739 {
 740         AppLogDebug("OnPlayerAudioFocusChanged");
 741
 742         CallOnPlayStateChanged(GetState());
 743 }
 744
 745 void
 746 VideoPlayerPresentationModel::OnPlayerReleased(void)
 747 {
 748         AppLogDebug("OnPlayerReleased");
 749         __pVideoPlayerEventListener->OnPlayReleased();
 750 }
 751
 752 void
 753 VideoPlayerPresentationModel::CallOnPlayContentChanged(const String& fileName)
 754 {
 755         AppLogDebug("CallOnPlayContentChanged");
 756
 757         __pVideoPlayerEventListener->OnPlayContentChanged(fileName);
 758 }
 759
 760 void
 761 VideoPlayerPresentationModel::CallOnPlayTimeChanged(int currentProgressPos, String& currentPlayTime)
 762 {
 763         AppLogDebug("CallOnPlayTimeChanged");
 764
 765         __pVideoPlayerEventListener->OnPlayTimeChanged(currentProgressPos, currentPlayTime);
 766 }
 767
 768 void
 769 VideoPlayerPresentationModel::CallOnPlayStateChanged(PlayerState playState)
 770 {
 771         AppLogDebug("CallOnPlayStateChanged");
 772
 773         __pVideoPlayerEventListener->OnPlayStateChanged(playState);
 774 }
 775
 776 void
 777 VideoPlayerPresentationModel::InitTimer(void)
 778 {
 779         AppLogDebug("InitTimer");
 780
 781         __pTimer = new (std::nothrow) Timer();
 782         __pTimer->Construct(*this);
 783
 784         __pFastForwardTimer = new (std::nothrow) Timer();
 785         __pFastForwardTimer->Construct(*this);
 786
 787         __pFastRewindTimer = new (std::nothrow) Timer();
 788         __pFastRewindTimer->Construct(*this);
 789 }
 790
 791 void
 792 VideoPlayerPresentationModel::DeleteTimer(void)
 793 {
 794         AppLogDebug("DeleteTimer");
 795
 796         __pTimer->Cancel();
 797         delete __pTimer;
 798         __pTimer = null;
 799
 800         __pFastForwardTimer->Cancel();
 801         delete __pFastForwardTimer;
 802         __pFastForwardTimer = null;
 803
 804         __pFastRewindTimer->Cancel();
 805         delete __pFastRewindTimer;
 806         __pFastRewindTimer = null;
 807 }
 808
 809 void
 810 VideoPlayerPresentationModel::OnTimerExpired(Timer& timer)
 811 {
 812         result r = E_FAILURE;
 813         long msTime = 0;
 814         int currentProgressPos = 0;
 815         DateTime dateTime;
 816         String currentPlayTime;
 817         long playerDuration = 0;
 818
 819         PlayerState playState = GetState();
 820
 821         if (timer.GetHashCode() == __pTimer->GetHashCode())
 822         {
 823                 if (playState == PLAYER_STATE_INITIALIZED || playState == PLAYER_STATE_PLAYING)
 824                 {
 825                         playerDuration = GetDuration();
 826                         dateTime.AddSeconds(GetPosition() / MILLISECOND);
 827                         currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
 828
 829                         if (playerDuration != START_TIME)
 830                         {
 831                                 currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
 832                         }
 833                         CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 834
 835                         __pTimer->Start(PROGRESS_TIMER_DURATION);
 836                 }
 837         }
 838         else if (timer.GetHashCode() == __pFastForwardTimer->GetHashCode())
 839         {
 840                 msTime = GetPosition();
 841                 playerDuration = GetDuration();
 842
 843                 msTime = msTime + (TWO_SEC * MILLISECOND);
 844
 845                 if (msTime < playerDuration)
 846                 {
 847                         if (__playerSeekCompleted == true)
 848                         {
 849                                 r = SeekTo(msTime);
 850                                 TryReturnVoid(r == E_SUCCESS, "VideoPlayerPresentationModel::SeekTo() failed:%s", GetErrorMessage(r));
 851
 852                                 __playerSeekCompleted = false;
 853
 854                                 dateTime.AddSeconds(msTime / MILLISECOND);
 855                                 currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
 856
 857                                 if (playerDuration != START_TIME)
 858                                 {
 859                                         currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
 860                                 }
 861                                 CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 862                         }
 863                 }
 864                 else
 865                 {
 866                         if (__playerSeekCompleted == true)
 867                         {
 868                                 r = SeekTo(playerDuration);
 869                                 TryReturnVoid(r == E_SUCCESS, "VideoPlayerPresentationModel::SeekTo() failed:%s", GetErrorMessage(r));
 870                                 __playerSeekCompleted = false;
 871
 872                                 dateTime.AddSeconds(playerDuration / MILLISECOND);
 873                                 currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
 874
 875                                 if (playerDuration != START_TIME)
 876                                 {
 877                                         currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
 878                                 }
 879                                 CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 880                         }
 881                 }
 882                 __pFastForwardTimer->Start(LONGKEY_TIMER_DURATION);
 883         }
 884         else if (timer.GetHashCode() == __pFastRewindTimer->GetHashCode())
 885         {
 886                 msTime = GetPosition();
 887                 playerDuration = GetDuration();
 888
 889                 msTime = msTime - (TWO_SEC * MILLISECOND);
 890
 891                 if (msTime > START_TIME)
 892                 {
 893                         if (__playerSeekCompleted == true)
 894                         {
 895                                 r = SeekTo(msTime);
 896                                 TryReturnVoid(r == E_SUCCESS, "VideoPlayerPresentationModel::SeekTo() failed:%s", GetErrorMessage(r));
 897
 898                                 __playerSeekCompleted = false;
 899
 900                                 dateTime.AddSeconds(msTime / MILLISECOND);
 901                                 currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
 902
 903                                 if (playerDuration != START_TIME)
 904                                 {
 905                                         currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
 906                                 }
 907                                 CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 908                         }
 909                 }
 910                 else
 911                 {
 912                         if (__playerSeekCompleted == true)
 913                         {
 914                                 r = SeekTo(START_TIME);
 915                                 TryReturnVoid(r == E_SUCCESS, "VideoPlayerPresentationModel::SeekTo() failed:%s", GetErrorMessage(r));
 916
 917                                 __playerSeekCompleted = false;
 918
 919                                 currentPlayTime.Format(20, L"%02d:%02d:%02d", START_TIME, START_TIME, START_TIME);
 920
 921                                 currentProgressPos = START_TIME;
 922
 923                                 CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 924                         }
 925                 }
 926                 __pFastRewindTimer->Start(LONGKEY_TIMER_DURATION);
 927         }
 928 }
 929
 930 void
 931 VideoPlayerPresentationModel::Forward(void)
 932 {
 933         result r = E_FAILURE;
 934
 935         long msTime = 0;
 936         int currentProgressPos = 0;
 937         DateTime dateTime;
 938         String currentPlayTime;
 939         long playerDuration = 0;
 940
 941         AppLogDebug("Forward");
 942
 943         PlayerState playState = GetState();
 944
 945         if (playState != PLAYER_STATE_ENDOFCLIP)
 946         {
 947                 playerDuration = GetDuration();
 948                 msTime = GetPosition();
 949
 950                 if (!(msTime == START_TIME && playState == PLAYER_STATE_PLAYING))
 951                 {
 952                         msTime = msTime + (TEN_SEC * MILLISECOND);
 953
 954                         if (msTime < playerDuration)
 955                         {
 956                                 if (__playerSeekCompleted == true)
 957                                 {
 958                                         r = SeekTo(msTime);
 959                                         TryReturnVoid(r == E_SUCCESS, "SeekTo() failed:%s", GetErrorMessage(r));
 960
 961                                         dateTime.AddSeconds(msTime / MILLISECOND);
 962                                         currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
 963
 964                                         if (playerDuration != START_TIME)
 965                                         {
 966                                                 currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
 967                                         }
 968                                         CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 969
 970                                         __playerSeekCompleted = false;
 971                                         __stateAfterSeek = playState;
 972                                 }
 973                         }
 974                         else
 975                         {
 976                                 if (__playerSeekCompleted == true)
 977                                 {
 978                                         r = SeekTo(playerDuration);
 979                                         TryReturnVoid(r == E_SUCCESS, "SeekTo() failed:%s", GetErrorMessage(r));
 980
 981                                         dateTime.AddSeconds(playerDuration / MILLISECOND);
 982                                         currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
 983
 984                                         if (playerDuration != START_TIME)
 985                                         {
 986                                                 currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
 987                                         }
 988                                         CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
 989
 990                                         __playerSeekCompleted = false;
 991                                         __stateAfterSeek = playState;
 992                                 }
 993                         }
 994                 }
 995         }
 996 }
 997
 998 void
 999 VideoPlayerPresentationModel::Rewind(void)
1000 {
1001         result r = E_FAILURE;
1002
1003         long msTime = 0;
1004         int currentProgressPos = 0;
1005         DateTime dateTime;
1006         String currentPlayTime;
1007         long playerDuration = 0;
1008
1009         AppLogDebug("Rewind");
1010
1011         PlayerState playState = GetState();
1012
1013         if (playState != PLAYER_STATE_ENDOFCLIP)
1014         {
1015                 playerDuration = GetDuration();
1016                 msTime = GetPosition();
1017
1018                 msTime = msTime - (TEN_SEC * MILLISECOND);
1019
1020                 if (msTime < START_TIME)
1021                 {
1022                         if (__playerSeekCompleted == true)
1023                         {
1024                                 r = SeekTo(START_TIME);
1025                                 TryReturnVoid(r == E_SUCCESS, "SeekTo() failed:%s", GetErrorMessage(r));
1026
1027                                 currentPlayTime.Format(20, L"%02d:%02d:%02d", START_TIME, START_TIME, START_TIME);
1028
1029                                 if (playerDuration != START_TIME)
1030                                 {
1031                                         currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
1032                                 }
1033                                 CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
1034
1035                                 __playerSeekCompleted = false;
1036                                 __stateAfterSeek = playState;
1037                         }
1038                 }
1039                 else
1040                 {
1041                         if (__playerSeekCompleted == true)
1042                         {
1043                                 r = SeekTo(msTime);
1044                                 TryReturnVoid(r == E_SUCCESS, "SeekTo() failed:%s", GetErrorMessage(r));
1045
1046                                 dateTime.AddSeconds(msTime / MILLISECOND);
1047                                 currentPlayTime.Format(20, L"%02d:%02d:%02d", dateTime.GetHour(), dateTime.GetMinute(), dateTime.GetSecond());
1048
1049                                 if (playerDuration != START_TIME)
1050                                 {
1051                                         currentProgressPos = static_cast<int>(GetPosition() / (playerDuration / MAX_PROGRESS_RANGE));
1052                                 }
1053                                 CallOnPlayTimeChanged(currentProgressPos, currentPlayTime);
1054
1055                                 __playerSeekCompleted = false;
1056                                 __stateAfterSeek = playState;
1057                         }
1058                 }
1059         }
1060 }
1061
1062 void
1063 VideoPlayerPresentationModel::FastForward(bool playAfterSeek)
1064 {
1065         AppLogDebug("FastForward");
1066
1067         if (GetState() != PLAYER_STATE_ENDOFCLIP)
1068         {
1069                 PausePlay();
1070                 if (playAfterSeek)
1071                 {
1072                         __stateAfterSeek = PLAYER_STATE_PLAYING;
1073                 }
1074                 else
1075                 {
1076                         __stateAfterSeek = PLAYER_STATE_PAUSED;
1077                 }
1078
1079                 __pFastForwardTimer->Start(LONGKEY_TIMER_DURATION);
1080         }
1081 }
1082
1083 void
1084 VideoPlayerPresentationModel::FastRewind(bool playAfterSeek)
1085 {
1086         AppLogDebug("FastRewind");
1087
1088         if (GetState() != PLAYER_STATE_ENDOFCLIP)
1089         {
1090                 PausePlay();
1091                 if (playAfterSeek)
1092                 {
1093                         __stateAfterSeek = PLAYER_STATE_PLAYING;
1094                 }
1095                 else
1096                 {
1097                         __stateAfterSeek = PLAYER_STATE_PAUSED;
1098                 }
1099
1100                 __pFastRewindTimer->Start(LONGKEY_TIMER_DURATION);
1101         }
1102 }
1103
1104 void
1105 VideoPlayerPresentationModel::StopFastForwardRewind(void)
1106 {
1107         AppLogDebug("StopFastForwardRewind");
1108
1109         if (GetState() != PLAYER_STATE_ENDOFCLIP)
1110         {
1111                 __pFastForwardTimer->Cancel();
1112                 __pFastRewindTimer->Cancel();
1113
1114                 if (__playerSeekCompleted == true)
1115                 {
1116                         if (__stateAfterSeek == PLAYER_STATE_PLAYING)
1117                         {
1118                                 result r = StartPlay();
1119                                 TryReturnVoid(r == E_SUCCESS, "__pPlayer->Play() failed:%s", GetErrorMessage(r));
1120
1121                                 CallOnPlayStateChanged(GetState());
1122
1123                                 __pTimer->Start(PROGRESS_TIMER_DURATION);
1124                         }
1125                 }
1126                 else
1127                 {
1128                         __playerLastSeekCompleted = true;
1129                 }
1130         }
1131 }
1132
1133 String
1134 VideoPlayerPresentationModel::GetMediaPathName(void) const
1135 {
1136         AppLogDebug("GetMediaPathName");
1137
1138         String* pMediaName = null;
1139
1140         pMediaName = static_cast<String*>(__pMediaPathArrayList->GetAt(__currentMediaIndex));
1141         return *pMediaName;
1142 }
1143
1144 result
1145 VideoPlayerPresentationModel::SetMediaPathArray(void)
1146 {
1147         AppLogDebug("SetMediaPathArray");
1148
1149         result r = E_SUCCESS;
1150
1151         VideoPlayerApp* pVideoPlayerApp = static_cast<VideoPlayerApp*>(VideoPlayerApp::GetInstance());
1152
1153         String uriData = pVideoPlayerApp->GetUriData();
1154
1155         __pMediaPathArrayList = new (std::nothrow) ArrayList();
1156         r = __pMediaPathArrayList->Construct();
1157         TryCatch(r == E_SUCCESS,, "__pMediaPathArrayList->Construct() failed:%s", GetErrorMessage(r));
1158
1159         if (uriData != L"")
1160         {
1161                 __pMediaPathArrayList->Add((new (std::nothrow) String(uriData)));
1162         }
1163         else
1164         {
1165                 const IMap* pArguments = pVideoPlayerApp->GetAppControlArguments();
1166                 if (pArguments != null)
1167                 {
1168                         const ArrayList* pList = static_cast<const ArrayList*>(pArguments->GetValue(String(APPCONTROL_KEY_PATH)));
1169
1170                         if (pList != null)
1171                         {
1172                                 const String* pPath;
1173                                 int count = pList->GetCount();
1174                                 for (int i = 0; i < count; ++i)
1175                                 {
1176                                         pPath = static_cast<const String*>(pList->GetAt(i));
1177                                         __pMediaPathArrayList->Add(new (std::nothrow) String(*pPath));
1178                                 }
1179                         }
1180                 }
1181         }
1182
1183         return r;
1184
1185 CATCH:
1186         if (__pMediaPathArrayList != null)
1187         {
1188                 __pMediaPathArrayList->RemoveAll(true);
1189                 delete __pMediaPathArrayList;
1190                 __pMediaPathArrayList = null;
1191         }
1192         return r;
1193 }
1194
1195 int
1196 VideoPlayerPresentationModel::GetMediaCount(void) const
1197 {
1198         return __pMediaPathArrayList->GetCount();
1199 }
1200
1201 int
1202 VideoPlayerPresentationModel::GetCurrentMediaIndex(void) const
1203 {
1204         return __currentMediaIndex;
1205 }
1206
1207 bool
1208 VideoPlayerPresentationModel::GetSeekCompleted(void) const
1209 {
1210         return __playerSeekCompleted;
1211 }
1212
1213 result
1214 VideoPlayerPresentationModel::InitializePlayer(void)
1215 {
1216         BufferInfo bufferInfo;
1217         result r = E_SUCCESS;
1218
1219         AppLogDebug("InitializePlayer");
1220
1221         delete __pPlayer;
1222         __pPlayer = null;
1223
1224         r = __pOverlayPanel->GetBackgroundBufferInfo(bufferInfo);
1225         TryCatch(r == E_SUCCESS,, "__pOverlayPanel->GetBackgroundBufferInfo failed:%s", GetErrorMessage(r));
1226
1227         __pPlayer = new (std::nothrow) Player();
1228         AppLogDebug("__pPlayer [%x]", __pPlayer);
1229
1230         r = __pPlayer->Construct(*this, &bufferInfo);
1231         TryCatch(r == E_SUCCESS,, "__pPlayer->Construct failed:%s", GetErrorMessage(r));
1232
1233         return r;
1234
1235 CATCH:
1236  if ( __pPlayer != null)
1237  {
1238         delete __pPlayer;
1239         __pPlayer = null;
1240  }
1241         return r;
1242 }
1243
1244 int
1245 VideoPlayerPresentationModel::GetRepeatMode(void) const
1246 {
1247         return __repeatMode;
1248 }
1249
1250 void
1251 VideoPlayerPresentationModel::SetRepeatMode(int repeatMode)
1252 {
1253         __repeatMode = repeatMode;
1254 }
1255
1256 void
1257 VideoPlayerPresentationModel::ChangeCurrentMediaIndex(void)
1258 {
1259         AppLogDebug("ChangeCurrentMediaIndex");
1260
1261         if (GetState() == PLAYER_STATE_ENDOFCLIP)
1262         {
1263                 switch (GetRepeatMode())
1264                 {
1265                 case REPEAT_TYPE_OFF:
1266                         {
1267                                 __currentMediaIndex = INIT_CONTENT_INDEX;
1268                         }
1269                         break;
1270
1271                 case REPEAT_TYPE_ONE:
1272                         {
1273                                 __currentMediaIndex = __pMediaPathArrayList->GetCount() - 1;
1274                         }
1275                         break;
1276
1277                 case REPEAT_TYPE_ALL:
1278                         {
1279                                 __currentMediaIndex = INIT_CONTENT_INDEX;
1280                         }
1281                         break;
1282
1283                 default:
1284                         break;
1285                 }
1286         }
1287 }
1288
1289 void
1290 VideoPlayerPresentationModel::OnFileEventOccured (const unsigned long events, const Tizen::Base::String &path, const unsigned int eventId)
1291 {
1292         AppLogDebug("OnFileEventOccured: %ls", path.GetPointer());
1293
1294         if ((events & FILE_EVENT_TYPE_MOVE_SELF) == FILE_EVENT_TYPE_MOVE_SELF
1295             || (events & FILE_EVENT_TYPE_DELETE_SELF) == FILE_EVENT_TYPE_DELETE_SELF
1296             || (events & FILE_EVENT_TYPE_ATTRIBUTE) == FILE_EVENT_TYPE_ATTRIBUTE)
1297         {
1298                 __pFileEventMgr->RemovePath(path);
1299                 UiApp* pApp = UiApp::GetInstance();
1300                 pApp->Terminate();
1301         }
1302 }