/*

* 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 <e32std.h>

#include "iaupdateselfupdaterctrl.h"

#include "iaupdatenode.h"

#include "iaupdatebasenode.h"

#include "iaupdatependingnodesfile.h"

#include "iaupdateridentifier.h"

#include "iaupdaterestartinfo.h"

#include "iaupdaterendezvous.h"

#include "iaupdateselfupdaterobserver.h"

#include "iaupdatedebug.h"

// Self updater file handling objects

#include "iaupdaterfilelistfile.h"

// Self updater header for udpater constants

#include "iaupdaterdefs.h"

CIAUpdateSelfUpdaterCtrl* CIAUpdateSelfUpdaterCtrl::NewL( 

    MIAUpdateSelfUpdaterObserver& aObserver )

    {

    CIAUpdateSelfUpdaterCtrl* self =

        CIAUpdateSelfUpdaterCtrl::NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

CIAUpdateSelfUpdaterCtrl* CIAUpdateSelfUpdaterCtrl::NewLC( 

    MIAUpdateSelfUpdaterObserver& aObserver )

    {

    CIAUpdateSelfUpdaterCtrl* self =

        new( ELeave ) CIAUpdateSelfUpdaterCtrl( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

CIAUpdateSelfUpdaterCtrl::CIAUpdateSelfUpdaterCtrl( 

    MIAUpdateSelfUpdaterObserver& aObserver )

: CBase(),

  iObserver( aObserver )

    {

    }

void CIAUpdateSelfUpdaterCtrl::ConstructL()

    {

    iRendezvous = CIAUpdateRendezvous::NewL( *this );

    iFile = CIAUpdaterFileListFile::NewL();

    }

CIAUpdateSelfUpdaterCtrl::~CIAUpdateSelfUpdaterCtrl()

    {

    delete iRendezvous;

    delete iFile;

    }

TBool CIAUpdateSelfUpdaterCtrl::DataExists() const

    {

    TInt count( iFile->FileList().Count() );

    if ( count == 0 )

        {

        IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::DataExists no data");

        return EFalse;

        }

    else

        {

        IAUPDATE_TRACE_1("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::DataExists count: %d", count );

        return ETrue;

        }    

    }    

TBool CIAUpdateSelfUpdaterCtrl::StartL( 

    TInt aIndex, 

    TInt aTotalCount,

    const RPointerArray< MIAUpdateNode >& aPendingNodes,

    TBool aSilent )

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartL begin");

    if ( !DataExists() )

        {

        // Nothing to do.

        return EFalse;

        }

    // Set the information if the dialogs should be shown or

    // if the operation should be silent. Also,set the index 

    // and total count info.

    // Rest has been set before.

    File().SetSilent( aSilent );

    File().SetPckgStartIndex( aIndex );

    File().SetTotalPckgCount( aTotalCount );

    // Write data into the file for the self updater to use.

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartL write file");

    File().WriteDataL();

    // Now, that the data is written, reset filelist

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartL reset file");

    File().Reset();

    // Save the pending node infromation

    CIAUpdatePendingNodesFile* pendingNodesFile( 

        CIAUpdatePendingNodesFile::NewLC() );

    pendingNodesFile->SetIndex( aIndex );

    for ( TInt i = 0; i < aPendingNodes.Count(); ++i )

        {

        MIAUpdateNode* node( aPendingNodes[ i ] );

        MIAUpdateBaseNode& baseNode( node->Base() );

        CIAUpdaterIdentifier* identifier( CIAUpdaterIdentifier::NewLC() );

        identifier->SetUid( baseNode.Uid() );

        identifier->SetIdL( baseNode.MetaId() );

        identifier->SetNamespaceL( baseNode.MetaNamespace() );

        pendingNodesFile->PendingNodes().AppendL( identifier );

        CleanupStack::Pop( identifier );

        }

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartL write pending nodes file");

    pendingNodesFile->WriteDataL();

    CleanupStack::PopAndDestroy( pendingNodesFile );

    StartUpdaterProcessL();

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartL end");

    return ETrue;

    }

void CIAUpdateSelfUpdaterCtrl::Reset()

    {

    File().Reset();    

    }

void CIAUpdateSelfUpdaterCtrl::AddFileListL( 

    CIAUpdaterFileList* aFileList )

    {

    // Notice, that the ownership is transferred here.

    File().FileList().AppendL( aFileList );

    }

CIAUpdateRestartInfo* CIAUpdateSelfUpdaterCtrl::SelfUpdateRestartInfo()

    {

    CIAUpdateRestartInfo* info( NULL );

    TRAP_IGNORE( info = CIAUpdateRestartInfo::NewL() );

    return info;

    }

void CIAUpdateSelfUpdaterCtrl::RendezvousComplete( 

    TInt aErrorCode )

    {

    // Self updater finished its job and informed about it by setting the

    // rendezvous complete.

    Observer().SelfUpdaterComplete( aErrorCode );

    }

MIAUpdateSelfUpdaterObserver& CIAUpdateSelfUpdaterCtrl::Observer()

    {

    return iObserver;

    }

CIAUpdaterFileListFile& CIAUpdateSelfUpdaterCtrl::File()

    {

    return *iFile;

    }

CIAUpdateRendezvous& CIAUpdateSelfUpdaterCtrl::RendezvousListener()

    {

    return *iRendezvous;

    }

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

// CIAUpdateSelfUpdaterCtrl::StartUpdaterProcessL()

// 

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

//	

void CIAUpdateSelfUpdaterCtrl::StartUpdaterProcessL()

    {

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartUpdaterProcessL begin");

    // Start IAD Update

    // The application is started here by using process handle. 

    // This way we get the process id, which is required for the 

    // rendezvous listener.

    RProcess process;

    CleanupClosePushL( process );

    // Create the process

    User::LeaveIfError( 

        process.Create( IAUpdaterDefs::KIAUpdaterExe, KNullDesC ) );

    RendezvousListener().StartL( process.Id() );

    // Start executing the process.

    process.Resume();

    CleanupStack::PopAndDestroy( &process );

    IAUPDATE_TRACE("[IAUPDATE] CIAUpdateSelfUpdaterCtrl::StartUpdaterProcessL end");

    }