/*

* Copyright (c) 2006-2006 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:  CPSStateSourcePlugIn class implementation.

*

*/

#define __INCLUDE_CAPABILITY_NAMES__

#include <cfcontextinterface.h>

#include <cfcontextsourcesettingarray.h>

#include <e32capability.h>

#include "psstatesourceappstatedomainpskeys.h"

#include "psstatesourceplugin.h"

#include "psstatemapper.h"

#include "psstatemapperint.h"

#include "psstatemappertext.h"

const TUint KLimit = 0xFFFFFFFF;

_LIT (KAttrMapper, "mapper" );

_LIT (KAttrCategory, "category" );

_LIT (KAttrKey, "key" );

_LIT (KAttrCapability, "capability" );

_LIT (KAttrSource, "source" );

_LIT (KAttrType, "type" );

_LIT (KAttrPassThrough, "passthrough" );

_LIT (KValueInt, "int" );

_LIT (KValueText, "text" );

_LIT (KValueTrue, "true" );

_LIT (KTagIntMapping, "IntMapping");

_LIT (KTagTextMapping, "TextMapping");

_LIT (KAttributePSValue, "psvalue");

_LIT (KAttributeContextValue, "contextvalue");

//namespace PSSOURCE

//    {

//    // Panic category

//    _LIT( KPanicCat, "PSStateSrc" );

//    

//    // Panic codes

//    enum TPanicReason

//        {

//        EInvalidPSKey

//        };

//        

//    // Local panic function

//    LOCAL_C void Panic( TInt aCode )

//        {

//        User::Panic( KPanicCat, aCode );

//        }

//    }

//

//using namespace PSSOURCE;

CPSStateSourcePlugIn* CPSStateSourcePlugIn::NewL( 

    TContextSourceInitParams* aParams )

    {

    CPSStateSourcePlugIn* self = CPSStateSourcePlugIn::NewLC( aParams );

    CleanupStack::Pop();

    return self;

    }

CPSStateSourcePlugIn* CPSStateSourcePlugIn::NewLC( 

TContextSourceInitParams* aParams )

    {

    CPSStateSourcePlugIn* self =

        new( ELeave ) CPSStateSourcePlugIn( aParams );

    CleanupStack::PushL( self );

    return self;

    }

// Destructor

CPSStateSourcePlugIn::~CPSStateSourcePlugIn()

    {

    delete iSettings;

    iMappers.ResetAndDestroy();

    }

CPSStateSourcePlugIn::CPSStateSourcePlugIn(

    TContextSourceInitParams* aParams ):

    CCFContextSourcePlugIn( aParams )

    {

    }

// METHODS

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

// CPSStateSourcePlugIn::HandleSettingL

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

//

void CPSStateSourcePlugIn::HandleSettingL(

    CCFContextSourceSettingArray* aSettingList )

	{

    iSettings = aSettingList;

    for (TInt i = 0; i < iSettings->Count(); i++ )

    	{

		CPSStateMapper* mapper = NULL;

    	const RKeyValueArray& attributes = iSettings->Item( i ).Attributes();

    	// Check application and view names (also default values)

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

            {

            TPtrC key( attributes[ j ]->Key() );

            TPtrC value( attributes[ j ]->Value() );

            if( key.CompareF( KAttrMapper ) == KErrNone )

                {

                if (value.CompareF( KValueInt) == KErrNone )

                	{

                	CPSStateMapperInt* intmapper 

                		= CPSStateMapperInt::NewL( iCF );

                	mapper = (CPSStateMapper*) intmapper;

                	}

                else if (value.CompareF( KValueText) == KErrNone )

                	{

                	CPSStateMapperText* textmapper 

                		= CPSStateMapperText::NewL( iCF );

                	mapper = (CPSStateMapper*) textmapper;

                	}

                } 

            } 

		// Leave from here if PS state mapper is NULL.This may happen if none of the attributes' key value matches with the state mapper 

		if ( mapper == NULL)

			User::LeaveIfError(KErrArgument);

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

            {

            TPtrC key( attributes[ j ]->Key() );

            TPtrC value( attributes[ j ]->Value() );

            if( key.CompareF( KAttrCategory ) == KErrNone )

                {

               	TUint32 category;

                TInt err = ConvertHexToTUint( value, category );

				mapper->SetPSCategory(TUid::Uid(category));                

                }

            else if( key.CompareF( KAttrKey ) == KErrNone )

                {

                TUint32 key;

                TInt err = ConvertHexToTUint( value, key );

				mapper->SetPSKey(key);                

                }

            else if( key.CompareF( KAttrCapability ) == KErrNone )

                {

                TSecurityPolicy policy;

				ConvertDescToSecurityPolicy( value, policy ); 

				mapper->SetSecurityPolicy( policy );                

                }

            else if( key.CompareF( KAttrSource ) == KErrNone )

                {

				mapper->SetSourceL(value);

                }

            else if( key.CompareF( KAttrType ) == KErrNone )

                {

				mapper->SetTypeL(value);

                }

            else if( key.CompareF( KAttrPassThrough ) == KErrNone )

                {

                if (value.CompareF( KValueTrue ) == KErrNone )

                	{

                	mapper->SetPassThrough(ETrue);

                	} else 

                	{

                	mapper->SetPassThrough(EFalse);

                	}	

                }

            }

        const RSettingParameterArray& parameters 

        	= iSettings->Item( i ).Parameters();

        switch (mapper->MapperType())

        	{

        	case CPSStateMapper::EPSIntMapper:

        		{

        		ParseIntMapperParamsL(*mapper, parameters);

        		break;

        		}

            case CPSStateMapper::EPSTextMapper:

            	{

            	ParseTextMapperParamsL(*mapper, parameters);

            	break;

            	}

        	}

        iMappers.AppendL( mapper );    

    	}

	}

