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

// System includes

//User Includes
#include "TrkTcbCmdCodes.h"
#include "TrkTcbSrvSessionEngine.h"
// Type definitions

// Constants
const TInt KTrkTcbServerTransferBufferExpandSize = 100;
const TInt KSlot0 = 0;
const TInt KSlot1 = 1;
//const TInt KSlot2 = 2;
const TInt KSlot3 = 3;

// Enumerations

// Classes referenced


//
// CTrkTcbSrvSession (source)
//

//
// CTrkTcbSrvServer::CTrkTcbSrvSession()
//
// Constructor
//
CTrkTcbSrvSession::CTrkTcbSrvSession()
{
}

//
// CTrkTcbSrvServer::~CTrkTcbSrvSession()
//
// Destructor
//
CTrkTcbSrvSession::~CTrkTcbSrvSession()
{
	HandleServerDestruction();
	delete iTransferBuffer;
}

//
// CTrkTcbSrvServer::ConstructL()
//
// Creates an instance of CTrkTcbSrvSession.
//
void CTrkTcbSrvSession::ConstructL()
{
	iTransferBuffer = CBufFlat::NewL(KTrkTcbServerTransferBufferExpandSize);
	iSessionEngine = CTrkTcbSrvSessionEngine::NewL();
}

//
// CTrkTcbSrvServer::NewL()
//
// Static self construction
//
CTrkTcbSrvSession* CTrkTcbSrvSession::NewL()
{
	CTrkTcbSrvSession* self = new(ELeave) CTrkTcbSrvSession();
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
}

//
// CTrkTcbSrvServer::HandleServerDestruction()
//
// Called by the server's destructor. We need to be told that the server is
// being destroyed.
//
void CTrkTcbSrvSession::HandleServerDestruction()
{
	delete iSessionEngine;
	iSessionEngine = NULL;
}

//
// CTrkTcbSrvServer::ServiceL()
//
// Services requests from a client.
// Called by the IPC framework whenever a client sends a request to the server.
//
void CTrkTcbSrvSession::ServiceL(const RMessage2& aMessage)
{
	// Leave's are caught by CASSrvServer::RunError
	iMessage = &aMessage;
	
	const TBool completeMessage = DoServiceL();
	
	//Right now there are no asynchronous message completion.
	//So if the message is not completed, then there is an error and needs to be reported
	//to the client.
	if	(completeMessage)
		aMessage.Complete(KErrNone);
	else
		aMessage.Complete(KErrGeneral);
		
	iMessage=NULL;
}

//
// CTrkTcbSrvServer::ServiceL()
//
// Services the requests.
//
TBool CTrkTcbSrvSession::DoServiceL()
{
	TBool completeMessage = EFalse;
	const TInt cmd = Message().Function();
	//
	switch(cmd)
	{
		case ETrkTcbCmdCodeOpenFile:
			completeMessage = CmdOpenFileL();
			break;
		case ETrkTcbCmdCodeReadFile:
			completeMessage = CmdReadFileL();
			break;
		case ETrkTcbCmdCodeWriteFile:
			completeMessage = CmdWriteFileL();
			break;
		case ETrkTcbCmdCodeCloseFile:
			completeMessage = CmdCloseFileL();
			break;
		case ETrkTcbCmdCodePositionFile:
			completeMessage = CmdPositionFileL();
			break;
		case ETrkTcbCmdCodeShutDownServer:
			completeMessage = CmdShutDownServer();			
			break;
	
		default:
			Message().Panic(KServerIntiatedSessionPanic, ETrkTcbServerInitiatedClientPanicInvalidOperation);
			break;
	}
		
	return completeMessage;
}

//
// CTrkTcbSrvServer::CmdOpenFileL()
//
// Gets the data for open file request and calls the session engine open file method.
//
TBool CTrkTcbSrvSession::CmdOpenFileL()
{
	const TInt fileNameLength = static_cast<TInt>(Message().Int0());

	if (fileNameLength > 0)
	{
		HBufC* filePath = HBufC::NewLC(fileNameLength);
		TPtr pFilePath(filePath->Des());
		Message().ReadL(KSlot1, pFilePath);
	
		const TUint mode = static_cast<TUint>(Message().Int2());
		
		TTime modifiedTime;
		iSessionEngine->OpenFileL(filePath->Des(), mode, modifiedTime);
		
		TPckgC<TTime> package(modifiedTime);
		Message().WriteL(KSlot3, package);

		CleanupStack::PopAndDestroy(filePath);
		
		return ETrue;
	}
	return EFalse;
}

//
// CTrkTcbSrvServer::CmdReadFileL()
//
// Gets the data for read file request and calls the session engine read file method.
//
TBool CTrkTcbSrvSession::CmdReadFileL()
{
	const TInt dataLength = static_cast<TInt>(Message().Int0());
	
	if (dataLength > 0)
	{
		HBufC8* fileData = HBufC8::NewLC(dataLength);
		TPtr8 ptr(fileData->Des());
		
		iSessionEngine->ReadFileL(ptr);
		
		//write the file data into the client descriptor
		Message().WriteL(KSlot1, ptr);
	
		CleanupStack::PopAndDestroy(fileData);
	}

	return ETrue;
}

//
// CTrkTcbSrvServer::CmdWriteFileL()
//
// Gets the data for write file request and calls the session engine write file method.
//
TBool CTrkTcbSrvSession::CmdWriteFileL()
{
	const TInt fileDataLength = static_cast<TInt>(Message().Int0());
	
	if (fileDataLength > 0)
	{
		HBufC8* fileData = HBufC8::NewLC(fileDataLength);
		TPtr8 pFileData(fileData->Des());
		Message().ReadL(KSlot1, pFileData);
		
		iSessionEngine->WriteFileL(*fileData);

		CleanupStack::PopAndDestroy(fileData);
		
		return ETrue;
	}
	return EFalse;
}

//
// CTrkTcbSrvServer::CmdCloseFileL()
//
// Gets the data for close file request and calls the session engine close file method.
//
TBool CTrkTcbSrvSession::CmdCloseFileL()
{
	TTime modificationTime;
	
	TPckg<TTime> package(modificationTime);
	Message().ReadL(KSlot0, package);
	
	iSessionEngine->CloseFileL(modificationTime);
	
	return ETrue;
}

//
// CTrkTcbSrvServer::CmdPositionFileL()
//
// Gets the data for position file request and calls the session engine position file method.
//
TBool CTrkTcbSrvSession::CmdPositionFileL()
{
	TSeek seek;
	
	TPckg<TSeek> seekPckg(seek);
	Message().ReadL(KSlot0, seekPckg);
	
	TInt offset = static_cast<TInt>(Message().Int1());;

	iSessionEngine->PositionFileL(seek, offset);

	return ETrue;
}

//
// CTrkTcbSrvServer::CmdShutDownServer()
//
// Stops the active scheduler. This way, server process will run to completion.
//
TBool CTrkTcbSrvSession::CmdShutDownServer()
{
	CActiveScheduler::Stop();
	
	return ETrue;
}