// Copyright (c) 2007-2010 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 "ssmcommandlistresourcereaderimpl.h"

#include <bautils.h>

#include <barsc2.h>

#include <ssm/ssmcommandlist.h>

#include <ssm/ssmconditionalcallback.h>

#include <ssm/ssmcommandfactory.h>

#include <ssm/ssmcommand.h>

#include "ssmcommandbase.h"

#include "ssmcommandparameters.h"

#include "ssmcommandlistinterface.h"

#include "ssmdebug.h"

#include "ssmpanic.h"

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

#include "ssmcommandlistimpl.h"

#ifdef __WINS__

#include <u32hal.h>

//Literal to be appended with the main folder path to get the extended folder path

_LIT(KExtendedCommandListPath, "_ext\\");

//Used for checking the presence of keyword for using extended folder in epoc.ini

static TBool IsExtendedFolderDisabled()

    {

    TBool isMinimalBootDisable = EFalse;

    //If the keyword "MINIMALSTART" is found in epoc.ini then only commands from main folder are 

    //executed else commands from both main and extended folder are executed.

    UserSvr::HalFunction(EHalGroupEmulator, EEmulatorHalBoolProperty, (TAny*)"MINIMALSTART", &isMinimalBootDisable);

    return isMinimalBootDisable;

    }

#endif // __WINS__

#endif //SYMBIAN_SSM_FLEXIBLE_MERGE

CSsmCommandListResourceReaderImpl* CSsmCommandListResourceReaderImpl::NewL(RFs& aFs, const TDesC& aCommandListPath, MSsmConditionalCallback& aConditionalCallback)

	{

	CSsmCommandListResourceReaderImpl* self = new(ELeave) CSsmCommandListResourceReaderImpl();

	CleanupStack::PushL(self);

	self->ConstructL(aFs, aCommandListPath, aConditionalCallback);

	CleanupStack::Pop(self);

	return self;

	}

CSsmCommandListResourceReaderImpl::CSsmCommandListResourceReaderImpl()

	{

	}

CSsmCommandListResourceReaderImpl::~CSsmCommandListResourceReaderImpl()

	{

	delete iPreparer;

	delete iInitialiser;

	delete iResourcePool;

	}

void CSsmCommandListResourceReaderImpl::ConstructL(RFs& aFs, const TDesC& aCommandListPath, MSsmConditionalCallback& aConditionalCallback)

	{

	iResourcePool = new(ELeave) CResourcePool;

	iInitialiser = CInitialiser::NewL(aFs, aCommandListPath, *iResourcePool);

	iPreparer = new(ELeave) CPreparer(*iResourcePool, aConditionalCallback);

	}

void CSsmCommandListResourceReaderImpl::Initialise(TRequestStatus& aStatus)

	{

	__ASSERT_ALWAYS(!Busy(), PanicNow(KPanicCmdResourceReader, EInUse1));

	iInitialiser->Start(aStatus);

	}

void CSsmCommandListResourceReaderImpl::InitialiseCancel()

	{

	iInitialiser->Cancel();

	}

void CSsmCommandListResourceReaderImpl::PrepareCommandList(MSsmCommandList& aCommandList, TInt aCommandListId, const TSsmState& aState, TRequestStatus& aStatus)

	{

	__ASSERT_ALWAYS(!Busy(), PanicNow(KPanicCmdResourceReader, EInUse2));

	iPreparer->Start(aCommandList, aCommandListId, aState, aStatus);

	}

void CSsmCommandListResourceReaderImpl::PrepareCommandList(MSsmCommandList& aCommandList, TInt aCommandListId, const TSsmSwp& aSwp, TRequestStatus& aStatus)

	{

	__ASSERT_ALWAYS(!Busy(), PanicNow(KPanicCmdResourceReader, EInUse3));

	iPreparer->Start(aCommandList, aCommandListId, aSwp, aStatus);

	}

void CSsmCommandListResourceReaderImpl::PrepareCommandListCancel()

	{

	iPreparer->Cancel();

	}

