/*

* 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:  adaptation for open source

*

*/

#include "cossprotocolplugin.h"

#include "cossprotocolconnection.h"

#include "ossprotocolpluginlogger.h"

#include <badesca.h>

#include <ecom/implementationproxy.h>

#include <ximpserviceinfo.h>

#include <ximpbase.h>

#include <ximpidentity.h>

#include <presenceinfo.h>

#include <ximpprotocolconnectionhost.h>

#include <ximpcontextclientinfo.h>

#include <featmgr.h>

#include <bldvariant.hrh>

#include "processlaunher.h"

#include "cuserafter.h"

_LIT ( KOSSProtocolPlugin, "COSSProtocolPlugin" );

_LIT ( KIsoserver, "isoserver.exe" );

// ======== MEMBER FUNCTIONS ========

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

// Key value pair table to identify correct constructor

// function for the requested interface.

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

//

const TImplementationProxy ImplementationTable[] =

	{

	IMPLEMENTATION_PROXY_ENTRY ( 0x101FB3E7, COSSProtocolPlugin::NewL )

	};

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

// Exported function to return the implementation proxy table

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy ( TInt& aTableCount )

	{

	aTableCount = sizeof ( ImplementationTable ) / sizeof ( TImplementationProxy );

	return ImplementationTable;

	}

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

// COSSProtocolPlugin::COSSProtocolPlugin()

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

//

COSSProtocolPlugin::COSSProtocolPlugin()

	{

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

	}

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

// COSSProtocolPlugin::ConstructL()

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

//

void COSSProtocolPlugin::ConstructL()

	{

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

	iIsoServerLauncher = CProcessLauncher::NewL ( KIsoserver );

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

	}

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

// COSSProtocolPlugin::NewLC()

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

//

COSSProtocolPlugin* COSSProtocolPlugin::NewLC()

	{

	LOGGER ( TXT ( "COSSProtocolPlugin::NewLC() Start" ) );

	COSSProtocolPlugin* self = COSSProtocolPlugin::NewL();

	CleanupStack::PushL ( self );

	LOGGER ( TXT ( "COSSProtocolPlugin::NewLC() End" ) );

	return self;

	}

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

// COSSProtocolPlugin::NewL()

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

//

COSSProtocolPlugin* COSSProtocolPlugin::NewL()

	{

	LOGGER ( TXT ( "=============================START=========================================" ) );

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

	COSSProtocolPlugin* self = new ( ELeave ) COSSProtocolPlugin();

	CleanupStack::PushL ( self );

	self->ConstructL();

	CleanupStack::Pop ( self );

	LOGGER ( TXT ( "COSSProtocolPlugin::NewL() End :Address of %d" ), &self );

	return self;

	}

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

// COSSProtocolPlugin::~COSSProtocolPlugin()

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

//

COSSProtocolPlugin::~COSSProtocolPlugin()

	{

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

	delete iIsoServerLauncher;

	iConnections.ResetAndDestroy();

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

	LOGGER ( TXT ( "=============================END=========================================" ) );

	}

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

// COSSProtocolPlugin::PrimeHost()

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

//

void COSSProtocolPlugin::PrimeHost ( MXIMPProtocolPluginHost& aHost )

	{

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

	iHost = &aHost;

	LOGGER ( TXT ( "COSSProtocolPlugin::PrimeHost() End" ) );

	}

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

// COSSProtocolPlugin::AcquireConnectionL()

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

//

MXIMPProtocolConnection& COSSProtocolPlugin::AcquireConnectionL (

    const MXIMPServiceInfo& aServiceInfo,

    const MXIMPContextClientInfo& aClientCtxInfo )

	{

	LOGGER ( TXT ( "COSSProtocolPlugin::AcquireConnectionL() Start" ) );

	TInt count = iConnections.Count();

	//COSSProtocolConnection* connection = NULL;

	// count how many connections are there in plugin

	// create new connection if array is empty

	// create existing connection based on check if it

	if ( count == 0 )

		{

		COSSProtocolConnection* connection = COSSProtocolConnection::NewL ( aServiceInfo, aClientCtxInfo );

		CleanupStack::PushL ( connection );

		iConnections.AppendL ( connection );

		CleanupStack::Pop ( connection );

		iIsoServerLauncher->LaunchProcessL();	

		LOGGER ( TXT ( "COSSProtocolPlugin::isoserver launched" ) );

		LOGGER ( TXT ( "COSSProtocolPlugin::AcquireConnectionL() End" ) );

		return *connection;

		}

	else if ( count == 1 )

		{

		LOGGER(TXT("COSSProtocolPlugin::AcquireConnectionL() End") );

		return *iConnections[0];

		}

	else

		{

		// even if there are many connection objects, we just return

		// the reference to the first connection object which is 

		// initiated by CCH

		return *iConnections[0];

		}

	}

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

// COSSProtocolPlugin::ReleaseConnection()

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

//

void COSSProtocolPlugin::ReleaseConnection ( MXIMPProtocolConnection& aConnection )

	{

	LOGGER ( TXT ( "COSSProtocolPlugin::ReleaseConnection() Start" ) );

	TInt connectionsCount = iConnections.Count();

	for ( TInt i ( connectionsCount - 1 ); i >= 0; i-- )

		{

		MXIMPProtocolConnection* tmp = iConnections[i];

		if ( tmp == &aConnection )

			{

			TRAP_IGNORE( iConnections[i]->ReleaseConnectionL() );

			delete iConnections[i];

			iConnections.Remove ( i );

			}

		}

	LOGGER ( TXT ( "COSSProtocolPlugin::ReleaseConnection() End" ) );

	}

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

// COSSProtocolPlugin::GetInterface()

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

//

TAny* COSSProtocolPlugin::GetInterface ( TInt32 aInterfaceId,

        TIfGetOps aOptions  )

	{

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

	if ( aInterfaceId == MXIMPProtocolPlugin::KInterfaceId )

		{

		MXIMPProtocolPlugin* self = this;

		return self;

		}

	if ( aOptions == MXIMPBase::EPanicIfUnknown )

		{

		User::Panic ( KOSSProtocolPlugin, KErrExtensionNotSupported );

		}

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

	return NULL;

	}

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

// COSSProtocolPlugin::GetInterface()

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

//

const TAny* COSSProtocolPlugin::GetInterface ( TInt32 aInterfaceId,

        TIfGetOps aOptions ) const

	{

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

	if ( aInterfaceId == MXIMPProtocolPlugin::KInterfaceId )

		{

		const MXIMPProtocolPlugin* self = this;

		return self;

		}

	if ( aOptions == MXIMPBase::EPanicIfUnknown )

		{

		User::Panic ( KOSSProtocolPlugin, KErrExtensionNotSupported );

		}

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

	return NULL;

	}

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

// COSSProtocolPlugin::GetInterfaceId() const

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

//

TInt32 COSSProtocolPlugin::GetInterfaceId() const

	{

	LOGGER ( TXT ( "COSSProtocolPlugin::GetInterface() without parameters Start-End" ) );

	return MXIMPProtocolPlugin::KInterfaceId;

	}

// End of file