/*

* Copyright (c) 2002-2007 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:  A class that reads an array of PSU2_COPY_TO_SIM_FIELDTYPE_INFO

*                items

*

*/

// INCLUDE FILES

#include "CPsu2CopyToSimFieldInfoArray.h"

#include <RPbk2LocalizedResourceFile.h>

#include <Pbk2DataCaging.hrh>

#include <TVPbkFieldTypeMapping.h>

#include <CVPbkFieldTypeSelector.h>

#include <MVPbkFieldType.h>

#include <coemain.h>

#include <barsread.h>

#include <gsmerror.h>

#include <featmgr.h>

namespace

{

_LIT(KPsu2USimExtensionResFile, "Pbk2USimUIRes.rsc");

// ============================= LOCAL FUNCTIONS ===============================

#ifdef _DEBUG

enum TPanicCode

    {

    EPostCond_ConstructL,

    EPostCond_CreateMappingsL

    };

void Panic(TInt aReason)

    {

    _LIT(KPanicText, "SimFieldInfoArray");

    User::Panic(KPanicText, aReason);

    }

#endif // _DEBUG

}

/**

 * A class that can read PSU2_COPY_TO_SIM_FIELDTYPE_MAPPING resource

 * structure from Pbk2USimUi.rh

 */

class CPsu2CopyToSimFieldtypeMapping : public CBase

    {

    public:

        /**

         * @param aReader a resource reader to 

         *  PSU2_COPY_TO_SIM_FIELDTYPE_MAPPING.

         * @param aMasterFieldTypeList all field types from CVPbkContactManager

         */

        static CPsu2CopyToSimFieldtypeMapping* NewLC( 

            TResourceReader& aReader,

            const MVPbkFieldTypeList& aMasterFieldTypeList );

        // Destructor

        ~CPsu2CopyToSimFieldtypeMapping();

        /**

         * The selector for the source field types.

         *

         * @return The selector for the source field types.

         */

        MVPbkFieldTypeSelector& SourceTypeSelector() const;

        /**

         *

         */

        TInt TargetFieldtypeResId() const;

        /**

         * Returns flags defined Pbk2UsimUi.hrh

         *

         * @return flags defined Pbk2UsimUi.hrh

         */

        TUint8 Flags() const;

        /**

         * @return TPsu2ErrorCode that causes this sim field type 

         *  to be blocked.

         */

        TUint8 BlockingError() const;

    private:

        void ConstructL( TResourceReader& aReader,

            const MVPbkFieldTypeList& aMasterFieldTypeList );

    private: // Data

        /// Own: source field type selector

        CVPbkFieldTypeSelector* iSourceTypeSelector;

        TInt iTargetFieldTypeResId;

        /// Flags from Pbk2UsimUi.hrh

        TUint8 iFlags;

        /// See TPsu2ErrorCode

        TUint8 iBlockingError;

    };

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

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

// TPsu2CopyToSimFieldInfo::TPsu2CopyToSimFieldInfo

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

TPsu2CopyToSimFieldInfo::TPsu2CopyToSimFieldInfo( 

        const MVPbkFieldType& aSourceType,

        const MVPbkFieldType& aSimType, 

        TUint8 aFlags, 

        TUint8 aBlockingError )

        :   iSourceType( aSourceType ),

            iSimType( aSimType ),

            iFlags( aFlags ),

            iBlockingError( aBlockingError )

    {

    }

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

// CPsu2CopyToSimFieldtypeMapping::NewLC

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

//

CPsu2CopyToSimFieldtypeMapping* CPsu2CopyToSimFieldtypeMapping::NewLC( 

        TResourceReader& aReader,

        const MVPbkFieldTypeList& aMasterFieldTypeList )

    {

    CPsu2CopyToSimFieldtypeMapping* self = 

        new( ELeave ) CPsu2CopyToSimFieldtypeMapping;

    CleanupStack::PushL( self );

    self->ConstructL( aReader, aMasterFieldTypeList );

    return self;

    }

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

// CPsu2CopyToSimFieldtypeMapping::ConstructL

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

//

void CPsu2CopyToSimFieldtypeMapping::ConstructL( TResourceReader& aReader,

        const MVPbkFieldTypeList& aMasterFieldTypeList )

    {

    iSourceTypeSelector = CVPbkFieldTypeSelector::NewL( aReader, 

        aMasterFieldTypeList );

    iTargetFieldTypeResId = aReader.ReadInt32();

    iFlags = aReader.ReadUint8();

    iBlockingError = aReader.ReadUint8();

    }

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

// CPsu2CopyToSimFieldtypeMapping::~CPsu2CopyToSimFieldtypeMapping

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

