/*

* Copyright (c) 2005-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: CMMCScBkupEngineImpl implementation

*

*

*/

#include "CMMCScBkupEngineImpl.h"

// User includes

#include "MMCScBkupLogger.h"

#include "CMMCScBkupState.h"

#include "MMCScBkupSBEUtils.h"

#include "CMMCScBkupArchive.h"

#include "MMCScBkupOperations.h"

#include "MMCScBkupArchiveUtils.h"

#include "CMMCScBkupStateFactory.h"

#include "MMCScBkupPhoneModelUtils.h"

#include "MMMCScBkupEngineObserver.h"

#include "CMMCScBkupFileListCollection.h"

#include "CMMCScBkupDataOwnerCollection.h"

#include "CMMCScBkupOperationParameters.h"

#include "CMMCScBkupArchiveInfo.h"

#include "BkupEngine.hrh"

#include <pathinfo.h>

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

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

// CMMCScBkupEngineImpl::CMMCScBkupEngineImpl()

// 

// C++ constructor.

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

CMMCScBkupEngineImpl::CMMCScBkupEngineImpl( RFs& aFsSession )

:   CActive( CActive::EPriorityIdle ), 

    iFsSession(aFsSession), 

    iCurrentArchive(0),

    iTotalProgress(0),

    iActiveDataProcessingOngoing(EFalse)

    {

    CActiveScheduler::Add(this);

    }

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

// CMMCScBkupEngineImpl::~CMMCScBkupEngineImpl()

// 

// Destructor.

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

CMMCScBkupEngineImpl::~CMMCScBkupEngineImpl()

    {

    Cancel();

    //

    TRAP_IGNORE(CleanupL());

    iArchives.Close();

    iDataOwners.Close();

    iFileLists.Close();

    delete iSBEClient;

    }

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

// CMMCScBkupEngineImpl::ConstructL()

// 

// Second phase constructor

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

void CMMCScBkupEngineImpl::ConstructL()

    {

    __LOG("CMMCScBkupEngineImpl::ConstructL() - START");

#ifdef MAKE_SBE_LOGGING_DIRECTORY

    _LIT( KSBELoggingDir, "C:\\Logs\\connect\\" );

    iFsSession.MkDirAll( KSBELoggingDir );

#endif

#ifdef MAKE_MMCSCBKUP_LOGGING_DIRECTORY

    iFsSession.MkDirAll( KMMCScBkupLoggingFullPath );

#endif

    __LOG("CMMCScBkupEngineImpl::ConstructL() - END");

    }

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

// CMMCScBkupEngineImpl::NewL()

// 

// Static constructor

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

