/*
* 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 "testusbawareapp.h"

#include <e32cons.h>
#include <e32debug.h>
#include "e32svr.h"
#include <e32keys.h>

#include "usbcontrolappshared.h"
#include "e32property.h" 

#define LOG(A,B) RDebug::Print(_L("UsbAwareApp: " L##A),B)
#define PNT(A)	 RDebug::Print(_L("UsbAwareApp: " L##A))
#define PANIC Panic(__LINE__)

void Panic(TInt aLine)
	{
	RDebug::Printf("UsbAwareApp: PANIC line=%d", aLine);
	User::Panic(_L("USBAWAREAPP"), aLine);
	}

void RunAppL()
	{
	CUsbAwareAppConsole* awareapp = CUsbAwareAppConsole::NewLC();
	awareapp->Start();
	CleanupStack::PopAndDestroy(awareapp);
	}

TInt E32Main()
	{
	__UHEAP_MARK;
	CTrapCleanup* cleanup = CTrapCleanup::New();
	CActiveScheduler* activeScheduler = new CActiveScheduler;
	TInt err = KErrNoMemory;
	if(cleanup && activeScheduler)
		{
		CActiveScheduler::Install(activeScheduler);
		PNT("*** UsbAwareApp E32Main ***\n");
		TRAP(err, RunAppL());
		}
	delete activeScheduler;
	delete cleanup;
	__UHEAP_MARKEND;
	return err;
	}



CUsbAwareAppConsole* CUsbAwareAppConsole::NewLC()
	{
	CUsbAwareAppConsole* self = new(ELeave) CUsbAwareAppConsole;
	CleanupStack::PushL(self);
	self->ConstructL();
	PNT("\nConstructed Aware App\n");
	return self;
	}
	
CUsbAwareAppConsole::~CUsbAwareAppConsole()
	{
	PNT("\nClosing Aware App\n");
	delete iKeys;
	delete iShutdownMonitor;
	delete iConsole;
	}

CUsbAwareAppConsole::CUsbAwareAppConsole()
	{
	}

void CUsbAwareAppConsole::ConstructL()
	{
	iConsole = Console::NewL(KUsbAwareAppTitle, TSize(KViewerNumCharactersOnLine, KNumLinesInWindow));
	Move(-3, 9);
	iShutdownMonitor = CShutdownMonitor::NewL(*this);
	// After everything else, enable interactivity.
	iKeys = CUsbAwareAppKeys::NewL(*this);
	Draw();
	}

void CUsbAwareAppConsole::Move(TInt aX, TInt aY)
	{
	TRawEvent event;

	event.Set(TRawEvent::EKeyDown, EStdKeyLeftShift);
	UserSvr::AddEvent(event);

	if (aX)
		{
		if ( aX > 0 )
			{
			// Move to the right...
			for(TInt i=aX; i; i--)
				{
				event.Set(TRawEvent::EKeyDown, EStdKeyRightArrow);
				UserSvr::AddEvent(event);
				event.Set(TRawEvent::EKeyUp, EStdKeyRightArrow);
				UserSvr::AddEvent(event);
				}
			}
		else
			{
			// Move to the Left...
			for(TInt i=aX; i; i++)
				{
				event.Set(TRawEvent::EKeyDown, EStdKeyLeftArrow);
				UserSvr::AddEvent(event);
				event.Set(TRawEvent::EKeyUp, EStdKeyLeftArrow);
				UserSvr::AddEvent(event);
				}
			}
		}
	
	if (aY)
		{
		if ( aY > 0 )
			{
			// Move downwards...
			for(TInt i=aY; i; i--)
				{
				event.Set(TRawEvent::EKeyDown, EStdKeyDownArrow);
				UserSvr::AddEvent(event);
				event.Set(TRawEvent::EKeyUp, EStdKeyDownArrow);
				UserSvr::AddEvent(event);
				}
			}
		else
			{
			// Move upwards...
			for(TInt i=aY; i; i++)
				{
				event.Set(TRawEvent::EKeyDown, EStdKeyUpArrow);
				UserSvr::AddEvent(event);
				event.Set(TRawEvent::EKeyUp, EStdKeyUpArrow);
				UserSvr::AddEvent(event);
				}
			}
		}

	event.Set(TRawEvent::EKeyUp, EStdKeyLeftShift);
	UserSvr::AddEvent(event);
	}

void CUsbAwareAppConsole::Start()
	{
	// Get everything running
	CActiveScheduler::Start();
	}
	
void CUsbAwareAppConsole::Stop() const
	{
	CActiveScheduler::Stop();
	}

void CUsbAwareAppConsole::Draw()
	{
	iConsole->ClearScreen();
	
	iConsole->Printf(_L(
//          1         2         3         4         5 \r\n
// 12345678901234567890123456789012345678901234567890123
  "Test USB Aware App:           \r\n"
 L"\r\n"
 L"Press 'R' to RequestSession   \r\n"
	)
	);

	}



CUsbAwareAppKeys* CUsbAwareAppKeys::NewL(CUsbAwareAppConsole& aUsbAwareAppConsole)
	{
	CUsbAwareAppKeys* self = new(ELeave) CUsbAwareAppKeys(aUsbAwareAppConsole);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CUsbAwareAppKeys::~CUsbAwareAppKeys()
	{
	iUsb.Close();
	Cancel();
	}

CUsbAwareAppKeys::CUsbAwareAppKeys(CUsbAwareAppConsole& aUsbAwareAppConsole)
	: CActive(EPriorityStandard)
	, iUsbAwareAppConsole(aUsbAwareAppConsole)
	{
	CActiveScheduler::Add(this);
	}

void CUsbAwareAppKeys::ConstructL()
	{
	// Connect USB session
	TInt err = iUsb.Connect();
	LOG("CUsbAwareAppKeys::ConstructL()   iUsb.Connect()   err=%d", err);
	User::LeaveIfError(err);
	// Allow keyboard input
	iUsbAwareAppConsole.iConsole->Read(iStatus);
	SetActive();
	}

void CUsbAwareAppKeys::RunL()
	{
	if (!IsActive())
		{
		User::LeaveIfError(iStatus.Int());
		
		switch(iUsbAwareAppConsole.iConsole->KeyCode())
			{
		case 'r': case 'R':
			{
			TInt err = iUsb.RequestSession();
			LOG("CUsbAwareAppKeys::RunL()   RequestSession()	err=%d", err);
			}
			break;
			} // switch
		iUsbAwareAppConsole.iConsole->Read(iStatus);
		SetActive();
		}
	}

void CUsbAwareAppKeys::DoCancel()
	{
	iUsbAwareAppConsole.iConsole->ReadCancel();
	}




CShutdownMonitor* CShutdownMonitor::NewL(MShutdownInterface& aUsbAwareAppConsole)
	{
	CShutdownMonitor* self = new(ELeave) CShutdownMonitor(aUsbAwareAppConsole);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CShutdownMonitor::CShutdownMonitor(MShutdownInterface& aUsbAwareAppConsole)
	: CActive(EPriorityLow) // Low so all notifications that want to be serviced will be done first
	, iUsbAwareAppConsole(aUsbAwareAppConsole)
	{
	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
	iUsbAwareAppConsole.Stop(); // Stopping Active Scheduler will results in the destructor getting called
	}

void CShutdownMonitor::DoCancel()
	{
	iShutdownProp.Cancel();
	}