TBool CSsmCommandListResourceReaderImpl::IsCommandListReady() const

	{

	// enables caller to find out if the command list they passed

	// to PrepareCommandList is fully prepared or not

	return iPreparer->IsCommandListReady();

	}

TBool CSsmCommandListResourceReaderImpl::Busy() const

	{

	return iInitialiser->IsActive() || iPreparer->IsActive();

	}

void CSsmCommandListResourceReaderImpl::GetCommandListIdsL(RArray<TInt>& aArray) const

	{

	iResourcePool->GetCommandListIdsL(aArray);

	}

// CResourcePool

CSsmCommandListResourceReaderImpl::CResourcePool::CResourcePool()

	{

	}

CSsmCommandListResourceReaderImpl::CResourcePool::~CResourcePool()

	{

	iMappings.Close();

	iResourceFiles.ResetAndDestroy();

	iResourceFileNames.ResetAndDestroy();

	}

TBool CSsmCommandListResourceReaderImpl::CResourcePool::IsEmpty() const

	{

	return !(iMappings.Count() > 0);

	}

void CSsmCommandListResourceReaderImpl::CResourcePool::Reset()

	{

	iMappings.Reset();

	iResourceFiles.ResetAndDestroy();

	iResourceFileNames.ResetAndDestroy();

	}

void CSsmCommandListResourceReaderImpl::CResourcePool::AppendL(const CResourceFile* aResourceFile)

	{

	iResourceFiles.AppendL(aResourceFile);

	}

void CSsmCommandListResourceReaderImpl::CResourcePool::AppendL(const TDesC& aFileName)

	{

	HBufC* name = aFileName.AllocLC();

	iResourceFileNames.AppendL(name);

	CleanupStack::Pop(name);

	}

void CSsmCommandListResourceReaderImpl::CResourcePool::AppendL(const TMapping& aMapping)

	{

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE 

	//check if the mapping already exists

	TInt index = iMappings.Find(aMapping);

	if (index != KErrNotFound)

		{

		DEBUGPRINT2(_L("Duplicate Substate found at index: %d"), index);

		}

	TInt err = iMappings.InsertInSignedKeyOrderAllowRepeats(aMapping);

#else

	TInt err = iMappings.InsertInSignedKeyOrder(aMapping); 

    if(KErrAlreadyExists == err) 

		{ 

		PanicNow(KPanicCmdResourceReader, EDuplicateSubstateInCommandList); 

		} 

#endif

    User::LeaveIfError(err);     

	}

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

// This function will get all the mappings which have the same commandlistId's (substates) into aMappingArray

void CSsmCommandListResourceReaderImpl::CResourcePool::UpdateMappingArrayL(TInt aCommandListId, RArray<TMapping>& aMappingArray) const

	{

	aMappingArray.Reset();

	TMapping mapping(aCommandListId, 0, NULL);

	const TInt mappingCount = iMappings.Count();

	TInt mappingIndex = iMappings.FindL(mapping);

	for(; mappingIndex < mappingCount; ++mappingIndex)

		{

		aMappingArray.AppendL(iMappings[mappingIndex]);

		if ((mappingIndex >= (mappingCount - 1)) || (iMappings[mappingIndex].iCommandListId !=

		iMappings[mappingIndex + 1].iCommandListId))

			{

			//Breaking as it reached end of array or completed appending the mappings for

			//the given commandlist id

			break;

			}

		}

	DEBUGPRINT3(_L("Mapping Array for substate %04x Contains %d entries"), iMappings[mappingIndex].iCommandListId, aMappingArray.Count());

	}

#else

CSsmCommandListResourceReaderImpl::TMapping CSsmCommandListResourceReaderImpl::CResourcePool::MappingL(TInt aCommandListId) const

	{

	TMapping mapping(aCommandListId, 0, NULL);

	const TInt index = iMappings.FindL(mapping);

	return iMappings[index];

	}

