/*

* Copyright (c) 2007-2008 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:  oss protocol plugin connection

*

*/

#include "cossprotocolconnection.h"

#include <badesca.h>

#include <ximpcontextclientinfo.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpprotocolconnection.h>

#include <protocolpresencefeatures.h>

#include <ximpbase.h>

#include <ximpidentity.h>

#include <presenceinfo.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpserviceinfo.h>

#include <ximpfeatureinfo.h>

#include "cossprotocolconnectionmanager.h"

#include "cossprotocolpresencefeatures.h"

#include "cossprotocolimfeatures.h"

#include "ossprotocolpluginlogger.h"

#include "cossprotocolloginrequest.h"

#include "mossprotocolconnectionmanager.h"

#include <protocolsearchfeature.h>

#include "cossprotocolsearchfeatures.h"

#include "cossprotocollogoutrequest.h"

#include <ximperrors.hrh>

// ======== COSSProtocolConnection - MEMBER FUNCTIONS ========

// ---------------------------------------------------------------------------

// COSSProtocolConnection::COSSProtocolConnection()

// ---------------------------------------------------------------------------

//

COSSProtocolConnection::COSSProtocolConnection()

	{

	LOGGER ( TXT ( "COSSProtocolConnection::COSSProtocolConnection() Start-End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::ConstructL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::ConstructL (

    const MXIMPServiceInfo&  aServiceInfo ,

    const MXIMPContextClientInfo& aClientCtxInfo )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::ConstructL() Start" ) );

	PLUGIN_UNUSED_PARAM ( aClientCtxInfo );

	iConnMan = COSSProtocolConnectionManager::NewL();

	iConnMan->SetConnectionParamsL ( aServiceInfo.UserId(),

	                                 aServiceInfo.Password(),

	                                 aServiceInfo.IapId() );

	iPresFeatures = COSSProtocolPresenceFeatures::NewL ( *iConnMan );

	iImFeatures = COSSProtocolImFeatures::NewL ( *iConnMan );

	iSearchFeatures= COSSProtocolSearchFeature::NewL ( *iConnMan );

	LOGGER ( TXT ( "COSSProtocolConnection::ConstructL() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::NewL()

// ---------------------------------------------------------------------------

//

COSSProtocolConnection* COSSProtocolConnection::NewL (

    const MXIMPServiceInfo& aServiceInfo,

    const MXIMPContextClientInfo& aClientCtxInfo )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::NewL() Start" ) );

	COSSProtocolConnection* self = new ( ELeave ) COSSProtocolConnection;

	CleanupStack::PushL ( self );

	self->ConstructL ( aServiceInfo, aClientCtxInfo );

	CleanupStack::Pop ( self );

	LOGGER ( TXT ( "COSSProtocolConnection::NewL() End" ) );

	return self;

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::~COSSProtocolConnection()

// ---------------------------------------------------------------------------

//

COSSProtocolConnection::~COSSProtocolConnection()

	{

	LOGGER ( TXT ( "COSSProtocolConnection::~COSSProtocolConnection() Start" ) );

    delete iSearchFeatures;

	delete iConnMan;

	delete iPresFeatures;

	delete iImFeatures;

	LOGGER ( TXT ( "COSSProtocolConnection::~COSSProtocolConnection() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::GetInterface()

// ---------------------------------------------------------------------------

//

TAny* COSSProtocolConnection::GetInterface ( TInt32 aInterfaceId,

        TIfGetOps aOptions )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::GetInterface() Start" ) );

	if ( aInterfaceId == MXIMPProtocolConnection::KInterfaceId )

		{

		MXIMPProtocolConnection* self = this;

		return self;

		}

	if ( aOptions == MXIMPBase::EPanicIfUnknown )

		{

		User::Panic ( KOSSProtocolConnection, KErrExtensionNotSupported );

		}

	LOGGER ( TXT ( "COSSProtocolConnection::GetInterface() End" ) );

	return NULL;

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::GetInterface() const

// ---------------------------------------------------------------------------

//

const TAny* COSSProtocolConnection::GetInterface ( TInt32 aInterfaceId,

        TIfGetOps aOptions ) const

	{

	LOGGER ( TXT ( "COSSProtocolConnection::GetInterface() const Start" ) );

	if ( aInterfaceId == MXIMPProtocolConnection::KInterfaceId )

		{

		const MXIMPProtocolConnection* self = this;

		return self;

		}

	if ( aOptions == MXIMPBase::EPanicIfUnknown )

		{

		User::Panic ( KOSSProtocolConnection, KErrExtensionNotSupported );

		}

	LOGGER ( TXT ( "COSSProtocolConnection::GetInterface() const End" ) );

	return NULL;

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::GetInterfaceId() const

// ---------------------------------------------------------------------------

//

TInt32 COSSProtocolConnection::GetInterfaceId() const

	{

	LOGGER ( TXT ( "COSSProtocolConnection::GetInterfaceId() Start-End" ) );

	return MXIMPProtocolConnection::KInterfaceId;

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::PrimeHost()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::PrimeHost ( MXIMPProtocolConnectionHost& aHost )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::PrimeHost() Start" ) );

	iConnMan->SetHost ( aHost );

	LOGGER ( TXT ( "COSSProtocolConnection::PrimeHost() Start" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::OpenSessionL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::OpenSessionL (

    const MXIMPContextClientInfo& /*aClientCtxInfo*/,

    TXIMPRequestId aOpId )

	{

	if( iConntectionCreated )

		{

		iConntectionCreated++;

		iConnMan->HandleToHost().HandleRequestCompleted(aOpId,KErrNone);

		}

	else

		{

		LOGGER(TXT("COSSProtocolConnection::OpenSessionL \n"));

		COSSProtocolLoginRequest* req = 

		COSSProtocolLoginRequest::NewLC( *iConnMan, aOpId );

		req->IssueLoginRequestL();

		CleanupStack::Pop( req );	

		iConntectionCreated++;	

		}

	LOGGER ( TXT ( "COSSProtocolConnection::OpenSessionL() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::OpenSessionL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::OpenSessionL ( const TInt& aServiceId,

        TXIMPRequestId aReqId )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::OpenSessionLsettingsid \n" ) );

	if( iConntectionCreated )

		{

		iConntectionCreated++;

		iConnMan->HandleToHost().HandleRequestCompleted(aReqId,KErrNone);

		}

	else

		{

		TInt error = iConnMan->SetConnectionParamsL ( aServiceId );

		LOGGER ( TXT ( "COSSProtocolConnection::OpenSessionL settings id is %d" ), aServiceId );

		if( error == KErrNotFound )

			{

			iConnMan->HandleToHost().HandleRequestCompleted(aReqId,KXIMPErrServiceGeneralError);

			}

		else

			{

			COSSProtocolLoginRequest* req =

			COSSProtocolLoginRequest::NewLC ( *iConnMan, aReqId );	

			req->IssueLoginRequestL();

			CleanupStack::Pop ( req );

			iConntectionCreated++;	

			}

		}

	LOGGER ( TXT ( "COSSProtocolConnection::OpenSessionLsettingsid() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::OpenSessionL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::OpenSessionL (

    const MXIMPContextClientInfo& /*aContextClient*/,

    const TInt& /*aSettingsId*/,

    TXIMPRequestId /*aReqId*/ )

	{

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::CloseSession()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::CloseSession (

    const MXIMPContextClientInfo& /*aClientCtxInfo*/,

    TXIMPRequestId aOpId )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::CloseSession() Start" ) );

    iConntectionCreated--;

    // if server already disconnected no need to issue logout request

    TBool serverdisconnect = iConnMan->IsServerDisconnect();

    if(!iConntectionCreated && !serverdisconnect ) 

		{

		iRequestId = aOpId;

        TRAPD(error,LogoutRequestL(aOpId));

        	if( KErrNone != error )

        	{

			iConnMan->HandleToHost().HandleRequestCompleted(aOpId,error);

        	}

		}

	else

		{

		iConnMan->HandleToHost().HandleRequestCompleted(aOpId,KErrNone);

		}

	LOGGER ( TXT ( "COSSProtocolConnection::CloseSession() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::ReOpenSessionsL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::ReOpenSessionsL ( TXIMPRequestId /*aOpId*/ )

	{

	LOGGER ( TXT ( "COSSProtocolConnection::ReOpenSessionsL() Start" ) );

	LOGGER ( TXT ( "COSSProtocolConnection::ReOpenSessionsL() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::GetSupportedFeaturesL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::GetSupportedFeaturesL ( CDesC8Array& aFeatures ) const

	{

	LOGGER ( TXT ( "COSSProtocolConnection::GetSupportedFeaturesL() Start End" ) );

	// first empty the whole array

	aFeatures.Reset();

	// then add our features there

	// currently we are not doing any negotiation from the server for the supported features.

	// based on our implimentation we are hardcoding these values.

	// actual implimentatiion requires client server negotiation to tackle supported features.

	using namespace NXIMPFeature::Presence;

	aFeatures.AppendL( KPublish );

	aFeatures.AppendL( KFetch );

	aFeatures.AppendL( KSubscribe );    

	aFeatures.AppendL( KUnsubscribe );    

	aFeatures.AppendL( KAddContact  );

	aFeatures.AppendL( KDeleteContact  );	

	aFeatures.AppendL( KAvatar  );

	using namespace NXIMPFeature::InstantMessage;

	aFeatures.AppendL( KInstantMessage );

	using namespace NXIMPFeature::Search;

	aFeatures.AppendL( KSearch );

	LOGGER ( TXT ( "COSSProtocolConnection::GetSupportedFeaturesL" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::ProtocolPresenceFeatures()

// ---------------------------------------------------------------------------

//

MProtocolPresenceFeatures& COSSProtocolConnection::ProtocolPresenceFeatures()

	{

	LOGGER ( TXT ( "COSSProtocolConnection::ProtocolPresenceFeatures() Start " ) );

	return *iPresFeatures;

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::ProtocolImFeatures()

// ---------------------------------------------------------------------------

//

/*

CProtocolImFeatures* COSSProtocolConnection::ProtocolImFeatures()

	{

	LOGGER ( TXT ( "COSSProtocolConnection::ProtocolImFeatures() Start " ) );

	return iImFeatures;

	}*/

// ---------------------------------------------------------------------------

// COSSProtocolConnection::ReleaseConnectionL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::ReleaseConnectionL()

	{

	LOGGER ( TXT ( "COSSProtocolConnection::ReleaseConnectionL() Start " ) );

	if( iConnMan )

		{

		iConnMan->ReleaseConnectionL();

		}

	LOGGER ( TXT ( "COSSProtocolConnection::ReleaseConnectionL() End" ) );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::LogoutRequestL()

// ---------------------------------------------------------------------------

//

void COSSProtocolConnection::LogoutRequestL(TXIMPRequestId aOpId)

	{

		COSSProtocolLogoutRequest* req = COSSProtocolLogoutRequest::NewLC ( *iConnMan, aOpId );

		req->IssueLogoutRequestL();

		CleanupStack::Pop ( req );

	}

// ---------------------------------------------------------------------------

// COSSProtocolConnection::GetProtocolInterface

// ---------------------------------------------------------------------------

//	

TAny* COSSProtocolConnection::GetProtocolInterface(TInt aInterfaceId)

	{

	LOGGER ( TXT ( "COSSProtocolConnection::ProtocolImFeatures() Start " ) );

	//return iImFeatures->GetInterface(aInterfaceId, MXIMPBase::EPanicIfUnknown );

	if(aInterfaceId == CProtocolImFeatures::KInterfaceId)

		{

		return iImFeatures->GetInterface(aInterfaceId, MXIMPBase::EPanicIfUnknown ); 

		}

    else if(aInterfaceId == MProtocolSearchFeature::KInterfaceId)

		{

		return  iSearchFeatures->GetInterface(aInterfaceId, MXIMPBase::EPanicIfUnknown ) ;

		}		

    return NULL;

	}