1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Contains logic for watching certain disk's space

    15 *

    16 */

    17 

    18 #include <e32base.h>

    19 #ifdef USER_DEFINED_DISKSPACE

    20 #include <QFile>

    21 #include <QTextStream>

    22 #include <QStringList>

    23 #endif

    24 #include "irqdiskspacewatcher.h"

    25 #include "irqdiskspaceobserver.h"

    26 

    27 const TInt KIR_DEFAULT_CRITICAL_LEVEL = 3*1024*1024;    // 3MB

    28 

    29 #ifdef USER_DEFINED_DISKSPACE

    30 void getDiskSpaceCriticalLevel(qint64 & aLevel);

    31 #endif

    32 

    33 // ---------------------------------------------------------------------------

    34 // Constructor

    35 // ---------------------------------------------------------------------------

    36 //

    37 EXPORT_C IRQDiskSpaceWatcher::IRQDiskSpaceWatcher()

    38        : iDiskSpaceObserver(NULL),

    39          iDefaultLevel(KIR_DEFAULT_CRITICAL_LEVEL) 

    40 {

    41 #ifdef USER_DEFINED_DISKSPACE

    42     getDiskSpaceCriticalLevel(iDefaultLevel);

    43 #endif    

    44 }

    45 

    46 // ---------------------------------------------------------------------------

    47 // Destructor

    48 // ---------------------------------------------------------------------------

    49 //

    50 EXPORT_C IRQDiskSpaceWatcher::~IRQDiskSpaceWatcher()

    51 {

    52     delete iDiskSpaceObserver;

    53     iDiskSpaceObserver = NULL;

    54 }

    55 

    56 

    57 // ---------------------------------------------------------------------------

    58 // IRQDiskSpaceWatcher::criticalLevel()

    59 // return critical level which is been observed.

    60 // ---------------------------------------------------------------------------

    61 //

    62 EXPORT_C qint64 IRQDiskSpaceWatcher::criticalLevel() const

    63 {

    64     if(NULL != iDiskSpaceObserver)

    65     {

    66         return (qint64)(iDiskSpaceObserver->criticalLevel());

    67     }

    68     else

    69     {

    70         return -1;

    71     }

    72 }

    73 

    74 

    75 // ---------------------------------------------------------------------------

    76 // IRQDiskSpaceWatcher::startMonitorDrive()

    77 // start monitoring disk space change

    78 // ---------------------------------------------------------------------------

    79 //

    80 EXPORT_C bool IRQDiskSpaceWatcher::startMonitorDrive(const qint64 aCriticalLevel)

    81 {

    82     if(aCriticalLevel < 0)

    83     {

    84         return false;

    85     }

    86     

    87     if(NULL == iDiskSpaceObserver)

    88     {

    89         TRAPD(err, iDiskSpaceObserver = IRQDiskSpaceObserver::NewL(this))

    90         if(KErrNone != err)

    91         {

    92             return false;

    93         }

    94     }

    95     

    96     stopMonitorDrive();

    97     iDiskSpaceObserver->start((TInt64)aCriticalLevel);

    98     return true;

    99 }

   100 

   101 EXPORT_C bool IRQDiskSpaceWatcher::startMonitorDrive()

   102 {

   103     return startMonitorDrive(iDefaultLevel);

   104 }

   105 // ---------------------------------------------------------------------------

   106 // IRQDiskSpaceWatcher::stopMonitorDrive()

   107 // stop monitoring disk space change

   108 // ---------------------------------------------------------------------------

   109 //

   110 EXPORT_C void IRQDiskSpaceWatcher::stopMonitorDrive()

   111 {

   112     if(NULL != iDiskSpaceObserver)

   113     {

   114         iDiskSpaceObserver->Cancel();

   115     }

   116 }

   117 

   118 // ---------------------------------------------------------------------------

   119 // IRQDiskSpaceWatcher::isBelowCriticalLevel()

   120 // ---------------------------------------------------------------------------

   121 //

   122 EXPORT_C bool IRQDiskSpaceWatcher::isBelowCriticalLevel( const qint64 aCriticalLevel )

   123 {

   124     if(NULL == iDiskSpaceObserver)

   125     {

   126         TRAPD(err, iDiskSpaceObserver = IRQDiskSpaceObserver::NewL(this))

   127         if(KErrNone != err)

   128         {

   129             return false;

   130         }

   131     }

   132     

   133     return iDiskSpaceObserver->isBelowCriticalLevel((TInt64)aCriticalLevel );

   134 }                               

   135 

   136 EXPORT_C bool IRQDiskSpaceWatcher::isBelowCriticalLevel()

   137 {

   138     return isBelowCriticalLevel(iDefaultLevel);

   139 }

   140 

   141 // ---------------------------------------------------------------------------

   142 // From MIRQDiskSpaceObserver.

   143 // ---------------------------------------------------------------------------

   144 //

   145 void IRQDiskSpaceWatcher::notifyLowDiskSpace(const qint64 aCriticalLevel)

   146 {

   147     emit diskSpaceLow(aCriticalLevel);

   148 }

   149 

   150 #ifdef USER_DEFINED_DISKSPACE

   151 void getDiskSpaceCriticalLevel(qint64 & aLevel)

   152 {

   153     QFile file("C:\\data\\QTIRConfigure.txt");

   154     if(file.open(QIODevice::ReadOnly)) 

   155     {

   156         QTextStream stream( &file );

   157         QString line;

   158         QStringList parameter;

   159         while (!stream.atEnd())

   160         {

   161             line = stream.readLine();

   162             parameter = line.split("=");

   163             if (parameter.count() == 2)

   164             {

   165                 if (parameter.first() == "diskSpaceCriticalLevel")

   166                 {

   167                     QString level = parameter.last();

   168                     aLevel = level.toLongLong();

   169                     break;

   170                 }

   171             }

   172         }

   173     }

   174     file.close();

   175 }

   176 #endif