#endif

void CSsmCommandListResourceReaderImpl::CResourcePool::GetCommandListIdsL(RArray<TInt>& aArray) const

	{

	TInt count = iMappings.Count();

	__ASSERT_ALWAYS(count > 0, PanicNow(KPanicCmdResourceReader, ENotInitialized3));

	if (aArray.Count() != 0)

		{

		SSMLOGLEAVE(KErrArgument);

		}

	aArray.ReserveL(count);

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

	TInt i = 0;

	for(i = 0; i < iMappings.Count() - 1 ; ++i)

		{

		if(iMappings[i].iCommandListId != iMappings[i+1].iCommandListId)

			{

			aArray.AppendL(iMappings[i].iCommandListId);

			}

		}

	//append the last element anyway as it is already compared

	aArray.AppendL(iMappings[i].iCommandListId);

	aArray.Compress();

	DEBUGPRINT2(_L("The number of substates in resource files : %d"),iMappings.Count() );

	DEBUGPRINT2(_L("The number of substates after filtering duplicates : %d"),aArray.Count());

#else

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

		{

		aArray.AppendL(iMappings[i].iCommandListId);

		}

#endif

	}

const TDesC& CSsmCommandListResourceReaderImpl::CResourcePool::FileNameForResourceFileL(const CResourceFile* aResourceFile) const

	{

	TInt count = iResourceFiles.Count();

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

		{

		if(iResourceFiles[i] == aResourceFile)

			{

			return *iResourceFileNames[i];

			}

		}

	SSMLOGLEAVE(KErrNotFound);

	return KNullDesC16();

	}

// CActiveBase

CSsmCommandListResourceReaderImpl::CActiveBase::CActiveBase(TInt aPriority)

	:CActive(aPriority), iAction(EIdle)

	{

	}

CSsmCommandListResourceReaderImpl::CActiveBase::~CActiveBase()

	{

	}

void CSsmCommandListResourceReaderImpl::CActiveBase::Start()

	{

	TRequestStatus* status = &iStatus;

	User::RequestComplete(status, KErrNone);

	SetActive();

	}

void CSsmCommandListResourceReaderImpl::CActiveBase::CompleteClientRequest(TInt aReason)

	{

	if (iRequestStatus)

		{

		User::RequestComplete(iRequestStatus, aReason);

		iRequestStatus = NULL;

		}

	}

// CInitialiser

CSsmCommandListResourceReaderImpl::CInitialiser* CSsmCommandListResourceReaderImpl::CInitialiser::NewL(RFs& aFs, const TDesC& aCommandListPath, CResourcePool& aResourcePool)

	{

	CInitialiser* self = new(ELeave) CInitialiser(aFs, aResourcePool);

	CleanupStack::PushL(self);

	self->ConstructL(aCommandListPath);

	CleanupStack::Pop(self);

	return self;

	}

CSsmCommandListResourceReaderImpl::CInitialiser::CInitialiser(RFs& aFs, CResourcePool& aResourcePool)

	:CActiveBase(EPriorityStandard),  iFs(aFs), iResourcePool(aResourcePool)

#if defined(SYMBIAN_SSM_FLEXIBLE_MERGE) && defined(__WINS__)

	, iExtendedEntryIndex(0)

#endif //SYMBIAN_SSM_FLEXIBLE_MERGE && __WINS__

	{

	CActiveScheduler::Add(this);

	}

CSsmCommandListResourceReaderImpl::CInitialiser::~CInitialiser()

	{

	Cancel();

	ResetToUninitialisedState();

	iPath.Close();

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

	iSystemDrivePath.Close();

#ifdef __WINS__ 

	iExtendedPath.Close();

#endif //__WINS__

#endif

	}

