/*
* 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:   ?Description
*
*/




#include <ncdprovider.h>

#include "iaupdatecachecleaner.h"
#include "iaupdatedebug.h"


CIAUpdateCacheCleaner* CIAUpdateCacheCleaner::NewL( MNcdProvider& aProvider )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::NewL begin");
    CIAUpdateCacheCleaner* self(
        CIAUpdateCacheCleaner::NewLC( aProvider ) );
    CleanupStack::Pop( self );
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::NewL end");
    return self;
    }
    
    
CIAUpdateCacheCleaner* CIAUpdateCacheCleaner::NewLC( MNcdProvider& aProvider )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::NewLC begin");
    CIAUpdateCacheCleaner* self(
        new( ELeave ) CIAUpdateCacheCleaner( aProvider ) );
    CleanupStack::PushL( self );
    self->ConstructL();
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::NewLC end");
    return self;
    }


CIAUpdateCacheCleaner::CIAUpdateCacheCleaner( MNcdProvider& aProvider )
: CActive( CActive::EPriorityStandard ),
  iProvider( aProvider )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::CIAUpdateCacheCleaner begin");    

    CActiveScheduler::Add( this );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::CIAUpdateCacheCleaner end");
    }


void CIAUpdateCacheCleaner::ConstructL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::ConstructL");
    }
    
    
CIAUpdateCacheCleaner::~CIAUpdateCacheCleaner()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::~CIAUpdateCacheCleaner begin");    
    
    // Wait until the ongoing operation is finished.
    // Cancel handles this.
    Cancel();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::~CIAUpdateCacheCleaner end");
    }


void CIAUpdateCacheCleaner::ClearL( TRequestStatus& aStatus )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::ClearL begin");    
    
    if ( IsActive()
         || iRequestStatus )
        {
        IAUPDATE_TRACE("[IAUPDATE] ERROR: ClearL already started");
        User::Leave( KErrInUse );
        }

    // Use provider to clear the cache.
    // This will asynchronously finish the operation
    // and update the status when operation finishes.
    // Start to wait the completion in this active object.
    iProvider.ClearCacheL( iStatus );
    SetActive();

    // Set the pending value for the request.
    // Notice, iRequestStatus is just a reference to the
    // actual status object of the user of this object.
    // The user will be informed when the operation finishes
    // by completing the request.
    aStatus = KRequestPending;
    iRequestStatus = &aStatus;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::ClearL begin");    
    }


void CIAUpdateCacheCleaner::DoCancel()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::DoCancel begin");    
    
    // Because we do not have any means to cancel the actual
    // operation. We need to use CActiveSchedulerWait::Start
    // here. This way this function will not proceed directly
    // to the User::WaitForRequest in Cancel after DoCancel. 
    // That would block the thread and the iStatus
    // would not be updated by the cache clear operation. 
    // Then, Cancel would be stuck forever. iWaiter->AsyncStop
    // is called in RunL that is in turn called when the actual 
    // operation finishes. Then, this will continue and the 
    // RunL has set the iStatus and Cancel can continue also.
    TRAP_IGNORE( iWaiter = new( ELeave ) CActiveSchedulerWait() );
	if ( iWaiter  )
	    {
        iWaiter->Start();
        }
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::DoCancel begin");    
    }
    
    
void CIAUpdateCacheCleaner::RunL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::RunL begin");    
    
    TInt errorCode( iStatus.Int() );
    IAUPDATE_TRACE_1("[IAUPDATE] Error code: %d", errorCode);
    
    if ( iWaiter )
        {
        IAUPDATE_TRACE("[IAUPDATE] Waiter exists. Cancel should be going on.");
        
        // Notice, that we come here only when the Cancel is
        // called for this operation and there was an cache
        // clear operation going on.

        // Stop the waiter. 
        // So, DoCancel may continue after this.
        iWaiter->AsyncStop();    
        delete iWaiter;
        iWaiter = NULL;

        // Update the request status.
        // So, Cancel can continue after DoCancel.
        TRequestStatus* status( &iStatus );
        User::RequestComplete( status, errorCode );
        }
    else
        {
        IAUPDATE_TRACE("[IAUPDATE] Cache clear operation done.");
        
        // Complete the original operation because it
        // has completed normally.
        User::RequestComplete( iRequestStatus, errorCode );
        }

    // Because the operation is finished now,
    // set the request status pointer to NULL.
    iRequestStatus = NULL;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateCacheCleaner::RunL end");
    }


TInt CIAUpdateCacheCleaner::RunError( TInt aError )
    {
    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateCacheCleaner::RunError: %d", aError);
    
    // Because the operation is finished now,
    // set the request status pointer to NULL.
    iRequestStatus = NULL;    
    
    // Notice, that if the return value is not KErrNone,
    // the code will panic.
    return aError;
    }