/*

* 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:

*

*/

#include "exampleusbcontrolapp.h"

#include <e32cons.h>

#include <e32debug.h>

// For Message Watcher

#include <d32otgdi_errors.h>

#include <d32usbdi_errors.h>

#include <usb/usbshared.h>

#define LOG(A,B)	RDebug::Print(_L("UsbControlApp: " L##A),B)

#define PNT(A)		RDebug::Print(_L("UsbControlApp: " L##A))

#define BLN(A)		RDebug::Print(_L("" L##A))

#define PANIC		Panic(__LINE__)

#ifdef __USB_DEBUG__

#define DBG_PANIC	Panic(__LINE__)

#else

#define DBG_PANIC

#endif

void Panic(TInt aLine)

	{

	RDebug::Printf("UsbControlApp: PANIC line=%d", aLine);

	User::Panic(_L("USBCONTROLAPP"), aLine);

	}

void RunAppL()

	{

	CUsbControlAppEngine* engine = CUsbControlAppEngine::NewLC();

	engine->Start();

	CleanupStack::PopAndDestroy(engine);

	}

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup = CTrapCleanup::New();

	CActiveScheduler* activeScheduler = new CActiveScheduler;

	TInt err = KErrNoMemory;

	if(cleanup && activeScheduler)

		{

		CActiveScheduler::Install(activeScheduler);

		PNT("*** UsbControlApp E32Main ***\n");

		TRAP(err, RunAppL());

		}

	delete activeScheduler;

	delete cleanup;

	__UHEAP_MARKEND;

	return err;

	}

