// Copyright (c) 2005-2009 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:

//

/**

 @file

 @internalTechnology

*/

#ifndef SS_API_EXT_H

#define SS_API_EXT_H

#define SYMBIAN_NETWORKING_UPS

#include <es_sock.h>

#include <comms-infras/api_ext_msg.h>

#include <comms-infras/api_ext_list.h>

#include <elements/interfacetable.h>

#include <elements/responsemsg.h>

#include <ecom/ecom.h>

/**

   Forward declaration to avoid including mm_context.h

*/

namespace MeshMachine

{

    class TNodeContextBase;

}

namespace ESock

{

/**

	@internalTechnology

*/

class CExtItfMsgPluginInfo : public CBase

	{

public:

	IMPORT_C static CExtItfMsgPluginInfo* NewInstanceL(const STypeId& aTypeId);

	IMPORT_C ~CExtItfMsgPluginInfo();

	virtual const TImplementationProxy* ImplementationProxy() const = 0;

	virtual TInt ImplementationProxyTableSize() const = 0;

private:

	TUid iDestroyUid;

	};

/**

	@internalTechnology

*/

class CCommsApiExtResponder : public CBase

	{

public:

	IMPORT_C static void Complete(CCommsApiExtResponder*& aThis, TInt aError);

protected:

	IMPORT_C explicit CCommsApiExtResponder();

	IMPORT_C virtual ~CCommsApiExtResponder();

private:

	virtual void DoComplete(TInt aError) = 0;

	};

/**

	@internalTechnology

*/

class CCommsApiExtIpcResponder : public CCommsApiExtResponder 

	{

public:

	IMPORT_C static CCommsApiExtIpcResponder* NewL(const RMessage2& aMessage);

	IMPORT_C static CCommsApiExtIpcResponder* NewL(Elements::RResponseMsg& aResponseMsg);

protected:

	explicit CCommsApiExtIpcResponder(const RMessage2& aMessage)

	:	iResponseMsg(aMessage, aMessage.Int0(), 1, 2)

		{

		}

	explicit CCommsApiExtIpcResponder(Elements::RResponseMsg& aResponseMsg)

	:	iResponseMsg(aResponseMsg)

		{

		}

protected:

	IMPORT_C virtual void DoComplete(TInt aError);

protected:	

	Elements::RResponseMsg iResponseMsg;

	};

/**

   Specialised responder for Legacy messages. Wraps all RMessage2 functionallity,

   so that it cannot be completed without us knowing about it.

   @publishedPartner

   @released since tb92

*/

class RLegacyResponseMsg : public Elements::RResponseMsg

	{

public:

	IMPORT_C RLegacyResponseMsg();

	IMPORT_C explicit RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext);

	IMPORT_C explicit RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage, TInt aInterfaceId, TInt aRequestMsgParam = -1, TInt aResponseMsgParam = -1);

	IMPORT_C explicit RLegacyResponseMsg(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage, const Den::TApiExtIdentification& aInterfaceId, TInt aRequestMsgParam = -1, TInt aResponseMsgParam = -1);

	IMPORT_C void Complete(TInt aError) const;

	IMPORT_C void Panic(const TDesC& aCategory, TInt aReason) const;

	IMPORT_C TBool IsNull() const;

private:

	mutable Messages::TNodeCtxId iNodeAddr;

	};

/**

	@internalTechnology

*/

class CCommsApiExtLegacyIpcResponder : public CCommsApiExtResponder 

	{

public:

	IMPORT_C static CCommsApiExtLegacyIpcResponder* NewL(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage);

	IMPORT_C static CCommsApiExtLegacyIpcResponder* NewL(RLegacyResponseMsg& aResponseMsg);

protected:

	explicit CCommsApiExtLegacyIpcResponder(MeshMachine::TNodeContextBase& aContext, const RMessage2& aMessage)

		:	iResponseMsg(aContext, aMessage, aMessage.Int0(), 1, 2)

		{

		}

	explicit CCommsApiExtLegacyIpcResponder(RLegacyResponseMsg& aResponseMsg)

	:	iResponseMsg(aResponseMsg)

		{

		}

protected:

	IMPORT_C virtual void DoComplete(TInt aError);

protected:	

	RLegacyResponseMsg iResponseMsg;

	};

/**

	@internalTechnology

*/

