// Copyright (c) 2009 - 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:

// aplappinforeader.cpp

//

/** 

* @file aplappinforeader.cpp

*

* @internalComponent

* @released

*/

#include <stdlib.h> 

#include <iostream.h> 

#include <string> 

#include "aplappinforeader.h"

#include "barsc2.h"

#include "barsread2.h"

#include <cassert>

#include "parse.h"

#include "uidtype.h"

#include "stringutils.h"

#include "is_utils.h"

#include "apsecutils.h"

#include "parse.h"

using namespace std;

const TUint KNonLocalized = 0;

#define REINTERPRET_CAST(type,exp) (reinterpret_cast<type>(exp))

const TUint KResourceOffsetMask = 0xFFFFF000;

std::string KAppBinaryPathAndExtension("\\sys\\bin\\.exe");

const TInt KAppRegistrationInfoResourceId = 1;

// The 2nd UID that defines a resource file as being an application registration resource file.

const TUid KUidAppRegistrationFile = {0x101F8021};

/**

@internalTechnology

*/

std::string KAppResourceFileExtension(".rsc");

std::string KLitPathForUntrustedRegistrationResourceFiles("\\private\\10003a3f\\import\\apps\\");

//

// CAppInfoReader

//

// The behaviour of the Take-methods of this class is a little non-standard, as it

// transfers ownership of the pointer owned by a CAppInfoReader derived object

// to the caller. This means that this function is only designed to be called once.

// Doing things this way provides a small performance optimisation by enabling the caller

// to delete it's stored pointer, and replace it with one returned by this function,

// instead of having to copy the object (copying could be expensive for the methods

// of this class that need to return arrays).

CAppInfoReader* CAppInfoReader::NewL(const std::string& aRegistrationFileName, TUid aAppUid, const std::string& aLocalizeFilePath)

{

	CAppInfoReader* self = new CAppInfoReader(aRegistrationFileName, aAppUid, aLocalizeFilePath);

	if(NULL == self)

	{

		std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

		throw CResourceFileException(errMsg);

	}

	return self;

}

CAppInfoReader::CAppInfoReader(const std::string& aRegistrationFileName, TUid aAppUid, const std::string& aLocalizeFilePath) :

	iAppUid(aAppUid),

	iDefaultScreenNumber(0),

	iNonMbmIconFile(false),

	iApplicationLanguage(ELangNone),

	iIndexOfFirstOpenService(KErrNotFound),

	iRegistrationFileName(aRegistrationFileName),

	iDrivePath(aLocalizeFilePath)

	{

	 	iAppBinaryFullName = NULL;;

		iCapability.iGroupName = NULL;

		iCaption = NULL;

		iShortCaption = NULL;

		iViewDataArray = NULL;;

		iOwnedFileArray = NULL;

		iIconFileName = NULL;

	 	iLocalisableResourceFileName = NULL;

		iServiceArray = NULL;

	}

CAppInfoReader::~CAppInfoReader()

{

	delete iAppBinaryFullName;

	delete iCaption;

	delete iShortCaption;

	if(iViewDataArray)

		iViewDataArray->clear();

	delete iViewDataArray;

	if(iOwnedFileArray)

		iOwnedFileArray->clear();

	delete iOwnedFileArray;

	delete iIconFileName;

	delete iLocalisableResourceFileName;

	if(iServiceArray)

		iServiceArray->clear();

	delete iServiceArray;

	if(iAppLocalizableInfo.size())

		iAppLocalizableInfo.clear();

	if(iOpaqueDataArray.size())

		iOpaqueDataArray.clear();

}

Ptr16* CAppInfoReader::AppBinaryFullName()

{

	Ptr16* fileName = iAppBinaryFullName;

	return fileName;

}

TUidType CAppInfoReader::AppBinaryUidType() const

{

	return iAppBinaryUidType;

}

TUid CAppInfoReader::AppUid() const

{

	return iAppUid;

}

void CAppInfoReader::Capability(TAppCapability& aCapabilityBuf) const

{

	memcpy(&aCapabilityBuf, &iCapability,sizeof(TAppCapability));

}

TUint CAppInfoReader::DefaultScreenNumber() const

{

	return iDefaultScreenNumber;

}

Ptr16* CAppInfoReader::Caption()

{

	Ptr16* caption = iCaption;

	iCaption = NULL; // ownership transferred to caller

	return caption;

}

Ptr16* CAppInfoReader::ShortCaption()

{

	Ptr16* shortCaption = iShortCaption;

	iShortCaption = NULL; // ownership transferred to caller

	return shortCaption;

}

TInt CAppInfoReader::NumOfAppIcons() const

{

	return iNumOfAppIcons;

}

std::vector<CAppViewData*>* CAppInfoReader::Views()

{

	std::vector<CAppViewData*>* viewDataArray = iViewDataArray;

	iViewDataArray = NULL; // ownership transferred to caller

	return viewDataArray;

}

std::vector<CAppLocalizableInfo*> CAppInfoReader::LocalizableInfo()

{

	std::vector<CAppLocalizableInfo*> AppLocalizableInfo = iAppLocalizableInfo;

	return AppLocalizableInfo;

}

