// 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)

	{

	LOG_FUNC

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

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

		{

		iParent.MesnRegisterComplete(KErrArgument);

		}

	else if(iEirTag != EEirTagRESERVED)

		{

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

		iParent.MesnRegisterComplete(KErrInUse);

		}

	else

		{

		// Register this tag for callbacks

		if(iEirManServer.EirFeatureState() == EEirFeatureReady)

			{

			// Eir is supported

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

			if(result == KErrNone)

				{

				iEirTag = aTag;

				}

			iParent.MesnRegisterComplete(result);

			}

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

			{

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

			iRegisterPending = ETrue;

			iPendingEirTag = aTag;

			}

		else

			{

			// Eir is not supported

			iParent.MesnRegisterComplete(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 && iRegisterPending)

		{

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

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

		if(result == KErrNone)

			{

			iEirTag = iPendingEirTag;

			}

		iRegisterPending = EFalse;

		iParent.MesnRegisterComplete(result);

		}

	else if(iRegisterPending)

		{

		iRegisterPending = EFalse;

		iParent.MesnRegisterComplete(aResult);

		}

	}

TInt CEirManSession::NewData(TInt aRequiredLength)

	{

	LOG_FUNC

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

	}

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

	{

	LOG_FUNC

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

	}

// 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;

		}

	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()

	{

	delete iSession;

void CEirManExternalSession::ServiceL(const RMessage2& aMessage)

void CEirManExternalSession::RegisterTag(const RMessage2& aMessage)

	iRegisterMessage = aMessage;

	iSession->RegisterTag(tag);

void CEirManExternalSession::MesnRegisterComplete(TInt aResult)

	if (aResult == KErrArgument)

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

	iRegisterMessage.Complete(aResult);

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

TInt CEirManExternalSession::NewData(const RMessage2& aMessage)

	__ASSERT_ALWAYS(iSession->EirTag() != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag));

	return iSession->NewData(requiredLength);

TInt CEirManExternalSession::CancelSpaceAvailableListener()

TInt CEirManExternalSession::SetData(const RMessage2& aMessage)

	__ASSERT_ALWAYS(iSession->EirTag() != EEirTagRESERVED, aMessage.Panic(KEirManCliPncCat, EEirManPanicInvalidTag));

	LOG1(_L("EirDataMode: %d"),  eirDataMode);

		err = iSession->SetData(data, eirDataMode);

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);

	}