/*

* Copyright (c) 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: Handles new position timer implementation 

*

*/

#include "positionupdatetimer.h"

#include <mdaaudiosampleplayer.h>

#include <videoplayer2.h>

#include <e32math.h>

extern "C" {

#include "xarecorditfadaptationmmf.h"

}

#define RET_ERR_IF_ERR(s) if (s!=KErrNone) return s;

#define RET_IF_ERR(s) if (s!=KErrNone) return;

CPositionUpdateTimer::CPositionUpdateTimer(

        CMdaAudioPlayerUtility* aAudioPlayer,

        CVideoPlayerUtility2* aVideoPlayer)

:CActive(CActive::EPriorityStandard),

 iAudioPlayer(aAudioPlayer),

 iVideoPlayer(aVideoPlayer)

    {

    CActiveScheduler::Add(this);

    }

CPositionUpdateTimer::~CPositionUpdateTimer()

    {

    Cancel();

    iTimer.Close();

    }

CPositionUpdateTimer* CPositionUpdateTimer::NewL(

        CMdaAudioPlayerUtility* aAudioPlayer,

        CVideoPlayerUtility2* aVideoPlayer)

    {

    CPositionUpdateTimer* self = new (ELeave)CPositionUpdateTimer(aAudioPlayer, aVideoPlayer);

    CleanupStack::PushL(self);

    self->CostructL();

    CleanupStack::Pop(self);

    return self;

    }

void CPositionUpdateTimer::CostructL()

    {

    User::LeaveIfError(iTimer.CreateLocal());    

    }

void CPositionUpdateTimer::SetContext(TAny* aCtx)

    {

    iCtx = aCtx;    

    }

void CPositionUpdateTimer::SetPositionUpdatePeriod(XAmillisecond aPos)

    {

    iPositionUpdatePeriod = aPos;

    iDelay = TTimeIntervalMicroSeconds32(aPos*1000);

    }

void CPositionUpdateTimer::SetCallbackEventMask(XAuint32 aMask)

    {

    iCallbackEventMask = aMask;

    }

void CPositionUpdateTimer::RegisterCallback(xaPlayCallback aCallback)

    {

    iCallback = aCallback;

    }

void CPositionUpdateTimer::UseAudioPlayer()

    {

    iPlayerToUse = static_cast<CBase*>(iAudioPlayer);

    }

void CPositionUpdateTimer::UseVideoPlayer()

    {

    iPlayerToUse = static_cast<CBase*>(iVideoPlayer);

    }

void CPositionUpdateTimer::ResetPlayer()

    {

    iPlayerToUse = NULL;

    }

TInt CPositionUpdateTimer::Start()

    {

    TInt retVal(KErrNone);

    if (IsActive())

        {

        Cancel();

        }

    if ((iCallbackEventMask & XA_PLAYEVENT_HEADATNEWPOS) &&

        iCallback &&

        iPlayerToUse)

        {

        TTimeIntervalMicroSeconds curPlayPos;

        /* Convert milli to micro */

        TTimeIntervalMicroSeconds posUpdatePeriod(iPositionUpdatePeriod * 1000);

        TTimeIntervalMicroSeconds32 delay;

        /* Convert milli to micro */

        TReal res;

        TReal p;

        TReal q(posUpdatePeriod.Int64());

        iSyncToPlayHead = ETrue;

        retVal = GetCurrentPlayPosition(iSyncToPlayHeadStartPos);

        RET_ERR_IF_ERR(retVal);

        p = iSyncToPlayHeadStartPos.Int64();

        /* Adjust delay based on current play position

         * user may call this in the middle of playback */

        retVal = Math::Mod(res, p, q);

        RET_ERR_IF_ERR(retVal);

        /* Let the timer go off early and then re-adjust 

         * the remaining time based on then current position */

        delay = (posUpdatePeriod.Int64() - res) / 2;

#ifdef POSITIONUPDATETIMERLOG

        // Keep this block for debugging purposes

        RDebug::Print(_L("CPositionUpdateTimer::RunL:SyncPlayHead[%u]Delay Reset[%u]microSec"),

                iSyncToPlayHeadStartPos.Int64(),

                delay.Int());

#endif /* POSITIONUPDATETIMERLOG */

        if ( delay >= TTimeIntervalMicroSeconds32(0))

            {

            iStatus = KRequestPending;

            iTimer.After(iStatus, delay);

            SetActive();

            }

        }

    return retVal;

    }