class CCommsApiExtIpcOpenResponder : public CCommsApiExtIpcResponder 

	{

public:

	IMPORT_C static CCommsApiExtIpcOpenResponder* NewL(TSupportedCommsApiExt aInterfaceId, TSubSessionUniqueId aClientId, const RMessage2& aMessage);

protected:

	explicit CCommsApiExtIpcOpenResponder(TSupportedCommsApiExt aInterfaceId, TSubSessionUniqueId aClientId, const RMessage2& aMessage)

	:	CCommsApiExtIpcResponder(aMessage),

		iInterfaceId(aInterfaceId),

		iClientId(aClientId)

		{

		}

protected:

	IMPORT_C virtual void DoComplete(TInt aError);

protected:

	const TSupportedCommsApiExt iInterfaceId;

	const TSubSessionUniqueId iClientId;

	};

/**

	@internalTechnology

*/

class MExtensionInterfaceBase

	{

public:

	virtual void OpenExtensionInterface(TSubSessionUniqueId aClientId, const Messages::TRuntimeCtxId& aControlClient, CCommsApiExtResponder* aResponder) = 0;

	virtual void CloseExtensionInterface(TSubSessionUniqueId aClientId) = 0;

	virtual void CancelExtensionInterface(TSubSessionUniqueId aClientId) = 0;

	};

class AExtensionInterfaceThickBase : public MExtensionInterfaceBase

	{

public:

	// From MExtensionInterfaceBase

	IMPORT_C virtual void OpenExtensionInterface(TSubSessionUniqueId aClientId, const Messages::TRuntimeCtxId& aControlClient, CCommsApiExtResponder* aResponder);

	IMPORT_C virtual void CloseExtensionInterface(TSubSessionUniqueId aClientId);

	IMPORT_C virtual void CancelExtensionInterface(TSubSessionUniqueId aClientId);

	const Meta::STypeId& MsgImplTid() const

		{

		return iMsgImplTid;

		}

protected:

	IMPORT_C AExtensionInterfaceThickBase(const Meta::STypeId& aMsgImplTid);

	IMPORT_C virtual ~AExtensionInterfaceThickBase();

private:

	const Meta::STypeId iMsgImplTid;

	};

/**

	@internalTechnology

	Minimum functionality for an extension interface.  OpenL() 

	and Close() provided as a means of resource reservation and

	release.

*/

template <TInt32 MSG_IMPL_UID, TInt32 MSG_IMPL_TYPEID = 0>

class AExtensionInterfaceBase : public AExtensionInterfaceThickBase

	{

protected:

	AExtensionInterfaceBase()

		: AExtensionInterfaceThickBase(Meta::STypeId::CreateSTypeId(MSG_IMPL_UID,MSG_IMPL_TYPEID))

		{

		}

	//@todo - should AExtensionInterfaceThickBase have a gratuitous pure virtual to try to force use of this template? seems lame...

	};

/**

   @internalTechnology

*/

class AIPCClientInfo

	{

public:

	IMPORT_C TInt ClientUidType(TSubSessionUniqueId aSubSessionUniqueId, TUidType& aUidType) const;

	IMPORT_C TInt ClientSid(TSubSessionUniqueId aSubSessionUniqueId, TSecureId& aSid) const;

protected:

	IMPORT_C TInt OpenClientProcess(TSubSessionUniqueId aSubSessionUniqueId, RProcess& aProcess) const;

#ifndef SYMBIAN_NETWORKING_UPS

private:

#endif //SYMBIAN_NETWORKING_UPS

	TInt GetSubsessionOwnerInfo(TSubSessionUniqueId aSubSessionUniqueId, TProcessId& aProcessId, TUidType& aUidType, TThreadId& aThreadId) const;	

	};

/**

   @internalTechnology

*/

class AIPCClientPlatsecInfo : public AIPCClientInfo

    {

public:

    IMPORT_C TInt SecureId(TSubSessionUniqueId aSubSessionUniqueId, TSecureId& aResult) const;

    IMPORT_C TInt VendorId(TSubSessionUniqueId aSubSessionUniqueId, TVendorId& aResult) const;

    IMPORT_C TBool HasCapability(TSubSessionUniqueId aSubSessionUniqueId, const TCapability aCapability) const;

    IMPORT_C TInt  CheckPolicy(TSubSessionUniqueId aSubSessionUniqueId, const TSecurityPolicy& aPolicy) const;

#ifdef SYMBIAN_NETWORKING_UPS

    IMPORT_C TInt  GetProcessAndThreadId(TSubSessionUniqueId aSubSessionUniqueId, TProcessId& aProcessId, TThreadId& aThreadId) const;

#endif //SYMBIAN_NETWORKING_UPS

    };

} //namespace ESock

#endif // SS_API_EXT_H