/*

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

*

*/

// INCLUDE FILES

#include <pathinfo.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include "sconsbeclient.h"

#include "debug.h"

const TInt KDataBufExpandSize( 1024 );

const TInt KMaxObjectSize( 1048576 - 1024 ); // Max chunk size is 1MB, but give some space for ConML wbxml

_LIT( KSConNoDrive, "\x0" );

_LIT( KSConDriveExists, "\x1" );

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

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

// CSConSBEClient::NewL( cosnt TInt aMaxObjectSize )

// Two-phase constructor

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

//  

CSConSBEClient* CSConSBEClient::NewL( const TInt aMaxObjectSize, RFs& aFs )

    {

    TRACE_FUNC;

    CSConSBEClient* self = new (ELeave) CSConSBEClient( aMaxObjectSize, aFs );

    return self;

    }

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

// CSConSBEClient::CSConSBEClient( const TInt aMaxObjectSize )

// Constructor

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

//

CSConSBEClient::CSConSBEClient( const TInt /*aMaxObjectSize*/, RFs& aFs ) : 

        CActive( EPriorityStandard ), iBURModeNormal( ETrue ), iFs( aFs )

    {

    }

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

// CSConSBEClient::~CSConSBEClient()

// Initializes member data

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

//  

CSConSBEClient::~CSConSBEClient()

    {

    TRACE_FUNC_ENTRY;

    TInt err( KErrNone );

    if( !iBURModeNormal && iSBEClient )

        {

        TDriveList driveList;

        for( TInt i = 0; i<KMaxDrives; i++ )

            {

            if( i == EDriveC || i == EDriveE )

                {

                driveList.Append( KSConDriveExists );

                }

            else

                {

                driveList.Append( KSConNoDrive );

                }

            }

        TRAP( err, iSBEClient->SetBURModeL( driveList, EBURNormal, ENoBackup ) );

        }

    if( iSBEClient )

        {

        delete iSBEClient;

        iSBEClient = NULL;

        }

    delete iDataBuffer;

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )

// Set backup/restore mode

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

//  

