/*

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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: 

* Scr Accessor - server and implementation

*

*/

/**

 @file 

 @test

 @internalComponent

*/

#include "tscraccessor_server_session.h"

#include "tscraccessor_common.h"

#include "tscraccessor_client.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include "screntries_internal.h"

#endif //SYMBIAN_ENABLE_SPLIT_HEADERS

#include <scs/cleanuputils.h>

#include <usif/usiferror.h>

using namespace Usif;

/////////////////////// Utility functions //////////////////////////////

void StartTimer(TTime& aTimer)

	{

	aTimer.HomeTime();

	}

TInt StopTimer(TTime aStartTimer)

	{

	TTime endTime;

	endTime.HomeTime();

	TTimeIntervalMicroSeconds duration = endTime.MicroSecondsFrom(aStartTimer);

	TInt actualDuration = I64INT(duration.Int64())/1000; // in millisecond

	return actualDuration;

	}

//////////////////////// Server implementation /////////////////////////

CServer2* CScrAccessServer::NewLC()

	{

	CScrAccessServer* self=new(ELeave) CScrAccessServer;

	CleanupStack::PushL(self);

	self->ConstructL();

	return self;

	}

CScrAccessServer::CScrAccessServer()

	:CServer2(0, ESharableSessions)

	{

	}

CScrAccessServer::~CScrAccessServer()

	{

	iScrSession.Close();

	}

void CScrAccessServer::ConstructL()

	{

	StartL(KScrAccessServerName);

	}

CSession2* CScrAccessServer::NewSessionL(const TVersion&, const RMessage2&) const

	{

	return new(ELeave) CScrAccessSession();

	}

void CScrAccessServer::AddSession()

	{

	++iSessionCount;

	}

void CScrAccessServer::DropSession()

	{

	--iSessionCount;

	if(!iSessionCount)

		CActiveScheduler::Stop();

	}

//////////////////////// Session implementation /////////////////////////

CScrAccessSession::CScrAccessSession()

	{

	}

void CScrAccessSession::CreateL()

	{

	Server().AddSession();

	}

CScrAccessSession::~CScrAccessSession()

	{

	Server().DropSession();

	}

HBufC* ReadDescFromMessageLC(const RMessage2& aMessage, TInt aSlot)

	{

	TInt len = aMessage.GetDesLengthL(aSlot);

	HBufC* desc = HBufC::NewLC(len);

	TPtr ptrDesc(desc->Des());

	aMessage.ReadL(aSlot, ptrDesc);

	return desc;

	}

void VerifySoftwareTypeAdditionL(TInt& aError, RScrAccessor::TAccessorOperationResult& aOpResult, RSoftwareComponentRegistry& aScrSession, const TDesC& aMimeType, TUid aExpectedPluginUid)

	{

	// Do verification, there is no error until this step

	if(KErrNone == aError)

		{ // if adding software type operation is successful, check if the software type has really been added to teh sCR.

		  // Get the plugin uid of the newly added MIME type

		TUid retrievedPluginUid;

		TRAP(aError, retrievedPluginUid = aScrSession.GetPluginUidL(aMimeType));

		if(KErrNone == aError)

			{ // if the plugin uid is found, then compare it with the expected one.

			if(retrievedPluginUid != aExpectedPluginUid)

				aOpResult = RScrAccessor::EOpFailUnexpectedPluginUid;

			}

		else if(KErrNotFound == aError)

			aOpResult = RScrAccessor::EOpFailSwTypeNotFound;

		// if the returned error is different from KErrNone and KErrNotFound, pass it to the client.

		}

	}

