/*

* 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 "CdlLibrary.h"

#include "CCdlEngine.h"

#include <e32svr.h>

#include <f32file.h>

#include <e32uid.h>

#ifdef RD_SECURE_BIN_RES

#include <ecom/ecom.h>

#endif

const TInt KCdlLibManGranularity = 4;

const TUid KCdlLibraryUid = { 0x101F8BD1 };

template<class T> 

inline T* CheckPtrL(T* aPtr)

	{

	if (aPtr == NULL)

		User::Leave(KErrNotFound);

	return aPtr;

	}

//

// RCdlLibrary

//

enum TRCdlLibraryFlags

	{

	ERCdlLibrary_RomOnly

	};

RCdlLibrary::RCdlLibrary() : iName(0), iRefCount(0)

,iEcomDtorUid(KNullUid), iEcomImpl(0)

	{

	}

void RCdlLibrary::Close()

	{

	REComSession::DestroyedImplementation(iEcomDtorUid);

	iEcomDtorUid.iUid = 0;

	iEcomImpl = 0;

	delete iName;

	iName = NULL;

	}

TInt RCdlLibrary::CdlLoad(const TDesC& aLibName, TBool /*aRomOnly*/)

	{

	// get the ECom implementation id from the DLL name

	TParsePtrC parse(aLibName);

	TPtrC name(parse.Name());

	TLex lexer(name);

	TUint32 uid;

	TInt r = lexer.Val(uid, EHex);

	if (r!=KErrNone)

		return r;

	TRAP(r, iEcomImpl = REComSession::CreateImplementationL(TUid::Uid(uid), iEcomDtorUid, NULL));

	delete iName;

	iName = 0;

	if (r==KErrNone)

		{

		iName = aLibName.Alloc();

		if (!iName)

			{

			Close();

			return KErrNoMemory;

			}

		iShortName.Set(ExtractName(*iName));

		}

	return r;

	}

TBool RCdlLibrary::CheckIfNotRomOnly(TBool aRomOnly, const TDesC& aName)

	{

	return	aRomOnly &&

			aName.Length() >= 2 && aName[1] == ':' && 

			aName[0] != 'z' && aName[0] != 'Z';

	}

const SCdlCustomisation* RCdlLibrary::CustomisationL(TUid aUid, TInt aImplId) const

	{

	const TCdlArray<SCdlCustomisation>& contents = ContentsL();

	// first try the micro customisation optimisation, where aImplId is an index into

	// the contents table.

	if (0 <= aImplId && aImplId < contents.iCount)

		{

		const SCdlCustomisation& c = contents[aImplId];

		if (c.iInterface->iUid == aUid && c.iId == aImplId)

			return &c;

		}

	// if that failed, scan the contents table.

	for (TInt ii=0; ii<contents.iCount; ii++)

		{

		const SCdlCustomisation& c = contents[ii];

		if (c.iInterface->iUid == aUid && c.iId == aImplId)

			return &c;

		}

	User::Leave(KErrNotFound);

	return NULL;

	}

const TCdlArray<SCdlCustomisation>& RCdlLibrary::ContentsL() const

	{

	TAny* f = iEcomImpl;

	SCdlMain* m = CheckPtrL((SCdlMain*)(f));

	if (m->iMajorVer != KCdlCompilerMajorVersion || m->iMinorVer != KCdlCompilerMinorVersion)

		User::Leave(KErrCorrupt);

	return *CheckPtrL((const TCdlArray<SCdlCustomisation>*)(m->iData));

	}

TPtrC RCdlLibrary::Name() const

	{

	return iShortName;

	}

const TDesC* RCdlLibrary::FullName() const

	{

	return iName;

	}

TPtrC RCdlLibrary::ExtractName(const TDesC& aLibName)

	{

	// find the postion of the colon in aLibName

	TInt colonPos = aLibName.Locate(':');

	// set name to be after the colon in aLibName, this works when colonPos is KErrNotFound (-1) too

	TPtrC name(aLibName.Mid(colonPos + 1));

	// find the postion of the last slash

	TInt lastSlashPos = name.LocateReverse('\\');

	// move name so that it only contains name after the last slash. Works with -1 again.

	name.Set(name.Mid(lastSlashPos + 1));

	// find the position of the "." in the name

	TInt dotPos = name.Locate('.');

	// if there is a dot, set the name to be the portion before the dot.

	if (dotPos != KErrNotFound)

		name.Set(name.Left(dotPos));

	// name will now be the file name only, without extension.

	return name;

	}

