/*
* Copyright (c) 2007-2008 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:   CIAUpdateNormalContentOperation 
*
*/



#include <ncdoperation.h>
#include <ncdquery.h>
#include <ncdprogress.h>

#include "iaupdatenormalcontentoperation.h"
#include "iaupdatenodeimpl.h"
#include "iaupdatedebug.h"


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::CIAUpdateNormalContentOperation
// 
// ---------------------------------------------------------------------------
// 
CIAUpdateNormalContentOperation::CIAUpdateNormalContentOperation(
    CIAUpdateBaseNode& aNode,
    MIAUpdateContentOperationObserver& aObserver )
: CIAUpdateContentOperation( aNode, aObserver )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::CIAUpdateNormalContentOperation");
    }


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::ConstructL
// 
// ---------------------------------------------------------------------------
// 
void CIAUpdateNormalContentOperation::ConstructL()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::ConstructL() begin");

    CIAUpdateContentOperation::ConstructL();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::ConstructL() end");
    }


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::~CIAUpdateNormalContentOperation
// 
// ---------------------------------------------------------------------------
// 
CIAUpdateNormalContentOperation::~CIAUpdateNormalContentOperation()
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::~CIAUpdateNormalContentOperation begin");

    // Do not call CancelOperation here because its implementation depends on 
    // child class implementations. So, this object is deleted, the child classes
    // are already deleted and their implementation is not available.
    // So, call CancelOperation in child classes.

    // Operation is created by using the HandleContentL function.
    // If operation is created, it will be released when child class calls
    // CancelOperation.

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


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::StartOperationL
// 
// ---------------------------------------------------------------------------
//
TBool CIAUpdateNormalContentOperation::StartOperationL()
    {
    // Init variables by using the parent.
    CIAUpdateContentOperation::StartOperationL();
    
    // Start new active object round.
    TBool started( EFalse );

    // Start the operation and set the pointer to it.
    // Operation pointer needs to be set for the possible cancellation.
    SetOperation( HandleContentL() );        

    if ( iOperation )
        {
        // Operation exists. So, start it. 
        iOperation->StartOperationL();
        SetOperationInUse( ETrue );
        started = ETrue;
        }
        
    return started;
    }


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::CancelOperation
// 
// ---------------------------------------------------------------------------
//
void CIAUpdateNormalContentOperation::CancelOperation()
    {
    if ( iOperation )
        {
        // Cancel the operation and release the current operation.
        // Notice, that this will result to call to ContentOperationComplete
        iOperation->CancelOperation();
        }
    }


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::ContentQueryReceived
// 
// ---------------------------------------------------------------------------
//
void CIAUpdateNormalContentOperation::ContentQueryReceived( 
    MNcdOperation& aOperation, 
    MNcdQuery* aQuery )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::ContentQueryReceived() begin");

    // Operation query received. Always accept queries.
    // Queries should not be requested from this client.
    TInt trapError( KErrNone );
    if ( aQuery )
        {
        TRAP ( trapError, 
               aQuery->SetResponseL( MNcdQuery::EAccepted );
               aOperation.CompleteQueryL( *aQuery ); );
        // Release needs to be called to the query after it is not used.
        aQuery->Release();        
        }

    if ( ( trapError != KErrNone ) || ( !aQuery ) )
        {
        // Error occurred when query was handled.
        // So, operation can not continue.
        // Cancel operation. Notice, that OperationComplete will be called
        // by the operation when cancel is called.
        aOperation.CancelOperation();
        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::ContentQueryReceived() end");
    }


// ---------------------------------------------------------------------------
// CIAUpdateContentOperation::ContentOperationComplete
// 
// ---------------------------------------------------------------------------
//
void CIAUpdateNormalContentOperation::ContentOperationComplete( 
    MNcdOperation& /*aOperation*/,
    TInt aError )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperation::ContentOperationComplete() begin");

    // Notice, that this releases the old operation.
    SetOperation( NULL );            
    OperationComplete( aError );
    
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateContentOperation::ContentOperationComplete() end");
    }


// ---------------------------------------------------------------------------
// CIAUpdateNormalContentOperation::SetOperation
// 
// ---------------------------------------------------------------------------
// 
void CIAUpdateNormalContentOperation::SetOperation( 
    MNcdOperation* aOperation )
    {
    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::SetOperation() begin");
    
    if ( iOperation )
        {
        IAUPDATE_TRACE("[IAUPDATE] Release old operation before setting new one");        
        iOperation->Release();
        }
    
    iOperation = aOperation;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateNormalContentOperation::SetOperation() end");
    }