// Copyright (c) 2004-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 "csendasserver.h"

#include <ecom/ecom.h>
#include <barsc.h> 
#include <barsread.h>

#include "csendassession.h"
#include "csendasservertimer.h"
#include "sendasserverdefs.h"
#include "sendasservername.h"
#include "csendasactivecontainer.h"
#include "csendasmtmmanager.h"

// time the server will stay alive after the last session closes.
const TInt KSendAsServerCloseTime 		= 2000000;  //  2 seconds

// time the server will stay alive between starting and the first connect
// operation arriving.
const TInt KSendAsServerInitCloseTime 	= 10000000; // 10 seconds

// location of the server resource file and resource struct version number
_LIT(KSendAsServerResourceFile,"Z:\\resource\\messaging\\sendasserver.rsc");
const TInt KResVersion = 0x00000001;

/** Factory function to create a new instance of the SendAs server.

@return
A new CSendAsServer object.  This object is left on the cleanup stack.
*/
CSendAsServer* CSendAsServer::NewLC()
	{
	CSendAsServer* self = new (ELeave) CSendAsServer;
	CleanupStack::PushL(self);
	self->ConstructL();
	return self;
	}
	
/** Second-stage constructor.

Here the server allocates the 'object container index' object that is used to
keep track of the sessions.
*/
void CSendAsServer::ConstructL()
	{
	iMsvSession = CMsvSession::OpenSyncL(*this);
	iContainerIndex = CObjectConIx::NewL();
	
	iMtmManager = CSendAsMtmManager::NewL(*this);

	// read UIDs for edit tools and confirmation notifier from file
	ReadResourceFileL();	

	// configure the close timer to shut us down if there are no sessions
	// connected in the first 10 seconds.
	iCloseTimer = CSendAsServerTimer::NewL();
	iCloseTimer->After(KSendAsServerInitCloseTime);
	
	iActiveContainer = CSendAsActiveContainer::NewL(*this);
	
	StartL(KSendAsServerName);
	}

CSendAsServer::CSendAsServer()
: CServer2(CActive::EPriorityStandard)
	{
	}

CSendAsServer::~CSendAsServer()
	{
	delete iCloseTimer;
	delete iContainerIndex;
	delete iActiveContainer;
	delete iMtmManager;	
	delete iMsvSession;

	REComSession::FinalClose();
	}
	
/** Create a new session.

Called inside the NewSessionL callback.  This creates a new session
using the factory function.  The new session will call back into the server to
request an object container from the index during the operation of this factory function.
*/
CSession2* CSendAsServer::DoNewSessionL(const TVersion& aVersion, const RMessage2& /*aMsg*/)
	{
	// stop the delayed startup shutdown mechanism
	iCloseTimer->Cancel();
	
	CSendAsSession* session = CSendAsSession::NewL(aVersion, *this);
	return session;
	}
	
/** Create a new session.

The callback called by the server framework when a client calls Connect on an RSession-derived
object.
In the SendAs Server, a server-side CSendAsSession represents an RSendAs client-side object.
*/
CSession2* CSendAsServer::NewSessionL(const TVersion& aVersion, const RMessage2& aMsg) const
	{
	return ((CSendAsServer*)this)->DoNewSessionL(aVersion, aMsg);
	}

/** Generate a new object container for the session.

(Callback from session creation factory function).
Server remembers how many sessions are open.
*/
CObjectCon* CSendAsServer::NewContainerL()
	{
	CObjectCon* con = iContainerIndex->CreateL();
	++iOpenSessions;
	return con;
	}

/** Indication of session closing down.

Called from the session destructor to allow the server to dereference the
object container for that session.
*/
void CSendAsServer::SessionClosed(CObjectCon* aSessionContainer)
	{
	if( aSessionContainer != NULL)
		{
		iContainerIndex->Remove(aSessionContainer);
		--iOpenSessions;
		if( iOpenSessions == 0 )
			{
			if ( iActiveContainer->IsEmpty() )
				{
				iCloseTimer->After(KSendAsServerCloseTime);
				}
			else
				{
				// ensure no orphaned entries in background task container
				iActiveContainer->PurgeInactive();
				}
			}
		}
	}

