// Copyright (c) 2007-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:

// EIR Manager server session.

// 

//

/**

 @file

 @internalComponent

*/

#include "eirmansession.h"

#include <bluetooth/logger.h>

#include <bluetooth/eirmanshared.h>

#include <bttypes.h>

#include <bluetooth/hci/hciconsts.h>

#include "eirmanpanics.h"

#include "eirmanserver.h"

#ifdef __FLOG_ACTIVE

_LIT8(KLogComponent, LOG_COMPONENT_EIRMANAGER);

#endif

CEirManSession* CEirManSession::NewL(CEirManServer& aServer)

	{

	LOG_STATIC_FUNC

	CEirManSession* self = new(ELeave) CEirManSession(aServer);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

CEirManSession::CEirManSession(CEirManServer& aServer)

	: iEirManServer(aServer)

	, iEirTag(EEirTagRESERVED)

	{

	LOG_FUNC

	}

void CEirManSession::ConstructL()

	{

	LOG_FUNC

	iEirManServer.AddSession();

	}

CEirManSession::~CEirManSession()

	{

	LOG_FUNC

	// deregister any registered tag that may be registered

	DeregisterTag();

	if(!iDataAvailableListenerMessage.IsNull())

		{

		// complete any outstanding messages.

		iDataAvailableListenerMessage.Complete(KErrCancel);

		}

	iEirManServer.DropSession();

	}

void CEirManSession::ServiceL(const RMessage2& aMessage)

	{

	LOG_FUNC

	LOG1(_L("CEirManSession::ServiceL aMessage.Function() = %d"), aMessage.Function());

	TBool complete = ETrue;

	TInt ret = KErrNone;

	switch (aMessage.Function())

		{

	case EEirManRegisterTag:

		complete = EFalse; // always async.

		RegisterTag(aMessage);

		break;

	case EEirManSpaceAvailableNotification:

		ret = RegisterSpaceAvailableListener(aMessage, complete);

		break;

	case EEirManCancelSpaceAvailableNotification:

		ret = CancelSpaceAvailableListener();

		break;

	case EEirManSetData:

		ret = SetData(aMessage);

		break;

	case EEirManNewData:

		ret = NewData(aMessage);

		break;

	default:

		aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidIPC);

		break;

		}

	if (complete)

		{

		aMessage.Complete(ret);

		}

	}

void CEirManSession::RegisterTag(const RMessage2& aMessage)

	{

	LOG_FUNC

	TEirTag tag = static_cast<TEirTag>(aMessage.Int0());

	LOG1(_L("CEirManSession::RegisterTag tag = %d"), tag);

	if(!(tag >= EEirTagName && tag < EEirTagRESERVED))

		{

		__ASSERT_ALWAYS(EFalse, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag));

		}

	else if(iEirTag != EEirTagRESERVED)

		{

		LOG1(_L("CEirManSession::RegisterTag ERROR, Tag in use: %d"), iEirTag);

		aMessage.Complete(KErrInUse);

		}

	else

		{

		// Register this tag for callbacks

		if(iEirManServer.EirFeatureState() == EEirFeatureReady)

			{

			// Eir is supported

			TInt result = iEirManServer.EirManager().RegisterTag(tag, *this);

			if(result == KErrNone)

				{

				iEirTag = tag;

				}

			aMessage.Complete(result);

			}

		else if(iEirManServer.EirFeatureState() == EEirFeaturePending)

			{

			// We don't know if eir is supported or not at this moment

			iPendingEirTag = tag;

			iRegisterMessage = aMessage;

			}

		else

			{

			// Eir is not supported

			aMessage.Complete(KErrNotSupported);

			}

		}

	}

void CEirManSession::DeregisterTag()

	{

	LOG_FUNC

	LOG1(_L("CEirManSession::DeregisterTag tag = %d"), iEirTag);

	if(iEirTag != EEirTagRESERVED)

		{

		// Deregister this tag for callbacks 

		iEirManServer.EirManager().DeregisterTag(iEirTag);

		iEirTag = EEirTagRESERVED;

		}

	}

// Eir Server has tried to register tag

