// Copyright (c) 2004-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 "BTTextNotifiers.h"

#include <btdevice.h>

#include <e32cons.h>

#include <bluetooth/logger.h>

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, "TextNotifiers");

#endif

_LIT(KBTPanDeviceSelectionNotifier, "PanDevSlctNotif"); // for panics

_LIT(KBTPanNotifierConsoleName, "PAN device selector");

//

// Notifier

//

CBTPanDeviceSelectionNotifier* CBTPanDeviceSelectionNotifier::NewLC()

	{

	LOG_STATIC_FUNC

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

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CBTPanDeviceSelectionNotifier::CBTPanDeviceSelectionNotifier()

	{

	LOG_FUNC

	}

void CBTPanDeviceSelectionNotifier::ConstructL()

	{

	LOG_FUNC

	iEngine = CBTPanDeviceSelectionNotifierEngine::NewL(*this);

	}

CBTPanDeviceSelectionNotifier::~CBTPanDeviceSelectionNotifier()

	{

	LOG_FUNC

	delete iEngine;

	}

void CBTPanDeviceSelectionNotifier::Release()

	{

	LOG_FUNC

	Cancel();

	delete this;

	}

CBTPanDeviceSelectionNotifier::TNotifierInfo CBTPanDeviceSelectionNotifier::RegisterL()

	{

	LOG_FUNC

	iInfo.iUid=KBTPanDeviceSelectionNotifierUid;

	iInfo.iChannel=KScreenOutputChannel;

	iInfo.iPriority=ENotifierPriorityVLow;

	return iInfo;

	}

CBTPanDeviceSelectionNotifier::TNotifierInfo CBTPanDeviceSelectionNotifier::Info() const

	{

	LOG_FUNC

	return iInfo;

	}

TPtrC8 CBTPanDeviceSelectionNotifier::StartL(const TDesC8& /*aBuffer*/)

	{

	LOG_FUNC

	LOG(_L("The synchronous StartL overload is not used."))

	User::Panic(KBTPanDeviceSelectionNotifier, KErrNotSupported);

	return KNullDesC8(); // should never be reached

	}

void CBTPanDeviceSelectionNotifier::StartL(const TDesC8& aBuffer, TInt aReplySlot, const RMessagePtr2& aMessage)

	{

	LOG_FUNC

	iReplySlot = aReplySlot;

	iMessage = RMessage2(aMessage);

	iMessageOutstanding = ETrue;

	TRAPD(err, iEngine->PromptForDevicesL(aBuffer));

	FTRACE(FPrint(_L("RNot\tPAN device selection notifier completed with result %d"), err));

	if (err)

		{

		aMessage.Complete(err);

		iMessageOutstanding = EFalse;

		User::Leave(err);

		}

	}

void CBTPanDeviceSelectionNotifier::Cancel()

	{

	LOG_FUNC

	iEngine->Stop();

	if (iMessageOutstanding)

		{

		iMessage.Complete(KErrCancel);

		iMessageOutstanding = EFalse;

		}

	}

TPtrC8 CBTPanDeviceSelectionNotifier::UpdateL(const TDesC8& /*aBuffer*/)

/**

*/

	{

	LOG_FUNC

	return KNullDesC8();

	}

void CBTPanDeviceSelectionNotifier::DeviceSelectionComplete(TBTDeviceList& aDevices)

/**

The user has selected the devices they want to connect to

*/

	{

	LOG_FUNC

	TInt err = iMessage.Write(iReplySlot, aDevices);

	iMessage.Complete(err);

	iMessageOutstanding = EFalse;

	}

void CBTPanDeviceSelectionNotifier::DeviceSelectionError(TInt aError)

/**

There was an error during device selection

*/

	{

	LOG_FUNC

	LOG1(_L("\taError = %d"), aError);

	if(iMessageOutstanding)

		{

		iMessage.Complete(aError);

		iMessageOutstanding = KErrNone;

		}

	}

//

// Notifier engine

//

_LIT(KNewline, "\n");

_LIT(KBTPanDSNSelectedDevice, "-> ");

_LIT(KBTPanDSNNotSelectedDevice, "   ");

_LIT(KBTPanDSNSelected, " * ");

_LIT(KBTPanDSNNotSelected, "   ");

_LIT(KBTPanDSNDevAddrOpen, "[");

_LIT(KBTPanDSNDevAddrClose, "]");

_LIT(KBTPanDeviceSelectionNotifierInstructions, "Use [up] and [down] arrow keys to move around; press [space] to select a device, press [return] to finish, [esc] to cancel:\nUp to 8 devices can be selected.\n");

_LIT(KBTPanDSNNoMoreDevices, " --- Device discovery complete ---");

const TUint KBTPanDSNDevNameMaxChars = 20;

const TUint KBTPanDSNMaxReadableBufLength = 12;

const TUint KBTPanDSNDeviceDisplayBufLength = (sizeof(KBTPanDSNSelected)/2)+KBTPanDSNDevNameMaxChars+(sizeof(KBTPanDSNDevAddrOpen)/2)+KBTPanDSNMaxReadableBufLength+(sizeof(KBTPanDSNDevAddrClose)/2);

const TUint KBTPanDSNInitialDeviceCount = KMaxDeviceRows; // start out by assuming we're going to discover this many devices - will realloc later if necessary

const TUint KBTPanDSNInitialBufSize = ((sizeof(KBTPanDeviceSelectionNotifierInstructions)/2)+(KBTPanDSNInitialDeviceCount*KBTPanDSNDeviceDisplayBufLength));

CBTPanDeviceSelectionNotifierEngine* CBTPanDeviceSelectionNotifierEngine::NewL(MBTPanDeviceSelectionNotify& aNotify)

/**

*/

	{

	LOG_STATIC_FUNC

	CBTPanDeviceSelectionNotifierEngine* self = new(ELeave) CBTPanDeviceSelectionNotifierEngine(aNotify);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CBTPanDeviceSelectionNotifierEngine::CBTPanDeviceSelectionNotifierEngine(MBTPanDeviceSelectionNotify& aNotify) :

	CActive(EPriorityStandard), iDevices(KMaxDeviceRows), iDisplayPtr(NULL, 0), iNotify(aNotify)

/**

*/

	{

	LOG_FUNC

	CActiveScheduler::Add(this);

	}

void CBTPanDeviceSelectionNotifierEngine::ConstructL()

/**

*/

	{

	LOG_FUNC

	iDisplayBuf = HBufC::NewL(KBTPanDSNInitialBufSize);

	iDisplayPtr.Set(iDisplayBuf->Des());

	}

CBTPanDeviceSelectionNotifierEngine::~CBTPanDeviceSelectionNotifierEngine()

/**

*/

	{

	LOG_FUNC

	delete iDeviceDiscoverer;

	iDeviceDiscoverer = NULL;

	delete iConsole;

	iConsole = NULL;

	delete iDisplayBuf;

	iDisplayBuf = NULL;

	iDevices.Close();

	}

void CBTPanDeviceSelectionNotifierEngine::PromptForDevicesL(const TDesC8& /*aBuffer*/)

/**

Start a device discovery

TODO: Reset state each time this is called

*/

	{

	LOG_FUNC

	iDeviceDiscoverer = CBTPanDeviceSelectionNotifierDeviceDiscoverer::NewL(*this);

	iConsole = Console::NewL(KBTPanNotifierConsoleName, TSize(KConsFullScreen,KConsFullScreen));

	Redraw();

	iDeviceDiscoverer->StartDeviceDiscovery();

	iConsole->Read(iStatus);

	SetActive();

	}

void CBTPanDeviceSelectionNotifierEngine::Stop()

/**

The notifier wants us to abort - stop everything

*/

	{

	LOG_FUNC

	AbortEverything();

	}

void CBTPanDeviceSelectionNotifierEngine::RunL()

/**

Got input from the user

*/

	{

	LOG_FUNC

	TChar key = iConsole->KeyCode();

	switch(key)

		{

		case EKeyUpArrow:

			{

			if(iCurrentlySelectedDevice>0)

				{

				--iCurrentlySelectedDevice;

				}

			if(iCurrentlySelectedDevice<iPositionOfTopDeviceInList)

				{

				--iPositionOfTopDeviceInList;

				}

			break;

			}

		case EKeyDownArrow:

			{

			if(iCurrentlySelectedDevice < (iDevices.Count()-1))

				{

				++iCurrentlySelectedDevice;

				}

			if(iCurrentlySelectedDevice>=(iPositionOfTopDeviceInList+KMaxDeviceRows))

				{

				++iPositionOfTopDeviceInList;

				}

			break;

			}

		case EKeySpace:

			{

			if(iDevices.Count()) // make sure there's something in the array

				{

				if(iDevices[iCurrentlySelectedDevice]->iSelected)

					{

					iDevices[iCurrentlySelectedDevice]->iSelected = EFalse;

					}

				else

					{

					if(NumberOfDevicesSelected()<KMaxPanDevicesForSimultaneousSelection)

						{

						iDevices[iCurrentlySelectedDevice]->iSelected = ETrue;

						}

					}

				}

			break;

			}

		case EKeyEnter:

			{

			PackageSelectedDevicesAndCompleteNotifier();

			return;

			}

		default:

			// fall through

		case EKeyEscape:

			{

			CompleteNotifierWithError(KErrCancel);

			return;

			}

		}

	Redraw();

	iConsole->Read(iStatus);	// post another read

	SetActive();

	}

void CBTPanDeviceSelectionNotifierEngine::DoCancel()

/**

*/

	{

	LOG_FUNC

	iConsole->ReadCancel();

	}

void CBTPanDeviceSelectionNotifierEngine::NewDeviceFoundL(TNameRecord& aNewDevice)

/**

Add the new device to the end of the list

*/

	{

	LOG_FUNC

	LOG1(_L("\tDevice Name = %S"), &(aNewDevice.iName));

	TBTDeviceSelectionInfo* devInfo = new(ELeave) TBTDeviceSelectionInfo();

	devInfo->iNameRecord = aNewDevice;

	devInfo->iSelected = EFalse;

	User::LeaveIfError(iDevices.Append(devInfo));

	// check if we need to allocate bigger buffer

	TUint instructions = sizeof(KBTPanDeviceSelectionNotifierInstructions)/2;

	TUint devices = iDevices.Count();

	TUint devDisplay = KBTPanDSNDeviceDisplayBufLength;

	TUint minRequiredBufSize = instructions+(devices*devDisplay);

	if(iDisplayPtr.MaxLength() < minRequiredBufSize)

		{

		delete iDisplayBuf;

		iDisplayBuf = NULL;

		TUint size = (sizeof(KBTPanDeviceSelectionNotifierInstructions)/2)+2*iDevices.Count()*KBTPanDSNDeviceDisplayBufLength;

		iDisplayBuf = HBufC::NewL( size );

		iDisplayPtr.Set(iDisplayBuf->Des());

		}		

	Redraw();

	}

void CBTPanDeviceSelectionNotifierEngine::DeviceSearchComplete(TInt aError)

/**

No more devices can be found

*/

	{

	LOG_FUNC

	LOG1(_L("\taError = %d"), aError);

	if(aError!=KErrEof)	// there's a problem, so complete with an error

		{

		CompleteNotifierWithError(aError);

		return;

		}

	else

		{

		iDeviceSearchComplete = ETrue;		

		Redraw();

		}

	}

TInt CBTPanDeviceSelectionNotifierEngine::DisplayDevice(TUint aDeviceNumber, TPtr& aDisplayBuf)

/**

*/

	{

	LOG_FUNC

	//ASSERT(aDisplayBuf.Length()==KBTPanDSNDeviceDisplayBufLength);

	if(aDeviceNumber>=iDevices.Count())

		{

		return KErrNotFound;

		}

	else

		{

		if(iDevices[aDeviceNumber]->iSelected)

			{

			aDisplayBuf.Append(KBTPanDSNSelected);

			}

		else

			{

			aDisplayBuf.Append(KBTPanDSNNotSelected);

			}

		aDisplayBuf.Append(iDevices[aDeviceNumber]->iNameRecord.iName.Left(KBTPanDSNDevNameMaxChars));	// append device name

		aDisplayBuf.Append(KBTPanDSNDevAddrOpen);

		TBuf<KBTPanDSNMaxReadableBufLength> readableDevAddrBuf;

		static_cast<TInquirySockAddr>(iDevices[aDeviceNumber]->iNameRecord.iAddr).BTAddr().GetReadable(readableDevAddrBuf);	// append device address

		aDisplayBuf.Append(readableDevAddrBuf);

		aDisplayBuf.Append(KBTPanDSNDevAddrClose);

		return KErrNone;

		}

	}

void CBTPanDeviceSelectionNotifierEngine::DisplayInstructions(TPtr& aDisplayBuf)

/**

~130 chars

*/

	{

	LOG_FUNC

	aDisplayBuf.Append(KBTPanDeviceSelectionNotifierInstructions);

	}

void CBTPanDeviceSelectionNotifierEngine::Redraw()

/**

Redraw the console

*/

	{

	LOG_FUNC

	iDisplayPtr.Zero();

	iConsole->ClearScreen();

	TInt err;

	DisplayInstructions(iDisplayPtr);

	for(TInt i = 0; i < KMaxDeviceRows; ++i)

		{

		if(iPositionOfTopDeviceInList+i==iCurrentlySelectedDevice)

			{

			iDisplayPtr.Append(KBTPanDSNSelectedDevice);

			}

		else

			{

			iDisplayPtr.Append(KBTPanDSNNotSelectedDevice);

			}

		err = DisplayDevice(iPositionOfTopDeviceInList+i, iDisplayPtr);

		if(err==KErrNotFound)	// no more devices left

			{

			break;

			}

		iDisplayPtr.Append(KNewline);

		}

	if(iDeviceSearchComplete)

		{

		iDisplayPtr.Append(KBTPanDSNNoMoreDevices);

		}

	iConsole->Write(*iDisplayBuf);

	}

void CBTPanDeviceSelectionNotifierEngine::PackageSelectedDevicesAndCompleteNotifier()

/**

Package the selected device addresses into the device list and pass back to the notifier

*/

	{

	LOG_FUNC

	AbortEverything();	// stop inquiry and remove console

	TBTDeviceList deviceList;

	for(TInt i = 0; i < iDevices.Count(); ++i)

		{

		if(iDevices[i]->iSelected)

			{

			TBTDevAddr devAddr = static_cast<TInquirySockAddr>(iDevices[i]->iNameRecord.iAddr).BTAddr();

			deviceList.AddDevice(devAddr);

			}

		}

	iNotify.DeviceSelectionComplete(deviceList);

	}

void CBTPanDeviceSelectionNotifierEngine::CompleteNotifierWithError(TInt aError)

/**

An error occurred during device selection - cancel everything and complete the notifier with an error

*/

	{

	LOG_FUNC

	if(iAborting)

		{

		// do nothing, we're already aborting everything

		}

	else

		{

		iAborting = ETrue; // make a note that we're aborting

		AbortEverything();

		iNotify.DeviceSelectionError(aError);

		iAborting = EFalse; // reset flag

		}

	}

void CBTPanDeviceSelectionNotifierEngine::AbortEverything()

/**

Common method to abort everything - called from both the notifier error path and our own

*/

	{

	LOG_FUNC

	if(iDeviceDiscoverer)

		{

		iDeviceDiscoverer->Cancel();	// cancel the device discovery, and delete the device discoverer

		delete iDeviceDiscoverer;

		iDeviceDiscoverer = NULL;

		}

	Cancel();						// cancel the input from the console

	if(iConsole)

		{

		delete iConsole;				// remove the console from screen

		iConsole = NULL;

		}

	}	

TInt CBTPanDeviceSelectionNotifierEngine::NumberOfDevicesSelected()

/**

Return the number of devices marked as selected in the array

*/

	{

	LOG_FUNC

	TInt count = 0;

	for(TInt i=0; i < iDevices.Count(); ++i)

		{

		if(iDevices[i]->iSelected)

			{

			++count;

			}

		}

	return count;

	}