// Copyright (c) 2006-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
 @internalComponent
*/


#ifndef CAGENTADAPTER_H
#define CAGENTADAPTER_H


#include <comms-infras/nifagt.h>
#include <comms-infras/ss_nodemessages.h> //TStateChange
#include <comms-infras/ss_nodemessages_legacy.h>
#include <comms-infras/ss_nodemessages_legacy_internal.h>
#include <comms-infras/ss_legacyinterfaces.h>
#include <comms-infras/responsemsg.h>
#include <comms-infras/nifprvar_internal.h>

class CAgentSubConnectionProvider;
class CNifAgentBase;
class CAgentCprDataAccess;
class CAgentAdapterSessionNotifier;

namespace ESock
	{
	class MPlatsecApiExt;
	}

/**
This is the Agent Adapter for new style NIFs/SCPRs/CPRs
It is created and owned by Link Layer MCPRs and passed to the left in
the BindTo messages. It is controlled ONLY by the SCPR.  

@internalTechnology
@prototype
*/
NONSHARABLE_CLASS(CAgentAdapter) : public CBase, private MNifAgentNotify, 
	public ESock::MLinkCprServiceChangeNotificationApiExt
    {
    friend class CAgentCprDataAccess;
    friend class CAgentConnectionProvider;
    friend class CAgentAdapterSessionNotifier;
    
public:
    enum TAgentState
        {
        EDisconnected,
        EConnecting,
        EConnected,
        EDisconnecting,
        EReconnecting
        };

    static CAgentAdapter* NewL(CAgentSubConnectionProvider& aAgentScpr, const TDesC& aAgentName);
    ~CAgentAdapter();

    void ConnectAgent(TAgentConnectType aConnectType);
    void DisconnectAgent(TInt aReason);
    void PromptForReconnect();
    void Authenticate(TDes& aUsername, TDes& aPassword);
    void CancelAuthenticate();

    // Database Access Methods
    TInt ReadNifName(TDes8& aNifName);
    TInt ReadPortName(TDes8& aPortName);
    TInt ReadIfParams(TDes8& aIfParams);
    TInt ReadIfNetworks(TDes8& aIfNetworks);

    TInt ReadNifName(TDes16& aNifName);
    TInt ReadPortName(TDes16& aPortName);
    TInt ReadIfParams(TDes16& aIfParams);
    TInt ReadIfNetworks(TDes16& aIfNetworks);

    TInt ReadExcessData(TDes8& aBuffer);
    TInt QueryIsDialIn();

    TInt NotificationToAgent(TFlowToAgentEventType aEvent, TAny* aInfo);

    inline const TAgentState AgentState() const;
    
    TInt Control(TUint aOptionLevel, TUint aOptionName, TDes8& aOption, ESock::MPlatsecApiExt* aPlatsecItf);
	void ClientAttachControl();
	
	// From MLinkCprServiceChangeNotificationApiExt Interface
	void RequestServiceChangeNotificationL(const Messages::TNodeId& aSender, ESock::RLegacyResponseMsg& aResponse);
	void CancelServiceChangeNotification(const Messages::TNodeId& aSender);
	
	  TBool IsAgentInErrorState() 
	    {
	    return iAgentErrorState;
	    }	
#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
	inline CNifAgentBase * Agent() const; 
#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

protected:
    CAgentAdapter(CAgentSubConnectionProvider& aAgentScpr);
    inline CAgentSubConnectionProvider& AgentScpr() const;

private:
    // MNifAgentNotify Interface
    virtual void ConnectComplete(TInt aStatus);
    virtual void ReconnectComplete(TInt aStatus);
    virtual void AuthenticateComplete(TInt aStatus);
    virtual void DisconnectComplete();
    virtual void AgentProgress(TInt aStage, TInt aError);
    virtual TInt Notification(TAgentToNifEventType aEvent, TAny* aInfo = NULL);
    virtual void AgentEvent(TNetworkAdaptorEventType aEventType, TUint aEvent, const TDesC8& aEventData, TAny* aSource=0);
    virtual void ServiceStarted();

    // MNifAgentNotify Interface (Empty implementations)
    virtual TInt IncomingConnectionReceived();
    virtual void ServiceClosed();
    virtual void AgentProgress(TSubConnectionUniqueId aSubConnectionUniqueId, TInt aStage, TInt aError);

    CNifFactory* FindOrCreateAgentFactoryL(const TDesC& aFilename);
    void CreateAgentL(const TDesC& aAgentName);
    
private:
    CAgentSubConnectionProvider& iAgentScpr;
    CNifAgentBase* iAgent;
    CNifAgentFactory* iFactory;
    TAgentState iAgentState; 
    TAgentConnectType iAgentConnectType;
    Elements::TStateChange iLastProgress;
	RPointerArray<CAgentAdapterSessionNotifier> iAgentAdapterSessionNotifiers;
	TBool iAgentErrorState;
    };


CAgentSubConnectionProvider& CAgentAdapter::AgentScpr() const
    {
    return iAgentScpr;
    }


const CAgentAdapter::TAgentState CAgentAdapter::AgentState() const
    {
    return iAgentState;
    }
    
#ifdef SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW
/**
 * Returns the agent 
 * @param none
 * @return Interface of the Nifman/Agent
**/
CNifAgentBase *CAgentAdapter::Agent() const
	{
   	return iAgent;
 	}
#endif //SYMBIAN_ADAPTIVE_TCP_RECEIVE_WINDOW

/**
 * This class is an Adapter to allow CAgentBase to Notify for
 * ServiceChangeNotification post-399.
 * 
 * @internalTechnology
 * @prototype */
NONSHARABLE_CLASS(CAgentAdapterSessionNotifier) : public CBase,
	public MAgentSessionNotify
    {
private:
	// Phase #1 Constructor
	CAgentAdapterSessionNotifier (CAgentAdapter* aCreator,
			const Messages::TNodeId& aSender);
	
	// Phase #2 Constructor
	void ConstructL (ESock::RLegacyResponseMsg& aResponseMsg);
public:
	// 2-Phase Static Constructor
	static CAgentAdapterSessionNotifier* NewL(CAgentAdapter* aCreator,
			const Messages::TNodeId& aSender,
			ESock::RLegacyResponseMsg& aResponseMsg);
	
	// 2-Phase Static Constructor. In this case it builds an "empty" Notifier.
	static CAgentAdapterSessionNotifier* NewL(CAgentAdapter* aCreator,
				const Messages::TNodeId& aSender);
	
	// Virtual Destructor
	virtual ~CAgentAdapterSessionNotifier();

	// Operator to allow the usage of Find(...) inside a R(Pointer)Array container
	virtual TBool operator== (const CAgentAdapterSessionNotifier& aOtherInstanceOfThisClass) const;
	
	// Return an Id that identify this Agent Session
	virtual const Messages::TNodeId& NodeId() const;

	// Implementation of MAgentSessionNotify interface
    virtual void ServiceChangeNotification(TUint32 aId, const TDesC& aType);
    
    virtual void CancelServiceChangeNotification(TInt aReason = KErrCancel);
    
private:
	/** This identify "who" asked for being notified. */
	Messages::TNodeId iSender;
	/** The RResponseMsg to use to answer(notify) the request. */
	ESock::RLegacyResponseMsg* iResponseMsg;
	/** The AgentAdapter which has created this object.
	 * This Pointer allows this CAgentAdapterSessionNotifier to remove
	 * itself from the Array in the Creator (Queue of S.C. Notifications) */
	CAgentAdapter* iCreator;
    };

#endif
// CAGENTADAPTER_H