开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 通讯/手机编程 > Symbian > 查看源码
chxavplayview.cpp
资源名称：142_61_thumb_advanced.rar　[点击查看]
上传用户：dangjiwu
上传日期：2013-07-19
资源大小：42019k
文件大小：44k
源码类别：

Symbian

开发平台：

Visual C++

chxavplayview.cpp：源码内容
  1. /************************************************************************
  2.  * chxavplayview.cpp
  3.  * -----------------
  4.  *
  5.  * Synopsis:
  6.  * Contains the implementation of the CHXAvPlayView class.  This class 
  7.  * will control actual playback once a file/url has been selected for play.
  8.  *
  9.  * Target:
  10.  * Symbian OS
  11.  *
  12.  *
  13.  * (c) 1995-2003 RealNetworks, Inc. Patents pending. All rights reserved.
  14.  *
  15.  ************************************************************************/
  17. // Symbian includes...
  18. #include <coeccntx.h>
  19. #include <eikbtgpc.h>
  20. #include <eikmenub.h>
  21. #include <eikmenup.h>
  22. #include <eikfutil.h>
  23. #include <eikenv.h>
  24. #include <eikappui.h>
  25. #include <eikapp.h>
  26. #include <eikdoc.h>
  27. #include <avkon.hrh>
  28. #include <avkon.rsg>
  29. #include <eikmenup.h>
  30. #include <eikon.hrh>
  31. #include <aknviewappui.h>
  32. #include <apchangeobserver.h>
  34. // Helix includes...
  35. #include "hxassert.h"
  36. #include "ihxpckts.h"
  37. #include "hxstring.h"
  38. #include "hxurl.h"
  40. // Includes for this project...
  41. #include "hxsym_debug.h"
  42. #include "realplayer.rsg"
  43. #include "realplayer.mbg"
  44. #include "chxavplayer.h"
  45. #include "chxavplayerui.h"
  46. #include "chxavfilestore.h"
  47. #include "chxavfileui.h"
  48. #include "chxavclipinfolist.h"
  49. #include "chxavconfignames.h"
  50. #include "chxavinfolistpopup.h"
  51. #include "chxavcleanupstack.h"
  52. #include "chxavnavipanecontrol.h"
  53. #include "chxavplaylistnavicontrol.h"
  54. #include "chxavplayviewwindow.h"
  55. #include "chxavplayerstate.h"
  56. #include "chxavviewbase.h"
  57. #include "chxavplayview.h"
  58. #include "hxapihelp.h"
  59. #include "hxsym_leaveutil.h"
  60. #include "chxavcleanstring.h"
  61. #include "realplayer.hrh"
  62. #include "chxavnetconnectui.h"
  63. #include "chxavplayerr.h"
  66. namespace
  67. {
  68.     // how long to show non-default navi control after user action
  69.     const TUint k_msShowTempNavi = 1000;
  70.     
  71.     // how often to reset inactivity timer so backlight stays on during a video presentation
  72.     const TUint k_msBacklightInterval = 5000;
  73. }
  76. /* 
  77.  * CHXAvPlayView
  78.  * -------------
  79.  * Constructor.
  80.  *
  81.  */
  82. CHXAvPlayView::CHXAvPlayView(TInt viewIndex, CHXAvPlayerUI *playerUI)
  83. : CHXAvViewBase(viewIndex, playerUI)
  84. , m_bViewPlaylistMode(false)
  85. , m_bEnsureResumeOnExitPlaylistMode(false)
  86. , m_lastPhoneState(ESACallNone)
  87. , m_msSeekStep(0)
  88. , m_bShutDownOnViewDeactivate(true)
  89. {
  90. }
  94. /*
  95.  * ~CHXAvPlayView
  96.  * --------------
  97.  * Destructor.
  98.  *
  99.  */
  100. CHXAvPlayView::~CHXAvPlayView()
  101. {
  102.     // player may not be shutdown yet (e.g., exiting from 'child' view)
  103.     HX_ASSERT(m_player);
  104.     if( m_player )
  105.     {
  106.         m_player->ShutDown();
  107.         m_player->GetPlayerState().RemoveObserver(this);
  108.     }
  110. }
  114. /* 
  115.  * ConstructL
  116.  * ----------
  117.  * Construction of elements.
  118.  *
  119.  */
  120. void CHXAvPlayView::ConstructL()
  121. {
  122.     BaseConstructL(R_AVP_PLAYER_VIEW_INFO);
  124.     // timer for hiding volume control after user interaction delay 
  125.     const CHXAvCommand& cmdHide = 
  126. MakeCommand(this, &CHXAvPlayView::HideTempNaviControlNowL);
  127.     m_cbTempNaviDisplay.ConstructL(cmdHide);
  129.     // timer for periodically resetting backlight so it stays on while playing
  130.     const CHXAvCommand& cmdBacklight = 
  131. MakeCommand(this, &CHXAvPlayView::OnBacklightTimer);
  132.     m_cbBacklight.ConstructL(cmdBacklight);
  135.     // see SetEndSeekCallback()
  136.     const CHXAvCommand& cmdEndSeek = MakeCommand(this, &CHXAvPlayView::OnEndSeekCallback);
  137.     m_cbEndSeek.ConstructL(cmdEndSeek);
  139.    
  140.     // watch for phone call events
  141.     const CHXAvCommand& cmdOnPhoneEvent = 
  142.         MakeCommand(this, &CHXAvPlayView::OnPhoneEvent);
  143.     m_saWatcher.ConstructL(KUidCurrentCall, CActive::EPriorityHigh);
  145.     m_lastPhoneState = m_saWatcher.GetSa().GetState(KUidCurrentCall);
  146.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::ContructL(): current phone state = %ldn", m_lastPhoneState));
  148.     m_saWatcher.SetEventActionL(cmdOnPhoneEvent);
  149.     m_saWatcher.StartWatching();
  152.     // command to execute if user cancels while connecting
  153.     const CHXAvCommand& cmdCancelConnect =
  154.         MakeCommand(this, &CHXAvPlayView::OnUserCancelConnect);
  156.     m_spNetConnectUi = new (ELeave) CHXAvNetConnectUI();
  157.     m_spNetConnectUi->ConstructL(m_playerUI->GetClientEngineManager()->GetEngine(), cmdCancelConnect);
  159.     m_player = new (ELeave) CHXAvPlayer();
  160.     m_player->ConstructL(m_playerUI->GetClientEngineManager(), m_spNetConnectUi);
  161. }
  164. ////////////////////////////////////////
  165. //
  166. void
  167. CHXAvPlayView::HandleVolumeCommand(TInt idCmd)
  168. {
  169.     switch(idCmd)
  170.     {
  171.     case EVolUp:
  172.         m_player->StepVolume(1);
  173.         if( m_player->IsMuted())
  174.         {
  175.             // unmute 
  176.             m_player->Mute(false);  
  177.         }
  178.         
  179. break;
  180.     case EVolDown:
  181.         m_player->StepVolume(-1);
  182.         if( m_player->GetVolume() == 0 )
  183.         {
  184.             // ensure mute
  185.             m_player->Mute(true);
  186.         }
  187.         else
  188.         {
  189.             // ensure not muted after user volume change to (still) positive volume level
  190.             m_player->Mute(false);
  191.         }
  192.         break;
  193.     default:
  194.         HX_ASSERT(false);
  195. break;
  196.     }
  197. }
  199. ////////////////////////////////////////////////
  200. //
  201. void CHXAvPlayView::DoExitPlaylistModeL(bool bPlayCurrent)
  202. {
  203.     m_bViewPlaylistMode = false;
  204.     DeactivateNaviPlaylistControl();
  205.     if(bPlayCurrent && m_player->CanResume() )
  206.     {
  207.         m_player->PlayCurrent();
  208.     }
  209.     else
  210.     {
  211.         UpdateSoftkeyMenuStateL();
  212.     }
  213. }
  215. ////////////////////////////////////////////////
  216. // activate navi playlist control with auto-hide timer ON so
  217. // it hides after a brief display
  218. void CHXAvPlayView::ShowTempPlaylistControlL()
  219. {
  220.     if(!m_bViewPlaylistMode)
  221.     {
  222.         ActivateNaviPlaylistControlL(k_msShowTempNavi);
  223.         m_naviPane->PushL(*m_spNaviPlaylistDecorator);
  224.     }
  225. }
  228. ////////////////////////////////////////////////
  229. //
  230. // check for playlist-related commands
  231. //
  232. // return 'false' if we should continuing handling command
  233. //
  234. bool CHXAvPlayView::TryHandlePlaylistCommandL(TInt command)
  235. {
  236.     bool bWasHandled = true;
  238.     if(m_player->IsPlaylistLoaded() && m_player->GetPlaylistItemCount() > 1 )
  239.     {
  240.         switch(command)
  241.         {
  242.             case EShowPlaylistInfo:
  243.                 HX_ASSERT(!m_bViewPlaylistMode);
  244.                 ShowTempPlaylistControlL();
  245.                 break;
  246.             case EEnterPlaylistMode:
  247.                 //HX_ASSERT(!m_bViewPlaylistMode);
  248.                 if( !m_bViewPlaylistMode )
  249.                 {
  250.                     m_bEnsureResumeOnExitPlaylistMode = m_player->IsPlaying();
  251.                     m_bViewPlaylistMode = true;
  252.                     UpdateSoftkeyMenuStateL();
  253.                     
  254.                     // activate navi playlist control with auto-hide timer OFF
  255.                     ActivateNaviPlaylistControlL(0);
  256.                     m_naviPane->PushL(*m_spNaviPlaylistDecorator);
  257.                 }
  258.                 break;
  259.             case EExitPlaylistMode:
  260.                 HX_ASSERT(m_bViewPlaylistMode);
  261.                 if( m_bViewPlaylistMode)
  262.                 {
  263.                     DoExitPlaylistModeL(m_bEnsureResumeOnExitPlaylistMode);
  264.                     
  265.                 }
  266.                 break;
  267.             case ENextClip:
  268.                 m_player->AdvancePlaylist(CHXAvPlayer::advanceNext | CHXAvPlayer::advanceLoop);
  269.                 ShowTempPlaylistControlL();
  270.                 if(!m_bViewPlaylistMode && m_player->CanResume())
  271.                 {
  272.                     m_player->PlayCurrent();
  273.                 }
  274.         break;
  275.             case EPrevClip:
  276.                 m_player->AdvancePlaylist(CHXAvPlayer::advancePrev | CHXAvPlayer::advanceLoop);
  277.                 ShowTempPlaylistControlL();
  278.                 if(!m_bViewPlaylistMode && m_player->CanResume())
  279.                 {
  280.                     m_player->PlayCurrent();
  281.                 }
  282.         break;
  283.             case EShowDefaultMenu:
  284.                 DoExitPlaylistModeL(false);
  285.                 HandleShowPopupL();
  286.                 break;
  288.             default:
  289.                 bWasHandled = false;
  290.                 break;
  291.         }
  292.     }
  293.     else
  294.     {
  295.         switch(command)
  296.         {
  297.             // ignore these when playlist not loaded
  298.             case EShowPlaylistInfo:
  299.             case EEnterPlaylistMode:
  300.             case EExitPlaylistMode:
  301.             case ENextClip:
  302.             case EPrevClip:
  303.                 break;
  304.             default:
  305.                 bWasHandled = false;
  306.                 break;
  307.         }
  308.     }
  309.  
  310.     return bWasHandled;
  311. }
  313. void CHXAvPlayView::DoTogglePlayState()
  314. {
  315.     if (m_player->IsPaused())
  316.     {
  317. m_player->Resume();
  318.     }
  319.     else if (m_player->IsStopped())
  320.     {
  321. m_player->PlayCurrent();
  322.     }
  323.     else
  324.     {
  325. m_player->Pause();
  326.     }
  327. }
  329. /*
  330.  * HandleSeekKeyCommand
  331.  * --------------------
  332.  * User pressed seek forward/back key.
  333.  *
  334.  */
  335. void 
  336. CHXAvPlayView::HandleSeekKeyCommand(bool bForward)
  337. {
  338.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::HandleSeekKeyCommand('%s')n", dbg::Bool(bForward)));
  339.     if (m_player->IsSeeking())
  340.     {
  341. HX_ASSERT(!m_player->GetClipInfo().IsLive());
  343. UINT32 newTime = m_player->GetClipTime();
  344.  
  345. m_msSeekStep = GetNextSeekStep(m_msSeekStep);
  347. if( bForward )
  348. {
  349.     // ok if we go past duration -- player handles it by moving to next clip (or stopping)
  350.     newTime += m_msSeekStep;
  351. }
  352. else
  353. {
  354.     newTime = m_player->GetClipTime();
  355.     if( newTime > m_msSeekStep )
  356.     {
  357. newTime -= m_msSeekStep;
  358.     }
  359.     else
  360.     {
  361. newTime = 0;
  362.     }
  363. }
  365. m_player->SetSeekPoint(newTime);
  366.     }
  367. }
  368. ////////////////////////////////////////
  369. //
  370. void CHXAvPlayView::DoViewClipInfoL()
  371. {
  372.     CHXAvClipInfoList* pList = new (ELeave) CHXAvClipInfoList();
  373.     AUTO_PUSH_POP(pList);
  374.     pList->ConstructL();
  375.     pList->BuildClipInfoL(m_player);
  377.     CHXAvInfoListPopup* pPopup = new (ELeave) CHXAvInfoListPopup();
  379.     // save cleanupstack init until LD
  380.     {
  381.         AUTO_PUSH_POP(pPopup);
  382.         pPopup->ConstructL( CHXAvCleanString(R_AVP_CLIPINF_TITLE)(), pList);
  383.     }
  385.     pPopup->ExecuteLD();
  386. }
  388. ////////////////////////////////////////
  389. //
  390. void
  391. CHXAvPlayView::DoSaveL()
  392. {
  394.     //
  395.     // perform action based on type of URL:
  396.     //
  397.     // local ram url  -> copy ram file
  398.     // local rm url   -> copy file
  399.     // network url    -> create link
  400.     //
  402.     CHXString strSource;
  404.     bool bUserCancelled = false;
  405.     bool bSavingPlaylist = false;
  407.     // save playlist or current clip that is playing?
  408.     if( m_player->IsPlaylistLoaded() &&  m_player->GetPlaylistItemCount() > 1)
  409.     {
  410.         // query user: playlist or current clip
  411.         TInt idxSel = 0;
  412.         CAknListQueryDialog* pDlg = new (ELeave) CAknListQueryDialog(&idxSel);
  414.         TInt ret = pDlg->ExecuteLD(R_AVP_SELECT_SAVE_SOURCE_DLG);
  415.         if(ret != 0)
  416.         {
  417.             //HX_ASSERT((ret == EAknSoftkeyOk) || (ret == EAknSoftkeyYes));
  418.             bool bCopyRam = (idxSel == 0);
  419.             if( bCopyRam )
  420.             {
  421.                 // save playlist (ram)
  422.                 bSavingPlaylist = true;
  423.                 strSource = m_player->GetMainURL();
  424.             }
  425.         }
  426.         else
  427.         {
  428.             bUserCancelled = true;
  429.         }
  430.     }
  432.     if(!bUserCancelled)
  433.     {
  434.    
  435.         const CHXAvVector<CHXAvMediaFolderInfoPtr>& storeInfo = m_playerUI->GetMediaStoreInfoL();
  437.         // XXXLCM automatic smart pointer not cleanup stack safe
  439.         // set an arbitrary 'current path' for the file store
  440.         CHXAvFileStorePtr spStore = new (ELeave) CHXAvFileStore();
  441.         spStore->ConstructL(storeInfo[0]->GetRoot());
  443.         CHXAvFileUIPtr spFileUi = new (ELeave) CHXAvFileUI();
  444.         spFileUi->ConstructL(m_playerUI, spStore);
  446.         if(strSource.IsEmpty())
  447.         {
  448.             // set source file to current URL
  449.             strSource = m_player->GetPlayURL(); 
  450.         }
  452.         HX_ASSERT(!strSource.IsEmpty());
  453.         CHXAvCleanString urlText(strSource);
  454.         
  455.         if( CHXAvUtil::IsLocal(urlText()))
  456.         {
  457.             //
  458.             // copy file
  459.             //
  461.             // use source filename for default name
  463.     // url may be escaped; get unescaped path-only portion 
  464.             // (e.g., realnetworksrootfoo.rm)
  465.     HBufC* pSrcPath = CHXAvUtil::AllocStdPathFromPlayerUrlL(urlText()); 
  466.     AUTO_PUSH_POP_DEL(pSrcPath);
  468.             bool bIsValidLocalPath = CHXAvFile::PathExists(*pSrcPath);
  469.             HX_ASSERT(bIsValidLocalPath); // menu item should be hidden to prevent this
  470.             if( bIsValidLocalPath )
  471.             {
  472.                 if( bSavingPlaylist )
  473.                 {
  474.             spFileUi->DoSavePlaylistL(*pSrcPath, KNullDesC);
  475.                 }
  476.                 else
  477.                 {
  478.                 
  479.                     spFileUi->DoSaveClipL(*pSrcPath, KNullDesC);
  480.                 }
  481.             }
  482.         }
  483.         else
  484.         {
  485.             //
  486.             // create link
  487.             //
  489.             // set default link name to clip display title
  490.             HBufC* pTitleText = CHXAvMisc::AllocTitleL(m_player);
  491.             if(pTitleText)
  492.             {
  493.                 AUTO_PUSH_POP_DEL(pTitleText);
  494.                 spFileUi->DoCreateLinkL(strSource, *pTitleText);
  495.             }
  496.             else
  497.             {
  498.                 spFileUi->DoCreateLinkL(strSource, KNullDesC);
  499.             }
  500.     
  501.         }
  502.     }
  504. }
  507. ////////////////////////////////////////////////         
  508. // we want to delay a bit (i.e., after the last seek key press)
  509. // before telling  the player to end seeking (and resume play at
  510. // new point);
  511. //
  512. // this allows for a user entering a series of quick key presses and
  513. // avoids excessive start and end seek commands
  514. //
  515. void CHXAvPlayView::SetEndSeekCallback(bool bEnable)
  516. {
  517.     if(bEnable && m_player->IsSeeking())
  518.     {
  519.         const TUint32 k_msEndSeekDelay = 400;
  520. m_cbEndSeek.Set(k_msEndSeekDelay);
  521.     }
  522.     else
  523.     {
  524. m_cbEndSeek.Stop();
  525.     }
  526. }
  527. ////////////////////////////////////////////////         
  528. // see SetEndSeekCallback()
  529. void CHXAvPlayView::OnEndSeekCallback()
  530. {
  531.     // only call end seek if we are still in seek mode; it is possible that 
  532.     // state changed (e.g., stop requested) since we set the end seek callback
  533.     if( m_player->IsSeeking() )
  534.     {
  535.         m_player->EndSeek();
  536.     }
  537. }
  539. /*
  540.  * EnterSeekMode
  541.  * -------------
  542.  * Start and end seek.
  543.  *
  544.  */
  545. void 
  546. CHXAvPlayView::EnterSeekMode(bool bEnter)
  547. {
  548.     if (bEnter)
  549.     {
  550.         m_msSeekStep = 0; 
  552.         SetEndSeekCallback(false);
  553.         // player may be seeking in case where end seek callback was pending
  554.         if (!m_player->IsSeeking() && m_player->CanSeek())
  555.         {
  556.     // on-demand clip is seek-able
  557.     m_player->StartSeek();
  558.         }
  559.     }
  560.     else
  561.     {
  562.         // don't do seek right away (see SetEndSeekCalback)
  563.         SetEndSeekCallback(true);
  564.     }
  565.     
  566. }
  568. /*
  569.  * GetNextSeekStep
  570.  * ---------------
  571.  * Seek in larger steps as a seek key is held down, up to an absolute max step.
  572.  *
  573.  */
  574. UINT32   
  575. CHXAvPlayView::GetNextSeekStep(UINT32 msSeekStep)
  576. {
  577.     const UINT32 ONE_SECOND_MS      = 1000;
  578.     const UINT32 BIG_SEEK_DIV_MS    = 20;  // 5 % per step
  580.     if (m_player != NULL)
  581.     {
  583. UINT32 duration = m_player->GetClipDuration();
  584. UINT32 msMaxStep = duration / BIG_SEEK_DIV_MS;
  586. if( msSeekStep != 0 )
  587. {
  588.     // double current step
  589.     msSeekStep *= 2;
  590. }
  591. else
  592. {
  593.     // init first step
  594.     msSeekStep = ONE_SECOND_MS;
  595. }
  597. // confine value to our limits
  598. msSeekStep = max(ONE_SECOND_MS, min(msSeekStep, msMaxStep));
  599.     }
  601.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::GetNextSeekStep(): next step = %lu ms", msSeekStep));
  602.     return msSeekStep;
  603. }
  605. // helper
  606. void CHXAvPlayView::HandleShowPopupL()
  607. {
  608.     // pop up left options menu
  609.     //
  610.     // showing a popup menu prevents us from getting the key up event; just in case,
  611.     // ensure we deactivate the playlist control
  612.     //
  613.     if( m_player->IsPlaying() )
  614.     {
  615.         // pause or stop
  616.         DoTogglePlayState();
  617.     }
  619.     if(m_player->IsPaused())
  620.     {
  621.         ShowPopupMenuL(R_AVP_PAUSE_MENU_BAR);
  622.     }
  623.     else if (m_player->IsStopped()) 
  624.     {
  625.         ShowPopupMenuL(R_AVP_STOPPED_MENU_BAR);
  626.     }
  627.     else if(m_player->GetClipInfo().IsLive())
  628.     {
  629.         ShowPopupMenuL(R_AVP_LIVE_PLAY_MENU_BAR);
  630.     }
  631. }
  633. /*
  634.  * HandleCommandL
  635.  * --------------
  636.  * Handle commands passed to us by our control and directly.
  637.  *
  638.  */
  639. void CHXAvPlayView::HandleCommandL(TInt command)
  640. {
  641.     bool bWasHandled = TryHandlePlaylistCommandL(command);
  643.     if( !bWasHandled )
  644.     {
  645.         switch(command)
  646.         {
  647.         case EPlayPause:  
  648.             HX_ASSERT(m_player->CanPause() || m_player->CanResume());
  649.             DoTogglePlayState();
  650.     break;
  651.         case EStop:
  652.     m_player->Stop();
  653.     break;
  654.         case EBeginSeek:
  655.             HX_ASSERT(m_player->CanSeek());
  656.     EnterSeekMode(true);
  657.     break;
  658.         case EEndSeek:
  659.     EnterSeekMode(false);
  660.     break;
  661.         case ESeekForward:
  662.     HandleSeekKeyCommand(true);
  663.     break;
  664.         case ESeekBack:
  665.     HandleSeekKeyCommand(false);
  666.     break;
  667.         case EVolUp:
  668.         case EVolDown:
  669.             HandleVolumeCommand(command);
  670.             break;
  671.         case EMute:
  672.             m_player->Mute(!m_player->IsMuted());
  673.             break;
  674.         case ESaveToFolder:
  675.             DoSaveL();
  676.             break;
  677.         case EClipInfoDialog:
  678.             DoViewClipInfoL();
  679.             break;
  680.         case EShowDefaultMenu: 
  681.             HandleShowPopupL();
  682.             break;
  683.         /*case EToggleFullScreen:
  684.             m_wpStatusPane->MakeVisible(!m_wpStatusPane->IsVisible());
  685.     break;*/
  686.         default:
  687.             CHXAvViewBase::HandleCommandL(command);
  688.     break;
  689.         }
  690.     }
  691. }
  694. /*
  695.  * UpdateViewStateL
  696.  * ----------------
  697.  * ensure that view is in sync with player state
  698.  *
  699.  */
  700. void CHXAvPlayView::UpdateViewStateL()
  701. {
  702.     UpdateSoftkeyMenuStateL();
  703.     UpdateTitleL();
  704.     UpdateContextPaneL();
  705.     UpdateNaviVolumeControlL();
  706.     UpdateNaviPlaylistControlL();
  707.     UpdateNaviDefaultControlL();
  708. }   
  711. ////////////////////////////////////////////////////////////
  712. // set file to launch on next view activation
  713. void CHXAvPlayView::SetViewActivateClipL(const TDesC& file)
  714. {
  715.     m_spViewActivateClip = file.AllocL();
  716. }
  719. /*
  720.  * CreateViewWindowForActivatingViewL
  721.  * -------------------
  722.  * Construct view window needed for active view
  723.  *
  724.  */
  725. CCoeControl* CHXAvPlayView::CreateViewWindowForActivatingViewL()
  726. {
  727.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::CreateViewWindowForActivatingViewL()n"));
  728.     if(!m_spWindow)
  729.     {
  730.         m_spWindow = new (ELeave) CHXAvPlayViewWindow();
  731.         m_spWindow->ConstructL(m_playerUI, this, ClientRect());
  732.     }
  733.     return m_spWindow.raw_ptr();
  734. }
  736. /*
  737.  * FinishViewActivateL
  738.  * -------------------
  739.  * View window is active and on top of control stack. Now
  740.  * is a good time to allocate additional resources needed
  741.  * for the active view.
  742.  *
  743.  */
  745. void CHXAvPlayView::FinishViewActivateL()
  746. {
  747.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::FinishViewActivateL()n"));
  748.     HX_ASSERT(m_spWindow);
  750.     CHXAvPresentationWindow* pRenderWin = m_spWindow->GetPresentationWindow();
  752.     // shut down player by default when view deactivates
  753.     m_bShutDownOnViewDeactivate = true;
  755.     if( m_player->IsShutDown() )
  756.     {
  757.         m_player->InitPlayerL(pRenderWin);
  758.     }
  759.     m_player->GetPlayerState().AddObserver(m_spNetConnectUi.raw_ptr());
  760.     m_player->GetPlayerState().AddObserver(this);
  762. }
  766. /*
  767.  * FinishViewDeactivateL
  768.  * ---------------------
  769.  * Destroy resources not needed when view is inactive
  770.  *
  771.  */
  772. void CHXAvPlayView::FinishViewDeactivateL()
  773. {
  774.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::FinishViewDeactivateL()n"));
  776.      // this ensures that next view gets a restored status pane
  777.     m_spNaviVolDecorator = 0;
  778.     m_spNaviDefaultDecorator = 0;
  779.     m_spNaviPlaylistDecorator = 0;
  781.     // ensure we don't get observation messages (and try to do ui stuff in response) when inactive
  782.     m_player->GetPlayerState().RemoveObserver(this);
  783.     m_player->GetPlayerState().RemoveObserver(m_spNetConnectUi.raw_ptr());
  785.     if( m_bShutDownOnViewDeactivate )
  786.     {
  787.         // shutting down player saves some resources and ensures no cpu is used for static rendering
  788.         m_player->ShutDown();
  790.         // only destroy window if player is shutdown (otherwise player site still needs presentation window)
  791.         m_spWindow = 0;
  792.     }
  794.     
  795.     m_bViewPlaylistMode = false;
  796.     m_bEnsureResumeOnExitPlaylistMode = false;
  797.    
  798.     // in case we were full screen
  799.     //   m_wpStatusPane->MakeVisible(ETrue);
  801. }
  805. /* 
  806.  * OnPlayInitiate
  807.  * --------------
  808.  * CHXAvPlayerStateObserver
  809.  *
  810.  */
  811. void 
  812. CHXAvPlayView::OnPlayInitiate(const char *url)
  813. {
  814.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPlayInitiate(): '%s'n", (const char*)url));
  816.     UpdateContextPaneL();
  817.     UpdateSoftkeyMenuStateL();
  818.     UpdateTitleL();
  819. }
  822. /*
  823.  * OnMute
  824.  * ------
  825.  * CHXAvPlayerStateObserver, mute.
  826.  *
  827.  */
  828. void 
  829. CHXAvPlayView::OnMute(bool bMute)
  830. {
  831.     if(bMute)
  832.     {
  833.         //
  834.         // mute state is indicated on the default navi control - hide temp
  835.         // navi control so user can see it (vol control does not show mute)
  836.         //
  837.         HideTempNaviControlNowL();
  838.     }
  839. }
  842. void
  843. CHXAvPlayView::OnBacklightTimer()
  844. {
  845.     User::ResetInactivityTime();
  846. }
  848. /*
  849.  * OnResume
  850.  * --------
  851.  * CHXAvPlayerStateObserver, started playing again.
  852.  *
  853.  */
  854. void 
  855. CHXAvPlayView::OnResume()
  856. {
  857.     UpdateContextPaneL();
  858.     UpdateSoftkeyMenuStateL();
  859.     InitBacklightState();
  860. }
  865. /*
  866.  * OnStop
  867.  * ------
  868.  * CHXAvPlayerStateObserver, stopped.
  869.  *
  870.  */
  871. void 
  872. CHXAvPlayView::OnStop()
  873. {
  874.     UpdateContextPaneL();
  875.     UpdateSoftkeyMenuStateL();
  876.     m_cbBacklight.Stop();
  877. }
  880. /*
  881.  * OnPause
  882.  * -------
  883.  * CHXAvPlayerStateObserver, paused.
  884.  *
  885.  */
  886. void 
  887. CHXAvPlayView::OnPause()
  888. {
  889.     UpdateContextPaneL();
  890.     UpdateSoftkeyMenuStateL();
  891.     m_cbBacklight.Stop();
  892. }
  895. void 
  896. CHXAvPlayView::OnAdvancePlaylist()
  897. {
  898.     UpdateTitleL();
  899.     UpdateSoftkeyMenuStateL();
  900. }
  903. /*
  904.  * OnBeginBuffering
  905.  * ----------------
  906.  *
  907.  */
  908. void 
  909. CHXAvPlayView::OnBeginBuffering(bool /*bIsBegin*/)
  910. {
  911.     // update everything when entering/exiting buffering state
  912.     UpdateContextPaneL();
  913.     UpdateSoftkeyMenuStateL();  
  914. }
  919. /*
  920.  * OnBeginSeek
  921.  * -----------
  922.  * CHXAvPlayerStateObserver
  923.  *
  924.  */
  925. void 
  926. CHXAvPlayView::OnBeginSeek()
  927. {
  928.     UpdateSoftkeyMenuStateL();
  930.     // this event only happens from user interaction; override volume control
  931.     HideTempNaviControlNowL();
  932. }
  936. /*
  937.  * OnLoadSession
  938.  * -------------
  939.  * Change the softkeys to show a stop button now that we are actually playing back.
  940.  *
  941.  */
  942. void 
  943. CHXAvPlayView::OnLoadSession(IHXRequest *request)
  944. {
  945.     CHXAvURLListPtr spRecentClips = m_playerUI->GetRecentClipsList();
  947.     // Add this url to the recent clip list...
  948.     HX_ASSERT(spRecentClips);
  949.     if (spRecentClips)
  950.     {
  951.         HBufC* pTitleText = CHXAvMisc::AllocTitleL(m_player);
  952.         if( pTitleText )
  953.         {
  954.             AUTO_PUSH_POP_DEL(pTitleText);
  955.             CHXString strUrl = m_player->GetPlayURL();
  956.             CHXString strTitle = CHXAvStringUtils::DescToString(*pTitleText);
  957.     CHXAvURLInfo* pInfo = new (ELeave) CHXAvURLInfo(strUrl, strTitle); //XXXLCM leave
  958.     spRecentClips->AddHead(pInfo);
  959.         }
  960.     }
  962.     UpdateContextPaneL();
  963.     UpdateSoftkeyMenuStateL();
  964.     UpdateTitleL();
  966.     // this is the first time we can know this is a video presentation
  967.     InitBacklightState();
  968.     
  969. }
  971. void CHXAvPlayView::InitBacklightState()
  972. {
  973.     if(m_player->GetClipInfo().IsVideoPresentation())
  974.     {
  975.         // set repeating callback for keeping backlight on
  976.         m_cbBacklight.Set(k_msBacklightInterval, CHXAvCallback::REPEAT); 
  977.     }
  978. }
  981. /*
  982.  * OnVolume
  983.  * --------
  984.  * CHXAvPlayerStateObserver, volume changing.
  985.  *
  986.  */
  987. void 
  988. CHXAvPlayView::OnVolume(unsigned int /*percentVol*/)
  989. {
  990.     //if( bIsUserCommand )
  991.     //{
  992.     if(!m_bViewPlaylistMode )
  993.     {
  994.         ActivateNaviVolumeControlL(k_msShowTempNavi);
  995.         UpdateNaviVolumeControlL();
  996.         m_naviPane->PushL(*m_spNaviVolDecorator);
  997.     }
  998. }
  1000. void
  1001. CHXAvPlayView::OnNetConnect()
  1002. {
  1003.     UpdateSoftkeyMenuStateL();
  1004. }
  1006. /*
  1007.  * UpdateSoftkeyMenuStateL
  1008.  * ----------------------
  1009.  * Update the softeky and menu bar based on the player state.
  1010.  *
  1011.  */
  1012. void 
  1013. CHXAvPlayView::UpdateSoftkeyMenuStateL()
  1014. {
  1015.     CEikMenuBar* pMenuBar = MenuBar();
  1016.     HX_ASSERT(pMenuBar);
  1017.     if(!pMenuBar)
  1018.     {
  1019. return;
  1020.     }
  1022.     const CHXAvPlayerState& state = m_player->GetPlayerState();
  1024.     CHXAvPlayerState::State playState = state.GetState();
  1025.     
  1026.     TInt idMenuBar = -1;
  1027.     TInt idCba = -1;
  1029.     if( m_bViewPlaylistMode )
  1030.     {
  1031.         idCba = R_AVP_PLAYER_VIEW_PLAYLIST_MODE_CBA;
  1032.         idMenuBar = R_AVP_EMPTY_MENU_BAR;
  1033.     }
  1034.     else
  1035.     {
  1036.         switch (playState)
  1037.         {
  1038.         case CHXAvPlayerState::Stopped:
  1039.          idCba = R_AVP_PLAYER_VIEW_IDLE_CBA;
  1040.     idMenuBar = R_AVP_STOPPED_MENU_BAR;
  1041.     break;
  1042.         case CHXAvPlayerState::Paused:
  1043.     idCba = R_AVP_PLAYER_VIEW_PAUSE_CBA;
  1044.     idMenuBar = R_AVP_PAUSE_MENU_BAR;
  1045.     break;
  1046.         case CHXAvPlayerState::Initiating:
  1047.             idCba = R_AVP_PLAYER_VIEW_CONNECTING_CBA;
  1048.             idMenuBar = R_AVP_EMPTY_MENU_BAR;
  1049.             break;
  1050.         case CHXAvPlayerState::Seeking:
  1051.             idCba = R_AVKON_SOFTKEYS_EMPTY;
  1052.             idMenuBar = R_AVP_EMPTY_MENU_BAR;
  1053.             break;
  1054.         case CHXAvPlayerState::Connecting:
  1055.             idCba = R_AVP_PLAYER_VIEW_CONNECTING_CBA;
  1056.             idMenuBar = R_AVP_EMPTY_MENU_BAR;
  1057.             break;
  1058.         case CHXAvPlayerState::Playing:
  1059.     if (m_player->GetClipInfo().IsLive())
  1060.     {
  1061. idCba = R_AVP_PLAYER_VIEW_LIVE_PLAY_CBA;
  1062. idMenuBar = R_AVP_LIVE_PLAY_MENU_BAR;
  1063.     }
  1064.     else
  1065.     {
  1066. idCba = R_AVP_PLAYER_VIEW_PLAY_CBA;
  1067. idMenuBar = R_AVP_EMPTY_MENU_BAR;
  1068.     }
  1069.     break;
  1070.         default:
  1071.     break;
  1072.         }
  1073.     }
  1075.     if (idMenuBar != -1 && idCba != -1)
  1076.     {
  1077. Cba()->SetCommandSetL(idCba);
  1078. pMenuBar->SetMenuTitleResourceId(idMenuBar);
  1079. if (!m_playerUI->IsDisplayingMenuOrDialog())
  1080. {
  1081.     Cba()->DrawNow();
  1082. }
  1083.     }
  1084. }
  1088. //////////////////////////////
  1089. // update volume control (if active) to match current player volume state
  1090. // 
  1091. void CHXAvPlayView::UpdateNaviVolumeControlL()
  1092. {
  1093.     if( m_spNaviVolDecorator)
  1094.     {
  1095. CAknVolumeControl* volControl = static_cast<CAknVolumeControl*>(
  1096.     m_spNaviVolDecorator->DecoratedControl());
  1098.         TUint vol = m_player->GetVolume();
  1099.         HX_ASSERT( vol >= 0 && vol <= 100);
  1101.         // scale volume to vol (0 - 100) to control setting scale (1 - 10)
  1102.         TUint scaleVol = ( 10 * (vol + 9) ) / 100;
  1103.         if( scaleVol == 0 )
  1104.         {
  1105.             scaleVol = 1;
  1106.         }
  1107.         HX_ASSERT(scaleVol >=1 && scaleVol <= 10);
  1108. volControl->SetValue(scaleVol);
  1109.     }
  1111. }
  1113. ////////////////////////////////////
  1114. //
  1115. void CHXAvPlayView::UpdateNaviPlaylistControlL()
  1116. {
  1117.     // nothing
  1118. }
  1120. ////////////////////////////////////
  1121. //
  1122. void CHXAvPlayView::DeactivateNaviVolumeControl()
  1123. {
  1124.     if(m_spNaviVolDecorator)
  1125.     {
  1126.         if( m_cbTempNaviDisplay.IsPending() )
  1127.         {
  1128.             m_cbTempNaviDisplay.Stop();
  1129.         }
  1130. m_naviPane->Pop(m_spNaviVolDecorator.Ptr());
  1131. m_spNaviVolDecorator = 0;
  1132.     }
  1133. }
  1136. ////////////////////////////////////
  1137. //
  1138. void CHXAvPlayView::DeactivateNaviPlaylistControl()
  1139. {
  1140.     m_bViewPlaylistMode = false;
  1141.     if(m_spNaviPlaylistDecorator)
  1142.     {
  1143.         if( m_cbTempNaviDisplay.IsPending() )
  1144.         {
  1145.             m_cbTempNaviDisplay.Stop();
  1146.         }
  1147. m_naviPane->Pop(m_spNaviPlaylistDecorator.Ptr());
  1148. m_spNaviPlaylistDecorator = 0;
  1149.     }
  1150. }
  1152. ////////////////////////////////////
  1153. //
  1154. void CHXAvPlayView::HideTempNaviControlNowL()
  1155. {
  1156.     // one of these is showing; hide
  1157.     DeactivateNaviVolumeControl();
  1158.     DeactivateNaviPlaylistControl();
  1160.     // now re-display custom control
  1161.     DrawNaviDefaultControlNowL();
  1162.    
  1163. }
  1165. ///////////////////////////////////
  1166. // activate volume display callback and show the control
  1167. //
  1168. void CHXAvPlayView::ActivateNaviVolumeControlL(TUint msHide)
  1169. {
  1170.     // ensure playlist control is hidden
  1171.     DeactivateNaviPlaylistControl();
  1173.     if( msHide )
  1174.     {
  1175.         // set timer for hiding volume control after a delay
  1176.         m_cbTempNaviDisplay.Set(msHide);
  1177.     }
  1179.     if( !m_spNaviVolDecorator )
  1180.     {
  1181. // R_AVKON_NAVI_PANE_RECORDER_VOLUME_INDICATOR
  1182. m_spNaviVolDecorator = m_naviPane->CreateVolumeIndicatorL(R_AVKON_NAVI_PANE_VOLUME_INDICATOR);
  1183.     }
  1184. }
  1186. ///////////////////////////////////
  1187. // activate playlist callback and show the control
  1188. //
  1189. void CHXAvPlayView::ActivateNaviPlaylistControlL(TUint msHide)
  1190. {
  1191.     // ensure volume control is hidden
  1192.     DeactivateNaviVolumeControl();
  1194.     if( msHide != 0 )
  1195.     {
  1196.         // set timer for hiding playlist control after a delay
  1197.         m_cbTempNaviDisplay.Set(msHide);
  1198.     }
  1199.     else if(m_cbTempNaviDisplay.IsPending())
  1200.     {
  1201.         m_cbTempNaviDisplay.Stop();
  1202.     }
  1203.     
  1204.     if( !m_spNaviPlaylistDecorator )
  1205.     {
  1206.         // create custom navi control (status and timer, etc)
  1207.         CHXAvPlaylistNaviControl* pControl = CHXAvPlaylistNaviControl::NewL(m_player, *m_naviPane);
  1208.         AUTO_PUSH_POP(pControl);
  1210.         // draw only works well if done via the navi pane push (from the decorator)
  1211.         const CHXAvCommand& cmdRefresh =
  1212.         MakeCommand(this, &CHXAvPlayView::DrawNaviPlaylistControlNowL);
  1213.         // navi pane control must draw itself via the navi pane
  1214.         pControl->SetRefreshCommandL(cmdRefresh);
  1216.         // decorator assumes ownership of our custom control
  1217.         m_spNaviPlaylistDecorator = CAknNavigationDecorator::NewL(m_naviPane, pControl);
  1218.     }
  1219. }
  1221. ////////////////////////////////////////
  1222. // update navi control so it is showing if necessary
  1223. // and redrawn; volume control takes precedence (unless
  1224. // user action causes navi control state change)
  1225. //
  1226. void CHXAvPlayView::UpdateNaviDefaultControlL()
  1227. {
  1228.     CHXAvNaviPaneControl* pControl = 0;
  1229.     if( m_spNaviDefaultDecorator )
  1230.     {
  1231.         pControl = static_cast<CHXAvNaviPaneControl*>(m_spNaviDefaultDecorator->DecoratedControl());
  1232.     }
  1233.     else
  1234.     {
  1235.         // create custom navi control (status and timer, etc)
  1236.         pControl = CHXAvNaviPaneControl::NewL(m_player, *m_naviPane);
  1237.         AUTO_PUSH_POP(pControl);
  1238.         // draw only works well if done via the navi pane push (from the decorator)
  1239.         const CHXAvCommand& cmdRefresh =
  1240.         MakeCommand(this, &CHXAvPlayView::DrawNaviDefaultControlNowL);
  1241.         // navi pane control must draw itself via the navi pane
  1242.         pControl->SetRefreshCommandL(cmdRefresh);
  1244.         // decorator assumes ownership of our custom control
  1245.         m_spNaviDefaultDecorator = CAknNavigationDecorator::NewL(m_naviPane, pControl);
  1246.     }
  1248.     pControl->UpdateEverythingL();
  1249.     DrawNaviDefaultControlNowL();
  1250. }
  1252. ///////////////////////////////////
  1253. //
  1254. void CHXAvPlayView::OnPhoneEvent()
  1255. {
  1256.     // phone call state changed to one of following (enums in order):
  1257.     //
  1258.     // ESACallNone,
  1259.     // ESACallVoice,
  1260.     // ESACallFax,
  1261.     // ESACallData,
  1262.     // ESACallAlerting,
  1263.     // ESACallRinging,
  1264.     // ESACallAlternating
  1265.     //
  1266.     TSysAgentEvent event = m_saWatcher.GetSaEvent();
  1267.     TInt state = event.State();
  1268.     HX_ASSERT(event.Uid() == KUidCurrentCall);
  1270.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPhoneEvent(): phone state now = %ldn", state));
  1271.     
  1272.     switch(state)
  1273.     {
  1274.         case ESACallNone:
  1275.         {
  1276.             // END call
  1277.             DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPhoneEvent(): call (type = %ld) endedn", m_lastPhoneState));
  1278.             if(ESACallData == m_lastPhoneState)
  1279.             {
  1280.                 //
  1281.                 // data call has ended; user will be prompted by system to re-connect modem;
  1282.                 // if user opts not to reconnect, backend socket user does not get notification
  1283.                 // and ends up in weird state
  1284.                 //
  1285.                 HaltPlayer();
  1286.             }
  1287.         
  1288.         }
  1289.         break;
  1290.         case ESACallVoice:
  1291.         case ESACallFax:
  1292.         case ESACallAlerting:
  1293.         case ESACallRinging:
  1294.         case ESACallAlternating:
  1295.             // BEGIN call
  1296.             DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPhoneEvent(): call starting or startedn"));
  1297.             HaltPlayer(); // just in case; we expect deactivate/loose focus event as well
  1298.             break;
  1299.         default:
  1300.             // ignore....
  1301.             break;
  1302.     }
  1304.     m_lastPhoneState = state;
  1306. }
  1308. void CHXAvPlayView::HandleForegroundEventL(TBool bEnterForeground)
  1309. {
  1310.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::HandleForegroundEventL(): enter = '%s'n", dbg::Bool(bEnterForeground)));
  1312.     CHXAvViewBase::HandleForegroundEventL(bEnterForeground);
  1314.     if( bEnterForeground)
  1315.     {
  1316.         // in case this is first foreground event after activation
  1317.         if(m_spViewActivateClip)
  1318.         {
  1319.             m_player->Play(*m_spViewActivateClip);
  1320.             m_spViewActivateClip = 0;
  1321.         }
  1322.     }
  1323.     else
  1324.     {
  1325.         if(m_bViewPlaylistMode)
  1326.         {
  1327.             // we may miss shift up key event if it occurs while we are not in foreground
  1328.             DoExitPlaylistModeL(false);
  1329.         }
  1330.     }
  1331.     
  1332. }
  1334. ////////////////////////////////////////////////
  1335. // app is loosing focus and we are active view
  1336. void CHXAvPlayView::HandleLosePlayFocus()
  1337. {
  1338.     HaltPlayer();
  1339. }
  1341. void CHXAvPlayView::HaltPlayer()
  1342. {
  1343.     if( m_player )
  1344.     {
  1345.         bool bIsHalted = m_player->IsStopped() || m_player->IsPaused();
  1346.         if(!bIsHalted)
  1347.         {
  1348.             if(m_player->CanPause())
  1349.             {
  1350.                 m_player->Pause();
  1351.             }
  1352.             else
  1353.             {
  1354.                 m_player->Stop();
  1355.             }
  1356.         }
  1357.     }
  1358. }
  1359. ////////////////////////////////////////
  1360. //
  1361. void CHXAvPlayView::DrawNaviPlaylistControlNowL()
  1362. {
  1363.     HX_ASSERT(!m_spNaviVolDecorator);
  1364.     if( m_spNaviPlaylistDecorator) 
  1365.     {
  1366.         m_naviPane->PushL(*m_spNaviPlaylistDecorator);
  1367.     }
  1368. }
  1370. ////////////////////////////////////////
  1371. //
  1372. void CHXAvPlayView::DrawNaviDefaultControlNowL()
  1373. {
  1374.     // don't draw custom if temp control is up
  1375.     if( m_spNaviDefaultDecorator  && !m_spNaviVolDecorator && !m_spNaviPlaylistDecorator) 
  1376.     {
  1377.         m_naviPane->PushL(*m_spNaviDefaultDecorator);
  1378.     }
  1379.     
  1380. }
  1382. ////////////////////////////////////////////////
  1383. // ensure that title reflects state of the
  1384. // player
  1385. //
  1386. void CHXAvPlayView::UpdateTitleL()
  1387. {
  1388.     DPRINTF(SYMP_INFO, ("CHXAvPlayView::UpdateTitleL()n")); 
  1390.     HBufC* pTitleText = CHXAvMisc::AllocTitleL(m_player);
  1391.     if( pTitleText )
  1392.     {
  1393.         AUTO_PUSH_POP_DEL(pTitleText);
  1394.         m_titlePane->SetTextL(*pTitleText);
  1395.     }
  1396.     else
  1397.     {
  1398.         // probably means no current url, let alone a file header
  1399.         SetDefaultAppTitleL();
  1400.     }
  1401. }
  1404. //////////////////////////////////////////////
  1405. // hide or show clip info based on availability 
  1406. // of clip info
  1407. void CHXAvPlayView::InitClipInfoMenuItem(CEikMenuPane* pMenuPane)
  1408. {
  1409.     bool bShow = (m_player->GetClipInfo().GetFileHeader(0) != 0);
  1410.     pMenuPane->SetItemDimmed(EClipInfoDialog, !bShow);
  1411. }
  1413. //////////////////////////////////////////////
  1414. // hide or show playlist menu items depending
  1415. // on whether or not a playlist is loaded
  1416. void CHXAvPlayView::InitPlaylistMenuItems(CEikMenuPane* pMenuPane)
  1417. {
  1418.     bool bEnable = m_player->IsPlaylistLoaded() && m_player->GetPlaylistItemCount() > 1;
  1419.     pMenuPane->SetItemDimmed(EPrevClip, !bEnable);
  1420.     pMenuPane->SetItemDimmed(ENextClip, !bEnable);
  1422. }
  1425. //////////////////////////////////////////////
  1426. // hide or show save based on the currently
  1427. // loaded url
  1428. void CHXAvPlayView::InitSaveMenuItem(CEikMenuPane* pMenuPane)
  1429. {
  1430.     bool bHideIt = true;
  1432.     CHXAvCleanString txtSaveUrl(m_player->GetMainURL());
  1435.     //
  1436.     // hide 'save' menu item only for local clips that:
  1437.     //
  1438.     //  1) are already under one of our media folders and not in a hidden folder
  1439.     //  2) that reference an invalid path
  1440.     //  
  1441.     // note: playlists (ram's) are always local 
  1442.     //
  1443.     
  1444.     if( CHXAvUtil::IsLocal(txtSaveUrl()) )
  1445.     {
  1446. // convert file url to full local path format
  1447. HBufC* pPath = CHXAvUtil::AllocStdPathFromPlayerUrlL(txtSaveUrl()); 
  1448. AUTO_PUSH_POP_DEL(pPath);
  1450.         if( !CHXAvFile::PathExists(*pPath) )
  1451.         {
  1452.             // can't save invalid path!
  1453.             bHideIt = true;
  1454.         }
  1455.         else
  1456.         {
  1457.             //
  1458.             // XXXLCM it arguably would be a nice idea to enable save all the time (as long as path is valid);
  1459.             //        this would allow one way to copy from phone to mmc (or just ability to make new copy for
  1460.             //        whatever reason)
  1461.             //
  1462.             // check if path exists under a media store root; if it does, hide it (already saved)
  1463.             // 
  1464.             // exception: if under the system folder (which is hidden), enable it
  1465.             //
  1466.             const CHXAvVector<CHXAvMediaFolderInfoPtr>& info = m_playerUI->GetMediaStoreInfoL();
  1467.             for(TInt idx = 0; idx < info.Nelements(); ++idx)
  1468.             {
  1469.                 TPtrC folder = info[idx]->GetRoot();
  1471.                 // get relative path (without drive letter)
  1472.                 TInt idxStart = 0;
  1473.                 if(CHXAvFile::GetDriveIndex(*pPath) >= 0)
  1474.                 {
  1475.                     idxStart = 2;
  1476.                 }
  1477.                 TPtrC relPath(pPath->Mid(idxStart));
  1478.                 bool bIsUnderSystemFolder = CHXAvFile::IsSubPath(CHXAvUtil::KEPSystemFolderName, relPath);
  1479.           
  1480.                 bHideIt =  CHXAvFile::IsSubPath(folder, *pPath) && !bIsUnderSystemFolder;
  1481.                 if( bHideIt )
  1482.                 {
  1483.                     // no need to keep looking...
  1484.                     break;
  1485.                 }
  1486.             }
  1487.         }
  1488.     }
  1490.     pMenuPane->SetItemDimmed(ESaveToFolder, bHideIt);
  1492.     /*// if it is already saved, we can add it to the pinboard
  1493.     if (bHideIt)
  1494.     {
  1495. // add to pinboard
  1496. m_wpContext->PinbModel().AddLinkMenuItemL(*pMenuPane, EClipInfoDialog);
  1497.     }*/
  1498.     
  1499. }
  1501. ////////////////////////////////////////////////
  1502. // idle (stopped) state
  1503. void CHXAvPlayView::InitIdleOptionsMenu(CEikMenuPane* pMenuPane)
  1504. {
  1505.     // enable play if player can be resumed (has a(n) URL) 
  1506.     TBool bEnablePlay = m_player->CanResume();
  1507.     pMenuPane->SetItemDimmed(EPlayPause, !bEnablePlay);
  1509.     // save
  1510.     InitSaveMenuItem(pMenuPane);
  1512.     // clip info
  1513.     InitClipInfoMenuItem(pMenuPane);
  1515.     // playlist items
  1516.     InitPlaylistMenuItems(pMenuPane);
  1517.     
  1518.     // mute
  1519.     TInt textResID = m_player->IsMuted() ? R_MENU_UNMUTE : R_MENU_MUTE;
  1520.     pMenuPane->SetItemTextL(EMute, textResID);
  1521. #if(0)
  1522.     // full screen
  1523.     const bool bEnableFullScreen = false;
  1524.     if( m_player->IsStopped() && bEnableFullScreen )
  1525.     {
  1526. // only if player stopped (until backend supports dynamic resize)
  1527. pMenuPane->SetItemDimmed(EToggleFullScreen, EFalse);
  1528. TInt textResID = StatusPane()->IsVisible() ? R_MENU_ENTER_FULL_SCREEN : R_MENU_EXIT_FULL_SCREEN;
  1529. pMenuPane->SetItemTextL(EToggleFullScreen, textResID);
  1530.     }
  1531.     else
  1532.     {
  1533. pMenuPane->SetItemDimmed(EToggleFullScreen, ETrue);
  1534.     }
  1535. #endif
  1537.     CHXAvMisc::InitHelpMenuItem(pMenuPane);
  1538.     
  1539. }
  1541. ////////////////////////////////////////////////
  1542. // items common to pause and live
  1543. void CHXAvPlayView::InitNonIdleMenuOptions(CEikMenuPane* pMenuPane)
  1544. {
  1545.     // mute
  1546.     TInt textResID = m_player->IsMuted() ? R_MENU_UNMUTE : R_MENU_MUTE;
  1547.     pMenuPane->SetItemTextL(EMute, textResID);
  1549.     // save
  1550.     InitSaveMenuItem(pMenuPane);
  1552.     // clip info
  1553.     InitClipInfoMenuItem(pMenuPane);
  1555.     // prev next
  1556.     InitPlaylistMenuItems(pMenuPane);
  1557. }
  1559. ////////////////////////////////////////////////
  1560. //
  1561. void CHXAvPlayView::InitLivePlayOptionsMenu(CEikMenuPane* pMenuPane)
  1562. {
  1563.     InitNonIdleMenuOptions(pMenuPane);
  1564. }
  1566. ////////////////////////////////////////////////
  1567. //
  1568. void CHXAvPlayView::InitPausedOptionsMenu(CEikMenuPane* pMenuPane)
  1569. {
  1570.     InitNonIdleMenuOptions(pMenuPane);
  1571.     CHXAvMisc::InitHelpMenuItem(pMenuPane);
  1572. }
  1574. ////////////////////////////////////////////////
  1575. // Called when a menu pane is about to be displayed
  1576. // 
  1577. void
  1578. CHXAvPlayView::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* pMenuPane)
  1579. {
  1580.     bool bInitCommonItems = true;
  1582.     //
  1583.     // note: there is no menu in play state (just cba)
  1584.     //
  1585.     DPRINTF(SYMP_WSEVENTS, ("CHXAvPlayView::DynInitMenuPaneL(id=%d)n", aResourceId));
  1586.     switch(aResourceId)
  1587.     {
  1588.     case R_AVP_PLAYER_VIEW_IDLE_MENU_PANE:
  1589. InitIdleOptionsMenu(pMenuPane);
  1590.         break;
  1591.     case R_AVP_PLAYER_VIEW_PAUSED_MENU_PANE:
  1592. InitPausedOptionsMenu(pMenuPane);
  1593.         break;
  1594.     case R_AVP_PLAYER_VIEW_LIVE_PLAY_MENU_PANE:
  1595.         InitLivePlayOptionsMenu(pMenuPane);
  1596.         break;
  1597.     default:
  1598.         bInitCommonItems = false;
  1599.         break;
  1600.     }
  1602.     if(bInitCommonItems)
  1603.     {
  1604.         CHXAvMisc::InitDebugMenuItemsL(pMenuPane);
  1605.     }
  1606.     
  1607. }
  1609. ////////////////////////////////////////////////////
  1610. // update context pane (i.e., app icon area) to reflect player state
  1611. //
  1612. void CHXAvPlayView::UpdateContextPaneL()
  1613. {
  1614. #if(0)
  1615.     bool bShowResumePendingIcon = false;
  1617.     //
  1618.     // dim icon while playback pending unless we are running
  1619.     // embedded (in that case we don't want to overwrite the
  1620.     // container app icon)
  1621.     // 
  1622.     if( !m_playerUI->IsRunningEmbedded() )
  1623.     {
  1624.         CHXAvPlayerState::State state = m_player->GetPlayerState(),GetState();
  1625.         bShowResumePendingIcon = (state == CHXAvPlayerState::Connecting);
  1626.         bShowResumePendingIcon |= (CHXAvPlayerState::NotBuffering != m_player->GetPlayerState().GetBufferState());
  1628.     }
  1630.     if(bShowResumePendingIcon)
  1631.     {
  1632.         // grey out the app icon
  1633. m_contextPane->SetPictureFromFileL(m_playerUI->GetAppImageFilePath(), 
  1634.     EMbmRealplayerQgn_menu_rp_grey_cxt, EMbmRealplayerQgn_menu_rp_grey_cxt_mask);
  1635.     }
  1636.     else
  1637.     {
  1638. // set default icon from AIF
  1639. m_contextPane->SetPictureToDefaultL();
  1640.     }
  1641. #endif
  1642. }
  1644. ////////////////////////////////////////
  1645. // connect note callback
  1646. void CHXAvPlayView::OnUserCancelConnect()
  1647. {
  1648.     m_player->Stop();
  1649. }
  1651. // we must be last in observer chain
  1652. void
  1653. CHXAvPlayView::OnError(HX_RESULT code)
  1654. {   
  1655.     //
  1656.     // lookup user error message
  1657.     //
  1658.     UINT32 ulErrorStringID = ErrorStringTable[0].m_ulErrorStringID;
  1659.     for (int i = 0;
  1660.         i < sizeof(ErrorStringTable) / sizeof(ErrorStringTable[0]); ++i)
  1661.     {
  1662.         if(ErrorStringTable[i].m_ulErrorTag == code)
  1663.         {
  1664.             ulErrorStringID = ErrorStringTable[i].m_ulErrorStringID;
  1665.             break;
  1666.         }
  1667.     }
  1668.     CHXAvCleanString errText(ulErrorStringID);
  1670.     comptr<CHXLitePrefs> prefs = m_playerUI->GetClientEngineManager()->GetPrefs();
  1672.     const bool bAppendHexCode = prefs::GetBool(prefs, CHXAV_ErrMsgIncludeCode, true);
  1673.     // Let's not do any more memory allocations than we have to if we are 
  1674.     // here precisely because we are out of memory.
  1675.     if(bAppendHexCode && code != HXR_OUTOFMEMORY)
  1676.     {
  1677.         //
  1678.         // create stringified error code to append to error message text
  1679.         //
  1680.         HBufC* pCodeText = 0;
  1681. #if defined(HELIX_FEATURE_DPRINTF)
  1682.         // get nice (translated) version of result code 
  1683.         CHXString str("n");
  1684.         str += dbg::ErrorCode(code);
  1685.         pCodeText = CHXAvStringUtils::AllocTextL(str);
  1686. #else
  1687.         // in this case, just format number
  1688.         _LIT(KErrCodeFormat, "n0x%08x");
  1689.         pCodeText = CHXAvStringUtils::AllocFormatTextHexArgL(KErrCodeFormat, code);
  1690. #endif
  1691.         AUTO_PUSH_POP_DEL(pCodeText);
  1694.         //
  1695.         // form message: user text + appended error code
  1696.         //
  1697.         HBufC* pFullText = CHXAvStringUtils::AllocTextL(errText(), *pCodeText);
  1698.         AUTO_PUSH_POP_DEL(pFullText);
  1700.         CHXAvMessageDialog::DoAlertErrorL(*pFullText);
  1701.     }
  1702.     else
  1703.     {
  1704.         CHXAvMessageDialog::DoAlertErrorL(errText());
  1705.     }
  1707. }