// Copyright (c) 2007-2010 Nokia Corporation and/or its subsidiary(-ies).

CEirManSession* CEirManSession::NewL(CEirManServer& aServer, MEirSessionNotifier& aParent, TBool aInternalSession)

	CEirManSession* self = new(ELeave) CEirManSession(aServer, aParent, aInternalSession);

CEirManSession::CEirManSession(CEirManServer& aServer, MEirSessionNotifier& aParent, TBool aInternalSession)

	, iParent(aParent)

	, iInternalSession(aInternalSession)

	iEirManServer.AddSession(*this, iInternalSession);

	iLink.Deque();

	iEirManServer.DropSession(iInternalSession);

void CEirManSession::RegisterTag(TEirTag aTag)

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

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

		iParent.MesnRegisterComplete(KErrArgument);

		iParent.MesnRegisterComplete(KErrInUse);

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

				iEirTag = aTag;

			iParent.MesnRegisterComplete(result);

			iRegisterPending = ETrue;

			iPendingEirTag = aTag;

			iParent.MesnRegisterComplete(KErrNotSupported);

	if(aResult == KErrNone && iRegisterPending)

		iRegisterPending = EFalse;

		iParent.MesnRegisterComplete(result);

	else if(iRegisterPending)

		iRegisterPending = EFalse;

		iParent.MesnRegisterComplete(aResult);

TInt CEirManSession::NewData(TInt aRequiredLength)

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

TInt CEirManSession::SetData(const TDesC8& aData, TEirDataMode aMode)

	return iEirManServer.EirManager().SetData(iEirTag, aData, aMode);

	iParent.MesnSpaceAvailable(aSpaceForTag);

	}

TEirTag CEirManSession::EirTag() const

	{

	return iEirTag;

	}

CEirManExternalSession* CEirManExternalSession::NewL(CEirManServer& aServer)

	{

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

	CleanupStack::PushL(self);

	self->ConstructL(aServer);

	CleanupStack::Pop(self);

	return self;

	}

CEirManExternalSession::CEirManExternalSession()

	{

	}

void CEirManExternalSession::ConstructL(CEirManServer& aServer)

	{

	iSession = CEirManSession::NewL(aServer, *this, EFalse);

	}

CEirManExternalSession::~CEirManExternalSession()

	{

	if(!iDataAvailableListenerMessage.IsNull())

		{

		// complete any outstanding messages.

		iDataAvailableListenerMessage.Complete(KErrCancel);

		}

	delete iSession;

	}

/*

 * Each of the individual methods is responsible for completing the message.

 * All 'leaves' are processed in CSession2::ServiceError() resulting in message completion

 * with the appropriate error code.

 * RegisterTagL() and RegisterSpaceAvailableListenerL() store aMessage parameter for the future use

 * when the callbacks are called.

 */

void CEirManExternalSession::ServiceL(const RMessage2& aMessage)

	{

	LOG_FUNC

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

	switch (aMessage.Function())

		{

	case EEirManRegisterTag:

		RegisterTagL(aMessage);

		break;

	case EEirManSpaceAvailableNotification:

		RegisterSpaceAvailableListenerL(aMessage);

		break;

	case EEirManCancelSpaceAvailableNotification:

		CancelSpaceAvailableListenerL(aMessage);

		break;

	case EEirManSetData:

		SetDataL(aMessage);

		break;

	case EEirManNewData:

		NewDataL(aMessage);

		break;

	default:

		aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidIPC);

		break;

		}

	}

void CEirManExternalSession::RegisterTagL(const RMessage2& aMessage)

	{

	LOG_FUNC

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

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

	iRegisterMessage = aMessage;

	iSession->RegisterTag(tag);

	}

void CEirManExternalSession::MesnRegisterComplete(TInt aResult)

	{

	if (aResult == KErrArgument)

		{

		iRegisterMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag);

		}

	else

		{

		iRegisterMessage.Complete(aResult);

		}

	}

