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:  Low disk space observer for harvester server

    15 *

    16 */

    17 

    18 #include "harvesterdiskspaceobserver.h"

    19 #include "harvestercommon.h"

    20 

    21 CMdSHarvesterDiskspaceObserverAO* CMdSHarvesterDiskspaceObserverAO::NewL(

    22     MMdSHarvesterDiskSpaceObserver& aObserver, TInt64 aThreshold, const TDesC& aFilename)

    23     {

    24     CMdSHarvesterDiskspaceObserverAO* self = 

    25         CMdSHarvesterDiskspaceObserverAO::NewLC( aObserver, aThreshold, aFilename );

    26     CleanupStack::Pop( self );

    27     return self;

    28     }

    29 

    30 CMdSHarvesterDiskspaceObserverAO* CMdSHarvesterDiskspaceObserverAO::NewLC(

    31     MMdSHarvesterDiskSpaceObserver& aObserver, TInt64 aThreshold, const TDesC& aFilename)

    32     {

    33     TDriveNumber driveNumber = GetDriveNumberL( aFilename );

    34 

    35     CMdSHarvesterDiskspaceObserverAO* self = 

    36         new ( ELeave ) CMdSHarvesterDiskspaceObserverAO( aObserver, aThreshold, driveNumber );

    37     CleanupStack::PushL( self );

    38     self->ConstructL();

    39     return self;

    40     }

    41 

    42 CMdSHarvesterDiskspaceObserverAO::~CMdSHarvesterDiskspaceObserverAO()

    43     {

    44     Cancel();

    45 

    46     iFileServerSession.Close();

    47     }

    48 

    49 void CMdSHarvesterDiskspaceObserverAO::RunL()

    50     {   

    51     TVolumeInfo volumeInfo;

    52 

    53     if ( iState == CMdSHarvesterDiskspaceObserverAO::ENormal )

    54         {

    55         TInt status = iStatus.Int();

    56         

    57         switch( status )

    58             {

    59             case KErrNone:

    60                 {

    61                 const TInt error = iFileServerSession.Volume( volumeInfo, iDrive );

    62                 if( error != KErrNone )

    63                     {

    64                     // Continue harvester if some error in accessing volume occures so that harvester does not remain paused forever 

    65                     iObserver.HandleDiskSpaceNotificationL( MMdSHarvesterDiskSpaceObserver::EMore );

    66                     StartNotifier();

    67                     break;

    68                     }

    69                 

    70                 // Check if free space is less than threshold level

    71                 if( volumeInfo.iFree < iThreshold )

    72                     {

    73                     iObserver.HandleDiskSpaceNotificationL( MMdSHarvesterDiskSpaceObserver::ELess );

    74                     iState = EIterate;

    75                     iIterationCount = 0;

    76                     SetActive();

    77                     TRequestStatus* status = &iStatus;

    78                     User::RequestComplete( status, KErrNone );

    79                     return;

    80                     }

    81                 else

    82                     {

    83                     iObserver.HandleDiskSpaceNotificationL( MMdSHarvesterDiskSpaceObserver::EMore );

    84                     }

    85                 StartNotifier();

    86                 break;

    87                 }

    88 

    89             default:

    90                 StartNotifier();

    91                 break;

    92             }

    93         }

    94     else if ( iState == CMdSHarvesterDiskspaceObserverAO::EIterate )

    95         {

    96         const TInt KMaxIterations = 5;

    97         TInt error = iFileServerSession.Volume( volumeInfo, iDrive );

    98         if( error != KErrNone )

    99             {

   100             // Continue harvester if some error in accessing volume occures so that harvester does not remain paused forever 

   101             iObserver.HandleDiskSpaceNotificationL( MMdSHarvesterDiskSpaceObserver::EMore );

   102             iState = ENormal;

   103             iIterationCount = 0;

   104             StartNotifier();

   105             return;

   106             }

   107 

   108         if ( volumeInfo.iFree < iThreshold )

   109             {

   110             ++iIterationCount;

   111             if ( iIterationCount < KMaxIterations )

   112                 {

   113                 SetActive();

   114                 TRequestStatus* status = &iStatus;

   115                 User::RequestComplete( status, KErrNone );

   116                 return;

   117                 }

   118             }

   119         else

   120             {

   121             iObserver.HandleDiskSpaceNotificationL( MMdSHarvesterDiskSpaceObserver::EMore );

   122             }

   123         iState = ENormal;

   124         iIterationCount = 0;

   125         StartNotifier();            

   126         }

   127     else

   128         {

   129         User::Leave( KErrGeneral );

   130         }

   131     }

   132 

   133 TInt CMdSHarvesterDiskspaceObserverAO::RunError(TInt /*aError*/)

   134     {

   135     StartNotifier();     

   136     

   137     return KErrNone;

   138     }

   139 

   140 void CMdSHarvesterDiskspaceObserverAO::DoCancel()

   141     {

   142     if( IsActive() )

   143         {   

   144         iFileServerSession.NotifyDiskSpaceCancel();

   145         }

   146     }

   147 

   148 CMdSHarvesterDiskspaceObserverAO::CMdSHarvesterDiskspaceObserverAO(

   149     MMdSHarvesterDiskSpaceObserver& aObserver, TInt64 aThreshold, TDriveNumber aDrive)

   150     : CActive( KHarvesterPriorityMonitorPlugin), 

   151     iObserver( aObserver ), iThreshold( aThreshold ), iDrive( aDrive ), iState( CMdSHarvesterDiskspaceObserverAO::ENormal )

   152     {

   153     CActiveScheduler::Add( this );

   154     }

   155 

   156 void CMdSHarvesterDiskspaceObserverAO::ConstructL()

   157     {   

   158     TInt KMessageSlotCount = 2; // slots for NotifyDiskSpace and NotifyDiskSpaceCancel

   159 

   160     User::LeaveIfError( iFileServerSession.Connect( KMessageSlotCount ) );

   161 

   162     StartNotifier();

   163     }

   164 

   165 void CMdSHarvesterDiskspaceObserverAO::StartNotifier()

   166     {   

   167     iFileServerSession.NotifyDiskSpace( iThreshold, iDrive, iStatus );

   168     

   169     SetActive();

   170     }

   171 

   172 TDriveNumber CMdSHarvesterDiskspaceObserverAO::GetDriveNumberL( const TDesC& aFilename )

   173     {

   174     TLex driveParser( aFilename );

   175     

   176     TChar driveChar = driveParser.Get();

   177 

   178     if( 0 == driveChar || TChar( ':' ) != driveParser.Peek() )

   179         {

   180         User::Leave( KErrArgument );

   181         }

   182         

   183     TInt driveNumber;

   184     

   185     RFs::CharToDrive( driveChar, driveNumber );

   186     

   187     return (TDriveNumber)driveNumber;

   188     }

   189