void CSsmCommandListResourceReaderImpl::CInitialiser::ResetToUninitialisedState()

	{

	delete iResourceFileEntries;

	iResourceFileEntries = NULL;

	iEntryIndex = 0;

	iResourcePool.Reset();

	iAction = EIdle;

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

	delete iRssFileEntriesInSysDrive;

	iRssFileEntriesInSysDrive = NULL;

#ifdef __WINS__ 

	delete iExtendedResourceFileEntries;

	iExtendedResourceFileEntries = NULL;

#endif //__WINS__

#endif

	}

void CSsmCommandListResourceReaderImpl::CInitialiser::ConstructL(const TDesC& aCommandListPath)

	{

	if (aCommandListPath.Length() == 0)

		{

		SSMLOGLEAVE(KErrArgument);

		}

	iPath.CreateL(aCommandListPath);

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

	// get the system drive char and create system drive path 

	TChar systemDriveChar = iFs.GetSystemDriveChar();

	//append the system drive

	iSystemDrivePath.CreateL(iPath.MaxLength());

	iSystemDrivePath.Append(systemDriveChar);

	//append the system drive path which is same as ROM drive path minus ROM drive char 

	iSystemDrivePath.Append(iPath.Right(iPath.Length()-1));

#endif

	}

void CSsmCommandListResourceReaderImpl::CInitialiser::Start(TRequestStatus& aStatus)

	{

	__ASSERT_ALWAYS(iRequestStatus == NULL, PanicNow(KPanicCmdResourceReader, EInUse1));

	aStatus = KRequestPending;

	iRequestStatus = &aStatus;

	iAction = EInitialiseFirstStep;

	CActiveBase::Start();

	}

/**

@panic ENonNullResourceFileEntries if the Resource File Entries is Not Null

@panic ENullResourceFileEntries if the Resource File Entries is Null

@panic EInvalidRunLAction if the RunL Action is invalid

*/

void CSsmCommandListResourceReaderImpl::CInitialiser::RunL()

	{

	SSMLOGLEAVEIFERROR(iStatus.Int());

	switch (iAction)

		{

	case EInitialiseFirstStep:

		DoInitialiseFirstStepL();

		break;

	case EInitialiseNextStep:

		DoInitialiseNextStepL();

		break;

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

	case EInitialiseSysDriveStep:

		DoInitialiseSysDriveStepL();

		break;

#ifdef __WINS__ 

	case EInitialiseExtFolderStep:

	    DoInitialiseExtFolderStepL();

	    break;

#endif //__WINS__

#endif

	default:

		PanicNow(KPanicCmdResourceReader, EInvalidRunLAction);

		break;

		}

	if (iAction == EIdle)

		{

		CompleteClientRequest(KErrNone); // must not leave between here and end of RunL

		return;

		}

	CActiveBase::Start(); // run again

	}

void CSsmCommandListResourceReaderImpl::CInitialiser::DoCancel()

	{

	// iStatus is always completed before this object is set active, so no need to complete iStatus with KErrCancel

	CompleteClientRequest(KErrCancel);

	ResetToUninitialisedState();

	}

TInt CSsmCommandListResourceReaderImpl::CInitialiser::RunError(TInt aError)

	{

	DEBUGPRINT2(_L("Resource reader initialiser reason (%d)"), aError);

	CompleteClientRequest(aError);

	ResetToUninitialisedState();

	return KErrNone;

	}