//

CPsu2CopyToSimFieldtypeMapping::~CPsu2CopyToSimFieldtypeMapping()

    {

    delete iSourceTypeSelector;

    }

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

// CPsu2CopyToSimFieldtypeMapping::SourceTypeSelector

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

//

MVPbkFieldTypeSelector& CPsu2CopyToSimFieldtypeMapping::SourceTypeSelector() const

    {

    return *iSourceTypeSelector;

    }

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

// CPsu2CopyToSimFieldtypeMapping::TargetFieldtypeResId

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

//

TInt CPsu2CopyToSimFieldtypeMapping::TargetFieldtypeResId() const

    {

    return iTargetFieldTypeResId;

    }

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

// CPsu2CopyToSimFieldtypeMapping::Flags

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

//

TUint8 CPsu2CopyToSimFieldtypeMapping::Flags() const

    {

    return iFlags;

    }

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

// CPsu2CopyToSimFieldtypeMapping::BlockingError

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

//

TUint8 CPsu2CopyToSimFieldtypeMapping::BlockingError() const

    {

    return iBlockingError;

    }

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

// CPsu2CopyToSimFieldInfoArray::CPsu2CopyToSimFieldInfoArray

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CPsu2CopyToSimFieldInfoArray::CPsu2CopyToSimFieldInfoArray(

    const MVPbkFieldTypeList& aMasterFieldTypeList)

    :   iMasterFieldTypeList(aMasterFieldTypeList)

    {

    }

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

// CPsu2CopyToSimFieldInfoArray::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CPsu2CopyToSimFieldInfoArray::ConstructL( RFs& aFs )

    {

    // Open USIM extension resource file for reading field mappings.

    // This class can be used from SIM copy policy so it must not

    // depend on CCoeEnv in anyway.

    RPbk2LocalizedResourceFile resFile( &aFs );

    resFile.OpenLC(KPbk2RomFileDrive,

        KDC_RESOURCE_FILES_DIR, KPsu2USimExtensionResFile);

    FeatureManager::InitializeLibL();

    TResourceReader reader;

    if( !FeatureManager::FeatureSupported( 

                    KFeatureIdFfTdClmcontactreplicationfromphonebooktousimcard ) )

        {

        reader.SetBuffer( 

               resFile.AllocReadLC( R_PSU2_COPY_TO_SIM_FIELDTYPE_MAPPINGS ) );

        }

    else

        {

        reader.SetBuffer( 

               resFile.AllocReadLC( R_PSU2_COPY_TO_USIM_FIELDTYPE_MAPPINGS ) );

        }

    // Go through all mappings in resource and create a mapping array

    const TInt count = reader.ReadInt16();

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

        {

        CPsu2CopyToSimFieldtypeMapping* cmapping = 

            CPsu2CopyToSimFieldtypeMapping::NewLC( reader, 

                iMasterFieldTypeList );

        CreateMappingsL( *cmapping );

        CleanupStack::PopAndDestroy( cmapping );

        }

    CleanupStack::PopAndDestroy(); // R_PSU2_COPY_TO_SIM_FIELDTYPE_MAPPINGS

    // Valid characters for number fields.

    // Note: StringLoader can not be used in this class because it depends

    // on CCoeEnv. This class can be run in non-UI context because

    // CPsu2ContactCopyPolicy uses this class.

    reader.SetBuffer( 

        resFile.AllocReadLC( R_PSU2_STANDARD_NUMBER_CHARACTER_MAP ) );

    iNumberKeyMap = reader.ReadHBufCL();

    // R_PSU2_STANDARD_NUMBER_CHARACTER_MAP, resFile

    CleanupStack::PopAndDestroy(2); 

    // Get SIM name field type. This must be the same type as the type

    // defined in VPbkSimStore

    iSimNameType = iMasterFieldTypeList.Find( R_VPBK_FIELD_TYPE_LASTNAME );

    iSimReadingType = 

        iMasterFieldTypeList.Find( R_VPBK_FIELD_TYPE_LASTNAMEREADING );

    __ASSERT_DEBUG( iSimNameType && iSimReadingType, 

        Panic( EPostCond_ConstructL ) );

    }

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

// CPsu2CopyToSimFieldInfoArray::NewL

// Two-phased constructor.

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

//

CPsu2CopyToSimFieldInfoArray* CPsu2CopyToSimFieldInfoArray::NewL(

        const MVPbkFieldTypeList& aMasterFieldTypeList, RFs& aFs )

    {

    CPsu2CopyToSimFieldInfoArray* self =

        new( ELeave ) CPsu2CopyToSimFieldInfoArray(aMasterFieldTypeList);

    CleanupStack::PushL( self );

    self->ConstructL( aFs );

    CleanupStack::Pop();

    return self;

    }