void CEirManSession::NotifyEirFeatureState(TInt aResult)

	{

	LOG1(_L("Eir Server has been notified feature ready, result: %d"), aResult);

	if(aResult == KErrNone && !iRegisterMessage.IsNull())

		{

		__ASSERT_DEBUG(iEirManServer.EirFeatureState() == EEirFeatureReady, EIR_SESSION_PANIC(EEirSessionEirFeatureNotSupported));

		TInt result = iEirManServer.EirManager().RegisterTag(iPendingEirTag, *this);

		if(result == KErrNone)

			{

			iEirTag = iPendingEirTag;

			}

		iRegisterMessage.Complete(result);

		}

	else if(!iRegisterMessage.IsNull())

		{

		iRegisterMessage.Complete(aResult);

		}

	}

TInt CEirManSession::RegisterSpaceAvailableListener(const RMessage2& aMessage, TBool& aComplete)

	{

	LOG_FUNC

	if(iDataAvailableListenerMessage.Handle())

		{

		LOG(_L("CEirManSession:::RegisterSpaceAvailableListener ERROR IN USE"));

		return KErrInUse;

		}

	iDataAvailableListenerMessage = aMessage;

	aComplete = EFalse;

	if(iLastSpaceOffered != 0)

		{

		LOG(_L("cached space present, completing immediately"));

		CompleteSpaceAvailableRequest(iLastSpaceOffered);

		iLastSpaceOffered = 0;

		return KErrNone;

		}

	LOG(_L("waiting for callback..."));

	return KErrNone;

	}

TInt CEirManSession::NewData(const RMessage2& aMessage)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(iEirTag != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag));

	TInt requiredLength = static_cast<TInt>(aMessage.Int0());

	return iEirManServer.EirManager().NewData(iEirTag, requiredLength);

	}

TInt CEirManSession::CancelSpaceAvailableListener()

	{

	LOG_FUNC

	if(!iDataAvailableListenerMessage.Handle())

		{

		return KErrNotFound;

		}

	iDataAvailableListenerMessage.Complete(KErrCancel);

	return KErrNone;

	}

TInt CEirManSession::SetData(const RMessage2& aMessage)

	{

	LOG_FUNC

	__ASSERT_ALWAYS(iEirTag != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag));

	TEirDataMode eirDataMode = static_cast<TEirDataMode>(aMessage.Int1());

	LOG2(_L("Tag: %d EirDataMode: %d"), iEirTag, eirDataMode);

	// No need to allocate memory with an expensive malloc() call (via HBuf8::NewL or whatever), 

	// since the EIR contents fit in the stack, and the EIR Manager will cache the data anyway

	TBuf8<KHCIExtendedInquiryResponseMaxLength> data;

	TInt err = aMessage.Read(0, data);

	if(err == KErrNone)

		{

		err = iEirManServer.EirManager().SetData(iEirTag, data, eirDataMode);

		}

	return err;

	}

// Callback from the EIR Manager

void CEirManSession::MemnEirBlockAvailable(TEirTag aTag, TUint aSpaceForTag)

	{

	LOG_FUNC

	LOG2(_L("CEirManSession::MemnEirBlockAvailable Tag: %d space: %d"), aTag, aSpaceForTag);

	// Silently discard callbacks not containing our EIR Tag

	if(aTag != iEirTag)

		{

		__ASSERT_DEBUG(EFalse, EIR_SESSION_PANIC(EEirSessionInvalidEirTag));

		LOG3(_L("CEirManSession::MemnEirBlockAvailable early return: aTag: %d iEirTag: %d space: %d"), aTag, iEirTag, aSpaceForTag);

		return;

		}

	if(iDataAvailableListenerMessage.Handle())

		{

		LOG(_L("Listener outstanding, completing request"));

		// Clear stored value

		iLastSpaceOffered = 0;

		CompleteSpaceAvailableRequest(aSpaceForTag);

		}

	else

		{

		LOG(_L("NO Listener outstanding, storing space"));

		// Store in case a client registers later. If this happens multiple times, only the last one will be remembered

		iLastSpaceOffered = aSpaceForTag;

		}

	}

void CEirManSession::CompleteSpaceAvailableRequest(TUint aBytesAvailable)

	{

	LOG_FUNC

	LOG1(_L("CEirManSession::CompleteSpaceAvailableRequest bytes: %d"), aBytesAvailable);

	// Offer the space to the client

	TPckg<TUint32> pckg(aBytesAvailable);

	TInt err = iDataAvailableListenerMessage.Write(0, pckg);

	iDataAvailableListenerMessage.Complete(err);

	}