chxavplayview.cpp

来自「symbian 下的helix player源代码」· C++ 代码 · 共 1,708 行 · 第 1/3 页

    if(m_spNaviPlaylistDecorator)
    {
        if( m_cbTempNaviDisplay.IsPending() )
        {
            m_cbTempNaviDisplay.Stop();
        }
	m_naviPane->Pop(m_spNaviPlaylistDecorator.Ptr());
	m_spNaviPlaylistDecorator = 0;
    }
}

////////////////////////////////////
//
void CHXAvPlayView::HideTempNaviControlNowL()
{
    // one of these is showing; hide
    DeactivateNaviVolumeControl();
    DeactivateNaviPlaylistControl();

    // now re-display custom control
    DrawNaviDefaultControlNowL();
   
}

///////////////////////////////////
// activate volume display callback and show the control
//
void CHXAvPlayView::ActivateNaviVolumeControlL(TUint msHide)
{
    // ensure playlist control is hidden
    DeactivateNaviPlaylistControl();

    if( msHide )
    {
        // set timer for hiding volume control after a delay
        m_cbTempNaviDisplay.Set(msHide);
    }

    if( !m_spNaviVolDecorator )
    {
	// R_AVKON_NAVI_PANE_RECORDER_VOLUME_INDICATOR
	m_spNaviVolDecorator = m_naviPane->CreateVolumeIndicatorL(R_AVKON_NAVI_PANE_VOLUME_INDICATOR);
    }
}

///////////////////////////////////
// activate playlist callback and show the control
//
void CHXAvPlayView::ActivateNaviPlaylistControlL(TUint msHide)
{
    // ensure volume control is hidden
    DeactivateNaviVolumeControl();

    if( msHide != 0 )
    {
        // set timer for hiding playlist control after a delay
        m_cbTempNaviDisplay.Set(msHide);
    }
    else if(m_cbTempNaviDisplay.IsPending())
    {
        m_cbTempNaviDisplay.Stop();
    }
    
    if( !m_spNaviPlaylistDecorator )
    {
        // create custom navi control (status and timer, etc)
        CHXAvPlaylistNaviControl* pControl = CHXAvPlaylistNaviControl::NewL(m_player, *m_naviPane);
        AUTO_PUSH_POP(pControl);

        // draw only works well if done via the navi pane push (from the decorator)
        const CHXAvCommand& cmdRefresh =
        MakeCommand(this, &CHXAvPlayView::DrawNaviPlaylistControlNowL);
        // navi pane control must draw itself via the navi pane
        pControl->SetRefreshCommandL(cmdRefresh);

        // decorator assumes ownership of our custom control
        m_spNaviPlaylistDecorator = CAknNavigationDecorator::NewL(m_naviPane, pControl);
    }
}

////////////////////////////////////////
// update navi control so it is showing if necessary
// and redrawn; volume control takes precedence (unless
// user action causes navi control state change)
//
void CHXAvPlayView::UpdateNaviDefaultControlL()
{
    CHXAvNaviPaneControl* pControl = 0;
    if( m_spNaviDefaultDecorator )
    {
        pControl = static_cast<CHXAvNaviPaneControl*>(m_spNaviDefaultDecorator->DecoratedControl());
    }
    else
    {
        // create custom navi control (status and timer, etc)
        pControl = CHXAvNaviPaneControl::NewL(m_player, *m_naviPane);
        AUTO_PUSH_POP(pControl);
        // draw only works well if done via the navi pane push (from the decorator)
        const CHXAvCommand& cmdRefresh =
        MakeCommand(this, &CHXAvPlayView::DrawNaviDefaultControlNowL);
        // navi pane control must draw itself via the navi pane
        pControl->SetRefreshCommandL(cmdRefresh);

        // decorator assumes ownership of our custom control
        m_spNaviDefaultDecorator = CAknNavigationDecorator::NewL(m_naviPane, pControl);
    }

    pControl->UpdateEverythingL();
    DrawNaviDefaultControlNowL();
}

