/*

 * 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 aError;

    }

TInt CPositionUpdateTimer::GetCurrentPlayPosition(

        TTimeIntervalMicroSeconds& aPos)

    {

    TTimeIntervalMicroSeconds pos;

    TInt err(KErrNone);

    if (iPlayerToUse && (iPlayerToUse == iAudioPlayer))

        {

        iAudioPlayer->GetPosition(aPos);

        }

    else if (iPlayerToUse && (iPlayerToUse == iVideoPlayer))

        {

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

        }

    return err;

    }