/*
* Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: IETF SIMPLE Protocol implementation for XIMP Framework
*
*/
#include <badesca.h>
#include <ximpbase.h>
#include <ximpserviceinfo.h>
#include <protocolpresencefeatures.h>
#include <cprotocolimfeatures.h>
#include <protocolpresencedatahost.h>
#include <presenceobjectfactory.h>
#include <ximpcontextclientinfo.h>
#include <protocolpresenceauthorization.h>
#include <ximpprotocolconnectionhost.h>
#include <ximpfeatureinfo.h> //for etc. KPublish
#include <msimpleconnection.h> //Part of Registration API from SIMPLE engine
#include <msimpleconnectionobserver.h>//Connection callback methods
#include <presenceinfo.h>
#include "presencepluginconnection.h"
#include "presencepluginsession.h"
#include "mpresencepluginconnectionobs.h"
#include "presencepluginwatcher.h"
#include "presencepluginauthorization.h"
#include "presencepluginwinfo.h"
#include "presencepluginpublisher.h"
#include "presenceplugingroup.h"
#include "presencepluginxdmutils.h"
#include "presencepluginvirtualgroup.h"
#include "presenceconnectioninfo.h"
#include "presenceplugindata.h"
#include "simpleimpluginuids.hrh" //KImplUidSimpleImPlugin
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
// CPresencePluginConnection::CPresencePluginConnection()
// ---------------------------------------------------------------------------
//
CPresencePluginConnection::CPresencePluginConnection( ):
CActive( CActive::EPriorityHigh ), iSipPresentity(NULL),
iStopPublishState( EFalse ), iGrantListSubs( EFalse ), iStopPublishCall( EFalse ),
iTerminatedCall( EFalse )
{
DP_SDA("CPresencePluginConnection::CPresencePluginConnection");
CActiveScheduler::Add(this);
iOwnTupleId = 0;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::NewL()
// ---------------------------------------------------------------------------
//
CPresencePluginConnection* CPresencePluginConnection::NewL(
const MXIMPServiceInfo& aServiceInfo,
const MXIMPContextClientInfo& aClientCtxInfo )
{
DP_SDA("CPresencePluginConnection::NewL");
CPresencePluginConnection* self =
new( ELeave ) CPresencePluginConnection( );
CleanupStack::PushL( self );
self->ConstructL( aServiceInfo, aClientCtxInfo );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::NewL() loaded
// ---------------------------------------------------------------------------
//
CPresencePluginConnection* CPresencePluginConnection::NewL(
const MXIMPServiceInfo& aServiceInfo,
const MXIMPContextClientInfo& aClientCtxInfo,
const TDesC8& aETag )
{
DP_SDA("CPresencePluginConnection::NewL loaded");
CPresencePluginConnection* self =
new( ELeave ) CPresencePluginConnection( );
CleanupStack::PushL( self );
self->ConstructL( aServiceInfo, aClientCtxInfo, aETag );
CleanupStack::Pop( self );
return self;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::ConstructL() loaded
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::ConstructL(
const MXIMPServiceInfo& aServiceInfo,
const MXIMPContextClientInfo& /*aClientCtxInfo*/,
const TDesC8& aETag )
{
DP_SDA("CPresencePluginConnection::ConstructL loaded");
iETag = aETag.AllocL();
iSession = CPresencePluginSession::NewL( aServiceInfo, *this );
// create instance from data class
iPresenceData = CPresencePluginData::NewL( *this,
aServiceInfo.IapId() );
DP_SDA("ConstructL create subscribed buddy list loaded ");
// create another virtual group for all subscribed buddyes
iSubscribedBuddys =
CPresencePluginVirtualGroup::NewL( *this,
KPresenceBuddyList(),
iPresenceData );
iAuth = CPresencePluginAuthorization::NewL( *this, iPresenceData );
iPublisher = CPresencePluginPublisher::NewL(
*this,
*iSession->SimpleConnection(),
iPresenceData );
iWatcher = CPresencePluginWatcher::NewL(
*this,
*iSession->SimpleConnection(),
iPresenceData );
iGroups = CPresencePluginGroups::NewL(
*this, iSubscribedBuddys, iPresenceData );
iPluginWinfo = CPresencePluginWinfo::NewL(
*this, *(iSession->SimpleConnection() ));
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::ConstructL()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::ConstructL(
const MXIMPServiceInfo& aServiceInfo,
const MXIMPContextClientInfo& /*aClientCtxInfo*/ )
{
DP_SDA("CPresencePluginConnection::ConstructL");
iETag = KNullDesC8().AllocL();
iSession = CPresencePluginSession::NewL( aServiceInfo, *this );
// create instance from data class
iPresenceData = CPresencePluginData::NewL( *this,
aServiceInfo.IapId() );
DP_SDA("ConstructL create subscribed buddy list");
// create another virtual group for all subscribed buddyes
iSubscribedBuddys =
CPresencePluginVirtualGroup::NewL(
*this, KPresenceBuddyList(), iPresenceData );
iAuth = CPresencePluginAuthorization::NewL( *this, iPresenceData );
iPublisher = CPresencePluginPublisher::NewL(
*this,
*iSession->SimpleConnection(),
iPresenceData );
iWatcher = CPresencePluginWatcher::NewL(
*this,
*iSession->SimpleConnection(),
iPresenceData );
iGroups = CPresencePluginGroups::NewL(
*this, iSubscribedBuddys, iPresenceData );
iPluginWinfo = CPresencePluginWinfo::NewL(
*this, *(iSession->SimpleConnection() ));
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::~CPresencePluginConnection()
// ---------------------------------------------------------------------------
//
CPresencePluginConnection::~CPresencePluginConnection()
{
DP_SDA("CPresencePluginConnection::~CPresencePluginConnection");
delete iSipPresentity;
iSipPresentity = NULL;
delete iPluginWinfo;
iPluginWinfo = NULL;
delete iWatcher;
iWatcher = NULL;
delete iPublisher;
iPublisher = NULL;
delete iAuth;
iAuth = NULL;
delete iGroups;
iGroups = NULL;
delete iSession;
iSession = NULL;
delete iImFeatures;
REComSession::FinalClose();
delete iSubscribedBuddys;
delete iPresenceData;
delete iETag;
iETag = NULL;
DP_SDA("CPresencePluginConnection::~CPresencePluginConnection end");
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PrimeHost
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::PrimeHost(
MXIMPProtocolConnectionHost& aHost )
{
DP_SDA("CPresencePluginConnection::PrimeHost");
iConnectionHost = &aHost;
iAuth->SetDataHost(
iConnectionHost->ProtocolPresenceDataHost().AuthorizationDataHost() );
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetOnlineBuddyGroup()
// ---------------------------------------------------------------------------
//
CPresencePluginVirtualGroup* CPresencePluginConnection::SubscribedContacts( )
{
return iSubscribedBuddys;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetSessionStatus()
// ---------------------------------------------------------------------------
//
TBool CPresencePluginConnection::GetSessionStatus( )
{
return iSession->ConnectionStatus();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::TupleIdGet()
// ---------------------------------------------------------------------------
//
TInt CPresencePluginConnection::GetTupleId() const
{
DP_SDA("CPresencePluginConnection::TupleIdGet");
return iOwnTupleId;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetEtag()
// ---------------------------------------------------------------------------
//
const TDesC8& CPresencePluginConnection::GetETag() const
{
DP_SDA("CPresencePluginConnection::GetETag");
if( !iETag )
{
DP_SDA2("CPresencePluginConnection::GetETag empty ??? %S", iConnectionArray->GetConnectionEtag() );
return KNullDesC8();
}
return *iETag;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::SetETag()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::SetETag( const TDesC8& aETag )
{
DP_SDA("CPresencePluginConnection::SetETag");
delete iETag;
iETag = NULL;
TRAP_IGNORE( ( iETag = aETag.AllocL() ) );
//Add etag also in connectionArray
iConnectionArray->SetConnectionETag( *iETag );
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::SetConnectionArray()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::SetConnectionArray(
CPresenceConnectionInfo* aArray )
{
DP_SDA("CPresencePluginConnection::SetConnectionArray");
iConnectionArray = aArray;
iConnectionArray->SetConnectionStatus( EActive );
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetConnectionArray()
// ---------------------------------------------------------------------------
//
CPresenceConnectionInfo* CPresencePluginConnection::GetConnectionArray( )
{
DP_SDA("CPresencePluginConnection::GetConnectionArray");
return iConnectionArray;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::TupleIdGet()
// ---------------------------------------------------------------------------
//
TInt32 CPresencePluginConnection::GetPresenceSetId() const
{
DP_SDA("CPresencePluginConnection::GetPresenceSetId");
return iSession->GetPresenceSetId();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::TupleIdGet()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::SetTupleId( const TInt aTupleId )
{
DP_SDA("CPresencePluginConnection::TupleIdSet");
iOwnTupleId = aTupleId;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetStopPublishState()
// ---------------------------------------------------------------------------
//
TBool CPresencePluginConnection::GetStopPublishState()
{
DP_SDA2("::GetStopPublishState = %d", (TInt)iStopPublishState );
return iStopPublishState;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::SetStopPublishState()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::SetStopPublishState( TBool aState )
{
DP_SDA2("SetStopPublishState : aState = %d ", (TInt)aState );
iStopPublishState = aState;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PresenceWatching
// ---------------------------------------------------------------------------
//
MProtocolPresenceDataHost& CPresencePluginConnection::ProtocolPresenceHost()
{
DP_SDA("CPresencePluginConnection::ProtocolPresenceHost");
return iConnectionHost->ProtocolPresenceDataHost();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PresenceWatching
// ---------------------------------------------------------------------------
//
MProtocolPresenceWatching& CPresencePluginConnection::PresenceWatching()
{
DP_SDA("CPresencePluginConnection::PresenceWatching");
return *iWatcher;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PresencePublishing
// ---------------------------------------------------------------------------
//
MProtocolPresencePublishing& CPresencePluginConnection::PresencePublishing()
{
return *iPublisher;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PresentityGroups
// ---------------------------------------------------------------------------
//
MProtocolPresentityGroups& CPresencePluginConnection::PresentityGroups()
{
return *iGroups;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PresenceAuthorization
// ---------------------------------------------------------------------------
//
MProtocolPresenceAuthorization&
CPresencePluginConnection::PresenceAuthorization()
{
DP_SDA2("CPresencePluginConnection::PresenceAuthorization %x", iAuth);
return *iAuth;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::InternalPresenceAuthorization
// ---------------------------------------------------------------------------
//
CPresencePluginAuthorization&
CPresencePluginConnection::InternalPresenceAuthorization()
{
DP_SDA2("CPresencePluginConnection::InternalPresenceAuthorization %x", iAuth);
return *iAuth;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::OpenSessionL
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::OpenSessionL(
const MXIMPContextClientInfo& /*aClientCtxInfo*/,
TXIMPRequestId aReqId )
{
DP_SDA("CPresencePluginConnection::OpenSessionL");
iGrantListSubs = ETrue;
iTerminatedCall = EFalse;
iXIMPId = aReqId;
iSession->OpenSessionL();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::OpenSessionL
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::OpenSessionL( const TInt& /*aSettingsId*/,
TXIMPRequestId aReqId )
{
DP_SDA("CPresencePluginConnection::OpenSessionL 2 ");
iXIMPId = aReqId;
iGrantListSubs = ETrue;
iTerminatedCall = EFalse;
iSession->OpenSessionL( );
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::CloseSession
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::CloseSession(
const MXIMPContextClientInfo& /*aContextClient*/,
TXIMPRequestId aReqId )
{
DP_SDA("CPresencePluginConnection::CloseSession begin");
TBool completeXimpRequestNow( EFalse );
iConnectionArray->DecreaseClientCount();
iXIMPId = aReqId;
// Client count canīt be negative. Increase if goes negative.
// This happens for example in network lost case.
// This method is called then because connection is terminated and
// for all clients which have done unbind. But here we cannot tell
// if this method is called by clients unbind or connection termination
// therefore this workaround needed.
if ( iConnectionArray->ClientCount() < 0 )
{
completeXimpRequestNow = ETrue;
iConnectionArray->IncreaseClientCount();
}
// In case there is no more clients we cannot complete Ximp request
// right away. We have to stop publish first, Ximp request completion is
// handled in RunL after that is done.
if( KErrNone == iConnectionArray->ClientCount() &&
(EActive == iConnectionArray->GetConnectionStatus()) )
{
completeXimpRequestNow = EFalse; // request is completed later in RunL
iGrantListSubs = EFalse;
//Start stopPublish request
DeRegister();
}
if ( !iStopPublishCall )
{
completeXimpRequestNow = ETrue;
}
if ( completeXimpRequestNow )
{
CompleteReq( iXIMPId, KErrNone );
}
DP_SDA("CPresencePluginConnection::CloseSession end");
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetSupportedFeaturesL
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::GetSupportedFeaturesL(
CDesC8Array& aFeatures ) const
{
DP_SDA("CPresencePluginConnection::GetSupportedFeaturesL");
// first empty the whole array
aFeatures.Reset();
using namespace NXIMPFeature::Presence;
aFeatures.AppendL( KPublish );
aFeatures.AppendL( KSubscribe );
aFeatures.AppendL( KUnsubscribe );
aFeatures.AppendL( KAddContact );
aFeatures.AppendL( KDeleteContact );
aFeatures.AppendL( KFetch );
aFeatures.AppendL( KBlock );
aFeatures.AppendL( KUnBlock );
if( iImFeatures )
{
using namespace NXIMPFeature::InstantMessage;
aFeatures.AppendL( KInstantMessage );
}
}
//*****************************************************************************
//* FROM MPresencePluginConnectionObs
//*****************************************************************************
// ---------------------------------------------------------------------------
// CPresencePluginConnection::CompleteReq()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::CompleteReq( TReqType aType, TInt aStatus )
{
DP_SDA("CPresencePluginConnection::CompleteReq");
// Return immediately if PrimeHost() is not called.
if ( !iConnectionHost )
{
DP_SDA("CPresencePluginConnection::CompleteReq !iConnectionHost");
iXIMPId = TXIMPRequestId();
return;
}
switch ( aType )
{
case EOpenSess:
{
DP_SDA("CPresencePluginConnection::CompleteReq EOpenSess");
iConnectionHost->HandleRequestCompleted( iXIMPId, aStatus );
iXIMPId = TXIMPRequestId();
//Set connection status to connection Array
iConnectionArray->SetConnectionStatus( EActive );
}
break;
case ECloseSess:
{
DP_SDA("CPresencePluginConnection::CompleteReq ECloseSess");
iConnectionArray->DecreaseClientCount();
CompleteReq( iXIMPId, aStatus );
iConnectionArray->SetConnectionStatus( ENotActive );
}
break;
default:
DP_SDA("CPresencePluginConnection::CompleteReq DEFAULT");
break;
};
DP_SDA("CPresencePluginConnection::CompleteReq end");
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::CompleteReq()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::CompleteReq(
TXIMPRequestId aReqId,
TInt aStatus )
{
DP_SDA2("CPresencePluginConnection::CompleteReq status %d", aStatus);
// Return immediately if PrimeHost() is not called.
if ( !iConnectionHost )
{
DP_SDA("CPresencePluginConnection::CompleteReq return");
return;
}
DP_SDA("CPresencePluginConnection::CompleteReq complete");
iConnectionHost->HandleRequestCompleted( aReqId, aStatus );
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::ObjectFactory()
// ---------------------------------------------------------------------------
//
MXIMPObjectFactory& CPresencePluginConnection::ObjectFactory()
{
DP_SDA("CPresencePluginConnection::ObjectFactory");
return iConnectionHost->ObjectFactory();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::Host
// ---------------------------------------------------------------------------
//
MXIMPProtocolConnectionHost* CPresencePluginConnection::Host()
{
DP_SDA("CPresencePluginConnection::Host");
return iConnectionHost;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection:CurrentDomain
// ---------------------------------------------------------------------------
//
TPtrC16 CPresencePluginConnection::CurrentDomain()
{
return iSession->CurrentDomain();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::CurrentSipPresentit8()
// ---------------------------------------------------------------------------
//
TPtrC8 CPresencePluginConnection::CurrentSipPresentity8()
{
return iSession->CurrentSipPresentity();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection:XdmUtilsL
// ---------------------------------------------------------------------------
//
CPresencePluginXdmUtils* CPresencePluginConnection::XdmUtilsL()
{
DP_SDA("CPresencePluginConnection::XdmUtilsL");
return iSession->XdmUtilsL();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::WinfoHandlerL()
// ---------------------------------------------------------------------------
//
CPresencePluginWinfo* CPresencePluginConnection::WinfoHandlerL()
{
DP_SDA("CPresencePluginConnection::WinfoHandlerL");
if ( !iPluginWinfo )
{
iPluginWinfo = CPresencePluginWinfo::NewL(
*this, *(iSession->SimpleConnection() ));
}
iPluginWinfo->SetHost( iConnectionHost );
return iPluginWinfo;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::WatcherHandlerL()
// ---------------------------------------------------------------------------
//
CPresencePluginWatcher* CPresencePluginConnection::WatcherHandlerL()
{
DP_SDA("CPresencePluginConnection::WatcherHandlerL");
if ( !iWatcher )
{
DP_SDA("CPresencePluginConnection::WatcherHandlerL: if ( !iWatcher )");
iWatcher = CPresencePluginWatcher::NewL(
*this,
*iSession->SimpleConnection(),
iPresenceData );
}
return iWatcher;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::WinfoTerminatedL()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::WinfoTerminatedL( TInt aReason )
{
DP_SDA("CPresencePluginConnection::WinfoTerminatedL");
// Pass the information to iAuth and iPublisher,
// so that they can call XIMP Plugin Data Host callbacks.
iAuth->WinfoTerminatedL( aReason );
iPublisher->WinfoTerminatedL( aReason );
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::WinfoNotification()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::WinfoNotification( MSimpleWinfo& aWinfo )
{
DP_SDA("CPresencePluginConnection::WinfoNotification");
TRAP_IGNORE( iPublisher->WinfoNotificationL( aWinfo ));
TRAP_IGNORE( iAuth->WinfoNotificationL( aWinfo ));
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetInterface()
// ---------------------------------------------------------------------------
//
TAny* CPresencePluginConnection::GetInterface(
TInt32 aInterfaceId,
TIfGetOps aOptions )
{
DP_SDA("CPresencePluginConnection::GetInterface()");
if ( aInterfaceId == GetInterfaceId() )
{
DP_SDA("CPresencePluginConnection::GetInterface()if ");
// caller wants this interface
return this;
}
if ( aOptions == MXIMPBase::EPanicIfUnknown )
{
DP_SDA("CPresencePluginConnection::GetInterface() panic");
User::Panic( KPluginName, KErrExtensionNotSupported );
}
return NULL;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetInterface()
// ---------------------------------------------------------------------------
//
const TAny* CPresencePluginConnection::GetInterface(
TInt32 aInterfaceId,
TIfGetOps aOptions ) const
{
DP_SDA("CPresencePluginConnection::GetInterface() const ");
if ( aInterfaceId == GetInterfaceId() )
{
DP_SDA("CPresencePluginConnection::GetInterface()2 ");
// caller wants this interface
return const_cast<CPresencePluginConnection*>(this);
}
if ( aOptions == MXIMPBase::EPanicIfUnknown )
{
DP_SDA("CPresencePluginConnection::GetInterface()panic 2");
User::Panic( KPluginName, KErrExtensionNotSupported );
}
return NULL;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetInterfaceId()
// ---------------------------------------------------------------------------
//
TInt32 CPresencePluginConnection::GetInterfaceId() const
{
DP_SDA("CPresencePluginConnection::GetInterfaceId() const ");
return MXIMPProtocolConnection::KInterfaceId;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::ProtocolPresenceFeatures()
// ---------------------------------------------------------------------------
//
MProtocolPresenceFeatures& CPresencePluginConnection::
ProtocolPresenceFeatures()
{
DP_SDA("CPresencePluginConnection::ProtocolPresenceFeatures() ");
return *this;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::PresenceObjectFactory()
// ---------------------------------------------------------------------------
//
MPresenceObjectFactory& CPresencePluginConnection::PresenceObjectFactoryOwn()
{
DP_SDA("CPresencePluginConnection::PresenceObjectFactoryOwn() ");
return iConnectionHost->
ProtocolPresenceDataHost().PresenceObjectFactory();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GrandListState()
// ---------------------------------------------------------------------------
//
TBool CPresencePluginConnection::GrandListState( )
{
DP_SDA2("GrandListState : iGrantListSubs = %d", (TInt)iGrantListSubs );
return iGrantListSubs;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::IsStopPublishCalled()
// ---------------------------------------------------------------------------
//
TBool CPresencePluginConnection::IsStopPublishCalled( )
{
DP_SDA("CPresencePluginConnection::IsStopPublishCalled");
return iStopPublishCall;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::TerminateConnectionL()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::TerminateConnectionL( )
{
DP_SDA("CPresencePluginConnection::TerminateConnectionL");
iConnectionHost->HandleConnectionTerminated( NULL );
iConnectionArray->SetConnectionStatus( ETerminated );
DP_SDA("CPresencePluginConnection::TerminateConnectionL Done");
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::DeRegister()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::DeRegister( )
{
DP_SDA("CPresencePluginConnection::Deregister");
DP_SDA(" -> CloseSession, delete permanent pres data");
TRAP_IGNORE( iPresenceData->DeletePresenceVariablesL( ServiceId() ) );
// Try to stop publish only if we have successfully published
if ( iPublisher->Published() )
{
DP_SDA("CloseSession call stopPublish");
TRAP_IGNORE( iPublisher->StopPublishL( iStatus ) );
iStopPublishCall = ETrue;
SetActive();
}
DP_SDA("CPresencePluginConnection::Deregister Done");
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::CreateImFeaturesPlugin()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::CreateImFeaturesPluginL( )
{
if ( !iImFeatures )
{
DP_SDA("Creating SimpleImPlugin");
CSimpleImFeatures::TSimpleImPluginInitParams imPluginInitParams(
*this,
*iSession->SimpleConnection(),
iSession->ServiceId() );
iImFeatures = static_cast<CSimpleImFeatures*> (
CProtocolImFeatures::NewL( TUid::Uid(KImplUidSimpleImPlugin),
&imPluginInitParams ) );
DP_SDA("Creating SimpleImPlugin done");
}
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::DeleteImFeaturesPlugin()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::DeleteImFeaturesPlugin( )
{
if ( iImFeatures )
{
DP_SDA("Deleting SimpleImPlugin");
delete iImFeatures;
iImFeatures = NULL;
REComSession::FinalClose();
DP_SDA("Deleting SimpleImPlugin done");
}
}
// ---------------------------------------------------------------------------
// CPresencePluginPublisher::DoCancel()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::DoCancel( )
{
DP_SDA("CPresencePluginConnection::DoCancel CANCEL");
}
// ---------------------------------------------------------------------------
// CPresencePluginSession::RunL()
// ---------------------------------------------------------------------------
//
void CPresencePluginConnection::RunL( )
{
DP_SDA("CPresencePluginConnection::RunL");
TInt status = iStatus.Int();
DP_SDA2("CPresencePluginConnection::RunL status %d", status );
if ( iStopPublishCall )
{
DP_SDA("CPresencePluginConnection::RunL complete");
iStopPublishCall = EFalse;
CompleteReq( iXIMPId, status );
DP_SDA("CPresencePluginConnection::RunL --> REMOVE CACHE");
iPresenceData->RemoveCacheL();
DP_SDA("CPresencePluginConnection::RunL --> Delete im plugin");
DeleteImFeaturesPlugin();
}
}
// ---------------------------------------------------------------------------
// CPresencePluginSession::RunError
// ---------------------------------------------------------------------------
//
TInt CPresencePluginConnection::RunError( TInt /*aError*/ )
{
DP_SDA("CPresencePluginConnection::RunError");
return KErrNone;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GroupsL()
// ---------------------------------------------------------------------------
//
CPresencePluginGroups& CPresencePluginConnection::GroupsL()
{
User::LeaveIfNull( iGroups );
return *iGroups;
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::ServiceId()
// ---------------------------------------------------------------------------
//
TInt& CPresencePluginConnection::ServiceId()
{
return iSession->ServiceId();
}
// ---------------------------------------------------------------------------
// CPresencePluginConnection::GetProtocolInterface()
// ---------------------------------------------------------------------------
//
TAny* CPresencePluginConnection::GetProtocolInterface( TInt aInterfaceId )
{
DP_SDA("CPresencePluginConnection::GetProtocolInterface");
if( aInterfaceId == CProtocolImFeatures::KInterfaceId )
{
TInt err( KErrNone );
if ( !iImFeatures )
{
DP_SDA(" --> Create im features plugin");
TRAP( err, CreateImFeaturesPluginL() );
}
if ( !err )
{
DP_SDA(" --> get interface");
return iImFeatures->GetInterface(
aInterfaceId, MXIMPBase::EPanicIfUnknown );
}
else
{
DP_SDA(" --> Creating im features plugin failed");
return NULL;
}
}
else
{
return NULL;
}
}
// End of file