void GenerateTestDataL(RPointerArray<HBufC>& aMimeTypes, const TDesC& aBaseMimeTypeName, TInt aMimeTypeNum, RPointerArray<CLocalizedSoftwareTypeName>& aLocalizedSwTypeNames, const TDesC& aBaseSwTypeName, TInt aSwTypesNum)

	{

	RBuf buf;

	buf.CreateL(aBaseMimeTypeName.Length() + 3); // 3 is extra bytes to append number to the buffer

	buf.CleanupClosePushL();

	buf.Copy(aBaseMimeTypeName);

	for(TInt i=0; i<aMimeTypeNum; ++i)

		{

		buf.AppendNum(i);

		HBufC *name = buf.AllocLC();

		aMimeTypes.AppendL(name);

		CleanupStack::Pop(name);

		buf.SetLength(buf.Length()-1);

		}

	buf.Close();

	buf.CreateL(aBaseSwTypeName.Length() + 3);

	buf.Copy(aBaseSwTypeName);

	for(TInt i=0; i<aSwTypesNum; ++i)

		{

		buf.AppendNum(i);

		CLocalizedSoftwareTypeName *localizedName = CLocalizedSoftwareTypeName::NewL(buf, TLanguage(i+1));

		CleanupStack::PushL(localizedName); // Use NewL for coverage

		aLocalizedSwTypeNames.AppendL(localizedName);

		CleanupStack::Pop(localizedName); // ownership is transferred

		}

	CleanupStack::PopAndDestroy(&buf);

	}

	{

	RPointerArray<HBufC> mimeTypesArray;

	CleanupResetAndDestroyPushL(mimeTypesArray);

	RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;

	CleanupResetAndDestroyPushL(localizedSwNames);

	GenerateTestDataL(mimeTypesArray, aBaseMimeTypeName, aMimeTypeNum, localizedSwNames, aBaseSwTypeName, aSwTypesNum);

	RPointerArray<CLocalizedSoftwareTypeName> *plocalizedSwNames = 	&localizedSwNames;

	if(!aSwTypesNum)

		plocalizedSwNames = NULL;

	HBufC *mimeType2BChecked (0);

	if(mimeTypesArray.Count() > 0)

		mimeType2BChecked = mimeTypesArray[0]->AllocLC();

	else

		mimeType2BChecked = KNullDesC().AllocLC();

	VerifySoftwareTypeAdditionL(err, aOpResult, aScrSession, *mimeType2BChecked, aSifPluginUid);

	return err;

	}