void CSsmCommandListResourceReaderImpl::CInitialiser::DoInitialiseFirstStepL()

	{

	if (!iResourcePool.IsEmpty())

		{

		// already initialised, don't count this as an error

		iAction = EIdle;

		return;

		}

	// get list of command list resource filenames

	TFileName path(iPath);

	_LIT(KStar, "*");

	path.Append(KStar);

	const TUid KUidResourceFile = {0x101f4a6b};

	__ASSERT_ALWAYS(iResourceFileEntries == NULL, PanicNow(KPanicCmdResourceReader, ENonNullResourceFileEntries));

	// The error cannot be KErrPathNotFound as fallback will be used if there is not startup path

	// Even if there are no resource files, this succeeds

	// User::LeaveIfError handles other error conditions

	User::LeaveIfError(iFs.GetDir(path, TUidType(KUidResourceFile, TUid::Uid(KUidSsmCommandListResourceFile)), ESortNone, iResourceFileEntries));

	iEntryIndex = iResourceFileEntries->Count();

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

#ifdef __WINS__

	if(!IsExtendedFolderDisabled())

	    {

	    TFileName extPath(iPath);

	    extPath.Replace(iPath.Length() - 1, 1, KExtendedCommandListPath);

	    iExtendedPath.CreateL(extPath);

	    DEBUGPRINT2(_L("Extended list path is %S"), &extPath);

	    extPath.Append(KStar);

	    const TInt extErr = (iFs.GetDir(extPath, TUidType(KUidResourceFile, TUid::Uid(KUidSsmCommandListResourceFile)), ESortNone, iExtendedResourceFileEntries));

	    if (KErrNone == extErr)

	        {

	        iExtendedEntryIndex = iExtendedResourceFileEntries->Count();

	        DEBUGPRINT2(_L("Number of resource files in extended folder : %d"), iExtendedEntryIndex);

	        }	    

	    }

#endif //__WINS__

	DEBUGPRINT2(_L("Number of resource files in ROM Drive : %d"),iEntryIndex );

	// Now, get list of command list resource filenames from system drive too

	TFileName sysPath(iSystemDrivePath);

	sysPath.Append(KStar);

	TInt err = (iFs.GetDir(sysPath, TUidType(KUidResourceFile, TUid::Uid(KUidSsmCommandListResourceFile)), ESortNone, iRssFileEntriesInSysDrive));

	if (KErrNone == err)

		{

		iSysDriveEntryIndex = iRssFileEntriesInSysDrive->Count();

		DEBUGPRINT2(_L("Number of resource files in System Drive : %d"),iSysDriveEntryIndex );

		}

	// all other error conditions are ignored as there is no compulsion for resource files to be present on system drive

	else if(KErrPathNotFound == err)

		{

		//the path for SCLs on system drive does not exist

		DEBUGPRINT1(_L("System Drive does not contain command lists"));

		}

	if(iEntryIndex == 0 && iSysDriveEntryIndex == 0)

		{

		DEBUGPRINT3(_L("Command list resource file directories (%S) and (%S) do not contain any command list resource files"), &path, &sysPath);

		SSMLOGLEAVE(KErrNotFound);

		}

#else

	if (iEntryIndex == 0)

		{

		DEBUGPRINT2(_L("Command list resource file directory (%S) does not contain any command list resource files"), &path);

		SSMLOGLEAVE(KErrNotFound);

		}

#endif

	iAction = EInitialiseNextStep;

	}

void CSsmCommandListResourceReaderImpl::CInitialiser::DoInitialiseNextStepL()

	{

	__ASSERT_ALWAYS(iResourceFileEntries != NULL, PanicNow(KPanicCmdResourceReader, ENullResourceFileEntries));

	if (iEntryIndex--)

		{

		TFileName filename(iPath);

		filename.Append((*iResourceFileEntries)[iEntryIndex].iName);

		CResourceFile* const resourceFile = OpenResourceFileL(filename);

		ParseFileL(resourceFile);

		}

	else

		{

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

		iAction = EInitialiseSysDriveStep;

#else

		// initialisation complete

		iAction = EIdle;

#endif

		delete iResourceFileEntries;

		iResourceFileEntries = NULL;

		}

	}

#ifdef SYMBIAN_SSM_FLEXIBLE_MERGE

void CSsmCommandListResourceReaderImpl::CInitialiser::DoInitialiseSysDriveStepL()

	{

	if (iSysDriveEntryIndex--)

		{

		TFileName filename(iSystemDrivePath);

		filename.Append((*iRssFileEntriesInSysDrive)[iSysDriveEntryIndex].iName);

		CResourceFile* const resourceFile = OpenResourceFileL(filename);

		ParseFileL(resourceFile);

		}