// Copyright (c) 2005-2009 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:

//

// INCLUDE FILES

#include <e32base.h>

#include  "EPos_CPosCallbackTimer.h"

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

/**

 * C++ default constructor.

 * @param aCallBack 

 */

CPosCallbackTimer::CPosCallbackTimer(TCallBack& aCallBack)

:   CTimer(EPriorityStandard),

    iTimeoutCallBack(aCallBack)    

    {

    CActiveScheduler::Add(this);

    }

/**

 * Symbian constructor.

 */

void CPosCallbackTimer::ConstructL()

    {

    CTimer::ConstructL();

    }

/**

 * Two-phased constructor.

 * @param aCallBack 

 */

CPosCallbackTimer* CPosCallbackTimer::NewL(TCallBack& aCallBack)

    {

    CPosCallbackTimer* self = new (ELeave) CPosCallbackTimer(aCallBack);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

/**

 * Destructor.

 */

CPosCallbackTimer::~CPosCallbackTimer()

    {

    }

/**

 * Start the callback timer. If there is already a timer running, it

 * will be restarted.

 *

 * @param aTimeout The timeout.

 */

void CPosCallbackTimer::StartTimer(const TTimeIntervalMicroSeconds& aTimeOut)

    {    

    Cancel();    

    // MaxInt64 = MaxInt32 * MaxUint32

    // up to MaxUint32 internal rounds by MaxInt32 are possible before final 

    // timeout of up to MaxInt32

    iNumInternalRounds = static_cast<TUint32>(aTimeOut.Int64() / KMaxTInt32);

    iTimeOut = static_cast<TInt32>(aTimeOut.Int64() % KMaxTInt32);

    // iTimeOut can be also zero. It is catered for in NextRound

    NextRound();

    }

/**

 *  Activates timer for next period: full round (KMaxTInt32) or 

 *  small delay stored in iTimeOut

 */

TBool CPosCallbackTimer::NextRound()

    {

    if (iNumInternalRounds > 0)

        {

        After(KMaxTInt32);

        iNumInternalRounds--;

        return ETrue;           // timer not yet completed

        }

    else if (iTimeOut.Int() > 0)

        {

        After(iTimeOut);

        iTimeOut = 0;           // timer will complete on next round

        return ETrue;           // timer not yet completed

        }

    else

        {

        return EFalse;          // timer completed

        }

    }

/**

 * From CActive

 */

void CPosCallbackTimer::RunL()

    {    

    if (!NextRound())           // timer completed?

        {

        if (iStatus.Int() == KErrNone)

            {

            iStatus = KErrTimedOut;

            }

        iTimeoutCallBack.CallBack();

        }    

    }

/**

 * From CActive

 */

TInt CPosCallbackTimer::RunError(TInt /*aError*/)

    {

    return KErrNone;

    }

/**

 * Returns the request status of this callback timer.

 * 

 * @return Returns KErrTimedOut if timer elapsed or KErrCancel

 *         if timer was cancelled. Otherwise any of the system wide

 *         error codes.

 */

TInt CPosCallbackTimer::Status()

    {

    return iStatus.Int();

    }

void CPosCallbackTimer::ExtendTimeout(const TTimeIntervalMicroSeconds& aAdditionalTime)

	{

	if(!IsActive())

		{

		return;

		}

	//We do not need to cancel here. Just correct the iNumInternalRounds and iTimeOut

	TInt64 timeout = iNumInternalRounds * KMaxTInt32 + iTimeOut.Int() + aAdditionalTime.Int64();

	iNumInternalRounds = static_cast<TUint32>(timeout / KMaxTInt32);

	iTimeOut = static_cast<TInt32>(timeout % KMaxTInt32);

	}

//  End of File