// Copyright (c) 2005-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:
// GraphicsTestUtilsServer implementation
// 
//

/**
 @file
 @test
 @internalComponent - Internal Symbian test code 
*/

#include <e32std.h>

#include "GraphicsTestUtilsServer.h"
#include "GraphicsTestUtils.h"

typedef TUint8 TWipeItems;

inline CShutdown::CShutdown()
	:CTimer(-1)
	{CActiveScheduler::Add(this);}
inline void CShutdown::ConstructL()
	{CTimer::ConstructL();}
inline void CShutdown::Start()
	{After(KMyShutdownDelay);}

inline CSmlTestUtilsServer::CSmlTestUtilsServer()
	:CServer2(0,ESharableSessions)
	{}

inline CSmlTestUtilsSession::CSmlTestUtilsSession()
	{}
inline CSmlTestUtilsServer& CSmlTestUtilsSession::Server()
	{return *static_cast<CSmlTestUtilsServer*>(const_cast<CServer2*>(CSession2::Server()));}


void PanicClient(const RMessage2& aMessage,TTestPanic aPanic)
//
// RMessage::Panic() also completes the message. This is:
// (a) important for efficient cleanup within the kernel
// (b) a problem if the message is completed a second time
//
	{
	_LIT(KPanic,"TestServer");
 	aMessage.Panic(KPanic,aPanic);
	}

void CSmlTestUtilsSession::CreateL()
//
// 2nd phase construct for sessions - called by the CServer framework
//
	{
	Server().AddSession();
	User::LeaveIfError(iFs.Connect());
	iFileMan = CFileMan::NewL(iFs);
	}

CSmlTestUtilsSession::~CSmlTestUtilsSession()
	{
	Server().DropSession();
	iFs.Close();
	delete iFileMan;
	}


void CSmlTestUtilsSession::ServiceL(const RMessage2& aMessage)
//
// Entry point for when a new message is received
//
	{
	TInt result = KErrNone;

	switch (aMessage.Function())
		{
	case ECreateDir:
		result = DoCreateDirectoryL(aMessage);
		break;
	case ERenameDir:
		result = DoRenameDirectoryL(aMessage);
		break;
	case EDeleteDir:
		result = DoDeleteDirectoryL(aMessage);
		break;
	case ECreateFile:
		result = DoCreateFileL(aMessage);
		break;
	case EDeleteFile:
		result = DoDeleteFileL(aMessage);
		break;
	case EDeleteFileUsingWildcard:
		result = DoDeleteFileUsingWildcardL(aMessage);
		break;
	case ECopyFile:
		result = DoCopyFileL(aMessage);
		break;
	case EReplaceFile:
		result = DoReplaceFileL(aMessage);
		break;
	case EIsFilePresent:
		result = DoIsFilePresentL(aMessage);
		break;
	case ESetReadOnly:
		result = DoSetReadOnlyL(aMessage);
		break;
	case EGetAttributes:
		result = DoGetAttL( aMessage );
		break;
	case ESetAttributes:
		result = DoSetAttL( aMessage );
		break;		
	case ECopyDirectory:
		result = DoCopyDirectoryL(aMessage);
		break;
	case EChangeFilePermission:
		result = DoChangeFilePermissionL(aMessage);
		break;	
	default:
		PanicClient(aMessage,ETestPanicIllegalFunction);
		break;
		}
	aMessage.Complete(result);
	}

TInt CSmlTestUtilsSession::DoCreateDirectoryL(const RMessage2& aMessage)
	{
	TBuf<255> path;
	aMessage.ReadL(0, path);
	TInt ret = iFs.MkDirAll(path);
	return ret;
	}
	
TInt CSmlTestUtilsSession::DoRenameDirectoryL(const RMessage2& aMessage)
	{
	TBuf<100> srcpath;
	aMessage.ReadL(0, srcpath);
	TBuf<100> destpath;
	aMessage.ReadL(1, destpath);
	TInt ret = iFs.Rename(srcpath, destpath);
	
	return ret;	
	}
	
TInt CSmlTestUtilsSession::DoDeleteDirectoryL(const RMessage2& aMessage)
	{
	TBuf<255> path;
	aMessage.ReadL(0, path);
	TInt ret = iFs.RmDir(path);
	return ret;
	}
	
TInt CSmlTestUtilsSession::DoCreateFileL(const RMessage2& aMessage)
	{
	TBuf<100> path;
	aMessage.ReadL(0, path);
	RFile file;
	CleanupClosePushL(file);
	TInt ret = file.Create(iFs, path, EFileRead);
	CleanupStack::PopAndDestroy(&file);
	return ret;
	}
	
	
TInt CSmlTestUtilsSession::DoDeleteFileL(const RMessage2& aMessage)
	{
	TBuf<100> path;
	aMessage.ReadL(0, path);
	TInt ret = iFs.Delete(path);
	return ret;	
	}

TInt CSmlTestUtilsSession::DoDeleteFileUsingWildcardL(const RMessage2& aMessage)
	{
	TBuf<100> path;
	aMessage.ReadL(0, path);
	TInt ret = iFileMan->Delete(path);
	return ret;	
	}

