/*

* Copyright (c) 2007-2010 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:   This module contains the implementation of CIAUpdateFwNode class 

*                member functions.

*

*/

#include <e32cmn.h>

#include <etelmm.h>

#include <ncdnode.h>

#include <ncdnodecontentinfo.h>

#include <ncdpurchasedownloadinfo.h>

#include <ncdutils.h>

#include "iaupdatefwnodeimpl.h"

#include "iaupdatecontrollerimpl.h"

#include "iaupdatefwpurchaseoperation.h"

#include "iaupdatefwnodeobserver.h"

#include "iaupdatenodedetails.h"

#include "iaupdatedebug.h"

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

// CIAUpdateFwNode::NewLC

// Two-phased constructor.

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

// 

CIAUpdateFwNode* CIAUpdateFwNode::NewLC( 

    MNcdNode* aNode,

    CIAUpdateController& aController,

    MIAUpdateFwNode::TFwUpdateType aFwType )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::NewLC() begin");

    CIAUpdateFwNode* self = 

        new( ELeave ) CIAUpdateFwNode( aController, aFwType );

    CleanupStack::PushL( self );    

    self->ConstructL( aNode );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::NewLC() end");

    return self;

    }

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

// CIAUpdateFwNode::NewL

// Two-phased constructor.

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

//     

CIAUpdateFwNode* CIAUpdateFwNode::NewL( 

    MNcdNode* aNode,

    CIAUpdateController& aController,

    MIAUpdateFwNode::TFwUpdateType aFwType )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::NewL() begin");

    CIAUpdateFwNode* self = 

        CIAUpdateFwNode::NewLC( aNode, aController, aFwType );

    CleanupStack::Pop( self );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::NewL() end");

    return self;

    }

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

// CIAUpdateFwNode::CIAUpdateFwNode

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CIAUpdateFwNode::CIAUpdateFwNode( CIAUpdateController& aController,

                                  MIAUpdateFwNode::TFwUpdateType aFwType ) 

: CIAUpdateBaseNode( aController ),

  iType( aFwType )

    {

    }

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

// CIAUpdateFwNode::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CIAUpdateFwNode::ConstructL( MNcdNode* aNode )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::ConstructL() begin");

    // Let the parent handle it all.

    CIAUpdateBaseNode::ConstructL( aNode );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::ConstructL() end");

    }

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

// CIAUpdateFwNode::~CIAUpdateFwNode

// Destructor

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

//    

CIAUpdateFwNode::~CIAUpdateFwNode()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::~CIAUpdateFwNode() begin");

    if ( iPurchaseOperation )

        {

        // Because purchase operation exists, set the cancelling flag on. 

        // Then, observer callbacks are not called when the deletion of 

        // the object cancels the operation. 

        // Also, notice that instead of directly using the error code given 

        // to callbacks, we use the local cancel flag. So, we can handle cases 

        // when operation was able to finish and cancellation did not occur even

        // if it was requested. That would most likely never occur, but better to

        // be safe than sorry,.

        iCancelling = ETrue;

        // Notice, that callback function will delete the iPurchaseOperation.

        // So, do not call delete instead of cancel operation here because then

        // delete would be called twice for the same pointer. Instead, just use 

        // the CancelOperation function call.

        iPurchaseOperation->CancelOperation();

        // There should not be any need to call delete after cancel above. 

        // But, insert it here just in case the operation functionality changes. 

        // It does not hurt to call it here now

        // because pointer should always be NULL already.

        delete iPurchaseOperation;    

        }

    delete iContentUrl;

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::~CIAUpdateFwNode() end");

    }

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

// MIAUpdateFwNode functions

// 

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

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

// CIAUpdateFwNode::FwType

// 

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

//    

MIAUpdateFwNode::TFwUpdateType CIAUpdateFwNode::FwType() const

    {

    return iType;

    }

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

// CIAUpdateFwNode::FwVersion1

// 

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

//    

const TDesC& CIAUpdateFwNode::FwVersion1() const

    {

    return Details().FwVersion1();

    }

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

// CIAUpdateFwNode::FwVersion2

// 

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

//    

const TDesC& CIAUpdateFwNode::FwVersion2() const

    {

    return Details().FwVersion2();

    }

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

// CIAUpdateFwNode::FwVersion3

// 

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

//    

const TDesC& CIAUpdateFwNode::FwVersion3() const

    {

    return Details().FwVersion3();

    }

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

// CIAUpdateFwNode::InitDownloadDataL

// 

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

//    

TBool CIAUpdateFwNode::InitDownloadDataL( MIAUpdateFwNodeObserver& aObserver )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::InitDownloadDataL() begin");

    if ( iPurchaseOperation )

        {

        IAUPDATE_TRACE("[IAUPDATE] ERROR: KErrInUse, operation already going on.");

        User::Leave( KErrInUse );

        }

    // Create new purchase operation and start it if purchase is necessary.

    IAUPDATE_TRACE("[IAUPDATE] Create new purchase operation");

    CIAUpdateContentOperation* tmpPurchaseOperation(

        CIAUpdateFwPurchaseOperation::NewLC( *this, *this ) );

    TBool operationStarted(

        tmpPurchaseOperation->StartOperationL() );

    if ( operationStarted )

        {

        IAUPDATE_TRACE("[IAUPDATE] Operation started");

        // Ownership will be transferred below to the member variable.

        // So, do not leve the operation into the stack.

        CleanupStack::Pop( tmpPurchaseOperation );

        // Now, that function can not leave, set the member variable values.

        // These values are required when the asynchronous purcahse operation

        // completes and callback functions are called.

        iPurchaseOperation = tmpPurchaseOperation;

        iObserver = &aObserver;        

        }

    else

        {

        // Because operation was not started,

        // delete the operation object.

        CleanupStack::PopAndDestroy( tmpPurchaseOperation );        

        tmpPurchaseOperation = NULL;

        }

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateFwNode::InitDownloadDataL() end: %d",

                     operationStarted);

    return operationStarted;

    }

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

