/*
* 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:  Buffer commands
*
*/


#include"mpxplaybackcommandbuffer.h"
#include "mpxlog.h"

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


// ----------------------------------------------------------------------------
// Two-phased constructor
// ----------------------------------------------------------------------------
//
CMPXPlaybackCmdBuffer* CMPXPlaybackCmdBuffer::NewL(
    MMPXPlaybackCmdBufferObserver& aObserver)
    {
    CMPXPlaybackCmdBuffer* h=new(ELeave)CMPXPlaybackCmdBuffer(aObserver);
    CleanupStack::PushL(h);
    h->ConstructL();
    CleanupStack::Pop(h);
    return h;
    }

// ----------------------------------------------------------------------------
// C++ constructor can NOT contain any code that might leave.
// ----------------------------------------------------------------------------
//
CMPXPlaybackCmdBuffer::CMPXPlaybackCmdBuffer(
    MMPXPlaybackCmdBufferObserver& aObserver)
:   CTimer(EPriorityStandard),
    iObserver(aObserver)
    {
    CActiveScheduler::Add(this);
    }


// ----------------------------------------------------------------------------
// Is this a command controlled by command buffer
// ----------------------------------------------------------------------------
//
TBool CMPXPlaybackCmdBuffer::CommandForBuffering(TMPXPlaybackCommand aCmd) const
    {
    switch(aCmd)
        {
        case EPbCmdPlay:
        case EPbCmdStop:
        case EPbCmdPause:
        case EPbCmdPlayPause:
        case EPbCmdNext:
        case EPbCmdPrevious:
            return ETrue;
        default:
            return EFalse;
        }
    }

// ----------------------------------------------------------------------------
// Handle time out event
// ----------------------------------------------------------------------------
//
void CMPXPlaybackCmdBuffer::RunL()
    {
    MPX_DEBUG1("CMPXPlaybackCmdBuffer::RunL() entering");

    if (!iEventProcessing && IsCommandBuffered())
    //
    // Client is not currently processing any events, and there are new
    // events to deliver
    //
        {
        if (iEvent.iNavKeyBuffered)
            {
            iObserver.HandleCmdBufferSkipEventL( EPbsSkipEventEnd ); // notify end skip event
            }
        iIsCommandBuffered=EFalse;
        iEventProcessing=ETrue; // Handled by client
        iObserver.HandleCmdBufferEventL(iEvent);
        }

    MPX_DEBUG1("CMPXPlaybackCmdBuffer::RunL() exiting");
    }

