diff -r 000000000000 -r c9bc50fca66e usbmgmt/usbmgrtest/usbcontrolapp/exampleusbcontrolapp/exampleusbcontrolapp.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/usbmgmt/usbmgrtest/usbcontrolapp/exampleusbcontrolapp/exampleusbcontrolapp.h Tue Feb 02 02:02:59 2010 +0200 @@ -0,0 +1,418 @@ +/* +* 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 +#include +#include +#include +#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 > iViewerMsgQ; + }; // CUsbControlAppEngine + +#endif // EXAMPLEUSBCONTROLAPP_H