perscmgr.cpp

著名的 helix realplayer 基于手机 symbian 系统的 播放器全套源代码

	{
	    if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
	    {
		pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
		if (pGroupSink)
		{
		    pGroupSink->GroupAdded(uGroupIndex, pGroup);
		}
	    }
	    HX_RELEASE(pPersistentComponent);
	}
    }
    HX_RELEASE(pProperties);

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroupSink::GroupRemoved
*  Purpose:
*		Notification of a group being removed from the presentation.
*/
STDMETHODIMP
HXPersistentComponentManager::GroupRemoved(UINT16	/*IN*/ uGroupIndex,
					    IHXGroup*  /*IN*/ pGroup)
{
    HX_RESULT			rc = HXR_OK;
    UINT32			ulPersistentComponentID = 0;
    IHXValues*			pProperties = NULL;
    IHXGroupSink*		pGroupSink = NULL;
    IHXPersistentComponent*	pPersistentComponent = NULL;

    pProperties = pGroup->GetGroupProperties();
    if (pProperties)
    {
	if (HXR_OK == pProperties->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
	{
	    if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
	    {
		pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
		if (pGroupSink)
		{
		    pGroupSink->GroupRemoved(uGroupIndex, pGroup);
		}
	    }
	    HX_RELEASE(pPersistentComponent);
	}
    }
    HX_RELEASE(pProperties);

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroupSink::AllGroupsRemoved
*  Purpose:
*		Notification that all groups have been removed from the 
*		current presentation.
*/
STDMETHODIMP
HXPersistentComponentManager::AllGroupsRemoved(void)
{
    return HXR_OK;
}

/************************************************************************
*  Method:
*      IHXGroupSink::TrackAdded
*  Purpose:
*		Notification of a new track being added to a group.
*/
STDMETHODIMP
HXPersistentComponentManager::TrackAdded(UINT16 	    /*IN*/ uGroupIndex,
					  UINT16 	    /*IN*/ uTrackIndex,
					  IHXValues*	    /*IN*/ pTrack)
{
    HX_RESULT			rc = HXR_OK;
    UINT32			ulPersistentComponentID = 0;
    IHXGroupSink*		pGroupSink = NULL;
    IHXPersistentComponent*	pPersistentComponent = NULL;
    UINT32                   bNotUsed = 0;

    if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
    {
	if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
	{
	    pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
	    if (pGroupSink)
	    {
            //If the persistant renderer isn't using groups don't call track added.
            if (HXR_OK != pTrack->GetPropertyULONG32("NoGroupsPresent", bNotUsed))
            {
                pGroupSink->TrackAdded(uGroupIndex, uTrackIndex, pTrack);
            }
            
	    }
	}
	HX_RELEASE(pPersistentComponent);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroupSink::TrackRemoved
*  Purpose:
*		Notification of a track being removed from a group.
*/
STDMETHODIMP
HXPersistentComponentManager::TrackRemoved(UINT16	    /*IN*/ uGroupIndex,
					    UINT16 	    /*IN*/ uTrackIndex,
					    IHXValues*	    /*IN*/ pTrack)
{
    HX_RESULT			rc = HXR_OK;
    UINT32			ulPersistentComponentID = 0;
    IHXGroupSink*		pGroupSink = NULL;
    IHXPersistentComponent*	pPersistentComponent = NULL;

    if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
    {
	if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
	{
	    pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
	    if (pGroupSink)
	    {
		pGroupSink->TrackRemoved(uGroupIndex, uTrackIndex, pTrack);
	    }
	}
	HX_RELEASE(pPersistentComponent);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroupSink::TrackStarted
*  Purpose:
*		Notification of a track being started (to get duration, for
*		instance...)
*/
STDMETHODIMP
HXPersistentComponentManager::TrackStarted(UINT16	    /*IN*/ uGroupIndex,
					    UINT16	    /*IN*/ uTrackIndex,
					    IHXValues*	    /*IN*/ pTrack)
{
    HX_RESULT			rc = HXR_OK;
    UINT32			ulPersistentComponentID = 0;
    IHXGroupSink*		pGroupSink = NULL;
    IHXPersistentComponent*	pPersistentComponent = NULL;

    if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
    {
	if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
	{
	    pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
	    if (pGroupSink)
	    {
		pGroupSink->TrackStarted(uGroupIndex, uTrackIndex, pTrack);
	    }
	}
	HX_RELEASE(pPersistentComponent);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroupSink::TrackStopped
*  Purpose:
*		Notification of a track being stopped
*
*/
STDMETHODIMP
HXPersistentComponentManager::TrackStopped(UINT16	    /*IN*/ uGroupIndex,
					    UINT16	    /*IN*/ uTrackIndex,
					    IHXValues*	    /*IN*/ pTrack)
{
    HX_RESULT			rc = HXR_OK;
    UINT32			ulPersistentComponentID = 0;
    IHXGroupSink*		pGroupSink = NULL;
    IHXPersistentComponent*	pPersistentComponent = NULL;

    if (HXR_OK == pTrack->GetPropertyULONG32("PersistentComponentID", ulPersistentComponentID))
    {
	if (HXR_OK == GetPersistentComponent(ulPersistentComponentID, pPersistentComponent))
	{
	    pGroupSink = ((HXPersistentComponent*)pPersistentComponent)->m_pGroupSink;
	    if (pGroupSink)
	    {
		pGroupSink->TrackStopped(uGroupIndex, uTrackIndex, pTrack);
	    }
	}
	HX_RELEASE(pPersistentComponent);
    }

    return rc;
}

/************************************************************************
*  Method:
*      IHXGroupSink::CurrentGroupSet
*  Purpose:
*		This group is being currently played in the presentation.
*/
STDMETHODIMP
HXPersistentComponentManager::CurrentGroupSet(UINT16	    /*IN*/ uGroupIndex,
					       IHXGroup*   /*IN*/ pGroup)
{
    HX_RESULT			rc = HXR_OK;

    m_nCurrentGroup = uGroupIndex;

    if (m_pRootPersistentComponent)
    {
	rc = m_pRootPersistentComponent->CurrentGroupSet(uGroupIndex, pGroup);
    }

    return rc;
}

HX_RESULT
HXPersistentComponentManager::OnTimeSync(ULONG32 ulCurrentTime)
{
    HX_RESULT	rc = HXR_OK;

    if (m_pRootPersistentComponent)
    {
	rc = m_pRootPersistentComponent->OnTimeSync(ulCurrentTime);
    }

    return rc;
}

BOOL
HXPersistentComponentManager::IsCleanupLayoutNeeded(INT32 nCurrentGroup, INT32 nGroupSwitchTo)
{
    BOOL			bResult = FALSE;
    UINT32			ulPersistentComponentIDSwitchTo = 0;
    IHXValues*			pGroupProperties = NULL;
    IHXValues*			pGroupSwitchToProperties = NULL;
    IHXGroup*			pGroup = NULL;
    IHXGroup*			pGroupSwitchTo = NULL;
    IHXGroup2*			pGroup2 = NULL;
    IHXGroupManager*		pGroupManager = NULL;
    IHXPersistentComponent*	pPersistentComponent = NULL;

    // we will cleanup the layout if the from_group and to_group:
    // * associated with different persistent component OR
    // * associated with the same RAM
    if (HXR_OK == m_pPlayer->QueryInterface(IID_IHXGroupManager, (void**)&pGroupManager))
    {
	if (HXR_OK == pGroupManager->GetGroup(nGroupSwitchTo, pGroupSwitchTo))
	{
	    pGroupSwitchToProperties = pGroupSwitchTo->GetGroupProperties();
	    if (pGroupSwitchToProperties)
	    {
		if (HXR_OK == pGroupSwitchToProperties->GetPropertyULONG32("PersistentComponentID", 
									   ulPersistentComponentIDSwitchTo))
		{
		    if (HXR_OK == pGroupManager->GetGroup(nCurrentGroup, pGroup) &&
			HXR_OK == pGroup->QueryInterface(IID_IHXGroup2, (void**)&pGroup2))
		    {	
			if (HXR_OK == pGroup2->GetPersistentComponentProperties(ulPersistentComponentIDSwitchTo,
										pGroupProperties))
			{
			    if (HXR_OK == GetPersistentComponent(ulPersistentComponentIDSwitchTo, pPersistentComponent))
			    {
				// switch group within RAM
				if (((HXPersistentComponent*)pPersistentComponent)->m_ulPersistentType == PersistentRAM)
				{
				    bResult = TRUE;
				}
				// switch group within SMIL without root layout
				// m_pPlayer->m_bAddLayoutSiteGroupCalled = TRUE when there is root layout
				// specified in SMIL
				// this needs to be revisited when fixing the nested meta layout
				else if (!m_pPlayer->m_bAddLayoutSiteGroupCalled)
				{
				    bResult = TRUE;
				}
			    }
			    else
			    {
				HX_ASSERT(FALSE);
			    }
			    HX_RELEASE(pPersistentComponent);
			}
			else
			{
			    bResult = TRUE;
			}
			HX_RELEASE(pGroupProperties);
		    }
		    HX_RELEASE(pGroup2);
		    HX_RELEASE(pGroup);
		}
	    }
	    HX_RELEASE(pGroupSwitchToProperties);
	}
	HX_RELEASE(pGroupSwitchTo);
    }
    HX_RELEASE(pGroupManager);

    return bResult;
}

UINT32
HXPersistentComponentManager::GetPersistentComponentCount(void)
{
    if (m_pRootPersistentComponent)
    {
	return m_pRootPersistentComponent->GetPersistentComponentCount();
    }

    return 0;
}

void		
HXPersistentComponentManager::TrackUpdated(UINT16 uGroupIndex, 
					    UINT16 uTrackIndex, 
					    IHXValues* pValues)
{
    if (m_pRootPersistentComponent)
    {
	m_pRootPersistentComponent->TrackUpdated(uGroupIndex, 
	   				         uTrackIndex,
						 pValues);
    }

    return;
}

void
HXPersistentComponentManager::CloseAllRenderers(INT32 nGroupSwitchTo)
{
    // nested meta support
    if (m_pRootPersistentComponent)
    {
	if (m_pRootPersistentComponent->m_bToBeClosed)
	{
	    m_pRootPersistentComponent->Remove();
	    HX_RELEASE(m_pRootPersistentComponent);
	    m_pPlayer->CleanupLayout();
        }
    	else
	{
	    m_pRootPersistentComponent->AllRenderersClosed();

	    if (IsCleanupLayoutNeeded(m_nCurrentGroup, nGroupSwitchTo))
	    {
		m_pPlayer->CleanupLayout();
	    }
	}
    }
    else
    {	
	m_pPlayer->CleanupLayout();
    }

    return;
}

void
HXPersistentComponentManager::Reset()
{
    if (m_pRootPersistentComponent)
    {
	m_pRootPersistentComponent->Reset();
    }
    m_ulComponentIndex = 0;

    return;
}

void 
HXPersistentComponentManager::Close()
{
    HX_ASSERT(!m_pRootPersistentComponent);

    return;
}