emailservices/nmclientapi/src/nmapieventnotifier_p.cpp
changeset 23 2dc6caa42ec3
parent 20 ecc8def7944a
child 30 759dc5235cdb
equal deleted inserted replaced
20:ecc8def7944a 23:2dc6caa42ec3
    16  */
    16  */
    17 
    17 
    18 #include "nmapiengine.h"
    18 #include "nmapiengine.h"
    19 #include "nmapieventnotifier_p.h"
    19 #include "nmapieventnotifier_p.h"
    20 
    20 
       
    21 #include <QTimer>
       
    22 
    21 namespace EmailClientApi
    23 namespace EmailClientApi
    22 {
    24 {
    23 /*!
    25 /*!
    24  * Constructor
    26    Constructor
    25  */
    27  */
    26 NmEventNotifierPrivate::NmEventNotifierPrivate(QObject *parent) :
    28 NmApiEventNotifierPrivate::NmApiEventNotifierPrivate(QObject *parent) :
    27     QObject(parent), mEmitSignals(NULL), mEngine(NULL), mIsRunning(false)
    29     QObject(parent), mEmitSignals(NULL), mEngine(NULL), mIsRunning(false)
    28 {
    30 {
    29 
    31 
    30 }
    32 }
    31 
    33 
    32 /*!
    34 /*!
    33  * Destructor
    35    Destructor
    34  */
    36  */
    35 NmEventNotifierPrivate::~NmEventNotifierPrivate()
    37 NmApiEventNotifierPrivate::~NmApiEventNotifierPrivate()
    36 {
    38 {
    37 
    39 
    38 }
    40 }
    39 
    41 
    40 /*!
    42 /*!
    41  * \brief It initialize engine for email operations. 
    43    \brief It initialize engine for email operations. 
    42  * 
    44    
    43  * When use initializeEngine need to remember release it.
    45    When use initializeEngine need to remember release it.
    44  * It return value if initialization go good.
    46    It return value if initialization go good.
    45  * \sa releaseEngine 
    47    \sa releaseEngine 
    46  * \return Return true if engine works.
    48    \return Return true if engine works.
    47  */
    49  */
    48 bool NmEventNotifierPrivate::initializeEngine()
    50 bool NmApiEventNotifierPrivate::initializeEngine()
    49 {
    51 {
    50     if (!mEngine) {
    52     if (!mEngine) {
    51         mEngine = NmEngine::instance();
    53         mEngine = NmApiEngine::instance();
    52     }
    54     }
    53 
    55 
    54     return mEngine ? true : false;
    56     return mEngine ? true : false;
    55 }
    57 }
    56 
    58 
    57 /*!
    59 /*!
    58  * \brief It release engine for email operations.
    60    \brief It release engine for email operations.
    59  * 
    61    
    60  * It release Engine and return value if release go good.
    62    \sa initializeEngine
    61  * 
       
    62  * \arg engine Is used to get info if engine was released, if yes, then argument have value 0.
       
    63  * 
       
    64  * \sa initializeEngine
       
    65  */
    63  */
    66 void NmEventNotifierPrivate::releaseEngine()
    64 void NmApiEventNotifierPrivate::releaseEngine()
    67 {
    65 {
    68     if (mIsRunning) {
    66     if (mIsRunning) {
    69         cancel();
    67         cancel();
    70     }
    68     }
    71     else {
    69     else {
    72         NmEngine::releaseInstance(mEngine);
    70         NmApiEngine::releaseInstance(mEngine);
    73     }
    71     }
    74 }
    72 }
    75 
    73 
    76 /*!
    74 /*!
    77  * Add one email event into buffer.
    75    Add one email event into buffer.
    78  * 
    76    
    79  * It is run by \sa NmEngine::emailStoreEvent signal.
    77    It is run by \sa NmApiEngine::emailStoreEvent signal.
    80  * \sa NmApiMessage
    78    \sa NmApiMessage
    81  * \arg It contains full info about object and it event.
    79    \param events It contains full info about object and it event.
    82  */
    80  */
    83 void NmEventNotifierPrivate::emailStoreEvent(const NmApiMessage &events)
    81 void NmApiEventNotifierPrivate::emailStoreEvent(const NmApiMessage &events)
    84 {
    82 {
    85     mBufferOfEvents << events;
    83     mBufferOfEvents << events;
    86 }
    84 }
    87 
    85 
    88 void NmEventNotifierPrivate::cancel()
    86 void NmApiEventNotifierPrivate::cancel()
    89 {
    87 {
       
    88     if (!mIsRunning) {
       
    89         return;
       
    90     }
    90 
    91 
       
    92     mIsRunning = false;
       
    93     mEmitSignals->stop();
       
    94 
       
    95     if (mEngine) {
       
    96         disconnect(mEngine, SIGNAL(emailStoreEvent(NmApiMessage)), this,
       
    97             SLOT(emailStoreEvent(NmApiMessage)));
       
    98     }
       
    99 
       
   100     releaseEngine();
       
   101 
       
   102     mBufferOfEvents.clear();
    91 }
   103 }
    92 
   104 
    93 }
   105 }
    94 
   106