--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/simpledatamodeladapter/src/presencepluginxdmutils.cpp Wed Sep 01 12:23:14 2010 +0100
@@ -0,0 +1,1687 @@
+/*
+* 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 <e32std.h>
+#include <utf.h>
+#include <e32test.h>
+#include <ximpobjectfactory.h>
+#include <presenceobjectfactory.h>
+#include <ximpidentity.h>
+#include <ximpobjectcollection.h>
+#include <presentitygroupinfo.h>
+#include <presentitygroupmemberinfo.h>
+#include <XdmEngine.h>
+#include <XdmDocument.h>
+#include <XdmProtocolInfo.h>
+#include <XdmDocumentNode.h>
+#include <XdmNodeAttribute.h>
+#include <XdmErrors.h>
+#include <pressettingsapi.h> //for TPresSettingsSet
+#include <XdmSettingsApi.h>
+#include <XdmProtocolUidList.h>
+#include <avabilitytext.h>
+
+#include "presencepluginxdmpresrules.h"
+#include "mpresencepluginconnectionobs.h"
+#include "presenceplugincommon.h"
+#include "presencepluginxdmutils.h"
+#include "presencepluginvirtualgroup.h"
+#include "presencepluginauthorization.h"
+#include "presenceplugindata.h"
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::CPresencePluginXdmUtils()
+// ---------------------------------------------------------------------------
+//
+CPresencePluginXdmUtils::CPresencePluginXdmUtils(
+ MPresencePluginConnectionObs& aObs , TInt aXmdId, TBool aLocalmode )
+ : CActive( CActive::EPriorityStandard ),
+ iConnObs(aObs), iSettingsId(aXmdId),
+ iXdmState(EStateIdle), iOperation( ENoOperation ),
+ iPresXdmOk( EFalse ), iXdmOk( EFalse ),
+ iRulesUpdateState(EStateNoOperation), iLocalMode( aLocalmode )
+ {
+ CActiveScheduler::Add( this );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::ConstructL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::ConstructL( )
+ {
+
+ //If we are in normalmode we need presence rules too
+ if ( !iLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::ConstructL NormalMode");
+ iXdmPresRules = CPresencePluginXdmPresRules::NewL(
+ iSettingsId, EFalse );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::NewL()
+// ---------------------------------------------------------------------------
+//
+CPresencePluginXdmUtils* CPresencePluginXdmUtils::NewL(
+ MPresencePluginConnectionObs& aObs, TInt aXmdId, TBool aLocalmode )
+ {
+ CPresencePluginXdmUtils* self =
+ new( ELeave ) CPresencePluginXdmUtils( aObs, aXmdId, aLocalmode );
+ CleanupStack::PushL( self );
+ self->ConstructL( );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::~CPresencePluginXdmUtils()
+// ---------------------------------------------------------------------------
+//
+CPresencePluginXdmUtils::~CPresencePluginXdmUtils()
+ {
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils");
+ if ( iXdmDoc )
+ {
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 1");
+ if (iXdmEngine)
+ {
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils del doc");
+ TRAP_IGNORE( iXdmEngine->DeleteDocumentModelL( iXdmDoc ));
+ }
+ }
+
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 3");
+ delete iXdmEngine;
+ iXdmEngine = NULL;
+
+
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 4");
+ delete iXdmPresRules;
+ iXdmPresRules = NULL;
+
+
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils 5");
+ delete iEntityUri;
+ iEntityUri = NULL;
+
+ iBlockedContacts.ResetAndDestroy();
+
+ DP_SDA("CPresencePluginXdmUtils::~CPresencePluginXdmUtils end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::InitializeXdmL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::InitializeXdmL( TRequestStatus& aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL");
+
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ // if resource-list not ready
+ if ( !iXdmOk )
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL !iXdmOk");
+ if ( !iLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL NormalMode");
+ GetXdmListsL( ETrue, EFalse );
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL LocalMode");
+ GetXdmListsL( ETrue, ETrue );
+ }
+ }
+ else if ( !iPresXdmOk && !iLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL !iPresXdmOk");
+ GetXdmRulesL();
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL All is OK ");
+ // All is ok
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmL SEND COMPLETE")
+ CompleteClientReq( KErrNone );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::InitializeXdmL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::InitializePresRulesL( )
+ {
+ DP_SDA("CPresencePluginXdmUtils:: MakeInitialRules");
+ iXdmState = ECreateXdmRules;
+ iRulesUpdateState = EStateInitializeRules;
+ iXdmPresRules->MakeInitialRulesDocumentL( this );
+ UpdateXdmRulesL();
+ DP_SDA("CPresencePluginXdmUtils:: MakeInitialRules done");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::GetXdmRulesL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::GetXdmRulesL()
+ {
+ DP_SDA("CPresencePluginXdmUtils:: GetXdmRulesL");
+
+ if ( !iXdmPresRules )
+ {
+ // get data from a network if not done so yet
+ if ( !iLocalMode )
+ {
+ iXdmPresRules = CPresencePluginXdmPresRules::NewL(
+ iSettingsId, EFalse );
+ }
+ else
+ {
+ /*localmode*/
+ //iXdmPresRules
+ //= CPresencePluginXdmPresRules::NewL( iSettingsId, ETrue );
+ }
+ }
+
+ if( !iLocalMode && iXdmPresRules )
+ {
+ User::LeaveIfError( iXdmPresRules->UpdateFromServerL( this ));
+ }
+ iXdmState = EGetXdmRules;
+ DP_SDA("CPresencePluginXdmUtils:: GetXdmRulesL done");
+ DP_SDA("CPresencePluginXdmUtils::GetXdmRulesL - add buddies to virtual");
+ AddIdentityToVirtualListL( KPresenceBuddyList );
+
+ DP_SDA("CPresencePluginXdmUtils::GetXdmRulesL - add blocked to virtual");
+ AddIdentityToVirtualListL( KPresenceBlockedList );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::InitializeXdmsOnlyL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::InitializeXdmsOnlyL( TRequestStatus& aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL");
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ if ( !iXdmOk )
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL 1");
+ GetXdmListsL( EFalse, EFalse );
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL all ok");
+ // All is ok
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL SEND COMPLETE")
+ CompleteClientReq( KErrNone );
+ }
+ DP_SDA("CPresencePluginXdmUtils::InitializeXdmsOnlyL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::CheckXdmDoc()
+// ---------------------------------------------------------------------------
+//
+TBool CPresencePluginXdmUtils::CheckXdmDoc()
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc");
+
+ if ( iXdmDoc )
+ {
+ CXdmDocumentNode* root = iXdmDoc->DocumentRoot();
+ DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc2");
+ if( root )
+ {
+ TInt count = root->NodeCount();
+ DP_SDA2("CPresencePluginXdmUtils::CheckXdmDoc count %d", count);
+ if ( !count )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc NotFound");
+ iXdmOk = EFalse;
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc file ok");
+ iXdmOk = ETrue;
+ }
+ }
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckXdmDoc file False");
+ iXdmOk = EFalse;
+ }
+
+ return iXdmOk;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::CheckIfError
+// ---------------------------------------------------------------------------
+//
+TInt CPresencePluginXdmUtils::CheckIfErrorL( TInt aMyStatus )
+ {
+ TInt myStatus = aMyStatus;
+ DP_SDA2("CPresencePluginXdmUtils::CheckIfError ErrorCode %d ", myStatus);
+ if ( myStatus == KErrTimedOut )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckIfError TimeOut error");
+ myStatus = KErrTimedOut;
+ User::Leave( KErrTimedOut );
+ }
+ else if ( myStatus == KErrCouldNotConnect ||
+ myStatus == KXcapErrorNetworkNotAvailabe )
+ {
+ DP_SDA("CheckIfError KErrCouldNotConnect error");
+ myStatus = aMyStatus;
+ }
+ else if ( myStatus == KXcapErrorHttpNotFound )
+ {
+ DP_SDA("CheckIfError KXcapErrorHttpNotFound");
+ myStatus = aMyStatus;
+ }
+ else if ( myStatus == KXcapErrorAuthentication )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckIfError auth error");
+ myStatus = aMyStatus;
+ }
+ else if ( myStatus == KXcapErrorTooManyOccurencies )
+ {
+ DP_SDA("CPresencePluginXdmUtils KXcapErrorTooManyOccurencies");
+ myStatus = 0;
+ }
+ else if( myStatus == KErrDisconnected )
+ {
+ myStatus = aMyStatus;
+ User::Leave( KErrCancel );
+ }
+ else if( myStatus == KXcapErrorHttpPrecondFailed )
+ {
+ DP_SDA("CheckIfError KXcapErrorHttpPrecondFailed");
+ myStatus = aMyStatus;
+ }
+ else if ( KErrNoMemory == myStatus )
+ {
+ DP_SDA("CheckIfError KErrNoMemory");
+ User::Leave( KErrNoMemory );
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckIfError ERROR");
+ myStatus = aMyStatus;
+ }
+ return myStatus;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::RunL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::RunL( )
+ {
+ DP_SDA("CPresencePluginXdmUtils::RunL");
+ TPluginXdmState origState = iXdmState;
+ iXdmState = EStateIdle;
+ TInt myStatus = iStatus.Int();
+
+ DP_SDA2("CPresencePluginXdmUtils::RunL mystatus %d ", myStatus);
+ DP_SDA2("CPresencePluginXdmUtils::RunL state %d ", origState);
+ DP_SDA2("CPresencePluginXdmUtils:: ClientStatus %d",iClientStatus->Int() );
+
+ if ( myStatus == KErrCancel )
+ {
+ DP_SDA("CPresencePluginXdmUtils::RunL CANCEL SEND COMPLETE")
+ CompleteClientReq( KErrCancel );
+ }
+
+ switch ( origState )
+ {
+ case EGetXdmLists:
+ case EGetXdmListsOnly:
+ {
+ DoGetXdmListsL( myStatus, origState );
+ }
+ break;
+
+ case ECreateXdmLists:
+ {
+ DoCreateXdmListsL( myStatus, origState, EFalse );
+ }
+ break;
+
+ case ECreateXdmListsOnly:
+ {
+ DoCreateXdmListsL( myStatus, origState, ETrue );
+ }
+ break;
+
+ case EGetXdmBlockList:
+ {
+ DP_SDA("RunL EGetXdmBlockList SEND COMPLETE");
+ CompleteClientReq( KErrNone );
+ }
+ break;
+
+ case EUpdateXdmList:
+ {
+ DoUpdateXdmListsL( myStatus, origState );
+ }
+ break;
+
+ case EUpdateBlockedContactPresenceCache:
+ DoUpdateBlockedContactPresenceCacheL( myStatus );
+ break;
+
+ default:
+ {
+ DP_SDA("CPresencePluginXdmUtils::RunL last else");
+ //check myStatus error
+ myStatus = CheckIfErrorL( myStatus );
+
+ if ( myStatus )
+ {
+ // complete reqular request
+ DP_SDA("CPresencePluginXdmUtils::RunL SEND LAST COMPLETE");
+ CompleteClientReq( myStatus );
+ }
+ DP_SDA("CPresencePluginXdmUtils::RunL default end")
+ }
+ break;
+
+ }
+ DP_SDA("CPresencePluginXdmUtils::RunL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoUpdateXdmLists()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoUpdateXdmListsL(
+ TInt aMyStatus,
+ TPluginXdmState /*aOrigState*/)
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoUpdateXdmLists EUpdateXdmList");
+ if ( !iLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoUpdateXdmLists updaterules");
+ if( aMyStatus )
+ {
+ DP_SDA("DoUpdateXdmLists updaterules error");
+ aMyStatus = CheckIfErrorL( aMyStatus );
+ CompleteClientReq( aMyStatus );
+ }
+ else
+ {
+ DP_SDA("DoUpdateXdmLists updaterules else");
+ UpdateXdmRulesL();
+ }
+ }
+ else
+ {
+ DP_SDA("EUpdateXdmList LOCALMODE SEND COMPLETE");
+ aMyStatus = CheckIfErrorL( aMyStatus );
+ CompleteClientReq( aMyStatus );
+ }
+ iRulesUpdateState = EStateNoOperation;
+ DP_SDA("CPresencePluginXdmUtils::DoUpdateXdmLists EUpdateXdmList end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoCreateXdmLists()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoCreateXdmListsL(
+ TInt aMyStatus,
+ TPluginXdmState /*aOrigState*/,
+ TBool aOnlyResourceList )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoCreateXdmListsL ECreateXdmLists");
+ //check myStatus error
+ aMyStatus = CheckIfErrorL( aMyStatus );
+ if( !aOnlyResourceList )
+ {
+ if ( aMyStatus )
+ {
+ DP_SDA("DoCreateXdmLists ECreateXdmLists SEND COMPLETE");
+ CompleteClientReq( aMyStatus );
+ }
+ else if ( !iLocalMode )
+ {
+ DP_SDA("ECreateXdmLists !myStatus GetXdmRules");
+ iXdmOk = ETrue;
+ GetXdmRulesL();
+ }
+ else if ( iLocalMode )
+ {
+ DP_SDA("DoCreateXdmLists ECreateXdmLists SEND COMPLETE 2");
+ iXdmOk = ETrue;
+ CompleteClientReq( aMyStatus );
+ }
+ }
+ else
+ {
+ //check myStatus error
+ aMyStatus = CheckIfErrorL( aMyStatus );
+ if ( aMyStatus == KErrTimedOut )
+ {
+ DP_SDA("DoCreateXdmLists EGetXdmListsOnly 1");
+ aMyStatus = 0;
+ }
+ if ( !aMyStatus )
+ {
+ DP_SDA("DoCreateXdmLists EGetXdmListsOnly 2");
+ iXdmOk = ETrue;
+ }
+
+ if( !(KXcapErrorNetworkNotAvailabe == aMyStatus ||
+ KErrCouldNotConnect == aMyStatus ) )
+ {
+ DP_SDA("DoCreateXdmLists EGetXdmListsOnly SEND COMPLETE");
+ CompleteClientReq( aMyStatus );
+ }
+ }
+ DP_SDA("CPresencePluginXdmUtils::DoCreateXdmListsL ECreateXdmLists end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoGetXdmLists()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoGetXdmListsL(
+ TInt aMyStatus,
+ TPluginXdmState aOrigState )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists EGetXdmLists");
+ //check myStatus error
+ aMyStatus = CheckIfErrorL( aMyStatus );
+
+ if ( aMyStatus )//Check is file includes nodes
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists CreateXDM");
+ // no resource-list, let's start to create it.
+ CreateXdmListsL( ETrue );
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists EGetXdmLists else");
+ if( iLocalMode )
+ {
+ //Check if document empty
+ TBool empty = CheckXdmDoc();
+ if( !empty )
+ {
+ CreateXdmListsL( ETrue );
+ }
+ else
+ {
+ iXdmOk = ETrue;
+ DP_SDA("DoGetXdmLists Localmode SEND COMPLETE");
+ CompleteClientReq( KErrNone );
+ }
+ }
+ else
+ {
+ iXdmOk = ETrue;
+ if ( !iPresXdmOk && !iLocalMode && aOrigState == EGetXdmLists )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists GetXDM");
+ GetXdmRulesL();
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists SEND COMPLETE");
+ CompleteClientReq( KErrNone );
+ }
+ }
+ }
+ DP_SDA("CPresencePluginXdmUtils::DoGetXdmLists end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoCancel()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoCancel( )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoCancel");
+ iOperation = EXdmCancel;
+
+ if ( iXdmState == EGetXdmLists || iXdmState == ECreateXdmLists ||
+ iXdmState == EUpdateXdmRules || iXdmState == EUpdateXdmList ||
+ iXdmState == EGetXdmBlockList || iXdmState == ECreateXdmRules ||
+ iXdmState == ESubsBlockList ||
+ iXdmState == EGetResourceListFromServer ||
+ iXdmState == EGetXdmListsOnly || iXdmState == ECreateXdmListsOnly )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoCancel list get or create");
+ iXdmState = ECancelDocument;
+ iXdmEngine->CancelUpdate( iXdmDoc );
+ // cancel presrules too
+ iXdmPresRules->Cancel();
+ }
+ else
+ {
+ iStatus = KRequestPending;
+ TRequestStatus* s= &iStatus;
+ DP_SDA("CPresencePluginXdmUtils::DoCancel SEND COMPLETE");
+ User::RequestComplete( s, KErrCancel );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::RunError()
+// ---------------------------------------------------------------------------
+//
+TInt CPresencePluginXdmUtils::RunError( TInt aError )
+ {
+ DP_SDA("CPresencePluginXdmUtils::RunError");
+ // complete the open request
+ CompleteClientReq( aError );
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::AddEntityToGrantedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::AddEntityToGrantedL(
+ const TDesC& aUri,
+ TRequestStatus& aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToGrantedL");
+ DP_SDA2("CPresencePluginXdmUtils::AddEntityToGrantedL, uri: %S", &aUri );
+
+ TRAPD( err, iEntityUri = aUri.AllocL() );
+ DP_SDA2(" AddEntityToGrantedL, uri alloc err: %d", err );
+
+ //Add entity to virtualGroup
+ iConnObs.SubscribedContacts()->AddEntityL( iEntityUri->Des() );
+
+ if ( !err )
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToGrantedL !err");
+ iXdmState = EUpdateXdmList;
+ iClientStatus = &aStatus;
+ iOperation = EXdmAddUserToGroup;
+ iRulesUpdateState = EStateAddToWhiteList;
+
+ //add user to resouce-list list
+ DoAddUserToListL( KPresenceBuddyList, aUri );
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToGrantedL 1");
+ UpdateXdmsL();
+
+ *iClientStatus = KRequestPending;
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToGrantedL end");
+ }
+ else
+ {
+ DP_SDA("AddEntityToGrantedL else error SEND COMPLETE");
+ //If error we can complete request
+ CompleteClientReq( KErrNone );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::AddEntityToBlockedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::AddEntityToBlockedL(
+ const TDesC& aUri,
+ TRequestStatus& aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToBlockedL");
+ iClientStatus = &aStatus;
+
+ if( iLocalMode )
+ {
+ //Block is not used in localmode
+ DP_SDA("AddEntityToBlockedL localmode rules not support");
+ CompleteClientReq( KErrNotSupported );
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToBlockedL !localmode");
+ TRAPD(err, iEntityUri = aUri.AllocL() );
+ //Remove entity form subscribed virtual group
+ iConnObs.SubscribedContacts()->RemoveEntityL( iEntityUri->Des() );
+
+ if ( !err )
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToBlockedL no error");
+ iXdmState = EUpdateXdmList;
+ iOperation = EXdmAddUserToGroup;
+ iRulesUpdateState = EStateAddToBlockList;
+
+ DoAddUserToListL( KPresenceBlockedList, aUri );
+ UpdateXdmsL();
+
+ *iClientStatus = KRequestPending;
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToBlockedL ready");
+ }
+ else
+ {
+ //If error we can complete request
+ DP_SDA("AddEntityToBlockedL SEND COMPLETE");
+ CompleteClientReq( KErrNone );
+ }
+ }
+ DP_SDA("CPresencePluginXdmUtils::AddEntityToBlockedL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoAddUserToListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoAddUserToListL(
+ const TDesC& aList,
+ const TDesC& aUri )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL");
+ DP_SDA2("CPresencePluginXdmUtils::DoAddUserToListL aList: %S", &aList);
+ DP_SDA2("CPresencePluginXdmUtils::DoAddUserToListL aUri: %S", &aUri);
+
+ using namespace NPresencePlugin::NPresence;
+
+ CXdmDocumentNode* root = iXdmDoc->DocumentRoot();
+ CXdmDocumentNode* foundNode = SearchListUnderParentL( root, aList );
+
+ if ( foundNode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL found");
+ if ( !CheckIfEnityExistL( aList, aUri ) )
+ {
+ DP_SDA("DoAddUserToListL entity not exist");
+ if ( foundNode->IsEmptyNode() )
+ {
+ DP_SDA("DoAddUserToListL IsEmptyNode");
+ foundNode->SetEmptyNode( EFalse );
+ }
+
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL newNode");
+ CXdmDocumentNode* newNode =
+ foundNode->CreateChileNodeL( KPresenceEntry );
+ DP_SDA("DoAddUserToListL entry attribute");
+ CXdmNodeAttribute* attributeEntryUri =
+ newNode->CreateAttributeL( KPresenceUri );
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL set entry");
+ attributeEntryUri->SetAttributeValueL( aUri );
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL Append");
+ iXdmDoc->AppendL( );
+ }
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL leave");
+ User::Leave( KErrNotFound );
+ }
+ DP_SDA("CPresencePluginXdmUtils::DoAddUserToListL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::CheckIfEnityExistL
+// ---------------------------------------------------------------------------
+//
+TBool CPresencePluginXdmUtils::CheckIfEnityExistL(
+ const TDesC& aList,
+ const TDesC& aUri )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckIfEnityExist");
+
+ using namespace NPresencePlugin::NPresence;
+
+ CXdmNodeAttribute* attr = NULL;
+ RPointerArray<CXdmDocumentNode> nodes;
+ CleanupClosePushL( nodes );
+ TBool state( EFalse );
+
+ CXdmDocumentNode* root = iXdmDoc->DocumentRoot();
+ CXdmDocumentNode* foundNode = SearchListUnderParentL( root, aList );
+
+ if ( foundNode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckIfEnityExist check nodes");
+ TInt findErr = foundNode->Find( KPresenceEntry, nodes );
+ DP_SDA2("CheckIfEnityExist - findErr: %d", findErr );
+
+ if ( findErr )
+ {
+ DP_SDA("CheckIfEnityExist Enity not exist ");
+ state = EFalse;
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::CheckIfEnityExist Else");
+ TInt nodeCount = nodes.Count();
+ for ( TInt i = 0; i < nodeCount; i++ )
+ {
+ CXdmDocumentNode* currNode = nodes[i];
+ attr = ( currNode )->Attribute( KPresenceUri );
+
+ TBool uriMatch( EFalse );
+ uriMatch = CompareUriWithoutPrefixL(
+ aUri, attr->AttributeValue() );
+
+ if ( attr && uriMatch )
+ {
+ DP_SDA("CheckIfEnityExist entity exists");
+ //Enity is exist
+ state = ETrue;
+ break;
+ }
+ }
+ }
+ }
+ DP_SDA("CPresencePluginXdmUtils::CheckIfEnityExist Destroy nodes");
+ CleanupStack::PopAndDestroy( &nodes ); // >>> nodes
+ return state;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::SearchListUnderParentL
+// ---------------------------------------------------------------------------
+//
+CXdmDocumentNode* CPresencePluginXdmUtils::SearchListUnderParentL(
+ CXdmDocumentNode* aParent,
+ const TDesC& aName )
+ {
+ DP_SDA("CPresencePluginXdmUtils::SearchListUnderParentL");
+
+ using namespace NPresencePlugin::NPresence;
+
+ if ( !aParent )
+ {
+ DP_SDA("CPresencePluginXdmUtils::SearchListUnderParentL return NULL");
+ return NULL;
+ }
+
+ RPointerArray<CXdmDocumentNode> resultArray;
+ RPointerArray<SXdmAttribute16> attributeArray;
+
+ CleanupClosePushL( resultArray ); // <<< resultArray
+ CleanupClosePushL( attributeArray ); // <<< attributeArray
+
+ SXdmAttribute16 attr;
+ attr.iName.Set( KPresenceName );
+ attr.iValue.Set( aName );
+ attributeArray.AppendL( &attr );
+
+ CXdmDocumentNode* currNode = NULL;
+
+ aParent->Find( KPresenceList, 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( &attributeArray); // >>> attributeArray
+ CleanupStack::PopAndDestroy( &resultArray ); // >>> resultArray
+ DP_SDA("CPresencePluginXdmUtils::SearchListUnderParentL return");
+ return currNode;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::RemoveEntityFromGrantedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::RemoveEntityFromGrantedL(
+ const TDesC& aUri,
+ TRequestStatus& aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::RemoveEntityFromGrantedL");
+
+ iEntityUri = aUri.AllocL();
+ iConnObs.SubscribedContacts()->RemoveEntityL( iEntityUri->Des() );
+
+ iClientStatus = &aStatus;
+ *iClientStatus = KRequestPending;
+
+ iRulesUpdateState = EStateRemoveFromWhiteList;
+ iOperation = EXdmRemoveUserFromGroup;
+
+ TRAPD( err, DoRemoveUserFromListL( KPresenceBuddyList, aUri ) );
+
+ if ( !err )
+ {
+ // send to the server and start wait a response
+ UpdateXdmsL();
+ iXdmState = EUpdateXdmList;
+ }
+ else
+ {
+ //complete request with error
+ DP_SDA2( "RemoveEntityFromGrantedL -DoRemoveUserFromListL error = %d", err );
+ CompleteClientReq( err );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::RemoveEntityFromBlockedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::RemoveEntityFromBlockedL(
+ const TDesC& aUri,
+ TRequestStatus& aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::RemoveEntityFromBlockedL");
+ TRAPD(err, iEntityUri = aUri.AllocL() );
+
+ if ( !err )
+ {
+ iClientStatus = &aStatus;
+ iRulesUpdateState = EStateRemoveFromBlackList;
+ iOperation = EXdmRemoveUserFromGroup;
+
+ DoRemoveUserFromListL( KPresenceBlockedList, aUri );
+ // send to the server and start wait a response
+ UpdateXdmsL();
+ iXdmState = EUpdateXdmList;
+ *iClientStatus = KRequestPending;
+ }
+ else
+ {
+ //If error we can complete request
+ DP_SDA("RemoveEntityFromBlockedL SEND COMPLETE");
+ CompleteClientReq( KErrNone );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoRemoveUserFromListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoRemoveUserFromListL(
+ const TDesC& aList,
+ const TDesC& aUri )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoRemoveUserFromListL");
+ CXdmNodeAttribute* attr = NULL;
+
+ using namespace NPresencePlugin::NPresence;
+
+ RPointerArray<CXdmDocumentNode> lists;
+ CleanupClosePushL( lists );
+
+ RPointerArray<CXdmDocumentNode> nodes;
+ CleanupClosePushL( nodes );
+
+ CXdmDocumentNode* root = iXdmDoc->DocumentRoot();
+ CXdmDocumentNode* foundNode = SearchListUnderParentL( root, aList );
+ if ( foundNode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoRemoveUserFromListL Node Found");
+ User::LeaveIfError( foundNode->Find( KPresenceEntry, nodes ));
+ TInt nodeCount = nodes.Count();
+ for ( TInt i = 0; i < nodeCount; i++ )
+ {
+ CXdmDocumentNode* currNode = nodes[i];
+ attr = ( currNode )->Attribute( KPresenceUri );
+
+ TBool uriMatch( EFalse );
+ uriMatch = CompareUriWithoutPrefixL(
+ aUri, attr->AttributeValue() );
+
+ if ( attr && uriMatch )
+ {
+ DP_SDA(" DoRemoveUserFromListL Node Found, do delete");
+
+ // This is the user we are looking for deletion.
+ //First remove currNode form model
+ iXdmDoc->RemoveFromModelL( currNode );
+ // Update model to server
+ iXdmDoc->AppendL();
+ break;
+ }
+ }
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoRemoveUserFromListL Leave");
+ User::Leave( KErrNotFound );
+ }
+
+ CleanupStack::PopAndDestroy( &nodes ); // >>> nodes
+ CleanupStack::PopAndDestroy( &lists ); // >>> lists
+ DP_SDA("CPresencePluginXdmUtils::DoRemoveUserFromListL END");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::SubscribeBuddyListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::SubscribeBuddyListL(
+ RPointerArray<MXIMPIdentity>& aMembers )
+ {
+ DP_SDA("CPresencePluginXdmUtils::SubscribeBuddyListL");
+
+ iOperation = EXdmGetBuddyList;
+ DoGetListMembersL( KPresenceBuddyList, aMembers );
+
+ DP_SDA("CPresencePluginXdmUtils::SubscribeBuddyListL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::SubscribeBlockListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::SubscribeBlockListL(
+ RPointerArray<MXIMPIdentity>& aMembers )
+ {
+ DP_SDA("CPresencePluginXdmUtils::SubscribeBlockListL");
+
+ if ( !iLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::SubscribeBlockListL !iLocalMode");
+ iOperation = EXdmGetBlockedList;
+ DoGetListMembersL( KPresenceBlockedList, aMembers );
+ }
+ DP_SDA("CPresencePluginXdmUtils::SubscribeBlockListL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoGetListMembersL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoGetListMembersL(
+ const TDesC& aList,
+ RPointerArray<MXIMPIdentity>& aMembers )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetListMembersL");
+ using namespace NPresencePlugin::NPresence;
+
+ aMembers.Reset();
+
+ RPointerArray<CXdmDocumentNode> nodes;
+ CleanupClosePushL( nodes );
+
+ CXdmDocumentNode* listNode = NULL;
+ CXdmNodeAttribute* attr = NULL;
+
+ TBool found(EFalse);
+
+ if ( iXdmDoc )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetListMembersL iXdmDoc");
+ User::LeaveIfError( iXdmDoc->Find( KPresenceList, nodes ) );
+ DP_SDA("CPresencePluginXdmUtils::DoGetListMembersL find ready");
+ TInt count = nodes.Count();
+ DP_SDA2("DoGetListMembersL find Count %d", count);
+ for ( TInt i=0; i < count; i++ )
+ {
+ listNode = nodes[i];
+ attr = listNode->Attribute( KPresenceName );
+ if ( attr && !attr->AttributeValue().CompareF( aList ))
+ {
+ // That's the right list
+ DP_SDA("DoGetListMembersL Target found");
+ found = ETrue;
+ break;
+ }
+ }
+ }
+
+ if ( found )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetListMembersL found");
+ MXIMPObjectFactory& myFactory = iConnObs.ObjectFactory();
+ nodes.Reset();
+ TInt err = listNode->Find( KPresenceEntry, nodes );
+ DP_SDA2("CPresencePluginXdmUtils::DoGetListMembersL err %d", err);
+ if( !err )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetListMembersL Entry found");
+ TInt nodeCount = nodes.Count();
+ for ( TInt i = 0; i < nodeCount; i++ )
+ {
+ attr = (nodes[i])->Attribute( KPresenceUri );
+ if ( attr )
+ {
+ DP_SDA("DoGetListMembersL attr check");
+ MXIMPIdentity* entity =
+ myFactory.NewIdentityLC(); // << entity
+ entity->SetIdentityL( attr->AttributeValue() );
+ aMembers.AppendL( entity );
+ CleanupStack::Pop(); // >> entity
+ }
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( &nodes );
+ DP_SDA("CPresencePluginXdmUtils::DoGetListMembersL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::GetXdmListsL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::GetXdmListsL(
+ TBool aCreateRules,
+ TBool aLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL");
+ //Normal Mode start
+ if ( !iXdmEngine && !aLocalMode )
+ {
+ DP_SDA2("!iXdmEngine settingID = %d", iSettingsId);
+
+#ifdef _DEBUG
+ //Get xdmSettings
+ HBufC* accesPoint = TXdmSettingsApi::PropertyL(
+ iSettingsId, EXdmPropToNapId );
+ CleanupStack::PushL( accesPoint );
+ DP_SDA2("CPresencePluginXdmUtils::GetXdmListsL accesPoint %S",
+ accesPoint);
+#endif
+
+ // get data from a network if not done so yet
+ CXdmProtocolInfo* info = CXdmProtocolInfo::NewL( iSettingsId );
+ CleanupStack::PushL( info );
+
+ // Notice: we do not use cache for XDM
+ info->SetCacheUsage( EFalse ); //False in normal case
+
+ iXdmEngine = CXdmEngine::NewL( *info );
+ CleanupStack::PopAndDestroy( info );
+#ifdef _DEBUG
+ CleanupStack::PopAndDestroy( accesPoint );
+#endif
+ }
+ //LocalMode Start, !!! THERE IS LIMIT !!!
+ //Only one settings can use localmode
+ else if ( !iXdmEngine && aLocalMode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL aLocalMode");
+ CXdmProtocolInfo* info =
+ CXdmProtocolInfo::NewL( 0, KLocalProtocol, KNullDesC );
+ CleanupStack::PushL( info );
+
+ iXdmEngine = CXdmEngine::NewL( *info );
+ CleanupStack::PopAndDestroy( info );
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL aLocalMode end");
+ }
+ if ( !iXdmOk )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL !XdmOK ");
+ using namespace NPresencePlugin::NPresence;
+ // Get data from network
+ DP_SDA("GetXdmListsL Create Document Model ");
+
+ iXdmDoc = iXdmEngine->CreateDocumentModelL(
+ KPresenceResourceList, EXdmResourceLists );
+
+
+ DP_SDA("Create Document Model FetchData");
+ iXdmDoc->FetchDataL();
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL !XdmOK SETACTIVE ");
+ UpdateXdmsL();
+ iXdmState = aCreateRules ? EGetXdmLists : EGetXdmListsOnly;
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL !XdmOK END");
+ }
+ else
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL else");
+ // Document already exists, no need to search from a server
+ iStatus = KRequestPending;
+ TRequestStatus* s= &iStatus;
+ DP_SDA("CPresencePluginXdmUtils::GetXdmListsL SEND COMPLETE");
+ User::RequestComplete( s, KErrNone );
+ iXdmState = aCreateRules ? EGetXdmLists : EGetXdmListsOnly;
+ SetActive();
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::CreateXdmListsL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::CreateXdmListsL( TBool aCreateRules )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CreateXdmListsL");
+
+ CXdmDocumentNode* root = iXdmDoc->CreateRootL();
+ CleanupStack::PushL( root );
+
+ using namespace NPresencePlugin::NPresence;
+ root->SetNameL( KPresenceResourceLists );
+
+ // add all the list nodes
+ // buddylist
+ using namespace NPresencePlugin::NPresence;
+ if ( root->IsEmptyNode() )
+ {
+ root->SetEmptyNode( EFalse );
+ }
+ //buddy list
+ CXdmDocumentNode* child1 = root->CreateChileNodeL( KPresenceList );
+ CleanupStack::PushL( child1 );
+ CXdmNodeAttribute* name = child1->CreateAttributeL( KPresenceName );
+ CleanupStack::PushL( name );
+ name->SetAttributeValueL( KPresenceBuddyList );
+
+ // blockedcontacts
+ CXdmDocumentNode* child2 = root->CreateChileNodeL( KPresenceList );
+ CleanupStack::PushL( child2 );
+ CXdmNodeAttribute* name2 = child2->CreateAttributeL( KPresenceName );
+ CleanupStack::PushL( name2 );
+ name2->SetAttributeValueL( KPresenceBlockedList );
+
+ // send to the server and start wait a response
+ iXdmDoc->AppendL();
+ UpdateXdmsL();
+ iXdmState = aCreateRules ? ECreateXdmLists : ECreateXdmListsOnly;
+
+ CleanupStack::Pop( name2 );
+ CleanupStack::Pop( child2 );
+ CleanupStack::Pop( name );
+ CleanupStack::Pop( child1 );
+ CleanupStack::Pop( root );
+ DP_SDA("CPresencePluginXdmUtils::CreateXdmListsL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::GetEntitiesInListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::GetEntitiesInListL(
+ const TDesC& aList,
+ MXIMPObjectCollection& aColl )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL ");
+ using namespace NPresencePlugin::NPresence;
+
+ CXdmDocumentNode* buddylist = DoGetBuddyListL( aList );
+
+ // make a collection of MXIMPPresentityGroupMemberInfo
+ RPointerArray<CXdmDocumentNode> entries;
+ CleanupClosePushL(entries); // <<< entries
+
+ RPointerArray<CXdmDocumentNode> nodes;
+ CleanupClosePushL(nodes); // <<< nodes
+
+ buddylist->Find( KPresenceEntry, entries );
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL entries");
+ TInt count = entries.Count();
+ DP_SDA2("GetEntitiesInListL entries count %d",count);
+ for ( TInt i=0; i < count; i++ )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL 1");
+ // create here MXIMPPresentityGroupMemberInfo
+ MPresentityGroupMemberInfo* info =
+ iConnObs.PresenceObjectFactoryOwn().
+ NewPresentityGroupMemberInfoLC();
+
+ // ID
+ CXdmDocumentNode* entry = entries[i];
+ CXdmNodeAttribute* attr = entry->Attribute( KPresenceUri );
+ if ( attr )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL 2");
+ MXIMPIdentity* id =
+ iConnObs.ObjectFactory().NewIdentityLC();//<< id
+ id->SetIdentityL( attr->AttributeValue() );
+ info->SetGroupMemberIdL( id );
+ CleanupStack::Pop(); // >> id
+ }
+
+ // Display name
+ TInt err = entry->Find( KPresenceDisplayName, nodes );
+ // Notice: assume there is only one display-name
+ if ( !err )
+ {
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL display name");
+ CXdmDocumentNode* disName = nodes[0];
+ HBufC16* uri16 = NULL;
+ uri16 =
+ CnvUtfConverter::ConvertToUnicodeFromUtf8L(
+ disName->LeafNodeContent() );
+
+ CleanupStack::PushL( uri16 ); // << uri16
+ info->SetGroupMemberDisplayNameL( uri16->Des() );
+ CleanupStack::PopAndDestroy( uri16 ); // >> uri16
+ }
+
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL 3");
+ aColl.AddObjectL( info );
+
+ //if contact is from buddylist add it to virtual subscribed list too
+ if( !aList.CompareF( KPresenceBuddyList ) )
+ {
+ DP_SDA("GetEntitiesInListL add virtualgroup");
+ //Add identity to virtual list
+ iConnObs.SubscribedContacts()->AddEntityL(
+ info->GroupMemberId().Identity() );
+ }
+
+ CleanupStack::Pop(); // >> info
+ }
+
+ CleanupStack::PopAndDestroy( &nodes ); // >>> nodes
+ CleanupStack::PopAndDestroy( &entries ); // >>> entries*/
+ DP_SDA("CPresencePluginXdmUtils::GetEntitiesInListL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::AddIdentityToVirtualListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::AddIdentityToVirtualListL( const TDesC& aList )
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddIdentityToVirtualListL ");
+ using namespace NPresencePlugin::NPresence;
+
+ if ( aList.Compare( KPresenceBlockedList ) == NULL )
+ {
+ iBlockedContacts.ResetAndDestroy();
+ }
+
+ CXdmDocumentNode* buddylist = DoGetBuddyListL( aList );
+
+ // make a collection of MXIMPPresentityGroupMemberInfo
+ RPointerArray<CXdmDocumentNode> entries;
+ CleanupClosePushL(entries); // <<< entries
+
+ buddylist->Find( KPresenceEntry, entries );
+ DP_SDA("CPresencePluginXdmUtils::AddIdentityToVirtualListL entries");
+ TInt count = entries.Count();
+ DP_SDA2("AddIdentityToVirtualListL entries count %d",count);
+ for ( TInt i=0; i < count; i++ )
+ {
+ DP_SDA("CPresencePluginXdmUtils::AddIdentityToVirtualListL 1");
+ // ID
+ CXdmDocumentNode* entry = entries[i];
+ CXdmNodeAttribute* attr = entry->Attribute( KPresenceUri );
+ if ( attr )
+ {
+ if( !aList.CompareF( KPresenceBuddyList ) )
+ {
+ DP_SDA("AddIdentityToVirtualListL add to buddies");
+ //Add identity to virtual list
+ iConnObs.SubscribedContacts()->AddEntityL(
+ attr->AttributeValue() );
+ }
+ else if ( !aList.CompareF( KPresenceBlockedList ) )
+ {
+ DP_SDA("AddIdentityToVirtualListL add to blocked");
+ HBufC* withoutPrefix =
+ iConnObs.InternalPresenceAuthorization().
+ PluginData().RemovePrefixLC( attr->AttributeValue() );
+ CleanupStack::Pop( withoutPrefix );
+ iBlockedContacts.AppendL( withoutPrefix );
+ }
+ }
+ }
+ CleanupStack::PopAndDestroy( &entries ); // >>> entries
+ DP_SDA("CPresencePluginXdmUtils::AddIdentityToVirtualListL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoGetBuddyListL()
+// ---------------------------------------------------------------------------
+//
+CXdmDocumentNode* CPresencePluginXdmUtils::DoGetBuddyListL(
+ const TDesC& aParent )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetBuddyListL");
+ CXdmDocumentNode* root = iXdmDoc->DocumentRoot();
+
+ CXdmDocumentNode* ret = SearchListUnderParentL( root, aParent );
+ if ( !ret )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetBuddyListL !found");
+ User::Leave( KErrNotFound );
+ }
+ return ret;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoGetUserListL()
+// ---------------------------------------------------------------------------
+//
+CXdmDocumentNode* CPresencePluginXdmUtils::DoGetUserListL(
+ const TDesC& aList, CXdmDocumentNode* aBuddyList )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetUserListL");
+ CXdmDocumentNode* listNode = NULL;
+ CXdmNodeAttribute* attr = NULL;
+ TBool found( EFalse );
+
+ using namespace NPresencePlugin::NPresence;
+
+ RPointerArray<CXdmDocumentNode> lists;
+ CleanupClosePushL( lists );
+
+ User::LeaveIfError( aBuddyList->Find( KPresenceEntry, lists ));
+ TInt count = lists.Count();
+ DP_SDA2("CPresencePluginXdmUtils::DoGetUserListL count %d",count);
+ for ( TInt i=0; i < count; i++ )
+ {
+ listNode = lists[i];
+ attr = listNode->Attribute( KPresenceUri );
+ if ( attr && !attr->AttributeValue().CompareF( aList ))
+ {
+ // List is found
+ found = ETrue;
+ break;
+ }
+ }
+ if ( !found )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoGetUserListL !found");
+ User::Leave( KErrNotFound );
+ }
+
+ CleanupStack::PopAndDestroy( &lists );
+ DP_SDA("CPresencePluginXdmUtils::DoGetUserListL end");
+ return listNode;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::UpdateXdmsL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::UpdateXdmsL()
+ {
+ DP_SDA("CPresencePluginXdmUtils::UpdateXdmsL");
+ iXdmEngine->UpdateL( iXdmDoc, iStatus );
+ if ( !IsActive() )
+ {
+ DP_SDA("CPresencePluginXdmUtils::UpdateXdmsL SetActive");
+ SetActive();
+ }
+ DP_SDA("CPresencePluginXdmUtils::UpdateXdmsL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::UpdateXdmRulesL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::UpdateXdmRulesL()
+ {
+ DP_SDA("CPresencePluginXdmUtils::UpdateXdmRulesL");
+ iXdmState = EUpdateXdmRules;
+
+ if( iRulesUpdateState == EStateInitializeRules )
+ {
+ User::LeaveIfError( iXdmPresRules->UpdateXdmRulesL( this ));
+ }
+ //Add entity to presrules too
+ if ( iRulesUpdateState == EStateAddToWhiteList )
+ {
+ DP_SDA("EStateAddToWhiteList");
+ iXdmPresRules->AddEntityToWhiteListL(
+ iEntityUri->Des(), this );
+ }
+ if ( iRulesUpdateState == EStateAddToBlockList )
+ {
+ DP_SDA("EStateAddToBlockList");
+ iXdmPresRules->AddEntityToBlockedRulesL(
+ iEntityUri->Des(), this );
+ }
+ if ( iRulesUpdateState == EStateRemoveFromWhiteList)
+ {
+ DP_SDA("EStateRemoveFromWhiteList");
+ iXdmPresRules->RemoveEntityFromWhiteListL(
+ iEntityUri->Des(), this );
+ }
+ if ( iRulesUpdateState == EStateRemoveFromBlackList)
+ {
+ DP_SDA("EStateRemoveFromBlackList");
+ iXdmPresRules->RemoveEntityBlockedRulesL(
+ iEntityUri->Des(), this );
+ }
+ DP_SDA("CPresencePluginXdmUtils::UpdateXdmRulesL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoHandlePresUpdateDocumentL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoHandlePresUpdateDocumentL( TInt aErrorCode )
+ {
+ DP_SDA("CPresencePluginXdmUtils::DoHandlePresUpdateDocumentL");
+
+ // check if error
+ CheckIfErrorL( aErrorCode );
+
+ if ( iXdmState == EGetXdmRules )
+ {
+ DP_SDA("DoHandlePresUpdateDocumentL EGetXdmRules");
+ iXdmState = EStateIdle;
+ if ( aErrorCode && aErrorCode == KXcapErrorHttpNotFound )
+ {
+ DP_SDA("DoHandlePresUpdateDocumentL EGetXdmRules ini rules ERROR");
+ InitializePresRulesL();
+ }
+ else
+ {
+ DP_SDA("DoHandlePresUpdateDocumentL EGetXdmRules SEND COMPLETE ");
+ // Complete with ok or error the last initial opreration
+
+ // update presence cache if needed before complete client req.
+ iPresXdmOk = ETrue;
+
+ if ( iBlockedContacts.Count() > 0 )
+ {
+ iConnObs.InternalPresenceAuthorization().
+ IsBlockedContactFriendRequestL(
+ *iBlockedContacts[ iBlockedContacts.Count() - 1 ],
+ *this, iStatus );
+
+ iXdmState = EUpdateBlockedContactPresenceCache;
+ SetActive();
+ }
+ else
+ {
+ CompleteClientReq( aErrorCode );
+ }
+ }
+ }
+ else if ( iXdmState == EUpdateXdmRules )
+ {
+ DP_SDA("DoHandlePresUpdateDocumentL EUpdateXdmRules SEND COMPLETE ");
+ // Complete with ok or error the last initial opreration
+ CompleteClientReq( aErrorCode );
+ }
+ else if ( iXdmState == ECreateXdmRules )
+ {
+ DP_SDA("DoHandlePresUpdateDocumentL ECreateXdmRules SEND COMPLETE ");
+ iPresXdmOk = ETrue;
+ CompleteClientReq( aErrorCode );
+ }
+
+ else if ( iXdmState == EUpdateXdmList)
+ {
+ DP_SDA("DoHandlePresUpdateDocumentL EUpdateXdmList SEND COMPLETE");
+ CompleteClientReq( aErrorCode );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::CompleteClientReq()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::CompleteClientReq( TInt aStatus )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CompleteClientReq");
+ DP_SDA2("CPresencePluginXdmUtils::CompleteClientReq status %d ", aStatus);
+ iXdmState = EStateIdle;
+ iOperation = ENoOperation;
+ TRequestStatus* s = iClientStatus;
+ User::RequestComplete( s, aStatus );
+ DP_SDA("CPresencePluginXdmUtils::CompleteClientReq end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::HandlePresUpdateDocumentL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::HandlePresUpdateDocumentL(
+ TInt aErrorCode )
+ {
+#ifdef _DEBUG
+ DP_SDA2("HandlePresUpdateDocumentL errorCode %d ", aErrorCode );
+ DP_SDA2("HandlePresUpdateDocumentL mystatus %d ", iStatus.Int());
+ DP_SDA2("HandlePresUpdateDocumentL state %d ", iXdmState);
+ DP_SDA2("HandlePresUpdateDocumentL ClientStatus %d",iClientStatus->Int() );
+#endif
+
+ DP_SDA("CPresencePluginXdmUtils::HandlePresUpdateDocumentL");
+ if ( aErrorCode == KErrTimedOut )
+ {
+ DP_SDA("CPresencePluginXdmUtils::HandlePresUpdateDocumentL TimeOut");
+ aErrorCode = 0;
+ }
+
+ TRAPD( err, DoHandlePresUpdateDocumentL( aErrorCode ));
+ if ( err )
+ {
+ DP_SDA("CPresencePluginXdmUtils::HandlePresUpdateDocumentL complete");
+ // Complete with ok or error the last initial opreration
+ CompleteClientReq( err );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::SearchListUnderParentL
+// ---------------------------------------------------------------------------
+//
+TBool CPresencePluginXdmUtils::CompareUriWithoutPrefixL(
+ const TDesC& aUri, const TDesC& aAttribute )
+ {
+ DP_SDA("CPresencePluginXdmUtils::CompareUriWithoutPrefixL");
+
+ TBool match( EFalse );
+
+ RBuf uriWithoutPrefix;
+ CleanupClosePushL( uriWithoutPrefix );
+ uriWithoutPrefix.CreateL( aUri );
+ TInt prefixLocation = uriWithoutPrefix.Locate( ':' );
+
+ if ( KErrNotFound != prefixLocation )
+ {
+ uriWithoutPrefix.Delete( 0, ( prefixLocation + 1 ) );
+ }
+
+ RBuf attributeWithoutprefix;
+ CleanupClosePushL( attributeWithoutprefix );
+ attributeWithoutprefix.CreateL( aAttribute );
+ prefixLocation = attributeWithoutprefix.Locate( ':' );
+
+ if ( KErrNotFound != prefixLocation )
+ {
+ attributeWithoutprefix.Delete( 0, ( prefixLocation + 1 ) );
+ }
+
+ DP_SDA2(" --> uri without prefix=%S", &uriWithoutPrefix );
+ DP_SDA2(" --> attribute without prefix=%S", &attributeWithoutprefix );
+
+ if ( uriWithoutPrefix.Compare( attributeWithoutprefix ) == 0 )
+ {
+ match = ETrue;
+ }
+
+ CleanupStack::PopAndDestroy( &attributeWithoutprefix );
+ CleanupStack::PopAndDestroy( &uriWithoutPrefix );
+
+ return match;
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPresencePluginXdmUtils::DoUpdateBlockedContactPresenceCacheL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::DoUpdateBlockedContactPresenceCacheL(
+ TInt aMyStatus )
+ {
+ DP_SDA( "CPresencePluginXdmUtils::DoUpdateBlockedContactPresenceCache" );
+
+ const TInt KTextBufferSize = 10;
+ TInt contactsCount = iBlockedContacts.Count();
+
+ if ( contactsCount > 0 )
+ {
+ if ( iPresenceContactsAsyncReqResult )
+ {
+ DP_SDA(" RunL -write blocked status to cache" );
+ TBuf<KTextBufferSize> buf;
+ buf.Copy( KBlockedExtensionValue );
+ iConnObs.InternalPresenceAuthorization().PluginData().
+ WriteStatusToCacheL( *iBlockedContacts[ contactsCount - 1 ],
+ MPresenceBuddyInfo2::EUnknownAvailability,
+ buf,
+ KNullDesC() );
+ }
+ delete iBlockedContacts[ contactsCount - 1 ];
+ iBlockedContacts.Remove( contactsCount - 1 );
+
+ if ( iBlockedContacts.Count() > 0 )
+ {
+ iConnObs.InternalPresenceAuthorization().
+ IsBlockedContactFriendRequestL(
+ *iBlockedContacts[ iBlockedContacts.Count() - 1 ],
+ *this, iStatus );
+
+ iXdmState = EUpdateBlockedContactPresenceCache;
+ SetActive();
+ }
+ else
+ {
+ CompleteClientReq( aMyStatus );
+ }
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// From MPresencePluginContactsObs
+// CPresencePluginXdmUtils::RequestComplete
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginXdmUtils::RequestComplete( TAny* aResult,
+ TPresenceContactsOperation /*aOperation*/, TInt aError )
+ {
+ iPresenceContactsAsyncReqResult = EFalse;
+ if ( NULL != aResult && KErrNone == aError )
+ {
+ iPresenceContactsAsyncReqResult =
+ *static_cast<TBool*>( aResult );
+ }
+ }
+
+// End of file