// 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 <mpxmessagegeneraldefs.h>

#include <mpxplaybackutility.h>

#include <mpxplaybackmessage.h>

#include <mpxplaybackmessagedefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectionplaylist.h>

#include <mpxcollectionpath.h>

#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<TMPXAttribute> 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<TUint32>( state ));

            CompleteSelf( KPlaybackErrNone );

            }

            break;

        case EPlaybackCmdGetObject:

            {

            RequestMediaL();

            }

            break;

        case EPlaybackCmdGetIndex:

            {

            delete iCmdParam;

            iCmdParam = NULL;

            iCmdParam = CMTPPbCmdParam::NewL( static_cast<TUint32>( 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<TMPXMessageId>( KMPXMessageGeneralId ) );

    if ( KMPXMessageGeneral == id )

        {

        TInt event( aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );

        switch ( event )

            {

            case TMPXPlaybackMessage::EPropertyChanged:

                {

                DoHandlePropertyL(

                    aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralType ),

                    aMessage.ValueTObjectL<TInt>( KMPXMessageGeneralData ));

                }

                break;

            case TMPXPlaybackMessage::EStateChanged:

                {

                TMPXPlaybackState state( 

                        aMessage.ValueTObjectL<TMPXPlaybackState>( 

                                KMPXMessageGeneralType ));