/*

* 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: CMMCScBkupStateGetDataOwners implementation

*

*

*/

#include "CMMCScBkupStateGetDataOwners.h"

#include <bldvariant.hrh>

// User includes

#include "MMCScBkupLogger.h"

#include "CMMCScBkupDataOwnerCollection.h"

#include "MMCScBkupSBEUtils.h"

// Constants

const TInt KMMCScBkupDataOwnerGranularity = 20;

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

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

// CMMCScBkupStateGetDataOwners::CMMCScBkupStateGetDataOwners()

// 

// C++ constructor.

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

CMMCScBkupStateGetDataOwners::CMMCScBkupStateGetDataOwners( MMMCScBkupDriver& aDriver )

:   CMMCScBkupState( aDriver )

    {

    __LOG1("CMMCScBkupStateGetDataOwners::CMMCScBkupStateGetDataOwners() - 0x%08x", StateId().iUid );

    }

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

// CMMCScBkupStateGetDataOwners::NewL()

// 

// 

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

CMMCScBkupStateGetDataOwners* CMMCScBkupStateGetDataOwners::NewL( MMMCScBkupDriver& aDriver )

    {

    CMMCScBkupStateGetDataOwners* self = new(ELeave) CMMCScBkupStateGetDataOwners( aDriver );

    return self;

    }

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

// CMMCScBkupStateGetDataOwners::StateId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateGetDataOwners::StateId() const

    {

    return KMMCScBkupStateIdGetDataOwners;

    }

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

// CMMCScBkupStateGetDataOwners::NextStateId()

// 

// 

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

TMMCScBkupStateId CMMCScBkupStateGetDataOwners::NextStateId() const

    {

    // This is the same for backup & restore

    return KMMCScBkupStateIdSetPhoneMode;

    }

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

// CMMCScBkupStateGetDataOwners::PerformStateInitL()

// 

// 

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

void CMMCScBkupStateGetDataOwners::PerformStateInitL()

    {

    // Query asynchronously

    CompleteSelf();

    }

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

// CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL()

// 

// 

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

void CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL()

    {

    RMMCScBkupPointerArray<CDataOwnerInfo> dataOwners(KMMCScBkupDataOwnerGranularity);

    CleanupClosePushL( dataOwners );

    // Get data owner listing from secure backup engine

    Driver().DrvSecureBackupClient().ListOfDataOwnersL(dataOwners);

    // Inform driver of result

#ifdef RD_FILE_MANAGER_BACKUP

    RPointerArray<CMMCScBkupDataOwnerCollection>& dataOwnerLists = Driver().DrvDataOwnersAll();

    TInt count = dataOwners.Count();

    // Construct an info array to get introduced for every category

    for(TInt i = count-1; i >= 0; i--)

        {

        // Ownership is immediately transferred to the backup owner info object

        // so we should remove it from the array prior to passing into NewLC

        conn::CDataOwnerInfo* sbDataOwner = dataOwners[i];

        dataOwners.Remove( i ); // Ensures it won't be deleted twice

        const TSBDerivedType type = sbDataOwner->Identifier().DerivedTypeL();

        if  ( type == EJavaDerivedType || type == EJavaTransferDerivedType )

            {

            HBufC* hash = MMCScBkupSBEUtils::JavaHashFromGenericLC( sbDataOwner->Identifier() );

            __LOG1("CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL() - Assigning java owner with hash %S for categories", 

                hash );

            CleanupStack::PopAndDestroy( hash );

            }

        else

            {

            __LOG1("CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL() - Assigning data owner 0x%08x for categories", 

                MMCScBkupSBEUtils::SecureIdFromGenericL( sbDataOwner->Identifier() ).iId );

            }

        // We have to create copy of original data owner for each category, so we have to externalize it

        RPointerArray<CDataOwnerInfo> sbDataOwnerCopies(dataOwnerLists.Count());

        CleanupClosePushL( sbDataOwnerCopies );

        HBufC8* dataOwner = sbDataOwner->ExternaliseL();

        CleanupStack::PushL( dataOwner );

        // Delete original data owner instance 

        delete sbDataOwner;

        // Create copies for each category (even if they do not eventually end up to those lists)

        for(TInt j = 0; j < dataOwnerLists.Count(); j++)

            {

            conn::CDataOwnerInfo* sbDataOwnerCopy = conn::CDataOwnerInfo::NewL(*dataOwner);

            CleanupStack::PushL( sbDataOwnerCopy );

            sbDataOwnerCopies.AppendL(sbDataOwnerCopy);

            CleanupStack::Pop( sbDataOwnerCopy );

            }

        CleanupStack::PopAndDestroy( dataOwner );

        // Loop through all lists and assign copied data owners there

        for(TInt j = 0; j < dataOwnerLists.Count(); j++)

            {

            // Again we have to create instances for each category, 

            // because each has to have own copy of data owner

            CMMCScBkupDataOwnerInfo* info = CMMCScBkupDataOwnerInfo::NewLC( sbDataOwnerCopies[j] );

            if(dataOwnerLists[j]->AssignL( *info ))

                {

                CleanupStack::Pop( info );

                }

            else

                {

                CleanupStack::PopAndDestroy( info );

                }

            }

            CleanupStack::PopAndDestroy( &sbDataOwnerCopies );

        }

#if defined(__MMCSCBKUPLOGGING_ENABLED__)

    __LOG("CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL() - Data owners per categories:");

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

        {

        __LOG2("CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL() - Category 0x%x contains %d data owners", 

            dataOwnerLists[i]->Category().iFlags, dataOwnerLists[i]->Count() );

        for(TInt j = 0; j < dataOwnerLists[i]->Count(); j++)

            {

            CMMCScBkupDataOwnerInfo* entry = &dataOwnerLists[i]->Owner(j);

            const TSBDerivedType type = entry->Owner().Identifier().DerivedTypeL();

            if  ( type == EJavaDerivedType || type == EJavaTransferDerivedType )

                {

                HBufC* hash = MMCScBkupSBEUtils::JavaHashFromGenericLC( entry->Owner().Identifier() );

                __LOG1("CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL() - java data owner with hash %S", 

                    hash );

                CleanupStack::PopAndDestroy( hash );

                }

            else

                {

                __LOG1("CMMCScBkupStateGetDataOwners::PerformAsynchronousStateStepL() - data owner 0x%08x", 

                    MMCScBkupSBEUtils::SecureIdFromGenericL( entry->Owner().Identifier() ).iId );

                }

            }

        }

#endif

#else // RD_FILE_MANAGER_BACKUP

    Driver().DrvDataOwners().AssignL( dataOwners );

#endif // RD_FILE_MANAGER_BACKUP

    CleanupStack::PopAndDestroy( &dataOwners );

    }