std::vector<CAppLocalOpaqueDataInfo*> CAppInfoReader::GetOpaqueDataArray()

{

	std::vector<CAppLocalOpaqueDataInfo*> opaqueDataArray = iOpaqueDataArray;

	return opaqueDataArray;

}

std::vector<Ptr16*>* CAppInfoReader::OwnedFiles()

{

	std::vector<Ptr16*>* ownedFileArray = iOwnedFileArray;

	iOwnedFileArray = NULL; // ownership transferred to caller

	return ownedFileArray;

}

Ptr16* CAppInfoReader::IconFileName()

{

	Ptr16* iconFileName = iIconFileName;

	iIconFileName = NULL; // ownership transferred to caller

	return iconFileName;

}

TBool CAppInfoReader::NonMbmIconFile() const

{

	return iNonMbmIconFile;

}

Ptr16* CAppInfoReader::LocalisableResourceFileName()

{

	Ptr16* localisableResourceFileName = iLocalisableResourceFileName;

	iLocalisableResourceFileName = NULL; // ownership transferred to caller

	return localisableResourceFileName;

}

TLanguage CAppInfoReader::AppLanguage() const

{

	return iApplicationLanguage;

}

std::vector<TAppServiceInfo*>* CAppInfoReader::ServiceArray(TInt& aIndexOfFirstOpenService)

{

	std::vector<TAppServiceInfo*>* serviceArray = iServiceArray;

	iServiceArray = NULL;

	aIndexOfFirstOpenService = iIndexOfFirstOpenService;

	return serviceArray;

}

TBool CAppInfoReader::ReadL(const std::vector<FileDescription*>& aFileDescription, std::string& aRomPath, int aInRom )

{

		TUint fileOffset = 0;

		TInt fileLength = 0;

		TUid firstUid(KExecutableImageUidVal);

		TUid middleUid(KUidApp);

		TInt err;

		TInt LocalizeError = 0;

		TUid reguid;

		CResourceFile* registrationFile = new CResourceFile(iRegistrationFileName, fileOffset, fileLength);

		if(NULL==registrationFile)

		{

			std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

			throw CResourceFileException(errMsg);

		}

		if(registrationFile)

		{

			iAppUid = registrationFile->ReadAppUidL();

			if(!iAppUid.GetUid())

			{

				std::string errMsg= "Failed : Invalid Resource File. Null Application UID.";

				throw CResourceFileException(errMsg);

			}

			reguid = registrationFile->ReadFileUidL();

			if(reguid.GetUid()!= KUidAppRegistrationResourceFile)

			{

				std::string errMsg= "Failed : Invalid Resource File. UID2 is not defined.";

				throw CResourceFileException(errMsg);

			}

		}

		// set the TUidType for the app binary

		// cannot read the TEntry info from the app binary because it's in \sys\bin

		iAppBinaryUidType = TUidType(firstUid, middleUid, iAppUid); 

		RResourceReader resourceReader;

		resourceReader.OpenL(registrationFile, KAppRegistrationInfoResourceId); 

		TUint localisableResourceId = 1; // only initialising this here to keep the compiler happy, as it's concerned that the variable might be used without having been initialised. The variable should be initialised later, before it's used

		try {

				ReadMandatoryInfoL(resourceReader);

				err = ReadNonLocalisableInfoL(resourceReader, localisableResourceId);

				if (!err)

				{	

					err = ReadNonLocalisableOptionalInfoL(resourceReader, registrationFile);

				}

			}

			catch(const CResourceFileException& aObject)

			{

				delete registrationFile;

				cout<< aObject.GetMsg()<< endl;

				return EFalse; // might have read something, but failed to setup enough info to make it worthwhile trying to read any more

			}

		TBool useDefaultIcons = ETrue;

		if(iLocalisableResourceFileName)

		{

			std::string localizeFileName = Ptr16ToString(iLocalisableResourceFileName);

			std::vector<FileDescription*>::const_iterator filedesIter;

			//std::wstring iFile;

			std::wstring iLocalizeFile;

			//std::string aFileName;

			std::string iLocalFilePath;

			std::string iLocalFileExt(".r");

			for(filedesIter = aFileDescription.begin() ; filedesIter != aFileDescription.end(); ++filedesIter)

			{

				iLocalizeFile = (*filedesIter)->GetLocalFile();

				iLocalFilePath = wstring2string(iLocalizeFile);

				if((iLocalFilePath.find(localizeFileName,0) == std::wstring::npos) 

						|| (iLocalFilePath.find(iLocalFileExt,0) == std::wstring::npos))

					continue;

				size_t found;

				std::string Locale;

				int iLocale = 0;

				found=iLocalFilePath.find_last_of(".");

				if(found)

					Locale = iLocalFilePath.substr(found+2);

				iLocale = atoi(Locale.c_str()); 

				if(!iLocale)

					iLocale = KNonLocalized;

				CResourceFile* tlocalisableFile = NULL;

				if(aInRom)

				{

					std::string LocalFile = FullNameWithoutDrive(iLocalFilePath);

					iLocalFilePath = aRomPath + LocalFile;

				}

				try {

					// open the localisable resource file	

					tlocalisableFile = new CResourceFile(iLocalFilePath, 0, 0);

					if(NULL==tlocalisableFile)

					{

						std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

						throw CResourceFileException(errMsg);

					}

					if (!err)

					{

						if (tlocalisableFile && (localisableResourceId & KResourceOffsetMask))

							tlocalisableFile->ConfirmSignatureL();

						err = ReadLocalisableInfoLoopL(*tlocalisableFile, localisableResourceId, useDefaultIcons, iLocale);

					}

					delete tlocalisableFile;

				}

				catch(const CResourceFileException& aObject)

				{

					LocalizeError = 1;

					aObject.Display();

					delete tlocalisableFile;

				}

			}

		}

	// if anything went wrong, we tell the caller that the read was unsuccessful. Some

	// of the members of this class may contain data which is not complete, but this doesn't matter

	// because the caller shouldn't try to access the data if the read was unsuccessful

	TBool readSuccessful = 0;

	if(!LocalizeError)

		readSuccessful = (err == KErrNone);

	delete registrationFile;

	return readSuccessful;

}

