diff -r 000000000000 -r 96612d01cf9f videoplayerapp/mpxvideoplayer/src/mpxvideoplayerappuiengine.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/videoplayerapp/mpxvideoplayer/src/mpxvideoplayerappuiengine.cpp Mon Jan 18 20:21:12 2010 +0200 @@ -0,0 +1,1520 @@ +/* +* Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: AppUI engine implementation +* +*/ + +// Version : %version: da1mmcf#58 % + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include // CMDBSession +#include // CCDWAPIPBearerRecord +#include +#include // TCommDbConnPref +#include + +#include "mpxvideoplayerappuiengine.h" +#include "mpxvideoplayerlogger.h" +#include "mpxvideoplayerconstants.h" +#include "mpxvideoembeddedpdlhandler.h" +#include +#include "mpxvideo_debug.h" +#include "mpxvideoplayercustomviewmsgconsts.h" + +_LIT( KMpxVideoPlayerQueryIap, "IAP\\Id" ); + +const TInt KMpxPlaybackPluginTypeUid = 0x101FFCA0; + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine +// ----------------------------------------------------------------------------- +// +CMpxVideoPlayerAppUiEngine::CMpxVideoPlayerAppUiEngine( CMpxVideoPlayerAppUi* aAppUi ) + : iAppUi( aAppUi ), + iPlaybackUtility( NULL ), + iViewUtility( NULL ), + iCollectionUtility( NULL ), + iExitAo( NULL ), + iRecognizer( NULL ), + iExtAccessPointId( KErrUnknown ), + iMultilinkPlaylist(EFalse), + iSeekable(ETrue), + iUpdateSeekInfo(EFalse), + iExitToMatrixMenu(ETrue) +{ +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::NewL +// ----------------------------------------------------------------------------- +// +CMpxVideoPlayerAppUiEngine* CMpxVideoPlayerAppUiEngine::NewL( CMpxVideoPlayerAppUi* aAppUi ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::NewL()")); + + CMpxVideoPlayerAppUiEngine* self = new( ELeave) CMpxVideoPlayerAppUiEngine( aAppUi ); + + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::ConstructL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::ConstructL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ConstructL()")); + + iRecognizer = CMediaRecognizer::NewL(); + + // + // Create the View Utility + // + iViewUtility = MMPXViewUtility::UtilityL(); + iViewUtility->AddObserverL( this ); + iViewUtility->ConstructDefaultViewHistoryL(); + + // + // Create the Collection Utility + // + if ( ! iAppUi->IsEmbedded() ) + { + TUid collectionMode( KUidMpxVideoPlayerApplication ); + + iCollectionUtility = MMPXCollectionUtility::NewL( this, collectionMode ); + } + + // + // Create Active Object for exiting the application + // + iExitAo = CIdle::NewL( CActive::EPriorityStandard ); +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::CreateCollectionUtilityMemberVariablesL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::CreateCollectionUtilityMemberVariablesL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::CreateCollectionUtilityMemberVariablesL()")); + + if ( ! iCollectionUtility ) + { + // PLAYLIST default mode + iCollectionUtility = MMPXCollectionUtility::NewL( this ); + } + + if ( ! iCollectionUiHelper ) + { + iCollectionUiHelper = CMPXCollectionHelperFactory::NewCollectionUiHelperL(); + } +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityMemberVariablesL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityMemberVariablesL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::CreatePlaybackUtilityMemberVariablesL()")); + + if ( ! iPlaybackUtility ) + { + // + // Create VideoHelix playback plugin + // + iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer ); + MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager(); + manager.SelectPlayerL( KVideoHelixPlaybackPluginUid ); + iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse ); + } +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::CreateEmbeddedPdlPlaybackUtilityMemberVariablesL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::CreateEmbeddedPdlPlaybackUtilityMemberVariablesL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::CreateEmbeddedPdlPlaybackUtilityMemberVariablesL()")); + + iViewUtility->PreLoadViewL( KVideoPdlPlaybackViewUid ); + + if ( ! iPlaybackUtility ) + { + iPlaybackUtility = MMPXPlaybackUtility::UtilityL( EMPXCategoryVideo, KPbModeNewPlayer ); + MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager(); + manager.SelectPlayerL( KVideoHelixPlaybackPluginUid ); + iPlaybackUtility->CommandL( EPbCmdSetAutoResume, EFalse ); + } +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine +// ----------------------------------------------------------------------------- +// +CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::~CMpxVideoPlayerAppUiEngine()")); + + if ( iExitAo ) + { + delete iExitAo; + iExitAo = NULL; + } + + if ( iRecognizer ) + { + delete iRecognizer; + iRecognizer = NULL; + } + + if ( iPdlHandler ) + { + delete iPdlHandler; + iPdlHandler = NULL; + } + + if ( iCollectionUtility ) + { + iCollectionUtility->Close(); + } + + if ( iCollectionUiHelper ) + { + iCollectionUiHelper->Close(); + } + + if ( iViewUtility ) + { + iViewUtility->RemoveObserver( this ); + iViewUtility->Close(); + } + + if ( iPlaybackUtility ) + { + TRAP_IGNORE( iPlaybackUtility->CommandL( EPbCmdClose ) ); + iPlaybackUtility->Close(); + } +} + +// --------------------------------------------------------------------------- +// From MMPXViewActivationObserver. +// Handle view activation. +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleViewActivation( const TUid& /*aCurrentViewType*/, + const TUid& /*aPreviousViewType*/ ) +{ +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleAiwGenericParamListL() +// ------------------------------------------------------------------------------------------------- +// +TInt CMpxVideoPlayerAppUiEngine::HandleAiwGenericParamListL( const CAiwGenericParamList* aParams ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleAiwGenericParamListL()")); + + TInt retVal = KErrNone; + + TInt index = 0; + + // + // Check if there is a terminate message. If it exists, exit the application. + // + TInt32 terminateID = 0; + + const TAiwGenericParam* paramTerminate = + aParams->FindFirst( index, EGenericParamTerminate, EVariantTypeTInt32 ); + + if ( paramTerminate ) + { + paramTerminate->Value().Get( terminateID ); + } + + if ( terminateID ) + { + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::HandleAiwGenericParamListL() Terminate message received")); + + // + // Embedded app is being closed + // + iAppUi->HandleCommandL( EEikCmdExit ); + + retVal = KErrCancel; + } + else + { + // + // Determine if these parameters are for PDL + // + index = 0; + TInt32 dlId = KErrNotFound; + + const TAiwGenericParam* genParamDlId = + aParams->FindFirst( index, EGenericParamDownloadId, EVariantTypeTInt32 ); + + if ( genParamDlId ) + { + genParamDlId->Value().Get( dlId ); + + index = 0; + + const TAiwGenericParam* paramFileName = + aParams->FindFirst( index, EGenericParamFile, EVariantTypeDesC ); + + TPtrC fileName; + + // + // Set the filename. The LWPlayerAppUi checks for the + // filename and exits if it doesn't exist + // + fileName.Set( paramFileName->Value().AsDes() ); + + if ( ! iPdlHandler ) + { + iPdlHandler = CMpxVideoEmbeddedPdlHandler::NewL( this ); + } + + iPdlHandler->ConnectToEmbeddedDownloadL( dlId, fileName ); + } + else + { + // + // Check Access Point + // + index = 0; + + const TAiwGenericParam* genParamAccessPoint = + aParams->FindFirst( index, EGenericParamAccessPoint, EVariantTypeTInt32 ); + + if ( index >= 0 && genParamAccessPoint ) + { + TInt32 apId = KErrUnknown; + genParamAccessPoint->Value().Get( apId ); + iExtAccessPointId = apId; + } + } + } + + return retVal; +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::OpenFileL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::OpenFileL( RFile& aFile, const CAiwGenericParamList* aParams ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::OpenFileL(RFile)")); + + TInt err = KErrNone; + + if ( aParams ) + { + err = HandleAiwGenericParamListL( aParams ); + } + + if ( KErrNone == err && ! iPdlHandler ) + { + // + // Create member variables for embedded use cases that are not PDL + // + CreatePlaybackUtilityMemberVariablesL(); + + TFileName filename; + aFile.FullName(filename); + + CMediaRecognizer::TMediaType mediaType = iRecognizer->IdentifyMediaTypeL( filename, aFile ); + + if ( mediaType == CMediaRecognizer::ELocalRamFile || + mediaType == CMediaRecognizer::ELocalAsxFile ) + { + HandleMultiLinksFileL( aFile, mediaType ); + } + else if ( mediaType == CMediaRecognizer::ELocalSdpFile ) + { + SetAccessPointL(); + iPlaybackUtility->InitStreamingL( aFile, iAccessPointId ); + ActivatePlaybackViewL(); + } + else + { + iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ); + iPlaybackUtility->InitL( aFile ); + ActivatePlaybackViewL(); + } + } + + iRecognizer->FreeFilehandle(); + + aFile.Close(); +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::OpenFileL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::OpenFileL( const TDesC& aFileName ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::OpenFileL()"), + _L("aFileName = %S"), &aFileName); + + // + // Create member variables for embedded use cases that are not PDL + // + CreatePlaybackUtilityMemberVariablesL(); + + // pre load the view and initialize the playback framework + iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ); + + CMediaRecognizer::TMediaType mediaType = iRecognizer->IdentifyMediaTypeL(aFileName); + + if ( mediaType == CMediaRecognizer::ELocalVideoFile ) + { + InitializeFileL( aFileName ); + } + // check if aFileName is a path to a ram or asx file + // eg. c:\\data\\videos\\ramfile.ram + else if ( mediaType == CMediaRecognizer::ELocalRamFile || + mediaType == CMediaRecognizer::ELocalAsxFile ) + { + HandleMultiLinksFileL( aFileName, mediaType ); + } + // check if this is a url eg. rtsp://someaddress/file.3gp + // + else if ( iRecognizer->IsValidStreamingPrefix( aFileName ) || + mediaType == CMediaRecognizer::ELocalSdpFile ) + { + InitializeStreamingLinkL( aFileName ); + } + else + { + InitializeFileL( aFileName ); + } + + iRecognizer->FreeFilehandle(); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::OpenMediaL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::OpenMediaL( const CMPXMedia& aMedia ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::OpenMediaL()")); + + // Assume MPX medias are always local clips + CMPXCollectionPath* mediaPath = CMPXCollectionPath::NewL(); + CleanupStack::PushL( mediaPath ); + + mediaPath->AppendL( KVcxUidMyVideosMpxCollection ); + mediaPath->AppendL( KVcxMvcCategoryIdAll ); + + mediaPath->AppendL( aMedia.ValueTObjectL( KMPXMediaGeneralId ) ); + mediaPath->SelectL( aMedia.ValueTObjectL( KMPXMediaGeneralId ) ); + + CMPXCollectionPlaylist* playList = CMPXCollectionPlaylist::NewL( *mediaPath ); + CleanupStack::PushL( playList ); + playList->SetSingleItemPlaylist(); + playList->SetToFirst(); + + CreatePlaybackUtilityMemberVariablesL(); + + iViewUtility->PreLoadViewL( KVideoPlaybackViewUid ); + + InitializePlaylistL( *playList, ETrue ); + + CleanupStack::PopAndDestroy( playList ); + CleanupStack::PopAndDestroy( mediaPath ); +} + +// --------------------------------------------------------------------------- +// Activate the proper playback view +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::ActivatePlaybackViewL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ActivatePlaybackViewL()")); + + if ( iUpdateSeekInfo ) + { + // + // The plugin has been instantiated, update the media + // + UpdatePbPluginMediaL(); + iUpdateSeekInfo = EFalse; + } + + MMPXPlayer* player = iPlaybackUtility->PlayerManager().CurrentPlayer(); + + TUid pluginUid( KNullUid ); + RArray array; + + CleanupClosePushL( array ); + + if ( iPdlHandler ) + { + array.AppendL( KVideoPdlPlaybackViewUid ); + } + else + { + if ( player ) + { + pluginUid = player->UidL(); + array.AppendL( pluginUid ); + } + } + + iViewUtility->ActivateViewL( array ); + + CleanupStack::PopAndDestroy( &array ); +} + +// --------------------------------------------------------------------------- +// Closed mpx components and readies to application takedown. +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::PrepareCloseMpxL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::PrepareCloseMpxL()")); + + if ( iPlaybackUtility ) + { + iPlaybackUtility->CommandL( EPbCmdClose ); + MMPXPlayerManager& manager = iPlaybackUtility->PlayerManager(); + TRAP_IGNORE( manager.ClearSelectPlayersL() ); + } +} + +// --------------------------------------------------------------------------- +// Sets AppUiEngine in stand alone "mode" +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::StartStandAloneL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::StartStandAloneL()")); + + iExitToMatrixMenu = EFalse; + + // + // Create the utilities for the stand alone player + // + CreatePlaybackUtilityMemberVariablesL(); + + // Fetch the video collection UID + RArray uid; + CleanupClosePushL( uid ); + + uid.AppendL( TUid::Uid( KVcxMediaIdMyVideos ) ); + + iVideoCollectionId = iCollectionUtility->CollectionIDL( uid.Array() ); + + CleanupStack::PopAndDestroy( &uid ); + + iViewUtility->SetAsDefaultViewL( KUidMyVideosViewType ); +} + +// ----------------------------------------------------------------------------- +// Handle collection message +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL( CMPXMessage* aMessage ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL()")); + + TMPXMessageId id = *(aMessage->Value( KMPXMessageGeneralId )); + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL() TMPXMessageId = 0x%08x"), id ); + + if ( id == KMPXMessageGeneral ) + { + TInt event( *( aMessage->Value ( KMPXMessageGeneralEvent )) ); + TInt type( *( aMessage->Value ( KMPXMessageGeneralType )) ); + TInt data( *( aMessage->Value ( KMPXMessageGeneralData )) ); + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL event %d, type %d, data %d"), event, type, data ); + + if ( event == TMPXCollectionMessage::EPathChanged && type == EMcPathChangedByOpen ) + { + if ( data == EMcItemOpened ) + { + // An item was opened on the collection. Get the media attributes + // on the item so we can initiatiate playback + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: EMcItemOpened received. Can open video")); + + CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL(); + + CleanupStack::PushL( cPath ); + + if ( cPath->Count() > 0 ) + { + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: Call MediaL() on collection.")); + + RArray attribs; + CleanupClosePushL( attribs ); + + attribs.Append( KMPXMediaGeneralUri ); + attribs.Append( KVcxMediaMyVideosDownloadId ); + iCollectionUtility->Collection().MediaL( *cPath, attribs.Array() ); + + CleanupStack::PopAndDestroy( &attribs ); + } + + CleanupStack::PopAndDestroy( cPath ); + } + else if ( data == EMcContainerOpened && iMultilinkPlaylist ) + { + // start the playback for streaming playlists + // once the playlist is opened + iMultilinkPlaylist = EFalse; + + // The playlist was opened, initiatiate playback + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: EMcContainerOpened received. initiatiate playback")); + + CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL(); + CleanupStack::PushL( cPath ); + + if ( cPath->Count() > 0 ) + { + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMessageL: Call Playback utility with the playlist.")); + + CMPXCollectionPlaylist* playlist = CMPXCollectionPlaylist::NewL( *cPath ); + CleanupStack::PushL( playlist ); + + // Set the AutoPlay mode to false + playlist->SetAutoPlay(EFalse); + // set pre init plugin to false + playlist->SetPreInitPlugin(EFalse); + + InitializePlaylistL( *playlist, ETrue ); + CleanupStack::PopAndDestroy( playlist ); + } + CleanupStack::PopAndDestroy( cPath ); + } + } + } +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::DoHandleCollectionMediaL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::DoHandleCollectionMediaL( const CMPXMedia& aMedia ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoHandleCollectionMediaL()")); + + const TDesC& fileUri = aMedia.ValueText(KMPXMediaGeneralUri); + + MPX_DEBUG(_L("Video URI: %S"), &fileUri ); + + if ( aMedia.IsSupported( KVcxMediaMyVideosDownloadId ) && + aMedia.ValueTObjectL( KVcxMediaMyVideosDownloadId ) != 0 ) + { + TUint32 dlId = aMedia.ValueTObjectL( KVcxMediaMyVideosDownloadId ); + + if ( ! iPdlHandler ) + { + iPdlHandler = CMpxVideoEmbeddedPdlHandler::NewL( this ); + } + + iPdlHandler->ConnectToCollectionDownloadL( dlId, const_cast( fileUri ) ); + } + else + { + OpenMediaL( aMedia ); // Initialize and initiate playback of a single video + } +} + +// --------------------------------------------------------------------------- +// Steps back one level back in collection path. Will activate previous view if level exists +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::StepBackCollectionPathL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::StepBackCollectionPathL()")); + + // Back the collection path one level... + + CMPXCollectionPath* cPath = iCollectionUtility->Collection().PathL(); + CleanupStack::PushL( cPath ); + + // Don't back up if there are no more levels or will panic + if ( cPath->Levels() > 1 ) + { + cPath->Back(); + iCollectionUtility->Collection().OpenL( *cPath ); + // ... and then activate the previous view. + iViewUtility->ActivatePreviousViewL(); + } + + CleanupStack::PopAndDestroy( cPath ); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL( const TDesC& aFileName, + CMediaRecognizer::TMediaType aMediaType ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL()"), + _L("aFileName = %S, type = %d"), &aFileName, aMediaType ); + + TBool singleLink; + TBool localFile; + + CVideoPlaylistUtility* playlistUtil = CVideoPlaylistUtility::NewL(); + CleanupStack::PushL(playlistUtil); + + playlistUtil->GetFileInfoL( aFileName, aMediaType, singleLink, localFile ); + + DoHandleMultiLinksFileL( playlistUtil, singleLink, localFile ); + + CleanupStack::PopAndDestroy( playlistUtil ); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL( RFile& aFile, + CMediaRecognizer::TMediaType aMediaType ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleMultiLinksFileL(RFile)")); + + // playlist + TBool singleLink; + TBool localFile; + + CVideoPlaylistUtility* playlistUtil = CVideoPlaylistUtility::NewL(); + CleanupStack::PushL(playlistUtil); + + playlistUtil->GetFileInfoL( aFile, aMediaType, singleLink, localFile ); + + DoHandleMultiLinksFileL( playlistUtil, singleLink, localFile ); + + CleanupStack::PopAndDestroy( playlistUtil ); +} + + +void CMpxVideoPlayerAppUiEngine::DoHandleMultiLinksFileL( CVideoPlaylistUtility* aPlaylistUtil, + TBool aSingleLink, + TBool aLocalFile ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoHandleMultiLinksFileL()"), + _L("aSingleLink = %d aLocalFile %d "), aSingleLink, aLocalFile); + + if ( aSingleLink ) + { + TPtrC link; + link.Set( aPlaylistUtil->GetLinkLC() ); + iUpdateSeekInfo = ETrue; + iSeekable = aPlaylistUtil->IsSeekable(); + + if ( aLocalFile ) + { + CMediaRecognizer::TMediaType mediaType = iRecognizer->IdentifyMediaTypeL( link ); + + if ( mediaType == CMediaRecognizer::EUnidentified ) + { + User::Leave( KErrNotSupported ); + } + else + { + InitializeFileL( link ); + } + } + else + { + InitializeStreamingLinkL( link ); + } + CleanupStack::PopAndDestroy(); // link + } + else + { + if ( ! aLocalFile ) + { + SetAccessPointL(); + } + + CMPXMedia* playlist = aPlaylistUtil->GetPlayListL( iAccessPointId ); + CleanupStack::PushL( playlist ); + + // Create FW utility member variables for playlist embedded use case + CreateCollectionUtilityMemberVariablesL(); + + // Set the flag to true + iMultilinkPlaylist = ETrue; + + // load the in memory plugin + iCollectionUiHelper->OpenL( KUidMpxVideoPlayerApplication, + *playlist, + this, + EMPXCollectionPluginGallery ); + + CleanupStack::PopAndDestroy( playlist ); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::SetAccessPointL +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::SetAccessPointL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::SetAccessPointL()")); + + // + // a value was passed in for argument aAPId + // + if ( ( iExtAccessPointId != KErrUnknown ) && IsWLANAccessPointL( iExtAccessPointId ) ) + { + // + // An external WLAN access point was passed in by an embedding app, use it + // + iAccessPointId = iExtAccessPointId; + } + else + { + // + // No access point was passed in or it's not WLAN, retrieve the default access point + // + TInt defaultAPId(0); + + MPX_TRAPD( err, defaultAPId = GetDefaultAccessPointL() ); + + if ( ( err == KErrNone ) && ( defaultAPId != 0 )) + { + // + // Use the default access point + // + iAccessPointId = defaultAPId; + } + else + { + // + // Valid default access point was not found + // + if ( iExtAccessPointId != KErrUnknown ) + { + // + // Use the AP passed in by embedding app, regardless of bearer type + // + iAccessPointId = iExtAccessPointId; + } + else + { + // + // Try to fetch AP ID and open connection selection dialog if required + // + TUint32 apUid = TryToGetAccessPointL(); + + // + // Use selected access point + // + if ( apUid != 0 ) + { + // + // convert the AccessPoint-Uid to AccessPoint-Id + // + iAccessPointId = GetAccessPointIdForUIDL( apUid ); + } + } + } + } +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::IsWLANAccessPointL +// ------------------------------------------------------------------------------------------------- +// +TBool CMpxVideoPlayerAppUiEngine::IsWLANAccessPointL( TInt aAPId ) +{ + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::IsWLANAccessPointL(%d)"), aAPId); + + TBool wlanAP(EFalse); + TUint32 bearer( 0 ); + + RCmManagerExt cmManager; + CleanupClosePushL( cmManager ); + cmManager.OpenL(); + + bearer = cmManager.ConnectionMethodL( aAPId ).GetIntAttributeL( CMManager::ECmBearerType ); + CleanupStack::PopAndDestroy( &cmManager ); + + if ( bearer == KUidWlanBearerType ) + { + wlanAP = ETrue; + } + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::IsWLANAccessPointL() return %d"), wlanAP); + + return wlanAP; +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::GetDefaultAccessPointL +// ----------------------------------------------------------------------------- +// +TInt CMpxVideoPlayerAppUiEngine::GetDefaultAccessPointL() +{ + TInt defaultAP(0); + TUint32 iap; + + CMPSettingsModel* ropSettings = CMPSettingsModel::NewL( KSettingsModelForROPUid ); + + CleanupStack::PushL( ropSettings ); + + ropSettings->LoadSettingsL( EConfigDefault ); + + User::LeaveIfError( ropSettings->GetDefaultAp( iap ) ); + + CleanupStack::PopAndDestroy(); // ropSettings + + defaultAP = GetAccessPointIdForUIDL( iap ); + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::GetDefaultAccessPointL(%d)"), defaultAP); + + return defaultAP; +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::GetAccessPointIdForUIDL +// ----------------------------------------------------------------------------- +// +TInt CMpxVideoPlayerAppUiEngine::GetAccessPointIdForUIDL( TUint32 aAPUid ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::GetAccessPointIdForUIDL()"), + _L(" aAPUid = %d"), aAPUid); + + TInt apId(0); + + CMDBSession* db = CMDBSession::NewL( CMDBSession::LatestVersion() ); + CleanupStack::PushL( db ); + + // + // WapIpBearer table contains the mapping between wap and iap id's. + // + CCDWAPIPBearerRecord* wapBearerRecord = + static_cast(CCDRecordBase::RecordFactoryL(KCDTIdWAPIPBearerRecord)); + + CleanupStack::PushL( wapBearerRecord ); + + wapBearerRecord->iWAPAccessPointId = aAPUid; + + TBool found = wapBearerRecord->FindL( *db ); + + if ( ! found ) + { + User::Leave( KErrNotFound ); + } + + apId = static_cast( wapBearerRecord->iWAPIAP ); + + CleanupStack::PopAndDestroy( wapBearerRecord ); + CleanupStack::PopAndDestroy( db ); + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::GetAccessPointIdForUIDL(%d)"), apId); + + return apId; +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::TryToGetAccessPointL +// ----------------------------------------------------------------------------- +// +TUint32 CMpxVideoPlayerAppUiEngine::TryToGetAccessPointL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::TryToGetAccessPointL()")); + + TUint32 returnVal(0); + + RSocketServ ss; + CleanupClosePushL( ss ); + + User::LeaveIfError( ss.Connect() ); + + RConnection conn; + CleanupClosePushL( conn ); + + User::LeaveIfError( conn.Open( ss ) ); + + TConnPrefList prefList; + TExtendedConnPref prefs; + prefs.SetSnapPurpose( CMManager::ESnapPurposeInternet ); + prefs.SetNoteBehaviour( TExtendedConnPref::ENoteBehaviourConnSilent ); + prefList.AppendL( &prefs ); + + TInt err = conn.Start( prefList ); + + if ( err == KErrNone ) + { + returnVal = QueryIap( conn ); + } + else if ( err == KErrNotFound ) + { + // + // SNAP is empty or no WLAN was available. + // Try again with connection selection dialog. + // + MPX_DEBUG(_L(" connection start returned KErrNotFound")); + + TConnPrefList prefList2; + TExtendedConnPref prefs2; + + prefs2.SetConnSelectionDialog( ETrue ); + prefList2.AppendL( &prefs2 ); + + err = conn.Start( prefList2 ); + + if ( err == KErrNone ) + { + returnVal = QueryIap( conn ); + } + else + { + User::Leave( err ); + } + } + else + { + User::Leave( err ); + } + + CleanupStack::PopAndDestroy( &conn ); + + CleanupStack::PopAndDestroy( &ss ); + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::TryToGetAccessPointL() AP ID: %d"), returnVal); + + return returnVal; +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::QueryIap() +// ------------------------------------------------------------------------------------------------- +// +TUint32 CMpxVideoPlayerAppUiEngine::QueryIap( RConnection& aConn ) +{ + TUint32 iap( 0 ); + aConn.GetIntSetting( KMpxVideoPlayerQueryIap, iap ); + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::QueryIap(%u)"), iap); + return iap; +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::ProcessActivationMessageL +// ----------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::ProcessActivationMessageL( const TDesC8 &aMsg ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ProcessActivationMessageL()")); + + if ( aMsg.Length() < KVideoPlayerActivationMessageMinLength ) + { + User::Leave( KErrNotSupported ); + } + + TVideoPlayerActivationMessage msgHandler; + TPckg paramsPckg( msgHandler ); + paramsPckg.Copy( aMsg ); + + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::ProcessActivationMessageL() sender = %d, type = %d"), + msgHandler.iMsgSender, msgHandler.iMsgType ); + + if ( msgHandler.iMsgSender == TVideoPlayerActivationMessage::EMatrixMenu ) + { + // Clear the view history, so app exits back to matrix. + iViewUtility->PushDefaultHistoryL(); + } + + if ( msgHandler.iMsgType == TVideoPlayerActivationMessage::EOpenInternetVideos ) + { + iViewUtility->ActivateViewL( TUid::Uid( KMpxVideoPlayerVodViewPluginTypeId ) ); + } + else if ( msgHandler.iMsgType == TVideoPlayerActivationMessage::EOpenVideoStorage ) + { + iViewUtility->ActivateViewL( TUid::Uid( KUidMyVideosViewTypeId ) ); + } + else if ( msgHandler.iMsgType == TVideoPlayerActivationMessage::ELaunchVideoToPlayer ) + { + // + // Launch video to player, it can be either local video or stream. + // If there's path and mpx id, clip can be played directly. + // + if ( msgHandler.iServiceId && msgHandler.iFullPath.Length() > 0 ) + { + if ( iRecognizer->IdentifyMediaTypeL( msgHandler.iFullPath ) + == CMediaRecognizer::ELocalVideoFile ) + { + TMPXItemId id; + id.iId1 = msgHandler.iServiceId; + CMPXMedia* media = CMPXMedia::NewL(); + CleanupStack::PushL( media ); + media->SetTObjectValueL( KMPXMediaGeneralId, id ); + OpenMediaL( *media ); + CleanupStack::PopAndDestroy( media ); + } + else + { + // Most likely the clip has been deleted + User::Leave( KErrNotFound ); + } + } + else + { + TBool vodUiRunning = ( iViewUtility->ActiveViewType() == + TUid::Uid( KMpxVideoPlayerVodViewPluginTypeId ) ); + + if ( vodUiRunning ) + { + // VOD is active, must use the utility to pass the message. + SendCustomCommandToActiveViewL( aMsg ); + } + else + { + // VOD is not running, activate with custom message. + HBufC* customMsg = HBufC::NewLC( paramsPckg.Length() ); + customMsg->Des().Copy( paramsPckg ); + iViewUtility->ActivateViewL( TUid::Uid( KMpxVideoPlayerVodViewPluginTypeId ), customMsg ); + CleanupStack::PopAndDestroy( customMsg ); + + // Clear the view history, so playback returns where it was started + iViewUtility->PushDefaultHistoryL(); + } + } + } + else if ( msgHandler.iMsgType == TVideoPlayerActivationMessage::ELaunchServiceById ) + { + if ( iViewUtility->ActiveViewType() == TUid::Uid( KMpxVideoPlayerVodViewPluginTypeId ) ) + { + // VOD is active, must use the utility to pass the message. + SendCustomCommandToActiveViewL( aMsg ); + } + else + { + // VOD is not running, activate with custom message. + HBufC* customMsg = HBufC::NewLC( paramsPckg.Length() ); + customMsg->Des().Copy( paramsPckg ); + iViewUtility->ActivateViewL( TUid::Uid( KMpxVideoPlayerVodViewPluginTypeId ), customMsg ); + CleanupStack::PopAndDestroy( customMsg ); + } + } +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleMessageL() +// ----------------------------------------------------------------------------- +// +TBool CMpxVideoPlayerAppUiEngine::HandleMessageL( TUid aMessageUid, + const TDesC8& aMessageParameters ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleMessageL()")); + + TBool msgHandled = EFalse; + + switch ( aMessageUid.iUid ) + { + // TVideoPlayerActivationMessage received. + case KVideoPlayerVodStartPlayer: + { + // + // Do nothing if we are loaded in a playback view + // + if ( iViewUtility->ActiveViewType() != TUid::Uid( KMpxPlaybackPluginTypeUid ) ) + { + ProcessActivationMessageL( aMessageParameters ); + } + + msgHandled = ETrue; + + break; + } + case KVideoPlayerStartPDlPlayer: + { + // Start the PDl + if ( iPdlHandler ) + { + CBufFlat* paramBuf = CBufFlat::NewL( 1 ); + CleanupStack::PushL( paramBuf ); + paramBuf->InsertL( 0, aMessageParameters ); + RBufReadStream readStream( *paramBuf ); + + CAiwGenericParamList* genParamList = CAiwGenericParamList::NewLC( readStream ); + + HandleAiwGenericParamListL( genParamList ); + + CleanupStack::PopAndDestroy( genParamList ); + CleanupStack::PopAndDestroy( paramBuf ); + + msgHandled = ETrue; + } + + break; + } + } + + return msgHandled; +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleCollectionMessage() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleCollectionMessage( CMPXMessage* aMessage, TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleCollectionMessage()")); + + if ( aError == KErrNone && aMessage ) + { + TRAP_IGNORE( DoHandleCollectionMessageL( aMessage ) ) + } +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleCollectionMediaL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleCollectionMediaL( const CMPXMedia& aMedia, TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleCollectionMediaL()")); + + if ( aError == KErrNone ) + { + DoHandleCollectionMediaL( aMedia ); + } +} + +// --------------------------------------------------------------------------- +// From MMPXCollectionObserver. +// Handles the collection entries being opened. +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleOpenL( const CMPXMedia& /* aEntries */, + TInt /* aIndex */, + TBool /* aComplete */, + TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleOpenL(CMPXMedia)")); + + if ( aError != KErrNone ) + { + // + // Clip the collection path to root level and reopen + // This could happen after a USB refresh event where the + // item no longer exists + // + CMPXCollectionPath* path = iCollectionUtility->Collection().PathL(); + + CleanupStack::PushL( path ); + + while( path->Levels() > 1 ) + { + path->Back(); + } + + iCollectionUtility->Collection().OpenL( *path ); + CleanupStack::PopAndDestroy( path ); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::HandleOpenL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleOpenL( const CMPXCollectionPlaylist& aPlaylist, TInt aError ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleOpenL(CMPXCollectionPlaylist)")); + + if ( aError == KErrNone ) + { + InitializePlaylistL( aPlaylist, EFalse ); + } +} + + +// --------------------------------------------------------------------------- +// From MMPXCHelperEmbeddedOpenObserver +// Handles OpenL from that occured in embedded mode +// --------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::HandleEmbeddedOpenL( TInt aErr, TMPXGeneralCategory /*aCategory*/ ) +{ + MPX_DEBUG(_L("CMPXVideoAppUi::HandleEmbeddedOpenL()")); + + if ( aErr == KErrNone ) + { + iPlaybackUtility->CommandL( EPbCmdDisableEffect ); + } +} + + +void CMpxVideoPlayerAppUiEngine::HandleSoftKeyBackL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::HandleSoftKeyBackL()")); + + // + // if we're in top level of our local view stack, + // back command exits the app. otherwise activate + // the previous view in our local view stack + // + if ( iViewUtility->ViewHistoryDepth() <= 1 ) + { + iExitToMatrixMenu = EFalse; + ActivateExitActiveObject(); + } + else + { + StepBackCollectionPathL(); + } +} + +TBool CMpxVideoPlayerAppUiEngine::ProcessCommandParametersL( TApaCommand aCommand, + TFileName& aDocumentName, + const TDesC8& aTail ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ProcessCommandParametersL()")); + + TBool retVal = EFalse; + + // + // If command line has tail, this is probably a message from Matrix, Live TV + // reminder, Video Center soft notification, or other VC component. + // + if ( aTail.Length() > 0 ) + { + ProcessActivationMessageL( aTail ); + } + else + { + // + // If we are embedded or the command is to open a document + // + if ( iAppUi->IsEmbedded() || aCommand != EApaCommandRun ) + { + if ( iRecognizer->IsValidStreamingPrefix( aDocumentName ) ) + { + retVal = ETrue; + } + else + { + retVal = ConeUtils::FileExists( aDocumentName ); + } + } + else + { + StartStandAloneL(); + } + } + + return retVal; +} + +void CMpxVideoPlayerAppUiEngine::ActivateExitActiveObject() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ActivateExitActiveObject()")); + + if ( ! iExitAo->IsActive() ) + { + iExitAo->Start( TCallBack( CMpxVideoPlayerAppUiEngine::ExitApplicationL, this ) ); + } +} + +// ----------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::ExitApplicationL +// ----------------------------------------------------------------------------- +// +TInt CMpxVideoPlayerAppUiEngine::ExitApplicationL( TAny* aPtr ) +{ + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::ExitApplicationL()")); + + static_cast(aPtr)->DoExitApplicationL(); + return KErrNone; +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::DoExitApplicationL +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::DoExitApplicationL() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::DoExitApplicationL()")); + + iAppUi->HandleCommandL( EEikCmdExit ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoBasePlaybackView::UpdatePbPluginMedia() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::UpdatePbPluginMediaL() +{ + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::UpdatePbPluginMediaL()iSeekable %d"), iSeekable); + + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + + cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); + + cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXMediaIdVideoPlayback ); + + cmd->SetTObjectValueL( KMPXMediaVideoPlaybackCommand, + EPbCmdUpdateSeekable ); + + cmd->SetTObjectValueL( KMPXMediaGeneralExtVideoSeekable, iSeekable ); + + iPlaybackUtility->CommandL( *cmd ); + + CleanupStack::PopAndDestroy( cmd ); +} + +// ------------------------------------------------------------------------------------------------- +// CMPXVideoBasePlaybackView::ViewHistoryDepth() +// ------------------------------------------------------------------------------------------------- +// +TInt CMpxVideoPlayerAppUiEngine::ViewHistoryDepth() +{ + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::ViewHistoryDepth()")); + + return ( iViewUtility->ViewHistoryDepth() ); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::SendCustomCommandToActiveViewL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::SendCustomCommandToActiveViewL( const TDesC8& aMsg ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::SendCustomCommandToActiveViewL()")); + + User::LeaveIfNull( iAppUi->View() ); + + HBufC8* msgBuf = aMsg.AllocLC(); + + TAny* ptr = (TAny*) msgBuf; + + UserSvr::DllSetTls( KVcxCustomViewMessagePtr, ptr ); + + iAppUi->View()->HandleCommandL( KVcxCustomViewMessageCmd ); + + UserSvr::DllFreeTls( KVcxCustomViewMessagePtr ); + + CleanupStack::PopAndDestroy( msgBuf ); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::ClearPdlInformation() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::ClearPdlInformation() +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::ClearPdlInformation()")); + + if ( iPdlHandler ) + { + iPdlHandler->ClearPdlInformation(); + } +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::StartedStandAlone() +// ------------------------------------------------------------------------------------------------- +// +TBool CMpxVideoPlayerAppUiEngine::ExitToMatrixMenu() +{ + MPX_DEBUG(_L("CMpxVideoPlayerAppUiEngine::ExitToMatrixMenu(%d)"), iExitToMatrixMenu); + return iExitToMatrixMenu; +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::InitializeStreamingLinkL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::InitializeStreamingLinkL( const TDesC& aUri ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::InitializeStreamingLinkL()"), + _L("aUri = %S"), &aUri ); + + SetAccessPointL(); + + iPlaybackUtility->InitStreamingL( aUri, + (TDesC8*)(&KDATATYPEVIDEOHELIX), + iAccessPointId ); + + ActivatePlaybackViewL(); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::InitializeFileL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::InitializeFileL( const TDesC& aFileName ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::InitializeFileL()"), + _L("aFileName = %S"), &aFileName ); + + iPlaybackUtility->InitL( aFileName ); + + ActivatePlaybackViewL(); +} + +// ------------------------------------------------------------------------------------------------- +// CMpxVideoPlayerAppUiEngine::InitializePlaylistL() +// ------------------------------------------------------------------------------------------------- +// +void CMpxVideoPlayerAppUiEngine::InitializePlaylistL( const CMPXCollectionPlaylist& aPlaylist, + TBool aPlay ) +{ + MPX_ENTER_EXIT(_L("CMpxVideoPlayerAppUiEngine::InitializePlaylistL()")); + + iPlaybackUtility->InitL( aPlaylist, aPlay ); + + ActivatePlaybackViewL(); +} + + +// EOF