diff -r 000000000000 -r c8caa15ef882 simpledatamodeladapter/src/presencepluginpublisher.cpp --- /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 +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include // For KSimplePDM +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#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 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 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 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 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 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 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 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& 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 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 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 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 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 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 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