/*
* Copyright (c) 2003 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 "CdlServer.h"

const TInt KCdlSessionMaxBuf = 0x100000; // 1 megabyte limit on IPC transfers

CCdlSession::CCdlSession()
	{
	}

CCdlServer& CCdlSession::Server()
	{
	return *static_cast<CCdlServer*>(const_cast<CServer2*>(CSession2::Server()));
	}

TBool CCdlSession::NotifyPending() const
	{
	return !iNotify.IsNull();
	}

void CCdlSession::CreateL()
//
// 2nd phase construct for sessions - called by the CServer2 framework
//
	{
	Server().AddSession();
	}

CCdlSession::~CCdlSession()
	{
	delete iTempBuf;
	delete iSendingBuf;
	delete iSendingState;
	Server().DropSession();
	}

void CCdlSession::ServiceL(const RMessage2& aMessage)
//
// Handle a client request.
// Leaving is handled by CCdlServer::RunError() which reports the error code
// to the client
//
	{
	switch (aMessage.Function())
		{
		case ECdlServCmdRequestGetCust:
			RequestGetCustL(aMessage);
			break;

		case ECdlServCmdGetCust:
			GetCustL(aMessage);
			break;

		case ECdlServCmdSetUidsToNotify:
			SetUidsToNotifyL(aMessage);
			break;

		case ECdlServCmdNotifyChange:
			NotifyChangeL(aMessage);
			break;

		case ECdlServCmdCancelNotifyChange:
			CancelNotifyChangeL(aMessage);
			break;

		case ECdlServCmdSetCust:
			SetCustL(aMessage);
			break;

		case ECdlServCmdGetRefsSize:
			GetRefsSizeL(aMessage);
			break;

		case ECdlServCmdGetNamesSize:
			GetNamesSizeL(aMessage);
			break;

		case ECdlServCmdGetTempBuf:
			GetTempBufL(aMessage);
			break;

		case ECdlServCmdGetAllRefsSize:
			GetAllRefsSizeL(aMessage);
			break;

		case ECdlServCmdIsPluginInRom:
			IsPluginInRomL(aMessage);
			break;

		case ECdlServCmdPluginDrive:
			PluginDriveL(aMessage);
			break;

		default:
			PanicClient(aMessage,EPanicIllegalFunction);
			break;
		}
	}

void CCdlSession::RequestGetCustL(const RMessage2& aMessage)
	{
	if (iSendingBuf)
		{
		aMessage.Complete(KErrNotReady);
		return;
		}

	// get the uids from the client
	CCdlUids* uids = CCdlUids::NewLC();
	HBufC8* buf = HBufC8::NewMaxLC(ValidIntL(aMessage.Int2(), 0, KCdlSessionMaxBuf));
	TPtr8 ptr = buf->Des();
	aMessage.ReadL(1, ptr);
	uids->ImportL(*buf);
	CleanupStack::PopAndDestroy(buf);

	// get the size of the requested customisation
	delete iSendingState;
	iSendingState = 0;
	delete iSendingBuf;
	iSendingBuf = 0;
	CCdlRefs* sendingState = Server().GetStateLC(*uids);
	iSendingBuf = sendingState->ExportL();
	iSendingState = sendingState;
	TInt size=iSendingBuf->Size();
	CleanupStack::Pop(sendingState);
	CleanupStack::PopAndDestroy(uids);

	// send the size to the client
	TPckg<TInt> sizePckg(size);
	WriteAndComplete(aMessage, 0, sizePckg);
	}

void CCdlSession::GetCustL(const RMessage2& aMessage)
	{
	if (!iSendingBuf)
		{
		PanicClient(aMessage, EPanicNoCustomisationRequested);
		return;
		}

	if (iSendingBuf->Size() > aMessage.Int1())
		{
		TInt size=iSendingBuf->Size();
		TPckg<TInt> sizePckg(size);
		WriteAndComplete(aMessage, 2, sizePckg, KCdlRefsSizeChanged);
		return;
		}

	WriteAndComplete(aMessage, 0, *iSendingBuf);
	delete iSendingBuf;
	iSendingBuf = 0;
	delete iSendingState;
	iSendingState = 0;
	iQueuedCustChange = EFalse;
	}

void CCdlSession::SetUidsToNotifyL(const RMessage2& aMessage)
	{
	HBufC8* buf = HBufC8::NewMaxLC(ValidIntL(aMessage.Int1(), 0, KCdlSessionMaxBuf));
	TPtr8 ptr = buf->Des();
	aMessage.ReadL(0, ptr);
	iUids.ImportL(*buf);
	CleanupStack::PopAndDestroy(buf);
	aMessage.Complete(KErrNone);
	}

void CCdlSession::NotifyChangeL(const RMessage2& aMessage)
	{
	if (NotifyPending())
		PanicClient(aMessage,EPanicNotifyActive);
	else
		iNotify=aMessage;

	if (iQueuedCustChange)
		{
		NotifyCustChangeL();
		}
	else if (iQueuedRefsChange)
		{
		HandleRefsChangeL();
		}
	}

void CCdlSession::CancelNotifyChangeL(const RMessage2& aMessage)
	{
	if (NotifyPending())
		iNotify.Complete(KErrCancel);
	aMessage.Complete(KErrNone);
	}

void CCdlSession::SetCustL(const RMessage2& aMessage)
	{
	CCdlRefs* state = CCdlRefs::NewLC();
	HBufC8* buf = HBufC8::NewMaxLC(ValidIntL(aMessage.Int1(), 0, KCdlSessionMaxBuf));
	TPtr8 ptr = buf->Des();
	aMessage.ReadL(0, ptr);
	state->ImportL(*buf);
	CleanupStack::PopAndDestroy(buf);
	Server().SetStateL(state);
	CleanupStack::PopAndDestroy(state);
	aMessage.Complete(KErrNone);
	}

void CCdlSession::NotifyCustChangeL()
	{
	if (NotifyPending())
		{
		TPckgBuf<SCdlServerChange> change;
		change().iType = SCdlServerChange::EGlobalCustomisation;
		change().iSize = iSendingBuf->Size();
		WriteAndComplete(iNotify, 0, change);
		iQueuedCustChange = EFalse;
		}
	else
		{
		iQueuedCustChange = ETrue;
		}
	}

void CCdlSession::WriteAndComplete(const RMessagePtr2& aMessage, TInt aParam, const TDesC8& aDes, TInt aCode)
	{
	TRAPD(r,aMessage.WriteL(aParam, aDes));
	if (r==KErrNone)
		aMessage.Complete(aCode);
	else
		PanicClient(aMessage, EPanicBadDescriptor);
	}

void CCdlSession::HandleCustChangeL(const CCdlUids& aUids)
	{
	CCdlUids* change = iUids.IntersectionLC(aUids);
	if (change->Count())
		{
		if (iSendingBuf == NULL)
			{
			iSendingState = Server().GetStateLC(*change);
			CleanupStack::Pop(iSendingState);
			iSendingBuf = iSendingState->ExportL();
			NotifyCustChangeL();
			}
		else
			{
			iSendingState->MergeAndReplaceL(*Server().GetStateLC(*change));
			CleanupStack::PopAndDestroy(); // change in state;
			delete iSendingBuf;
			iSendingBuf = 0;
			iSendingBuf = iSendingState->ExportL();
			// don't notify change in state for ongoing transaction
			}
		}

	CleanupStack::PopAndDestroy(change);
	}

void CCdlSession::HandleRefsChangeL()
	{
	if (NotifyPending())
		{
		TPckgBuf<SCdlServerChange> change;
		change().iType = SCdlServerChange::EAvailableRefs;
		WriteAndComplete(iNotify, 0, change);
		iQueuedRefsChange = EFalse;
		}
	else
		{
		iQueuedRefsChange = ETrue;
		}
	}

void CCdlSession::GetRefsSizeL(const RMessage2& aMessage)
	{
	delete iTempBuf;
	iTempBuf = 0;

	if (aMessage.Int1())	// Get by name
		{
		HBufC* buf = HBufC::NewMaxLC(ValidIntL(aMessage.Int2(), 0, KMaxFileName));
		TPtr ptr = buf->Des();
		aMessage.ReadL(1, ptr);
		CCdlRefs* refs = Server().AllRefs().SubsetByNameLC(*buf);
		if (refs->CountRefs() == 0)	// library not found in server, perhaps not scanned yet.
			{
			CCdlRefCollection* contents = Server().FileContentsLC(*buf);
			refs->AppendL(*contents);
			CleanupStack::PopAndDestroy(contents);
			}
		iTempBuf = refs->ExportL();
		CleanupStack::PopAndDestroy(refs);
		CleanupStack::PopAndDestroy(buf);
		}
	else					// Get by UID
		{
		iTempBuf = Server().AllRefs().SubsetByUidLC(TUid::Uid(aMessage.Int3()))->ExportL();
		CleanupStack::PopAndDestroy();		// unnamed CCdlRefs
		}

	// send the size to the client
	TPckgBuf<TInt> sizePckg(iTempBuf->Size());
	WriteAndComplete(aMessage, 0, sizePckg);
	}

void CCdlSession::GetAllRefsSizeL(const RMessage2& aMessage)
	{
	delete iTempBuf;
	iTempBuf = 0;
	iTempBuf = Server().AllRefs().ExportL();

	// send the size to the client
	TPckgBuf<TInt> sizePckg(iTempBuf->Size());
	WriteAndComplete(aMessage, 0, sizePckg);
	}

void CCdlSession::GetNamesSizeL(const RMessage2& aMessage)
	{
	delete iTempBuf;
	iTempBuf = 0;
	iTempBuf = Server().AllRefs().Names().ExportL();

	// send the size to the client
	TPckgBuf<TInt> sizePckg(iTempBuf->Size());
	WriteAndComplete(aMessage, 0, sizePckg);
	}

void CCdlSession::GetTempBufL(const RMessage2& aMessage)
	{
	if (iTempBuf)
		{
		WriteAndComplete(aMessage, 0, *iTempBuf);
		delete iTempBuf;
		iTempBuf = 0;
		}
	else
		{
		// This message can only be used after one of the messages that
		// set up iTempBuf
		PanicClient(aMessage, EPanicBufRequestedWithoutSetup);
		}
	}

void CCdlSession::IsPluginInRomL(const RMessage2& aMessage)
	{
	HBufC* fileBuf = HBufC::NewMaxLC(ValidIntL(aMessage.Int1(), 0, KMaxFileName));
	TPtr filePtr = fileBuf->Des();
	aMessage.ReadL(0, filePtr);

	TPckgBuf<TBool> isInRomPckg(EFalse);
	TInt err = Server().IsPluginInRom(*fileBuf, isInRomPckg());
	CleanupStack::PopAndDestroy(fileBuf);
	
	WriteAndComplete(aMessage, 2, isInRomPckg, err);
	}

void CCdlSession::PluginDriveL(const RMessage2& aMessage)
	{
	HBufC* fileBuf = HBufC::NewMaxLC(ValidIntL(aMessage.Int1(), 0, KMaxFileName));
	TPtr filePtr = fileBuf->Des();
	aMessage.ReadL(0, filePtr);

	TDriveUnit drive;
	TInt err = Server().PluginDrive(*fileBuf, drive);
	CleanupStack::PopAndDestroy(fileBuf);

	aMessage.Complete(err ? err : static_cast<TInt>(drive));
	}

TInt CCdlSession::ValidIntL(TInt aVal, TInt aMin, TInt aMax) const
	{
	if (aVal < aMin || aMax < aVal)
		{
		User::Leave(KErrArgument);
		}
	return aVal;
	}