1 #ifndef UITIMER_H_

     2 #define UITIMER_H_

     3 

     4 #include <QDateTime>

     5 #include <QDebug>

     6 #include "qstmfilelogger.h"

     7 

     8 #define TIMESTAMP() QDateTime::currentDateTime().toString("hh:mm:ss:zzz")

     9 

    10 #ifdef Q_OS_SYMBIAN

    11 #include <e32base.h>

    12 #include <e32const.h>

    13 

    14 class CUiTimer : public CTimer

    15 {

    16 public:

    17     enum CUiTimerType

    18     {

    19         AfterType,

    20         HighResType,

    21         LockType

    22     };

    23     

    24     CUiTimer(int priority) : CTimer(priority), m_timerType(AfterType)

    25     {

    26     }

    27     

    28     

    29     

    30     static CUiTimer* New(int priority)

    31     {

    32         CUiTimer* uitao = new CUiTimer(priority);

    33         if (uitao) {            

    34             TRAPD(r, uitao->ConstructL());

    35             if (r == KErrNone) {

    36                 CActiveScheduler::Add(uitao);

    37             }

    38             else {

    39                 delete uitao;

    40                 uitao = NULL;

    41             }

    42         }

    43         return uitao;

    44     }

    45     

    46     ~CUiTimer() {}

    47     

    48     void Start(TTimeIntervalMicroSeconds32 delay,TTimeIntervalMicroSeconds32 interval,TCallBack callBack)

    49     {

    50         __ASSERT_ALWAYS(interval.Int()>=0,User::Panic(_L("Interval < 0"), -1));

    51         __ASSERT_ALWAYS(delay.Int()>=0,User::Panic(_L("Delay < 0"), -2));

    52         m_interval = interval.Int();

    53         m_callback = callBack;

    54         m_timerType = AfterType;

    55         After(delay);

    56     }

    57     

    58     void StartHighRes(TTimeIntervalMicroSeconds32 delay,TTimeIntervalMicroSeconds32 interval,TCallBack callBack)

    59     {

    60         __ASSERT_ALWAYS(interval.Int()>=0,User::Panic(_L("Interval < 0"), -1));

    61         __ASSERT_ALWAYS(delay.Int()>=0,User::Panic(_L("Delay < 0"), -2));

    62         m_interval = interval.Int();

    63         m_callback = callBack;

    64         m_timerType = HighResType;

    65         HighRes(delay);

    66     }

    67         

    68     void StartLock(TTimerLockSpec lockSpec,TCallBack callBack)

    69     {

    70         m_lockSpec = lockSpec;

    71         m_callback = callBack;

    72         m_timerType = LockType;

    73         Lock(m_lockSpec);

    74     }

    75 

    76     

    77     void RunL()

    78     {

    79         switch (m_timerType) {

    80         case HighResType:

    81             HighRes(m_interval);

    82             m_callback.CallBack();

    83             break;

    84         case LockType:

    85             Lock(m_lockSpec);

    86             m_callback.CallBack();

    87             break;

    88         case AfterType:

    89             After(m_interval);

    90             m_callback.CallBack();

    91             break;

    92         }

    93     }

    94     

    95 private:    

    96     uint            m_interval; 

    97     TCallBack       m_callback;

    98     CUiTimerType    m_timerType;

    99     TTimerLockSpec  m_lockSpec;

   100 };

   101 

   102 class UiTimer : QObject

   103 {

   104     enum UiTimerType

   105     {

   106         AfterType,

   107         HighResType,

   108         LockType

   109     };

   110 

   111 public:

   112     static UiTimer*  New() 

   113     { 

   114         return new UiTimer(); 

   115     }

   116   

   117     inline UiTimer(): QObject(), m_id(0), m_requestedTicks(-1), 

   118                       m_ticksCount(0), m_cbName("uiTimerCallback") 

   119     {    

   120         m_timer = CUiTimer::New(20);

   121     }

   122   

   123     inline void setPriority(int priority) { m_timer->SetPriority(priority); }

   124     inline ~UiTimer() { m_timer->Cancel(); delete m_timer;}

   125     

   126     inline int timerId() const { return m_id; }

   127 

   128     static int timercallback(TAny* ptr)

   129     {

   130         UiTimer* uitimer = static_cast<UiTimer*>(ptr);

   131         uitimer->doTimerCallback();

   132         return 0;

   133     }

   134     

   135     void doTimerCallback()

   136     {

   137        if (isActive() && (m_requestedTicks < 0 || m_ticksCount++ < m_requestedTicks)) {  

   138            

   139            QMetaObject::invokeMethod(m_obj, m_cbName, Qt::DirectConnection);

   140            if (m_ticksCount == m_requestedTicks) {

   141                stop();

   142            }

   143        }

   144        return;

   145     }

   146     

   147     void start(int msec, QObject *obj, UiTimerType timerType = HighResType) 

   148     {

   149         m_delay = msec;

   150         m_obj = obj;

   151         m_ticksCount = 0;

   152         switch (timerType)

   153         {

   154         case HighResType:

   155             m_timer->StartHighRes((msec + 1) * 1000, (msec + 1) * 1000, TCallBack(timercallback, this));

   156             break;

   157         case AfterType:

   158             m_timer->Start(msec * 1000, msec * 1000, TCallBack(timercallback, this));

   159             break;

   160         case LockType:

   161             TTimerLockSpec lockSpec = static_cast<TTimerLockSpec>(msec);

   162             m_timer->StartLock(lockSpec, TCallBack(timercallback, this));

   163             break;

   164         }

   165     }

   166     

   167     void stop() 

   168     { 

   169         m_timer->Cancel(); 

   170     }

   171     

   172     bool isActive() { return m_timer->IsActive(); }

   173     

   174     void setRequestedTicks(int ticksCount) { m_requestedTicks = ticksCount; }

   175     int ticksCount() { return m_ticksCount; }

   176     

   177     void setSingleShot(bool isOneShot) { isOneShot ?  m_requestedTicks = 1 : m_requestedTicks = -1; }

   178     bool isSingleShot() { return m_requestedTicks == 1; }

   179     

   180     void setTimerCallback(char* cbName) { m_cbName = cbName; }

   181     

   182 private:

   183     int         m_id;

   184     int         m_delay;

   185     QObject*    m_obj;

   186     CUiTimer*   m_timer;

   187     int         m_requestedTicks;

   188     int         m_ticksCount;

   189     char*       m_cbName;

   190     

   191 };

   192 #else

   193 class UiTimer : public QObject

   194 {

   195 public:

   196     static UiTimer* New() { return new UiTimer(); }

   197     UiTimer() : QObject(), m_requestedTicks(-1), m_cbName(0)

   198     {

   199     }

   200     inline void setPriority(int priority) {}

   201     inline void start(int msec, QObject *obj) 

   202     {

   203         m_delay = msec;

   204         m_obj = obj;

   205         m_ticksCount = 0;

   206         m_timer.start(msec, this);

   207     }

   208     inline ~UiTimer() {}

   209         

   210     inline int timerId() const { return m_timer.timerId(); }

   211 

   212     inline void timerEvent(QTimerEvent *event)

   213     {

   214         if (m_requestedTicks < 0 || m_ticksCount++ < m_requestedTicks) {

   215             QMetaObject::invokeMethod(m_obj, m_cbName ? m_cbName : "uiTimerCallback", Qt::DirectConnection);

   216         }

   217         else {

   218             stop();

   219         }

   220         return;

   221     }

   222 

   223     inline void stop() { m_timer.stop(); }

   224         

   225     inline bool isActive() { return m_timer.isActive(); }

   226 

   227     void setRequestedTicks(int ticksCount) { m_requestedTicks = ticksCount; }

   228     int ticksCount() { return m_ticksCount; }

   229     

   230     void setSingleShot(bool isOneShot) { isOneShot ?  m_requestedTicks = 1 : m_requestedTicks = -1; }

   231     bool isSingleShot() { return m_requestedTicks == 1; }

   232     void setTimerCallback(char* cbName) { m_cbName = cbName; }

   233 

   234 private:

   235     QBasicTimer  m_timer; 

   236     int          m_delay;

   237     QObject*     m_obj;

   238     int         m_requestedTicks;

   239     int         m_ticksCount;

   240     char*       m_cbName;

   241 };

   242 

   243 #endif

   244 

   245 

   246 

   247 

   248 #endif /* UITIMER_H_ */