// CIAUpdateFwNode::ContentUrl

// 

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

//    

const TDesC& CIAUpdateFwNode::ContentUrl() const

    {

    if ( !iContentUrl )

        {

        return KNullDesC();

        }

    return *iContentUrl;

    }

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

// CIAUpdateFwNode::NodeType

// 

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

//

MIAUpdateAnyNode::TNodeType CIAUpdateFwNode::NodeType() const

    {

    return MIAUpdateAnyNode::ENodeTypeFw;

    }

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

// CIAUpdateFwNode::Base

// 

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

//

MIAUpdateBaseNode& CIAUpdateFwNode::Base()

    {

    return *this;   

    }

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

// MIAUpdateContentOperationObserver functions

// 

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

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

// CIAUpdateFwNode::ContentOperationComplete

// 

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

//

void CIAUpdateFwNode::ContentOperationComplete( CIAUpdateBaseNode& /*aNode*/, 

                                                TInt aError )

    {

    IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateFwNode::ContentOperationComplete() begin: %d",

                     aError);

    delete iPurchaseOperation;

    iPurchaseOperation = NULL;

    // Use the temporary variable here for the observer because, in some cases,

    // the observer may delete this object when callback is called and no

    // member variables should be used after that.

    MIAUpdateFwNodeObserver* tmpObserver( iObserver );

    // Do not delete observer because it is not owned here.

    // Just set it to NULL.

    iObserver = NULL;

    if ( !iCancelling )

        {

        IAUPDATE_TRACE("[IAUPDATE] Operation not cancelled.");

        // Because operation was not cancelled, 

        // set the URL if everything went OK.        

        if ( aError == KErrNone )

            {

            // If URL can not be set, then replace KErrNone value of aError

            // with the leave error. So, that value will be given for the observer.

            TRAP( aError, SetContentUrlL() );

            }

        IAUPDATE_TRACE_1("[IAUPDATE] Inform observer: %d", aError);

        tmpObserver->InitDownloadDataComplete( *this, aError );        

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::ContentOperationComplete() end");

    }

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

// CIAUpdateFwNode::ContentOperationProgress

// 

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

//

void CIAUpdateFwNode::ContentOperationProgress( CIAUpdateBaseNode& /*aNode*/, 

                                                TInt /*aProgress*/, 

                                                TInt /*aMaxProgress*/ )

    {

    }

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

// CIAUpdateFwNode functions

// 

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

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

// CIAUpdateFwNode::SetContentUrlL

// 

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

//

void CIAUpdateFwNode::SetContentUrlL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::SetContentUrlL() begin");

    // Before trying to set the new values for content URL,

    // delete old values.

    delete iContentUrl;

    iContentUrl = NULL;

    CNcdPurchaseDetails* details( PurchaseDetailsLC() );

    TArray< MNcdPurchaseDownloadInfo* > downloadInfos( 

        details->DownloadInfoL() );

    if ( downloadInfos.Count() == 0 )

        {

        IAUPDATE_TRACE("[IAUPDATE] ERROR: KErrNotFound, no download info");

        User::Leave( KErrNotFound );

        }

    else

        {

        IAUPDATE_TRACE_1("[IAUPDATE] Download info count: %d", 

                         downloadInfos.Count());

        // Always use the first download info even if there exists

        // multiple of them.

        MNcdPurchaseDownloadInfo* info( downloadInfos[ 0 ] );

        // Get the content uri and insert it to the member variable.

        iContentUrl = info->ContentUri().AllocL();

        IAUPDATE_TRACE_1("[IAUPDATE] Content uri set: %S",

                         iContentUrl); 

        }    

    CleanupStack::PopAndDestroy( details );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::SetContentUrlL() end");

    }

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

// CIAUpdateFwNode::SetNameL

// 

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

//

void CIAUpdateFwNode::SetNameL( const MNcdNodeMetadata& /*aMetaData*/ )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::SetNameL() begin");

    RTelServer telServer;

    CleanupClosePushL( telServer );

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

    RTelServer::TPhoneInfo teleinfo;

    User::LeaveIfError( telServer.GetPhoneInfo( 0, teleinfo ) );

    RMobilePhone phone;

    CleanupClosePushL( phone );

    User::LeaveIfError( phone.Open( telServer, teleinfo.iName ) );

    User::LeaveIfError(phone.Initialise()); 

    TUint32 teleidentityCaps;

    phone.GetIdentityCaps( teleidentityCaps );

    RMobilePhone::TMobilePhoneIdentityV1 telid;

    TRequestStatus status;

    phone.GetPhoneId( status, telid );

    User::WaitForRequest( status );

    delete iName;

    iName = NULL;

    if ( status==KErrNone )

        {

        iName = telid.iModel.AllocL(); 

        }

    else

        {

        iName = KNullDesC().AllocL();

        }

    CleanupStack::PopAndDestroy( &phone );

    CleanupStack::PopAndDestroy( &telServer );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateFwNode::SetNameL() end");

    }

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

// CIAUpdateFwNode::SetUiState()

// 

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

//

void CIAUpdateFwNode::SetUiState( MIAUpdateFwNode::TUIUpdateState aState )

    {

    iUiUpdateState = aState;

    }

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

// CIAUpdateFwNode::UiState()

// 

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

//

MIAUpdateFwNode::TUIUpdateState CIAUpdateFwNode::UiState() const

    {

    return iUiUpdateState;

    }