CSendAsActiveContainer& CSendAsServer::ActiveContainer()
	{
	return *iActiveContainer;
	}

void CSendAsServer::ContainerEmpty()
	{
	// if no open sessions, start server shutdown timer
	if( iOpenSessions == 0 )
		{
		iCloseTimer->After(KSendAsServerCloseTime);
		}
	}

void CSendAsServer::ReadResourceFileL()
	{
	RFs fs;
	User::LeaveIfError(fs.Connect());
	CleanupClosePushL(fs);
		
	RResourceFile file;
    file.OpenL(fs, KSendAsServerResourceFile);
    
    CleanupClosePushL(file);

	// Read the resource
	HBufC8* resBuf = file.AllocReadLC(1);

	// interpret the resource buffer
	TResourceReader reader;
	reader.SetBuffer(resBuf);
	
	// Read Edit Tools plugin UID and SendAs Confirm Notifier UID
	TInt resVersion     = reader.ReadInt32();
	iEditUtilsPluginUid = TUid::Uid(reader.ReadInt32());
	iNotifierUid        = TUid::Uid(reader.ReadInt32());
	
	if (resVersion != KResVersion || iEditUtilsPluginUid == KNullUid || iNotifierUid == KNullUid)
		{
		User::Leave(KErrCorrupt);
		}

	CleanupStack::PopAndDestroy(3, &fs);	// resBuf, file, fs
	}

const TUid& CSendAsServer::NotifierUid() const
	{
	return iNotifierUid;
	}

const TUid& CSendAsServer::EditUtilsPluginUid() const
	{
	return iEditUtilsPluginUid;
	}

CMsvSession& CSendAsServer::GetMsvSessionL()
	{ 
	// if session has become lazy - create new session
	if (iMsvSession == NULL)
		{
		iMsvSession = CMsvSession::OpenSyncL(*this);
		}
	return *iMsvSession; 
	}

CSendAsMtmManager* CSendAsServer::GetMtmManager()
	{ 
	return iMtmManager;
	}

/** Message Server Session Observer Callback.

Used to keep track of the status of the message server.

@param	aEvent
The message server event to be handled.
*/
void CSendAsServer::HandleSessionEventL(TMsvSessionEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)
	{
	switch(aEvent)
		{
	case EMsvServerTerminated:
	case EMsvCloseSession:
		// close session (be lazy)
		delete iMsvSession;
		iMsvSession = NULL;
		break;
	case EMsvMtmGroupDeInstalled:
	case EMsvMtmGroupInstalled:
		// handle mtm installation/uninstallation 
		HandleMtmChangeL(aEvent);
		break;
	case EMsvCorruptedIndexRebuilding:
	case EMsvCorruptedIndexRebuilt:
		// ignore
	case EMsvEntriesChanged:
	case EMsvEntriesCreated:
	case EMsvEntriesDeleted:
	case EMsvEntriesMoved:
		// don't care
	case EMsvGeneralError:
		// not used after v5
	case EMsvMediaAvailable:
	case EMsvMediaChanged:
	case EMsvMediaIncorrect:
	case EMsvMediaUnavailable:
		// not to worry - appropriate errors will filter back to client
	case EMsvServerReady:
	case EMsvServerFailedToStart:
		// shouldn't happen since session is synchronously opened
		break;	
	default:
		break;
		}
	}

void CSendAsServer::HandleMtmChangeL(TMsvSessionEvent& aEvent)
	{
	// update the MTM manager
	iMtmManager->RefreshMtmUidArrayL();
	
	// call each session's MTM Change handling method if a MTM has been de-installed
	if (aEvent == EMsvMtmGroupDeInstalled)
		{
		iSessionIter.SetToFirst();
		CSendAsSession* ses = (CSendAsSession*)&(*iSessionIter++);
		while (ses!=NULL)
			{
			ses->HandleMtmChange();
			ses = (CSendAsSession*)&(*(iSessionIter++));
			}
		}
	}