diff -r 77cb48a03620 -r d9861ae9169c simpledatamodeladapter/src/presencepluginxdmpresrules.cpp --- a/simpledatamodeladapter/src/presencepluginxdmpresrules.cpp Thu Jul 01 14:09:06 2010 +0100 +++ /dev/null Thu Jan 01 00:00:00 1970 +0000 @@ -1,1100 +0,0 @@ -/* -* Copyright (c) 2006-2010 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: IETF SIMPLE Protocol implementation for XIMP Framework -* -*/ - -#include -#include -#include -#include -#include -#include -#include - -#include "presencepluginxdmpresrules.h" -#include "mpresrulesasynchandler.h" - - -// ======== MEMBER FUNCTIONS ======== - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::NewLC() -// --------------------------------------------------------------------------- -// -CPresencePluginXdmPresRules* CPresencePluginXdmPresRules::NewLC( - const TInt aSettingId, TBool aLocalMode ) - { - CPresencePluginXdmPresRules* self = - new (ELeave) CPresencePluginXdmPresRules( aSettingId ); - CleanupStack::PushL( self ); - self->ConstructL( aSettingId, aLocalMode ); - return self; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::NewL() -// --------------------------------------------------------------------------- -// -CPresencePluginXdmPresRules* CPresencePluginXdmPresRules::NewL( - const TInt aXmdId, TBool aLocalMode ) - { - CPresencePluginXdmPresRules* self = - new( ELeave ) CPresencePluginXdmPresRules( aXmdId ); - CleanupStack::PushL( self ); - self->ConstructL( aXmdId, aLocalMode ); - CleanupStack::Pop( self ); - return self; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::CPresencePluginXdmPresRules() -// --------------------------------------------------------------------------- -// -CPresencePluginXdmPresRules::CPresencePluginXdmPresRules( const TInt aXdmId ) - :CActive( EPriorityStandard ), - iSettingsId( aXdmId ), - iXdmState( EStateIdle ), //Listeting xdState - iRulesUpdateState(EStateNoOperation), - iPresXdmOk( EFalse ), - iAsyncReq( ENoOperation ) - { - CActiveScheduler::Add( this ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::ConstructL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::ConstructL( - const TInt aXmdId, - TBool aLocalMode ) - { - DP_SDA2("CPresencePluginXdmPresRules::ConstructL - aXdmId: %d", aXmdId ); - using namespace NPresencePlugin::NPresence; - if ( !aLocalMode ) - { - DP_SDA("CPresencePluginXdmPresRules::ConstructL Normal Mode"); - CXdmProtocolInfo* xdmProtocolInfo = CXdmProtocolInfo::NewL( aXmdId ); - CleanupStack::PushL( xdmProtocolInfo ); - DP_SDA("CPresencePluginXdmPresRules::ConstructL - protocol info created"); - xdmProtocolInfo->SetCacheUsage( EFalse ); - DP_SDA("CPresencePluginXdmPresRules::ConstructL - create xdm engine"); - iXdmEngine = CXdmEngine::NewL( *xdmProtocolInfo ); - CleanupStack::PopAndDestroy( xdmProtocolInfo ); - DP_SDA("CPresencePluginXdmPresRules::ConstructL - xdm engine created"); - - DP_SDA("CPresencePluginXdmPresRules::ConstructL - create doc model"); - //Create empty document model - iPresRulesDoc = - iXdmEngine->CreateDocumentModelL( - KPresencePresRules, EXdmOmaPresenceRules ); - DP_SDA("CPresencePluginXdmPresRules::ConstructL - create doc model ok"); - } - else - { - DP_SDA("CPresencePluginXdmPresRules::ConstructL LocalMode Mode"); - //Lets Try localmode - CXdmProtocolInfo* xdmProtocolInfo = - CXdmProtocolInfo::NewL( 0, KLocalProtocol, KNullDesC ); - CleanupStack::PushL( xdmProtocolInfo ); - iXdmEngine = CXdmEngine::NewL( *xdmProtocolInfo ); - CleanupStack::PopAndDestroy( xdmProtocolInfo ); - - //Create empty document model - iPresRulesDoc = - iXdmEngine->CreateDocumentModelL( - KPresencePresRules, EXdmOmaPresenceRules ); - } - DP_SDA("CPresencePluginXdmPresRules::ConstructL create root"); - CreateRootIfNeededL(); - DP_SDA("CPresencePluginXdmPresRules::ConstructL - out" ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules() -// --------------------------------------------------------------------------- -// -CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules() - { - DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules"); - - if ( iPresRulesDoc ) - { - DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules 2"); - if ( iXdmEngine ) - { - DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules 3"); - TRAP_IGNORE( iXdmEngine->DeleteDocumentModelL( iPresRulesDoc )); - } - } - - delete iXdmEngine; - delete iEntityUri; - - DP_SDA("CPresencePluginXdmPresRules::~CPresencePluginXdmPresRules Done"); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::GetXdmRulesL() -// --------------------------------------------------------------------------- -// -TInt CPresencePluginXdmPresRules::GetXdmRulesL( - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL"); - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - if (IsActive()) - return KErrAlreadyExists; - iAsyncReq = EXdmGetRulesFromServer; - iAsyncHandler = aHandler; - using namespace NPresencePlugin::NPresence; - - if ( !iPresXdmOk ) - { - DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL !iPresXdmOk"); - - - iPresRulesDoc->FetchDataL(); - DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL !iPresXdmOk end"); - } - else - { - // Document already exists, no need to search from a server - DP_SDA("CPresencePluginXdmPresRules::GetXdmRulesL Already exists"); - iStatus = KRequestPending; - SetActive(); - } - return KErrNone; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::UpdateXdmRulesL() -// --------------------------------------------------------------------------- -// -TInt CPresencePluginXdmPresRules::UpdateXdmRulesL( - MPresRulesAsyncHandler* const aHandler ) - { - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - if (IsActive()) - { - return KErrAlreadyExists; - } - iAsyncReq = EXdmUpdateRules; - iAsyncHandler = aHandler; - - iPresRulesDoc->AppendL(); - iXdmEngine->UpdateL(iPresRulesDoc, iStatus); - SetActive(); - return KErrNone; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::MakeInitialRulesDocumentL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::MakeInitialRulesDocumentL( - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL"); - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - iAsyncReq = EXdmInitialPresDoc; - iAsyncHandler = aHandler; - - CXdmDocumentNode* root = iPresRulesDoc->DocumentRoot(); - if ( !root ) - { - DP_SDA("CPresencePluginXdmPresRules:: Create root"); - root = iPresRulesDoc->CreateRootL(); - } - - using namespace NPresencePlugin::NPresence; - root->SetNameL( KPresenceRuleset ); - - // send to the server and start wait a response - iPresRulesDoc->AppendL( root ); - DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL append"); - iAsyncReq = EXdmInitialPresDoc; - DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL end"); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::AddWhiteListL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::AddWhiteListL( CXdmDocumentNode* aRoot ) - { - DP_SDA("CPresencePluginXdmPresRules::AddWhiteList"); - using namespace NPresencePlugin::NPresence; - using namespace NPresencePlugin::NPresenceTransformations; - - if ( aRoot->IsEmptyNode() ) - { - DP_SDA("AddWhiteList is empty node"); - aRoot->SetEmptyNode( EFalse ); - } - // whitelist - CXdmDocumentNode* child2 = aRoot->CreateChileNodeL( KPresenceRule ); - CleanupStack::PushL( child2 ); - CXdmNodeAttribute* name2 = child2->CreateAttributeL( KPresenceId ); - CleanupStack::PushL( name2 ); - name2->SetAttributeValueL( KPresenceXdmWhiteList ); - DP_SDA("CPresencePluginXdmPresRules::AddWhiteList 2"); - - CXdmDocumentNode* conditionsNode2 = - child2->CreateChileNodeL( KPresenceConditions ); - - conditionsNode2->CreateChileNodeL( KPresenceIdentity ); - CXdmDocumentNode* actionNode2 = - child2->CreateChileNodeL( KPresenceAction ); - - DP_SDA("CPresencePluginXdmPresRules::AddWhiteList 3"); - CXdmDocumentNode* subNode2 = actionNode2->CreateChileNodeL( KPresenceSub ); - DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL 4"); - - subNode2->SetLeafNode( ETrue ); - subNode2->SetLeafNodeContentL( KPresenceAllow8 ); - DP_SDA("CPresencePluginXdmPresRules::AddWhiteList 5"); - - //Add transformations - /* - - - - - - - - - - - - - - */ - - CXdmDocumentNode* trasform2 = - child2->CreateChileNodeL( KPresenceTrasformations ); - CXdmDocumentNode* services2 = - trasform2->CreateChileNodeL( KPresenceProvideServices ); - services2->CreateChileNodeL( KPresenceAllServices ); - CXdmDocumentNode* person2 = - trasform2->CreateChileNodeL( KPresenceProvidePersons ); - person2->CreateChileNodeL( KPresenceAllPersons ); - CXdmDocumentNode* devices2 = - trasform2->CreateChileNodeL( KPresenceProvidedevices ); - devices2->CreateChileNodeL( KPresenceAlldevices ); - trasform2->CreateChileNodeL( KPresenceProvideAllAttributes ); - - CleanupStack::Pop( name2 ); - CleanupStack::Pop( child2 ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::AddBlackList() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::AddBlackListL( CXdmDocumentNode* aRoot ) - { - DP_SDA("CPresencePluginXdmPresRules::AddBlackList"); - // add all the list nodes - // buddylist - using namespace NPresencePlugin::NPresence; - using namespace NPresencePlugin::NPresenceTransformations; - if ( aRoot->IsEmptyNode() ) - { - DP_SDA("AddBlackList is empty node"); - aRoot->SetEmptyNode( EFalse ); - } - CXdmDocumentNode* child1 = aRoot->CreateChileNodeL( KPresenceRule ); - CleanupStack::PushL( child1 ); - CXdmNodeAttribute* name = child1->CreateAttributeL( KPresenceId ); - CleanupStack::PushL( name ); - - name->SetAttributeValueL( KPresenceXdmBlockRule ); - // add condition - CXdmDocumentNode* conditionsNode = - child1->CreateChileNodeL( KPresenceConditions ); - conditionsNode->CreateChileNodeL( KPresenceIdentity ); - - CXdmDocumentNode* actionNode = - child1->CreateChileNodeL( KPresenceAction ); - - DP_SDA("CPresencePluginXdmPresRules::AddBlackList 1"); - CXdmDocumentNode* subNode = - actionNode->CreateChileNodeL( KPresenceSub ); - DP_SDA("CPresencePluginXdmPresRules::MakeInitialXdmsDocumentL 1/2"); - subNode->SetLeafNode(ETrue); - subNode->SetLeafNodeContentL( KPresenceBlock8 ); - DP_SDA("CPresencePluginXdmPresRules::AddBlackList 1/3"); - - CXdmDocumentNode* trasform = - child1->CreateChileNodeL( KPresenceTrasformations ); - CXdmDocumentNode* services = - trasform->CreateChileNodeL( KPresenceProvideServices ); - services->CreateChileNodeL( KPresenceAllServices ); - - CXdmDocumentNode* person = - trasform->CreateChileNodeL( KPresenceProvidePersons ); - person->CreateChileNodeL( KPresenceAllPersons ); - CXdmDocumentNode* devices = - trasform->CreateChileNodeL( KPresenceProvidedevices ); - devices->CreateChileNodeL( KPresenceAlldevices ); - trasform->CreateChileNodeL( KPresenceProvideAllAttributes ); - CleanupStack::Pop( name ); - CleanupStack::Pop( child1 ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::RunL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::RunL( ) - { - DP_SDA("CPresencePluginXdmPresRules::RunL"); - TPluginPresRulesXdmOperation origState = iAsyncReq; - iAsyncReq = ENoOperation; - TInt myStatus = iStatus.Int(); - - DP_SDA2("CPresencePluginXdmPresRules::RunL mystatus %d ", myStatus); - DP_SDA2("CPresencePluginXdmPresRules::RunL state %d ", origState); - - switch( origState ) - { - case EXdmGetRulesFromServer: - { - DP_SDA("CPresencePluginXdmPresRules::RunL EXdmGetRulesFromServer"); - iAsyncHandler->HandlePresUpdateDocumentL( - iStatus.Int() ); - } - break; - case EXdmInitialPresDoc: - { - DP_SDA("CPresencePluginXdmPresRules::RunL EXdmInitialPresDoc"); - iAsyncHandler->HandlePresUpdateDocumentL( - iStatus.Int() ); - } - break; - case EXdmUpdateRules: - { - DP_SDA("CPresencePluginXdmPresRules::RunL EXdmUpdateRules"); - iAsyncHandler->HandlePresUpdateDocumentL( - iStatus.Int() ); - } - break; - case EXdmUpdateRulesFromServer: - { - DP_SDA("RunL ExdmUpdateRulesFromServer"); - CreateRootIfNeededL(); //This check is added for Openser/OpenXcap - iAsyncHandler->HandlePresUpdateDocumentL( iStatus.Int() ); - iRulesUpdateState = EStateNoOperation; - } - break; - case ENoOperation: - default: - break; - } - DP_SDA("CPresencePluginXdmPresRules::RunL end"); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::DoCancel() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::DoCancel( ) - { - DP_SDA("CPresencePluginXdmPresRules::DoCancel"); - iXdmEngine->CancelUpdate(iPresRulesDoc); - iAsyncReq = ECancelDocument; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::RunError() -// --------------------------------------------------------------------------- -// -TInt CPresencePluginXdmPresRules::RunError( TInt /*aError*/ ) - { - DP_SDA("CPresencePluginXdmPresRules::RunError"); - return KErrNone; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::AddEntityToWhiteListL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::AddEntityToWhiteListL( - const TDesC& aUri, - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::AddEntityToWhiteListL"); - iEntityUri = aUri.Alloc(); - DP_SDA2( "AddEntityToWhiteListL entity %S", iEntityUri ); - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - - iAsyncReq = EXdmUpdateRules; - iAsyncHandler = aHandler; - iRulesUpdateState = EStateAddToWhiteList; - DoOneAddUserL( KPresenceXdmWhiteList, iEntityUri->Des() ); - - UpdateXdmRulesL( aHandler ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::RemoveEntityFromWhiteListL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::RemoveEntityFromWhiteListL( - const TDesC& aUri, - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::RemoveEntityFromWhiteListL"); - iEntityUri = aUri.Alloc(); - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - - iAsyncReq = EXdmUpdateRules; - iAsyncHandler = aHandler; - iRulesUpdateState = EStateRemoveFromWhiteList; - RemoveOneFromRuleL( KPresenceXdmWhiteList, iEntityUri->Des() ); - - UpdateXdmRulesL( aHandler ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::AddEntityToBlockedRulesL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::AddEntityToBlockedRulesL( - const TDesC& aUri, - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::AddEntityToBlockedRulesL"); - iEntityUri = aUri.Alloc(); - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - - iAsyncReq = EXdmUpdateRules; - iAsyncHandler = aHandler; - iRulesUpdateState = EStateAddToBlockList; - DoOneAddUserL( KPresenceXdmBlockRule, iEntityUri->Des() ); - - UpdateXdmRulesL( aHandler ); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL( - const TDesC& aUri, - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL"); - iEntityUri = aUri.Alloc(); - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - - iAsyncReq = EXdmUpdateRules; - iAsyncHandler = aHandler; - iRulesUpdateState = EStateRemoveFromBlackList; - RemoveOneFromRuleL( KPresenceXdmBlockRule, iEntityUri->Des() ); - - UpdateXdmRulesL( aHandler ); - DP_SDA("CPresencePluginXdmPresRules::RemoveEntityBlockedRulesL end"); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::RemoveOneFromRule() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::RemoveOneFromRuleL( - const TDesC& aRule, const TDesC& aUri ) - { - DP_SDA("CPresencePluginXdmPresRules::RemoveOneFromRule"); - CXdmDocumentNode* ruleNode = NULL; - CXdmNodeAttribute* attr = NULL; - TBool found( EFalse ); - TBool ruleAvaible( EFalse ); - - using namespace NPresencePlugin::NPresence; - - RPointerArray rules; - CleanupClosePushL( rules ); - - RPointerArray nodes; - CleanupClosePushL( nodes ); - - RPointerArray ones; - CleanupClosePushL( ones ); - - if ( iPresRulesDoc ) - { - DP_SDA("RemoveOneFromRule iPresRulesDoc ok"); - - //Check if rule exist - ruleAvaible = FindRuleL( aRule, EFalse ); - - if ( ruleAvaible ) - { - - TRAPD( err, ruleNode = GetRulesL( aRule, rules ) ); - if( !err ) - { - found = ETrue; - } - } - } - - if ( found ) - { - DP_SDA("CPresencePluginXdmPresRules::RemoveOneFromRule found"); - TInt findErr = ruleNode->Find( KPresenceOne, nodes ); - if ( !findErr ) - { - TInt nodeCount = nodes.Count(); - for ( TInt i = 0; i < nodeCount; i++ ) - { - CXdmDocumentNode* currNode = nodes[i]; - attr = ( currNode )->Attribute( KPresenceId ); - if ( attr && !attr->AttributeValue().CompareF( aUri )) - { - DP_SDA("RemoveOneFromRule Remove"); - //First remove currNode form model - iPresRulesDoc->RemoveFromModelL( currNode ); - - //Check how many rules are in group now - DP_SDA("RemoveOneFromRule Find all one field from rule"); - User::LeaveIfError( ruleNode->Find( KPresenceOne, ones ) ); - TInt oneCount = ones.Count(); - DP_SDA2("RemoveOneFromRule ones count %d", oneCount); - //if there is no any ones in rule remove it - if( KErrNone == oneCount ) - { - //Remove group - DP_SDA("RemoveOneFromRule Remove GROUP"); - RemoveRuleGroupL( aRule ); - } - // Update model to server - iPresRulesDoc->AppendL(); - break; - } - } - } - } - - CleanupStack::PopAndDestroy( &ones ); // >>> nodes - CleanupStack::PopAndDestroy( &nodes ); // >>> nodes - CleanupStack::PopAndDestroy( &rules ); // >>> lists - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::DoOneAddUserL() -// --------------------------------------------------------------------------- -// - void CPresencePluginXdmPresRules::DoOneAddUserL( - const TDesC& aRule, const TDesC& aUri ) - { - DP_SDA("CPresencePluginXdmPresRules::DoOneAddUserL"); - using namespace NPresencePlugin::NPresence; - - CXdmDocumentNode* ruleNode = NULL; - RPointerArray identityNode; - CleanupClosePushL( identityNode ); - - TBool found( EFalse ); - TBool ruleAvaible( EFalse ); - - using namespace NPresencePlugin::NPresence; - - RPointerArray rules; - CleanupClosePushL( rules ); - - - DP_SDA("CPresencePluginXdmPresRules::DoOneAddUserL iPresRulesDoc"); - if ( iPresRulesDoc ) - { - DP_SDA("DoOneAddUserL iPresRulesDoc Exist"); - - ruleAvaible = FindRuleL( aRule, ETrue ); - - if ( ruleAvaible ) - { - TRAPD( err, ruleNode = GetRulesL( aRule, rules ) ); - if( !err ) - { - found = ETrue; - } - } - } - - //Finaly add entity to rules - if ( found ) - { - //Check if enity already in list - if( !CheckIfOneExistL( aRule, aUri ) ) - { - DP_SDA("CPresencePluginXdmPresRules::DoOneAddUserL Found"); - // Find identityNode inside rulenode - User::LeaveIfError( - ruleNode->Find( KPresenceIdentity, identityNode ) ); - if ( identityNode[0] ) - { - if ( identityNode[0]->IsEmptyNode() ) - { - DP_SDA("DoOneAddUserL rule node empty"); - identityNode[0]->SetEmptyNode( ETrue ); - } - // create new one node inside identity - CXdmDocumentNode* newNode = - identityNode[0]->CreateChileNodeL( KPresenceOne ); - newNode->SetEmptyNode( ETrue ); - CXdmNodeAttribute* attributeOneId = - newNode->CreateAttributeL( KPresenceId ); - - attributeOneId->SetAttributeValueL( aUri ); - iPresRulesDoc->AppendL(); - DP_SDA("DoOneAddUserL added"); - } - } - } - else - { - DP_SDA("CPresencePluginXdmPresRules::DoOneAddUserL error not found"); - User::Leave( KErrNotFound ); - } - DP_SDA("CPresencePluginXdmPresRules::DoOneAddUserL end"); - CleanupStack::PopAndDestroy( 2 ); - - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::GetRulesL() -// --------------------------------------------------------------------------- -// -CXdmDocumentNode* CPresencePluginXdmPresRules::GetRulesL( const TDesC& aRule, - RPointerArray& aRuleArray ) - { - DP_SDA("GetRulesL find Again if rule now exist"); - using namespace NPresencePlugin::NPresence; - - CXdmDocumentNode* ruleNode = NULL; - CXdmNodeAttribute* attr = NULL; - - TBool result(EFalse); - // find if rule tag is exist - User::LeaveIfError( iPresRulesDoc->Find( KPresenceRule, aRuleArray ) ); - - // How many rules found - TInt count = aRuleArray.Count(); - DP_SDA2("GetRulesL ruleCount %d ", count); - - // Check is needed rule id exist - for ( TInt i=0; i < count; i++ ) - { - ruleNode = aRuleArray[i]; - TBuf buf; - buf.Copy( - ruleNode->Attribute( KPresenceId )->AttributeValue() ); - DP_SDA2("GetRulesL ruleNode %S", &buf); - - attr = ruleNode->Attribute( KPresenceId ); - if ( attr && !attr->AttributeValue().CompareF( aRule ) ) - { - DP_SDA("CPresencePluginXdmPresRules::GetRulesL FOUND"); - result = ETrue; - break; - } - } - - // Make second compare - if( !result ) - { - User::LeaveIfError(iPresRulesDoc->Find( KPresenceRule, aRuleArray )); - TInt count2 = aRuleArray.Count(); - - for ( TInt i=0; i < count2; i++ ) - { - ruleNode = aRuleArray[i]; - attr = ruleNode->Attribute( KPresenceId ); - if ( attr && attr->AttributeValue().CompareF( aRule ) ) - { - DP_SDA("CPresencePluginXdmPresRules::GetRulesL NOT FOUND"); - User::Leave( KErrNotFound ); - } - } - } - - return ruleNode; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::FindRuleL() -// --------------------------------------------------------------------------- -// -TBool CPresencePluginXdmPresRules::FindRuleL( - const TDesC& aRule, TBool aCreateRule ) - { - DP_SDA("CPresencePluginXdmPresRules::FindRuleL"); - using namespace NPresencePlugin::NPresence; - - if ( iPresRulesDoc ) - { - DP_SDA("CPresencePluginXdmPresRules::FindRuleL pres document exists"); - RPointerArray rule; - CleanupClosePushL( rule ); - - CXdmDocumentNode* ruleNode = NULL; - CXdmNodeAttribute* attr = NULL; - - TBool found = EFalse; - //Find all rules from document and but them to array - DP_SDA("CPresencePluginXdmPresRules::FindRuleL find rule"); - TInt err = iPresRulesDoc->Find( KPresenceRule, rule ); - DP_SDA2("FindRuleL find rule error %d", err); - - // There is no any rules yet avaible create - if ( err == KErrNotFound && aCreateRule ) - { - DP_SDA("FindRuleL Not any rules exist"); - if ( iRulesUpdateState == EStateAddToWhiteList ) - { - DP_SDA("FindRuleL add white list"); - AddWhiteListL( iPresRulesDoc->DocumentRoot() ); - CleanupStack::PopAndDestroy( 1 ); - return ETrue; - } - else if ( iRulesUpdateState == EStateAddToBlockList ) - { - DP_SDA("FindRuleL add black list"); - AddBlackListL( iPresRulesDoc->DocumentRoot() ); - CleanupStack::PopAndDestroy( 1 ); - return ETrue; - } - } - - // if rule element found find if aRule exist - TInt count = rule.Count(); - for ( TInt i=0; i < count; i++ ) - { - ruleNode = rule[i]; - TBuf buf; - buf.Copy( - ruleNode->Attribute( KPresenceId )->AttributeValue() ); - DP_SDA2("FindRuleL ruleNode %S", &buf); - - attr = ruleNode->Attribute( KPresenceId ); - if ( attr && !attr->AttributeValue().CompareF( aRule ) ) - { - DP_SDA("CPresencePluginXdmPresRules::FindRuleL FOUND"); - found = ETrue; - } - } - - if ( !found && aCreateRule) - { - // if rule not found create it - DP_SDA("CPresencePluginXdmPresRules::FindRuleL not found"); - //if rule not found add rule and check again - if ( EStateAddToWhiteList == iRulesUpdateState ) - { - DP_SDA("FindRuleL add white list2"); - AddWhiteListL( iPresRulesDoc->DocumentRoot() ); - CleanupStack::PopAndDestroy( 1 ); - return ETrue; - } - else if ( EStateAddToBlockList == iRulesUpdateState ) - { - DP_SDA("FindRuleL add black list 2"); - AddBlackListL( iPresRulesDoc->DocumentRoot() ); - CleanupStack::PopAndDestroy( 1 ); - return ETrue; - } - } - - CleanupStack::PopAndDestroy( 1 ); - return ETrue; - } - else - { - // Should we create presrules document - DP_SDA("CPresencePluginXdmPresRules::FindRuleL end"); - return EFalse; - } - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::CheckIfOneExistL -// --------------------------------------------------------------------------- -// -TBool CPresencePluginXdmPresRules::CheckIfOneExistL( - const TDesC& aRule, - const TDesC& aUri ) - { - using namespace NPresencePlugin::NPresence; - DP_SDA("CPresencePluginXdmPresRules::CheckIfOneExistL"); - - using namespace NPresencePlugin::NPresence; - - CXdmNodeAttribute* attr = NULL; - RPointerArray nodes; - CleanupClosePushL( nodes ); - TBool state( EFalse ); - - CXdmDocumentNode* root = iPresRulesDoc->DocumentRoot(); - CXdmDocumentNode* foundNode = SearchListUnderParentL( root, aRule ); - - if ( foundNode ) - { - DP_SDA("CPresencePluginXdmPresRules::CheckIfOneExistL check nodes"); - TInt findErr = foundNode->Find( KPresenceOne, nodes ); - DP_SDA2("CheckIfEnityExist - findErr: %d", findErr ); - - if ( findErr ) - { - DP_SDA("CheckIfOneExistL One not exist "); - state = EFalse; - } - else - { - DP_SDA("CPresencePluginXdmPresRules::CheckIfOneExistL Else"); - TInt nodeCount = nodes.Count(); - for ( TInt i = 0; i < nodeCount; i++ ) - { - CXdmDocumentNode* currNode = nodes[i]; - attr = ( currNode )->Attribute( KPresenceId ); - if ( attr && !attr->AttributeValue().CompareF( aUri )) - { - DP_SDA("CheckIfOneExistL entity exists"); - //Enity is exist - state = ETrue; - break; - } - } - } - } - DP_SDA("CPresencePluginXdmPresRules::CheckIfOneExistL Destroy nodes"); - CleanupStack::PopAndDestroy( &nodes ); // >>> nodes - return state; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::RemoveRuleGroupL( ) -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::RemoveRuleGroupL( const TDesC& aRule ) - { - DP_SDA("CPresencePluginXdmUtils::RemoveRuleGroupL"); - CXdmDocumentNode* ruleNode = NULL; - CXdmNodeAttribute* attr = NULL; - TBool found( EFalse ); - TBool ruleAvaible( EFalse ); - - using namespace NPresencePlugin::NPresence; - - RPointerArray rules; - CleanupClosePushL( rules ); - - RPointerArray nodes; - CleanupClosePushL( nodes ); - - //Find rules - if ( iPresRulesDoc ) - { - DP_SDA("RemoveRuleGroupL iPresRulesDoc ok"); - - //Check if rule exist - ruleAvaible = FindRuleL( aRule, EFalse ); - - if ( ruleAvaible ) - { - // If rule found get count how many rules are in xml - TInt findErr = iPresRulesDoc->Find( KPresenceRule, rules ); - DP_SDA2("RemoveRuleGroupL findError %d", findErr); - if ( !findErr ) - { - DP_SDA("RemoveRuleGroupL found EFalse"); - found = EFalse; - } - else - { - TInt count = rules.Count(); - DP_SDA2("RemoveRuleGroupL rule count %d", count); - for ( TInt i=0; i < count; i++ ) - { - ruleNode = rules[i]; - attr = ruleNode->Attribute( KPresenceId ); - if ( attr && !attr->AttributeValue().CompareF( aRule )) - { - found = ETrue; - break; - } - } - } - } - } - - if ( found ) - { - User::LeaveIfError( iPresRulesDoc->Find( KPresenceRule, nodes )); - TInt ruleCount = nodes.Count(); - DP_SDA2("L node count %d", ruleCount); - for ( TInt i = 0; i < ruleCount; i++ ) - { - CXdmDocumentNode* currNode = nodes[i]; - attr = currNode->Attribute( KPresenceId ); - if ( attr && !attr->AttributeValue().CompareF( aRule )) - { - DP_SDA("RemoveRuleGroupL remove rule"); - // This is the user we are looking for deletion. - iPresRulesDoc->RemoveFromModelL( currNode ); - //Update - iPresRulesDoc->AppendL(); - break; - } - } - } - else - { - User::Leave( KErrNotFound ); - } - CleanupStack::PopAndDestroy( &nodes ); // >>> nodes - CleanupStack::PopAndDestroy( &rules ); // >>> rules - DP_SDA("CPresencePluginXdmUtils::RemoveRuleGroupL end"); - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::UpdateFromServerL() -// --------------------------------------------------------------------------- -// -TInt CPresencePluginXdmPresRules::UpdateFromServerL( - MPresRulesAsyncHandler* const aHandler ) - { - DP_SDA("CPresencePluginXdmPresRules::UpdateFromServer"); - using namespace NPresencePlugin::NPresence; - __ASSERT_ALWAYS(aHandler, User::Leave(KErrArgument)); - - if ( IsActive() ) - { - return KErrAlreadyExists; - } - iPresRulesDoc->ResetContents(); - iPresRulesDoc->FetchDataL(); - iAsyncReq = EXdmUpdateRulesFromServer; - iAsyncHandler = aHandler; - iXdmEngine->UpdateL( iPresRulesDoc, iStatus ); - SetActive(); - DP_SDA("CPresencePluginXdmPresRules::UpdateFromServer end"); - return KErrNone; - } - -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::CreateRootIfNeededL() -// --------------------------------------------------------------------------- -// -void CPresencePluginXdmPresRules::CreateRootIfNeededL() - { - DP_SDA("CPresencePluginXdmPresRules::CreateRootIfNeededL"); - using namespace NPresencePlugin::NPresence; - - CXdmDocumentNode* myRootNode = iPresRulesDoc->DocumentRoot(); - - if ( myRootNode ) - { - DP_SDA("CreateRootIfNeededL document root exists"); - myRootNode->SetEmptyNode(EFalse); - return; - } - - DP_SDA("CPresencePluginXdmPresRules::CreateRootIfNeededL create root"); - myRootNode = iPresRulesDoc->CreateRootL(); - DP_SDA("CreateRootIfNeededL create root pushL"); - CleanupStack::PushL( myRootNode ); - myRootNode->SetNameL( KPresenceRuleset ); - DP_SDA("CPresencePluginXdmPresRules::CreateRootIfNeededL create root POP"); - CleanupStack::Pop( myRootNode ); - DP_SDA("CPresencePluginXdmPresRules::CreateRootIfNeededL create root end"); - } - -void CPresencePluginXdmPresRules::ResetAndDestroy1( TAny* aPointerArray ) - { - if ( aPointerArray ) - { - RPointerArray* array = - static_cast*>( aPointerArray ); - array->ResetAndDestroy(); - array->Close(); - } - } - -void CPresencePluginXdmPresRules::ResetAndDestroy2( TAny* aPointerArray ) - { - if ( aPointerArray ) - { - RPointerArray* array = - static_cast*>( aPointerArray ); - array->ResetAndDestroy(); - array->Close(); - } - } -// --------------------------------------------------------------------------- -// CPresencePluginXdmPresRules::SearchListUnderParentL -// --------------------------------------------------------------------------- -// -CXdmDocumentNode* CPresencePluginXdmPresRules::SearchListUnderParentL( - CXdmDocumentNode* aParent, - const TDesC& aName ) - { - DP_SDA("CPresencePluginXdmPresRules::SearchListUnderParentL"); - - using namespace NPresencePlugin::NPresence; - - if ( !aParent ) - { - DP_SDA("CPresencePluginXdmUtils::SearchListUnderParentL return NULL"); - return NULL; - } - - RPointerArray resultArray; - RPointerArray attributeArray; - - CleanupClosePushL( resultArray ); // <<< resultArray - CleanupClosePushL( attributeArray ); // <<< attributeArray - - SXdmAttribute16 attr; - attr.iName.Set( KPresenceId ); - attr.iValue.Set( aName ); - attributeArray.Append( &attr ); - - CXdmDocumentNode* currNode = NULL; - - aParent->Find( KPresenceRule, resultArray, attributeArray ); - - TInt count = resultArray.Count(); - DP_SDA2("SearchListUnderParentL node count %d",count); - for ( TInt i=0; i < count; i++ ) - { - currNode = resultArray[i]; - CXdmDocumentNode* parent = currNode->Parent(); - if ( parent == aParent ) - { - DP_SDA("SearchListUnderParentL parent MATCH"); - break; - } - currNode = NULL; - } - - CleanupStack::PopAndDestroy(); // clItem - CleanupStack::PopAndDestroy(); // clItem2 - DP_SDA("CPresencePluginXdmUtils::SearchListUnderParentL return"); - return currNode; - } - -// End of file