/*

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

*

*

*/

#include "MMCScBkupSBEUtils.h"

// System includes

#include <e32property.h>

#include <connect/sbdefs.h>

#include "CMMCScBkupDataOwnerInfo.h"

// Namespaces

using namespace conn;

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

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

// MMCScBkupSBEUtils::SecureIdFromGenericL()

// 

// 

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

TSecureId MMCScBkupSBEUtils::SecureIdFromGenericL(const CSBGenericDataType& aGeneric)

    {

    TSecureId ret = 0;

    CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aGeneric);

    const TSBDerivedType type = aGeneric.DerivedTypeL();

    //

    switch(type)

        {

    case ESIDDerivedType:

        {

        CSBSecureId* temp = CSBSecureId::NewL( nonConstOriginal );

        CleanupStack::PushL( temp );

        ret = temp->SecureIdL();

        CleanupStack::PopAndDestroy( temp );

        break;

        }

    case ESIDTransferDerivedType:

        {

        // First make a generic transfer type object...

        CSBGenericTransferType* transferTypeTemp = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

        CleanupStack::PushL(transferTypeTemp);

        // Now make instance transfer type

        CSBSIDTransferType* temp = CSBSIDTransferType::NewL( transferTypeTemp );

        CleanupStack::PushL(temp);

        // Now get the result

        ret = temp->SecureIdL();

        // Tidy up

        CleanupStack::PopAndDestroy(2, transferTypeTemp);

        break;

        }

    case EPackageDerivedType:

        {

        CSBPackageId* temp = CSBPackageId::NewL( nonConstOriginal );

        CleanupStack::PushL( temp );

        ret = temp->SecureIdL();

        CleanupStack::PopAndDestroy( temp );

        break;

        }

    case EPackageTransferDerivedType:

    case EJavaDerivedType:

    case EJavaTransferDerivedType:

    default:

        __BREAKPOINT();

        User::Leave(KErrNotSupported);

        break;

       }

    //

    return ret;

    }

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

// MMCScBkupSBEUtils::PackageIdFromGenericL()

// 

// 

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

TUid MMCScBkupSBEUtils::PackageIdFromGenericL(const CSBGenericDataType& aGeneric)

    {

    TUid ret = KNullUid;

    CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aGeneric);

    const TSBDerivedType type = aGeneric.DerivedTypeL();

    //

    switch(type)

        {

    case EPackageDerivedType:

        {

        CSBPackageId* temp = CSBPackageId::NewL( nonConstOriginal );

        CleanupStack::PushL(temp);

        ret = temp->PackageIdL();

        CleanupStack::PopAndDestroy(temp);

        break;

        }

    case EPackageTransferDerivedType:

        {

        // First make a generic transfer type object...

        CSBGenericTransferType* transferTypeTemp = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

        CleanupStack::PushL(transferTypeTemp);

        // Now make instance transfer type

        CSBPackageTransferType* temp = CSBPackageTransferType::NewL( transferTypeTemp );

        CleanupStack::PushL(temp);

        // Now get the result

        ret = temp->PackageIdL();

        // Tidy up

        CleanupStack::PopAndDestroy(2, transferTypeTemp);

        break;

        }

    case ESIDDerivedType:

    case ESIDTransferDerivedType:

    case EJavaDerivedType:

    case EJavaTransferDerivedType:

    default:

        __BREAKPOINT();

        User::Leave(KErrNotSupported);

        break;

       }

    //

    return ret;

    }

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

// MMCScBkupSBEUtils::JavaHashFromGenericLC()

// 

// 

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

HBufC* MMCScBkupSBEUtils::JavaHashFromGenericLC(const CSBGenericDataType& aGeneric)

    {

    HBufC* ret = NULL;

    CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aGeneric);

    const TSBDerivedType type = aGeneric.DerivedTypeL();

    //

    switch(type)

        {

    case EJavaDerivedType:

        {

        CSBJavaId* temp = CSBJavaId::NewL( nonConstOriginal );

        CleanupStack::PushL(temp);

        ret = temp->SuiteHashL().AllocL();

        CleanupStack::PopAndDestroy(temp);

        CleanupStack::PushL( ret );

        break;

        }

    case EJavaTransferDerivedType:

        {

        // First make a generic transfer type object...

        CSBGenericTransferType* transferTypeTemp = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

        CleanupStack::PushL(transferTypeTemp);

        // Now make a instance transfer type

        CSBJavaTransferType* temp = CSBJavaTransferType::NewL( transferTypeTemp );

        CleanupStack::PushL(temp);

        // Now get the result

        ret = temp->SuiteHashL().AllocL();

        // Tidy up

        CleanupStack::PopAndDestroy(2, transferTypeTemp);

        CleanupStack::PushL( ret );

        break;

        }

    case ESIDDerivedType:

    case ESIDTransferDerivedType:

    case EPackageDerivedType:

    case EPackageTransferDerivedType:

    default:

        __BREAKPOINT();

        User::Leave(KErrNotSupported);

        break;

       }

    //

    if  ( ret == NULL )

        {

        ret = KNullDesC().AllocLC();

        }

    //

    return ret;

    }

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