// Destructor

CPsu2CopyToSimFieldInfoArray::~CPsu2CopyToSimFieldInfoArray()

    {

    iInfoArray.Close();

    iMatchedTypes.Close();

    delete iNumberKeyMap;

    FeatureManager::UnInitializeLib();

    }

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

// CPsu2CopyToSimFieldInfoArray::FindInfoForSourceType

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

//

const TPsu2CopyToSimFieldInfo* 

        CPsu2CopyToSimFieldInfoArray::FindInfoForSourceType(

            const MVPbkFieldType& aSourceType )

    {

    const TPsu2CopyToSimFieldInfo* result = NULL;

    const TInt count = iInfoArray.Count();

    for (TInt i = 0; i < count && !result; ++i)

        {

        if (iInfoArray[i].SourceType().IsSame( aSourceType ) )

            {

            result = &iInfoArray[i];

            }

        }

    return result;

    }

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

// CPsu2CopyToSimFieldInfoArray::RemoveUnSupportedTargetTypeFieldInfo

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

//

void CPsu2CopyToSimFieldInfoArray::RemoveUnSupportedFieldInfo( const MVPbkFieldTypeList& aSupportedTypes )

    {

    // Check all the field info in the iInfoArray, if the target of the fieldinfo 

    // is not contained in the supportedTypes, Remove it from iInfoArray.

    TInt i = iInfoArray.Count() - 1;

    while( i >= 0 )

        {

        if( !aSupportedTypes.ContainsSame( iInfoArray[i].SimType()))

            {

            iInfoArray.Remove( i );

            }

        i --;

        }

    }

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

// CPsu2CopyToSimFieldInfoArray::SimNameType

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

//

const MVPbkFieldType& CPsu2CopyToSimFieldInfoArray::SimNameType() const

    {

    return *iSimNameType;

    }

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

// CPsu2CopyToSimFieldInfoArray::LastNameReadingType

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

//

const MVPbkFieldType& CPsu2CopyToSimFieldInfoArray::LastNameReadingType() const

    {

    return *iSimReadingType;

    }

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

// CPsu2CopyToSimFieldInfoArray::ConvertToSimType

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

//

const MVPbkFieldType* CPsu2CopyToSimFieldInfoArray::ConvertToSimType(

    const MVPbkFieldType& aSourceType)

    {

    const TInt count = iInfoArray.Count();

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

        {

        if (iInfoArray[i].SourceType().IsSame(aSourceType))

            {

            return &iInfoArray[i].SimType();

            }

        }

    return NULL;

    }

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

// CPsu2CopyToSimFieldInfoArray::TruncationAllowed

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

//

TBool CPsu2CopyToSimFieldInfoArray::TruncationAllowed(

        const MVPbkFieldType& aSimType )

    {

    const TInt count = iInfoArray.Count();

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

        {

        if ( iInfoArray[i].SimType().IsSame( aSimType ) )

            {

            return iInfoArray[i].TruncationAllowed();

            }

        }

    return EFalse;

    }

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

// CPsu2CopyToSimFieldInfoArray::NumberKeyMap

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

//

const TDesC& CPsu2CopyToSimFieldInfoArray::NumberKeyMap() const

    {

    return *iNumberKeyMap;

    }

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

// CPsu2CopyToSimFieldInfoArray::CreateMappingsL

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

//

void CPsu2CopyToSimFieldInfoArray::CreateMappingsL( 

        CPsu2CopyToSimFieldtypeMapping& aCMapping )

    {

    const TInt typeCount = iMasterFieldTypeList.FieldTypeCount();

    // First find the target type

    const MVPbkFieldType* targetType = iMasterFieldTypeList.Find( 

        aCMapping.TargetFieldtypeResId() );

    // Then find all source types and create mappings

    MVPbkFieldTypeSelector& selector = aCMapping.SourceTypeSelector();

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

        {

        if ( selector.IsFieldTypeIncluded( 

                iMasterFieldTypeList.FieldTypeAt( i ) ) )

            {

            TPsu2CopyToSimFieldInfo info( 

                iMasterFieldTypeList.FieldTypeAt( i ),

                *targetType, aCMapping.Flags(), aCMapping.BlockingError() );

            iInfoArray.AppendL( info );

            }

        }

    // Target type must be found from master field type list.

    // If it doesn't, then either the field type list is not the

    // master field types list or the field type resource id is corrupted.

    __ASSERT_DEBUG( targetType, Panic( EPostCond_CreateMappingsL) );

    }

//  End of File