void CEirManExternalSession::RegisterSpaceAvailableListenerL(const RMessage2& aMessage)

	{

	LOG_FUNC

	if(iDataAvailableListenerMessage.Handle())

		{

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

		LEAVEL(KErrInUse);

		}

	iDataAvailableListenerMessage = aMessage;

	if(iLastSpaceOffered != 0)

		{

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

		CompleteSpaceAvailableRequest(iLastSpaceOffered);

		iLastSpaceOffered = 0;

		return;

		}

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

	}

void CEirManExternalSession::NewDataL(const RMessage2& aMessage)

	{

	LOG_FUNC

	if (iSession->EirTag() == EEirTagRESERVED)

		{

		aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag);

		return;

		}

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

	LEAVEIFERRORL(iSession->NewData(requiredLength));

	aMessage.Complete(KErrNone);

	}

void CEirManExternalSession::CancelSpaceAvailableListenerL(const RMessage2& aMessage)

	{

	LOG_FUNC

	if(!iDataAvailableListenerMessage.Handle())

		{

		LEAVEL(KErrNotFound);

		}

	iDataAvailableListenerMessage.Complete(KErrCancel);

	aMessage.Complete(KErrNone);

	}

void CEirManExternalSession::SetDataL(const RMessage2& aMessage)

	{

	LOG_FUNC

	if (iSession->EirTag() == EEirTagRESERVED)

		{

		aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag);

		return;

		}

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

	LOG1(_L("EirDataMode: %d"),  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;

	LEAVEIFERRORL(aMessage.Read(0, data));

	LEAVEIFERRORL(iSession->SetData(data, eirDataMode));

	aMessage.Complete(KErrNone);

	}

void CEirManExternalSession::MesnSpaceAvailable(TUint aSpaceForTag)

	{

void CEirManExternalSession::CompleteSpaceAvailableRequest(TUint aBytesAvailable)

	TPckgC<TUint32> pckg(aBytesAvailable);

CEirManInternalSession* CEirManInternalSession::NewL(CEirManServer& aServer, MEirInternalSessionNotifier& aParent)

	{

	LOG_STATIC_FUNC

	CEirManInternalSession* self = new(ELeave) CEirManInternalSession(aParent);

	CleanupStack::PushL(self);

	self->ConstructL(aServer);

	CleanupStack::Pop(self);

	return self;

	}

CEirManInternalSession::CEirManInternalSession(MEirInternalSessionNotifier& aParent)

	: iParent(aParent)

	{

	}

void CEirManInternalSession::ConstructL(CEirManServer& aServer)

	{

	iSession = CEirManSession::NewL(aServer, *this, ETrue);

	iSetDataCb = new (ELeave) CAsyncCallBack(CActive::EPriorityHigh);

	TCallBack cb(&SetDataCb, this);

	iSetDataCb->Set(cb);

	}

CEirManInternalSession::~CEirManInternalSession()

	{

	delete iSetDataCb;

	delete iSession;

	}

void CEirManInternalSession::RegisterTag(TEirTag aTag)

	{

	iSession->RegisterTag(aTag);

	}

void CEirManInternalSession::SetData(const TDesC8& aData, TEirDataMode aMode)

	{

	delete iPendingData;

	iPendingData = NULL;

	iSetDataCb->Cancel();

	iPendingData = aData.Alloc();

	iPendingMode = aMode;

	if (iPendingData)

		{

		iSetDataCb->CallBack();

		}

	}

TInt CEirManInternalSession::SetDataCb(TAny* aThis)

	{

	static_cast<CEirManInternalSession*>(aThis)->DoSetData();

	return KErrNone;

	}

void CEirManInternalSession::DoSetData()

	{

	TInt err = iSession->SetData(*iPendingData, iPendingMode);

	if (err != KErrNone)

		{

		iParent.MeisnSetDataError(err);

		}

	}

TInt CEirManInternalSession::NewData(TInt aRequiredLength)

	{

	return iSession->NewData(aRequiredLength);

	}

void CEirManInternalSession::MesnRegisterComplete(TInt aResult)

	{

	iParent.MeisnRegisterComplete(aResult);

	}

void CEirManInternalSession::MesnSpaceAvailable(TUint aSpaceForTag)

	{

	iParent.MeisnSpaceAvailable(aSpaceForTag - KEirLengthTagLength);

	}