CTC++ Coverage Report - Execution Profile    #2/7

Directory Summary | Files Summary | Functions Summary | Execution Profile
To files: First | Previous | Next | Last | Index | No Index


File: N:\myprogram\forrrelease1\oodmonitor\oodmonitor2\src\outofdiskmonitor.cpp
Instrumentation mode: function
TER: 61 % ( 11/ 18)

Start/ End/    
True False - Line Source

  1 /*
  2 * Copyright (c) 2007 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:  Implementation of COutOfDiskMonitor class.
  15 *
  16 */
  17 
  18 
  19 // SYSTEM INCLUDES
  20 #include <driveinfo.h>
  21 #include <centralrepository.h>
  22 
  23 // USER INCLUDES
  24 #include "outofdiskmonitor.h"
  25 #include "outofdisknotifyobserver.h"
  26 #include "OodTraces.h"
  27 #include "UiklafInternalCRKeys.h"
  28 #include "outofdiskpsobserver.h"
  29 #include "UiklafInternalCRKeys.h"
  30 
  31 // CONSTANTS
  32 // ============================ MEMBER FUNCTIONS ===============================
  33 
  34 // ---------------------------------------------------------
  35 //
  36 // ---------------------------------------------------------
  37 //
Top
  38 COutOfDiskMonitor* COutOfDiskMonitor::NewL(MShutdownEventObserver& aObserver)
  39     { // static
  40     TRACES("COutOfDiskMonitor::NewL");
  41     COutOfDiskMonitor* self = new(ELeave) COutOfDiskMonitor(aObserver);
  42     CleanupStack::PushL(self);
  43     self->ConstructL();
  44     CleanupStack::Pop(self);
  45     return self;
  46     }
  47 
  48 // ---------------------------------------------------------
  49 //
  50 // ---------------------------------------------------------
  51 //
Top
  52 COutOfDiskMonitor::~COutOfDiskMonitor()
  53     {
  54     TRACES("COutOfDiskMonitor::~COutOfDiskMonitor");
  55     delete iOutOfDiskNotifyObserver;
  56     delete iOutOfDiskGlobalNote;    
  57     iResourceFile.Close();
  58     iFs.Close();
  59     for( TInt i = EDriveA; i <= EDriveZ; i++ )
  60         {
  61             if( iDriveStatus[i].iTimer )
  62             {
  63             iDriveStatus[i].iTimer->Cancel();
  64             delete iDriveStatus[i].iTimer;
  65             }
  66         }
  67 
  68     TRACES("COutOfDiskMonitor::~COutOfDiskMonitor: End");
  69     }
  70 
  71 // ---------------------------------------------------------
  72 //
  73 // ---------------------------------------------------------
  74 //
Top
  75 COutOfDiskMonitor::COutOfDiskMonitor(MShutdownEventObserver& aObserver)
  76     : CLafShutdownManagerBase(aObserver),
  77       iGlobalNotesAllowed(EFalse)
  78     {
  79     TRACES("COutOfDiskMonitor::COutOfDiskMonitor");
  80     }
  81 
  82 // ---------------------------------------------------------
  83 //
  84 // ---------------------------------------------------------
  85 //
