/*

* Copyright (c) 2006-2007 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:  This class implements duration timer for calls.

*

*/

// INCLUDE FILES

#include    "mccecallobserver.h"

#include    "mcceconferencecallobserver.h"

#include    "cccedurationtimer.h"

#include    "cccelogger.h"

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

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

// CCCEDurationTimer::CCCEDurationTimer

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCCEDurationTimer::CCCEDurationTimer()

    {

    iObserver           = NULL;

    iConferenceCallObserver = NULL;

    iActive             = EFalse;

    iNumberOfBeats      = 0;

    iStartTime          = 0;

    iAirTimeDuration    = EFalse;

    }

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

// CCCEDurationTimer::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCCEDurationTimer::ConstructL()

    {

    iHeartbeat = CHeartbeat::NewL( CActive::EPriorityStandard );

    }

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

// CCCEDurationTimer::NewL

// Two-phased constructor.

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

//

CCCEDurationTimer* CCCEDurationTimer::NewL()

    {

    CCCEDurationTimer* runner = new (ELeave) CCCEDurationTimer();

    CleanupStack::PushL( runner );

    runner->ConstructL();

    CleanupStack::Pop( runner );

    return runner;

    }

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

// CCCEDurationTimer::~CCCEDurationTimer

// Destructor.

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

//

CCCEDurationTimer::~CCCEDurationTimer()

    {

    iObserver = NULL;

    iConferenceCallObserver = NULL;

    if ( iHeartbeat )

        {

        //stop calling Beat...

        iHeartbeat->Cancel();

        }

    delete iHeartbeat;

    }

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

// CCCEDurationTimer::SetObserver

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

//

void CCCEDurationTimer::SetObserver( MCCECallObserver* aObserver )

    {

    iObserver = aObserver;

    }

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

// CCCEDurationTimer::SetObserver

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

//

void CCCEDurationTimer::SetConferenceObserver( MCCEConferenceCallObserver* aObserver )

    {

    iConferenceCallObserver = aObserver;

    }

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

// CCCEDurationTimer::Start

//    Overload to resetting iNumberOfBeats 

//

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

//

void CCCEDurationTimer::Start()

    {

    Start(0);

    }

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

// CCCEDurationTimer::Start

//    if timer is not already active

//        set iStarTime to current time

//        set iNumberOfBeats to aBeatsOffset

//        start timer

//        set value ETrue to iActive

//

// (other items were commented in a header).

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

//

void CCCEDurationTimer::Start(TInt aBeatsOffset)

    {

    //Check if active 

    if ( !iActive ) 

        {

        //Initialize iStartime

        iStartTime.HomeTime();

        //Clear number of beats

        iNumberOfBeats = aBeatsOffset;

        //Timer tick is on the second 

        iHeartbeat->Start( ETwelveOClock, this );

        //Set flag to indicate that timer is active

        iActive = ETrue;

        //Set flag to indicate that air time duration counter is not started

        iAirTimeDuration = EFalse;

        }

    }

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

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

//	

void CCCEDurationTimer::RestartAirTimeDuration(TInt aBeatsOffset)

    {

    //Check if active 

    if ( !iActive ) 

        {

        // Set number of beats

        iNumberOfBeats = aBeatsOffset;

        //Timer tick is on the second 

        iHeartbeat->Start( ETwelveOClock, this );

        //Set flag to indicate that timer is active

        iActive = ETrue;

        //Set flag to indicate that air time duration counter is started

        iAirTimeDuration = ETrue;

        }

    }

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

// CCCEDurationTimer::StartAirTimeDuration

//    if timer is not already active

//        set iStarTime to current time

//        start timer

//        set value ETrue to iActive

//        set value ETrue to iAirTimeDuration

//

// (other items were commented in a header).

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

//

void CCCEDurationTimer::StartAirTimeDuration()

    {

    //Check if active 

    if ( !iActive ) 

        { 

        //Initialize iStartime

        iStartTime.HomeTime();

        // Clear number of beats

        iNumberOfBeats = 0;

        //Timer tick is on the second 

        iHeartbeat->Start( ETwelveOClock, this );

        //Set flag to indicate that timer is active

        iActive = ETrue;

        //Set flag to indicate that air time duration counter is started

        iAirTimeDuration = ETrue;

        }

    }

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

