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

#include "CMMCScBkupStateRequestListOfPublicFiles.h"

// System includes
#include <e32std.h>

// User includes
#include "MMCScBkupLogger.h"
#include "MMCScBkupSBEUtils.h"
#include "CMMCScBkupDataOwnerInfo.h"
#include "RMMCScBkupProgressSizer.h"
#include "CMMCScBkupDataOwnerInfo.h"
#include "MMMCScBkupProgressObserver.h"
#include "CMMCScBkupFileListCollection.h"
#include "CMMCScBkupDataOwnerCollection.h"




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

// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles()
// 
// C++ constructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles( MMMCScBkupDriver& aDriver )
:   CMMCScBkupState( aDriver )
    {
    __LOG1("CMMCScBkupStateRequestListOfPublicFiles::CMMCScBkupStateRequestListOfPublicFiles() - 0x%08x", StateId().iUid );
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::~CMMCScBkupStateRequestListOfPublicFiles()
// 
// Destructor.
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestListOfPublicFiles::~CMMCScBkupStateRequestListOfPublicFiles()
    {
    Cancel();
    //
    delete iRequestObject;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::ConstructL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestListOfPublicFiles::ConstructL()
    {
    iRequestObject = CMMCScBkupStateRequestSpecificPublicFileInfo::NewL(Driver());
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::NewL()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestListOfPublicFiles* CMMCScBkupStateRequestListOfPublicFiles::NewL( MMMCScBkupDriver& aDriver )
    {
    CMMCScBkupStateRequestListOfPublicFiles* self = new(ELeave) CMMCScBkupStateRequestListOfPublicFiles( aDriver );
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::StateId()
// 
// 
// ---------------------------------------------------------------------------
TMMCScBkupStateId CMMCScBkupStateRequestListOfPublicFiles::StateId() const
    {
    return KMMCScBkupStateIdRequestListOfPublicFiles;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::NextStateId()
// 
// 
// ---------------------------------------------------------------------------
TMMCScBkupStateId CMMCScBkupStateRequestListOfPublicFiles::NextStateId() const
    {
    return KMMCScBkupStateIdValidateDiskSpace;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::PerformStateInitL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestListOfPublicFiles::PerformStateInitL()
    {
    // Set to -1 so that the first time RunL is called, we start with
    // the data owner at index 0.
    iCurrentDataOwnerIndex = -1;
    CompleteSelf(KErrNone);
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousStateStepL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousStateStepL()
    {
    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
    if  (++iCurrentDataOwnerIndex < dataOwners.Count())
        {
        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner(iCurrentDataOwnerIndex);

        const TBool hasPublicFiles = (owner.Owner().PassiveSettings() & EHasPublicFiles);
        if  (hasPublicFiles)
            {
            // Request all the public files (on all supported drives) for this
            // particular data owner
            __ASSERT_ALWAYS(iRequestObject->IsActive() == EFalse, User::Invariant());
            //
            iRequestObject->RequestL(owner, iStatus);
            SetActive();
            }
        else
            {
            // Try next data owner
            CompleteSelf();
            }
        }
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup()
// 
// 
// ---------------------------------------------------------------------------
TBool CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup(TInt aError)
    {
    (void) aError;
    __LOG1("CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup() - **** - error: %d", aError );

    // Cancel requester. Its probably already inactive, but just in case...
    PerformAsynchronousCancellation();

    // Reset state and move to next item. Treat the current (badly behaving) item
    // as completed/processed.
    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
    if  ( iCurrentDataOwnerIndex < dataOwners.Count() )
        {
        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( iCurrentDataOwnerIndex );
        (void) owner;
        __LOGFILE2("CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousErrorCleanup() - **** - error: %d, SID: 0x%08x - PUBLIC data skipped for DO", aError, owner.SecureId().iId );

        // Ensures that asynchronous state step is called again..
        CompleteSelf();
        }

    return ETrue;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousCancellation()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestListOfPublicFiles::PerformAsynchronousCancellation()
    {
    if  ( iRequestObject )
        {
        iRequestObject->Cancel();
        }
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL()
    {
    // Now we can calculate the progress        
    TInt64 totalProgressAmount = 0;

    // Calculate the total progress required for the entire backup operation
    CMMCScBkupDataOwnerCollection& dataOwners = Driver().DrvDataOwners();
    const TInt count = dataOwners.Count();
    //
    RMMCScBkupProgressSizer sizer( Driver().DrvParamsBase().DriveAndOperations() );
    for(TInt i=0; i<count; i++)
        {
        CMMCScBkupDataOwnerInfo& owner = dataOwners.Owner( i );
        //
        totalProgressAmount += sizer.BackupTotalProgressValueL( owner );
        }

    // Check whether all categories have been processed and either store current 
    // progress information in driver or inform progress handler about cumulative progress.
    // If size is getting beyond file system limitation (2GB), leave with KErrxxx.
    if(Driver().DrvLastCategory())
        {
        __LOG2("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - report progress understood (%Ld + %Ld)", 
            totalProgressAmount, Driver().DrvTotalProgress());
        
        Driver().DrvStoreTotalProgress( totalProgressAmount );

        if( Driver().DrvTotalProgress() > KMaxTInt )
            {
            __LOG1("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - leaving with KErrNotSupported due amount of data (%Ld)", 
                Driver().DrvTotalProgress());
            Driver().DrvProgressHandler().MMCScBkupStartBackuping( EFalse );
            User::Leave( KErrNotSupported );
            }
        else
            {
            Driver().DrvProgressHandler().MMCScBkupHandleProgressDomainUnderstood( Driver().DrvTotalProgress() );
            }
        }
    else
        {
        __LOG2("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - adding progress amount %Ld to existing %Ld)", 
            totalProgressAmount, Driver().DrvTotalProgress());
            
        if( (totalProgressAmount + Driver().DrvTotalProgress()) > KMaxTInt )
            {
            __LOG1("CMMCScBkupStateRequestListOfPublicFiles::PerformLastRightsL() - leaving due amount of data (%Ld)", 
                totalProgressAmount + Driver().DrvTotalProgress());
            User::Leave(KErrNotSupported);
            }
        else
            {
            Driver().DrvStoreTotalProgress( totalProgressAmount );
            }
        }
    }








































// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestSpecificPublicFileInfo::CMMCScBkupStateRequestSpecificPublicFileInfo()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestSpecificPublicFileInfo::CMMCScBkupStateRequestSpecificPublicFileInfo( MMMCScBkupDriver& aDriver )
:   CMMCScBkupDriveSpecificRequest( aDriver.DrvParamsBase().DriveAndOperations(), EMMCScBkupOwnerDataTypePublicData ), iDriver(aDriver)
    {
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestSpecificPublicFileInfo::NewL()
// 
// 
// ---------------------------------------------------------------------------
CMMCScBkupStateRequestSpecificPublicFileInfo* CMMCScBkupStateRequestSpecificPublicFileInfo::NewL( MMMCScBkupDriver& aDriver )
    {
    CMMCScBkupStateRequestSpecificPublicFileInfo* self = new (ELeave) CMMCScBkupStateRequestSpecificPublicFileInfo(aDriver);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestSpecificPublicFileInfo::RequestL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestSpecificPublicFileInfo::RequestL( CMMCScBkupDataOwnerInfo& aOwner, TRequestStatus& aObserver )
    {
    iOwner = &aOwner;
    CMMCScBkupDriveSpecificRequest::RequestL( aObserver );

    // Start the asynchronous request. 
    CompleteSelf(KErrNone);
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestSpecificPublicFileInfo::RunL()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestSpecificPublicFileInfo::RunL()
    {
    __LOG1("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - START - iStatus: %d", iStatus.Int());
    User::LeaveIfError(iStatus.Int());
    //
    CDataOwnerInfo& owner = iOwner->Owner();
    const TDriveList& ownerDrives = owner.DriveList();
    TDriveNumber drive = EDriveA;
    const TBool driveAvailable = NextValidDrive(drive, ownerDrives);
    const TSecureId secureId = iOwner->SecureId();

    __LOG3("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - secureId: 0x%08x, driveAvailable: %d, drive: %c", secureId.iId, driveAvailable, drive + 'A');

    if  (driveAvailable)
        {
        // This drive needs to be scanned...
        TInt err( KErrNone );
        RFileArray files;
        CleanupClosePushL(files);

        // Get a copy of the generic data type for which we are
        // requesting file listings...
        CSBGenericDataType* genericDataType = CSBSecureId::NewL( secureId );
        CleanupStack::PushL( genericDataType );
        TRAP( err, Driver().DrvSecureBackupClient().PublicFileListL( drive, *genericDataType, files ) );
        if( err != KErrNone && err != KErrNotFound )
            {
            User::Leave( err );
            }
        CleanupStack::PopAndDestroy( genericDataType );
        // Additionally we need to request list of public files registered for packages.
        if( MMCScBkupSBEUtils::HasSystemDataL( owner ) )
            {
            RFileArray pkgFiles;
            CleanupClosePushL( pkgFiles );
            __LOG2("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - have %d files before package listing for DO, err %d", files.Count(), err);
            TRAP( err, Driver().DrvSecureBackupClient().PublicFileListL( drive, owner.Identifier(), pkgFiles ) );
            __LOG2("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - have %d package files for DO, err %d", files.Count(), err);
            const TInt pkgCount = pkgFiles.Count();
            for(TInt i = 0; i < pkgCount; i++)
                {
                files.AppendL( pkgFiles[i] );
                }
            CleanupStack::PopAndDestroy( &pkgFiles );
            }

        // Add to the file list
        __LOG1("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - have %d files for DO", files.Count());
        if  (files.Count())
            {

            // We want to be told by the public file collection exactly which files
            // it added... We need to do this in order to report progress as accurately 
            // as possible during the backup operation.
            RArray< const CMMCScBkupFileInfo* > addedItems;
            CleanupClosePushL(addedItems);
            
            // Add them to the public data file collection
            Driver().DrvFileList().AppendL( files, addedItems, secureId );
            
            // For each identified file, update the data owner with the size of public data
            const TInt count = addedItems.Count();
            for(TInt i=0; i<count; i++)
                {
                const CMMCScBkupFileInfo& file = *addedItems[i];
                const TInt size = file.Size();
                //
                __LOG3("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - file[%04d] = %S, size: %d", i, &file.FileName(), size);
                iOwner->AddToOperationalSizeL( EMMCScBkupOwnerDataTypePublicData, drive, size );
                }
            //
            CleanupStack::PopAndDestroy( &addedItems );
            }
        //
        CleanupStack::PopAndDestroy( &files );

        // Complete ourself to try the next drive
        CompleteSelf( KErrNone );
        }
    else
        {
        CompleteObserverRequest( KErrNone );
        }

    __LOG("CMMCScBkupStateRequestSpecificPublicFileInfo::RunL() - END");
    }


// ---------------------------------------------------------------------------
// CMMCScBkupStateRequestSpecificPublicFileInfo::DoCancel()
// 
// 
// ---------------------------------------------------------------------------
void CMMCScBkupStateRequestSpecificPublicFileInfo::DoCancel()
    {
    }