// ----------------------------------------------------------------------------
// Handle leave in command handling
// ----------------------------------------------------------------------------
//
TInt CMPXPlaybackCmdBuffer::RunError(TInt /*aError*/)
    {
    MPX_DEBUG1("==>CMPXPlaybackCmdBuffer::RunL()");
    ClearCommands();
    iEventProcessing=EFalse;
    MPX_DEBUG1("<==CMPXPlaybackCmdBuffer::RunL()");
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Buffer a playback/skip command, along with the current state and position in
// the track. Update playback state/position internally. When time-out, restore
// state/position to playback engine.
// ----------------------------------------------------------------------------
//
void CMPXPlaybackCmdBuffer::BufferCommandL(TMPXPlaybackCommand aCmd,
                                           TMPXPlaybackState aState,
                                           TInt aPos)
    {
    MPX_DEBUG4("CMPXPlaybackCmdBuffer::BufferCommandL(%d, %d, %d) entering", aCmd, aState, aPos);

    if (!CommandForBuffering(aCmd) ||
        (aCmd==EPbCmdPlay && aState==EPbStatePlaying) ||
        (aCmd==EPbCmdPause && aState==EPbStatePaused))
        {
        // This command does not change any state, so make sure
        // to negate any previous commands
        ClearCommands();
        return;
        }

    TBool saveIsCmdBuffered = iIsCommandBuffered;
    iBufferTime = KPbMediaKeyIntervalMicroSeconds;
    const TInt KPbMediaKeyNoIntervalMicroSeconds=10;  // 0.00001s
    const TInt KPbMediaKeySkipIntervalMicroSeconds=200000;  // 0.2s or 200ms
    const TInt KPbMediaKeyPauseIntervalMicroSeconds=100000;  // 0.1s or 100ms
    Cancel(); // Stop timer and wait again for any other events

    if (!iIsCommandBuffered)
        {
        iIsCommandBuffered=ETrue;
        iEvent.iTrackOffset=0;
        iEvent.iState=aState;
        iEvent.iNavKeyBuffered=EFalse;
        }

    if (!iEvent.iNavKeyBuffered)
        {
        iEvent.iPos = aPos;
        }

    switch(aCmd)
        {
        case EPbCmdNext:
            {
            iEvent.iTrackOffset++;
            iEvent.iNavKeyBuffered++;
            TBool savedStatus( iEventProcessing );
            iEventProcessing = ETrue;
            iObserver.HandleCmdBufferSkipEventL( EPbsSkipEventNext ); // notify skip event
            iEventProcessing = savedStatus;
			if ( !saveIsCmdBuffered )
				{
				iBufferTime = KPbMediaKeySkipIntervalMicroSeconds; // 0.2s or 200ms
				}
            break;
            }
        case EPbCmdPrevious:
            {
            if (!iEvent.iNavKeyBuffered &&
                (aState==EPbStatePlaying || aState==EPbStatePaused) &&
                 iEvent.iPos > KPbReplayThresholdMiliSeconds)
                {
                MPX_DEBUG1("CMPXPlaybackCmdBuffer::BufferCommandL() Setting position 0");
                aPos=0;
                }
            else
                {
                TBool savedStatus( iEventProcessing );
                iEventProcessing = ETrue;
                iObserver.HandleCmdBufferSkipEventL( EPbsSkipEventPrevious ); // notify skip event
                iEventProcessing = savedStatus;
                iEvent.iTrackOffset--;
                }
            iEvent.iNavKeyBuffered++;
            break;
            }
        case EPbCmdPlay:
            iEvent.iState = EPbStatePlaying;
            if ( !saveIsCmdBuffered )
                {
                iBufferTime = KPbMediaKeyNoIntervalMicroSeconds;
                }
            break;
        case EPbCmdPause: // From play to pause
            if (EPbStatePlaying == iEvent.iState)
                {
                iEvent.iState = EPbStatePaused;
				if ( !saveIsCmdBuffered )
					{
					iBufferTime = KPbMediaKeyPauseIntervalMicroSeconds;
					}
                }
             break;
        case EPbCmdPlayPause:
            {
            if ( EPbStatePlaying == iEvent.iState )
                {
                iEvent.iState = EPbStatePaused;
				if ( !saveIsCmdBuffered )
					{
					iBufferTime = KPbMediaKeyPauseIntervalMicroSeconds;
					}
				break;
                }
            else
                {
                iEvent.iState = EPbStatePlaying;
                if ( !saveIsCmdBuffered )
                    {
                    iBufferTime = KPbMediaKeyNoIntervalMicroSeconds;
                    }
                }
            break;
            }
        case EPbCmdStop:
            iEvent.iState = EPbStateStopped;
            break;
        default:
            break;
        }
    // maintain pos unless track has changed
    iEvent.iPos=iEvent.iTrackOffset ? 0 : aPos;
    //
    if (!iEventProcessing) // If client isn't processing event
        {
        After(iBufferTime);
        }

    MPX_DEBUG1("CMPXPlaybackCmdBuffer::BufferCommandL() exiting");
    }

// ----------------------------------------------------------------------------
// Called by client when finished processing commands in buffer
// ----------------------------------------------------------------------------
//
void CMPXPlaybackCmdBuffer::CompleteCommand()
    {
    MPX_DEBUG1("CMPXPlaybackCmdBuffer::CompleteCommand() entering");

    iEventProcessing=EFalse; // Client finished processing event
    if (IsCommandBuffered() && !IsActive())
        {
        After(iBufferTime);
        }

    MPX_DEBUG1("CMPXPlaybackCmdBuffer::CompleteCommand() exiting");
    }

// ----------------------------------------------------------------------------
// Check if any commands buffered
// ----------------------------------------------------------------------------
//
TBool CMPXPlaybackCmdBuffer::IsCommandBuffered() const
    {
    return iIsCommandBuffered;
    }

// ----------------------------------------------------------------------------
// Clear all commands
// ----------------------------------------------------------------------------
//
void CMPXPlaybackCmdBuffer::ClearCommands()
    {
    iIsCommandBuffered=EFalse;
    Cancel();
    }