Top
  86 void COutOfDiskMonitor::ConstructL()
  87     {
  88     TRACES("COutOfDiskMonitor::ConstructL"); 
  89    
  90     TRACES("COutOfDiskMonitor::ConstructL: Connect to FS");
  91     User::LeaveIfError(iFs.Connect());
  92     
  93     DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, iDefaultPhoneMemory );
  94     DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, iDefaultMassStorage );
  95     TRACES2("COutOfDiskMonitor::ConstructL: Default Phone mem %c, default mass mem %c"
  96                     ,iDefaultPhoneMemory+'A',iDefaultMassStorage+'A');      
  97     
  98     iOutOfDiskGlobalNote = COutOfDiskGlobalNote::NewL( this, iFs );
  99 
  100     for( TInt i = EDriveA; i <= EDriveZ; i++ )
  101         {
  102         SaveDriveStatus(i, DISK_SPACE_OK, ETrue);
  103         }
  104     
  105     iOutOfDiskPSObserver = COutOfDiskPSObserver::NewL( this );
  106 
  107     CRepository* repository( NULL );
  108     TInt warningThreshold(0);
  109     TInt criticalThreshold(0);
  110     TInt warningThresholdMassMemory(0);
  111     TRAPD( err, repository = CRepository::NewL( KCRUidUiklaf ) );
  112     if ( err == KErrNone )
  113         {
  114         err = repository->Get(KUikOODDiskFreeSpaceWarningNoteLevel, warningThreshold);
  115         err = repository->Get(KUikOODDiskCriticalThreshold, criticalThreshold);
  116         err = repository->Get(KUikOODDiskFreeSpaceWarningNoteLevelMassMemory, warningThresholdMassMemory);
  117         }
  118     delete repository;
  119     iOODWarningThreshold = warningThreshold;
  120     iOODCriticalThreshold = criticalThreshold;
  121     iOODWarningThresholdMassMemory = warningThresholdMassMemory;
  122     
  123    TRACES1("COutOfDiskMonitor::ConstructL: Warning threshold Phone Memory: %d percent",iOODWarningThreshold);
  124     TRACES1("COutOfDiskMonitor::ConstructL: Critical threshold: %ld bytes",iOODCriticalThreshold);
  125     TRACES1("COutOfDiskMonitor::ConstructL: Warning threshold Mass Memory: %ld bytes",iOODWarningThresholdMassMemory);
  126     
  127     iOutOfDiskNotifyObserver = COutOfDiskNotifyObserver::NewL( this, iFs );
  128     TRACES("COutOfDiskMonitor::ConstructL: End");
  129     }
  130 
  131 // ---------------------------------------------------------
  132 // 
  133 // 
  134 // ---------------------------------------------------------
  135 //
Top
  136 void COutOfDiskMonitor::ShowGlobalQueryIfNeededL()
  137     {
  138     TRACES("COutOfDiskMonitor::ShowGlobalQueryIfNeededL");
  139     TInt drive = GetTopPriorityDrive();
  140     if (drive != KErrNotFound)
  141         {
  142         iOutOfDiskGlobalNote->ShowGlobalQueryL(iDriveStatus[drive].iStatus, drive);
  143         }
  144     TRACES("COutOfDiskMonitor::ShowGlobalQueryIfNeededL: End");
  145     }
  146     
  147 // ---------------------------------------------------------
  148 //
  149 // ---------------------------------------------------------
  150 //
Top
- 151 TInt COutOfDiskMonitor::DoStopTimingL( TAny* aParam )
  152     {
  153     TAfterNoteTimer* p = reinterpret_cast<TAfterNoteTimer*>( aParam );
  154     COutOfDiskMonitor* oodm = STATIC_CAST( COutOfDiskMonitor*, p->iOODM ); // cast
  155     TBool ret =  oodm->ResetDisplayedStatus(p->iDrive); // call non-static function   
  156     if ( ret )
  157         {
  158         delete p;
  159         p = NULL;
  160         }
  161     return KErrNone;
  162     }
  163 
  164 // ---------------------------------------------------------
  165 //
  166 // ---------------------------------------------------------
  167 //
Top
  168 TInt COutOfDiskMonitor::GetDriveStatus(TInt aDrive)
  169     {
  170     TRACES("COutOfDiskMonitor::GetDriveStatus");
  171     TInt64 freeSpace(0);
  172     TInt state(DISK_SPACE_OK);
  173     TVolumeInfo volInfo;
  174     TInt ret( iFs.Volume( volInfo, aDrive ) );
  175     if ( ret == KErrNone )
  176         {
  177         freeSpace = volInfo.iFree;
  178         TRACES1("COutOfDiskMonitor::GetDriveStatus: Free space: %ld",freeSpace);           
  179         }
  180     else
  181         {
  182         TRACES1("COutOfDiskMonitor::GetDriveStatus: End: Returns %d",state);
  183         return state;
  184         }
  185     
  186     if (freeSpace < GetThreshold(DISK_SPACE_WARNING, aDrive) && 
  187         freeSpace > GetThreshold(DISK_SPACE_CRITICAL, aDrive))
  188         {
  189         state = DISK_SPACE_WARNING;
  190         }    
  191     else if (freeSpace <= iOODCriticalThreshold)
  192         {
  193         state = DISK_SPACE_CRITICAL;
  194         }
  195     TRACES1("COutOfDiskMonitor::GetDriveStatus: End: Returns %d",state);
  196     return state;
  197     }
  198 
  199 // ---------------------------------------------------------
  200 //
  201 // ---------------------------------------------------------
  202 //
