/*
* Copyright (c) 1997-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:
*
*/

#ifndef __CDCACMCLASS_H__
#define __CDCACMCLASS_H__

#include <d32comm.h>
#include "CdcControlInterfaceRequestHandler.h"
#include "BreakController.h"
 
class MHostPushedChangeObserver;
class MBreakObserver;
class MReadObserver;
class MReadOneOrMoreObserver;
class MNotifyDataAvailableObserver;
class MWriteObserver;
class CCdcControlInterface;
class CCdcDataInterface;

NONSHARABLE_CLASS(CCdcAcmClass) :	public CBase, 
						public MCdcCommsClassRequestHandler
/**
 * The Communication Device Class Abstract Control Model class.
 * This class owns and controls the classes that handle the ACM data and 
 * control interfaces.
 * Instantiation of this class instantiates an ACM function.
 */
	{
public:
	enum TUsbParity ///< Serial port emulated parity setting. Taken directly 
		// from the spec.
		{
		EUsbParityNone	= 0,
		EUsbParityOdd	= 1,
		EUsbParityEven	= 2,
		EUsbParityMark	= 3,
		EUsbParitySpace = 4
		};

	enum TUsbStopBits ///< Serial port emulated stop bit setting. Taken 
		// directly from the spec.
		{
		EUsbStopBitOne		 = 0,
		EUsbStopBitOnePtFive = 1,
		EUsbStopBitTwo		 = 2
		};

	enum TUsbDataBits ///< Serial port emulated data bit setting. Taken 
		// directly from the spec.
		{
		EUsbDataBitsFive	= 5,
		EUsbDataBitsSix 	= 6,
		EUsbDataBitsSeven	= 7,
		EUsbDataBitsEight	= 8,
		EUsbDataBitsSixteen = 16
		};

	enum TUsbCommFeatureSelector
		{
		EUsbCommFeatureSelectAbstractState = 0x01,
		EUsbCommFeatureSelectCountryCode   = 0x02
		};

	enum TUsbAbstractStateBits
		{
		EUsbAbstractStateNoBits 	   = 0x0000,
		EUsbAbstractStateIdleSetting   = 0x0001,
		EUsbAbstractStateDataMultiplex = 0x0002
		};

	NONSHARABLE_CLASS(TUsbConfig)	///< Serial port emulated configuration
		{
	public:
		TUint		 iChangedMembers;
		TUint32 	 iRate; 			///< The line rate
		TUsbDataBits iDataBits; 		///< The number of data bits
		TUsbStopBits iStopBits; 		///< The number of stop bits
		TUsbParity	 iParity;			///< The parity
		};

public:
	static CCdcAcmClass* NewL(const TUint8 aProtocolNum, const TDesC16& aAcmControlIfcName, const TDesC16& aAcmDataIfcName);
	~CCdcAcmClass();

public:
	void SetCallback(MHostPushedChangeObserver* aCallback);
	void SetBreakCallback(MBreakObserver* aBreakCallback);
	void Read(MReadObserver& aObserver, TDes8 &aDes);
	void Read(MReadObserver& aObserver, TDes8 &aDes,TInt aLength);
	void ReadOneOrMore(MReadOneOrMoreObserver& aObserver, TDes8 &aDes);
	void ReadOneOrMore(MReadOneOrMoreObserver& aObserver, TDes8 &aDes, TInt aLength);
	void ReadCancel();
	void NotifyDataAvailable(MNotifyDataAvailableObserver& aObserver);
	void NotifyDataAvailableCancel();

	void Write(MWriteObserver& aObserver, const TDesC8& aDes);
	void Write(MWriteObserver& aObserver, const TDesC8& aDes, TInt aLength);
	void WriteCancel();

	TInt SendSerialState(TBool aRing, TBool aDsr, TBool aDcd);

public: // API for requesting a timed or locked break, and for turning the 
	// break off.
	TInt BreakRequest(CBreakController::TRequester aRequester, 
		CBreakController::TState aState,
		TTimeIntervalMicroSeconds32 aDelay = 0);

public: // used by the break controller
	TBool RingState() const;
	TBool DsrState() const;
	TBool DcdState() const;

	// Accessor for break state
	TBool BreakActive() const;
	void SetBreakActive(TBool aBreakActive);
	
	MHostPushedChangeObserver* Callback();
	MBreakObserver* BreakCallback();

private:
	CCdcAcmClass();
	void ConstructL(const TUint8 aProtocolNum);
	void ConstructL(const TUint8 aProtocolNum, const TDesC16& aControlIfcName, const TDesC16& aDataIfcName);

private: // from MCdcCommsClassRequestHandler
	virtual TInt HandleSendEncapCommand(const TDesC8& aData);
	virtual TInt HandleGetEncapResponse(TDes8& aReturnData);
	virtual TInt HandleSetCommFeature(const TUint16 aSelector, 
		const TDes8& aData);
	virtual TInt HandleGetCommFeature(const TUint16 aSelector, 
		TDes8& aReturnData);
	virtual TInt HandleClearCommFeature(const TUint16 aSelector);
	virtual TInt HandleSetLineCoding(const TDesC8& aData);
	virtual TInt HandleGetLineCoding(TDes8& aReturnData);
	virtual TInt HandleSetControlLineState(TBool aRtsState,TBool aDtrState);
	virtual TInt HandleSendBreak(TUint16 aDuration);

private: // utility
	void SetDefaultAcm(void);
	static void ConvertUsbConfigCodingToEpoc(const TUsbConfig& aUsbConfig, 
		TCommConfigV01& aEpocConfig);
	TInt HandleNewAbstractState(const TUint16 aAbstractState);
	TInt HandleNewCountryCode(const TUint16 aCountryCode);

private: // unowned
	MHostPushedChangeObserver* iCallback;
	MBreakObserver* iBreakCallback;

private: // owned
	CBreakController* iBreakController; ///< The BREAK state machine
	CCdcControlInterface* iControl; ///< The control interface
	CCdcDataInterface* iData; ///< The data interface

	TUint16 		iAcmState; ///< The multiplexed and idle state
	TUint16 		iCountryCode; ///< The country code from ISO 3166
	TUsbConfig		iUsbConfig; ///< The USB Configuration
	TBool			iRtsState; ///< The emulated RTS state
	TBool			iDtrState; ///< The eumlated DTR state

	TBool			iAcmDataMultiplex; ///< derived from bit D1 of iACMState
	TBool			iAcmIdleSetting; ///< derived from bit D0 of iACMState

	TBool			iRingState; 	///< Saved RING state
	TBool			iDsrState;		///< Saved DSR state
	TBool			iDcdState;		///< Saved DCD state

	TBool			iBreakActive;		///< Locally controlled BREAK state
	};

#endif // __CDCACMCLASS_H__