///////////////////////////////////
//
void CHXAvPlayView::OnPhoneEvent()
{
    // phone call state changed to one of following (enums in order):
    //
    // ESACallNone,
    // ESACallVoice,
    // ESACallFax,
    // ESACallData,
    // ESACallAlerting,
    // ESACallRinging,
    // ESACallAlternating
    //
    TSysAgentEvent event = m_saWatcher.GetSaEvent();
    TInt state = event.State();
    HX_ASSERT(event.Uid() == KUidCurrentCall);

    DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPhoneEvent(): phone state now = %ld\n", state));
    
    switch(state)
    {
        case ESACallNone:
        {
            // END call
            DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPhoneEvent(): call (type = %ld) ended\n", m_lastPhoneState));
            if(ESACallData == m_lastPhoneState)
            {
                //
                // data call has ended; user will be prompted by system to re-connect modem;
                // if user opts not to reconnect, backend socket user does not get notification
                // and ends up in weird state
                //
                HaltPlayer();
            }
        
        }
        break;
        case ESACallVoice:
        case ESACallFax:
        case ESACallAlerting:
        case ESACallRinging:
        case ESACallAlternating:
            // BEGIN call
            DPRINTF(SYMP_INFO, ("CHXAvPlayView::OnPhoneEvent(): call starting or started\n"));
            HaltPlayer(); // just in case; we expect deactivate/loose focus event as well
            break;
        default:
            // ignore....
            break;
    }

    m_lastPhoneState = state;

}

void CHXAvPlayView::HandleForegroundEventL(TBool bEnterForeground)
{
    DPRINTF(SYMP_INFO, ("CHXAvPlayView::HandleForegroundEventL(): enter = '%s'\n", dbg::Bool(bEnterForeground)));

    CHXAvViewBase::HandleForegroundEventL(bEnterForeground);

    if( bEnterForeground)
    {
        // in case this is first foreground event after activation
        if(m_spViewActivateClip)
        {
            m_player->Play(*m_spViewActivateClip);
            m_spViewActivateClip = 0;
        }
    }
    else
    {
        if(m_bViewPlaylistMode)
        {
            // we may miss shift up key event if it occurs while we are not in foreground
            DoExitPlaylistModeL(false);
        }
    }
    
}

////////////////////////////////////////////////
// app is loosing focus and we are active view
void CHXAvPlayView::HandleLosePlayFocus()
{
    HaltPlayer();
}

void CHXAvPlayView::HaltPlayer()
{
    if( m_player )
    {
        bool bIsHalted = m_player->IsStopped() || m_player->IsPaused();
        if(!bIsHalted)
        {
            if(m_player->CanPause())
            {
                m_player->Pause();
            }
            else
            {
                m_player->Stop();
            }
        }
    }
}
////////////////////////////////////////
//
void CHXAvPlayView::DrawNaviPlaylistControlNowL()
{
    HX_ASSERT(!m_spNaviVolDecorator);
    if( m_spNaviPlaylistDecorator) 
    {
        m_naviPane->PushL(*m_spNaviPlaylistDecorator);
    }
}

////////////////////////////////////////
//
void CHXAvPlayView::DrawNaviDefaultControlNowL()
{
    // don't draw custom if temp control is up
    if( m_spNaviDefaultDecorator  && !m_spNaviVolDecorator && !m_spNaviPlaylistDecorator) 
    {
        m_naviPane->PushL(*m_spNaviDefaultDecorator);
    }
    
}

////////////////////////////////////////////////
// ensure that title reflects state of the
// player
//
void CHXAvPlayView::UpdateTitleL()
{
    DPRINTF(SYMP_INFO, ("CHXAvPlayView::UpdateTitleL()\n")); 

    HBufC* pTitleText = CHXAvMisc::AllocTitleL(m_player);
    if( pTitleText )
    {
        AUTO_PUSH_POP_DEL(pTitleText);
        m_titlePane->SetTextL(*pTitleText);
    }
    else
    {
        // probably means no current url, let alone a file header
        SetDefaultAppTitleL();
    }
}


//////////////////////////////////////////////
// hide or show clip info based on availability 
// of clip info
void CHXAvPlayView::InitClipInfoMenuItem(CEikMenuPane* pMenuPane)
{
    bool bShow = (m_player->GetClipInfo().GetFileHeader(0) != 0);
    pMenuPane->SetItemDimmed(EClipInfoDialog, !bShow);
}

//////////////////////////////////////////////
// hide or show playlist menu items depending
// on whether or not a playlist is loaded
void CHXAvPlayView::InitPlaylistMenuItems(CEikMenuPane* pMenuPane)
{
    bool bEnable = m_player->IsPlaylistLoaded() && m_player->GetPlaylistItemCount() > 1;
    pMenuPane->SetItemDimmed(EPrevClip, !bEnable);
    pMenuPane->SetItemDimmed(ENextClip, !bEnable);

}


