/*

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

* All rights reserved.

* This component and the accompanying materials are made available

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

* which accompanies this distribution, and is available

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

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

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

*

*/

#include <pathinfo.h>

#include "irqdiskspaceobserver.h"

#include "irqdiskspaceobserverinterface.h"

const TDriveNumber KQtIRDefaultDrive = EDriveC;

const TUint KDriveAValue = 'A';

const TUint KDriveZValue = 'Z';

const TUint KDriveaValue = 'a';

const TUint KDrivezValue = 'z';

static TDriveNumber phoneMemRootDrive();

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

IRQDiskSpaceObserver* IRQDiskSpaceObserver::NewL(MIRQDiskSpaceObserver* aObserver)

{

    IRQDiskSpaceObserver* self = new (ELeave) IRQDiskSpaceObserver(aObserver);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

// ---------------------------------------------------------------------------

// Second stage constructor

// ---------------------------------------------------------------------------

//

void IRQDiskSpaceObserver::ConstructL()

{

    CActiveScheduler::Add(this);

    User::LeaveIfError(iFs.Connect());

}

// ---------------------------------------------------------------------------

// C++ Constructor

// ---------------------------------------------------------------------------

//

IRQDiskSpaceObserver::IRQDiskSpaceObserver( MIRQDiskSpaceObserver* aObserver )

                              : CActive( CActive::EPriorityStandard ),       

                                iObserver( aObserver ),

                                iCriticalLevel(0)

{

}

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//            

IRQDiskSpaceObserver::~IRQDiskSpaceObserver()

{

    Cancel();

    iFs.Close();    

}

// ---------------------------------------------------------------------------

// Critical Level

// ---------------------------------------------------------------------------

//

TInt64 IRQDiskSpaceObserver::criticalLevel() const

{

    if(IsActive())

    {

        return iCriticalLevel;

    }

    else

    {

        return -1;

    }    

}

// ---------------------------------------------------------------------------

// Start Monitoring

// ---------------------------------------------------------------------------

//

void IRQDiskSpaceObserver::start(const TInt64 aCriticalLevel)

{

    Cancel();

    iCriticalLevel = aCriticalLevel;

    run();

}

// ---------------------------------------------------------------------------

// From class CActive. 

// Cancels the pending request.

// ---------------------------------------------------------------------------

//

void IRQDiskSpaceObserver::DoCancel() 

{    

    iFs.NotifyDiskSpaceCancel(iStatus);

}

// ---------------------------------------------------------------------------

// From class CActive. 

// Invoked when the observed disk's free disk space has run below

// the supplied critical level.

// Notifies the observer and regenerates the request to RFs' NotifyDiskSpace.

// ---------------------------------------------------------------------------

//

void IRQDiskSpaceObserver::RunL()

{       

    run();   

}

// ---------------------------------------------------------------------------

// Returns true if below the critical level in defined disk, otherwise false

// ---------------------------------------------------------------------------

//

bool IRQDiskSpaceObserver::isBelowCriticalLevel(const TInt64 aCriticalLevel) const

{

    TVolumeInfo volInfo;

    if(KErrNone == iFs.Volume(volInfo, KQtIRDefaultDrive))

    {

        if(volInfo.iFree < aCriticalLevel)

        {

            return true;

        }

    }

    return false;

}

void IRQDiskSpaceObserver::run()

{

    if( iObserver && isBelowCriticalLevel(iCriticalLevel))

    {

        iObserver->notifyLowDiskSpace((qint64)iCriticalLevel);

    }

    iFs.NotifyDiskSpace(iCriticalLevel, phoneMemRootDrive(), iStatus);

    SetActive(); 

}

TDriveNumber phoneMemRootDrive()

{

    TParsePtrC phoneMemoryRootPath( PathInfo::PhoneMemoryRootPath() );

    TPtrC drive( phoneMemoryRootPath.Drive() );

    TUint driveValue = drive[0];

    TUint delta = 0;

    if( driveValue >= KDriveAValue &&

        driveValue <= KDriveZValue)

    {

        delta = driveValue - KDriveAValue;

    }

    else if( driveValue >= KDriveaValue &&

            driveValue <= KDrivezValue)

    {

        delta = driveValue - KDriveaValue;

    }

    else

    {

        return KQtIRDefaultDrive;

    }

    return static_cast<TDriveNumber>(EDriveA + delta);

}