/*

* Copyright (c) 2005 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: SmilPlayerTimeIndicatorTimer implementation

*

*/

// INCLUDE FILES

#include <AknUtils.h>       // AknTextUtils

#include <StringLoader.h>   // StringLoader

#include <avkon.rsg>        // R_QTN_TIME_DURAT_MIN_SEC

#include <SmilPlayer.rsg>   // R_SMILPLAYER_PRESENTATION_DURATION

#include "SmilPlayerTimeIndicatorTimer.h"

#include "SmilPlayerTimeObserver.h"

// CONSTANTS

const TInt KTimeControlIntToMicroSec            = 1000000;

const TInt KMaxTimeInSeconds                    = 3599;

const TInt KTimeControlStartDelay               = 500000; //0.5 sec

const TInt KTimeControlProceedingTime           = 200000; //0.2 sec

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

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

// CSmilPlayerTimeIndicatorTimer::CSmilPlayerTimeIndicatorTimer

// C++ constructor.

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

// 

CSmilPlayerTimeIndicatorTimer::CSmilPlayerTimeIndicatorTimer( MSmilPlayerTimeObserver* aObserver, 

                                                              CCoeEnv* aCoeEnv ) :

    CTimer( EPriorityStandard ),

    iTimeObserver( aObserver ),

    iCurrentValue( 0 ),

    iState( EReadyForAction ),

    iCoeEnv( aCoeEnv )

    {

    CActiveScheduler::Add( this );

    }

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

// CSmilPlayerTimeIndicatorTimer::ConstructL

// Symbian 2nd phase constructor. Initializes timer and loads corret resource string

// for localizable time string.

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

// 

void CSmilPlayerTimeIndicatorTimer::ConstructL()

    {

    CTimer::ConstructL();

    StringLoader::Load( iTimeDuratMinSecWithZero, R_QTN_TIME_DURAT_MIN_SEC, iCoeEnv );

    }

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

// CSmilPlayerTimeIndicatorTimer::NewL

// Symbian two phased constructor

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

// 

