// Copyright (c) 1997-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:
// Interface Manager
// 
//

/**
 @file IF_MAN.CPP
*/

#include "IF_DEF.H"
#include "NI_STD.H"
#include <es_mbman.h>
#include "Ni_Log.h"
#include <agentdialog.h>
#include <c32root.h>
#include <ecom/ecom.h>
#include "cagentdlgproc.h"

/**
@internalComponent
*/
const TInt KAsyncDtorPriority = 10000;

/**
@internalComponent
*/
typedef CNifFactory* (*TNifFactoryNewL)();

/**
@internalComponent
*/
/*typedef CNetworkControllerBase* (*CreateNetConFunctionL)();*/

inline TAny* Tls()
/**
@internalComponent
*/
 { return Dll::Tls(); }

inline TInt SetTls(TAny* aTls) 
/**
@internalComponent
*/
{ return Dll::SetTls(aTls); }


EXPORT_C CNifFactory::CNifFactory()
/**
Constructor
*/
	{

	}

EXPORT_C CNifFactory::~CNifFactory()
/**
Destructor
*/
	{

	__ASSERT_DEBUG(!iLib.Handle(), Panic(ENifManPanic_LibraryNotClosed));
	delete iAsyncDtor;
	}


EXPORT_C TInt CNifFactory::Open()
/**
If somehow something opens object just before it is destructed
@return KErrNone,systemwide error code.
*/
	{
	if(AccessCount()==0 && iAsyncDtor->IsActive())
		iAsyncDtor->Cancel();
	Inc();
	return KErrNone;
	}

EXPORT_C void CNifFactory::Close()
/**
Defer deletion of object to facilitate async closing of library
*/
	{

	Dec();
	if (AccessCount()==0)
		{
		if(iAsyncDtor)
			{
			if(!iAsyncDtor->IsAdded())
				{
				CActiveScheduler::Add(iAsyncDtor);
				}
			iAsyncDtor->CallBack();
			}
		else // Only partially constructed
			ControlledDelete(this);
		}
	}

EXPORT_C TInt CNifFactory::ControlledDelete(TAny* aFactory)
/**
Delete factory
@return systemwide error code
*/
	{
	
	CNifFactory* n = (CNifFactory*)aFactory;
	RLibrary lib;
	lib.SetHandle(n->iLib.Handle());
	n->iLib.SetHandle(0);
	delete n; // deletes async callback object also
	lib.Close();
	return KErrNone;
	}

EXPORT_C void CNifFactory::Cleanup(TAny* aObject)
/**
For use with clean up stack
@param aObject
*/
	{
	
	((CObject*)aObject)->Close();
	}

EXPORT_C void CNifFactory::InitL(RLibrary& aLib, CObjectCon& aCon)
/**
Setup async Destructor & transfer library
@param aLib
@param aCon
*/
	{	
	
	TCallBack c = TCallBack(ControlledDelete, this);
	iAsyncDtor = new (ELeave) CAsyncCallBack(c, KAsyncDtorPriority);
	iAsyncDtor->Deque();	//PERF: we'll re-join the queue JIT
	iLib.SetHandle(aLib.Handle());
	aLib.SetHandle(0); // Handle transferred

	TParse parse;
	User::LeaveIfError(parse.Set(iLib.FileName(),0,0));
	
	TPtrC temp = parse.Name();
	SetNameL(&temp);

	InstallL(); // pure virtual
	aCon.AddL(this);	
	}


//
CNifMan::CNifMan()
	{
	}

CNifMan::~CNifMan()
	{

	TInt i;

	// go through deleting agents
	CObjectCon* con;
	if(iAgents)
		{
		con = iAgents;
		for(i=0 ; i<con->Count() ; ++i)
			delete (*con)[i];
		}

	// As all agents have been deleted there should be no factories left
    // but as their d'tors are async they could still be lying around but
	// access counts should be zero
	// go through deleting factories for real

	delete iAgentDlgProc;

	if(iAgentFactories)
		{
		con = iAgentFactories;
		for(i=0 ; i<con->Count() ; ++i)
			delete (*con)[i];
		}

	if(iContainers)
        {
		delete iContainers;
        }
        
	if(iDefMatch)
        {
		delete iDefMatch;
        }
        
	if(iDefFilename)
	    {
		delete iDefFilename;
	    }
	    
	if(Global()==this)
	    {
	    SetTls(NULL);
	    }

	// Unload the Dialog Server CPM
	RRootServ rootserver;
	if(rootserver.Connect()==KErrNone) 
		{
		TCFModuleName name;
		name.Copy(KCommsDialogServerName);
		TRequestStatus status;
		rootserver.UnloadCpm(status, name, EImmediate);
		User::WaitForRequest(status);
		rootserver.Close();
		}
	
	REComSession::FinalClose();
	
	LOG( NifmanLog::Printf(_L("--------------- Nifman Finished --------------")); )
	}


