/*

* Copyright (c) 2008-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 EXAMPLEUSBCONTROLAPP_H

#define EXAMPLEUSBCONTROLAPP_H

#include <e32cmn.h>

#include <e32base.h>

#include <usbman.h>

#include <e32property.h>

#include "e32msgqueue.h"

#include "usbcontrolappshared.h"

class MControlAppEngineWatcherInterface;

static const TInt KInactivityTimerPeriod = 10000000; // 10 sec

NONSHARABLE_CLASS(CIdPinWatcher) : public CActive

	{

public:

	static CIdPinWatcher* NewL(MControlAppEngineWatcherInterface& aControlAppEngine);

	~CIdPinWatcher();

private:

	CIdPinWatcher(MControlAppEngineWatcherInterface& aControlAppEngine);

	void ConstructL();

	void SubscribeForNotification();

	void DoCancel();

	void RunL();

private:

	MControlAppEngineWatcherInterface&	iParentControlAppEngine;

	RProperty							iIdPinProp;

	};

NONSHARABLE_CLASS(CVBusWatcher) : public CActive

	{

public:

	static CVBusWatcher* NewL(MControlAppEngineWatcherInterface& aControlAppEngine);

	~CVBusWatcher();

private:

	CVBusWatcher(MControlAppEngineWatcherInterface& aControlAppEngine);

	void ConstructL();

	void SubscribeForNotification();

	void DoCancel();

	void RunL();

private:

	MControlAppEngineWatcherInterface&	iParentControlAppEngine;

	RProperty							iVBusProp;

	};

NONSHARABLE_CLASS(CConnectionIdleWatcher) : public CActive

	{

public:

	static CConnectionIdleWatcher* NewL(MControlAppEngineWatcherInterface& aControlAppEngine);

	~CConnectionIdleWatcher();

private:

	CConnectionIdleWatcher(MControlAppEngineWatcherInterface& aControlAppEngine);

	void ConstructL();

	void SubscribeForNotification();

	void DoCancel();

	void RunL();

private:

	MControlAppEngineWatcherInterface&	iParentControlAppEngine;

	RProperty							iConnIdleProp;

	};

NONSHARABLE_CLASS(CMessageWatcher) : public CActive

	{

public:

	static CMessageWatcher* NewL(MControlAppEngineWatcherInterface& aControlAppEngine);

	~CMessageWatcher();

private:

	CMessageWatcher(MControlAppEngineWatcherInterface& aControlAppEngine);

	void ConstructL();

	void DoCancel();

	void RunL();

public:

	enum TMessageWatcherNotifications

		{

		EUsbMessageRequestSession,

		EUsbMessageSrpReceived,

		EErrUsbOtgSrpTimeout,

		EErrUsbOtgVbusError

		};

private:

	MControlAppEngineWatcherInterface&	iParentControlAppEngine;

	TInt								iMessage;

	};

NONSHARABLE_CLASS(MControlAppStateMachineInterface)

	{

public: // All the events that the state machine can receive from outside:

	//		Initial

	virtual void StartUp()					= 0;

	//		B-Stopped, B-Started

	virtual void IdPinPresent()				= 0;

	//		B-Stopped, A-Started

	virtual void VBusRise()					= 0;

	//		B-Started, A-Started

	virtual void VBusDrop()					= 0;

	//		A-Started, A-Stopped

	virtual void IdPinAbsent()				= 0;

	//		A-Started

	virtual void ConnectionIdle()			= 0;

	//		A-Started

	virtual void ConnectionActive()			= 0;

	//		B-Stopped, A-Stopped, B-Started, A-Started

	virtual void RequestSessionCalled()		= 0;

	//		B-Started

	virtual void SrpTimeout()				= 0;

	//		A-Stopped, A-Started

	virtual void SrpDetected()				= 0;

	//		A-Started, A-Stopped

	virtual void VBusError()				= 0;

	};

class MControlAppEngineInterface;

NONSHARABLE_CLASS(CControlAppStateMachine) : public CBase, public MControlAppStateMachineInterface

	{

// States are friend classes so that they can call private methods of the state machine.

// We don't want those private methods visible outside the state machine.

friend class CControlAppStateInitial;

friend class CControlAppStateBServicesStopped;

friend class CControlAppStateBServicesStarted;

friend class CControlAppStateAServicesStarted;

friend class CControlAppStateAServicesStopped;

friend class CInactivityTimer;

public:

	static CControlAppStateMachine* NewL(MControlAppEngineInterface& aControlAppEngine);

	~CControlAppStateMachine();

private:

	CControlAppStateMachine(MControlAppEngineInterface& aControlAppEngine);

	void ConstructL();

public: // From MControlAppStateMachineInterface, all the events that the state machine can receive from outside:

	void StartUp();

	void IdPinPresent();

	void VBusRise();

	void VBusDrop();

	void IdPinAbsent();

	void ConnectionIdle();

	void ConnectionActive();

	void RequestSessionCalled();

	void SrpTimeout();

	void SrpDetected();

	void VBusError();

private:

	enum TControlAppState

		{

		EStateInitial,

		EStateBServicesStopped,

		EStateBServicesStarted,

		EStateAServicesStopped,

		EStateAServicesStarted

		};

	void SetState(TControlAppState aState);

	void ResetInactivityTimer();

	void CancelInactivityTimer();

	void InactivityTimerExpired();

	NONSHARABLE_CLASS(CInactivityTimer) : public CActive

		{

	public:

		static CInactivityTimer* NewL(CControlAppStateMachine& aParentStateMachine);

		~CInactivityTimer();

		void Reset(); // Sets and resets timer. 

		// Timer cancelled by calling CActive::Cancel()

	private:

		CInactivityTimer(CControlAppStateMachine& aParentStateMachine);

		void ConstructL();		

		void DoCancel();

		void RunL();

	private:

		CControlAppStateMachine&	iParentStateMachine;

		RTimer						iTimer;

		};

// Base State

	NONSHARABLE_CLASS(CControlAppStateBase) : public CBase, public MControlAppStateMachineInterface

		{

	public:

		CControlAppStateBase(CControlAppStateMachine& aParentStateMachine);

		virtual void StartUp();

		virtual void IdPinPresent();	

		virtual void VBusRise();

		virtual void VBusDrop();

		virtual void IdPinAbsent();

		virtual void ConnectionIdle();

		virtual void ConnectionActive();

		virtual void InactivityTimerExpired();	// Internally generated event

		virtual void RequestSessionCalled();

		virtual void SrpTriggered();			// Internally generated event

		virtual void SrpTimeout();

		virtual void SrpDetected();

		virtual void VBusError();

	protected:

		CControlAppStateMachine& iParentStateMachine;

		};

// Initial State

	NONSHARABLE_CLASS(CControlAppStateInitial) : public CControlAppStateBase

		{

	public:

		CControlAppStateInitial(CControlAppStateMachine& aParentStateMachine);

		// No action on these events which will come from Watchers when they are created.

		// The Watchers will update the Engine with these values however and the 

		// State Machine can act on those values on receiving the StartUp event.

		void VBusRise();

		void VBusDrop();

		void IdPinPresent();

		void IdPinAbsent();

		void ConnectionIdle();

		void ConnectionActive();

		// Act on this events only:

		void StartUp();

		};

// B-ServicesStopped State

	NONSHARABLE_CLASS(CControlAppStateBServicesStopped) : public CControlAppStateBase

		{

	public:

		CControlAppStateBServicesStopped(CControlAppStateMachine& aParentStateMachine);

		void VBusRise();

		void IdPinPresent();

		void RequestSessionCalled();

		void VBusDrop();

		};

// B-ServicesStarted State

	NONSHARABLE_CLASS(CControlAppStateBServicesStarted) : public CControlAppStateBase

		{

	public:

		CControlAppStateBServicesStarted(CControlAppStateMachine& aParentStateMachine);

		void VBusDrop();	

		void SrpTriggered(); // Internally generated event

		void SrpTimeout();

		void VBusRise(); // called when SRP has been successful

		void IdPinPresent();

		void RequestSessionCalled();

		};

// A-ServicesStarted State

	NONSHARABLE_CLASS(CControlAppStateAServicesStarted) : public CControlAppStateBase

		{

	public:

		CControlAppStateAServicesStarted(CControlAppStateMachine& aParentStateMachine);

		void IdPinAbsent();

		void SrpDetected();

		void VBusRise();

		void ConnectionIdle();

		void ConnectionActive();

		void InactivityTimerExpired(); // Internally generated event

		void RequestSessionCalled();

		void VBusError();

		};

// A-ServicesStopped State

	NONSHARABLE_CLASS(CControlAppStateAServicesStopped) : public CControlAppStateBase

		{

	public:

		CControlAppStateAServicesStopped(CControlAppStateMachine& aParentStateMachine);

		void IdPinAbsent();

		void SrpDetected();

		void RequestSessionCalled();

		void VBusError();

		};

private:

	CControlAppStateBase*				iCurrentState;

	CControlAppStateInitial*			iStateInitial;

	CInactivityTimer*					iInactivityTimer;

	CControlAppStateBServicesStopped*	iStateBServicesStopped;

	CControlAppStateBServicesStarted*	iStateBServicesStarted;

	CControlAppStateAServicesStarted*	iStateAServicesStarted;

	CControlAppStateAServicesStopped*	iStateAServicesStopped;

private:

	MControlAppEngineInterface&			iParentControlAppEngine;

	TBool								iTriggerSrp;

	};

NONSHARABLE_CLASS(MShutdownInterface)

	{

public:

	virtual void Stop() const = 0;

	};

class CUsbControlAppEngine;

NONSHARABLE_CLASS(CShutdownMonitor) : public CActive

	{

public:

	static CShutdownMonitor* NewL(MShutdownInterface& aControlAppEngine);

	~CShutdownMonitor();

private:

	CShutdownMonitor(MShutdownInterface& aControlAppEngine);

	void ConstructL();

	// From CActive

	void DoCancel();

	void RunL();

private:

	RProperty				iShutdownProp;

	MShutdownInterface&		iParentControlAppEngine;

	};

NONSHARABLE_CLASS(MControlAppEngineInterface)

	{

public: // All the services the Engine provides that the State Machine calls on:

	virtual TInt GetIdPin()									= 0;

	virtual TInt GetVBus()									= 0;

	virtual TInt StopUsbServices()							= 0;

	virtual TInt StartUsbServices()							= 0;

	virtual TInt EnableFunctionDriverLoading()				= 0;

	virtual void DisableFunctionDriverLoading()				= 0;

	virtual TInt BusRequest()								= 0;

	virtual TInt BusDrop()									= 0;

	virtual TInt BusRespondSrp()							= 0;

	virtual TInt ClearVBusError()							= 0;

	virtual void DisplayUserMessage(const TDesC& aUserMsg)	= 0;

	};

NONSHARABLE_CLASS(MControlAppEngineWatcherInterface)

	{

public: // All the methods the Engine provides that the Watcher classes can call:

	virtual void SetIdPin(TInt aIdPin)				= 0;

	virtual void SetVBus(TInt aVBus)				= 0;

	virtual void SetConnectionIdle(TInt aConnIdle)	= 0;

	virtual void MessageReceived(CMessageWatcher::TMessageWatcherNotifications aMessageNotification) = 0;

	virtual RUsb& Usb()								= 0;

	};

NONSHARABLE_CLASS(CUsbControlAppEngine) : public CBase, public MControlAppEngineInterface, public MControlAppEngineWatcherInterface, public MShutdownInterface

	{

public:

	static CUsbControlAppEngine* NewLC();

	~CUsbControlAppEngine();

	// Start/stop Active Scheduler

	void Start();     

	void Stop() const;

	// From MControlAppEngineWatcherInterface, Watcher callbacks

	void SetIdPin(TInt aIdPin);

	void SetVBus(TInt aVBus);

	void SetConnectionIdle(TInt aConnIdle);

	void MessageReceived(CMessageWatcher::TMessageWatcherNotifications aMessageNotification);

	RUsb& Usb();

	// Getters

	TInt GetIdPin();

	TInt GetVBus();

	// From MControlAppEngineInterface, called by State Machine

	TInt StopUsbServices();

	TInt StartUsbServices();

	TInt EnableFunctionDriverLoading();

	void DisableFunctionDriverLoading();

	TInt BusRequest();

	TInt BusDrop();

	TInt BusRespondSrp();

	TInt ClearVBusError();

	void DisplayUserMessage(const TDesC& aUserMsg);

private:

	CUsbControlAppEngine();

	void ConstructL();

private: 

	// Watcher related

	CIdPinWatcher* 			iIdPinWatcher;

	CVBusWatcher* 			iVBusWatcher;

	CConnectionIdleWatcher* iConnIdleWatcher;

	CMessageWatcher*		iMessageWatcher;

	TInt					iIdPin;

	TInt					iVBus;

	TInt					iConnIdle;

	// Resources

	CControlAppStateMachine*	iStateMachine;

	CShutdownMonitor*			iShutdownMonitor;

	RUsb						iUsb;

	//    RMsgQueue between exampleusbcontrolapp.exe & usbviewer.exe for displaying user messages

	RMsgQueue<TBuf<KViewerNumCharactersOnLine> >	iViewerMsgQ; 

	}; // CUsbControlAppEngine

#endif // EXAMPLEUSBCONTROLAPP_H