TBool RCdlLibrary::SameShortName(const TDesC& aShortLibName)

    {

    // Call Compare first, because it's much faster if the

	// strings match

	if (iShortName.Compare(aShortLibName) == 0)

		{

		return ETrue;

		}

	return iShortName.CompareF(aShortLibName) == 0;

	}

TBool RCdlLibrary::IsLibLoadedAsRomOnly() const

	{

	return iFlags[ERCdlLibrary_RomOnly];

	}

void RCdlLibrary::SetLibLoadedAsRomOnly()

	{

	iFlags.Set(ERCdlLibrary_RomOnly);

	}

//

// RCdlLibRef

//

RCdlLibRef::RCdlLibRef() : iLibMan(0), iLib(0)

	{

	}

void RCdlLibRef::Close()

	{

	if (iLib && iLibMan)

		iLibMan->Close(iLib);

	iLibMan = 0;

	iLib = 0;

	}

RCdlLibrary* RCdlLibRef::Lib() const

	{

	return iLib;

	}

void RCdlLibRef::SetRef(CCdlLibManager* aLibMan, RCdlLibrary* aLib)

	{

	__ASSERT_ALWAYS(!iLib && !iLibMan, Panic(ECdlEngPanic_LibraryAlreadySet));

	iLibMan = aLibMan;

	iLib = aLib;

	}

TPtrC RCdlLibRef::Name() const

	{

	return iLib->Name();

	}

//

// CCdlLibManager

//

CCdlLibManager::CCdlLibManager() : iLibs(KCdlLibManGranularity)

	{

	}

CCdlLibManager::~CCdlLibManager()

	{

	delete iLazyUnloader;

	TInt count = iLibs.Count();

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

		iLibs[ii]->Close();

	iLibs.ResetAndDestroy();

	if (iEcom)

		{

		iEcom->Close();

		REComSession::FinalClose();

		}

	}

void CCdlLibManager::ConstructL()

	{

	iEcom = &REComSession::OpenL();

	}

RCdlLibRef CCdlLibManager::LoadL(const TDesC& aLibName, RCdlLibrary* aLib, TBool aRomOnly)

	{

	__ASSERT_DEBUG(aLib || !FindLib(aLibName), Panic(ECdlEngPanic_LibraryCanBeFound));

	// load new library if a lib is not supplied

	if (!aLib)

		{

		aLib = new(ELeave) RCdlLibrary;

		CleanupStack::PushL(aLib);

		User::LeaveIfError(aLib->CdlLoad(aLibName, aRomOnly));

		CleanupClosePushL(*aLib);

		iLibs.AppendL(aLib);

		CleanupStack::Pop(2);		// lib->Close() and lib's heap cell

		}

	if (aRomOnly)

		{

		// the lib must be ROM only if aRomOnly is set and we got here.

		aLib->SetLibLoadedAsRomOnly();

		}

	RCdlLibRef ref;

	ref.SetRef(this, aLib);

	aLib->RefCount()++;

	return ref;

	}

void CCdlLibManager::Close(RCdlLibrary* aLib)

	{

	aLib->RefCount()--;

	if (aLib->RefCount()==0 && !iLazyUnloader)

		{

		// note, not (ELeave) because Close can't leave and

		// unloading can always be left till another time if

		// it doesn't work now.

		iLazyUnloader = new CAsyncCallBack(TCallBack(LazyUnload, this), CActive::EPriorityLow);

		if (iLazyUnloader)

			iLazyUnloader->CallBack();

		}

	}

TInt CCdlLibManager::LazyUnload(TAny* aThis)

	{

	static_cast<CCdlLibManager*>(aThis)->DoLazyUnload();

	return 0;

	}

void CCdlLibManager::DoLazyUnload()

	{

	TInt count = iLibs.Count();

	for (TInt ii=count-1; ii>=0; ii--)

		{

		RCdlLibrary* lib = iLibs[ii];

		if (lib->RefCount() <= 0)

			{

			iLibs.Delete(ii--);

			lib->Close();

			delete lib;

			}

		}

	delete iLazyUnloader;

	iLazyUnloader = 0;

	}

RCdlLibrary* CCdlLibManager::FindLib(const TDesC& aLibName) const

	{

	RCdlLibrary* lib = NULL;

	TPtrC libName(RCdlLibrary::ExtractName(aLibName));

	// search for already loaded library

	TInt count = iLibs.Count();

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

		{

		if (iLibs[ii]->SameShortName(libName))

			{

			lib = iLibs[ii];

			break;

			}

		}

	return lib;

	}

TBool CCdlLibManager::IsLibLoadedAsRomOnly(const TDesC& aLibName) const

	{

	RCdlLibrary* lib = FindLib(aLibName);

	return lib && lib->IsLibLoadedAsRomOnly();

	}