CAgentDialogProcessor* CNifMan::AgentDialogProcessor()
    {
    return iAgentDlgProc;
    }


void CNifMan::InstallL(const TDesC& /*aArgs*/)
/**
Treat as constructL() 
Unless the bug has been fixed leaving will orphan a library handle
so this is avoided at all costs by ensuring the extension is only ever loaded once
*/
	{

	LOG( NifmanLog::Printf(_L("--------------- Nifman Started ---------------")); )
	LOG_DETAILED( NifmanLog::Printf(_L("Detailed logging enabled")); )

	if(Tls())
		User::Leave(KErrAlreadyExists);

	iContainers = CObjectConIx::NewL();
	iAgents = iContainers->CreateL();
	iAgentFactories = iContainers->CreateL();

	iAgentDlgProc = new(ELeave)CAgentDialogProcessor();

//	StartEsWatchThread();
		
	User::LeaveIfError(SetTls(this));
	}

void CNifMan::Remove()
/**
Let the destructor do it all
*/
	{
	}

EXPORT_C CNifMan* CNifMan::Global()
/**
Get the global nifman
*/
	{
	return (CNifMan*)Tls();
	}

void CNifMan::DoGetFileNameL(const TDesC& aName, TDes& aFilename)
/**
Look in ini file for default agent module name
*/
	{

	CESockIniData* ini=0;
	TPtrC result;
	
	if(!iDefMatch || !iDefFilename)
		{

		ini = CESockIniData::NewL();
	    CleanupStack::PushL(ini);
		if(!iDefMatch)
		    {
		    if(!ini->FindVar(KNifManSection, KNifManDefault, result))
				{
				_LIT(genconnString,"genconn");
			    iDefMatch = genconnString().AllocL();
				}
		    else
			    iDefMatch = result.AllocL();
			}

		if(!iDefFilename)
			{
			if(!ini->FindVar(KNifManAgents, *iDefMatch, result))
				{
				TName name = *iDefMatch;
				name.Append(KAgentExtension);
				iDefFilename = name.AllocL();
				}
			else
				iDefFilename = result.AllocL();
			}
		}

	if(!aName.Length() || !aName.CompareF(*iDefMatch))
		{
		aFilename = *iDefFilename;
		}
	else
		{
		if(!ini)
			{
			ini = CESockIniData::NewL();
	        CleanupStack::PushL(ini);
			}
		if(!ini->FindVar(KNifManAgents, aName, result))
			{
			aFilename=aName;

			if(aFilename.Right(4) != KAgentExtension())
				aFilename.Append(KAgentExtension);
		    }
		else
		    aFilename = result;
		}
	
	if(ini)
		CleanupStack::PopAndDestroy();
	}


CNifFactory* CNifMan::DoFindFactoryL(TUid aUid2, const TDesC& aFilename, CObjectCon& aCon, TBool aCreate)
/**
Load a factory and check the Uid etc
function always opens factory CObject if successful
*/
	{


	TParse parse;
	User::LeaveIfError(parse.Set(aFilename, 0, 0));

	TName dummy1;
	TInt find=0;
	CNifFactory* f=0;

	if(aCon.FindByName(find, parse.Name(), dummy1)!=KErrNone)
		{

		if(!aCreate)
			User::Leave(KErrNotFound);

	    // Else load the module
		TAutoClose<RLibrary> lib;
		User::LeaveIfError(lib.iObj.Load(aFilename));
		lib.PushL();

		// The Uid check
		if(lib.iObj.Type()[1]!=aUid2)
			User::Leave(KErrBadLibraryEntryPoint);

		TNifFactoryNewL libEntry=(TNifFactoryNewL)lib.iObj.Lookup(1);
		if (libEntry==NULL)
			User::Leave(KErrNoMemory);

		f =(*libEntry)(); // Opens CObject
		if (!f)
			User::Leave(KErrBadDriver);

		CleanupStack::PushL(TCleanupItem(CNifFactory::Cleanup, f));
		f->InitL(lib.iObj, aCon); // Transfers the library object if successful

		// Can pop the library now - auto close will have no effect because handle is null
		CleanupStack::Pop();
		lib.Pop();

		}
	else
		{
		f=(CNifFactory*)aCon.At(find);
		f->Open();
		}
	return f;
	}


TInt CNifMan::NumAgents() const
	{
	return iAgents->Count();
	}