//////////////////////////////////////////////
// hide or show save based on the currently
// loaded url
void CHXAvPlayView::InitSaveMenuItem(CEikMenuPane* pMenuPane)
{
    bool bHideIt = true;

    CHXAvCleanString txtSaveUrl(m_player->GetMainURL());


    //
    // hide 'save' menu item only for local clips that:
    //
    //  1) are already under one of our media folders and not in a hidden folder
    //  2) that reference an invalid path
    //  
    // note: playlists (ram's) are always local 
    //
    
    if( CHXAvUtil::IsLocal(txtSaveUrl()) )
    {
	// convert file url to full local path format
	HBufC* pPath = CHXAvUtil::AllocStdPathFromPlayerUrlL(txtSaveUrl()); 
	AUTO_PUSH_POP_DEL(pPath);

        if( !CHXAvFile::PathExists(*pPath) )
        {
            // can't save invalid path!
            bHideIt = true;
        }
        else
        {
            //
            // XXXLCM it arguably would be a nice idea to enable save all the time (as long as path is valid);
            //        this would allow one way to copy from phone to mmc (or just ability to make new copy for
            //        whatever reason)
            //
            // check if path exists under a media store root; if it does, hide it (already saved)
            // 
            // exception: if under the system folder (which is hidden), enable it
            //
            const CHXAvVector<CHXAvMediaFolderInfoPtr>& info = m_playerUI->GetMediaStoreInfoL();
            for(TInt idx = 0; idx < info.Nelements(); ++idx)
            {
                TPtrC folder = info[idx]->GetRoot();

                // get relative path (without drive letter)
                TInt idxStart = 0;
                if(CHXAvFile::GetDriveIndex(*pPath) >= 0)
                {
                    idxStart = 2;
                }
                TPtrC relPath(pPath->Mid(idxStart));
                bool bIsUnderSystemFolder = CHXAvFile::IsSubPath(CHXAvUtil::KEPSystemFolderName, relPath);
          
                bHideIt =  CHXAvFile::IsSubPath(folder, *pPath) && !bIsUnderSystemFolder;
                if( bHideIt )
                {
                    // no need to keep looking...
                    break;
                }
            }
        }
    }

    pMenuPane->SetItemDimmed(ESaveToFolder, bHideIt);

    /*// if it is already saved, we can add it to the pinboard
    if (bHideIt)
    {
	// add to pinboard
	m_wpContext->PinbModel().AddLinkMenuItemL(*pMenuPane, EClipInfoDialog);
    }*/
    
}

////////////////////////////////////////////////
// idle (stopped) state
void CHXAvPlayView::InitIdleOptionsMenu(CEikMenuPane* pMenuPane)
{
    // enable play if player can be resumed (has a(n) URL) 
    TBool bEnablePlay = m_player->CanResume();
    pMenuPane->SetItemDimmed(EPlayPause, !bEnablePlay);

    // save
    InitSaveMenuItem(pMenuPane);

    // clip info
    InitClipInfoMenuItem(pMenuPane);

    // playlist items
    InitPlaylistMenuItems(pMenuPane);
    
    // mute
    TInt textResID = m_player->IsMuted() ? R_MENU_UNMUTE : R_MENU_MUTE;
    pMenuPane->SetItemTextL(EMute, textResID);
#if(0)
    // full screen
    const bool bEnableFullScreen = false;
    if( m_player->IsStopped() && bEnableFullScreen )
    {
	// only if player stopped (until backend supports dynamic resize)
	pMenuPane->SetItemDimmed(EToggleFullScreen, EFalse);
	TInt textResID = StatusPane()->IsVisible() ? R_MENU_ENTER_FULL_SCREEN : R_MENU_EXIT_FULL_SCREEN;
	pMenuPane->SetItemTextL(EToggleFullScreen, textResID);
    }
    else
    {
	pMenuPane->SetItemDimmed(EToggleFullScreen, ETrue);
    }
#endif

    CHXAvMisc::InitHelpMenuItem(pMenuPane);
    
}

////////////////////////////////////////////////
// items common to pause and live
void CHXAvPlayView::InitNonIdleMenuOptions(CEikMenuPane* pMenuPane)
{
    // mute
    TInt textResID = m_player->IsMuted() ? R_MENU_UNMUTE : R_MENU_MUTE;
    pMenuPane->SetItemTextL(EMute, textResID);

    // save
    InitSaveMenuItem(pMenuPane);

    // clip info
    InitClipInfoMenuItem(pMenuPane);

    // prev next
    InitPlaylistMenuItems(pMenuPane);
}

////////////////////////////////////////////////
//
void CHXAvPlayView::InitLivePlayOptionsMenu(CEikMenuPane* pMenuPane)
{
    InitNonIdleMenuOptions(pMenuPane);
}

////////////////////////////////////////////////
//
void CHXAvPlayView::InitPausedOptionsMenu(CEikMenuPane* pMenuPane)
{
    InitNonIdleMenuOptions(pMenuPane);
    CHXAvMisc::InitHelpMenuItem(pMenuPane);
}

