--- /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 <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