diff -r 000000000000 -r 2e3d3ce01487 contextframework/cfw/src/basicoperationsplugin/cfbasicscriptroot.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/contextframework/cfw/src/basicoperationsplugin/cfbasicscriptroot.cpp Tue Feb 02 10:12:00 2010 +0200 @@ -0,0 +1,581 @@ +/* +* Copyright (c) 2002-2008 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: CCFBasicScriptRoot class implementation. +* +*/ + + +// Define this to get capability strings in to use +#define __INCLUDE_CAPABILITY_NAMES__ + +// INCLUDE FILES +#include "cfbasicscriptroot.h" +#include "cfifclause.h" +#include "cfelseifclause.h" +#include "cfelseclause.h" +#include "cfdelay.h" +#include "cfbasicoptrace.h" + +#include +#include +#include + +// CONSTANTS +_LIT( KScriptRootName, "script" ); +_LIT( KScriptEvaluationDelayAttribute, "evaluationDelay" ); +_LIT( KScriptIfName, "if" ); +_LIT( KScriptElseIfName, "elseIf" ); +_LIT( KScriptElseName, "else" ); +_LIT( KScriptUpgradeName, "upgradeSecurity" ); +_LIT( KScriptCapabilityName, "capability" ); + +const TInt KMillisecondsToMicroMultiplier = 1000; + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::CCFBasicScriptRoot +// C++ default constructor can NOT contain any code, that might leave. +// ----------------------------------------------------------------------------- +// +CCFBasicScriptRoot::CCFBasicScriptRoot( MCFOperationServices& aServices, + CCFOperationNode* aParent ): + CCFScriptRoot( aServices, aParent ), + iCapabilitySet( ECapabilityAllFiles ) + { + FUNC_LOG; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::ConstructL() + { + FUNC_LOG; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CCFBasicScriptRoot* CCFBasicScriptRoot::NewL( MCFOperationServices& aServices, + CCFOperationNode* aParent ) + { + FUNC_LOG; + + CCFBasicScriptRoot* self = NewLC( aServices, aParent ); + CleanupStack::Pop( self ); + return self; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::NewLC +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CCFBasicScriptRoot* CCFBasicScriptRoot::NewLC( MCFOperationServices& aServices, + CCFOperationNode* aParent ) + { + FUNC_LOG; + + CCFBasicScriptRoot* self + = new( ELeave ) CCFBasicScriptRoot( aServices, aParent ); + CleanupStack::PushL( self ); + self->ConstructL(); + return self; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::ParseL +// Construction with parsing from a DOM node. +// ----------------------------------------------------------------------------- +// +CCFBasicScriptRoot* CCFBasicScriptRoot::ParseL( MCFOperationServices& aServices, + CCFOperationNode* aParent, + CMDXMLNode& aNode ) + { + if ( aNode.NodeName().CompareF( KScriptRootName ) != 0 + || aNode.NodeType() != CMDXMLNode::EElementNode ) + { + return NULL; // Cannot create script root from the given node. + } + + CCFBasicScriptRoot* self = NewLC( aServices, aParent ); // CLEANUP<< self + + // Try getting evaluation delay. + CMDXMLElement& element = static_cast< CMDXMLElement& >( aNode ); + TPtrC evaluationDelay; + if ( KErrNone == element.GetAttribute( KScriptEvaluationDelayAttribute, + evaluationDelay ) ) + { + if ( evaluationDelay.Length() ) + { + // Convert delay to integer. + TLex parseInt( evaluationDelay ); + parseInt.SkipSpace(); + TInt err = parseInt.Val( self->iScriptLevelDelay ); + if ( err != KErrNone ) + { + ERROR_1( err, "CCFBasicScriptRoot::ParseL - Converting script level evaluation delay failed for [%S]", + &evaluationDelay ); + User::LeaveIfError( err ); + } + self->iDelayActionFiring = CCFDelay::NewL( *self ); + } + } + + TBool ifFound( EFalse ); + TBool elseFound( EFalse ); + TBool unsupportedNode( EFalse ); + // Parse clause nodes (children). + CMDXMLNode* child = aNode.FirstChild(); + while ( child ) + { + TPtrC nodeName( child->NodeName() ); + if ( child->NodeType() == CMDXMLNode::EElementNode ) + { + if ( !ifFound ) + { + // + if ( nodeName.CompareF( KScriptUpgradeName ) == 0 ) + { + ResolveSecurity( *self, *child ); + } + // + else + { + if ( nodeName.CompareF( KScriptIfName ) != 0 ) + { + TPtrC nodeName( child->NodeName() ); + ERROR_GEN_1( "CCFBasicScriptRoot::ParseL - Expecting if, encountered %S", + &nodeName ); + unsupportedNode = ETrue; + break; + } + ifFound = ETrue; + CCFClauseNode* clause + = CCFIfClause::ParseL( aServices, self, *child ); + if ( clause ) + { + self->iChildren.AppendL( clause ); + } + else + { + ERROR_GEN( "CCFBasicScriptRoot::ParseL - Unknown if clause" ); + unsupportedNode = ETrue; + break; + } + } + } + else + { + // + if ( nodeName.CompareF( KScriptElseIfName ) == 0 ) + { + if ( elseFound ) + { + ERROR_GEN( "CCFBasicScriptRoot::ParseL - Clause sequence error, elseIf defined after else clause" ); + unsupportedNode = ETrue; + break; + } + CCFClauseNode* clause + = CCFElseIfClause::ParseL( aServices, self, *child ); + if ( clause ) + { + self->iChildren.AppendL( clause ); + } + else + { + ERROR_GEN( "CCFBasicScriptRoot::ParseL - Unknown elseIf clause" ); + unsupportedNode = ETrue; + break; + } + } + // + else if ( nodeName.CompareF( KScriptElseName ) == 0 ) + { + if ( elseFound ) + { + ERROR_GEN( "CCFBasicScriptRoot::ParseL - Only one else clause supported" ); + unsupportedNode = ETrue; + break; + } + elseFound = ETrue; + CCFClauseNode* clause + = CCFElseClause::ParseL( aServices, self, *child ); + if ( clause ) + { + self->iChildren.AppendL( clause ); + } + else + { + ERROR_GEN( "CCFBasicScriptRoot::ParseL - Unknown else clause" ); + unsupportedNode = ETrue; + break; + } + } + else + { + ERROR_GEN_1( "CCFBasicScriptRoot::ParseL - Expecting elseIf or else, encountered %S", + &nodeName ); + unsupportedNode = ETrue; + break; + } + } + } + else if ( child->NodeType() != CMDXMLNode::ECommentNode ) + { + ERROR_GEN_1( "CCFBasicScriptRoot::ParseL - Unsupported node [%S]", + &nodeName ); + unsupportedNode = ETrue; + break; + } + child = child->NextSibling(); + } + + CleanupStack::Pop( self ); // CLEANUP>> self + if ( unsupportedNode ) + { + delete self; + self = NULL; // Signal inability to parse. + } + + CREATE_DOM_INFO( self, aNode ); + + return self; + } + + +// Destructor +CCFBasicScriptRoot::~CCFBasicScriptRoot() + { + FUNC_LOG; + + delete iDelayActionFiring; + iChildren.ResetAndDestroy(); + } + + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::ContextEvaluatedL +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::ContextEvaluatedL( TInt aContextLevelDelay ) + { + FUNC_LOG; + + INFO_1( "CCFBasicScriptRoot::ContextEvaluatedL - Root value is (-1=undefined, 0=false, 1=true): %d", iValue ); + + // Delay if required + if ( iScriptLevelDelay || aContextLevelDelay ) + { + TTimeIntervalMicroSeconds32 delay( 0 ); + if ( aContextLevelDelay ) + { + delay = aContextLevelDelay * KMillisecondsToMicroMultiplier; + } + else + { + delay = iScriptLevelDelay * KMillisecondsToMicroMultiplier; + } + + if ( !iDelayActionFiring ) + { + iDelayActionFiring = CCFDelay::NewL( *this ); + } + iDelayActionFiring->Delay( delay ); + + INFO( "CCFBasicScriptRoot::ContextEvaluatedL - Action firing delayed" ); + } + else if ( Value() == CCFOperationNode::ECFConditionTrue + && ( !iDelayActionFiring || !( iDelayActionFiring->IsActive() ) ) ) + { + FireActionsL(); + } + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::EvaluatedL +// Cancel evaluation delay if firing actions. +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::EvaluatedL() + { + FUNC_LOG; + + INFO_1( "CCFBasicScriptRoot::EvaluatedL - Root value is (-1=undefined, 0=false, 1=true): %d", iValue ); + + if ( Value() == ECFConditionTrue ) + { + if ( iDelayActionFiring ) + { + iDelayActionFiring->Cancel(); + } + FireActionsL(); + } + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::UpgradeSecurity +// ----------------------------------------------------------------------------- +// +const TCapabilitySet& CCFBasicScriptRoot::UpgradeSecurity() const + { + FUNC_LOG; + + return iCapabilitySet; + } + +// --------------------------------------------------------------------------- +// CCFBasicScriptRoot::ActivateL +// --------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::ActivateL() + { + FUNC_LOG; + + for ( TInt i = 0; i < iChildren.Count(); ++i ) + { + iChildren[ i ]->ActivateL(); + } + } + +// --------------------------------------------------------------------------- +// CCFBasicScriptRoot::Deactivate +// --------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::Deactivate() + { + FUNC_LOG; + + for ( TInt i = 0; i < iChildren.Count(); ++i ) + { + iChildren[ i ]->Deactivate(); + } + } + +// --------------------------------------------------------------------------- +// CCFBasicScriptRoot::CheckSecurity +// --------------------------------------------------------------------------- +// +TInt CCFBasicScriptRoot::CheckSecurity() + { + FUNC_LOG; + + for ( TInt i = 0; i < iChildren.Count(); ++i ) + { + TInt err = iChildren[ i ]->CheckSecurity(); + if ( err != KErrNone ) + { + return err; + } + } + + return KErrNone; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::Cleanup +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::Cleanup() + { + FUNC_LOG; + + for ( TInt i = 0; i < iChildren.Count(); ++i ) + { + iChildren[ i ]->Cleanup(); + } + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::ExpiredL +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::ExpiredL() + { + FUNC_LOG; + + INFO_1( "CCFBasicScriptRoot::ExpiredL - Action firing delay expired, root value is (-1=undefined, 0=false, 1=true): %d", iValue ); + + if ( Value() == ECFConditionTrue ) + { + FireActionsL(); + } + } + + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::Evaluate +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::Evaluate() + { + FUNC_LOG; + + DOM_INFO( "CCFBasicScriptRoot::Evaluate" ); + + TCFConditionValue newValue = Value(); + TBool branchUndefined = EFalse; + + // New value is determined like for the OR operation. + for ( TInt i = 0; i < iChildren.Count(); ++i ) + { + newValue = iChildren[ i ]->Value(); + if ( newValue == ECFConditionTrue ) + { + break; + } + else if ( newValue == ECFConditionUndefined ) + { + branchUndefined = ETrue; + } + } + + if ( branchUndefined && newValue == ECFConditionFalse ) + { + newValue = ECFConditionUndefined; + } + + if ( newValue != Value() ) + { + INFO_1( "CCFBasicScriptRoot::Evaluate - Value changed to (-1=undefined, 0=false, 1=true): %d", newValue ); + + iValue = newValue; + if ( iParent ) + { + iParent->Evaluate(); // Script root should not have parents. + } + } + else + { + INFO_1( "CCFBasicScriptRoot::Evaluate - Value still (-1=undefined, 0=false, 1=true): %d", newValue ); + } + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::FireActionsL +// Fires actions of the first clause node having true value. +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::FireActionsL() + { + FUNC_LOG; + + // Fires actions of the first clause having true value. + for ( TInt i = 0; i < iChildren.Count(); ++i ) + { + if ( iChildren[ i ]->Value() == ECFConditionTrue ) + { + iChildren[ i ]->FireActionsL(); + break; + } + } + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::SetCapabilitites +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::SetCapabilitites( TCapabilitySet& aSet ) + { + FUNC_LOG; + + iCapabilitySet = aSet; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::CapabilityFromDesC +// ----------------------------------------------------------------------------- +// +TCapability CCFBasicScriptRoot::CapabilityFromDesC( + const TDesC8& aCapDesc ) + { + FUNC_LOG; + + TCapability capability = ECapability_None; + for( TInt i = 0; i < ECapability_Limit; i++ ) + { + const char* capName = CapabilityNames[i]; + TPtrC8 capabilityPtr( ( TUint8* )capName ); + if( capabilityPtr.CompareF( aCapDesc ) == KErrNone ) + { + // Found capability + capability = ( TCapability )i; + break; + } + } + + return capability; + } + +// ----------------------------------------------------------------------------- +// CCFBasicScriptRoot::ResolveSecurity +// ----------------------------------------------------------------------------- +// +void CCFBasicScriptRoot::ResolveSecurity( CCFBasicScriptRoot& aRoot, + CMDXMLNode& aNode ) + { + FUNC_LOG; + + TBool capabilitiesFound = EFalse; + + TCapabilitySet capabilitySet; + capabilitySet.SetEmpty(); + + // Get capabilities (security level) + HBufC8* textNodeData = HBufC8::New( KMaxFileName ); + if( textNodeData ) + { + TPtr8 textNodeDataPtr( textNodeData->Des() ); + CMDXMLNode* capabilityNode = aNode.FirstChild(); + while( capabilityNode ) + { + // + if( capabilityNode->NodeName().CompareF( + KScriptCapabilityName ) == KErrNone ) + { + if( capabilityNode->NodeType() == CMDXMLNode::EElementNode ) + { + CMDXMLNode* child = capabilityNode->FirstChild(); + if( child->NodeType() == CMDXMLNode::ETextNode ) + { + CMDXMLText* textNode = static_cast( child ); + textNodeDataPtr.Copy( textNode->Data() ); + capabilitySet.AddCapability( CapabilityFromDesC( + textNodeDataPtr ) ); + capabilitiesFound = ETrue; + } + } + } + capabilityNode = capabilityNode->NextSibling(); + } + + delete textNodeData; + textNodeData = NULL; + } + + // Check if the script does not have an upgrade security level set + if( !capabilitiesFound ) + { + // Set AllFiles capability + capabilitySet.Set( ECapabilityAllFiles ); + } + aRoot.SetCapabilitites( capabilitySet ); + } + +// End of file