void CPositionUpdateTimer::Stop()

    {

    Cancel();

    }

void CPositionUpdateTimer::RunL()

    {

    TInt retVal(KErrNone);

    /* Make sure some of the attributes are not unset */

    if ((iStatus == KErrNone) &&

            iCtx &&

            (iCallbackEventMask & XA_PLAYEVENT_HEADATNEWPOS) &&

            iCallback &&

            iPlayerToUse)

        {

        TTimeIntervalMicroSeconds curPlayPos;

        if (iSyncToPlayHead)

            {

            retVal = GetCurrentPlayPosition(curPlayPos);

            RET_IF_ERR(retVal);

            /* If the play head hasn't moved, re-start all over again */

            if (curPlayPos == iSyncToPlayHeadStartPos)

                {

#ifdef POSITIONUPDATETIMERLOG

            RDebug::Print(_L("CPositionUpdateTimer::RunL:CurPlayPos[%u]SyncPlayHead[%u]microSec. Restart"),

                    iSyncToPlayHeadStartPos.Int64(),

                    curPlayPos.Int64());

#endif /* POSITIONUPDATETIMERLOG */

                Start();

                return;

                }

            /* Play head has moved. calculate remaining time and set the timer */

            /* Convert milli to micro */

            TTimeIntervalMicroSeconds posUpdatePeriod(iPositionUpdatePeriod * 1000);

            TReal res;

            TReal p;

            TReal q(posUpdatePeriod.Int64());

            p = curPlayPos.Int64();

            iSyncToPlayHead = EFalse;

            retVal = Math::Mod(res, p, q);

            RET_IF_ERR(retVal);

            TTimeIntervalMicroSeconds32 delay = (posUpdatePeriod.Int64() - res);

#ifdef POSITIONUPDATETIMERLOG

            RDebug::Print(_L("CPositionUpdateTimer::RunL:CurPlayPos[%u]SyncPlayHead[%u]Delay Reset[%u]microSec"),

                    iSyncToPlayHeadStartPos.Int64(),

                    curPlayPos.Int64(),

                    delay.Int());

#endif /* POSITIONUPDATETIMERLOG */

            if ( delay >= TTimeIntervalMicroSeconds32(0))

                {

                iStatus = KRequestPending;

                iTimer.After(iStatus, delay);

                SetActive();

                }

            return;

            } /* of if (iSyncToPlayHead) */

#ifdef POSITIONUPDATETIMERLOG

        retVal = GetCurrentPlayPosition(curPlayPos);

        RDebug::Print(_L("CPositionUpdateTimer::RunL:CurPlayPos[%u]microSec. Posting XA_PLAYEVENT_HEADATNEWPOS."), curPlayPos.Int64());

#endif /* POSITIONUPDATETIMERLOG */

        XAAdaptEvent xaevent = {XA_PLAYITFEVENTS, XA_PLAYEVENT_HEADATNEWPOS, 0, 0 };

        XAAdaptationBase_SendAdaptEvents((XAAdaptationBaseCtx*)iCtx, &xaevent );

        iStatus = KRequestPending;

        iTimer.After(iStatus, iDelay);

        SetActive();

        }

    }

void CPositionUpdateTimer::DoCancel()

    {

    iTimer.Cancel();

    }

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

    {

    return KErrNone;

    }

TInt CPositionUpdateTimer::GetCurrentPlayPosition(TTimeIntervalMicroSeconds& aPos)

    {

    TTimeIntervalMicroSeconds pos;

    TInt err(KErrNone);

    if (iPlayerToUse == iAudioPlayer)

        {

        iAudioPlayer->GetPosition(aPos);

        }

    else if (iPlayerToUse == iVideoPlayer)

        {

        TRAP(err, aPos = iVideoPlayer->PositionL());

        }

    return err;

    }