/*

* 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:  DCMO Server implementation

*

*/

#include <e32svr.h>

#include <implementationproxy.h>

#include <ecom.h>

#include <e32base.h>

#include <centralrepository.h>

#include <stringresourcereader.h> 

#include <data_caging_path_literals.hrh>

#include <f32file.h> 

#include "dcmoclientserver.h"

#include "dcmoconst.h"

#include "dcmointerface.h"

#include "dcmoserver.h"

#include "dcmosession.h"

#include "dcmogenericcontrol.h"

#include "dcmodebug.h"

const TInt KBufferSize = 256;

TInt CDCMOServer::iSessionCount = 0;

// Standard server startup code

// 

static void StartServerL()

	{

	RDEBUG("DCMOServer: Starting server...");

	// EPOC and EKA 2 is easy, we just create a new server process. Simultaneous

	// launching of two such processes should be detected when the second one

	// attempts to create the server object, failing with KErrAlreadyExists.

	// naming the server thread after the server helps to debug panics

	User::LeaveIfError(User::RenameThread(KDCMOServerName));	

	// create and install the active scheduler

	CActiveScheduler* s=new(ELeave) CActiveScheduler;

	CleanupStack::PushL(s);

	CActiveScheduler::Install(s);

	// create the server (leave it on the cleanup stack)

	CDCMOServer::NewLC();

	// Initialisation complete, now signal the client

	RProcess::Rendezvous(KErrNone);

	// Ready to run

	CActiveScheduler::Start();

	// Cleanup the server and scheduler

	CleanupStack::PopAndDestroy(2);

	}

// ----------------------------------------------------------------------------------------

// Server process entry-point

// ----------------------------------------------------------------------------------------

TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanup=CTrapCleanup::New();

	TInt r=KErrNoMemory;

	if (cleanup)

		{

		TRAP(r,StartServerL());

		delete cleanup;

		}

	__UHEAP_MARKEND;

	return r;

	}

// ----------------------------------------------------------------------------------------

// CDCMOServer::NewLC

// ----------------------------------------------------------------------------------------

CServer2* CDCMOServer::NewLC()

