// 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 "cmtpplaybackresumehelper.h"

#include "cmtpplaybackcommand.h"

#include "cmtpplaybackcontrolimpl.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtpplaybackresumehelperTraces.h"

#endif

// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::NewL

// ---------------------------------------------------------------------------

//

CMTPPlaybackResumeHelper* CMTPPlaybackResumeHelper::NewL(

            CMTPPlaybackControlImpl& aControlImpl )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_NEWL_ENTRY );

    CMTPPlaybackResumeHelper* self = new ( ELeave ) 

                        CMTPPlaybackResumeHelper( aControlImpl );

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_NEWL_EXIT );

    return self;

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::~CMTPPlaybackResumeHelper

// ---------------------------------------------------------------------------

//

CMTPPlaybackResumeHelper::~CMTPPlaybackResumeHelper()

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_CMTPPLAYBACKRESUMEHELPER_ENTRY );

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_CMTPPLAYBACKRESUMEHELPER_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::UpdatePrepareCmdArrayL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::UpdatePrepareCmdArray( TMTPPlaybackCommand aMTPPPBCmd, 

        RResumeCmdArray& aMTPPBMPXCmd )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_UPDATEPREPARECMDARRAY_ENTRY );

    aMTPPBMPXCmd.Reset();

    iIfParepareArray = ETrue;

    switch ( aMTPPPBCmd )

        {

        case EPlaybackCmdSetPosition:

            {

            HandlePlaybackCmdSetPosition( aMTPPBMPXCmd );

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_UPDATEPREPARECMDARRAY_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::UpdateResumeCmdArrayL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::UpdateResumeCmdArray( TMTPPlaybackCommand aMTPPPBCmd, 

        RResumeCmdArray& aMTPPBMPXCmd)

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_UPDATERESUMECMDARRAY_ENTRY );

    aMTPPBMPXCmd.Reset();

    iIfParepareArray = EFalse;

    switch ( aMTPPPBCmd )

        {

        case EPlaybackCmdInitObject:

            {

            HandlePlaybackCmdInitObject( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdInitIndex:

            {

            HandlePlaybackCmdInitIndex( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdPlay:

            {

            HandlePlaybackCmdPlay( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdPause:

            {

            HandlePlaybackCmdPause( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdSkip:

            {

            HandlePlaybackCmdSkip( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdSeekForward:

            {

            HandlePlaybackCmdSeekForward( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdSeekBackward:

            {

            HandlePlaybackCmdSeekBackward( aMTPPBMPXCmd );

            }

            break;

        case EPlaybackCmdSetPosition:

            {

            HandlePlaybackCmdSetPosition( aMTPPBMPXCmd );

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_UPDATERESUMECMDARRAY_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::CMTPPlaybackResumeHelper

// ---------------------------------------------------------------------------

//

CMTPPlaybackResumeHelper::CMTPPlaybackResumeHelper( 

        CMTPPlaybackControlImpl& aControlImpl )

                : iMTPPlaybackControl( aControlImpl )

    {

    OstTraceFunctionEntry0( DUP1_CMTPPLAYBACKRESUMEHELPER_CMTPPLAYBACKRESUMEHELPER_ENTRY );

    OstTraceFunctionExit0( DUP1_CMTPPLAYBACKRESUMEHELPER_CMTPPLAYBACKRESUMEHELPER_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdInitObjectL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdInitObject( RResumeCmdArray& aMTPPBMPXCmdArray )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDINITOBJECT_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

            {

            TMPXComandElement command = { EPbCmdPlay, EPbStatePlaying };

            aMTPPBMPXCmdArray.Append( command );

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDINITOBJECT_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdInitObjectL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdInitIndex( RResumeCmdArray& aMTPPBMPXCmdArray )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDINITINDEX_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

            {

            TMPXComandElement command = { EPbCmdPlay, EPbStatePlaying };

            aMTPPBMPXCmdArray.Append( command );

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDINITINDEX_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdPlayL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdPlay(RResumeCmdArray& aMTPPBMPXCmdArray )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDPLAY_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePaused:

        case EPbStateStopped:

        case EPbStateInitialised:

            {

            TMPXComandElement command = { EPbCmdPlay, EPbStatePlaying };

            aMTPPBMPXCmdArray.Append( command );

            }

            break;

        case EPbStateSeekingBackward:

        case EPbStateSeekingForward:

            {

            if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePlaying )

                {

                TMPXComandElement tmp = { EPbCmdStopSeeking, EPbStatePlaying };

                aMTPPBMPXCmdArray.Append( tmp );

                }

            else if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePaused )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePaused };

                aMTPPBMPXCmdArray.Append( command );

                TMPXComandElement command1 = { EPbCmdPlay, EPbStatePlaying };

                aMTPPBMPXCmdArray.Append( command1 );

                }

            }

            break;

         default:

            break;

         }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDPLAY_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdPauseL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdPause( RResumeCmdArray& aMTPPBMPXCmdArray )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDPAUSE_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

            {

            TMPXComandElement command = { EPbCmdPlayPause, EPbStatePaused };

            aMTPPBMPXCmdArray.Append( command );

            }

            break;

        case EPbStateSeekingBackward:

        case EPbStateSeekingForward:

            {

            if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePaused )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePaused };

                aMTPPBMPXCmdArray.Append( command );

                }

            else if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePlaying )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePlaying };

                aMTPPBMPXCmdArray.Append( command );

                TMPXComandElement command1 = { EPbCmdPlayPause, EPbStatePaused };

                aMTPPBMPXCmdArray.Append( command1 );

                }

            }

           break;

        default:

           break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDPAUSE_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdSeekForwardL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdSeekForward( RResumeCmdArray& aMTPPBMPXCmd )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSEEKFORWARD_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

        case EPbStatePaused:

            {

            TMPXComandElement command = { EPbCmdStartSeekForward, EPbStateSeekingForward };

            aMTPPBMPXCmd.Append( command );

            }

            break;

        case EPbStateInitialised:

            {

            TMPXComandElement command = { EPbCmdPlay, EPbStatePlaying };

            aMTPPBMPXCmd.Append( command );

            TMPXComandElement command1 = { EPbCmdStartSeekForward, EPbStateSeekingForward };

            aMTPPBMPXCmd.Append( command1 );

            }

            break;

        case EPbStateSeekingBackward:

            {

            if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePaused )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePaused };

                aMTPPBMPXCmd.Append( command );

                TMPXComandElement command1 = { EPbCmdStartSeekForward, EPbStateSeekingForward };

                aMTPPBMPXCmd.Append( command1 );

                }

            else if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePlaying )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePlaying };

                aMTPPBMPXCmd.Append( command );

                TMPXComandElement command1 = { EPbCmdStartSeekForward, EPbStateSeekingForward };

                aMTPPBMPXCmd.Append( command1 );

                }

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSEEKFORWARD_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdSeekBackwardL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdSeekBackward( RResumeCmdArray& aMTPPBMPXCmd )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSEEKBACKWARD_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

        case EPbStatePaused:

            {

            TMPXComandElement command = { EPbCmdStartSeekBackward, EPbStateSeekingBackward };

            aMTPPBMPXCmd.Append( command );

            }

            break;

        case EPbStateSeekingForward:

            {

            if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePaused )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePaused };

                aMTPPBMPXCmd.Append( command );

                TMPXComandElement command1 = { EPbCmdStartSeekBackward, EPbStateSeekingBackward };

                aMTPPBMPXCmd.Append( command1 );

                }

            else if ( MTPPlaybackControlImpl().PreviousState() == EPbStatePlaying )

                {

                TMPXComandElement command = { EPbCmdStopSeeking, EPbStatePlaying };

                aMTPPBMPXCmd.Append( command );

                TMPXComandElement command1 = { EPbCmdStartSeekBackward, EPbStateSeekingBackward };

                aMTPPBMPXCmd.Append( command1 );

                }

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSEEKBACKWARD_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdSkipL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdSkip( RResumeCmdArray& aMTPPBMPXCmd )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSKIP_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

            {

            TMPXComandElement command = { EPbCmdPlay, EPbStatePlaying };

            aMTPPBMPXCmd.Append( command );

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSKIP_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::HandlePlaybackCmdSetPositionL

// ---------------------------------------------------------------------------

//

void CMTPPlaybackResumeHelper::HandlePlaybackCmdSetPosition( RResumeCmdArray& aMTPPBMPXCmd )

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSETPOSITION_ENTRY );

    switch ( MTPPlaybackControlImpl().CurrentState() )

        {

        case EPbStatePlaying:

            {

            if ( iIfParepareArray )

                {

                TMPXComandElement command = { EPbCmdPause, EPbStatePaused };

                aMTPPBMPXCmd.Append( command );

                }

            else

                {

                TMPXComandElement command = { EPbCmdPlay, EPbStatePlaying };

                aMTPPBMPXCmd.Append( command );

                }

            }

            break;

        default:

            break;

        }

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_HANDLEPLAYBACKCMDSETPOSITION_EXIT );

    }

// ---------------------------------------------------------------------------

// CMTPPlaybackResumeHelper::CMTPPlaybackControlImpl

// ---------------------------------------------------------------------------

//

CMTPPlaybackControlImpl& CMTPPlaybackResumeHelper::MTPPlaybackControlImpl()

    {

    OstTraceFunctionEntry0( CMTPPLAYBACKRESUMEHELPER_MTPPLAYBACKCONTROLIMPL_ENTRY );

    OstTraceFunctionExit0( CMTPPLAYBACKRESUMEHELPER_MTPPLAYBACKCONTROLIMPL_EXIT );

    return iMTPPlaybackControl;

    }