--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/simpledatamodeladapter/src/presencepluginpublisher.cpp Tue Feb 02 01:05:17 2010 +0200
@@ -0,0 +1,1433 @@
+/*
+* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: IETF SIMPLE Protocol implementation for XIMP Framework
+*
+*/
+
+
+#include <e32std.h>
+#include <utf.h>
+#include <ximpdatasubscriptionstate.h>
+#include <protocolpresencepublishingdatahost.h>
+#include <protocolpresencedatahost.h>
+#include <ximpobjectfactory.h>
+#include <presenceobjectfactory.h>
+#include <presenceinfo.h>
+#include <personpresenceinfo.h>
+#include <ximpprotocolconnectionhost.h>
+#include <ximpstatus.h>
+#include <ximperrors.hrh>
+#include <ximpidentity.h>
+#include <ximpobjectcollection.h>
+#include <presencewatcherinfo.h>
+#include <simpleutils.h> // For KSimplePDM
+#include <simplefactory.h>
+#include <msimpledocument.h>
+#include <msimplepublisher.h>
+#include <msimplewatcher.h>
+#include <msimplewinfo.h>
+#include <msimpleelement.h>
+#include <msimpleconnection.h>
+#include <simpleerrors.h>
+#include <avabilitytext.h>
+
+#include "presenceplugincommon.h"
+#include "presencepluginpublisher.h"
+#include "presencepluginwinfo.h"
+#include "presenceplugindata.h"
+#include "presencepluginxdmutils.h"
+#include "presencepluginwatcherinfo.h"
+#include "presenceplugincommon.h"
+
+// ======== MEMBER FUNCTIONS ========
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::CPresencePluginPublisher()
+// ---------------------------------------------------------------------------
+//
+CPresencePluginPublisher::CPresencePluginPublisher(
+ MPresencePluginConnectionObs& aObs,
+ MSimpleConnection& aConn )
+ : CActive( CActive::EPriorityStandard ),
+ iConnObs(aObs), iConnection(aConn),
+ iPublisher( NULL ), iWatcher( NULL ),
+ iSubscribed(EFalse), iSubscribedOwn(EFalse),
+ iPublished(EFalse), iRePublish(EFalse),
+ iWatcherList( CPresencePluginWatcherInfo::LinkOffset() )
+ {
+ DP_SDA("CPresencePluginPublisher::CPresencePluginPublisher ");
+ CActiveScheduler::Add(this);
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::ConstructL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::ConstructL( CPresencePluginData* aPresenceData )
+ {
+ DP_SDA("CPresencePluginPublisher::ConstructL ");
+ iWatcher = TSimpleFactory::NewWatcherL( iConnection, *this );
+ iPublisher = TSimpleFactory::NewPublisherL( iConnection, *this );
+ iPresenceData = aPresenceData;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::NewL()
+// ---------------------------------------------------------------------------
+//
+CPresencePluginPublisher* CPresencePluginPublisher::NewL(
+ MPresencePluginConnectionObs& aObs,
+ MSimpleConnection& aConn,
+ CPresencePluginData* aPresenceData )
+ {
+ CPresencePluginPublisher* self =
+ new( ELeave ) CPresencePluginPublisher( aObs, aConn );
+ CleanupStack::PushL( self );
+ self->ConstructL( aPresenceData );
+ CleanupStack::Pop( self );
+ return self;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::~CPresencePluginPublisher()
+// ---------------------------------------------------------------------------
+//
+CPresencePluginPublisher::~CPresencePluginPublisher()
+ {
+ DP_SDA("CPresencePluginPublisher::~CPresencePluginPublisher");
+
+ if ( iDocument )
+ {
+ iDocument->Close();
+ }
+
+ if ( iPublisher )
+ {
+ iPublisher->Close();
+ }
+
+ if ( iWatcher )
+ {
+ iWatcher->Close();
+ }
+
+ DeleteWatchers();
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DeleteWatchers
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DeleteWatchers()
+ {
+ DP_SDA("CPresencePluginPublisher::DeleteWatchers");
+ // Delete all buffered transaction requests
+ TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );
+ rIter.SetToFirst();
+
+ while ( rIter )
+ {
+ DP_SDA("CPresencePluginPublisher::DeleteWatchers while");
+ CPresencePluginWatcherInfo* w = rIter;
+ rIter++;
+ // delete wathcer info
+ w->Destroy();
+ }
+ DP_SDA("CPresencePluginPublisher::DeleteWatchers end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::AddWatcherIfNotExistsL
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::AddWatcherIfNotExistsL(
+ const TDesC8& aId,
+ const TDesC& aSipId )
+ {
+ DP_SDA("CPresencePluginPublisher::AddWatcherIfNotExistsL");
+ // Delete all buffered transaction requests
+ TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );
+ rIter.SetToFirst();
+
+ TBool found(EFalse);
+
+ while ( rIter )
+ {
+ CPresencePluginWatcherInfo* w = rIter;
+ rIter++;
+ found = w->Match( aId, aSipId );
+ if ( found )
+ {
+ DP_SDA("CPresencePluginPublisher::AddWatcherIfNotExistsL found");
+ break;
+ }
+ }
+ if ( !found )
+ {
+ DP_SDA("CPresencePluginPublisher::AddWatcherIfNotExistsL !found");
+ CPresencePluginWatcherInfo* w =
+ CPresencePluginWatcherInfo::NewL( aId, aSipId );
+ iWatcherList.AddLast( *w );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::RemoveWatcherIfExistsL
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::RemoveWatcherIfExists(
+ const TDesC8& aId, const TDesC& aSipId )
+ {
+ DP_SDA("CPresencePluginPublisher::RemoveWatcherIfExistsL");
+ // Delete all buffered transaction requests
+ TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );
+ rIter.SetToFirst();
+
+ TBool found(EFalse);
+
+ while ( rIter )
+ {
+ CPresencePluginWatcherInfo* w = rIter;
+ rIter++;
+ // delete wathcer info
+ found = w->Match( aId, aSipId );
+ if ( found )
+ {
+ w->Destroy();
+ break;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoPublishOwnPresenceL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoPublishOwnPresenceL(
+ const MPresenceInfo& aOwnPresence,
+ TXIMPRequestId aReqId )
+ {
+ DP_SDA("CPresencePluginPublisher::DoPublishOwnPresenceL");
+ const MPersonPresenceInfo* persInfo = aOwnPresence.PersonPresence();
+ if ( !persInfo )
+ {
+ // Notice: error codes
+ CompleteXIMPReq( KErrArgument );
+ return;
+ }
+ InitializeSimpleDocumentL( );
+ AddSimpleDocumentPersL( persInfo );
+
+ StartXdmOperationL( aReqId );
+ iOperation = EPublishOwn;
+ DP_SDA("CPresencePluginPublisher::DoPublishOwnPresenceL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoSubscribeOwnPresenceL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoSubscribeOwnPresenceL(
+ const MPresenceInfoFilter& /*aPif*/, // notice: later
+ TXIMPRequestId aReqId )
+ {
+ DP_SDA("CPresencePluginPublisher::DoSubscribeOwnPresenceL");
+ StartXdmOperationL( aReqId );
+ iOperation = ESubscribeOwn;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoUpdateOwnPresenceSubscriptionPifL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoUpdateOwnPresenceSubscriptionPifL(
+ const MPresenceInfoFilter& /*aPif*/,
+ TXIMPRequestId /*aReqId*/ )
+ {
+ // Notice: later
+ User::Leave( KErrNotSupported );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoUnsubscribeOwnPresenceL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoUnsubscribeOwnPresenceL(
+ TXIMPRequestId aReqId )
+ {
+ DP_SDA("CPresencePluginPublisher::DoUnsubscribeOwnPresenceL");
+ iSubscribedOwn = EFalse;
+ iSimpleId = iWatcher->UnsubscribeL();
+ iXIMPId = aReqId;
+ iOperation = EUnsubscribeOwn;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoSubscribePresenceWatcherListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoSubscribePresenceWatcherListL(
+ TXIMPRequestId aReqId )
+ {
+ DP_SDA("CPresencePluginPublisher::DoSubscribePresenceWatcherListL");
+ if ( !iSubscribed )
+ {
+ DP_SDA("DoSubscribePresenceWatcherListL !Subscribed");
+ iConnObs.WinfoHandlerL()->SubscribeWinfoListL( aReqId );
+ iSubscribed = ETrue;
+ iXIMPId = aReqId;
+ iOperation = ESubscribeWinfo;
+ }
+ else
+ {
+ DP_SDA("DoSubscribePresenceWatcherListL else");
+ iXIMPId = aReqId;
+ iOperation = ESubscribeWinfo;
+ CompleteXIMPReq( KErrNone );
+ }
+ DP_SDA("CPresencePluginPublisher::DoSubscribePresenceWatcherListL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoUnsubscribePresenceWatcherListL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoUnsubscribePresenceWatcherListL(
+ TXIMPRequestId aReqId )
+ {
+ DP_SDA("CPresencePluginPublisher::DoUnsubscribePresenceWatcherListL");
+ if ( iSubscribed )
+ {
+ DP_SDA("DoUnsubscribePresenceWatcherListL: if ( iSubscribed ) - begin");
+ iConnObs.WinfoHandlerL()->UnsubscribeWinfoListL( aReqId );
+ iSubscribed = EFalse;
+ iXIMPId = aReqId;
+ iOperation = EUnsubscribeWinfo;
+ DP_SDA("DoUnsubscribePresenceWatcherListL: if ( iSubscribed ) - end");
+
+ }
+ else
+ {
+ DP_SDA("DoUnsubscribePresenceWatcherListL: iSubscribed ) is false");
+ iXIMPId = aReqId;
+ iOperation = EUnsubscribeWinfo; //hameed
+ CompleteXIMPReq( KErrNone );
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::PublishReqCompleteL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::PublishReqCompleteL(
+ TInt /*aOpid*/,
+ TInt aStatus )
+ {
+ DP_SDA("CPresencePluginPublisher::PublishReqCompleteL");
+ // Notice: make 415 error code conversion here and other
+ //SIP code -> XIMP conversions
+ DP_SDA2("PublishReqCompleteL STATUS %d",aStatus );
+
+ if( iConnObs.GetSessionStatus() )
+ {
+ DP_SDA2("PublishReqComp stopState %d",iConnObs.GetStopPublishState());
+ if ( !aStatus && !iConnObs.GetStopPublishState() )
+ {
+ DP_SDA("CPresencePluginPublisher::PublishReqCompleteL ETrue");
+ iPublished = ETrue;
+ iConnObs.SetStopPublishState( ETrue );
+ }
+ // Save E-Tag
+ if( !aStatus )
+ {
+ DP_SDA("CPresencePluginPublisher::PublishReqCompleteL Save ETAG");
+ TBuf8<KBufSize255> buf;
+ buf.Copy( iPublisher->SIPETag() );
+ iConnObs.SetETag( buf );
+ }
+ //Do not complete if error republish is true. XIMPFW is not knowing we
+ //are sending republish.
+ if( EFalse == iRePublish && !aStatus )
+ {
+ //Complete Publish request
+ DP_SDA("CPresencePluginPublisher::PublishReqCompleteL complete");
+ if( !(iConnObs.IsStopPublishCalled()) )
+ {
+ DP_SDA("CPresencePluginPublisher::PublishReqCompleteL complete normal");
+ // successfull Online / others: store status to cache
+ StoreOwnStatusToCacheL( );
+ CompleteXIMPReq( aStatus );
+ }
+ //Complete stopPublish and close session if stopPublish is called
+ if( iConnObs.IsStopPublishCalled() )
+ {
+ DP_SDA("PublishReqCompleteL complete closeSession");
+ iPresenceData->DeletePresenceVariablesL( iConnObs.ServiceId() );
+ // successfull Online / others: store status to cache
+ StoreOwnStatusToCacheL( );
+ //Complete close session
+ CompleteClientReq( aStatus );
+ }
+ }
+ if( EFalse == iRePublish && ( KSimpleErrTemporary == aStatus ) )
+ {
+ DP_SDA("PublishReqCompleteL KSimpleErrTemporary");
+ // Make new publish request without ETag
+ CreatePublisherL();
+ iSimpleId = iPublisher->StartPublishL( *iDocument, ETrue );
+ }
+ else if( EFalse == iRePublish && ( KErrTimedOut == aStatus ) )
+ {
+ DP_SDA("PublishReqCompleteL KErrTimedOut");
+ iPublisher->StopPublishL();
+ CompleteXIMPReq( KXIMPErrServicRequestTimeouted );
+ }
+ else
+ {
+ //Set rePublish flag back to false.
+ iRePublish = EFalse;
+ }
+ }
+ else
+ {
+ //Run this case if connection is not good any more
+ DP_SDA("PublishReqCompleteL No connect CANCEL");
+ Cancel();
+ }
+ DP_SDA("CPresencePluginPublisher::PublishReqCompleteL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::PublishTerminatedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::PublishTerminatedL( TInt aOpid )
+ {
+ DP_SDA("CPresencePluginPublisher::PublishTerminatedL");
+ DP_SDA2("CPresencePluginPublisher::PublishTerminatedL opID %d",aOpid );
+ DP_SDA2("PublishTerminatedL iSimpleId %d",iSimpleId );
+ DP_SDA2("PublishTerminatedL iStatus %d",iStatus.Int() );
+
+ if ( iSimpleId == aOpid && iConnObs.GetSessionStatus() )
+ {
+ DP_SDA("CPresencePluginPublisher::PublishTerminatedL NewPublish");
+ CreatePublisherL();
+ TRAPD( error , iSimpleId = iPublisher->StartPublishL(
+ *iDocument, ETrue ) );
+ if ( KErrNone == error )
+ {
+ DP_SDA("PublishTerminatedL NewPublish KErrNone");
+ iRePublish = ETrue;
+ iConnObs.SetStopPublishState( EFalse );
+ }
+ }
+ else
+ {
+ DP_SDA("CPresencePluginPublisher::PublishTerminatedL else");
+ iPublished = EFalse;
+ if( iPublisher )
+ {
+ iPublisher->Close();
+ iPublisher = NULL;
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::WatcherReqCompleteL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::WatcherReqCompleteL( TInt /*aOpid*/,
+ TInt aStatus )
+ {
+ DP_SDA("CPresencePluginPublisher::WatcherReqCompleteL");
+ if ( !aStatus )
+ {
+ iSubscribedOwn = ETrue;
+ }
+
+ CompleteXIMPReq( aStatus );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::WatcherNotificationL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::WatcherNotificationL(
+ MSimpleDocument& aDocument )
+ {
+ // Notice: Do not need to check the expiration here since
+ // WatcherTerminatedL is called then too.
+ DP_SDA("CPresencePluginPublisher::WatcherNotificationL");
+
+ MProtocolPresencePublishingDataHost& publishHost =
+ iConnObs.ProtocolPresenceHost().PublishingDataHost();
+
+ MPresenceInfo* prInfo =
+ iConnObs.PresenceObjectFactoryOwn().NewPresenceInfoLC();// << prInfo
+
+ iPresenceData->NotifyToPrInfoL(
+ iConnObs.ObjectFactory(),
+ iConnObs.PresenceObjectFactoryOwn(),
+ aDocument,
+ *prInfo );
+
+ // XIMP Host API callbacks
+
+ publishHost.HandleSubscribedOwnPresenceL( prInfo );
+ CleanupStack::Pop(); // >> prInfo
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::WatcherListNotificationL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::WatcherListNotificationL(
+ MSimplePresenceList& /*aList*/ )
+ {
+ //Do nothing now
+ DP_SDA("CPresencePluginPublisher::WatcherListNotificationL EMPTY");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::WatcherTerminatedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::WatcherTerminatedL(
+ TInt /*aOpId*/, TInt aReason )
+ {
+ DP_SDA("CPresencePluginPublisher::WatcherTerminatedL");
+
+ iSubscribedOwn = EFalse;
+
+ MXIMPObjectFactory& myFactory = iConnObs.ObjectFactory();
+ MProtocolPresencePublishingDataHost& publishHost =
+ iConnObs.ProtocolPresenceHost().PublishingDataHost();
+
+ MXIMPDataSubscriptionState *state =
+ myFactory.NewDataSubscriptionStateLC();
+ MXIMPStatus* status = myFactory.NewStatusLC();
+ state->SetSubscriptionStateL(
+ MXIMPDataSubscriptionState::ESubscriptionInactive );
+
+ status->SetResultCode( aReason );
+ publishHost.SetOwnPresenceDataSubscriptionStateL( state, status );
+ CleanupStack::Pop( 2 ); // status, state
+
+ DP_SDA("CPresencePluginPublisher::WatcherTerminatedL - end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::CompleteXIMPReq()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::CompleteXIMPReq( TInt aStatus )
+ {
+ DP_SDA("CPresencePluginPublisher::CompleteXIMPReq");
+ DP_SDA2("CompleteXIMPReq: iOperation = %d",(TInt) iOperation );
+ // Notice: should this yield active scheduler???
+ if ( iOperation != ENoOperation )
+ {
+ DP_SDA("CPresencePluginPublisher::CompleteXIMPReq complete");
+ iOperation = ENoOperation;
+ iConnObs.CompleteReq( iXIMPId, aStatus );
+ iXIMPId = TXIMPRequestId();
+ }
+ DP_SDA("CPresencePluginPublisher::CompleteXIMPReq end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::CompleteClientReq()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::CompleteClientReq( TInt aStatus )
+ {
+ DP_SDA2("CPresencePluginPublisher::CompleteClientReq status %d ", aStatus);
+ iOperation = ENoOperation;
+ TRequestStatus* s = iClientStatus;
+ User::RequestComplete( s, aStatus );
+ DP_SDA("CPresencePluginPublisher::CompleteClientReq end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::DoCancel()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::DoCancel( )
+ {
+ DP_SDA("CPresencePluginPublisher::DoCancel CANCEL");
+ iXdmUtils->Cancel();
+ iPublisher->Close();
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::RunL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::RunL( )
+ {
+ DP_SDA("CPresencePluginPublisher::RunL");
+ TInt status = iStatus.Int();
+ DP_SDA2("CPresencePluginPublisher::RunL status %d", status );
+ if ( !status )
+ {
+
+ if ( iOperation == ESubscribeOwn )
+ {
+ DP_SDA("CPresencePluginPublisher::RunL Subscribe Own");
+ iSimpleId = iWatcher->SubscribeL(
+ iConnObs.CurrentSipPresentity8(),
+ NULL, // aFilter <-> aPif
+ ETrue, EFalse );
+ }
+ else if( iOperation == EPublishOwn )
+ {
+ DP_SDA("CPresencePluginPublisher::RunL MakePublishReqL");
+ MakePublishReqL();
+ }
+ }
+ else
+ {
+ DP_SDA("CPresencePluginPublisher::RunL complete");
+ CompleteXIMPReq( status );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::RunError
+// ---------------------------------------------------------------------------
+//
+TInt CPresencePluginPublisher::RunError( TInt aError )
+ {
+ DP_SDA2("CPresencePluginPublisher::RunError %d",aError );
+
+ CompleteXIMPReq( aError );
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::GetInterface()
+// ---------------------------------------------------------------------------
+//
+TAny* CPresencePluginPublisher::GetInterface(
+ TInt32 aInterfaceId,
+ TIfGetOps aOptions )
+ {
+ DP_SDA("CPresencePluginPublisher::GetInterface");
+
+ if ( aInterfaceId == GetInterfaceId() )
+ {
+ // caller wants this interface
+ MProtocolPresencePublishing* myIf = this;
+ return myIf;
+ }
+ if ( aOptions == MXIMPBase::EPanicIfUnknown )
+ {
+ User::Panic( KPluginName, KErrExtensionNotSupported );
+ }
+ return NULL;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::GetInterface()
+// ---------------------------------------------------------------------------
+//
+const TAny* CPresencePluginPublisher::GetInterface(
+ TInt32 aInterfaceId,
+ TIfGetOps aOptions ) const
+ {
+ DP_SDA("CPresencePluginPublisher::GetInterface 2 ");
+
+ if ( aInterfaceId == GetInterfaceId() )
+ {
+ // caller wants this interface
+ const MProtocolPresencePublishing* myIf = this;
+ return myIf;
+ }
+ if ( aOptions == MXIMPBase::EPanicIfUnknown )
+ {
+ User::Panic( KPluginName, KErrExtensionNotSupported );
+ }
+ return NULL;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::GetInterfaceId()
+// ---------------------------------------------------------------------------
+//
+TInt32 CPresencePluginPublisher::GetInterfaceId() const
+ {
+ DP_SDA("CPresencePluginPublisher::GetInterfaceId");
+
+ return MProtocolPresencePublishing::KInterfaceId;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::InitializeSimpleDocumentL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::InitializeSimpleDocumentL( )
+ {
+ _LIT8 ( KCipidNS, "urn:ietf:params:xml:ns:pidf:cipid" );
+ _LIT8 ( KCipidCP, "c" );
+ if ( iDocument )
+ {
+ DP_SDA("CPresencePluginPublisher:: deletedocument");
+ iDocument->Close();
+ iDocument = NULL;
+ iDocument = TSimpleFactory::NewDocumentL();
+ }
+ else
+ {
+ DP_SDA("CPresencePluginPublisher:: create document");
+ iDocument = TSimpleFactory::NewDocumentL();
+ }
+ iDocument->AddNamespaceL( KSimplePDM, KSimpleNsPDM );
+ iDocument->AddNamespaceL( KSimpleRPID, KSimpleNsRPID );
+ iDocument->AddNamespaceL( KCipidCP, KCipidNS );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::AddSimpleDocumentPersL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::AddSimpleDocumentPersL(
+ const MPersonPresenceInfo* aInfo )
+ {
+ TInt tupleId = iConnObs.GetTupleId();
+
+ DP_SDA2("AddSimpleDocumentPersL tuple id get: %d", tupleId);
+ if ( tupleId == 0 )
+ {
+ DP_SDA("AddSimpleDocumentPersL tuple generate");
+ tupleId = iPresenceData->GenerateTupleId();
+ iConnObs.SetTupleId(tupleId);
+ }
+
+ iPresenceData->AddPrPersToSimpleDocumentL(
+ aInfo, *iDocument, iConnObs.CurrentSipPresentity8(), tupleId );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::StopPublishL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::StopPublishL( TRequestStatus& aStatus )
+ {
+ DP_SDA2("StopPublish - begin : iPublished= %d ",(TInt) iPublished);
+
+ aStatus = KRequestPending;
+ iClientStatus = &aStatus;
+
+ TInt err1( 0 );
+ TInt err2( 0 );
+
+ // get stored document id if available
+ HBufC8* oldDocumentId = HBufC8::NewLC( KBufSize255 );
+ TPtr8 oldDocumentIdPtr( oldDocumentId->Des() );
+ TRAP( err1, iPresenceData->ReadDocumentIdL(
+ iConnObs.ServiceId(), oldDocumentIdPtr ) );
+
+ if ( iConnObs.GetStopPublishState() && iPublished )
+ {
+ DP_SDA("CPresencePluginPublisher::StopPublish really Stop");
+ if ( !err1 )
+ {
+ TRAP( err2, iPublisher->StopPublishL( oldDocumentIdPtr ) );
+ }
+ else
+ {
+ // if stored document id is not available try with this
+ TRAP( err2, iPublisher->StopPublishL( iConnObs.GetETag() ) );
+ }
+ DP_SDA2("StopPublish iPublisher->StopPublishL : error = %d ", err2 );
+ if ( KErrNone != err2 )
+ {
+ if( iPublisher )
+ {
+ DP_SDA("StopPublish delete and recreate publisher");
+ iPublisher->Close();
+ iPublisher = NULL;
+ DP_SDA("StopPublish really Stop try again 1 ");
+ iPublisher =
+ TSimpleFactory::NewPublisherL( iConnection, *this );
+ DP_SDA("StopPublish really Stop try again 2 ");
+ err2 = KErrGeneral;
+ TRAP( err2, iPublisher->StopPublishL( iConnObs.GetETag() ););
+ DP_SDA2("StopPublishL 2nd try : error = %d ", err2 );
+ if ( KErrNone != err2 )
+ {
+ DP_SDA("StopPublish TWO TIME Error, last try without tag ");
+ TRAP( err2, iPublisher->StopPublishL(); );
+ DP_SDA2("StopPublishL 3rd try : error = %d ", err2 );
+ }
+ }
+ }
+ iConnObs.SetStopPublishState( ETrue );
+ iPublished = EFalse;
+ }
+ CleanupStack::PopAndDestroy( oldDocumentId );
+
+ DP_SDA("CPresencePluginPublisher::StopPublish- end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::Published()
+// ---------------------------------------------------------------------------
+//
+TBool CPresencePluginPublisher::Published()
+ {
+ return iPublished;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::MakePublishReqL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::MakePublishReqL( )
+ {
+ DP_SDA("CPresencePluginPublisher::MakePublishReqL");
+
+ DP_SDA(" -> MakePublishReqL, check for old doc id");
+ HBufC8* oldDocumentId = HBufC8::NewLC( KBufSize255 );
+ TPtr8 oldDocumentIdPtr( oldDocumentId->Des() );
+ TRAPD( error, iPresenceData->ReadDocumentIdL(
+ iConnObs.ServiceId(), oldDocumentIdPtr ) );
+ if ( !iPublished )
+ {
+ DP_SDA("CPresencePluginPublisher::MakePublishReqL 1");
+ CreatePublisherL();
+
+ DP_SDA2(" -> MakePublishReqL, doc id error: %d", error );
+ if ( !error )
+ {
+ DP_SDA(" -> MakePublishReqL, publish with old id");
+ iSimpleId = iPublisher->ContinuePublishL(
+ *iDocument, ETrue, oldDocumentIdPtr );
+ }
+ else
+ {
+ DP_SDA(" -> MakePublishReqL, publish with new id");
+ iSimpleId = iPublisher->StartPublishL( *iDocument, ETrue );
+ }
+ }
+ else
+ {
+ DP_SDA("CPresencePluginPublisher::MakePublishReqL 2");
+ CreatePublisherL();
+ DP_SDA("CPresencePluginPublisher::MakePublishReqL Continue Publish");
+ if ( !error )
+ {
+ DP_SDA(" -> MakePublishReqL, publish with stored id");
+ iSimpleId = iPublisher->ContinuePublishL(
+ *iDocument ,ETrue, oldDocumentIdPtr );
+ }
+ else
+ {
+ DP_SDA(" -> MakePublishReqL, stored id not found" );
+ DP_SDA(", publish with old id");
+ iSimpleId = iPublisher->ContinuePublishL(
+ *iDocument ,ETrue, iConnObs.GetETag() );
+ }
+ DP_SDA("CPresencePluginPublisher::MakePublishReqL modifyed");
+ }
+ CleanupStack::PopAndDestroy( oldDocumentId );
+ DP_SDA("CPresencePluginPublisher::MakePublishReqL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::StartXdmOperationL
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::StartXdmOperationL(
+ TXIMPRequestId aReqId )
+ {
+ DP_SDA("CPresencePluginPublisher::StartXdmOperationL");
+ __ASSERT_DEBUG( !IsActive(), User::Leave( KErrNotReady ) );
+ iXIMPId = aReqId;
+ if ( !iXdmUtils )
+ {
+ DP_SDA("StartXdmOperationL Initialize XDMUtils");
+ iXdmUtils = iConnObs.XdmUtilsL();
+ }
+
+ // Allways check those XDM files are ok /
+ //publish seems to be jam if xdm not initialized ?
+ iXdmUtils->InitializeXdmL( iStatus );
+ SetActive();
+ DP_SDA("CPresencePluginPublisher::StartXdmOperationL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::WinfoNotificationL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::WinfoNotificationL(
+ MSimpleWinfo& aWinfo )
+ {
+ DP_SDA("CPresencePluginPublisher::WinfoNotificationL");
+
+ RPointerArray<MSimpleElement> elems;
+ CleanupClosePushL( elems ); // << elems
+ TInt err = aWinfo.SimpleElementsL( elems );
+ User::LeaveIfError( err );
+ TInt count = elems.Count();
+
+ DP_SDA2("WinfoNotificationL elems count%d", count);
+
+ __ASSERT_ALWAYS( count == 1, User::Leave( KErrCorrupt ) );
+
+ using namespace NPresencePlugin::NPresence;
+
+ const TDesC8* stateVal = aWinfo.AttrValue( KPresenceState8 );
+
+ if ( stateVal && !stateVal->CompareF( KPresenceFull8 )) //state full
+ {
+ // full winfo-list is received (New empty list )
+ DP_SDA("CPresencePluginPublisher::WinfoNotificationL full list found");
+ DeleteWatchers();
+ }
+ else
+ {
+ DP_SDA("PluginPublisher: state != full");
+ // Test if state is partitial
+ if ( stateVal && !stateVal->CompareF( KPresencePartial8 ))
+ {
+ DP_SDA("PluginPublisher: state = partitial");
+ }
+ }
+
+ MSimpleElement* elem = elems[0];
+ TPtrC8 p8 = elem->LocalName();
+ err = p8.CompareF( KPresenceWatcherList8 );
+ DP_SDA2("WinfoNotificationL KPresenceWatcherList8 err %d", err);
+ User::LeaveIfError( err );
+ DP_SDA("WinfoNotificationL KPresenceWatcherList8 continue");
+
+ //Get elemets from document
+ err = elem->SimpleElementsL( elems );
+ User::LeaveIfError( err );
+ DP_SDA2("WinfoNotificationL get elems err %d", err);
+ //Make collect from active watchers
+ CollectWatchersL( elems );
+
+ CDesCArrayFlat* watchers = MakeCurrentWatcherListLC();// << watchers
+ MXIMPObjectCollection *actives =
+ iConnObs.ObjectFactory().NewObjectCollectionLC();// << actives
+
+ // Create MXIMPPresenceWatcherInfo entities for
+ // all active watchers and add to actives.
+ TInt wCount = watchers->MdcaCount();
+ DP_SDA2("CPresencePluginPublisher::WinfoNotificationL wCount %d", wCount);
+ for ( TInt j = 0; j < wCount; j++ )
+ {
+ // create MXIMPPresenceWatcherInfo object
+ MPresenceWatcherInfo* wInfo =
+ iConnObs.PresenceObjectFactoryOwn().
+ NewPresenceWatcherInfoLC();// << wInfo
+
+ MXIMPIdentity* identity =
+ iConnObs.ObjectFactory().NewIdentityLC();// << identity
+
+ identity->SetIdentityL( watchers->MdcaPoint( j ) );
+ wInfo->SetWatcherIdL( identity );
+ CleanupStack::Pop( );// >> identity
+
+ wInfo->SetWatcherDisplayNameL( watchers->MdcaPoint( j ) );
+ wInfo->SetWatcherTypeL( MPresenceWatcherInfo::EPresenceSubscriber );
+
+ actives->AddObjectL( wInfo );
+ CleanupStack::Pop( ); // >> wInfo
+ }
+
+ MProtocolPresencePublishingDataHost& publishHost =
+ iConnObs.Host()->ProtocolPresenceDataHost().PublishingDataHost();
+
+ publishHost.HandlePresenceWatcherListL( actives );
+
+ CleanupStack::Pop(); // >> actives
+ CleanupStack::PopAndDestroy( watchers ); // >> watchers
+
+ CleanupStack::PopAndDestroy( &elems ); // >> elems
+ DP_SDA("CPresencePluginPublisher::WinfoNotificationL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::WinfoTerminatedL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::WinfoTerminatedL( TInt aReason )
+ {
+ DP_SDA("CPresencePluginPublisher::WinfoTerminatedL - begin");
+
+ // call SetPresenceWatcherListDataSubscriptionStateL
+ iSubscribed = EFalse;
+
+ MXIMPObjectFactory& myFactory = iConnObs.ObjectFactory();
+ MProtocolPresencePublishingDataHost& publishHost =
+ iConnObs.Host()->ProtocolPresenceDataHost().PublishingDataHost();
+ MXIMPDataSubscriptionState *state =
+ myFactory.NewDataSubscriptionStateLC();
+
+ MXIMPStatus* status = myFactory.NewStatusLC();
+ state->SetSubscriptionStateL(
+ MXIMPDataSubscriptionState::ESubscriptionInactive );
+
+ state->SetDataStateL( MXIMPDataSubscriptionState::EDataUnavailable );
+ status->SetResultCode( aReason );
+ publishHost.SetPresenceWatcherListDataSubscriptionStateL( state, status );
+ CleanupStack::Pop( 2 ); // status, state
+ DP_SDA("CPresencePluginPublisher::WinfoTerminatedL - end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::NewETagL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::NewETagL( const TDesC8& aVal )
+ {
+ DP_SDA("CPresencePluginPublisher::NewETagL");
+ // Set ETag value
+ DP_SDA("CPresencePluginPublisher::NewETagL Set ETag");
+ TBuf8<KBufSize255> buf;
+ buf.Copy( aVal );
+ iConnObs.SetETag( buf );
+ buf.Zero();
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::MakeCurrentWatcherListLC
+// ---------------------------------------------------------------------------
+//
+CDesCArrayFlat* CPresencePluginPublisher::MakeCurrentWatcherListLC()
+ {
+ DP_SDA("CPresencePluginPublisher::MakeCurrentWatcherListLC - begin");
+ // No one should be added more than once
+ const TInt KMyGran = 10;
+ CDesCArrayFlat* watchers = new (ELeave) CDesCArrayFlat( KMyGran );
+ CleanupStack::PushL( watchers ); // << watchers
+
+ // add user only once here.
+ TDblQueIter<CPresencePluginWatcherInfo> rIter( iWatcherList );
+ rIter.SetToFirst();
+
+ while ( rIter )
+ {
+ CPresencePluginWatcherInfo* w = rIter;
+ rIter++;
+
+ TInt dummy = 0;
+ // Zero -> Found
+ if ( watchers->Find( w->SipId(), dummy ))
+ {
+ watchers->AppendL( w->SipId() );
+ }
+ }
+
+ DP_SDA("CPresencePluginPublisher::MakeCurrentWatcherListLC - end");
+ return watchers;
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::CollectWatchers
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::CollectWatchersL(
+ RPointerArray<MSimpleElement>& aElems )
+ {
+ using namespace NPresencePlugin::NPresence;
+ HBufC* nodeContent = NULL;
+
+ TInt count = aElems.Count();
+ DP_SDA2("CPresencePluginPublisher::CollectWatchers elem count %d",count);
+
+ for ( TInt i = 0; i < count; i++ )
+ {
+ MSimpleElement* elem = aElems[i];
+ TPtrC8 p8( elem->LocalName());
+
+ if (!( p8.CompareF( KPresenceWatcher8 )))
+ {
+ DP_SDA("CPresencePluginPublisher::CollectWatchers watchers found");
+ const TDesC8* pp8 = elem->AttrValue( KPresenceStatus8 );
+ // Active wathers here
+ if ( pp8 && !pp8->CompareF( KPresenceActive8 ))
+ {
+ DP_SDA("CollectWatchers: ACTIVE found");
+ // save id since there may be multiple subscriptions
+ // from a single watcher SIP identity.
+ const TDesC8* pId8 = elem->AttrValue( KPresenceId8 );
+
+ // Build collection of grant requests
+ // Find the child node containing the SIP entity
+ nodeContent = elem->ContentUnicodeL();
+ CleanupStack::PushL( nodeContent );// << nodeContent
+
+ AddWatcherIfNotExistsL(
+ pId8 ? *pId8 : KNullDesC8, nodeContent->Des() );
+
+ CleanupStack::PopAndDestroy( nodeContent ); //>> nodeContent
+ }
+ // Terminated wathers here
+ else if ( pp8 && !pp8->CompareF( KPresenceTerminated8 ))
+ {
+ DP_SDA("CollectWatchers: Terminated");
+ const TDesC8* pId8 = elem->AttrValue( KPresenceId8 );
+
+ // Remove terminated from iWatcherList
+ nodeContent = elem->ContentUnicodeL();
+ CleanupStack::PushL( nodeContent );// << nodeContent
+
+ RemoveWatcherIfExists(
+ pId8 ? *pId8 : KNullDesC8, nodeContent->Des() );
+
+ CleanupStack::PopAndDestroy( nodeContent );// >> nodeContent
+ }
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::CreatePublisherL()
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::CreatePublisherL()
+ {
+ DP_SDA("CPresencePluginPublisher::CreatePublisherL");
+ if( iPublisher )
+ {
+ DP_SDA("CPresencePluginPublisher::CreatePublisherL create");
+ iPublisher->Close();
+ iPublisher = NULL;
+ iPublisher = TSimpleFactory::NewPublisherL( iConnection, *this );
+ }
+ DP_SDA("CPresencePluginPublisher::CreatePublisherL end");
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::StoreOwnStatusToCacheL
+// ---------------------------------------------------------------------------
+//
+void CPresencePluginPublisher::StoreOwnStatusToCacheL()
+ {
+ DP_SDA("CPresencePluginPublisher::StoreOwnStatusToCacheL" );
+
+ using namespace NPresencePlugin::NPresence;
+ using namespace NPresencePlugin::NPresenceStates;
+ using namespace NPresenceInfo::NFieldType;
+
+ DP_SDA(" CPresencePluginPublisher -> convert uri" );
+ HBufC* entityUri =
+ CnvUtfConverter::ConvertToUnicodeFromUtf8L(
+ *iDocument->EntityURI() );
+ CleanupStack::PushL( entityUri );
+
+ DP_SDA(" CPresencePluginPublisher -> strip prefix" );
+ HBufC16* prefixStripped = iPresenceData->RemovePrefixLC(
+ *entityUri );
+
+ DP_SDA(" CPresencePluginPublisher -> fetch simple elements" );
+ RPointerArray<MSimpleElement> simpleElements;
+ CleanupClosePushL( simpleElements );
+ DP_SDA(" CPresencePluginPublisher -> do fetch simple elements" );
+ TInt error = iDocument->SimpleElementsL( simpleElements );
+ DP_SDA2(" CPresencePluginPublisher -> fetch error: %d", error );
+ User::LeaveIfError( error );
+ TBool handled = EFalse;
+ DP_SDA2(" CPresencePluginPublisher -> element count: %d",
+ simpleElements.Count() );
+
+ MSimpleElement* basicSimpleElem(NULL);
+ MSimpleElement* noteSimpleElem(NULL);
+
+ TBuf<KBufSize100> activitiesContentBuf;
+ TBool activitiesHandled( EFalse );
+
+ for( TInt index = 0 ; index < simpleElements.Count() ; index++ )
+ {
+ DP_SDA(" CPresencePluginPublisher -> check for person element" );
+ // Check for person element
+ if (!( simpleElements[index]->LocalName().CompareF( KPresencePerson8 )) ||
+ !( simpleElements[index]->LocalName().CompareF( KPresenceTuple8 )) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> person/tuple element found" );
+ RPointerArray<MSimpleElement> personSubElems;
+ CleanupClosePushL( personSubElems );
+ simpleElements[index]->SimpleElementsL( personSubElems );
+ DP_SDA2(" CPresencePluginPublisher -> person/tuple sub elemen count: %d",
+ personSubElems.Count() );
+
+ for ( TInt j = 0; j < personSubElems.Count(); j++ )
+ {
+ DP_SDA(" CPresencePluginPublisher -> check for status/activities element");
+ if ( !personSubElems[j]->LocalName().CompareF( KPresenceStatus8 ) ||
+ !personSubElems[j]->LocalName().CompareF( KPresenceActivities8 ))
+ {
+ DP_SDA(" CPresencePluginPublisher -> status/activities element found");
+ //Get childs
+ RPointerArray<MSimpleElement> basicElems;
+ CleanupClosePushL( basicElems );
+
+ personSubElems[j]->SimpleElementsL( basicElems );
+ DP_SDA2(" CPresencePluginPublisher -> child elem count: %d",
+ basicElems.Count() );
+ for ( TInt k = 0; k < basicElems.Count(); k++ )
+ {
+ DP_SDA(" CPresencePluginPublisher -> check child elems");
+ if ( !basicElems[k]->LocalName().CompareF(
+ KPresenceBasic8 ))
+ {
+ DP_SDA(" -> basic element found");
+ basicSimpleElem = basicElems[k];
+ }
+ else if ( basicSimpleElem &&
+ !basicElems[k]->LocalName().CompareF( KPresenceActivities8 ) )
+ {
+ DP_SDA(" -> activities found from basic elem");
+ RPointerArray<MSimpleElement> activitiesElems;
+ CleanupClosePushL( activitiesElems );
+
+ DP_SDA(" -> get activities");
+ basicElems[k]->SimpleElementsL( activitiesElems );
+ DP_SDA2(" -> activities count: %d",
+ activitiesElems.Count() );
+ if ( activitiesElems.Count() )
+ {
+ DP_SDA(" -> get activities, multiple, use last");
+ TInt lastActiviesIndex =
+ ( activitiesElems.Count() - 1 );
+ activitiesContentBuf.Copy(
+ activitiesElems[lastActiviesIndex]->LocalName() );
+ activitiesHandled = ETrue;
+ DP_SDA(" -> activity elem ok");
+ }
+ CleanupStack::PopAndDestroy( &activitiesElems );
+ }
+ else if ( basicSimpleElem &&
+ !personSubElems[j]->LocalName().CompareF( KPresenceActivities8 ) )
+ {
+ DP_SDA(" -> activities found from person elem");
+ RPointerArray<MSimpleElement> activitiesElems;
+ CleanupClosePushL( activitiesElems );
+
+ DP_SDA(" -> get activities");
+ personSubElems[j]->SimpleElementsL( activitiesElems );
+ DP_SDA2(" -> activities count: %d",
+ activitiesElems.Count() );
+ if ( activitiesElems.Count() )
+ {
+ DP_SDA(" -> get activities, multiple, use last");
+ TInt lastActiviesIndex =
+ ( activitiesElems.Count() - 1 );
+ activitiesContentBuf.Copy(
+ activitiesElems[lastActiviesIndex]->LocalName() );
+ activitiesHandled = ETrue;
+ DP_SDA2(" -> activities len: %d",
+ activitiesContentBuf.Length() );
+ DP_SDA(" -> activity elem ok");
+ }
+ CleanupStack::PopAndDestroy( &activitiesElems );
+ }
+ }
+ CleanupStack::PopAndDestroy( &basicElems );
+ }
+ }
+ CleanupStack::PopAndDestroy( &personSubElems );
+ }
+ else if ( !simpleElements[index]->LocalName().CompareF( KPresenceNote8 ))
+ {
+ DP_SDA(" CPresencePluginPublisher -> note element found" );
+ noteSimpleElem = simpleElements[index];
+ }
+ }
+ DP_SDA(" CPresencePluginPublisher -> elements handled");
+ __ASSERT_ALWAYS( basicSimpleElem, User::Leave( KErrCorrupt ) );
+
+ if ( !activitiesHandled )
+ {
+ DP_SDA(" -> activities not handled, set unknown");
+ activitiesContentBuf.Copy( KPresenceUnknow );
+ }
+
+ HBufC* nodeContent = basicSimpleElem->ContentUnicodeL();
+ CleanupStack::PushL( nodeContent );
+
+ HBufC* noteContent = NULL;
+ if ( noteSimpleElem )
+ {
+ noteContent = noteSimpleElem->ContentUnicodeL();
+ CleanupStack::PushL( noteContent );
+ }
+ else
+ {
+ noteContent = KNullDesC().AllocLC();
+ }
+
+ MPresenceBuddyInfo2::TAvailabilityValues cacheAvailability =
+ MPresenceBuddyInfo2::ENotAvailable;
+ NPresenceInfo::TAvailabilityValues ximpAvailability =
+ NPresenceInfo::ENotAvailable;
+
+ HBufC* extendedCacheAvailability = HBufC::NewLC( KBufSize255 );
+ TPtr extendedCacheAvailabilityPtr( extendedCacheAvailability->Des() );
+ if ( nodeContent )
+ {
+ handled = ResolveOwnCacheValues( *nodeContent,
+ activitiesContentBuf, cacheAvailability,
+ extendedCacheAvailabilityPtr, ximpAvailability );
+ }
+
+ __ASSERT_ALWAYS( handled, User::Leave( KErrCorrupt ));
+
+ DP_SDA(" CPresencePluginPublisher -> write to cache" );
+
+ DP_SDA2(" CPresencePluginPublisher -> availability: %d",
+ cacheAvailability );
+ DP_SDA2(" CPresencePluginPublisher -> ext availability len: %d",
+ extendedCacheAvailabilityPtr.Length() );
+
+ iPresenceData->WriteStatusToCacheL(
+ *prefixStripped, cacheAvailability,
+ extendedCacheAvailabilityPtr, *noteContent );
+
+ // Store publish variables for republish
+ iPresenceData->StorePresenceOwnPresenceL(
+ iConnObs.ServiceId(), ximpAvailability, *noteContent );
+
+ CleanupStack::PopAndDestroy( extendedCacheAvailability );
+ CleanupStack::PopAndDestroy( noteContent );
+ CleanupStack::PopAndDestroy( nodeContent );
+
+ DP_SDA(" CPresencePluginPublisher -> attributes handled" );
+ CleanupStack::PopAndDestroy( &simpleElements );
+
+ DP_SDA(" CPresencePluginPublisher -> write to cache ok, cleanup" );
+
+ // prefixStripped, entityUri
+ CleanupStack::PopAndDestroy( 2 );
+ DP_SDA("CPresencePluginPublisher::StoreOwnStatusToCacheL out" );
+ }
+
+// ---------------------------------------------------------------------------
+// CPresencePluginPublisher::ResolveOwnCacheValues
+// ---------------------------------------------------------------------------
+//
+TBool CPresencePluginPublisher::ResolveOwnCacheValues(
+ const TDesC& aUnicodeContent,
+ const TDesC& aActivities,
+ MPresenceBuddyInfo2::TAvailabilityValues& aCacheAvailability,
+ TPtr& aExtendedCacheAvailability,
+ NPresenceInfo::TAvailabilityValues& aXimpApiAvailability )
+ {
+ DP_SDA("CPresencePluginPublisher::ResolveOwnCacheValuesL" );
+ using namespace NPresencePlugin::NPresence;
+ using namespace NPresencePlugin::NPresenceStates;
+ using namespace NPresenceInfo::NFieldType;
+
+ TBool handled = EFalse;
+ if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceBusy ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> busy");
+ aCacheAvailability = MPresenceBuddyInfo2::EBusy;
+ aExtendedCacheAvailability.Copy( KDndState() );
+ aXimpApiAvailability = NPresenceInfo::EBusy;
+ handled = ETrue;
+ }
+ // On-The-Phone case
+ else if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceOnThePhone ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> on-the-phone");
+ aCacheAvailability = MPresenceBuddyInfo2::EBusy;
+ aExtendedCacheAvailability.Copy( KOnPhoneState() );
+ aXimpApiAvailability = NPresenceInfo::EOnPhone;
+ handled = ETrue;
+ }
+ //Away case
+ else if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceAway ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> away");
+ aCacheAvailability = MPresenceBuddyInfo2::EBusy;
+ aExtendedCacheAvailability.Copy( KAwayState() );
+ aXimpApiAvailability = NPresenceInfo::EAway;
+ handled = ETrue;
+ }
+ //Dnd case
+ else if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceDoNotDisturb ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> dnd");
+ aCacheAvailability = MPresenceBuddyInfo2::EBusy;
+ aExtendedCacheAvailability.Copy( KDndState() );
+ aXimpApiAvailability = NPresenceInfo::EDoNotDisturb;
+ handled = ETrue;
+ }
+ // Unknown open
+ else if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceUnknow ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> open");
+ aCacheAvailability = MPresenceBuddyInfo2::EAvailable;
+ aExtendedCacheAvailability.Copy( KDefaultAvailableStatus() );
+ aXimpApiAvailability = NPresenceInfo::EAvailable;
+ handled = ETrue;
+ }
+ // available open
+ else if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceAvailable ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> open");
+ aCacheAvailability = MPresenceBuddyInfo2::EAvailable;
+ aExtendedCacheAvailability.Copy( KDefaultAvailableStatus() );
+ aXimpApiAvailability = NPresenceInfo::EAvailable;
+ handled = ETrue;
+ }
+ // available open
+ else if ( !aUnicodeContent.CompareF( KPresenceOpen ) &&
+ !aActivities.CompareF ( KPresenceOpen ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> open/open");
+ aCacheAvailability = MPresenceBuddyInfo2::EAvailable;
+ aExtendedCacheAvailability.Copy( KDefaultAvailableStatus() );
+ aXimpApiAvailability = NPresenceInfo::EAvailable;
+ handled = ETrue;
+ }
+ //Unknown closed
+ else if ( !aUnicodeContent.CompareF( KPresenceClosed ) &&
+ !aActivities.CompareF ( KPresenceUnknow ) )
+ {
+ DP_SDA(" CPresencePluginPublisher -> closed");
+ aCacheAvailability = MPresenceBuddyInfo2::ENotAvailable;
+ aExtendedCacheAvailability.Copy( KInvisibleState() );
+ aXimpApiAvailability = NPresenceInfo::ENotAvailable;
+ handled = ETrue;
+ }
+ //All other states are closed
+ else
+ {
+ DP_SDA(" CPresencePluginPublisher -> else closed");
+ aCacheAvailability = MPresenceBuddyInfo2::ENotAvailable;
+ aExtendedCacheAvailability.Copy( KInvisibleState() );
+ aXimpApiAvailability = NPresenceInfo::ENotAvailable;
+ handled = ETrue;
+ }
+ DP_SDA2("CPresencePluginPublisher::ResolveOwnCacheValuesL out, ret: %d",
+ handled );
+ return handled;
+ }
+
+// End of file