qtinternetradio/irqsystemeventhandler/src/irqsystemeventhandler_p.cpp
changeset 5 0930554dc389
parent 3 ee64f059b8e1
child 14 896e9dbc5f19
equal deleted inserted replaced
3:ee64f059b8e1 5:0930554dc389
     9 * Initial Contributors:
     9 * Initial Contributors:
    10 * Nokia Corporation - initial contribution.
    10 * Nokia Corporation - initial contribution.
    11 *
    11 *
    12 * Contributors:
    12 * Contributors:
    13 *
    13 *
    14 * Description:  Contains logic for watching certain disk's space
    14 * Description:
    15 *
    15 *
    16 */
    16 */
    17 
    17 
    18 #include "irqsystemeventhandler.h"
    18 #include "irqsystemeventhandler.h"
    19 #include "irqsystemeventhandler_p.h"
    19 #include "irqsystemeventhandler_p.h"
    20 #include "irdiskspaceobserver.h"
    20 #include "irdiskspaceobserver.h"
    21 #include "iralarmobserver.h"
    21 #include "iralarmobserver.h"
       
    22 #include "irpropertyobserver.h"
       
    23 #include "irqlogger.h"
    22 
    24 
    23 #ifdef USER_DEFINED_DISKSPACE 
    25 #ifdef USER_DEFINED_DISKSPACE 
    24 #include <QFile>
    26 #include <QFile>
    25 #include <QTextStream>
    27 #include <QTextStream>
    26 #include <QStringList> 
    28 #include <QStringList> 
    27 #endif
    29 #endif
    28 
    30 
       
    31 #define DEFAULT_DISKSPACE_LOW_LEVEL   (3*1024*1024)
    29 
    32 
    30 IRQSystemEventHandlerPrivate::IRQSystemEventHandlerPrivate(IRQSystemEventHandler *aSystemEventHandler) : q_ptr(aSystemEventHandler),
    33 IRQSystemEventHandlerPrivate::IRQSystemEventHandlerPrivate(IRQSystemEventHandler *aSystemEventHandler) : q_ptr(aSystemEventHandler),
    31                               mAlarmOn(false),mDefaultLevel(3*1024*1024),mAlarmObserver(NULL), mDiskSpaceObserver(NULL)
    34                               mAlarmOn(false),mDefaultLevel(DEFAULT_DISKSPACE_LOW_LEVEL),mAlarmObserver(NULL), mDiskSpaceObserver(NULL),
       
    35                               mPropertyObserver(NULL),mErrorCode(0)
    32 { 
    36 { 
    33 }
    37 }
    34 
    38 
    35 IRQSystemEventHandlerPrivate::~IRQSystemEventHandlerPrivate()
    39 IRQSystemEventHandlerPrivate::~IRQSystemEventHandlerPrivate()
    36 {
    40 {
    37     cancel();
    41     cancel();
    38     delete mDiskSpaceObserver;
    42     delete mDiskSpaceObserver;
    39     delete mAlarmObserver;   
    43     delete mAlarmObserver;   
       
    44     delete mPropertyObserver;
    40 }
    45 }
    41 
    46 
    42 bool IRQSystemEventHandlerPrivate::init()
    47 bool IRQSystemEventHandlerPrivate::init()
    43 { 
    48 { 
    44 #ifdef USER_DEFINED_DISKSPACE
    49 #ifdef USER_DEFINED_DISKSPACE
    50     {
    55     {
    51         return true;
    56         return true;
    52     }
    57     }
    53     else
    58     else
    54     {
    59     {
       
    60         mAlarmObserver = NULL;
    55         mDiskSpaceObserver = NULL;
    61         mDiskSpaceObserver = NULL;
    56         mAlarmObserver = NULL;
    62         mPropertyObserver = NULL;        
    57     }
    63     }
    58     
    64     
    59     
    65     
    60     return false;
    66     return false;
    61 }
    67 }
    74 
    80 
    75 
    81 
    76 void IRQSystemEventHandlerPrivate::initializeL()
    82 void IRQSystemEventHandlerPrivate::initializeL()
    77 {
    83 {
    78     mAlarmObserver = CIRAlarmObserver::NewLC(this);    
    84     mAlarmObserver = CIRAlarmObserver::NewLC(this);    
    79     mDiskSpaceObserver = CIRDiskSpaceObserver::NewL(this);
    85     mDiskSpaceObserver = CIRDiskSpaceObserver::NewLC(this);
    80     CleanupStack::Pop(mAlarmObserver);
    86     mPropertyObserver = CIRPropertyObserver::NewL(this);   
       
    87     CleanupStack::Pop(mDiskSpaceObserver);
       
    88     CleanupStack::Pop(mAlarmObserver);    
    81 }
    89 }
    82 
    90 
    83 void IRQSystemEventHandlerPrivate::cancel()
    91 void IRQSystemEventHandlerPrivate::cancel()
    84 {
    92 {
    85     if( mAlarmObserver )
    93     if( mAlarmObserver )
   101     }
   109     }
   102     
   110     
   103     if( mDiskSpaceObserver )
   111     if( mDiskSpaceObserver )
   104     {
   112     {
   105         mDiskSpaceObserver->Start((TInt64)mDefaultLevel);            
   113         mDiskSpaceObserver->Start((TInt64)mDefaultLevel);            
   106     }    
   114     }       
   107 }
   115 }
       
   116 
   108 
   117 
   109 bool IRQSystemEventHandlerPrivate::isBelowCriticalLevel(const qint64 aCriticalLevel)
   118 bool IRQSystemEventHandlerPrivate::isBelowCriticalLevel(const qint64 aCriticalLevel)
   110 {
   119 {
   111     if( 0 == aCriticalLevel )
   120     if( 0 == aCriticalLevel )
   112     {
   121     {
   113         return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)mDefaultLevel );
   122         return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)mDefaultLevel );
   114     }
   123     }
   115     
   124     
   116     return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)aCriticalLevel );
   125     return mDiskSpaceObserver->IsBelowCriticalLevel((TInt64)aCriticalLevel );
       
   126 }
       
   127 
       
   128 bool IRQSystemEventHandlerPrivate::isCallActive() const
       
   129 {
       
   130     return mPropertyObserver->IsCallActive();
       
   131 }
       
   132 
       
   133 int IRQSystemEventHandlerPrivate::getErrorCode() const
       
   134 {
       
   135     return mErrorCode;
   117 }
   136 }
   118 
   137 
   119 #ifdef USER_DEFINED_DISKSPACE
   138 #ifdef USER_DEFINED_DISKSPACE
   120 void IRQSystemEventHandlerPrivate::getDiskSpaceCriticalLevel(qint64 & aLevel)
   139 void IRQSystemEventHandlerPrivate::getDiskSpaceCriticalLevel(qint64 & aLevel)
   121 {
   140 {
   165 
   184 
   166 void IRQSystemEventHandlerPrivate::notifyLowDiskSpace(qint64 aCriticalLevel)
   185 void IRQSystemEventHandlerPrivate::notifyLowDiskSpace(qint64 aCriticalLevel)
   167 {
   186 {
   168     emit q_ptr->diskSpaceLowNotification(aCriticalLevel);
   187     emit q_ptr->diskSpaceLowNotification(aCriticalLevel);
   169 }
   188 }
       
   189 
       
   190 void IRQSystemEventHandlerPrivate::callIsActivated()
       
   191 {
       
   192     LOG_METHOD;
       
   193     emit q_ptr->callActivated();    
       
   194 }
       
   195 
       
   196 void IRQSystemEventHandlerPrivate::callIsDeactivated()
       
   197 {
       
   198     LOG_METHOD;
       
   199     emit q_ptr->callDeactivated();    
       
   200 }
       
   201 
       
   202 void IRQSystemEventHandlerPrivate::errorCallback(int aError)
       
   203 {
       
   204     mErrorCode = aError;
       
   205 }
       
   206 
       
   207 void IRQSystemEventHandlerPrivate::headsetIsConnected()
       
   208 {
       
   209     LOG_METHOD;    
       
   210     emit q_ptr->headsetConnected();
       
   211 }
       
   212 
       
   213 void IRQSystemEventHandlerPrivate::headsetIsDisconnected()
       
   214 {
       
   215     LOG_METHOD;
       
   216     emit q_ptr->headsetDisconnected();
       
   217 }
       
   218 
   170  
   219  
   171 
   220 
   172 
   221 
   173 
   222 
   174 
   223