TInt CSmlTestUtilsSession::DoCopyFileL(const RMessage2& aMessage)
	{
	TBuf<100> srcpath;
	aMessage.ReadL(0, srcpath);
	
	TBuf<100> destpath;
	aMessage.ReadL(1, destpath);
	
	TInt ret = iFileMan->Copy(srcpath,destpath);
	return ret;	
	}

TInt CSmlTestUtilsSession::DoReplaceFileL(const RMessage2& aMessage)
	{
	TBuf<100> srcpath;
	aMessage.ReadL(0, srcpath);
	TUint lFileMode;
	TPckgBuf<TUint> temp;
	aMessage.ReadL(1, temp);
	
	lFileMode=temp();
	RFile file;
	
	TInt ret = file.Replace(iFs,srcpath,lFileMode);
	return ret;	
	}

TInt CSmlTestUtilsSession::DoIsFilePresentL(const RMessage2& aMessage)
	{
	TFileName srcpath;
	aMessage.ReadL(0, srcpath);

	TEntry entry;
	TInt err = iFs.Entry(srcpath, entry);
	if (err == KErrNotFound)
		{
		aMessage.WriteL(1,TPckgBuf<TBool>(EFalse));
		}
	else
		{
		aMessage.WriteL(1,TPckgBuf<TBool>(ETrue));
		}

	return KErrNone;
	}

TInt CSmlTestUtilsSession::DoSetReadOnlyL(const RMessage2& aMessage)
	{
	TBuf<100> srcpath;
	aMessage.ReadL(0, srcpath);
	TUint attMask;
	TPckgBuf<TUint> temp;
	aMessage.ReadL(1, temp);
	
	attMask=temp();
	TInt ret = iFs.SetAtt(srcpath,attMask,KEntryAttReadOnly);
	return ret;	
	}
	
TInt CSmlTestUtilsSession::DoGetAttL( const RMessage2& aMessage )
	{
	
	TFileName nameBuf;
	TUint attributes = 0;
	
	aMessage.ReadL( 0, nameBuf );
	
	TInt err = iFs.Att( nameBuf, attributes );	
	
	if ( KErrNone == err )
		{
		aMessage.WriteL( 1, TPckgBuf<TInt>(attributes) );
		}
	
	
	return err;
	}


TInt CSmlTestUtilsSession::DoSetAttL( const RMessage2& aMessage )
	{
	
	TFileName nameBuf;
	aMessage.ReadL( 0, nameBuf );
	
	TUint setAttMask = *(TUint*)aMessage.Ptr1();
	TUint clearAttMask = *(TUint*)aMessage.Ptr2();
	
	TInt err = iFs.SetAtt( nameBuf, setAttMask, clearAttMask );
	
	
	return err;
	}
	
void CSmlTestUtilsSession::ServiceError(const RMessage2& aMessage,TInt aError)
//
// Handle an error from CMySession::ServiceL()
// A bad descriptor error implies a badly programmed client, so panic it;
// otherwise use the default handling (report the error to the client)
//
	{
	if (aError==KErrBadDescriptor)
		PanicClient(aMessage,ETestPanicBadDescriptor);
	CSession2::ServiceError(aMessage,aError);
	}


TInt CSmlTestUtilsSession::DoCopyDirectoryL(const RMessage2& aMessage)
	{
	TBuf<100> source;
	aMessage.ReadL(0, source);
	
	TBuf<100> target;
	aMessage.ReadL(1, target);
	
	TInt ret = iFileMan->Copy(source,target, CFileMan::ERecurse);
	return ret;		
	}


void CShutdown::RunL()
//
// Initiate server exit when the timer expires
//
	{
	CActiveScheduler::Stop();
	}

CServer2* CSmlTestUtilsServer::NewLC()
	{
	CSmlTestUtilsServer* self=new(ELeave) CSmlTestUtilsServer;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}

void CSmlTestUtilsServer::ConstructL()
//
// 2nd phase construction - ensure the timer and server objects are running
//
	{
	StartL(KTestServerName);
	iShutdown.ConstructL();
	// ensure that the server still exits even if the 1st client fails to connect
	iShutdown.Start();
	}


CSession2* CSmlTestUtilsServer::NewSessionL(const TVersion&,const RMessage2&) const
//
// Cretae a new client session. This should really check the version number.
//
	{
	return new(ELeave) CSmlTestUtilsSession();
	}

void CSmlTestUtilsServer::AddSession()
//
// A new session is being created
// Cancel the shutdown timer if it was running
//
	{
	++iSessionCount;
	iShutdown.Cancel();
	}

void CSmlTestUtilsServer::DropSession()
//
// A session is being destroyed
// Start the shutdown timer if it is the last session.
//
	{
	if (--iSessionCount==0)
		iShutdown.Start();
	}
	





//Given the name of a read-only file, this functions clears the read-only attribute on the file
TInt CSmlTestUtilsSession::DoChangeFilePermissionL(const RMessage2& aMessage)
	{
	TInt ret(0);
	TRequestStatus status;
	TTime time(0); 
	CFileMan* fileman = CFileMan::NewL (iFs);
	CleanupStack::PushL(fileman);
	TBuf<100> path;
	aMessage.ReadL(0, path);
	ret = fileman->Attribs(path,KEntryAttNormal,KEntryAttReadOnly, time,0,status);
	User::WaitForRequest(status);
	ret = status.Int(); 
	CleanupStack::PopAndDestroy(); 
	return ret;	
	}