diff -r 000000000000 -r 2e3d3ce01487 contextframework/cfwplugins/PSStateSourcePlugIn/src/psstatesourceplugin.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/contextframework/cfwplugins/PSStateSourcePlugIn/src/psstatesourceplugin.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,421 @@ +/* +* 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 +#include +#include + +#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; + } +