diff -r 0aa8cc770c8a -r 4a793f564d72 mtpdataproviders/mtpplaybackcontroldp/mtpplaybackmpximplementation/src/cmtpplaybackcontrolimpl.cpp --- a/mtpdataproviders/mtpplaybackcontroldp/mtpplaybackmpximplementation/src/cmtpplaybackcontrolimpl.cpp Tue Aug 31 16:03:15 2010 +0300 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1097 +0,0 @@ -// Copyright (c) 2010 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: -// - -/** - @file - @internalComponent -*/ - -#include -#include -#include -#include -#include - -#include -#include - -#include "cmtpplaybackcontrolimpl.h" -#include "cmtpplaybackplaylisthelper.h" -#include "cmtpplaybackcommandchecker.h" -#include "cmtpplaybackresumehelper.h" -#include "mtpplaybackcontrolpanic.h" -#include "cmtpplaybackcommand.h" -#include "cmtpplaybackevent.h" - -// Constants -__FLOG_STMT(_LIT8(KComponent,"PlaybackControlImpl");) - -// ======== MEMBER FUNCTIONS ======== - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::NewL -// --------------------------------------------------------------------------- -// -CMTPPlaybackControlImpl* CMTPPlaybackControlImpl::NewL( - MMTPPlaybackObserver& aObserver ) - { - CMTPPlaybackControlImpl* self = new ( ELeave ) - CMTPPlaybackControlImpl( aObserver ); - CleanupStack::PushL( self ); - self->ConstructL(); - CleanupStack::Pop( self ); - return self; - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::Close() -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::Close() - { - delete this; - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::~CMTPPlaybackControlImpl -// --------------------------------------------------------------------------- -// -CMTPPlaybackControlImpl::~CMTPPlaybackControlImpl() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::~CMTPPlaybackControlImpl")); - - if ( iPlaybackUtility ) - { - TRAP_IGNORE( SendMPXPlaybackCommandL( EPbCmdClose, ETrue ) ); - TRAP_IGNORE( iPlaybackUtility->RemoveObserverL( *this ) ); - iPlaybackUtility->Close(); - } - - if ( iNowActivePlaybackUtility ) - { - TRAP_IGNORE( SendMPXPlaybackCommandL( EPbCmdClose, EFalse ) ); - iNowActivePlaybackUtility->Close(); - } - - delete iPlaybackCommandChecker; - delete iPlaybackPlaylistHelper; - delete iPlaybackResumeHelper; - delete iPlayList; - iPrepareCmdArray.Reset(); - iPrepareCmdArray.Close(); - iResumeCmdArray.Reset(); - iResumeCmdArray.Close(); - delete iCmdParam; - - __FLOG(_L8("-CMTPPlaybackControlImpl::~CMTPPlaybackControlImpl")); - __FLOG_CLOSE; - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::CommandL -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::CommandL( CMTPPlaybackCommand& aCmd, MMTPPlaybackCallback* aCallback ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::CommandL")); - __FLOG_1(_L8("The command code is 0x%X"), aCmd.PlaybackCommand() ); - - iCallback = aCallback; - - TRAPD( err, CheckPlaybackCmdAndCacheL( aCmd )); - - if ( KErrNone == err ) - { - UpdateCommandArray(); - DoCommandL(); - } - else - { - CompleteSelf( err ); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::CommandL")); - } - -// --------------------------------------------------------------------------- -// From MMPXPlaybackObserver -// Handle playback message. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::HandlePlaybackMessage( CMPXMessage* aMessage, - TInt aError ) - { - __FLOG_1(_L8("+CMTPPlaybackControlImpl::HandlePlaybackMessage( %d ) "), aError ); - - if (( KErrNone == aError ) && aMessage ) - { - TRAP( aError, DoHandlePlaybackMessageL( *aMessage ) ); - } - - if ( KErrNone != aError ) - { - DoHandleError( MapError( aError )); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::HandlePlaybackMessage")); - } - -// --------------------------------------------------------------------------- -// From MMPXPlaybackCallback -// Handle playback property. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::HandlePropertyL( TMPXPlaybackProperty aProperty, - TInt aValue, TInt aError ) - { - __FLOG_VA((_L8("+CMTPPlaybackControlImpl::HandlePropertyL( aProperty = 0x%X, aValue = 0x%X, aError = %d ) "), aProperty, aValue, aError )); - - if ( KErrNone == aError ) - { - TRAP( aError, DoHandlePropertyL( aProperty, aValue )); - } - - if ( KErrNone != aError ) - { - DoHandleError( MapError( aError ) ); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::HandlePropertyL")); - } - -// --------------------------------------------------------------------------- -// From MMPXPlaybackCallback -// Method is called continously until aComplete=ETrue, signifying that -// it is done and there will be no more callbacks -// Only new items are passed each time -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::HandleSubPlayerNamesL( - TUid /* aPlayer */, - const MDesCArray* /* aSubPlayers */, - TBool /* aComplete */, - TInt /* aError */ ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::HandleSubPlayerNamesL")); - __FLOG(_L8("-CMTPPlaybackControlImpl::HandleSubPlayerNamesL")); - } - -// --------------------------------------------------------------------------- -// From MMPXPlaybackCallback -// Handle media -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::HandleMediaL( const CMPXMedia& aMedia, - TInt aError ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::HandleMediaL")); - - if (( KErrNone == aError ) && ( aMedia.IsSupported( KMPXMediaGeneralUri ))) - { - TRAP( aError, DoHandleMediaL( aMedia )); - } - - if ( KErrNone != aError ) - { - DoHandleError( MapError( aError )); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::HandleMediaL")); - } - -// --------------------------------------------------------------------------- -// From CActive -// CMTPPlaybackControlImpl::DoCancel() -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoCancel() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DoCancel")); - __FLOG(_L8("-CMTPPlaybackControlImpl::DoCancel")); - } - -// --------------------------------------------------------------------------- -// From CActive -// CMTPPlaybackControlImpl::RunL() -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::RunL() - { - __FLOG(_L8("+CMTPBTConnection::RunL")); - - if ( KPlaybackErrNone == iStatus.Int() ) - { - TRAPD( error, SendPlaybackCommandCompleteL()); - if ( error != KErrNone ) - { - DoHandleError( MapError( error ) ); - } - } - else - { - DoHandleError( iStatus.Int()); - } - - __FLOG(_L8("-CMTPBTConnection::RunL")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::CMTPPlaybackControlImpl -// --------------------------------------------------------------------------- -// -CMTPPlaybackControlImpl::CMTPPlaybackControlImpl( - MMTPPlaybackObserver& aObserver ) - : CActive( EPriorityStandard ), - iObserver( &aObserver ) - { - CActiveScheduler::Add( this ); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::ConstructL -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::ConstructL() - { - __FLOG_OPEN(KMTPSubsystem, KComponent); - __FLOG(_L8("+CMTPPlaybackControlImpl::ConstructL")); - - iPlaybackUtility = MMPXPlaybackUtility::NewL( KMTPPlaybackControlDpUid, this ); - iNowActivePlaybackUtility = MMPXPlaybackUtility::NewL( KPbModeActivePlayer ); - - iPlaybackCommandChecker = CMTPPlaybackCommandChecker::NewL( *this ); - iPlaybackPlaylistHelper = CMTPPlaybackPlaylistHelper::NewL( *this ); - iPlaybackResumeHelper = CMTPPlaybackResumeHelper::NewL( *this ); - - __FLOG(_L8("-CMTPPlaybackControlImpl::ConstructL")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::GetPlaylistFromCollectionCompleteL -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::GetPlaylistFromCollectionCompleteL( const CMPXCollectionPlaylist& aPlaylist ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::GetPlaylistFromCollectionCompleteL ")); - - CMPXCollectionPlaylist* tmp = - CMPXCollectionPlaylist::NewL( aPlaylist ); - CleanupStack::PushL( tmp ); - tmp->SetEmbeddedPlaylist( ETrue ); - tmp->SetRepeatEnabled( EFalse ); - tmp->SetShuffleEnabledL( EFalse ); - iPlaybackUtility->InitL( *tmp, ETrue ); - CleanupStack::PopAndDestroy( tmp ); - - __FLOG(_L8("-CMTPPlaybackControlImpl::HandlePlaybackGetPlaylistCompleteL")); - } - -// ---------------------------------------------------- -// CMTPPlaybackControlImpl::DeActiveOtherPlayerL -// ---------------------------------------------------- -// -void CMTPPlaybackControlImpl::DeActiveOtherPlayerL() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DeActiveOtherPlayerL()")); - - if ( iNowActivePlaybackUtility->StateL() != iPlaybackUtility->StateL()) - { - SendMPXPlaybackCommandL( EPbCmdPause, EFalse ); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DeActiveOtherPlayerL()")); - } - -// ---------------------------------------------------- -// CMTPPlaybackControlImpl::CheckPlaybackCmdAndCacheL -// ---------------------------------------------------- -// -void CMTPPlaybackControlImpl::CheckPlaybackCmdAndCacheL( CMTPPlaybackCommand& aCmd ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::CheckPlaybackCmdAndCacheL")); - - iPlaybackCommandChecker->CheckPlaybackCommandContextL( aCmd.PlaybackCommand()); - iPlaybackCommandChecker->CheckAndUpdatePlaybackParamL( aCmd, &iCmdParam ); - - __FLOG(_L8("-CMTPPlaybackControlImpl::CheckPlaybackCmdAndCacheL")); - } - -// ---------------------------------------------------- -// CMTPPlaybackControlImpl::UpdateCommandArrayL -// ---------------------------------------------------- -// -void CMTPPlaybackControlImpl::UpdateCommandArray() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::UpdateCommandArrayL")); - - iPlaybackResumeHelper->UpdatePrepareCmdArray( iMTPPBCmd, iPrepareCmdArray ); - iPlaybackResumeHelper->UpdateResumeCmdArray( iMTPPBCmd, iResumeCmdArray ); - - __FLOG(_L8("-CMTPPlaybackControlImpl::UpdateCommandArrayL")); - } - -// ---------------------------------------------------- -// CMTPPlaybackControlImpl::RequestMediaL -// ---------------------------------------------------- -// -void CMTPPlaybackControlImpl::RequestMediaL() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::RequestMediaL")); - - if ( iPlayList ) - { - delete iCmdParam; - iCmdParam = NULL; - iCmdParam = CMTPPbCmdParam::NewL( iPlaybackPlaylistHelper->MTPPbCategory(), - iPlaybackPlaylistHelper->MTPPbSuid()); - CompleteSelf( KPlaybackErrNone ); - } - else if ( iPlaybackUtility->Source() ) - { - //Album or Playlist - iPlayList = iPlaybackUtility->Source()->PlaylistL(); - - if ( iPlayList ) - { - TMTPPbDataSuid suid( EMTPPbCatNone, KNullDesC ); - suid = iPlaybackPlaylistHelper->GetMTPPBSuidFromCollectionL( *iPlayList ); - delete iCmdParam; - iCmdParam = NULL; - iCmdParam = CMTPPbCmdParam::NewL( suid.Category(), suid.Suid()); - CompleteSelf( KPlaybackErrNone ); - } - else - { - //Single Song - RArray attrs; - CleanupClosePushL(attrs); - attrs.Append( KMPXMediaGeneralUri ); - iPlaybackUtility->Source()->MediaL( attrs.Array(), *this ); - CleanupStack::PopAndDestroy( &attrs ); - } - } - else - { - //Not initialized - CompleteSelf( KPlaybackErrContextInvalid ); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::RequestMediaL")); - } - -// ---------------------------------------------------- -// CMTPPlaybackControlImpl::DoCommandL -// ---------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoCommandL() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DoCommandL")); - - if ( iPrepareCmdArray.Count() != 0 ) - { - InitiateMPXPlaybackCommandL( iPrepareCmdArray[0].iMPXCommand, ETrue ); - return; - } - - switch ( iMTPPBCmd ) - { - case EPlaybackCmdInitObject: - { - const TMTPPbCategory category = iCmdParam->SuidSetL().Category(); - if ( EMTPPbCatMusic == category ) - { - iPlaybackUtility->InitL( iCmdParam->SuidSetL().Suid() ); - } - else - { - iPlaybackPlaylistHelper->GetPlayListFromCollectionL( iCmdParam->SuidSetL() ); - } - } - break; - case EPlaybackCmdInitIndex: - { - iPlaybackPlaylistHelper->GetPlayListFromCollectionL( iCmdParam->Uint32L() ); - } - break; - case EPlaybackCmdStop: - { - delete iPlayList; - iPlayList = NULL; - SendMPXPlaybackCommandL( EPbCmdClose, ETrue ); - CompleteSelf( KPlaybackErrNone ); - } - break; - case EPlaybackCmdSkip: - { - iPlaybackPlaylistHelper->GetPlayListFromCollectionL( iCmdParam->Int32L() ); - } - break; - case EPlaybackCmdSetVolume: - { - iPlaybackUtility->SetL( EPbPropertyVolume, iCmdParam->Uint32L() ); - } - break; - case EPlaybackCmdSetPosition: - { - iPlaybackUtility->PropertyL(*this, EPbPropertyDuration); - } - break; - case EPlaybackCmdGetPosition: - { - iPlaybackUtility->PropertyL(*this, EPbPropertyPosition); - } - break; - case EPlaybackCmdGetVolumeSet: - case EPlaybackCmdGetVolume: - { - iPlaybackUtility->PropertyL(*this, EPbPropertyVolume); - } - break; - case EPlaybackCmdGetState: - { - delete iCmdParam; - iCmdParam = NULL; - TMTPPlaybackState state = MapState( CurrentState()); - iCmdParam = CMTPPbCmdParam::NewL( static_cast( state )); - CompleteSelf( KPlaybackErrNone ); - } - break; - case EPlaybackCmdGetObject: - { - RequestMediaL(); - } - break; - case EPlaybackCmdGetIndex: - { - delete iCmdParam; - iCmdParam = NULL; - iCmdParam = CMTPPbCmdParam::NewL( static_cast( SongIndex())); - CompleteSelf( KPlaybackErrNone ); - } - break; - default: - { - if ( iResumeCmdArray.Count() != 0 ) - { - InitiateMPXPlaybackCommandL( iResumeCmdArray[0].iMPXCommand, ETrue ); - } - else - { - CompleteSelf( KPlaybackErrNone ); - } - } - break; - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoCommandL")); - } - -// ---------------------------------------------------- -// CMTPPlaybackControlImpl::DoHandlePlaybackMessageL -// ---------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandlePlaybackMessageL( const CMPXMessage& aMessage ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DoHandlePlaybackMessageL")); - - TMPXMessageId id( - aMessage.ValueTObjectL( KMPXMessageGeneralId ) ); - - if ( KMPXMessageGeneral == id ) - { - TInt event( aMessage.ValueTObjectL( KMPXMessageGeneralEvent ) ); - - switch ( event ) - { - case TMPXPlaybackMessage::EPropertyChanged: - { - DoHandlePropertyL( - aMessage.ValueTObjectL( KMPXMessageGeneralType ), - aMessage.ValueTObjectL( KMPXMessageGeneralData )); - } - break; - case TMPXPlaybackMessage::EStateChanged: - { - TMPXPlaybackState state( - aMessage.ValueTObjectL( - KMPXMessageGeneralType )); - DoHandleStateChangedL( state ); - } - break; - case TMPXPlaybackMessage::EInitializeComplete: - { - DoHandleInitializeCompleteL(); - } - break; - case TMPXPlaybackMessage::EMediaChanged: - { - DoHandleMediaChangedL(); - } - break; - default: - __FLOG_VA((_L8("DoHandlePlaybackMessageL( TMPXPlaybackMessage event = 0x%X ) "), event )); - break; - } - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoHandlePlaybackMessageL")); - } - - -// --------------------------------------------------------------------------- -// Handle playback property. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandlePropertyL( TInt aProperty, TInt aValue ) - { - __FLOG_VA((_L8("+CMTPPlaybackControlImpl::DoHandlePropertyL( aProperty = 0x%X, aValue = 0x%X ) "), aProperty, aValue )); - - switch ( aProperty ) - { - case EPbPropertyPosition: - { - if ( EPlaybackCmdGetPosition == MTPPBCmdHandling()) - { - delete iCmdParam; - iCmdParam = NULL; - iCmdParam = CMTPPbCmdParam::NewL(static_cast(aValue)); - SendPlaybackCommandCompleteL(); - } - else if ( EPlaybackCmdSetPosition == MTPPBCmdHandling() ) - { - if ( aValue == iCmdParam->Uint32L() ) - { - SendPlaybackCommandCompleteL(); - } - } - } - break; - case EPbPropertyMute: - { - SendPlaybackEventL( EPlaybackEventVolumeUpdate ); - } - break; - case EPbPropertyVolume: - { - switch ( MTPPBCmdHandling() ) - { - case EPlaybackCmdSetVolume: - { - SendPlaybackCommandCompleteL(); - } - break; - case EPlaybackCmdGetVolumeSet: - { - delete iCmdParam; - iCmdParam = NULL; - TMTPPbDataVolume volumeSet( KPbPlaybackVolumeLevelMax, - KPbPlaybackVolumeLevelMin, - KMPXPlaybackDefaultVolume, - aValue, - KMTPPlaybackVolumeStep ); - iCmdParam = CMTPPbCmdParam::NewL( volumeSet ); - SendPlaybackCommandCompleteL(); - } - break; - case EPlaybackCmdGetVolume: - { - delete iCmdParam; - iCmdParam = NULL; - iCmdParam = CMTPPbCmdParam::NewL(static_cast( aValue )); - SendPlaybackCommandCompleteL(); - } - break; - default: - { - SendPlaybackEventL( EPlaybackEventVolumeUpdate ); - } - break; - } - } - break; - case EPbPropertyDuration: - { - if ( EPlaybackCmdSetPosition == MTPPBCmdHandling()) - { - if ( iCmdParam->Uint32L() < aValue ) - { - iPlaybackUtility->SetL( EPbPropertyPosition, iCmdParam->Uint32L() ); - } - else - { - DoHandleError( KPlaybackErrParamInvalid ); - } - } - } - break; - default: - break; - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoHandlePropertyL")); - } - -// --------------------------------------------------------------------------- -// Handle playback state changed. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandleStateChangedL( TMPXPlaybackState aState ) - { - __FLOG_VA((_L8("+CMTPPlaybackControlImpl::DoHandleStateChangedL( aState = 0x%X ) "), aState )); - - if (( iPrepareCmdArray.Count() != 0 ) && ( iPrepareCmdArray[0].iMPXExpectState == aState )) - { - iPrepareCmdArray.Remove( 0 ); - DoCommandL(); - } - else if (( iResumeCmdArray.Count() != 0 ) && ( iResumeCmdArray[0].iMPXExpectState == aState )) - { - iResumeCmdArray.Remove( 0 ); - SendPlaybackCommandCompleteL(); - } - else if (( iState != aState ) && ( MapState( aState )!= MapState( iState ) )) - { - SendPlaybackEventL( EPlaybackEventStateUpdate ); - } - - if ( iState != aState ) - { - iPreState = iState; - iState = aState; - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoHandleStateChangedL")); - } - -// --------------------------------------------------------------------------- -// DoHandleMediaL. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandleMediaL( const CMPXMedia& aMedia ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DoHandleMediaL")); - - TFileName filePath(aMedia.ValueText(KMPXMediaGeneralUri) ); - delete iCmdParam; - iCmdParam = NULL; - iCmdParam = CMTPPbCmdParam::NewL( EMTPPbCatMusic, filePath ); - SendPlaybackCommandCompleteL(); - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoHandleMediaL")); - } - -// --------------------------------------------------------------------------- -// Handle media changed. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandleMediaChangedL() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DoHandleMediaChangedL")); - - if (( EPbStateNotInitialised == iState ) || ( EPbStateInitialising == iState )) - { - if (( MTPPBCmdHandling() != EPlaybackCmdInitObject ) - && ( MTPPBCmdHandling() != EPlaybackCmdInitIndex ) - && ( MTPPBCmdHandling() != EPlaybackCmdSkip )) - { - //should send an event - MMPXSource* source = iPlaybackUtility->Source(); - CMPXCollectionPlaylist* playlist = source->PlaylistL(); - if (( playlist != NULL ) && ( iPlayList != NULL )) - { - CleanupStack::PushL( playlist ); - //New media is a playlist or album - TInt level = playlist->Path().Levels(); - if ( IfEqual(iPlayList->Path(), playlist->Path(), level-1 ) && !IfEqual(iPlayList->Path(), playlist->Path(), level )) - { - SendPlaybackEventL( EPlaybackEventObjectIndexUpdate ); - - CleanupStack::Pop( playlist ); - delete iPlayList; - iPlayList = playlist; - } - else - { - SendPlaybackEventL( EPlaybackEventObjectUpdate ); - SendPlaybackEventL( EPlaybackEventObjectIndexUpdate ); - - CleanupStack::PopAndDestroy( playlist ); - delete iPlayList; - iPlayList = NULL; - } - } - else - { - //New media is a single song - SendPlaybackEventL( EPlaybackEventObjectUpdate ); - - delete iPlayList; - iPlayList = NULL; - } - } - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoHandleMediaChangedL")); - } - -// --------------------------------------------------------------------------- -// Handle Initialize complete. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandleInitializeCompleteL() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::DoHandleInitializeCompleteL")); - - if ( EPlaybackCmdInitObject == MTPPBCmdHandling() - || EPlaybackCmdInitIndex == MTPPBCmdHandling() - || EPlaybackCmdSkip == MTPPBCmdHandling()) - { - delete iPlayList; - iPlayList = NULL; - - MMPXSource* source = iPlaybackUtility->Source(); - if ( source ) - { - iPlayList = source->PlaylistL(); - SendPlaybackCommandCompleteL(); - } - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::DoHandleInitializeCompleteL")); - } - -// --------------------------------------------------------------------------- -// Handle error. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::DoHandleError( TInt aErr ) - { - if ( aErr != KPlaybackErrNone ) - { - if ( iCallback ) - { - TRAP_IGNORE( iCallback->HandlePlaybackCommandCompleteL( NULL, aErr )); - ResetPlaybackCommand(); - } - else - { - TRAP_IGNORE( iObserver->HandlePlaybackEventL( NULL, aErr )); - } - } - } - -// --------------------------------------------------------------------------- -// Compare two path according to level. -// --------------------------------------------------------------------------- -// -TBool CMTPPlaybackControlImpl::IfEqual( const CMPXCollectionPath& aPathBase, const CMPXCollectionPath& aPathNew, TUint aLevel ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::IfEqual")); - - if (( aPathBase.Levels() < aLevel ) || ( aPathNew.Levels() < aLevel )) - { - return EFalse; - } - for ( TInt i = 0; i < aLevel; i++ ) - { - if ( aPathBase.Index( i ) != aPathNew.Index( i ) ) - { - return EFalse; - } - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::IfEqual")); - return ETrue; - } - -// --------------------------------------------------------------------------- -// Map states from TMPXPlaybackState to TMTPPlaybackState -// --------------------------------------------------------------------------- -// -TMTPPlaybackState CMTPPlaybackControlImpl::MapState( TMPXPlaybackState aState ) - { - __FLOG_VA((_L8("+CMTPPlaybackControlImpl::MapState( aState = 0x%X ) "), aState )); - - TMTPPlaybackState state = EPlayStateError; - - switch ( aState ) - { - case EPbStatePlaying: - { - state = EPlayStatePlaying; - } - break; - case EPbStatePaused: - case EPbStateInitialising: - case EPbStateInitialised: - case EPbStateNotInitialised: - case EPbStateStopped: - { - state = EPlayStatePaused; - } - break; - case EPbStateSeekingForward: - { - state = EPlayStateForwardSeeking; - } - break; - case EPbStateSeekingBackward: - { - state = EPlayStateBackwardSeeking; - } - break; - default: - break; - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::MapState")); - return state; - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::MapError. -// --------------------------------------------------------------------------- -// -TInt CMTPPlaybackControlImpl::MapError( TInt aError ) - { - TInt err( KPlaybackErrNone ); - - if ( KErrHardwareNotAvailable == aError ) - { - err = KPlaybackErrDeviceUnavailable; - } - else if ( KErrArgument == aError ) - { - err = KPlaybackErrParamInvalid; - } - else - { - err = KPlaybackErrDeviceBusy; - } - return err; - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::CompleteSelf. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::CompleteSelf( TInt aCompletionCode ) - { - __FLOG_1(_L8("+CMTPPlaybackControlImpl::CompleteSelf( %d )"), aCompletionCode ); - - SetActive(); - TRequestStatus* status = &iStatus; - User::RequestComplete( status, aCompletionCode ); - - __FLOG(_L8("-CMTPPlaybackControlImpl::CompleteSelf")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::InitiateMPXPlaybackCommandL. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::InitiateMPXPlaybackCommandL( TMPXPlaybackCommand aCommand, TBool aIsMTPPlaybackUtility ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::InitiateMPXPlaybackCommandL")); - - switch ( aCommand ) - { - case EPbCmdPlay: - { - DeActiveOtherPlayerL(); - SendMPXPlaybackCommandL( EPbCmdPlay, aIsMTPPlaybackUtility ); - } - break; - case EPbCmdPlayPause: - { - DeActiveOtherPlayerL(); - SendMPXPlaybackCommandL( EPbCmdPlayPause, aIsMTPPlaybackUtility ); - } - break; - default: - { - SendMPXPlaybackCommandL( aCommand, aIsMTPPlaybackUtility ); - } - break; - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::InitiateMPXPlaybackCommandL")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::SendMPXPlaybackCommandL. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::SendMPXPlaybackCommandL( TMPXPlaybackCommand aCommand, TBool aIsMTPPlaybackUtility ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::SendPlaybackCommandL")); - - CMPXCommand* cmd( CMPXCommand::NewL() ); - CleanupStack::PushL( cmd ); - cmd->SetTObjectValueL( KMPXCommandGeneralId, KMPXCommandIdPlaybackGeneral ); - cmd->SetTObjectValueL( KMPXCommandGeneralDoSync, ETrue ); - cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralType, aCommand ); - cmd->SetTObjectValueL( KMPXCommandPlaybackGeneralData, 0 ); - - if ( aIsMTPPlaybackUtility ) - { - iPlaybackUtility->CommandL( *cmd, this ); - } - else - { - iNowActivePlaybackUtility->CommandL( *cmd ); - } - - CleanupStack::PopAndDestroy( cmd ); - - __FLOG(_L8("-CMTPPlaybackControlImpl::SendPlaybackCommandL")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::SendPlaybackCommandCompleteL. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::SendPlaybackCommandCompleteL() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::SendPlaybackCommandCompleteL")); - - __ASSERT_DEBUG( iCallback, Panic( EMTPPBCallbackInvalid )); - __ASSERT_DEBUG(( iMTPPBCmd > EPlaybackCmdNone ) && ( iMTPPBCmd < EPlaybackCmdEnd ), Panic( EMTPPBCallbackInvalid )); - - if ( iResumeCmdArray.Count() != 0 ) - { - InitiateMPXPlaybackCommandL( iResumeCmdArray[0].iMPXCommand, ETrue ); - } - else - { - CMTPPlaybackCommand* cmd = CMTPPlaybackCommand::NewL( iMTPPBCmd, iCmdParam ); - iCmdParam = NULL;//Ownership is handled to CMTPPlaybackCommand - CleanupStack::PushL(cmd); - iCallback->HandlePlaybackCommandCompleteL( cmd ); - CleanupStack::PopAndDestroy(cmd); - - ResetPlaybackCommand(); - } - - __FLOG(_L8("-CMTPPlaybackControlImpl::SendPlaybackCommandCompleteL")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::SendPlaybackEventL. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::SendPlaybackEventL( TMTPPlaybackEvent aEvt ) - { - __FLOG(_L8("+CMTPPlaybackControlImpl::SendPlaybackEventL")); - - CMTPPlaybackEvent* event = CMTPPlaybackEvent::NewL( aEvt, NULL ); - CleanupStack::PushL(event); - iObserver->HandlePlaybackEventL( event ); - CleanupStack::PopAndDestroy(event); - - __FLOG(_L8("-CMTPPlaybackControlImpl::SendPlaybackEventL")); - } - -// --------------------------------------------------------------------------- -// CMTPPlaybackControlImpl::ResetPlaybackCommand. -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::ResetPlaybackCommand() - { - __FLOG(_L8("+CMTPPlaybackControlImpl::ResetPlaybackCommand")); - - iCallback = NULL; - iMTPPBCmd = EPlaybackCmdNone; - iPrepareCmdArray.Reset(); - iResumeCmdArray.Reset(); - delete iCmdParam; - iCmdParam = NULL; - - __FLOG(_L8("-CMTPPlaybackControlImpl::ResetPlaybackCommand")); - } - -// --------------------------------------------------------------------------- -// Return current state -// --------------------------------------------------------------------------- -// -TMPXPlaybackState CMTPPlaybackControlImpl::CurrentState() const - { - return iState; - } - -// --------------------------------------------------------------------------- -// Return previous state -// --------------------------------------------------------------------------- -// -TMPXPlaybackState CMTPPlaybackControlImpl::PreviousState() const - { - return iPreState; - } - -// --------------------------------------------------------------------------- -// Return song count -// --------------------------------------------------------------------------- -// -TInt32 CMTPPlaybackControlImpl::SongCount() const - { - TInt32 songCount = -1; - if ( iPlayList ) - { - songCount = iPlayList->Count(); - } - return songCount; - } - -// --------------------------------------------------------------------------- -// Return song index -// --------------------------------------------------------------------------- -// -TInt32 CMTPPlaybackControlImpl::SongIndex() const - { - TInt32 songIndex = -1; - if ( iPlayList ) - { - TInt level = iPlayList->Path().Levels(); - songIndex = iPlayList->Path().Index( level-1 ); - } - return songIndex; - } - -// --------------------------------------------------------------------------- -// Set mtp playback command -// --------------------------------------------------------------------------- -// -void CMTPPlaybackControlImpl::SetMTPPBCmd( TMTPPlaybackCommand aMTPPBCmd ) - { - iMTPPBCmd = aMTPPBCmd; - } - -// --------------------------------------------------------------------------- -// Return mtp playback command which is handling -// --------------------------------------------------------------------------- -// -TMTPPlaybackCommand CMTPPlaybackControlImpl::MTPPBCmdHandling() const - { - if ( iPrepareCmdArray.Count() == 0 ) - { - return iMTPPBCmd; - } - else - { - return EPlaybackCmdNone; - } - - } -