// reads as much info as it can

// at least captions and icons must be setup on return from this method (using defaults if necessary)

TBool CAppInfoReader::ReadL()

{

	TUint fileOffset = 0;

	TInt fileLength = 0;

	TUid firstUid(KExecutableImageUidVal);

	TUid middleUid(KUidApp);

	TInt err;

	TInt LocalizeError = 0;

	TUid reguid;

	CResourceFile* registrationFile = new CResourceFile(iRegistrationFileName, fileOffset, fileLength);

	if(NULL==registrationFile)

	{

		std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

		throw CResourceFileException(errMsg);

	}

	if(registrationFile)

	{

		iAppUid = registrationFile->ReadAppUidL();

		if(!iAppUid.GetUid())

		{

			std::string errMsg= "Failed : Invalid Resource File. Null Application UID.";

			throw CResourceFileException(errMsg);

		}

		reguid = registrationFile->ReadFileUidL();

		if(reguid.GetUid()!= KUidAppRegistrationResourceFile)

		{

			std::string errMsg= "Failed : Invalid Resource File. UID2 is not defined.";

			throw CResourceFileException(errMsg);

		}

	}

	// set the TUidType for the app binary

	// cannot read the TEntry info from the app binary because it's in \sys\bin

	iAppBinaryUidType = TUidType(firstUid, middleUid, iAppUid);	

	RResourceReader	resourceReader;

	resourceReader.OpenL(registrationFile, KAppRegistrationInfoResourceId);	

	TUint localisableResourceId = 1; // only initialising this here to keep the compiler happy, as it's concerned that the variable might be used without having been initialised. The variable should be initialised later, before it's used

	try {

			ReadMandatoryInfoL(resourceReader);

			err = ReadNonLocalisableInfoL(resourceReader, localisableResourceId);

			if (!err)

			{	

				err = ReadNonLocalisableOptionalInfoL(resourceReader, registrationFile);

			}

		}

		catch(const CResourceFileException& aObject)

		{

			delete registrationFile;

			cout<< aObject.GetMsg()<< endl;

			return EFalse; // might have read something, but failed to setup enough info to make it worthwhile trying to read any more

		}

	TBool useDefaultIcons = ETrue;

	if(iLocalisableResourceFileName)

	{

		std::string localizeFileName = Ptr16ToString(iLocalisableResourceFileName);

		std::string folder;

		std::string file;

		size_t found;

		std::string iLocalPath(iDrivePath);

	  	if(found)

	  		folder = localizeFileName.substr(0,found);

	  	else

	  	file = localizeFileName.substr(found+1);

		file.append(".");

		iLocalPath.append(folder);

		std::wstring iFilePath = string2wstring(iLocalPath);

		std::wstring iFileName = string2wstring(file);

		iLocalPath.append("\\");

		std::list<std::wstring> locDirs;

		GetDirContents( iFilePath, locDirs );

	 	std::list<std::wstring>::iterator curr = locDirs.begin();

		for( curr = locDirs.begin(); curr != locDirs.end(); ++curr )

		{

			if (curr->find(iFileName,0) != std::wstring::npos)

			{

			    std::string fName;

				std::string sAbsolutePath;

				sAbsolutePath.assign(iLocalPath);

			   	sAbsolutePath.append(fName);

				//cout << sAbsolutePath<<endl;

				std::string Locale;

				int iLocale = 0;

				found=fName.rfind(".r");

				if(found!=string::npos)

					Locale = fName.substr(found+2);

				else

					continue;

				iLocale = atoi(Locale.c_str()); 

			    if(!iLocale)

					iLocale = KNonLocalized;

				CResourceFile* tlocalisableFile = NULL;

				try {

					// open the localisable resource file	

					tlocalisableFile = new CResourceFile(sAbsolutePath, 0, 0);

					if(NULL==tlocalisableFile)

					{

						std::string errMsg= "Failed : Error in Reading File. Memory Allocation Failed";

						throw CResourceFileException(errMsg);

					}