CShutdownMonitor* CShutdownMonitor::NewL(MShutdownInterface& aControlAppEngine)

	{

	CShutdownMonitor* self = new(ELeave) CShutdownMonitor(aControlAppEngine);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CShutdownMonitor::CShutdownMonitor(MShutdownInterface& aControlAppEngine)

	: CActive(EPriorityLow) // Low so all notifications that want to be serviced will be done first

	, iParentControlAppEngine(aControlAppEngine)

	{

	CActiveScheduler::Add(this);

	}

void CShutdownMonitor::ConstructL()

	{

	// Monitor the KUsbControlAppShutdownKey property to tell us when to shut down

	TInt err = iShutdownProp.Attach(KUidUsbControlAppCategory, KUsbControlAppShutdownKey);

	LOG("CShutdownMonitor::ConstructL	 iShutdownProp.Attach() => %d", err);

	User::LeaveIfError(err);

	iShutdownProp.Subscribe(iStatus);

	SetActive();

	TInt val;

	// Make sure the cuurent value is 0 - shut down when this changes to 1

	err = iShutdownProp.Get(val);

	LOG("CShutdownMonitor::ConstructL()	 iShutdownProp.Get(val)		val => %d", val);

	LOG("CShutdownMonitor::ConstructL()	 iShutdownProp.Get(val)		err => %d", err);

	User::LeaveIfError(err);

	__ASSERT_ALWAYS(val==0, PANIC);

	}

CShutdownMonitor::~CShutdownMonitor()

	{

	iShutdownProp.Close();

	}

void CShutdownMonitor::RunL()

	{

	// Request to shut everything down made in USB Aware App

	TInt val;

	TInt err = iShutdownProp.Get(val);

	LOG("CShutdownMonitor::RunL	 iShutdownProp.Get(val) err => %d", err);

	LOG("CShutdownMonitor::RunL	 iShutdownProp.Get(val) val => %d", val);

	Cancel(); // Not interested in any more notifications

	iParentControlAppEngine.Stop(); // Stopping Active Scheduler will results in the destructor getting called

	}

void CShutdownMonitor::DoCancel()

	{

	iShutdownProp.Cancel();

	}

CUsbControlAppEngine* CUsbControlAppEngine::NewLC()

	{

	CUsbControlAppEngine* self = new(ELeave) CUsbControlAppEngine();

	CleanupStack::PushL(self);

	self->ConstructL();

	PNT("\nConstructed Control App\n");

	return self;

	}

CUsbControlAppEngine::~CUsbControlAppEngine()

	{

	PNT("\nClosing Control App\n");

	iViewerMsgQ.Close();

	delete iShutdownMonitor;

	delete iStateMachine;

	delete iMessageWatcher;

	delete iConnIdleWatcher;

	delete iVBusWatcher;

	delete iIdPinWatcher;

	iUsb.Close();

	}

CUsbControlAppEngine::CUsbControlAppEngine()

	{

	}

void CUsbControlAppEngine::ConstructL()

	{

	// Start session to USBMAN

	TInt err = iUsb.Connect();

	LOG("CUsbControlAppEngine::ConstructL()   iUsb.Connect()   err=%d", err);

	User::LeaveIfError(err);

	// Set this as the single controller of USBMAN

	err = iUsb.SetCtlSessionMode(ETrue);

	LOG("CUsbControlAppEngine::ConstructL()   iUsb.SetCtlSessionMode(ETrue)   err=%d", err);

	User::LeaveIfError(err);

	iStateMachine	= CControlAppStateMachine::NewL(*this);

	// Create Watcher Active Objects to monitor events

	iIdPinWatcher	= CIdPinWatcher::NewL(*this);

	iVBusWatcher	= CVBusWatcher::NewL(*this);

	iConnIdleWatcher= CConnectionIdleWatcher::NewL(*this);

	iMessageWatcher	= CMessageWatcher::NewL(*this);

	iShutdownMonitor = CShutdownMonitor::NewL(*this);

	// Create message queue between exampleusbcontrolapp.exe & usbviewer.exe for showing user messages

	err = iViewerMsgQ.CreateGlobal(KControlAppViewerMsgQName, KControlAppViewerMsgQSlots);

	LOG("CUsbControlAppEngine::ConstructL()	 iViewerMsgQ.CreateGlobal		err => %d", err);

	User::LeaveIfError(err);

	// Stop USB services if they are started so system can start from a known state

	err = StopUsbServices();

	LOG("CUsbControlAppEngine::ConstructL()   StopUsbServices()		err=%d", err);

	User::LeaveIfError(err);

	// Last thing - allow State Machine to find a main state by sending it a StartUp event

	iStateMachine->StartUp();

	}

void CUsbControlAppEngine::Start()

	{

	CActiveScheduler::Start(); // Get everything running

	}

void CUsbControlAppEngine::Stop() const

	{

	CActiveScheduler::Stop();

	}

// Called by State Machine

TInt CUsbControlAppEngine::StopUsbServices()

	{

	TRequestStatus status;

	iUsb.TryStop(status);

	User::WaitForRequest(status);

	LOG("CUsbControlAppEngine::StopUsbServices()   status.Int()=%d", status.Int());

	return status.Int();

	}

TInt CUsbControlAppEngine::StartUsbServices()

	{

	const TInt KACMPersonality = 1;

	TRequestStatus status;

	iUsb.TryStart(KACMPersonality, status);

	User::WaitForRequest(status);

	LOG("CUsbControlAppEngine::StartUsbServices()   status.Int()=%d", status.Int());

	return status.Int();

	}

TInt CUsbControlAppEngine::EnableFunctionDriverLoading()

	{

	TInt err = iUsb.EnableFunctionDriverLoading();

	LOG("CUsbControlAppEngine::EnableFunctionDriverLoading()   err=%d", err);

	return err;

	}

void CUsbControlAppEngine::DisableFunctionDriverLoading()

	{

	PNT("CUsbControlAppEngine::DisableFunctionDriverLoading()\n");

	iUsb.DisableFunctionDriverLoading();

	}

TInt CUsbControlAppEngine::BusRequest()

	{

	TInt err = iUsb.BusRequest();

	LOG("CUsbControlAppEngine::BusRequest()   err=%d", err);

	return err;

	}

TInt CUsbControlAppEngine::BusDrop()

	{

	TInt err = iUsb.BusDrop();

	LOG("CUsbControlAppEngine::BusDrop()   err=%d", err);

	return err;

	}

TInt CUsbControlAppEngine::BusRespondSrp()

	{

	TInt err = iUsb.BusRespondSrp();

	LOG("CUsbControlAppEngine::BusRespondSrp()   err=%d", err);

	return err;

	}

TInt CUsbControlAppEngine::ClearVBusError()

	{

	TInt err = iUsb.BusClearError();

	LOG("CUsbControlAppEngine::ClearVBusError()   err=%d", err);

	return err;

	}

// Must divide the user message to be displayed into segments that will fit on the usbviewer.exe window.

// Because the viewer.exe displays Events in a downward scrolling list with the latest entry at the top,

// the user message segments must be sent in reverse order.

void CUsbControlAppEngine::DisplayUserMessage(const TDesC& aUserMsg)

	{

	LOG("CUsbControlAppEngine::DisplayUserMessage(\"%S\")\n", &aUserMsg);

	TInt msgLength = aUserMsg.Length();

	TInt lastBitLength = msgLength % KEventLineMsgNumCharacters;

	LOG("CUsbControlAppEngine::DisplayUserMessage	 lastBitLength => %d", lastBitLength);

	if (lastBitLength) // show the 'last bit' segment of the message which is not divisible by KEventLineMsgNumCharacters

		{

		TBuf<KEventLineNumCharacters> buf(KPrefix);

		TPtrC text = aUserMsg.Right(lastBitLength);

		buf.Append(text);

		LOG("CUsbControlAppEngine::DisplayUserMessage	 iViewerMsgQ.Send(buf) buf => %S", &buf);

		TInt err = iViewerMsgQ.Send(buf);

		LOG("CUsbControlAppEngine::DisplayUserMessage	 iViewerMsgQ.Send(buf) err => %d", err);

		}

	msgLength -= lastBitLength;

	while (msgLength > 0) // show the segments of the message which are exactly divisible by KEventLineMsgNumCharacters

		{

		// TBuf of length KEventLineNumCharacters = KPrefix of length 2 + Mid bit of length KEventLineMsgNumCharacters

		TBuf<KEventLineNumCharacters> buf(KPrefix);

		TPtrC text = aUserMsg.Mid(msgLength-KEventLineMsgNumCharacters, KEventLineMsgNumCharacters);

		buf.Append(text);

		LOG("CUsbControlAppEngine::DisplayUserMessage	 iViewerMsgQ.Send(buf) buf => %S", &buf);

		TInt err = iViewerMsgQ.Send(buf);

		LOG("CUsbControlAppEngine::DisplayUserMessage	 iViewerMsgQ.Send(buf) err => %d", err);		

		msgLength -= KEventLineMsgNumCharacters;

		}

	}

// Called by Watchers. Will forward as event to State Machine.

void CUsbControlAppEngine::SetIdPin(TInt aIdPin)

	{

	PNT("CUsbControlAppEngine::SetIdPin()\n");

	iIdPin = aIdPin;

	__ASSERT_ALWAYS(iStateMachine, PANIC);

	aIdPin ? iStateMachine->IdPinPresent() : iStateMachine->IdPinAbsent();

	}

void CUsbControlAppEngine::SetVBus(TInt aVBus)

	{

	PNT("CUsbControlAppEngine::SetVBus()\n");

	iVBus = aVBus;

	__ASSERT_ALWAYS(iStateMachine, PANIC);

	aVBus ? iStateMachine->VBusRise() : iStateMachine->VBusDrop();

	}

void CUsbControlAppEngine::SetConnectionIdle(TInt aConnIdle)

	{

	PNT("CUsbControlAppEngine::SetConnectionIdle()\n");

	iConnIdle = aConnIdle;

	__ASSERT_ALWAYS(iStateMachine, PANIC);

	aConnIdle ? iStateMachine->ConnectionIdle() : iStateMachine->ConnectionActive();

	}

void CUsbControlAppEngine::MessageReceived(CMessageWatcher::TMessageWatcherNotifications aMessageNotification)

	{

	switch(aMessageNotification)

		{

	case CMessageWatcher::EUsbMessageRequestSession :

		PNT("CUsbControlAppEngine::MessageReceived()	EUsbMessageRequestSession\n");

		iStateMachine->RequestSessionCalled();

		break;

	case CMessageWatcher::EUsbMessageSrpReceived :

		PNT("CUsbControlAppEngine::MessageReceived()	EUsbMessageSrpReceived\n");

		iStateMachine->SrpDetected();

		break;

	case CMessageWatcher::EErrUsbOtgSrpTimeout :

		PNT("CUsbControlAppEngine::MessageReceived()	EErrUsbOtgSrpTimeout\n");

		iStateMachine->SrpTimeout();

		break;

	case CMessageWatcher::EErrUsbOtgVbusError :

		PNT("CUsbControlAppEngine::MessageReceived()	EErrUsbOtgVbusError\n");

		iStateMachine->VBusError();

		break;

	default:

		PANIC;

		}

	}

RUsb& CUsbControlAppEngine::Usb()

	{

	return iUsb;

	}

TInt CUsbControlAppEngine::GetIdPin()

	{

	return iIdPin;

	}

TInt CUsbControlAppEngine::GetVBus()

	{

	return iVBus;

	}

CControlAppStateMachine* CControlAppStateMachine::NewL(MControlAppEngineInterface& aControlAppEngine)

	{

	CControlAppStateMachine* self = new(ELeave) CControlAppStateMachine(aControlAppEngine);

	CleanupStack::PushL(self);

	self->ConstructL();

	PNT("CControlAppStateMachine::NewL\n");

	CleanupStack::Pop(self);

	return self;

	}

CControlAppStateMachine::~CControlAppStateMachine()

	{

	delete iStateAServicesStopped;

	delete iStateAServicesStarted;

	delete iStateBServicesStarted;

	delete iStateBServicesStopped;

	delete iStateInitial;

	delete iInactivityTimer;

	}

CControlAppStateMachine::CControlAppStateMachine(MControlAppEngineInterface& aControlAppEngine)

	: iParentControlAppEngine(aControlAppEngine)

	, iTriggerSrp(EFalse)

	{

	}

void CControlAppStateMachine::ConstructL()

	{

	iInactivityTimer		= CInactivityTimer::NewL(*this);

	iStateInitial			= new(ELeave) CControlAppStateInitial(*this);

	iStateBServicesStopped	= new(ELeave) CControlAppStateBServicesStopped(*this);

	iStateBServicesStarted	= new(ELeave) CControlAppStateBServicesStarted(*this);

	iStateAServicesStarted	= new(ELeave) CControlAppStateAServicesStarted(*this);

	iStateAServicesStopped	= new(ELeave) CControlAppStateAServicesStopped(*this);

	SetState(EStateInitial);

	}

void CControlAppStateMachine::SetState(TControlAppState aState)

	{

	TPtrC StateString(NULL, 0);

	//               123456789

	_LIT(KInitial,	" Initial ");

	_LIT(KBStopped, "B-Stopped");

	_LIT(KBStarted, "B-Started");

	_LIT(KAStopped, "A-Stopped");

	_LIT(KAStarted, "A-Started");

	switch(aState)

		{

	case EStateInitial :			

		StateString.Set(KInitial);		

		iCurrentState = iStateInitial;		

		break;

	case EStateBServicesStopped :	

		StateString.Set(KBStopped);		

		iCurrentState = iStateBServicesStopped;		

		break;

	case EStateBServicesStarted :	

		StateString.Set(KBStarted);		

		iCurrentState = iStateBServicesStarted;		

		break;

	case EStateAServicesStopped :	

		StateString.Set(KAStopped);		

		iCurrentState = iStateAServicesStopped;		

		break;

	case EStateAServicesStarted :	

		StateString.Set(KAStarted);		

		iCurrentState = iStateAServicesStarted;	

		break;

	default :	PANIC;

		}

	//                                         (123456789)  ***

	BLN("");

	PNT("******************************************************");

	LOG("***  CControlAppStateMachine::SetState(%S)  ***", &StateString);

	PNT("******************************************************");

	BLN("");

	}

// State Machine's publicly visible interface...

//		Initial

void CControlAppStateMachine::StartUp()

	{

	PNT("CControlAppStateMachine::StartUp() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->StartUp();

	}

//		B-Stopped, B-Started

void CControlAppStateMachine::IdPinPresent()

	{

	PNT("CControlAppStateMachine::IdPinPresent() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->IdPinPresent(); 

	}

//		B-Stopped, A-Started

void CControlAppStateMachine::VBusRise()

	{

	PNT("CControlAppStateMachine::VBusRise() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state		

	iCurrentState->VBusRise();

	}

//		B-Started, A-Started

void CControlAppStateMachine::VBusDrop()

	{

	PNT("CControlAppStateMachine::VBusDrop() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->VBusDrop();

	}

//		A-Started, A-Stopped

void CControlAppStateMachine::IdPinAbsent()

	{

	PNT("CControlAppStateMachine::IdPinAbsent() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->IdPinAbsent();

	}

//		A-Started

void CControlAppStateMachine::ConnectionIdle()

	{

	PNT("CControlAppStateMachine::ConnectionIdle() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->ConnectionIdle();

	}

//		A-Started

void CControlAppStateMachine::ConnectionActive()

	{

	PNT("CControlAppStateMachine::ConnectionActive() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->ConnectionActive();

	}

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

void CControlAppStateMachine::RequestSessionCalled()

	{

	PNT("CControlAppStateMachine::RequestSessionCalled() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->RequestSessionCalled();

	}

//		B-Started

void CControlAppStateMachine::SrpTimeout()

	{

	PNT("CControlAppStateMachine::SrpTimeout() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->SrpTimeout();

	}

//		A-Stopped

void CControlAppStateMachine::SrpDetected()

	{

	PNT("CControlAppStateMachine::SrpDetected() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->SrpDetected();

	}

//		A-Started, A-Stopped

void CControlAppStateMachine::VBusError()

	{

	PNT("CControlAppStateMachine::VBusError() - event will be forwarded to current state\n");

	__ASSERT_ALWAYS(iCurrentState, PANIC);

	// Could implement global USB enabled/disabled policy here by allowing/preventing event reaching current state

	iCurrentState->VBusError();