Top
  203 TInt64 COutOfDiskMonitor::GetThreshold(TInt aLevel, TInt aDrive)
  204     {
  205     TRACES2("COutOfDiskMonitor::GetThreshold(aLevel=%d, aDrive=%d)",aLevel, aDrive);
  206     TInt64 threshold(KErrNotFound);
  207     if (aLevel == DISK_SPACE_WARNING)
  208         {
  209       TVolumeInfo volInfo;
  210       TInt ret( iFs.Volume( volInfo, aDrive ) );
  211         TInt64 volSize(volInfo.iSize);
  212         TRACES1("COutOfDiskMonitor::GetThreshold: Volume size: %ld",volSize);      
  213       if ( ret == KErrNone )
  214          {
  215          if(aDrive == EDriveC)
  216              {
  217                 TRACES1("COutOfDiskMonitor::GetThreshold: Warning threshold Phone Memory: Used disk space %d percent",iOODWarningThreshold);
  218                 threshold = ((volSize*(100-iOODWarningThreshold))/100);
  219              }
  220          else
  221              {
  222              if(iOODWarningThresholdMassMemory < volSize )
  223                     {
  224                     TRACES1("COutOfDiskMonitor::GetThreshold: Warning threshold Mass Memory: %ld bytes",iOODWarningThresholdMassMemory);
  225                     threshold = iOODWarningThresholdMassMemory;
  226                     }
  227                 else
  228                     {
  229                     TRACES1("COutOfDiskMonitor::GetThreshold: Warning threshold Phone Memory: Used disk space %d percent",iOODWarningThreshold);
  230                     threshold = ((volSize*(100-iOODWarningThreshold))/100);                                
  231                     }
  232              }
  233          }
  234         }
  235     else if (aLevel == DISK_SPACE_CRITICAL)
  236         {
  237         threshold = iOODCriticalThreshold;
  238         }
  239     TRACES1("COutOfDiskMonitor::GetThreshold: End: Returns %ld",threshold);
  240     return threshold;
  241     }
  242 
  243 // ---------------------------------------------------------
  244 //
  245 // ---------------------------------------------------------
  246 //
Top
28 28   247 void COutOfDiskMonitor::SaveDriveStatus(TInt aDrive, TInt aStatus, TBool aReset)
  248     {
  249     TRACES("COutOfDiskMonitor::SaveDriveStatus");
  250     if (aDrive == iDefaultPhoneMemory)
  251         {
  252         TRACES("COutOfDiskMonitor::SaveDriveStatus: Defult phone mem. Update PS");
  253         RProperty::Set( KPSUidUikon, KUikFFSFreeLevel, aStatus );
  254         }
  255     else if (aDrive == iDefaultMassStorage)
  256         {
  257         TRACES("COutOfDiskMonitor::SaveDriveStatus: Defult mass mem. Update PS");
  258         RProperty::Set( KPSUidUikon, KUikMmcFFSFreeLevel, aStatus );
  259         }
  260 
  261     iDriveStatus[aDrive].iStatus = aStatus;      
  262     if (aReset)
  263         {
  264         ResetDisplayedStatus(aDrive);
  265         }
  266     TRACES3("COutOfDiskMonitor::SaveDriveStatus: End: D: %c, S: %d D: %d",aDrive+'A',aStatus,
  267             iDriveStatus[aDrive].iDisplayed);
  268     }
  269 
  270 // ---------------------------------------------------------
  271 //
  272 // ---------------------------------------------------------
  273 //
Top
28   274 TBool COutOfDiskMonitor::ResetDisplayedStatus(TInt aDrive, TBool aResetAll)
  275     {
  276     TRACES("COutOfDiskMonitor::ResetDisplayedStatus");
  277     if (aResetAll)
  278         {
  279         TRACES("COutOfDiskMonitor::ResetDisplayedStatus: Reset all drives");
  280         for( TInt i = EDriveA; i <= EDriveZ; i++ )
  281             {
  282             if (AllowedToReset(i))
  283                 {
  284                 iDriveStatus[i].iDisplayed = NULL;
  285                 if (iDriveStatus[i].iTimer)
  286                     {
  287                     delete iDriveStatus[i].iTimer;
  288                     iDriveStatus[i].iTimer = NULL;
  289                     return ETrue;
  290                     }
  291                 }
  292             }
  293         }
  294     else
  295         {
  296         TRACES1("COutOfDiskMonitor::ResetDisplayedStatus: Reset drive %c",aDrive+'A');
  297         if (AllowedToReset(aDrive))
  298             {
  299             iDriveStatus[aDrive].iDisplayed = NULL;
  300             if (iDriveStatus[aDrive].iTimer)
  301                 {
  302                 delete iDriveStatus[aDrive].iTimer;
  303                 iDriveStatus[aDrive].iTimer = NULL;
  304                 return ETrue;
  305                 }
  306             }
  307         }
  308     return EFalse;
  309     }
  310 
  311 // ---------------------------------------------------------
  312 //
  313 // ---------------------------------------------------------
  314 //