{

	RDEBUG("CDCMOServer::NewLC- begin");

	CDCMOServer* self=new(ELeave) CDCMOServer;

	CleanupStack::PushL(self);

	self->ConstructL();	

	RDEBUG("CDCMOServer::NewLC- end");

	return self;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::ConstructL

// ----------------------------------------------------------------------------------------

void CDCMOServer::ConstructL()

	{

	RDEBUG("CDCMOServer::ConstructL- begin");

	StartL(KDCMOServerName);	

	RDEBUG("CDCMOServer::ConstructL- end");

	}

// ----------------------------------------------------------------------------------------

// CDCMOServer::CDCMOServer() 

// ----------------------------------------------------------------------------------------

CDCMOServer::CDCMOServer() : CServer2(EPriorityStandard, EUnsharableSessions) /*CServer2(0)*/

	{	

		iStarter = EFalse;

	}

// ----------------------------------------------------------------------------------------

// CDCMOServer::~CDCMOServer() 

// ----------------------------------------------------------------------------------------

CDCMOServer::~CDCMOServer()

{	

	RDEBUG("CDCMOServer::~CDCMOServer- begin");

  TInt count = idcmoArray.Count();  

	if(count)

	{	

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

				delete idcmoArray[i].iCategoryName;

		idcmoArray.Reset();

	}

	REComSession::FinalClose();

}

// -----------------------------------------------------------------------------

// CDCMOServer::DropSession()

// -----------------------------------------------------------------------------

void CDCMOServer::DropSession()

	{

		RDEBUG("CDCMOServer::DropSession- begin");

		iSessionCount--;

		if ( iStarter ) 

  	{

  		RDEBUG("CDCMOServer::DropSession(): Starter");

  		SetStarter( EFalse );

  		return;                 

		if( idcmoArray.Count() && ( iSessionCount == 0 ))

		{

			// A session is being destroyed		

			TRAPD( err, DoFinalizeL());		

			if ( !err )

			{

				RDEBUG_2("CDCMOServer::DropSession err =  %d", err );

			}						

		}		

		RDEBUG("CDCMOServer::DropSession- end");

	}

// ----------------------------------------------------------------------------------------

// CDCMOServer::NewSessionL

// Create a new client session. This should really check the version number.

// ----------------------------------------------------------------------------------------

CSession2* CDCMOServer::NewSessionL(const TVersion& aVersion,const RMessage2&) const

	{

	RDEBUG("CDCMOServer::NewSessionL");

	// check we're the right version

	TVersion v(KDCMOServerMajorVersionNumber,

	           KDCMOServerMinorVersionNumber,

	           KDCMOServerBuildVersionNumber);

	if (!User::QueryVersionSupported(v,aVersion))

		{

			RDEBUG("CDCMOServer::NewSessionL - KErrNotSupported");

			User::Leave(KErrNotSupported);

		}

	if( iSessionCount > 0 )	

	{

		RDEBUG("CDCMOServer::NewSessionL - KErrServerBusy");

		User::Leave(KErrServerBusy );		

	}

	else

		 iSessionCount++;

	return new (ELeave) CDCMOSession(); 

	}

void CleanupEComArray(TAny* aArray)

	{

	(static_cast<RImplInfoPtrArray*> (aArray))->ResetAndDestroy();

	(static_cast<RImplInfoPtrArray*> (aArray))->Close();

	}

// ----------------------------------------------------------------------------------------

// CDCMOServer::GetAdapterUidL

// Gets the plug-in adapter implementation uid if it present.

// ----------------------------------------------------------------------------------------

{

	RDEBUG("CDCMOServer::GetDCMOAdapterUidL(): begin");

	TUid retUid = {0x0};

	RImplInfoPtrArray infoArray;

	// Note that a special cleanup function is required to reset and destroy

	// all items in the array, and then close it.

	TCleanupItem cleanup(CleanupEComArray, &infoArray);

	CleanupStack::PushL(cleanup);

	REComSession::ListImplementationsL(KDCMOInterfaceUid, infoArray);

	// Loop through each info for each implementation			

	TBuf8<KBufferSize> buf;            

	for (TInt i=0; i< infoArray.Count(); i++)

	{

		buf = infoArray[i]->OpaqueData();

		TBuf8<KBufferSize> category;

		category.Copy(aCategory);

		if(category.Find(infoArray[i]->OpaqueData())!= KErrNotFound)

		{

			retUid = infoArray[i]->ImplementationUid();

			break;

		}

		buf.Zero();

	}

	CleanupStack::PopAndDestroy(); //cleanup

	RDEBUG("CDCMOServer::GetDCMOAdapterUidL(): end");

	return retUid;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::GetLocalCategoryL

// Gets the cenrep key value of the plug-in adapter if it is available.

// ----------------------------------------------------------------------------------------

TInt CDCMOServer::GetLocalCategoryL(const TDesC& aCategory)

{

	RDEBUG("CDCMOServer::GetLocalCategoryL(): begin");

	TInt ret(-1);	

	CRepository* centrep = NULL;

	TInt err(KErrNone);

	TRAP(err, centrep = CRepository::NewL( KCRUidDCMOServer ));

	if(err != KErrNone)

	{

		RDEBUG("CDCMOServer::GetLocalCategoryL(): DCMO central repository does not exist");

		return ret;

	}

	TUint32 centrepKey = 0;

	TInt iControl(0);

	TInt reterr = centrep->Get( centrepKey, iControl );	

	if(reterr!= KErrNone)

	{

			RDEBUG("CDCMOServer::GetLocalCategoryL(): centrep Get error");

			delete centrep;

			centrep = NULL;

	    return ret;

	}

	RDEBUG_2("CDCMOServer::GetLocalCategoryL local plug-in =  %d", iControl );

	TBuf<30> buffer;

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

	{   

        centrepKey = KDCMOKeyMaxNumber*i + KDCMOPropertyNumber ;

        reterr = centrep->Get( centrepKey, buffer );

	    	if(aCategory.Find(buffer)== KErrNone)

        {

        	ret = centrepKey-1;

        	break;

        }

	}

	delete centrep;

	centrep = NULL;

	RDEBUG("CDCMOServer::GetLocalCategoryL(): end");

	return ret;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::GetIntAttributeL

// Gets the integer attribute value.

// ----------------------------------------------------------------------------------------

TDCMOStatus CDCMOServer::GetIntAttributeL(TDes& category, TDCMONode id, TInt& value)

{

	RDEBUG("CDCMOServer::GetIntAttributeL(): begin");

	TDCMOStatus err(EDcmoFail);

	TInt categotyNumber = GetLocalCategoryL(category);

	if(categotyNumber != -1)

	{

			RDEBUG("CDCMOServer::GetIntAttributeL(): LocalCategory");

			CDCMOGenericControl* iGenericControl = new(ELeave) CDCMOGenericControl;

			err = iGenericControl->GetIntAttributeL(categotyNumber, id, value);

			delete iGenericControl;

			iGenericControl = NULL;

	}

	else

	{

		RDEBUG("CDCMOServer::GetIntAttributeL(): Plug-in Adapter");

		TUid impluid = GetAdapterUidL(category);		

		if(impluid.iUid)

		{

			CDCMOInterface::TDCMOInterfaceInitParams initParms;

			initParms.uid = impluid;

			initParms.descriptor = &category;

			CDCMOInterface* ex = CDCMOInterface::NewL(initParms); //impluid);

			CleanupStack::PushL(ex);

			err = ex->GetDCMOPluginIntAttributeValueL(id,value);

			CleanupStack::PopAndDestroy(); //ex 	

		}

	}

	RDEBUG("CDCMOServer::GetIntAttributeL(): end");

	return err;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::GetStrAttributeL

// Gets the string attribute value.

// ----------------------------------------------------------------------------------------

TDCMOStatus CDCMOServer::GetStrAttributeL(TDes& category, TDCMONode id, TDes& strValue) 

{

	RDEBUG("CDCMOServer::GetStrAttributeL(): begin");

	TDCMOStatus err(EDcmoFail);

	TInt categotyNumber = GetLocalCategoryL(category);

	if(categotyNumber != -1)

	{

			RDEBUG("CDCMOServer::GetStrAttributeL(): LocalCategory");

			CDCMOGenericControl* iGenericControl = new(ELeave) CDCMOGenericControl;

			err = iGenericControl->GetStrAttributeL(categotyNumber, id, strValue);	

			delete iGenericControl;

			iGenericControl = NULL;

	}

	else

	{

		RDEBUG("CDCMOServer::GetStrAttributeL(): Plug-in Adapter");

		TUid impluid = GetAdapterUidL(category);

		if(impluid.iUid)

		{

			CDCMOInterface::TDCMOInterfaceInitParams initParms;

		  initParms.uid = impluid;

		  initParms.descriptor = &category;

		  CDCMOInterface* ex = CDCMOInterface::NewL(initParms);			

			CleanupStack::PushL(ex);

			err = ex->GetDCMOPluginStrAttributeValueL(id,strValue); 

			CleanupStack::PopAndDestroy(); //ex

		}

	}

	RDEBUG("CDCMOServer::GetStrAttributeL(): end");

	return err;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::SetIntAttributeL

// Sets the integer attribute value.

// ----------------------------------------------------------------------------------------

TDCMOStatus CDCMOServer::SetIntAttributeL(TDes& category, TDCMONode id, TInt value)

{

	RDEBUG("CDCMOServer::SetIntAttributeL(): begin");

	TDCMOStatus err(EDcmoFail);

	HBufC* stringHolder( NULL );

	TInt categotyNumber = GetLocalCategoryL(category);

	struct dcmoInfoList dcmoList;

	if(categotyNumber != -1)

	{

			RDEBUG("CDCMOServer::SetIntAttributeL(): LocalCategory");

			CDCMOGenericControl* iGenericControl = new(ELeave) CDCMOGenericControl;

			err = iGenericControl->SetIntAttributeL(categotyNumber, id, value);	

			TPtrC buf;

			dcmoList.iUid = categotyNumber;

			if(categotyNumber == 0)

			    } 

			else

  	 delete iGenericControl;

		 iGenericControl = NULL;

	}

	else

	{

		RDEBUG("CDCMOServer::SetIntAttributeL(): Plug-in Adapter");

		TUid impluid = GetAdapterUidL(category);

		dcmoList.iUid = impluid.iUid;

		if(impluid.iUid)

		{

			CDCMOInterface::TDCMOInterfaceInitParams initParms;

		  initParms.uid = impluid;

		  initParms.descriptor = &category;

		  CDCMOInterface* ex = CDCMOInterface::NewL(initParms); 

			CleanupStack::PushL(ex);

			err = ex->SetDCMOPluginIntAttributeValueL(id,value);	

			RDEBUG("CDCMOServer::SetIntAttributeL - SetDCMOPluginIntAttributeValueL(): end");				

			ex->GetLocalizedNameL(stringHolder);

			RDEBUG("CDCMOServer::SetIntAttributeL - GetLocalizedNameL(): end");				

			CleanupStack::PopAndDestroy(); //ex 	

		}

	}

	if ( iStarter )   			

   {

  		RDEBUG("CDCMOServer::SetIntAttributeL(): Starter");

  		SetStarter ( EFalse );

  		delete stringHolder;

  		return err;                

   }   

	if((err == EDcmoSuccess) && (id == EEnable) ) 

	{

		TInt arrayCount = idcmoArray.Count();

		RDEBUG_2("CDCMOServer::SetIntAttributeL arrayCount = %d", arrayCount );

		TBool insert = EFalse; 		

		if( arrayCount > 0)

		{

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

			{       	

      	if (idcmoArray[i].iUid == dcmoList.iUid)

      	{

      		idcmoArray[i].iStatus = (TBool) value;	

      		insert = ETrue;

      		break;

      	}

      }

    }

		if ( !insert )

		{

			dcmoList.iCategoryName = stringHolder->AllocL();

			dcmoList.iStatus = (TBool) value;		

			idcmoArray.AppendL(dcmoList);

			RDEBUG("CDCMOServer::SetIntAttributeL - dcmoList added ");		

		}

	}

	delete stringHolder;

	stringHolder = NULL;

	RDEBUG("CDCMOServer::SetIntAttributeL(): end");

	return err;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::SetStrAttributeL

// Sets the string attribute value.

// ----------------------------------------------------------------------------------------

TDCMOStatus CDCMOServer::SetStrAttributeL(TDes& category, TDCMONode id, const TDes& strValue)

{

	RDEBUG("CDCMOServer::SetStrAttributeL(): begin");

	TUid impluid = GetAdapterUidL(category);

	TDCMOStatus err(EDcmoFail);

	if(impluid.iUid)

	{

		CDCMOInterface* ex = CDCMOInterface::NewL(impluid);

		CleanupStack::PushL(ex);

		err = ex->SetDCMOPluginStrAttributeValueL(id,strValue);

		CleanupStack::PopAndDestroy(); //ex 

	}

	RDEBUG("CDCMOServer::SetStrAttributeL(): end");	

	return err;

}

// ----------------------------------------------------------------------------------------

// CDCMOServer::DoFinalizeL()

// Calls when all the operations are done. Shows the notification

// ----------------------------------------------------------------------------------------

void CDCMOServer::DoFinalizeL()

{

	RDEBUG("CDCMOServer::DoFinalizeL(): begin");	   

	HBufC* content  = HBufC::NewLC(KDCMOMaxStringSize);

	HBufC* enableContent  = HBufC::NewLC(KDCMOMaxStringSize);

	TPtr   enableContentptr  = enableContent->Des(); 

	HBufC* disableContent  = HBufC::NewLC(KDCMOMaxStringSize);

	TPtr   disableContentptr  = disableContent->Des(); 

	TBool enable ( EFalse );

	TBool disable ( EFalse );

	TInt arrayCount = idcmoArray.Count(); 

	_LIT(KNewLine, "\n");

	if( arrayCount > 0)

	{

		RDEBUG_2("CDCMOServer::DoFinalizeL arrayCount= %d", arrayCount );

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

		{       	

      	if (idcmoArray[i].iStatus )

      	{

      		enableContentptr.Append(KNewLine());

      		enableContentptr.Append( idcmoArray[i].iCategoryName->Des() );

      		enable = ETrue;

      	}

      	else

      	{

      		disableContentptr.Append(KNewLine());

      		disableContentptr.Append( idcmoArray[i].iCategoryName->Des() );

      		disable = ETrue;

      	}	

		if ( enable )

		{

	 		contentptr.Append(enableContentptr);

		}

		if ( disable )

		{