void CScrAccessSession::ServiceL(const RMessage2& aMessage)

	{

	TInt err(0);

	TTime timer;

	StartTimer(timer);

	TInt actualTestDuration(0);

	RScrAccessor::TAccessorOperationResult opResult = RScrAccessor::EOpSucessful;

	TScrAccessMessages f = static_cast<TScrAccessMessages>(aMessage.Function());

	if(EAddSoftwareType == f || EDeleteSoftwareType == f)

		{

		User::LeaveIfError(Server().ScrSession().Connect());

		// create transaction on SCR for mutable operations

		Server().ScrSession().CreateTransactionL();

		}

	switch (f)

		{

		case EAddSoftwareType:

			{

			RScrAccessor::TAccessorOperationType opType = static_cast<RScrAccessor::TAccessorOperationType>(aMessage.Int0());

			TUid localizedSifPluginUid = {0xA01B7222};

			_LIT(KMimeTypeBaseNameLocalized, "test_mimetype_localizedinstaller");

			_LIT(KSwTypeBaseLocalizableName, "test_localizedinstaller_name");

			_LIT(KSwTypeUniqueNameLocalized, "test_localizedinstaller_uniquename");

			switch(opType)

				{

				case RScrAccessor::EAddNonLocalizedSoftwareType:

					{	

					TUid sifPluginUid = {0xA01B7211};

					_LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");

					_LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");

					break;

					}

				case RScrAccessor::EAddLocalizedSoftwareType:

					{

					break;

					}

				case RScrAccessor::EAddSofwtareTypeWithoutMimeTypes:

					{

					TUid sifPluginUid = {0xA01B7333};

					_LIT(KSwTypeUniqueName, "test_nomimeinstaller_uniquename");

					break;

					} 

				case RScrAccessor::EAddLocalizedSoftwareTypeWithDifferentPluginUid:

					{

					TUid localizedDifferentSifPluginUid = {0xCC1B7333};

					if(KErrAlreadyExists == err)

						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

					break;

					}

				case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraName:

					{

					if(KErrAlreadyExists == err)

						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

					break;

					}

				case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingName:

					{

					if(KErrAlreadyExists == err)

						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

					break;

					}

				case RScrAccessor::EAddLocalizedSoftwareTypeWithExtraMime:

					{

					if(KErrAlreadyExists == err)

						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

					break;

					}

				case RScrAccessor::EAddLocalizedSoftwareTypeWithMissingMime:

					{

					if(KErrAlreadyExists == err)

						err = KErrNone; // The expected result is KErrAlreadyExists. So return no error to the test client.

					break;

				} // switch(opType)

			actualTestDuration = StopTimer(timer);

			break;

			}

		case EDeleteSoftwareType:

			{

			_LIT(KSwTypeUniqueName, "test_nonlocalizedinstaller_uniquename");

			_LIT(KMimeTypeBaseName, "test_mimetype_nonlocalizedinstaller");

			RPointerArray<HBufC> deletedMimeTypes;

			CleanupResetAndDestroyPushL(deletedMimeTypes);

			TRAP(err, Server().ScrSession().DeleteSoftwareTypeL(KSwTypeUniqueName,deletedMimeTypes));

			actualTestDuration = StopTimer(timer);

			// If the delete operation is successfull, check the returned MIME types deleted are as expected.

			// If the delete operation fails, just return the error code to teh client.

			if(KErrNone == err) 

				{

				RPointerArray<HBufC> mimeTypesArray;

				CleanupResetAndDestroyPushL(mimeTypesArray);

				RPointerArray<CLocalizedSoftwareTypeName> localizedSwNames;

				GenerateTestDataL(mimeTypesArray, KMimeTypeBaseName, 2, localizedSwNames, KNullDesC, 0);

				TInt expectedMimeTypesCount = mimeTypesArray.Count();

				TInt retrievedMimeTypesCount = deletedMimeTypes.Count();

				if(retrievedMimeTypesCount != expectedMimeTypesCount)

					opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;

				else

					{

					for(TInt i=0; i<retrievedMimeTypesCount; ++i)

						{

						if(*(deletedMimeTypes[i]) != *(mimeTypesArray[i]))

							opResult = RScrAccessor::EOpFailUnexpectedMimeTypeNum;;

						} // for

					} // if-else

				TRAP(err, Server().ScrSession().GetPluginUidL(KSwTypeUniqueName));

				if(KErrNone == err)

					{

					// The plugin UID has been retrieved successfully. This is unexpected result.

					opResult = RScrAccessor::EOpFailSwTypeStillExists;

					}

				else if(KErrSifUnsupportedSoftwareType == err)

					{

					// The plugin UID couldn't be found as expected. As the operation is successfull,

					// return KErrNone to the client

					err = KErrNone;

					}

				CleanupStack::PopAndDestroy(&mimeTypesArray);

				} 

			CleanupStack::PopAndDestroy(&deletedMimeTypes);

			break;

			}

		case EDeleteFile:

			{

			HBufC *file = ReadDescFromMessageLC(aMessage, 0);

			RFs fs;

			User::LeaveIfError(fs.Connect());

			CleanupClosePushL(fs);

			err = fs.Delete(*file);

			CleanupStack::PopAndDestroy(2, file); // file, fs

			break;

			}

		case ECopyFile:

			{

			HBufC *sourceFile = ReadDescFromMessageLC(aMessage, 0);

			HBufC *targetFile = ReadDescFromMessageLC(aMessage, 1);

			RFs fs;

			User::LeaveIfError(fs.Connect());

			CleanupClosePushL(fs);

			CFileMan* fileManager = CFileMan::NewL(fs);

			CleanupStack::PushL(fileManager);

			err = fileManager->Copy(*sourceFile, *targetFile, 0);

			// Reset the read-only attribute on the copied file

			TTime time;

			User::LeaveIfError(fileManager->Attribs(*targetFile, 0, KEntryAttReadOnly, time));		

			CleanupStack::PopAndDestroy(4, sourceFile); // sourceFile, targetFile, fs, fileManager

			break;

			}

		default:

			{

			PanicClient(aMessage, EPanicIllegalFunction);

			break;

			}

		}

	if(EAddSoftwareType == f || EDeleteSoftwareType == f)

		{

		// create transaction on SCR for mutable operations

		Server().ScrSession().CommitTransactionL();

		TPckg<TInt> timePckg(actualTestDuration);

		TPckg<RScrAccessor::TAccessorOperationResult> opResultPckg(opResult);

		if(EDeleteSoftwareType == f)

			{

			aMessage.WriteL(0, opResultPckg);

			aMessage.WriteL(1, timePckg);

			}

		else if (EAddSoftwareType == f)

			{

			aMessage.WriteL(1, opResultPckg);

			aMessage.WriteL(2, timePckg);

			}

		}

	aMessage.Complete(err);

	}

void CScrAccessSession::ServiceError(const RMessage2& aMessage, TInt aError)

	{

	if (aError == KErrBadDescriptor)

		PanicClient(aMessage, EPanicBadDescriptor);

	CSession2::ServiceError(aMessage,aError);

	}