// CCCEDurationTimer::StartTime

// Returns current date and time object.

// (other items were commented in a header).

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

//

TDateTime CCCEDurationTimer::StartTime()

    {

	return iStartTime.DateTime();

    }

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

// CCCEDurationTimer::Stop

// Stops timer

//

//    store iActive in ret boolean

//    if timer is active

//        reset iStartTime

//        stop timer.

//        set value EFalse to iActive

//    return ret

// (other items were commented in a header).

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

//

TBool CCCEDurationTimer::Stop()

    {

    TBool ret = iActive;

    //Check if active 

    if ( iActive ) 

        { 

        //Reset iStartTime

        iStartTime = 0;

        //Cancel beat method calling 

        iHeartbeat->Cancel(); 

        //Set flag to indicate that timer is not active

        iActive = EFalse;

        }

    return ret;

    }

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

// CCCEDurationTimer::Beat

// Beat is called once every second. If iMmCall is not null

//    (timer is used for calculating the duration of a call), the method

//    CompleteNotifyCallDurationChange is called. The iNumberOfBeats is

//    increased to count the amount of seconds passed from the starting

//    of the timer.

// (other items were commented in a header).

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

//

void CCCEDurationTimer::Beat()

    {

    iNumberOfBeats++;

    // If iOwner is NOT null, this timer is used to count call duration.

    if ( iObserver )

        {

        //complete notify duration change, 1 sec gone

        iObserver->CallDurationChanged( iNumberOfBeats );

        }

    // If iOwner is NOT null, this timer is used to count call duration.

    if ( iConferenceCallObserver )

        {

        //complete notify duration change, 1 sec gone

        iConferenceCallObserver->CallDurationChanged( iNumberOfBeats );

        }

    }

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

// CCCEDurationTimer::NumberOfBeats

// Returns number of beats from the previous Start of the timer.

// (other items were commented in a header).

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

//

TInt CCCEDurationTimer::NumberOfBeats() const

    {

    return iNumberOfBeats;

    }

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

// CCCEDurationTimer::Reset

// Sets the number of beats to zero

// (other items were commented in a header).

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

//

void CCCEDurationTimer::Reset() 

    {

    iNumberOfBeats = 0;

    }

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

// CCCEDurationTimer::Synchronize

// This methods is called when synchronization is lost (the 

// method Beat couldn't be called). It calculates the number

// of seconds passed after the start of the timer and assigns 

// it to iNumberOfBeats

//

//    if this is not air time duration counter

//        initialize local variables

//        get current home time

//        increase value of number of beats by one because at least one beat is 

//         missing

//        calculate difference of current home time and timer start time in 

//         seconds and save result in secondsFromStart

//        if secondsFromStart is positive

//            calculate difference of number of beats and secondsFromStart and 

//             save result in timeDifference

//            if timeDifference is less than 10

//                correct the deviation and set secondsFromStart in number of 

//                 beats

// (other items were commented in a header).

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

//

void CCCEDurationTimer::Synchronize()

    {

    const TInt tenSeconds = 10;

    //we can't synchronize if this is air time duration counter

    if ( !iAirTimeDuration )

        {

        TInt timeDifference( 0 );

        //get the correct time

        TTime currentTime;

        currentTime.HomeTime();

        TTimeIntervalSeconds secondsFromStart( 0 );

        //At least one beat is now missing

        iNumberOfBeats++;

        //calculate the amount of seconds that should be

        currentTime.SecondsFrom( iStartTime, secondsFromStart );

        //calculate difference of iNumberOfBeats and secondsFromStart

        if ( 0 <= secondsFromStart.Int() )

            {

            if ( secondsFromStart.Int() > iNumberOfBeats )

                {

                timeDifference = secondsFromStart.Int() - iNumberOfBeats;

                }

            else if ( secondsFromStart.Int() < iNumberOfBeats )

                {

                timeDifference = iNumberOfBeats - secondsFromStart.Int();

                }

            //correct the deviation only if time difference is less than 10 

            //seconds

            if ( timeDifference < tenSeconds )

                {

                iNumberOfBeats = secondsFromStart.Int();

                }

            }

        }

    }

//  End of File