CSmilPlayerTimeIndicatorTimer* CSmilPlayerTimeIndicatorTimer::NewL( MSmilPlayerTimeObserver* aObserver,

                                                                    CCoeEnv* aCoeEnv )

    {

    CSmilPlayerTimeIndicatorTimer* self = new(ELeave) CSmilPlayerTimeIndicatorTimer( aObserver, 

                                                                                     aCoeEnv );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CSmilPlayerTimeIndicatorTimer::~CSmilPlayerTimeIndicatorTimer

// Destructor

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

// 

CSmilPlayerTimeIndicatorTimer::~CSmilPlayerTimeIndicatorTimer()

    {    

    iTimeObserver = NULL; //For LINT

    iCoeEnv = NULL; // For LINT

    }

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

// CSmilPlayerTimeIndicatorTimer::RunL

// Called when timer triggers to update time indicator string if approriate.

// Also resets inactivity timer so that sceensaver is not triggered during

// playback.

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

// 

void CSmilPlayerTimeIndicatorTimer::RunL()

    {

    TInt previousTotalDuration( iDurationValue );

    TInt previousTime( iCurrentValue );

    // Updating current time

    TInt newTime( iTimeObserver->CurrentTime() );

    // Check to see if we are preparing to end even

    // if state is not updated correctly.

    if ( iState == ERunning && 

         iCurrentValue == (iDurationValue - 1) &&

         iCurrentValue != newTime )

        {

        iState = EPreparingForEnd;

        }

    if ( iState == EPreparingForEnd )

        {

        newTime = iDurationValue;

        previousTime = 0; // Force update

        }

    // Updating duration

    if ( !iTimeObserver->IsDurationFinite() )

        {

        iCurrentValue = newTime;

        iDurationValue = 0;

        }

    else

        {

        //store current time to the member

        iCurrentValue = newTime;

        //store current duration to the member 

        iDurationValue = iTimeObserver->PresentationDuration();

        }

    //check here is the current time or duration has changed

    if ( previousTime != iCurrentValue ||

         previousTotalDuration != iDurationValue )

        {

        // Reset inactivity timer.

        User::ResetInactivityTime();

        CreateNewTimeStringL();

        }

    // start the timer again

    After( KTimeControlProceedingTime );//0.2sec

    }

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

// CSmilPlayerTimeIndicatorTimer::Start

// Cancels the old time indicator refreshing is ongoing.

// Sets current time to zero and tries to create new time string so that new time value is 

// refreshed immediatelly to indicator. Error on creating time string are ignored

// since time string update is not critical task and allowing leaves from function

// would create multiple TRAPs to other places.

// After this timer is started to update the time indicator and state is set to running. 

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

// 

void CSmilPlayerTimeIndicatorTimer::Start()

    {

    Cancel();

    iCurrentValue = 0;

    TRAP_IGNORE( CreateNewTimeStringL() );

    After( KTimeControlStartDelay );

    iState = ERunning;

    }

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

// CSmilPlayerTimeIndicatorTimer::Pause

// Pauses time string update.

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

// 

void CSmilPlayerTimeIndicatorTimer::Pause()

    {

    iState = EPaused;

    Cancel();

    }

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

// CSmilPlayerTimeIndicatorTimer::Resume

// Continues time string update.

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

// 

void CSmilPlayerTimeIndicatorTimer::Resume()

    {

    iState = ERunning;

    After( KTimeControlProceedingTime );

    }

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

// CSmilPlayerTimeIndicatorTimer::Stop

// Stops time string update. Tries to update current value if possible.

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

// 

void CSmilPlayerTimeIndicatorTimer::Stop()

    {

    // Updating current time

    iCurrentValue = iTimeObserver->CurrentTime();

    TRAP_IGNORE( CreateNewTimeStringL() );

    iState = EReadyForAction;

    Cancel();

    }

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

// CSmilPlayerTimeIndicatorTimer::EndReached

// Indicates that presentation end has been reached. Sets timer state to preparing

// for end. 

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

// 

void CSmilPlayerTimeIndicatorTimer::EndReached()

    {

    iState = EPreparingForEnd;

    iCurrentValue = iDurationValue;

    }

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

// CSmilPlayerTimeIndicatorTimer::CreateNewTimeStringL

// Constructs new time string and updates it to observer.

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

//

void CSmilPlayerTimeIndicatorTimer::CreateNewTimeStringL()

    {

    // do not draw any time ( for example interactive presentation )

    if ( iCurrentValue != 0 || iDurationValue != 0 )

        {

        HBufC* timeBuffer = NULL;

        TBuf<KTimeControlMaxLength> timeString;

        TInt64 timeValue = MAKE_TINT64( 0, Min( KMaxTimeInSeconds, iCurrentValue ) );

        timeValue *= KTimeControlIntToMicroSec;

        TTime time( timeValue );

        time.FormatL( timeString, iTimeDuratMinSecWithZero );

        // checks if needed to draw total duration

        // and load localised string from resources

        if( iDurationValue != 0 )

            {

            TBuf<KTimeControlMaxLength> durationString;

            TInt64 durationValue = MAKE_TINT64( 0, Min( KMaxTimeInSeconds, iDurationValue ) );

            durationValue *= KTimeControlIntToMicroSec;

            TTime duration( durationValue );

            duration.FormatL( durationString,

                              iTimeDuratMinSecWithZero );

            //load localised string for presentation duration

            CDesCArrayFlat* array = new(ELeave) CDesCArrayFlat( 2 );

            CleanupStack::PushL( array );

            AknTextUtils::LanguageSpecificNumberConversion( timeString );

            array->AppendL( timeString );

            AknTextUtils::LanguageSpecificNumberConversion( durationString );

            array->AppendL( durationString );

            timeBuffer = StringLoader::LoadL( R_SMILPLAYER_PRESENTATION_DURATION,

                                              *array,

                                              iCoeEnv );

            CleanupStack::PopAndDestroy( array );

            }

        else

            {

            //only current time is drawn (no duration)

            //and localisation string is not needed to be used

            AknTextUtils::LanguageSpecificNumberConversion( timeString );

            timeBuffer = timeString.AllocL();

            }

        CleanupStack::PushL( timeBuffer );    

        iTimeObserver->TimeChangedL( *timeBuffer );

        CleanupStack::PopAndDestroy( timeBuffer );

        }

    }

// End of file