/*

* 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 <e32base.h>

#include "CdlEngine.h"

#include "CdlServEng.h"

#include "CCdlEngine.h"

#include <e32uid.h>

#include <f32file.h>

void Panic(TCdlEngPanic aReason)

	{

	_LIT(KCat, "CdlEng");

	User::Panic(KCat, aReason);

	}

//

// CCdlEngineRef

//

EXPORT_C CCdlEngineRef::~CCdlEngineRef()

	{

	__ASSERT_DEBUG(iRefCount==0 || iRefCount==1, Panic(ECdlEngPanic_BadRefCount));

	ReleaseRef();

	}

CCdlEngineRef::CCdlEngineRef(CCdlEngineBase* aEngine)

: iEngine(aEngine)

	{

	AddRef();

	}

void CCdlEngineRef::AddRef()

	{

	iEngine->IncRefCount();

	iRefCount++;

	}

void CCdlEngineRef::ReleaseRef()

	{

	if (iRefCount > 0)

		{

		iEngine->DecRefCount();

		iRefCount--;

		}

	}

CCdlEngineBase* CCdlEngineRef::Engine() const

	{

	return iEngine;

	}

//

// CdlEngine

//

EXPORT_C TBool CdlEngine::IsCdlEngineCreated()

	{

	return CCdlEngine::Static() != NULL;

	}

EXPORT_C CCdlEngineRef* CdlEngine::CreateCdlEngineL()

	{

	TBool pushed;

	CCdlEngine* eng = CCdlEngine::InstanceLC(pushed);

	CCdlEngineRef* ref = new(ELeave) CCdlEngineRef(eng);

	if (pushed)

		CleanupStack::Pop();

	return ref;

	}

EXPORT_C TAny* CdlEngine::GetData(TUid aCdlUid, TInt aApiId)

	{

	return CCdlEngine::Instance().GetData(aCdlUid, aApiId);

	}

EXPORT_C TCdlEngineFunc* CdlEngine::GetFunction(TUid aCdlUid, TInt aApiId)

	{

	CCdlEngine& eng = CCdlEngine::Instance();

	CCdlCustomisationStack** pCust = eng.iCustomisations.Find(aCdlUid.iUid);

	if(!pCust)

		{

		Panic(ECdlEngPanic_CustomisationNotPresent);

		return NULL;

		}

		CCdlCustomisationStack* stack = *pCust;

			const CCdlInstance* inst = stack->iTop;

			__ASSERT_ALWAYS(inst, Panic(ECdlEngPanic_NoInstanceLoaded));

			inst->iLastApi = aApiId;

			eng.SetLastApiId(aApiId);

			TCdlEngineFunc* func = 0;

			do

				{

				if (aApiId < inst->Interface().iApiSize)

					func = (TCdlEngineFunc*)(inst->Implementation(aApiId));

				inst = inst->iSubLayer;

				} while (!func && inst);

			__ASSERT_ALWAYS(func, Panic(ECdlEngPanic_NoImplementation));

			return func;

	}

//

// Note that if this method is called, then GetFunction will naturally be called on the resulting instance

// and not on CdlEngine, which means that the stack iteration will not be repeated unnecessarily

// 

EXPORT_C const CCdlInstance* CdlEngine::Implementor(TUid aCdlUid, TInt aApiId)

	{

	CCdlEngine& eng = CCdlEngine::Instance();

	CCdlCustomisationStack** pCust = eng.iCustomisations.Find(aCdlUid.iUid);

	if(!pCust)

		{

		Panic(ECdlEngPanic_CustomisationNotPresent);

		}

		CCdlCustomisationStack* stack = *pCust;

			const CCdlInstance* inst = stack->iTop;

			__ASSERT_ALWAYS(inst, Panic(ECdlEngPanic_NoInstanceLoaded));

			return inst->Implementor(aApiId);

	}

EXPORT_C void CdlEngine::RequireCustomisationL(const SCdlInterface* aInterfaceParams)

	{

	CCdlEngine::Instance().RequireCustomisationL(aInterfaceParams);

	}

EXPORT_C void CdlEngine::LoadCustomisationL(const TCdlRef& aRef)

	{

	CCdlEngine::Instance().LoadCustomisationL(aRef);

	}

EXPORT_C TBool CdlEngine::IsCustomisationStarted(const SCdlInterface* aInterfaceParams)

	{

	return CCdlEngine::Instance().IsCustomisationStarted(aInterfaceParams);

	}

EXPORT_C const CCdlInstance& CdlEngine::CustomisationInstance(TUid aCdlUid)

	{

	return CCdlEngine::Instance().CustomisationInstance(aCdlUid);

	}

EXPORT_C const TCdlRef& CdlEngine::LastAccessedRef(TUid aCdlUid)

	{

	return CCdlEngine::Instance().LastAccessedRef(aCdlUid);

	}

EXPORT_C void CdlEngine::FileNameRelativeToLastAccessedInstance(TUid aCdlUid, TFileName& aFileName)

	{

	CCdlEngine::Instance().FileNameRelativeToLastAccessedInstance(aCdlUid, aFileName);

	}

EXPORT_C TInt CdlEngine::LastApiId()

	{

	return CCdlEngine::Instance().LastApiId();

	}

EXPORT_C CCdlRefs* CdlEngine::FindInstancesLC(TUid aCdlUid)

	{

	return CCdlEngine::Instance().FindInstancesLC(aCdlUid);

	}

EXPORT_C CCdlRefCollection* CdlEngine::FileContentsLC(const TDesC& aFileName)

	{

	return CCdlEngine::Instance().FileContentsLC(aFileName);

	}

EXPORT_C CCdlNames* CdlEngine::FindCustomisationFilesLC()

	{

	return CCdlEngine::Instance().FindCustomisationFilesLC();

	}

EXPORT_C CCdlRefs* CdlEngine::AllAvailableRefsLC()

	{

	return CCdlEngine::Instance().AllAvailableRefsLC();

	}

EXPORT_C void CdlEngine::SetLocalStateL(const CCdlRefs& aState)

	{

	CCdlEngine::Instance().SetLocalStateL(aState);

	}

EXPORT_C void CdlEngine::SetGlobalStateL(const CCdlRefs& aState)

	{

	CCdlEngine::Instance().SetGlobalStateL(aState);

	}

EXPORT_C CCdlRefs* CdlEngine::LocalStateLC(const CCdlUids& aCdlUids)

	{

	return CCdlEngine::Instance().LocalStateLC(aCdlUids);

	}

EXPORT_C CCdlRefs* CdlEngine::GlobalStateLC(const CCdlUids& aCdlUids)

	{

	return CCdlEngine::Instance().GlobalStateLC(aCdlUids);

	}

EXPORT_C void CdlEngine::EnableGlobalCustomisationL(const CCdlUids& aCdlUids, TBool aEnabled)

	{

	CCdlEngine::Instance().EnableGlobalCustomisationL(aCdlUids, aEnabled);

	}

EXPORT_C void CdlEngine::StartGlobalCustomisationL()

	{

	CCdlEngine::Instance().StartGlobalCustomisationL();

	}

EXPORT_C void CdlEngine::SetCustomisationChangeObserverL(MCdlChangeObserver* aObserver, TUid aUid)

	{

	CCdlEngine::Instance().AddCustomisationChangeObserverL(aObserver, aUid);

	}

EXPORT_C void CdlEngine::SetAvailableRefsChangeObserverL(MCdlChangeObserver* aObserver)

	{

	CCdlEngine::Instance().AddGeneralChangeObserverL(aObserver);

	}

EXPORT_C TInt CdlEngine::CompareNames(const TDesC& aLeft, const TDesC& aRight)

	{

	TPtrC left(RCdlLibrary::ExtractName(aLeft));

	TPtrC right(RCdlLibrary::ExtractName(aRight));

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

	// strings match

	if (left.Compare(right) == 0)

		{

		return 0;

		}

	return left.CompareF(right);

	}

//

// CdlServerEngine

//

EXPORT_C CCdlEngineRef* CdlServerEngine::CreateCdlEngineL()

	{

	TBool pushed;

	CCdlEngineBase* eng = CCdlEngineBase::InstanceLC(pushed);

	CCdlEngineRef* ref = new(ELeave) CCdlEngineRef(static_cast<CCdlEngine*>(eng));

	if (pushed)

		CleanupStack::Pop();

	return ref;

	}

//

// MCdlChangeObserver

//

EXPORT_C MCdlChangeObserver::~MCdlChangeObserver()

	{

	// It's unusual for a M-class to have a real implementation of this function.

	// This function ensures that an observer will automatically deregister from the

	// engine on destruction.

	CCdlEngine* eng = CCdlEngine::Static();

	if (eng)

		eng->RemoveChangeObserver(this);

	}

EXPORT_C void MCdlChangeObserver::HandleCustomisationChangeL(const CCdlUids& /*aUids*/)

	{

	}

EXPORT_C void MCdlChangeObserver::HandleAvailableRefsChangeL()

	{

	}

#ifndef EKA2

GLDEF_C TInt E32Dll(TDllReason /*aReason*/)

	{

	return(KErrNone);

	}

#endif