// MMCScBkupSBEUtils::CopyLC()

// 

// 

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

CSBGenericDataType* MMCScBkupSBEUtils::CopyLC(const CSBGenericDataType& aToBeCopied)

    {

    CSBGenericDataType* ret = NULL;

    // Have to do this through poor implementation of SBE API 

    CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aToBeCopied);

    //

    const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

    switch(type)

        {

    case ESIDDerivedType:

        ret = CSBSecureId::NewL(nonConstOriginal);

        break;

    case EPackageDerivedType:

        ret = CSBPackageId::NewL(nonConstOriginal);

        break;

    case EJavaDerivedType:

        ret = CSBJavaId::NewL(nonConstOriginal);

        break;

    case ESIDTransferDerivedType:

    case EPackageTransferDerivedType:

    case EJavaTransferDerivedType:

        {

        // Must first create a generic transfer type object... sigh...

        CSBGenericTransferType* transferType = CSBGenericTransferType::NewL( nonConstOriginal->Externalise() );

            {

            ret = CSBSIDTransferType::NewL( transferType );

            ret = CSBPackageTransferType::NewL( transferType );

            ret = CSBJavaTransferType::NewL( transferType );

            }

        CleanupStack::PopAndDestroy( transferType );

        }

    default:

        break;

       }

    //

    if  (!ret)

        {

        __BREAKPOINT();

        User::Leave(KErrNotSupported);

        }

    CleanupStack::PushL(ret);

    return ret;

    }

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

// MMCScBkupSBEUtils::TransferTypeLC()

// 

// 

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

CSBGenericTransferType* MMCScBkupSBEUtils::TransferTypeLC( const CSBGenericDataType& aDT, TDriveNumber aDrive, 

    TTransferDataType aTransferType, TInt aVersion )

    {

    CSBGenericTransferType* ret = NULL;

    // Have to do this through poor implementation of SBE API 

    CSBGenericDataType* nonConstOriginal = const_cast< CSBGenericDataType* >( &aDT );

    //

    const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

    switch( type )

        {

    case ESIDDerivedType:

    case ESIDTransferDerivedType:

        {

        const TSecureId secureId = SecureIdFromGenericL( aDT );

        ret = CSBSIDTransferType::NewL( secureId, aDrive, aTransferType );

        break;

        }

    case EPackageDerivedType:

        {

        TSecureId secureId = SecureIdFromGenericL( aDT );

        if( secureId.iId == KNullUid.iUid && aVersion > CMMCScBkupDataOwnerInfo::EStreamFormatVersionFirst )

            {

            secureId = MMCScBkupSBEUtils::PackageIdFromGenericL( aDT );

            }

        ret = CSBSIDTransferType::NewL( secureId, aDrive, aTransferType );

        break;

        }

    default:

    case EPackageTransferDerivedType:

    case EJavaDerivedType:

    case EJavaTransferDerivedType:

        __BREAKPOINT();

        User::Leave( KErrNotSupported );

        break;

        }

    //

    CleanupStack::PushL( ret );

    return ret;

    }

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

// MMCScBkupSBEUtils::TransferTypeLC()

// 

// 

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

CSBGenericTransferType* MMCScBkupSBEUtils::TransferTypeLC(const CSBGenericDataType& aDT, TDriveNumber aDrive, 

    TPackageDataType aDataType, TInt /*aVersion*/)

    {

    CSBGenericTransferType* ret = NULL;

    // Have to do this through poor implementation of SBE API 

    CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aDT);

    //

    const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

    switch(type)

        {

    case EPackageDerivedType:

    case EPackageTransferDerivedType:

        {

        const TUid packageId = PackageIdFromGenericL(aDT);

        ret = CSBPackageTransferType::NewL(packageId, aDrive, aDataType);

        break;

        }

    default:

    case ESIDDerivedType:

    case ESIDTransferDerivedType:

    case EJavaDerivedType:

    case EJavaTransferDerivedType:

        __BREAKPOINT();

        User::Leave(KErrNotSupported);

        break;

        }

    //

    CleanupStack::PushL(ret);

    return ret;

    }

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

// MMCScBkupSBEUtils::TransferTypeLC()

// 

// 

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