Top
28   315 TBool COutOfDiskMonitor::AllowedToReset(TInt aDrive)
  316     {
  317     TInt retVal(ETrue);
  318     TNoteInfo noteInfo(iOutOfDiskGlobalNote->GetNoteInfo());
  319     TRACES1("COutOfDiskMonitor::AllowedToReset: Drive %c",aDrive+'A');   
  320     if ((iOutOfDiskGlobalNote->NoteOnDisplay())&&
  321         (noteInfo.iDrive == aDrive))
  322         {
  323         if (noteInfo.iStatus == iDriveStatus[aDrive].iStatus)
  324             {
  325             TRACES("COutOfDiskMonitor::AllowedToReset: Same drive with same status already on display");
  326             retVal = EFalse;
  327             }
  328         else if ( noteInfo.iStatus == DISK_SPACE_CRITICAL && iDriveStatus[aDrive].iStatus == DISK_SPACE_WARNING )
  329             {
  330             TRACES("COutOfDiskMonitor::AllowedToReset: Same drive with worse status already on display");        
  331             retVal = EFalse;
  332             }
  333         }   
  334     TRACES1("COutOfDiskMonitor::AllowedToReset: %d",retVal);      
  335     return retVal;
  336     }
  337 
  338 // ---------------------------------------------------------
  339 //
  340 // ---------------------------------------------------------
  341 //
Top
  342 TInt COutOfDiskMonitor::GetTopPriorityDrive()
  343     {
  344     TRACES("COutOfDiskMonitor::GetTopPriorityDrive");
  345     // 0 - Critical Default Phone Memory
  346     // 1 - Critical Default Mass Storage
  347     // 2 - Critical other drives
  348     // 3 - Warning Default Phone Memory
  349     // 4 - Warning Default Mass Storage
  350     // 5 - Warning other drives
  351 
  352     TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: DPM %d, %d",
  353         iDriveStatus[iDefaultPhoneMemory].iStatus, 
  354         iDriveStatus[iDefaultPhoneMemory].iDisplayed);
  355     
  356     TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: DMS %d, %d",
  357         iDriveStatus[iDefaultMassStorage].iStatus, 
  358         iDriveStatus[iDefaultMassStorage].iDisplayed);
  359     
  360     if (iDriveStatus[iDefaultPhoneMemory].iStatus == DISK_SPACE_CRITICAL &&
  361         (iDriveStatus[iDefaultPhoneMemory].iDisplayed == NULL ||
  362         iDriveStatus[iDefaultPhoneMemory].iDisplayed == DISK_SPACE_WARNING)) 
  363         {
  364         TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: Drive %c, status %d"
  365                         ,iDefaultPhoneMemory+'A',DISK_SPACE_CRITICAL);            
  366         return iDefaultPhoneMemory;
  367         }
  368     if (iDriveStatus[iDefaultMassStorage].iStatus == DISK_SPACE_CRITICAL &&
  369         iDriveStatus[iDefaultMassStorage].iDisplayed == NULL )
  370         {
  371         TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: Drive %c, status %d"
  372                         ,iDefaultMassStorage+'A',DISK_SPACE_CRITICAL);
  373         return iDefaultMassStorage;
  374         }
  375     for( TInt i = EDriveA; i <= EDriveZ; i++ )
  376         {
  377         if (iDriveStatus[i].iStatus == DISK_SPACE_CRITICAL &&
  378             iDriveStatus[i].iDisplayed == NULL )
  379             {
  380             TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: Drive %c, status %d"
  381                         ,i+'A',iDriveStatus[i].iStatus);                
  382             return i;
  383             }
  384         }
  385     if (iDriveStatus[iDefaultPhoneMemory].iStatus == DISK_SPACE_WARNING &&
  386         iDriveStatus[iDefaultPhoneMemory].iDisplayed == NULL )
  387         {
  388         TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: Drive %c, status %d"
  389                         ,iDefaultPhoneMemory+'A',DISK_SPACE_WARNING);
  390         return iDefaultPhoneMemory;
  391         }
  392     if (iDriveStatus[iDefaultMassStorage].iStatus == DISK_SPACE_WARNING &&
  393         iDriveStatus[iDefaultMassStorage].iDisplayed == NULL )
  394         {
  395         TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: Drive %c, status %d"
  396                         ,iDefaultMassStorage+'A',DISK_SPACE_WARNING);
  397         return iDefaultMassStorage;
  398         }
  399     for( TInt i = EDriveA; i <= EDriveZ; i++ )
  400         {
  401         if (iDriveStatus[i].iStatus == DISK_SPACE_WARNING &&
  402             iDriveStatus[i].iDisplayed == NULL )
  403             {
  404             TRACES2("COutOfDiskMonitor::GetTopPriorityDrive: Drive %c, status %d"
  405                         ,i+'A',iDriveStatus[i].iStatus);
  406             return i;
  407             }
  408         }
  409    TRACES("COutOfDiskMonitor::GetTopPriorityDrive: return KErrNotFound");
  410     return KErrNotFound;
  411     }
  412 
  413 // ---------------------------------------------------------
  414 //
  415 // ---------------------------------------------------------
  416 //
