diff -r 000000000000 -r a2952bb97e68 mpx/playbackframework/playbackengine/src/mpxplaybackinitializer.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/mpx/playbackframework/playbackengine/src/mpxplaybackinitializer.cpp Thu Dec 17 08:55:47 2009 +0200 @@ -0,0 +1,892 @@ +/* +* Copyright (c) 2006 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: Initialize a file before playback +* +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mpxplaybackinitializer.h" +#include "mpxplaybackpluginhandler.h" +#include "mpxplaybackengine.h" +#include "mpxplaybackmediahelper.h" + +const TInt KMPXInitTimer = 3000000; // 3 seconds + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer* NewL +// ---------------------------------------------------------------------------- +// +CMPXPlaybackInitializer* CMPXPlaybackInitializer::NewL( + CMPXPlaybackEngine& aEngine, + CMPXPlaybackMediaHelper& aMediaHelper ) + { + CMPXPlaybackInitializer* self = new (ELeave) + CMPXPlaybackInitializer( aEngine, aMediaHelper ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// ---------------------------------------------------------------------------- +// Constructor +// ---------------------------------------------------------------------------- +// +CMPXPlaybackInitializer::CMPXPlaybackInitializer( + CMPXPlaybackEngine& aEngine, + CMPXPlaybackMediaHelper& aMediaHelper ) + : iState( EPbStateNotInitialised ), + iEngine( aEngine ), + iMediaHelper( aMediaHelper ) + { + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::ConstructL +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::ConstructL() + { + iMedia = CMPXMedia::NewL(); + iTimer = CPeriodic::NewL( CActive::EPriorityIdle ); + } + +// ---------------------------------------------------------------------------- +// Destructor +// ---------------------------------------------------------------------------- +// +CMPXPlaybackInitializer::~CMPXPlaybackInitializer() + { + delete iMedia; + delete iMediaMessage; + Close(); + CancelPreInitTimer(); + delete iTimer; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::Init +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::Init( CMPXCollectionPlaylist& aPlaylist ) + { + MPX_FUNC_EX("CMPXPlaybackInitializer::Init aPlaylist"); + + // Check if we already initialized the song in this playlist, + // if so then do nothing + if ( !IsInitializing( aPlaylist )) + { + Reset(); // clean up all resources (start again) + delete iHandler; + iHandler = NULL; + + // Save the path index and count. This is just in case the + // engine calls InitL() again before we make a call to + // Request media, because these are used to check if we're + // initializing the same song in the IsInitializing() method. + iPathIndex = aPlaylist.Path().Index(); + iInitPlaylistCount = iEngine.iPlaylist->Count(); + } + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::Next +// Advance the playlist and start initializing (return ETrue) or if there's +// no next song, does nothing (return EFalse) +// ---------------------------------------------------------------------------- +// +TBool CMPXPlaybackInitializer::Next() + { + MPX_FUNC("CMPXPlaybackInitializer::Next"); + + ASSERT( iEngine.iPlaylist ); + + TInt nextPlIndex( KErrNotFound ); + TBool playNext( iEngine.iPlaylist->NextIndex( EFalse, nextPlIndex )); + Reset(); // Reset state + + // Only pre-init if there is a next song + if ( playNext ) + { + MPX_DEBUG1("CMPXPlaybackInitializer::Next(): Starting timer"); + iPathIndex = iEngine.iPlaylist->PathIndex( nextPlIndex ); + iInitPlaylistCount = iEngine.iPlaylist->Count(); + CancelPreInitTimer(); + // Start timer + iTimer->Start( + KMPXInitTimer, + KMPXInitTimer, + TCallBack(PreInitTimerCallback, this )); + } + return playNext; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::SetActiveL. Swaps the item being handled in the +// initializer to the engine, which takes over in whatever state it currently +// is in +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::SetActiveL() + { + ASSERT(iEngine.iPlaylist); + MPX_DEBUG3("-->CMPXPlaybackInitializer::SetActiveL state %d, error %d", + iState, iError); + CancelPreInitTimer(); + switch(iState) + { + case EPbStateNotInitialised: + // + // From NewL()/InitL()/NextL()/PreviousL() + // up until the requested media URI is returned. + // Need to swap the playlist only (no plugin has + // yet been resolved + // + { + if (iEngine.iPlaylist) + { + // + // Get the URI from the collection - the callback triggers + // the initialization + // + RequestMediaL(); + UpdateMediaForwarding(); + } + break; + } + + case EPbStateInitialising: + // + // From NewL()/InitL()/NextL()/PreviousL() up + // until the URI has been returned, plug-in is + // being intialized OR an error has been returned + // from playlist + // + { + UpdateMediaForwarding(); + SwapUriL(); + SwapFlag(); + if (iError==KErrNone) + // + // Plug-in must be initialising + // + { + SwapPluginL(); + } + else + { + // + // Hasn't got as far as initialising a plug-in + // + iEngine.HandleCollectionMediaL(*iMedia,iError); + } + break; + } + + case EPbStateStopped: + // + // From NewL()/InitL()/NextL()/PreviousL() up + // until the plug-in has been initialised, either + // successfully or with an error + // + { + UpdateMediaForwarding(); + SwapPluginL(); + SwapUriL(); + SwapFlag(); + if (iError==KErrNone) + { + iEngine.HandlePluginEvent(EPInitialised,iDuration,KErrNone); + } + else + { + iEngine.HandlePluginEvent(EPInitialised,0,iError); + } + break; + } + default: + ASSERT(0) ; + } + MPX_DEBUG1("<--CMPXPlaybackInitializer::SetActiveL"); + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::Close. Resets and destroys all resources owned by +// initializer +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::Close() + { + MPX_FUNC("CMPXPlaybackInitializer::Close"); + CancelPreInitTimer(); + Reset(); // must come after handler deletion + delete iHandler; + iHandler=NULL; + } + +// ---------------------------------------------------------------------------- +// Gets the current item id in use by the initializer +// ---------------------------------------------------------------------------- +// +TMPXItemId CMPXPlaybackInitializer::CurrentInitItemId() + { + TMPXItemId id( KMPXInvalidItemId ); + if( iState != EPbStateNotInitialised && iEngine.iPlaylist ) + { + id = iEngine.iPlaylist->Path().Id(); + } + return id; + } + +// ---------------------------------------------------------------------------- +// Implementation uid of the plugin for pre-initialzer +// ---------------------------------------------------------------------------- +// +TUid CMPXPlaybackInitializer::PluginUid() + { + TUid uid(KNullUid); + if (iHandler) + { + if (iHandler->Plugin()) + { + uid = iHandler->Plugin()->Uid(); + } + } + return uid; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::Reset. Resets such that next media can be initialised +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::Reset() + { + MPX_FUNC("CMPXPlaybackInitializer::Reset"); + // + // Cancel any activity with current plug-in + // + if (iHandler) + { + if (iHandler->Plugin()) + { + TRAP_IGNORE(iHandler->Plugin()->CommandL(EPbCmdStop)); + TRAP_IGNORE(iHandler->Plugin()->CommandL(EPbCmdClose)); + } + } + // + // Reset data associated with previous initialization + // + iState = EPbStateNotInitialised; + iError = KErrNone; + iDuration = 0; + iPathIndex = KErrNotFound; + iInitPlaylistCount = 0; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::RequestMediaL +// Get the Media from the collection - the callback triggers +// the initialization +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::RequestMediaL( ) + { + ASSERT(iEngine.iPlaylist); + + MPX_DEBUG3("-->CMPXPlaybackInitializer::RequestMediaL 0x%08x item index %d", + this, iEngine.iPlaylist->Index()); + // Reset media message + delete iMediaMessage; + iMediaMessage = NULL; + iErrorOfMediaMessage = KErrNone; + + // Setup attribute array + RArray attrs; + CleanupClosePushL(attrs); + attrs.Append(KMPXMediaGeneralId); + attrs.Append(KMPXMediaGeneralUri); + attrs.Append(KMPXMediaGeneralMimeType); + attrs.Append(KMPXMediaGeneralLastPlaybackPosition); + attrs.Append(KMPXMediaGeneralFlags); + attrs.Append(KMPXMediaGeneralDuration); + attrs.Append(KMPXMediaGeneralTitle); + attrs.Append( KMPXMediaMusicArtist ); + + // Create object to hold attributes and specs + CMPXCommand* cmd = CMPXCommand::NewL(); + CleanupStack::PushL( cmd ); + cmd->SetTObjectValueL(KMPXCommandGeneralId, KMPXCommandContentIdMedia); + CBufBase* buf = CBufFlat::NewL( KMPXBufGranularity ); + CleanupStack::PushL( buf ); + + RBufWriteStream writeStream( *buf ); + CleanupClosePushL( writeStream ); + // externalize attributes array + ::ExternalizeL(attrs.Array(), writeStream); + // Close and compress buffer + writeStream.CommitL(); + buf->Compress(); + CleanupStack::PopAndDestroy( &writeStream ); + TPtrC ptr( MPXUser::Ptr( buf->Ptr( 0 ))); + cmd->SetTextValueL( KMPXCommandMediaAttribute, ptr ); + + CMPXAttributeSpecs* attrSpecs( CMPXAttributeSpecs::NewL() ); + CleanupStack::PushL( attrSpecs ); + cmd->SetCObjectValueL( + KMPXCommandMediaAttributeSpecs, attrSpecs ); + CleanupStack::PopAndDestroy( attrSpecs ); + + // Instead of copying the whole path object, which may be large due + // to number of songs in the list, just get the container path and + // append the item ID to that. This saves memory and time. + const CMPXCollectionPath& path( iEngine.iPlaylist->Path() ); + CMPXCollectionPath* initPath( path.ContainerPathL() ); + CleanupStack::PushL( initPath ); + initPath->AppendL( path.IdOfIndex( iPathIndex ) ); + + iMediaHelper.MediaL( *initPath, + cmd, // ownership passed + this ); + CleanupStack::PopAndDestroy( initPath ); + CleanupStack::PopAndDestroy( buf ); + CleanupStack::Pop( cmd ); + CleanupStack::PopAndDestroy( &attrs ); + iMediaRequested = ETrue; + MPX_DEBUG2("<--CMPXPlaybackInitializer::RequestMediaL 0x%08x", this); + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::UpdateMediaForwarding. Updates the forwarding variable +// to send the media to the engine if a media has been requested. +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::UpdateMediaForwarding() + { + MPX_FUNC("CMPXPlaybackInitializer::UpdateMediaForwarding"); + + // Forward the media to the engine if it has been requested. + + // The difference between the iMediaToEngine and iMediaRequested flags, + // is that if the engine calls this method first (through SetActive()), + // but the media has not been requested yet, then we want to make sure + // in that case to not forward the subsequent media requests + iMediaToEngine = iMediaRequested ? ETrue : EFalse; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::SwapPluginL. Swaps the plugin being handled in the +// initializer to the engine, which takes over in whatever state it currently +// is in +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::SwapPluginL() + { + MPX_DEBUG1("==>CMPXPlaybackInitializer::SwapPluginL"); + // unfinished business with old playback plug-in + if (iEngine.iPluginHandler->Plugin()) + { + iEngine.iPluginHandler->Plugin()->CancelRequest(); + } + TInt index( iEngine.iPlaylist->Index() ); + TMPXPlaybackMessage msg( TMPXPlaybackMessage::EStateChanged, + EPbStateInitialising, + index ); + iEngine.SetStateL( msg ); + TRAPD(err, iEngine.DoStopL()); + if (err) + { // play is not available. e.g. power off + MPX_DEBUG2("CMPXPlaybackInitializer::SwapPluginL stop leave %d", err); + iError = err; // save error + } + else + { + if ( iMedia ) + { + iEngine.RestorePlaybackPositionAndStateL( *iMedia ); + } + // + // Set plug-in handler + // + if ( iHandler ) + { + CMPXPlaybackPluginHandler*& h=iEngine.iPluginHandler; + delete h; // delete engine's handler + + // plug-in handler now reports to engine + iHandler->SetObserver(iEngine); + + if (iHandler->Plugin()) + { + iHandler->Plugin()->SetObserver(iEngine); + } + + h=iHandler; // replace engine's handler + iHandler=NULL; // reset handler in initializer + } + + if (iMediaMessage) + { + iEngine.HandlePlaybackMessage(iMediaMessage, iErrorOfMediaMessage); + } + } + MPX_DEBUG1("<==CMPXPlaybackInitializer::SwapPluginL"); + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::SwapUriL. Swaps the item uri in the engine +// Only in the EPbStateInitialising and EPbStateStopped states +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::SwapUriL() + { + // Update the engine's uri to the item that was in the initializer + // + delete iEngine.iUri ; + iEngine.iUri = NULL; + if ( iMedia->IsSupported( KMPXMediaGeneralUri )) + { + iEngine.iUri = iMedia->ValueText(KMPXMediaGeneralUri).AllocL(); + } + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::SwapFlag. Swaps the item db flag in the engine +// Only in the EPbStateInitialising and EPbStateStopped states +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::SwapFlag() + { + // Update the engine's flag to the item that was in the initializer + // + if ( iMedia->IsSupported( KMPXMediaGeneralFlags ) ) + { + iEngine.iDbFlag = iMedia->ValueTObjectL( KMPXMediaGeneralFlags ); + } + else // not supported, reset to 0 + { + iEngine.iDbFlag = 0; + } + + // Also swap item id + if ( iMedia->IsSupported( KMPXMediaGeneralId )) + { + iEngine.iItemId = iMedia->ValueTObjectL( KMPXMediaGeneralId ); + } + else + { + iEngine.iItemId = KMPXInvalidItemId; + } + + // Also swap duration value + if ( iMedia->IsSupported( KMPXMediaGeneralDuration )) + { + iEngine.iMediaDuration = iMedia->ValueTObjectL( KMPXMediaGeneralDuration ); + } + else + { + iEngine.iMediaDuration = 0; + } + iEngine.iAccessPointSet = EFalse; + if ( iMedia->IsSupported(KMPXMediaGeneralExtAccessPoint) ) + { + TInt accessPoint = iMedia->ValueTObjectL( KMPXMediaGeneralExtAccessPoint ); + iEngine.iAccessPoint = accessPoint; + if ( accessPoint ) + { + iEngine.iAccessPointSet = ETrue; + } + } + else + { + iEngine.iAccessPoint = 0; + } + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::IsInitializing +// ---------------------------------------------------------------------------- +// +TBool CMPXPlaybackInitializer::IsInitializing( + const CMPXCollectionPlaylist& aPlaylist) + { + MPX_FUNC("CMPXPlaybackInitializer::IsInitializing aPlaylist"); + TBool ret=ETrue; + + if ( !iEngine.iPlaylist ) + { + ret=EFalse; + } + else if ( iPathIndex != aPlaylist.Path().Index() || + iInitPlaylistCount != aPlaylist.Count() || + aPlaylist.Levels() == 0 ) + { + ret=EFalse; + } + else if ( iHandler ) + // + // Check that PI obeys the same selection criteria as that of the + // engine, else we may have the wrong plug-in + // + { + if (iHandler->Plugin()) + { + TMPXPlaybackPlayerType t1; + TUid u1; + TInt i1; + TPtrC n1; + iHandler->GetSelection(t1,u1,i1,n1); + + TMPXPlaybackPlayerType t2; + TUid u2; + TInt i2; + TPtrC n2; + iEngine.iPluginHandler->GetSelection(t2,u2,i2,n2); + + ret=(t1==t2 && u1==u2 && i1==i2); + } + } + + MPX_DEBUG3("CMPXPlaybackInitializer::IsInitializing plugin=%08x, ret=%d", + iHandler ? iHandler->Plugin() : NULL, ret); + return ret; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::InitL +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::InitL(const CMPXMedia& aMedia,TInt aError) + { + MPX_FUNC("CMPXPlaybackInitializer::InitL(const CMPXMedia& aMedia,TInt aError)"); + iState=EPbStateInitialising; + if (aError==KErrNone) + { + *iMedia = aMedia; // Copy and save media(Uri) from collection + + // + // No error, get the URI + // + const TDesC& uri=aMedia.ValueText(KMPXMediaGeneralUri); + if (uri.Length()) + { + // + // Got the URI, so get a plug-in and go + // + if (!iHandler) + { + iHandler=CMPXPlaybackPluginHandler::NewL(iEngine.iPluginMonitor, + *this, *this); + // arg=plug-in observer + // + // Copy selection criteria + // + TMPXPlaybackPlayerType t; + TUid u; + TInt i; + TPtrC n; + iEngine.iPluginHandler->GetSelection(t,u,i,n); + + if (i!=KErrNotFound) + { + iHandler->SelectSubPlayerL(u,i); + } + else if (u!=KNullUid) + { + iHandler->SelectPlayerL(u); + } + else + { + iHandler->SelectPlayersL(t); + } + } + TInt accessPoint = 0; + if ( aMedia.IsSupported(KMPXMediaGeneralExtAccessPoint) ) + { + accessPoint = aMedia.ValueTObjectL( KMPXMediaGeneralExtAccessPoint ); + MPX_DEBUG2("CMPXPlaybackInitializer::InitL accessPoint %d", accessPoint ); + } + HBufC8* mimeType = + MPXUser::Alloc8L(aMedia.ValueText(KMPXMediaGeneralMimeType)); + CleanupStack::PushL(mimeType); + iHandler->SelectPlayerL(uri,*mimeType); + MPX_DEBUG2("CMPXPlaybackInitializer::InitL plugin=%08x",iHandler->Plugin()); + // Plugin handler guarantee to choose a plugin + // In case there is file open in the audio controller + iHandler->Plugin()->CommandL(EPbCmdClose); + InitL(uri, *mimeType, accessPoint); + CleanupStack::PopAndDestroy(mimeType); + } + else // No URI + { + iError=KErrNotFound; + } + } + else // aError not equal to KErrNone + { + iError=aError; + + // Reset media since if there's an error, the media + // object passed in is unreliable + delete iMedia; + iMedia = NULL; + iMedia = CMPXMedia::NewL(); + } + } + +// ---------------------------------------------------------------------------- +// Cancels the pre-init timer +// ---------------------------------------------------------------------------- +void CMPXPlaybackInitializer::CancelPreInitTimer() + { + MPX_FUNC("CMPXPlaybackInitializer::CancelPreInitTimer()"); + if ( iTimer && iTimer->IsActive() ) + { + MPX_DEBUG1("CMPXPlaybackInitializer::CancelPreInitTimer(): Timer active, cancelling"); + iTimer->Cancel(); + } + } + +// ---------------------------------------------------------------------------- +// Handle pre-init timer callback +// ---------------------------------------------------------------------------- +void CMPXPlaybackInitializer::HandlePreInitTimerCallback() + { + MPX_FUNC("CMPXPlaybackInitializer::HandlePreInitTimerCallback()"); + + CancelPreInitTimer(); + + TRAP_IGNORE(RequestMediaL()); + } + +// ---------------------------------------------------------------------------- +// Callback for pre-init timer. +// ---------------------------------------------------------------------------- +TInt CMPXPlaybackInitializer::PreInitTimerCallback(TAny* aPtr) + { + MPX_FUNC("CMPXPlaybackInitializer::PreInitTimerCallback()"); + + CMPXPlaybackInitializer* ptr = + static_cast(aPtr); + ptr->HandlePreInitTimerCallback(); + + return KErrNone; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::HandlePluginEventL. Must be non leaving since client has +// no context as this is a callback +// ---------------------------------------------------------------------------- + +void CMPXPlaybackInitializer::HandlePluginEvent( + TEvent aEvent,TInt aData,TInt aError) + { + TRAP_IGNORE( HandlePluginEventL( aEvent, aData, aError ) ); + } + +// ---------------------------------------------------------------------------- +// Leaving version of CMPXPlaybackInitializer::HandlePluginEvent +// ---------------------------------------------------------------------------- +void CMPXPlaybackInitializer::HandlePluginEventL( + TEvent aEvent,TInt aData,TInt aError) + { + MPX_DEBUG3("CMPXPlaybackInitializer::HandlePluginEventL %d, error %d", + aEvent, aError); + if (aEvent==EPInitialised) + { + if (aError!=KErrNone) + { + iError=aError; + } + else + { + iDuration=aData; + if ( iMedia->IsSupported( KMPXMediaGeneralDuration )) + { + TInt dur( iMedia->ValueTObjectL( KMPXMediaGeneralDuration )); + if ( dur != iDuration ) + { + // Set duration if it's different than what collection has + if ( iEngine.iPlaylist ) + { + if ( iEngine.iPlaylist->Count() && !iEngine.iPlaylist->EmbeddedPlaylist() ) + { + const CMPXCollectionPath& path( iEngine.iPlaylist->Path() ); + CMPXMedia* media = CMPXMedia::NewL(); + CleanupStack::PushL(media); + media->SetTObjectValueL( KMPXMediaGeneralType, + EMPXItem ); + media->SetTObjectValueL( KMPXMediaGeneralCategory, + EMPXSong ); + media->SetTObjectValueL( KMPXMediaGeneralCollectionId, + path.Id( + CMPXCollectionPath::ECollectionUid )); + media->SetTObjectValueL( + KMPXMediaGeneralId, + iMedia->ValueTObjectL( KMPXMediaGeneralId ) ); + media->SetTObjectValueL( KMPXMediaGeneralDuration, + iDuration ); + iEngine.iPlaylist->SetL( *media ); + CleanupStack::PopAndDestroy( media ); + } + } + } + } + } + iState=EPbStateStopped; + } + } + +// ---------------------------------------------------------------------------- +// Callback from plug-in, handle plugin message +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::HandlePlaybackMessage( + CMPXMessage* aMsg, + TInt aErr) + { + // Save the media update message + TRAP_IGNORE(iMediaMessage = CMPXMessage::NewL(*aMsg)); + iErrorOfMediaMessage = aErr; + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::HandleProperty +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::HandleProperty( + TMPXPlaybackProperty /*aProperty*/, + TInt /*aValue*/, + TInt /*aError*/) + { + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::HandleSubPlayerNames +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::HandleSubPlayerNames( + TUid /*aPlayer*/, + const MDesCArray* /*aSubPlayers*/, + TBool /*aComplete*/, + TInt /*aError*/) + { + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::HandleMedia +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::HandleMedia( + const CMPXMedia& aMedia, + TInt aError) + { + MPX_FUNC("CMPXPlaybackInitializer::HandleMedia()"); + + iMediaRequested = EFalse; + if ( iMediaToEngine ) + { + TRAP_IGNORE( iEngine.HandleCollectionMediaL( aMedia,iError) ); + iMediaToEngine = EFalse; + } + else + { + TRAPD( err, InitL( aMedia,aError )); + if ( err ) + { // Set the error so that not switch to un-initialized plugin + MPX_DEBUG2("CMPXPlaybackInitializer::HandleMedia TRAP InitL %d", + err); + iError = err; // reset error code to new error + } + } + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::HandlePluginHandlerEvent +// Rely on the playback engine to handle the plugin handler events. +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::HandlePluginHandlerEvent( + TPluginHandlerEvents /* aEvent */, + const TUid& /* aPluginUid */, + TBool /* aLoaded */, + TInt /* aData */) + { + } + +// ---------------------------------------------------------------------------- +// CMPXPlaybackInitializer::InitL +// Initialize. +// ---------------------------------------------------------------------------- +// +void CMPXPlaybackInitializer::InitL(const TDesC& aUri, const TDesC8& aType, TInt aAccessPoint) + { + MPX_FUNC("CMPXPlaybackInitializer::InitL"); + CMPXPlaybackPlugin* p = iHandler->Plugin(); + if ( !p ) + { + MPX_DEBUG1("CMPXPlaybackInitializer::InitL(): *** Init failed -- No plugin selected"); + return; + } + + // Check if version2 interface is supported + CDesCArray* interfaces = iHandler->SupportedInterfacesL( p->Uid() ); + TBool version2InterfaceSupported = EFalse; + if (interfaces->MdcaCount()) + { + TInt pos(0); + version2InterfaceSupported = !interfaces->FindIsq(KMPXPlaybackPluginVersion2, pos); + } + delete interfaces; + + if (version2InterfaceSupported) + { + // cast the plugin to use our interface + CMPXPlaybackPluginVersion2* plugin = NULL; + plugin = static_cast(p); + + // if cast was successful, then init streaming with access point + if (plugin) + { + if ( aAccessPoint ) + { + plugin->InitStreamingL( aUri, aType, aAccessPoint ); + } + else + { + plugin->InitialiseL(aUri); + } + } + else + { + MPX_DEBUG1("CMPXPlaybackInitializer::InitL(): *** Init failed -- failure to convert to expected interface"); + } + } + else + { + p->InitialiseL(aUri); + } + } + +// end of file