CMMCScBkupEngineImpl* CMMCScBkupEngineImpl::NewL( RFs& aFsSession )

    {

    CMMCScBkupEngineImpl* self = new(ELeave) CMMCScBkupEngineImpl( aFsSession );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMMCScBkupEngineImpl::StartOperationL()

// 

// 

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

void CMMCScBkupEngineImpl::StartOperationL(TMMCScBkupOperationType aOperation, MMMCScBkupEngineObserver& aObserver, CMMCScBkupOpParamsBase* aParams)

    {

    __ASSERT_DEBUG(DrvOperation() == EMMCScBkupOperationTypeIdle, User::Invariant()); // 

    // Setup our observer - we will report progress via this interface

    iObserver = &aObserver;

    // Take ownership of the parameters immediately

    SetParameters(aParams);

    if(!iSBEClient)

        {

        __LOG("CMMCScBkupEngineImpl::ConstructL() - creating SBE client...");

        iSBEClient = CSBEClient::NewL();

        }

#if defined(__MMCSCBKUPLOGGING_ENABLED__)

    // Create a logging directory for logging purposes and empty contents

    // in order to have the log only from last backup or restore operation

    CFileMan* fileMan = CFileMan::NewL( iFsSession );

    CleanupStack::PushL( fileMan );

    TParse* path = new(ELeave) TParse();

    CleanupStack::PushL(path);

    path->Set(KMMCScBkupLoggingFullPathAndName, NULL, NULL);

    fileMan->Delete( path->Path(), CFileMan::ERecurse ); // Ignore error

    iFsSession.MkDirAll( path->Path() );

    CleanupStack::PopAndDestroy(2, fileMan );

#endif

    // Prepare supporting objects

    PrepareObjectsL();

    // Work out what to do...

    CreateFactoryL( aOperation );

    //

    switch(aOperation)

        {

    case EMMCScBkupOperationTypeIdle:

        __ASSERT_ALWAYS(EFalse, User::Invariant());

        break;

    case EMMCScBkupOperationTypeFullBackup:

    case EMMCScBkupOperationTypePartialBackup:

        PrepareForBackupL( DrvOperation() == EMMCScBkupOperationTypePartialBackup );

        break;

    case EMMCScBkupOperationTypeFullRestore:

    case EMMCScBkupOperationTypePartialRestore:

        PrepareForRestoreL( DrvOperation() == EMMCScBkupOperationTypePartialRestore );

        break;

        }

    // Do this last, after everything that can leave has been executed

    iOperationType = aOperation;

    // Notify the observer we're starting up

    NotifyObserver(MMMCScBkupEngineObserver::ECommonOperationStarting);

    }

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

// CMMCScBkupEngineImpl::ValidArchiveForRestoreL()

// 

// 

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

TBool CMMCScBkupEngineImpl::ValidArchiveForRestoreL( const TDesC& aFileName )

    {

    const TBool valid = CMMCScBkupArchive::ValidArchiveForRestoreL( iFsSession, aFileName );

    return valid;

    }

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

// CMMCScBkupEngineImpl::TotalOperationSizeL()

// 

// 

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

TInt64 CMMCScBkupEngineImpl::TotalOperationSizeL() const

    {

    const TInt64 size = iDataOwners[iCurrentArchive]->TotalOperationalSizeL();

    return size;

    }

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

// CMMCScBkupEngineImpl::RebootRequired()

// 

// NOTE: This method is not used in S60 3.x - Sysap handles the reboot

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

TBool CMMCScBkupEngineImpl::RebootRequired() const

    {

    // Criteria for a reboot are:

    //

    // 1) One or more data owners indicate that a reboot is necessary

    //    via their backup_registration.xml files.

    //

    // 2) The current operation is some form of restore (partial or full).

    const TMMCScBkupOperationType currentOp = DrvOperation();

    __LOG1("CMMCScBkupEngineImpl::RebootRequired() - operation type is: %d", currentOp);

    TBool singleDataOwnerNeedsReboot = EFalse;

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

        {

        singleDataOwnerNeedsReboot |= iDataOwners[i]->RebootRequired();

        }

    __LOG1("CMMCScBkupEngineImpl::RebootRequired() - D.O requires reboot?: %d", singleDataOwnerNeedsReboot);

    const TBool rebootRequired = singleDataOwnerNeedsReboot && 

        ( currentOp == EMMCScBkupOperationTypeFullRestore || 

          currentOp == EMMCScBkupOperationTypePartialRestore );

    __LOG1("CMMCScBkupEngineImpl::RebootRequired() - final rebootRequired value: %d", rebootRequired);

    // We return the value to the caller - the UI will display appropriate

    // UI dialogs and reset the machine as appropriate.

    return rebootRequired;

    }

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

// CMMCScBkupEngineImpl::DrvADI()

// 

// 

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

MMMCScBkupArchiveDataInterface& CMMCScBkupEngineImpl::DrvADI() const

    {

    return iArchives[iCurrentArchive]->ADI();

    }

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

// CMMCScBkupEngineImpl::DrvArchive()

// 

// 

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

CMMCScBkupArchive& CMMCScBkupEngineImpl::DrvArchive() const

    {

    __ASSERT_ALWAYS(iCurrentArchive < iArchives.Count(), User::Invariant());

    return *iArchives[iCurrentArchive];

    }

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

// CMMCScBkupEngineImpl::DrvSecureBackupClient()

// 

// 

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

CSBEClient& CMMCScBkupEngineImpl::DrvSecureBackupClient() const

    {

    return *iSBEClient;

    }

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

// CMMCScBkupEngineImpl::DrvOperation()

// 

// 

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

TMMCScBkupOperationType CMMCScBkupEngineImpl::DrvOperation() const

    {

    return iOperationType;

    }

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

// CMMCScBkupEngineImpl::DrvParamsBase()

// 

// 

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

CMMCScBkupOpParamsBase& CMMCScBkupEngineImpl::DrvParamsBase() const

    {

    return *iParameters;

    }

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

// CMMCScBkupEngineImpl::DrvDataOwners()

// 

// 

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

CMMCScBkupDataOwnerCollection& CMMCScBkupEngineImpl::DrvDataOwners() const

    {

    __ASSERT_ALWAYS(iCurrentArchive < iDataOwners.Count(), User::Invariant());

    return *iDataOwners[iCurrentArchive];

    }

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

// CMMCScBkupEngineImpl::DrvDataOwnersAll()

// 

// 

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

RPointerArray<CMMCScBkupDataOwnerCollection>& CMMCScBkupEngineImpl::DrvDataOwnersAll()

    {

    return iDataOwners;

    }

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

// CMMCScBkupEngineImpl::DrvFileList()

// 

// 

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

CMMCScBkupFileListCollection& CMMCScBkupEngineImpl::DrvFileList() const

    {

    __ASSERT_ALWAYS(iCurrentArchive < iFileLists.Count(), User::Invariant());

    return *iFileLists[iCurrentArchive];

    }

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

// CMMCScBkupEngineImpl::DrvLastCategory()

// 

// 

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

TBool CMMCScBkupEngineImpl::DrvLastCategory() const

    {

    return ( (iCurrentArchive + 1) == iArchives.Count() );

    }

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

// CMMCScBkupEngineImpl::DrvStoreTotalProgress()

// 

// 

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

void CMMCScBkupEngineImpl::DrvStoreTotalProgress(TInt64 aProgress)

    {

    iTotalProgress += aProgress;

    }

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

// CMMCScBkupEngineImpl::DrvTotalProgress()

// 

// 

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

TInt64 CMMCScBkupEngineImpl::DrvTotalProgress() const

    {

    return iTotalProgress;

    }

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

// CMMCScBkupEngineImpl::DrvProgressHandler()

// 

// 

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

MMMCScBkupProgressObserver& CMMCScBkupEngineImpl::DrvProgressHandler() const

    {

    CMMCScBkupEngineImpl* self = const_cast< CMMCScBkupEngineImpl* > (this);

    return *self;

    }

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

// CMMCScBkupEngineImpl::MMCScBkupHandleProgress()

// 

// 

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

void CMMCScBkupEngineImpl::MMCScBkupHandleProgress( TInt aAmountCompleted )

    {

    __ASSERT_ALWAYS( aAmountCompleted >= 0, User::Invariant() );

    if  (aAmountCompleted > 0)

        {

        __LOG1("CMMCScBkupEngineImpl::MMCScBkupHandleProgress() - amount: %d", aAmountCompleted);

        iCumulativeProgress += aAmountCompleted;

        // Notify the observer that we've calculated the operational size

        NotifyObserver( MMMCScBkupEngineObserver::ECommonProgress, iCumulativeProgress );

        }

    }

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

// CMMCScBkupEngineImpl::MMCScBkupHandleProgressDomainUnderstood()

// 

// 

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

void CMMCScBkupEngineImpl::MMCScBkupHandleProgressDomainUnderstood( TInt aTotalProgressAmount )

    {

    __LOG1("CMMCScBkupEngineImpl::MMCScBkupHandleProgressDomainUnderstood() - ##### TOTAL PROGRESS AMOUNT IS: %d", aTotalProgressAmount);

    // Notify the observer that we've calculated the operational size

    NotifyObserver( MMMCScBkupEngineObserver::ECommonSizeOfTaskUnderstood, aTotalProgressAmount );

    }

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

// CMMCScBkupEngineImpl::MMCScBkupHandleFreeSpace()

// 

// 

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

TInt CMMCScBkupEngineImpl::MMCScBkupHandleFreeSpace( TInt aPercentualFree )

    {

    TInt error(KErrNone);

    TRAP_IGNORE( error = iObserver->HandleBkupEngineEventL( MMMCScBkupEngineObserver::EBackupAnalysingData, aPercentualFree ) );

    return error;

    }

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

// CMMCScBkupEngineImpl::MMCScBkupStartBackuping()

// 

// 

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

void CMMCScBkupEngineImpl::MMCScBkupStartBackuping( TBool aProceed )

    {

    __LOG1("CMMCScBkupEngineImpl::MMCScBkupStartBackuping() - Disk space validation done, proceed %d", aProceed);

    if( !aProceed )

        {

        // If there is no space to carry out backup, "restore" existing backup file,

        // so that it can still be restored.

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

            {

            iArchives[i]->RestoreOldArchive( );

            }

        }

    else

        {

        // Clean up existing backup files.

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

            {

            iArchives[i]->DeleteOldArchive( );

            }

        }

    }

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

// CMMCScBkupEngineImpl::RunL()

// 

// 

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

void CMMCScBkupEngineImpl::RunL()

    {

    __LOG(" ");

    __LOG(" ");

    if  ( !CurrentStateAvailable() )

        {

        __LOG2("CMMCScBkupEngineImpl::RunL() - START - iStatus: %d, iCurrentArchive %d", 

            iStatus.Int(), iCurrentArchive);

        }

    else

        {

        __LOG3("CMMCScBkupEngineImpl::RunL() - START - iStatus: %d, state: 0x%08x, iCurrentArchive %d", 

            iStatus.Int(), CurrentState().StateId().iUid, iCurrentArchive);

        }

    User::LeaveIfError(iStatus.Int());

    // Get the state that just finished - its always the head item

    const TBool stateStepAvailable = CurrentStateAvailable();

    __ASSERT_ALWAYS(stateStepAvailable, User::Invariant());

    CMMCScBkupState& currentState = CurrentState();

    // Store completed state id as we're about to delete the object

    // so it won't be available afterwards...

    const TMMCScBkupStateId completedState = currentState.StateId();

    // Identify which state should run next. In effect each state

    // defines the overall state machine. This is required since

    // some states need to dynamically change which state is executed

    // next. A good example is the archive op for active data - when

    // one or more active data clients are not ready, then the next

    // state should be to requery their readyness. After their

    // readyness has been ascertained, then any DO's that have now

    // become ready should be archived. This process continues

    // until all Active Data owners have provided all their data.

    TMMCScBkupStateId nextState;

    __LOG3("CMMCScBkupEngineImpl::RunL() - iActiveDataProcessingOngoing %d, completedState 0x%08x, nextState 0x%08x", 

            iActiveDataProcessingOngoing, completedState.iUid, currentState.NextStateId().iUid);

    // Identify should we run current state again, i.e. run that state 

    // for next category. If state does not require processing of same

    // state several times, then move on to next state.

    if( currentState.CategorySpecific() != CMMCScBkupState::EStateOnce )

        {

        // For simplicity let's collect active data for each category in row.

        // This means checking data owner status before proceeding to next category.

        if( iActiveDataProcessingOngoing )

            {

            iActiveDataProcessingOngoing = EFalse;

            nextState = currentState.NextStateId();

            }

        else 

            {

            if( completedState == KMMCScBkupStateIdArchiveOpActiveData )

                {

                if( currentState.NextStateId() == KMMCScBkupStateIdGetDataOwnerStatuses )

                    {

                    // There is still some active data to be processed

                    iActiveDataProcessingOngoing = ETrue;

                    nextState = KMMCScBkupStateIdGetDataOwnerStatuses;

                    }

                }

            if( !iActiveDataProcessingOngoing )

                {

                if( ++iCurrentArchive < iArchives.Count() )

                    {

                    nextState = completedState;

                    }

                else

                    {

                    iCurrentArchive = 0;

                    nextState = currentState.NextStateId();

                    }