CSBGenericTransferType* MMCScBkupSBEUtils::TransferTypeLC(const CSBGenericDataType& aDT, TDriveNumber aDrive, 

    TJavaTransferType aDataType, TInt /*aVersion*/)

    {

    CSBGenericTransferType* ret = NULL;

    // Have to do this through poor implementation of SBE API 

    CSBGenericDataType* nonConstOriginal = const_cast<CSBGenericDataType*>(&aDT);

    //

    const TSBDerivedType type = nonConstOriginal->DerivedTypeL();

    switch(type)

        {

    case EJavaDerivedType:

    case EJavaTransferDerivedType:

        {

        HBufC* hash = JavaHashFromGenericLC( aDT );

        ret = CSBJavaTransferType::NewL( *hash, aDrive, aDataType );

        CleanupStack::PopAndDestroy( hash );

        break;

        }

    default:

    case ESIDDerivedType:

    case ESIDTransferDerivedType:

    case EPackageDerivedType:

    case EPackageTransferDerivedType:

        __BREAKPOINT();

        User::Leave(KErrNotSupported);

        break;

        }

    //

    CleanupStack::PushL(ret);

    return ret;

    }

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

// MMCScBkupSBEUtils::PhoneIsInBackupOrRestoreModeL()

// 

// 

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

TBool MMCScBkupSBEUtils::PhoneIsInBackupOrRestoreModeL()

    {

    TBool backupInProgress = EFalse;

    //

    TInt value = 0;

    const TInt error = RProperty::Get( KUidSystemCategory, KUidBackupRestoreKey, value );

    User::LeaveIfError( error );

    //

    const TBURPartType partType = static_cast< TBURPartType >( value & KBURPartTypeMask );

    if  (value != 0)

        {

        switch(partType)

            {

        case EBURUnset:

        case EBURNormal:

            break;

        case EBURBackupFull:

        case EBURBackupPartial:

        case EBURRestoreFull:

        case EBURRestorePartial:

            backupInProgress = ETrue;

            break;

            }

        }

    //

    return backupInProgress;

    }

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

// MMCScBkupSBEUtils::EndBackupOrRestoreL()

// 

// 

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

void MMCScBkupSBEUtils::EndBackupOrRestoreL( CSBEClient& aSBEClient )

    {

    TDriveList nullDriveList;

    aSBEClient.SetBURModeL( nullDriveList, EBURNormal, ENoBackup);

    }

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

// MMCScBkupSBEUtils::HasSystemDataL()

// 

// 

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

TBool MMCScBkupSBEUtils::HasSystemDataL( const CDataOwnerInfo& aDataOwner )

    {

    const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

    const TBool systemDataType = ( type == EPackageDerivedType || 

                                   type == EPackageTransferDerivedType );

    const TBool hasSystemData = ( aDataOwner.CommonSettings() & EHasSystemFiles );

    //

    return ( systemDataType && hasSystemData );

    }

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

// MMCScBkupSBEUtils::HasJavaDataL()

// 

// 

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

TBool MMCScBkupSBEUtils::HasJavaDataL( const CDataOwnerInfo& aDataOwner )

    {

    const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

    const TBool javaDataType = ( type == EJavaDerivedType || 

                                 type == EJavaTransferDerivedType );

    const TBool hasSystemData = ( aDataOwner.CommonSettings() & EHasSystemFiles );

    // Java abuses the "has system files flag" - this has been confirmed

    // with Symbian.

    return ( javaDataType && hasSystemData );

    }

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

// MMCScBkupSBEUtils::HasPassiveDataL()

// 

// 

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

TBool MMCScBkupSBEUtils::HasPassiveDataL( const CDataOwnerInfo& aDataOwner )

    {

    const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

    const TBool passiveDataType = ( type == ESIDDerivedType || 

                                    type == ESIDTransferDerivedType ||

                                    type == EPackageDerivedType || 

                                    type == EPackageTransferDerivedType );

    const TBool hasPassiveData = ( aDataOwner.CommonSettings() & EPassiveBUR );

    //

    return ( passiveDataType && hasPassiveData );

    }

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

// MMCScBkupSBEUtils::HasActiveDataL()

// 

// 

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

TBool MMCScBkupSBEUtils::HasActiveDataL( const CDataOwnerInfo& aDataOwner )

    {

    const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

    const TBool activeDataType = ( type == ESIDDerivedType || 

                                   type == ESIDTransferDerivedType ||

                                   type == EPackageDerivedType || 

                                   type == EPackageTransferDerivedType );

    const TBool hasActiveData = ( aDataOwner.CommonSettings() & EActiveBUR );

    //

    return ( activeDataType && hasActiveData );

    }

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

// MMCScBkupSBEUtils::HasPublicDataL()

// 

// 

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

TBool MMCScBkupSBEUtils::HasPublicDataL( const CDataOwnerInfo& aDataOwner )

    {

    const TSBDerivedType type = aDataOwner.Identifier().DerivedTypeL();

    const TBool publicDataType = ( type == ESIDDerivedType || 

                                   type == ESIDTransferDerivedType ||

                                   type == EPackageDerivedType || 

                                   type == EPackageTransferDerivedType );

    const TBool hasPublicData = ( aDataOwner.PassiveSettings() & EHasPublicFiles );

    //

    return ( hasPublicData && publicDataType );

    }