void CPSStateSourcePlugIn::ParseIntMapperParamsL(CPSStateMapper& aMapper,

	const RSettingParameterArray& aParameters)

	{

	CPSStateMapperInt* intmapper = (CPSStateMapperInt*) &aMapper;

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

        {

        if ( aParameters[ j ]->Name() != KTagIntMapping )

            {

            continue;

            }

        TPtrC psValueDesc( KNullDesC );

        TPtrC contextValue( KNullDesC );

        const RKeyValueArray& paramAttr = aParameters[ j ]->Attributes();

        for( TInt k = 0; k < paramAttr.Count(); ++k )

            {

            TPtrC key( paramAttr[ k ]->Key() );

            TPtrC value( paramAttr[ k ]->Value() );

            if( key.CompareF( KAttributePSValue ) == KErrNone )

                {

                psValueDesc.Set( value );

                }

            else if( key.CompareF( KAttributeContextValue ) == KErrNone )

                {

                contextValue.Set( value );

                }

            }

		TInt psValue;

		TLex lex( psValueDesc );

		lex.Val(psValue);

		intmapper->AddMappingL(psValue, contextValue);

        }

	}

void CPSStateSourcePlugIn::ParseTextMapperParamsL(CPSStateMapper& aMapper,

	const RSettingParameterArray& aParameters)

	{

	CPSStateMapperText* textmapper = (CPSStateMapperText*) &aMapper;

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

        {

        if ( aParameters[ j ]->Name() != KTagTextMapping )

            {

            continue; 

            }

        TPtrC psValueDesc( KNullDesC );

        TPtrC contextValue( KNullDesC );

        const RKeyValueArray& paramAttr = aParameters[ j ]->Attributes();

        for( TInt k = 0; k < paramAttr.Count(); ++k )

            {

            TPtrC key( paramAttr[ k ]->Key() );

            TPtrC value( paramAttr[ k ]->Value() );

            if( key.CompareF( KAttributePSValue ) == KErrNone )

                {

                psValueDesc.Set( value );

                }

            else if( key.CompareF( KAttributeContextValue ) == KErrNone )

                {

                contextValue.Set( value );

                }

            }

		textmapper->AddMappingL(psValueDesc, contextValue);

        }

	}

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

// CPSStateSourcePlugIn::DefineContextsL

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

//

void CPSStateSourcePlugIn::DefineContextsL()

    {

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

    	{

    	iMappers[i]->Define();	

    	}

    }

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

// CPSStateSourcePlugIn::InitializeL

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

//

void CPSStateSourcePlugIn::InitializeL()

    {

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

    	{

    	iMappers[i]->InitializeL();	

    	}

    }

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

// CPSStateSourcePlugIn::ConvertHexToTUint

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

//

TInt CPSStateSourcePlugIn::ConvertHexToTUint( const TDesC& aString, 

    TUint32& aValue )

    {

    TInt err = KErrNone;

    TLex lex( aString );

    // Get rid of '0x'

    lex.Inc( 2 );

    if( lex.BoundedVal( aValue, EHex, KLimit ) != KErrNone )

        {

        err = KErrNotFound;

        }

    return err;

    }

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

// CPSStateSourcePlugIn::ConvertDescToSecurityPolicy

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

//

void CPSStateSourcePlugIn::ConvertDescToSecurityPolicy( const TDesC& aString, 

    TSecurityPolicy& aSecurityPolicy )

	{

	TCapability capabilities[7] = 

		{

		ECapability_None,

		ECapability_None,

		ECapability_None,

		ECapability_None,

		ECapability_None,

		ECapability_None,

		ECapability_None

		};

	TLex lexer( aString );

	TInt tokenLength = 0;	

	TInt i = 0;

	do  {

		lexer.SkipSpace();

		lexer.Mark();

		lexer.SkipCharacters();

		tokenLength = lexer.TokenLength();

		if (tokenLength != 0)

			{

			TPtrC token = lexer.MarkedToken();

			if ( i < 7 )

				{

				capabilities[i++] = ConvertToCapabilityNumber( token );

				}

			else

				{

				// TSecurityPolicy can hold maximum of 7 capabilities

				// if more are given, we make a security policy

				// that always fails.

				capabilities[0] = ECapability_Denied;

				}

			}

		}

	while( tokenLength != 0 );

	TSecurityPolicy policy  (

		capabilities[0],

		capabilities[1],

		capabilities[2],

		capabilities[3],

		capabilities[4],

		capabilities[5],

		capabilities[6] );

	aSecurityPolicy = policy;

	}

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

// CPSStateSourcePlugIn::ConvertDescToSecurityPolicy

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

//

TCapability CPSStateSourcePlugIn::ConvertToCapabilityNumber( 

const TDesC& aString )

	{

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

		{

		const TPtrC8 capName8 

			= TPtrC8( (const unsigned char*) CapabilityNames[i] );

		TBuf<20> capName;

		capName.Copy( capName8 );

		if ( aString.CompareF( capName ) == KErrNone )

			{

			return (TCapability) i;

			}

		}

	// In the case the capability is not found from the list

	// a capability that always fail is returned.

	return ECapability_Denied;

	}