Top
- 417 void COutOfDiskMonitor::SetAsDisplayedL(TInt aDrive, TInt aDriveStatus)
  418     {
  419     TRACES2("COutOfDiskMonitor::SetAsDisplayedL: Drive %d: DriveStatus %d",aDrive, aDriveStatus);
  420     iDriveStatus[aDrive].iDisplayed = aDriveStatus;
  421     // Don't show notes for same drive on a given time. Show only if state is following cases:
  422     // 1) State is going worse
  423     // 2) Autolock off
  424     // 3) The drive is unmounted and mounted again
  425     // 4) Phone is restarted
  426     if ( !iDriveStatus[aDrive].iTimer)
  427         {
  428         TAfterNoteTimer* p = 0;
  429         p = new (ELeave) TAfterNoteTimer;
  430         p->iOODM = this;
  431         p->iDrive = aDrive;
  432         iDriveStatus[aDrive].iTimer = CPeriodic::NewL( EPriorityNormal );
  433         iDriveStatus[aDrive].iTimer->Start( KDelayAfterNote, KDelayAfterNote, TCallBack( DoStopTimingL, p ) );
  434         }
  435     }
  436 
  437 // ---------------------------------------------------------
  438 //
  439 // ---------------------------------------------------------
  440 //
Top
- 441 void COutOfDiskMonitor::SetGlobalNotesAllowed(TInt aValue)
  442     {
  443     TRACES1("COutOfDiskMonitor::SetGlobalNotesAllowed: Value %d",aValue);
  444     if (aValue)
  445         iGlobalNotesAllowed = ETrue;
  446     else
  447         iGlobalNotesAllowed = EFalse;
  448     }
  449 
  450 // ---------------------------------------------------------
  451 //
  452 // ---------------------------------------------------------
  453 //
Top
- 454 TBool COutOfDiskMonitor::GetGlobalNotesAllowed()
  455     {
  456     TRACES1("COutOfDiskMonitor::GetGlobalNotesAllowed: Value %d",iGlobalNotesAllowed);
  457     return iGlobalNotesAllowed;
  458     }
  459 
  460 // ---------------------------------------------------------
  461 //
  462 // ---------------------------------------------------------
  463 //
Top
- 464 TInt COutOfDiskMonitor::GetDefaultPhoneMemory()
  465     {
  466     TRACES("COutOfDiskMonitor::GetDefaultPhoneMemory");
  467     return iDefaultPhoneMemory;
  468     }
  469 
  470 // ---------------------------------------------------------
  471 //
  472 // ---------------------------------------------------------
  473 //
Top
- 474 TInt COutOfDiskMonitor::GetDefaultMassStorage()
  475     {
  476     TRACES("COutOfDiskMonitor::GetDefaultMassStorage");
  477     return iDefaultMassStorage;
  478     }
  479 
  480 // ---------------------------------------------------------
  481 //
  482 // ---------------------------------------------------------
  483 //
Top
- 484 TInt COutOfDiskMonitor::GetDefaultRomDrive()
  485     {
  486     TRACES("COutOfDiskMonitor::GetDefaultRomDrive");
  487     return iDefaultRomDrive;
  488     }
  489 // End of file.
***TER 61% (11/18) of SOURCE FILE outofdiskmonitor.cpp

Directory Summary | Files Summary | Functions Summary | Execution Profile
To files: First | Previous | Next | Last | Top | Index | No Index