////////////////////////////////////////////////
// Called when a menu pane is about to be displayed
// 
void
CHXAvPlayView::DynInitMenuPaneL(TInt aResourceId, CEikMenuPane* pMenuPane)
{
    bool bInitCommonItems = true;

    //
    // note: there is no menu in play state (just cba)
    //
    DPRINTF(SYMP_WSEVENTS, ("CHXAvPlayView::DynInitMenuPaneL(id=%d)\n", aResourceId));
    switch(aResourceId)
    {
    case R_AVP_PLAYER_VIEW_IDLE_MENU_PANE:
	InitIdleOptionsMenu(pMenuPane);
        break;
    case R_AVP_PLAYER_VIEW_PAUSED_MENU_PANE:
	InitPausedOptionsMenu(pMenuPane);
        break;
    case R_AVP_PLAYER_VIEW_LIVE_PLAY_MENU_PANE:
        InitLivePlayOptionsMenu(pMenuPane);
        break;
    default:
        bInitCommonItems = false;
        break;
    }

    if(bInitCommonItems)
    {
        CHXAvMisc::InitDebugMenuItemsL(pMenuPane);
    }
    
}

////////////////////////////////////////////////////
// update context pane (i.e., app icon area) to reflect player state
//
void CHXAvPlayView::UpdateContextPaneL()
{
#if(0)
    bool bShowResumePendingIcon = false;

    //
    // dim icon while playback pending unless we are running
    // embedded (in that case we don't want to overwrite the
    // container app icon)
    // 
    if( !m_playerUI->IsRunningEmbedded() )
    {
        CHXAvPlayerState::State state = m_player->GetPlayerState(),GetState();
        bShowResumePendingIcon = (state == CHXAvPlayerState::Connecting);
        bShowResumePendingIcon |= (CHXAvPlayerState::NotBuffering != m_player->GetPlayerState().GetBufferState());

    }

    if(bShowResumePendingIcon)
    {
        // grey out the app icon
	m_contextPane->SetPictureFromFileL(m_playerUI->GetAppImageFilePath(), 
	    EMbmRealplayerQgn_menu_rp_grey_cxt, EMbmRealplayerQgn_menu_rp_grey_cxt_mask);
    }
    else
    {
	// set default icon from AIF
	m_contextPane->SetPictureToDefaultL();
    }
#endif
}

////////////////////////////////////////
// connect note callback
void CHXAvPlayView::OnUserCancelConnect()
{
    m_player->Stop();
}

// we must be last in observer chain
void
CHXAvPlayView::OnError(HX_RESULT code)
{   
    //
    // lookup user error message
    //
    UINT32 ulErrorStringID = ErrorStringTable[0].m_ulErrorStringID;
    for (int i = 0;
        i < sizeof(ErrorStringTable) / sizeof(ErrorStringTable[0]); ++i)
    {
        if(ErrorStringTable[i].m_ulErrorTag == code)
        {
            ulErrorStringID = ErrorStringTable[i].m_ulErrorStringID;
            break;
        }
    }
    CHXAvCleanString errText(ulErrorStringID);

    comptr<CHXLitePrefs> prefs = m_playerUI->GetClientEngineManager()->GetPrefs();

    const bool bAppendHexCode = prefs::GetBool(prefs, CHXAV_ErrMsgIncludeCode, true);
    // Let's not do any more memory allocations than we have to if we are 
    // here precisely because we are out of memory.
    if(bAppendHexCode && code != HXR_OUTOFMEMORY)
    {
        //
        // create stringified error code to append to error message text
        //
        HBufC* pCodeText = 0;
#if defined(HELIX_FEATURE_DPRINTF)
        // get nice (translated) version of result code 
        CHXString str("\n");
        str += dbg::ErrorCode(code);
        pCodeText = CHXAvStringUtils::AllocTextL(str);
#else
        // in this case, just format number
        _LIT(KErrCodeFormat, "\n0x%08x");
        pCodeText = CHXAvStringUtils::AllocFormatTextHexArgL(KErrCodeFormat, code);
#endif
        AUTO_PUSH_POP_DEL(pCodeText);


        //
        // form message: user text + appended error code
        //
        HBufC* pFullText = CHXAvStringUtils::AllocTextL(errText(), *pCodeText);
        AUTO_PUSH_POP_DEL(pFullText);

        CHXAvMessageDialog::DoAlertErrorL(*pFullText);
    }
    else
    {
        CHXAvMessageDialog::DoAlertErrorL(errText());
    }

}