void CSConSBEClient::SetBURMode( TRequestStatus& aStatus, CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus; 

    User::RequestComplete( status, KErrNone ); 

    SetActive();

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus, 

//                                  CSConTask*& aTask )

// Lists public files from data owners

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

//  

void CSConSBEClient::ListPublicFiles( TRequestStatus& aStatus, 

                                    CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus; 

    User::RequestComplete( status, KErrNone ); 

    SetActive();    

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::ListDataOwners( TRequestStatus& aStatus, CSConTask*& aTask )

// Lists participant data owners

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

//  

void CSConSBEClient::ListDataOwners( TRequestStatus& aStatus, CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus; 

    User::RequestComplete( status, KErrNone ); 

    SetActive();

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::GetDataSize( TRequestStatus& aStatus, CSConTask*& aTask )

// Lists data sizes from data owners

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

//  

void CSConSBEClient::GetDataSize( TRequestStatus& aStatus, CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus; 

    User::RequestComplete( status, KErrNone ); 

    SetActive();

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::RequestData( TRequestStatus& aStatus, CSConTask*& aTask )

// Request a data from a data owner

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

//  

void CSConSBEClient::RequestData( TRequestStatus& aStatus, CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );          

    SetActive();    

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus, 

//                                      CSConTask*& aTask )

// Lists the status of data owners

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

//  

void CSConSBEClient::GetDataOwnerStatus( TRequestStatus& aStatus, 

                                        CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus; 

    User::RequestComplete( status, KErrNone ); 

    SetActive();

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::SupplyData( TRequestStatus& aStatus, CSConTask*& aTask )

// Supplies a data to a data owner

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

//  

void CSConSBEClient::SupplyData( TRequestStatus& aStatus, CSConTask*& aTask )

    {

    TRACE_FUNC_ENTRY;

    iCallerStatus = &aStatus;

    *iCallerStatus = KRequestPending;

    iCurrentTask = aTask;

    TRequestStatus* status = &iStatus; 

    User::RequestComplete( status, KErrNone ); 

    SetActive();    

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::DoCancel()

// Implementation of CActive::DoCancel()

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

//          

void CSConSBEClient::DoCancel()

    {

    TRACE_FUNC;

    }

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

// CSConSBEClient::RunL()

// Implementation of CActive::RunL()

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

//              

void CSConSBEClient::RunL()

    {

    TRACE_FUNC_ENTRY;

    TInt err( KErrNone );

    TInt ret( KErrNone );

    //Initialize a connection to the backup server

    if( !iSBEClient )

        {

        iSBEClient = CSBEClient::NewL();

        }   

    switch( iCurrentTask->GetServiceId() )

        {

        case ESetBURMode :

            LOGGER_WRITE( "CSConSBEClient::RunL() : ESetBURMode" );

            TRAP( err, ProcessSetBURModeL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessSetBURModeL() : returned %d", err );

            break;

        case EListPublicFiles :

            LOGGER_WRITE( "CSConSBEClient::RunL() : EListPublicFiles" );

            TRAP( err, ProcessListPublicFilesL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListPublicFilesL() : returned %d", err );

            break;

        case EListDataOwners :

            LOGGER_WRITE( "CSConSBEClient::RunL() : EListDataOwners" ); 

            TRAP( err, ProcessListDataOwnersL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessListDataOwnersL() : returned %d", err );

            break;

        case EGetDataSize :

            LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataSize" );    

            TRAP( err, ProcessGetDataSizeL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataSizeL() : returned %d", err );

            break;

        case ERequestData :

            LOGGER_WRITE( "CSConSBEClient::RunL() : ERequestData" );

            TRAP( err, ret = ProcessRequestDataL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessRequestDataL() : returned %d", err );

            break;  

        case EGetDataOwnerStatus :

            LOGGER_WRITE( "CSConSBEClient::RunL() : EGetDataOwnerStatus" );

            TRAP( err, ProcessGetDataOwnerStatusL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : ProcessGetDataOwnerStatusL() : returned %d", err );

            break;

        case ESupplyData :

            LOGGER_WRITE( "CSConSBEClient::RunL() : ESupplyData" ); 

            TRAP( err, ret = ProcessSupplyDataL() );

            LOGGER_WRITE_1( "CSConSBEClient::RunL() : SupplyDataL() : returned %d", err );

            break;

        default :

            err = KErrNotSupported;

            LOGGER_WRITE( "CSConSBEClient::RunL() : ERROR! Unknown!" ); 

            break;

        }

    if ( err )

        {

        HandleSBEErrorL( err );

        }

    else

        {

        err = ret;

        }

    User::RequestComplete( iCallerStatus, err );

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::ProcessSetBURModeL()

// Executes SetBURMode task

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

//  

void CSConSBEClient::ProcessSetBURModeL()

    {

    TRACE_FUNC_ENTRY;

    iAllSnapshotsSuppliedCalled = EFalse;

    iLastChunk = EFalse;

    TDriveList driveList = iCurrentTask->iBURModeParams->iDriveList;

    TBURPartType partialType = EBURUnset;

    iRestoreMode = EFalse;

    switch( iCurrentTask->iBURModeParams->iPartialType )

        {

        case ESConBurNormal :

            partialType = EBURNormal;

            break;

        case ESConBurBackupFull :

            partialType = EBURBackupFull;

            break;

        case ESConBurBackupPartial :

            partialType = EBURBackupPartial;

            break;

        case ESConBurRestoreFull :

            partialType = EBURRestoreFull;

            iRestoreMode = ETrue;

            break;

        case ESConBurRestorePartial :

            partialType = EBURRestorePartial;

            iRestoreMode = ETrue;

            break;

        default :

            partialType = EBURUnset;

            break;

        }

    if ( partialType == EBURBackupFull || partialType == ESConBurBackupPartial )

        {

        // initialize buffer

        if ( !iDataBuffer )

            iDataBuffer = CBufFlat::NewL( KDataBufExpandSize );

        else

            iDataBuffer->Reset();

        iDataBufferSize=0;

        }

    else

        {

        delete iDataBuffer;

        iDataBuffer = 0;

        }

    TBackupIncType incType = ENoBackup;

    switch( iCurrentTask->iBURModeParams->iIncType )    

        {

        case ESConNoBackup :

            incType = ENoBackup;

            break;

        case ESConBackupBase :

            incType = EBackupBase;

            break;

        case ESConBackupIncrement :

            incType = EBackupIncrement;

            break;

        default :

            incType = ENoBackup;

            break;

        }

    iSBEClient->SetBURModeL( driveList, partialType, incType );

    if( partialType != EBURNormal )

        {

        iBURModeNormal = EFalse;

        }

    else

        {

        iBURModeNormal = ETrue;

        }

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::ProcessListPublicFilesL()

// Executes ListPublicFiles task

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

//

void CSConSBEClient::ProcessListPublicFilesL()

    {

    TRACE_FUNC_ENTRY;

    //Get the secure id

    TSecureId sid = iCurrentTask->iPubFilesParams->iDataOwners[0]->iUid;

    TSecureId packageSid;

    LOGGER_WRITE_1("DO: 0x%08x", sid.iId);

    TPtrC packageName(KNullDesC);

    const TUint KSConUidLength = 8; // 8 digits (hex)

    const TUint KSConUidPrefixLength = 3; // prefix is '#0x'

    TInt packageNameLength = iCurrentTask->iPubFilesParams->iDataOwners[0]->iPackageName.Length();

    if ( packageNameLength > KSConUidLength )

        {

        // remove uid from package name

        packageName.Set( 

                iCurrentTask->iPubFilesParams->iDataOwners[0]->

                iPackageName.Left( packageNameLength - (KSConUidLength + KSConUidPrefixLength) ) );

        LOGGER_WRITE_1("PackageName: %S", &packageName );

        TPtrC sidPtr( iCurrentTask->iPubFilesParams->iDataOwners[0]->

                iPackageName.Right( KSConUidLength ) );

        TLex lex(sidPtr);

        TInt err = lex.Val( packageSid.iId, EHex );

        if ( err )

            {

            LOGGER_WRITE_1("lex.Val error: %d", err);

            packageName.Set( KNullDesC );

            packageSid.iId = 0;

            }

        LOGGER_WRITE_1("packageSid: 0x%08x", packageSid.iId );

        }

    //Get the drive list

    TDriveList driveList = 

    iCurrentTask->iPubFilesParams->iDataOwners[0]->iDriveList;

    RFileArray files;

    CleanupClosePushL( files );

    //Go through all the drives in the list

    for( TInt i = 0; i < KMaxDrives; i++ )

        {

        if( driveList[i] )

            {

            //Get files from the drive

            TDriveNumber driveNumber = GetDriveNumber( i );

            LOGGER_WRITE_1("driveNumber: %d", driveNumber);

            LOGGER_WRITE("List public files using CSBSecureId");

            CSBSecureId* secureId = CSBSecureId::NewL( sid );

            CleanupStack::PushL( secureId );

            TRAPD( err, iSBEClient->PublicFileListL( driveNumber, *secureId, files ) );

            if( err != KErrNone && err != KErrNotFound )

                {

                LOGGER_WRITE_1("iSBEClient->PublicFileListL leaved: %d", err);

                User::LeaveIfError( err );

                }

            CleanupStack::PopAndDestroy( secureId );

            LOGGER_WRITE_1("public files: %d", files.Count());

            AppendFilesToFilelistL( files, iCurrentTask->iPubFilesParams->iFiles) ;

            if ( packageName.Length() > 0 )

                {

                LOGGER_WRITE("Append files registered to packages. Using CSBPackageId");

                CSBPackageId* packageId = CSBPackageId::NewL(

                        iCurrentTask->iPubFilesParams->iDataOwners[0]->iUid,

                        packageSid,

                        packageName );

                CleanupStack::PushL( packageId );

                TRAPD( err, iSBEClient->PublicFileListL( driveNumber, *packageId, files ) );

                if( err != KErrNone && err != KErrNotFound )

                    {

                    LOGGER_WRITE_1("iSBEClient->PublicFileListL leaved: %d", err);

                    User::LeaveIfError( err );

                    }

                CleanupStack::PopAndDestroy( packageId );

                LOGGER_WRITE_1("public files: %d", files.Count());

                AppendFilesToFilelistL( files, iCurrentTask->iPubFilesParams->iFiles) ;

                }

            files.Reset();

            }

        }

    CleanupStack::PopAndDestroy( &files );

    TRACE_FUNC_EXIT;

    }

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

// CSConSBEClient::ProcessListDataOwnersL()

// Executes ListDataOwners task

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

//

void CSConSBEClient::ProcessListDataOwnersL()

    {

    TRACE_FUNC_ENTRY;

    TBool includeToList( ETrue );

    RPointerArray<CDataOwnerInfo> dataOwners;

    RArray<TUid> packageArray;

    CleanupResetAndDestroyPushL( dataOwners );

    CleanupClosePushL( packageArray );

    iSBEClient->ListOfDataOwnersL( dataOwners );

    LOGGER_WRITE_1( "dataOwners count: %d", dataOwners.Count() );

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

        {

        LOGGER_WRITE_2("handling do: %d, count: %d", i, dataOwners.Count());

        CSConDataOwner* dataOwner = new (ELeave) CSConDataOwner();

        CleanupStack::PushL( dataOwner );

        // default values

        TSecureId sid( 0 );

        includeToList = ETrue;