/*
* Copyright (c) 2007 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:  Class for disk space watcher
*
*/


//  INCLUDES
#include <e32std.h>
#include <f32file.h>
#include "diskspacewatcher.h"
#include "disknotifyhandler.h"
#include "disknotifyhandlerdebug.h"


// ======== LOCAL FUNCTIONS ========

// ---------------------------------------------------------------------------
// SetEvent
// ---------------------------------------------------------------------------
//
inline static void SetEvent(
        MDiskNotifyHandlerCallback::TDiskSpaceEvent& aEvent,
        TInt aDrive,
        const TInt64& aThreshold )
    {
    aEvent.iDrive = aDrive;
    aEvent.iThreshold = aThreshold;
    }


// ======== MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::CDiskSpaceWatcher
// ---------------------------------------------------------------------------
//
CDiskSpaceWatcher::CDiskSpaceWatcher(
        MDiskNotifyHandlerCallback& aCallback,
        RFs& aFs,
        RPointerArray< CDiskSpaceWatcher >& aWatcherList,
        TInt aDrive,
        const TInt64& aThreshold ) :
    CDiskWatcherBase( aCallback, aFs ),
    iWatcherList( aWatcherList ),
    iDrive( aDrive ),
    iThreshold( aThreshold )
    {
    FUNC_LOG
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::ConstructL
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::ConstructL()
    {
    FUNC_LOG

    iWatcherList.InsertInOrderL( this, CompareFindObject );
    Activate();
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::NewL
// ---------------------------------------------------------------------------
//
CDiskSpaceWatcher* CDiskSpaceWatcher::NewL(
        MDiskNotifyHandlerCallback& aCallback,
        RFs& aFs,
        RPointerArray< CDiskSpaceWatcher >& aWatcherList,
        TInt aDrive,
        const TInt64& aThreshold )
    {
    FUNC_LOG

    CDiskSpaceWatcher* self = new ( ELeave ) CDiskSpaceWatcher(
        aCallback, aFs, aWatcherList, aDrive, aThreshold );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::~CDiskSpaceWatcher
// ---------------------------------------------------------------------------
//
CDiskSpaceWatcher::~CDiskSpaceWatcher()
    {
    FUNC_LOG

    Cancel();
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::CompareFind
// ---------------------------------------------------------------------------
//
TInt CDiskSpaceWatcher::CompareFind(
        const TInt* aDrive,
        const CDiskSpaceWatcher& aWatcher )
    {
    return Compare( *aDrive, aWatcher.iDrive );
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::CompareFindData
// ---------------------------------------------------------------------------
//
TInt CDiskSpaceWatcher::CompareFindData(
        const TFindData* aData,
        const CDiskSpaceWatcher& aWatcher )
    {
    TInt ret( Compare( aData->iDrive, aWatcher.iDrive ) );
    if ( !ret )
        {
        ret = Compare( aData->iThreshold, aWatcher.iThreshold );
        }
    return ret;
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::CompareFindObject
// ---------------------------------------------------------------------------
//
TInt CDiskSpaceWatcher::CompareFindObject(
        const CDiskSpaceWatcher& aWatcher1,
        const CDiskSpaceWatcher& aWatcher2 )
   {
    TInt ret( Compare( aWatcher1.iDrive, aWatcher2.iDrive ) );
    if ( !ret )
        {
        ret = Compare( aWatcher1.iThreshold, aWatcher2.iThreshold );
        }
    return ret;
   }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::WatcherError
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::WatcherError(
        TInt aError,
        const TBool& aKilled )
    {
    FUNC_LOG

    LOG_IF_ERROR3(
        aError,
        "CDiskSpaceWatcher::WatcherError-iDrive=%d,iThreshold=%Ld,aError=%d",
        iDrive, iThreshold, aError )

    MDiskNotifyHandlerCallback::TDiskSpaceEvent event;
    SetEvent( event, iDrive, iThreshold );
    Callback().HandleNotifyDiskSpace( aError, event );
    if ( aKilled )
        {
        return;
        }
    // Remove useless watcher if not manually activated from callback
    if ( !IsActive() )
        {
        RemoveFromListAndDestroy();
        }
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::ReactivateWatcher
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::ReactivateWatcher()
    {
    FUNC_LOG

    Activate();
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::RunWatcher
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::RunWatcher( const TBool& /*aKilled*/ )
    {
    FUNC_LOG
    
    INFO_LOG2(
        "CDiskSpaceWatcher::RunWatcher-iThreshold=%Ld,iDrive=%d",
        iThreshold, iDrive )

    MDiskNotifyHandlerCallback::TDiskSpaceEvent event;
    SetEvent( event, iDrive, iThreshold );
    Callback().HandleNotifyDiskSpace( KErrNone, event );
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::CancelWatcher
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::CancelWatcher()
    {
    FUNC_LOG

    INFO_LOG2(
        "CDiskSpaceWatcher::CancelWatcher-iThreshold=%Ld,iDrive=%d",
        iThreshold, iDrive )

    Fs().NotifyDiskSpaceCancel( iStatus );
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::Activate
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::Activate()
    {
    FUNC_LOG

    if( !IsActive() )
        {
        INFO_LOG2(
            "CDiskSpaceWatcher::Activate-iThreshold=%Ld,iDrive=%d",
            iThreshold, iDrive )
        Fs().NotifyDiskSpace( iThreshold, iDrive, iStatus );
        SetActive();
        }
    }

// ---------------------------------------------------------------------------
// CDiskSpaceWatcher::RemoveFromListAndDestroy
// ---------------------------------------------------------------------------
//
void CDiskSpaceWatcher::RemoveFromListAndDestroy()
    {
    FUNC_LOG

    TInt i( iWatcherList.FindInOrder( this, CompareFindObject ) );
    if ( i >= 0 && i < iWatcherList.Count() )
        {
        INFO_LOG3(
            "CDiskSpaceWatcher::RemoveFromListAndDestroy-iThreshold=%Ld,iDrive=%d,i=%d",
            iThreshold, iDrive, i )
        iWatcherList.Remove( i );
        delete this;
        }
    }

// End of File