// Copyright (c) 2002-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 <e32math.h>
#include <mmf/server/mmfdrmpluginserverproxy.h>
#include "mmfcontrollerframework.h"
#include "mmfcontroller.h"
#include "mmfcontrollerheap.h"
#include "mmfcontrollerframeworkpriv.h"
#include "mmfcontrollerpatchdata.h"

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <mmf/common/mmfcontrollerextendeddata.h>
#include <mmf/common/mmfcustomcommandparsermanager.h>
#include <mmf/common/mmfcontrollerframeworkclasses.h>
#endif

// Panic
   
enum
	{
	EPanicHeapHalfOpen=1,
	EPanicHeapOpenWithoutTls,
	EPanicReleaseWithoutRegister,
	EPanicBadInvariant
	};
	
#ifdef _DEBUG
static void Panic(TInt aReason)
	{
	_LIT(KControllerFramework, "ControllerFramework");
	User::Panic(KControllerFramework, aReason);
	}
#endif

EXPORT_C RMMFControllerProxy::RMMFControllerProxy() :
	iDestinationPckg(TMMFMessageDestination(KUidInterfaceMMFControllerProxy, KMMFObjectHandleControllerProxy)),
	iLogonAO(NULL), iThreadPriority(static_cast<TThreadPriority>(KDefaultMMFControllerThreadPriority)), iFlags(0)
	{
	iSubThread.Close();//iSubThread is automatically initialised to be a handle to this thread!
	}

TInt RMMFControllerProxy::LoadController(
	TUid aControllerUid, 
 	const CMMFControllerImplementationInformation& aControllerInfo,
 	TBool aUseSharedHeap,
 	TBool aNoDRMCap)
	{
	// First check that we haven't already created the subthread
	if (iSubThread.Handle() != 0)
		return KErrAlreadyExists;
	
#ifdef SYMBIAN_FORCE_USE_SHARED_HEAP
	aUseSharedHeap = ETrue;
#endif

	//determine what maximum heap size this thread should be created with
	TUint maxHeapSize =0;
	TInt error = KErrNone;
	maxHeapSize = aControllerInfo.HeapSpaceRequired();
	TUint stackSize = aControllerInfo.StackSize();
	
	ASSERT(!iLogonAO);
	TRAP(error, iLogonAO = CLogonMonitor::NewL(this));
	
	if (!error)
		{
		if (aNoDRMCap && aControllerInfo.SupportsSecureDRMProcessMode())
			{
			error = DoCreateSessionForNoDRMCapClient(maxHeapSize, aUseSharedHeap, stackSize);
			}
		else
			{
			// server2 will be set in this function call
			error = DoCreateSubThread(&iLogonAO->Server(), maxHeapSize, aUseSharedHeap, stackSize);
		
			// Now create a session with the controller proxy server running in the subthread
			if (!error)
				{
				// create a session with iServer2 (local server)
				error = CreateSession(iLogonAO->Server(), KMMFControllerProxyVersion);
				}
			}
		}

	// Finally, tell the controller proxy server to load the relevant plugin
	if (!error)
		{
		TMMFUidPckg uidPckg(aControllerUid);
		error = SendSync(iDestinationPckg, 
						 EMMFControllerProxyLoadControllerPluginByUid, 
						 uidPckg, 
						 KNullDesC8);
		}

	// If an error occurred with any of the above, close all the handles
	if (error)
		Close();

	return error;
	}


EXPORT_C TInt RMMFControllerProxy::LoadController(TUid aControllerUid, TBool aUseSharedHeap)
	{
 	CMMFControllerImplementationInformation* controllerInfo = NULL;
 	
 	TRAPD(err, controllerInfo = CMMFControllerImplementationInformation::NewL(aControllerUid));
	if (!err && controllerInfo)
		{
		err = LoadController(aControllerUid, *controllerInfo, aUseSharedHeap, EFalse);
		delete controllerInfo;
		}
 	return err;
	}

EXPORT_C TInt RMMFControllerProxy::LoadController(const CMMFControllerImplementationInformation& aControllerInfo, TBool aUseSharedHeap)
	{
	return LoadController(aControllerInfo.Uid(), aControllerInfo, aUseSharedHeap, EFalse);
	}

EXPORT_C TInt RMMFControllerProxy::LoadControllerInSecureDRMProcess(TUid aControllerUid, TBool aUseSharedHeap)
	{
	CMMFControllerImplementationInformation* controllerInfo = NULL;
	
	TRAPD(err, controllerInfo = CMMFControllerImplementationInformation::NewL(aControllerUid));
	if (!err && controllerInfo)
		{
		err = LoadController(aControllerUid, *controllerInfo, aUseSharedHeap, ETrue);
		delete controllerInfo;
		}
	return err;
	}
	
EXPORT_C TInt RMMFControllerProxy::LoadControllerInSecureDRMProcess(const CMMFControllerImplementationInformation& aControllerInfo, TBool aUseSharedHeap)
	{
	return LoadController(aControllerInfo.Uid(), aControllerInfo, aUseSharedHeap, ETrue);
	}

TUint RMMFControllerProxy::ControllersMaxHeapSizeL(TUid aControllerUid)
	{
	CMMFControllerImplementationInformation* controllerInfo = NULL;

	TRAPD(err, controllerInfo = CMMFControllerImplementationInformation::NewL(aControllerUid));


	TUint maxHeapSize = KMMFDefaultControllerThreadHeapSize;
	
	if((err != KErrNone) && (err != KErrCorrupt))
		{
		delete controllerInfo;
		User::Leave(err);
		}


	if(controllerInfo && (err == KErrNone))
		maxHeapSize = controllerInfo->HeapSpaceRequired();

	delete controllerInfo;

	return maxHeapSize;
	}


TInt RMMFControllerProxy::DoCreateSubThread(RServer2* aServer2, TUint aMaxHeapSize, TBool aUseSharedHeap, TUint aStackSize)
	{
	TInt error = KErrNone;

	TControllerProxyServerParams params;
	params.iServer = aServer2;
	params.iUsingSharedHeap = aUseSharedHeap;

#ifdef SYMBIAN_USE_CLIENT_HEAP
	// controller threads share the *client* heap (intended for out of memory testing)
	error = iSubThread.Create(_L(""), &CMMFControllerProxyServer::StartThread, 
			aStackSize, NULL, &params, EOwnerThread);
#else
	if( aUseSharedHeap )
		{
		//controller threads all share a controller heap
		CMMFControllerHeap* contHeap = static_cast<CMMFControllerHeap*>(Dll::Tls());
		if(contHeap == NULL)
			{
			TRAP(error, contHeap = CMMFControllerHeap::NewL());
			if(error)
				{			
				return error;	
				}
				
			Dll::SetTls(contHeap);
			}
			
		__ASSERT_DEBUG((iFlags&EFlagOpenedSharedHeap)==0, Panic(EPanicHeapHalfOpen));
			
		RHeap* sharedHeap = contHeap->RegisterHeap();
		// We've registered, so record the fact so can "unregister" on close or error
		iFlags |= EFlagOpenedSharedHeap; 
		
		error = iSubThread.Create(KNullDesC, &CMMFControllerProxyServer::StartThread,
				aStackSize, sharedHeap, 						
				&params, EOwnerThread);		
		}
	else
		{	
		// Threads create own heap (default behaviour)
		if(aMaxHeapSize < static_cast<TUint>(KMinHeapSize))
			aMaxHeapSize = KMinHeapSize; //else raises a USER 111 panic
		else if(aMaxHeapSize >  static_cast<TUint>(KMMFControllerProxyMaxHeapSize))
			aMaxHeapSize = KMMFControllerProxyMaxHeapSize;
		
		TThreadCreateInfo threadSettings (KNullDesC, &CMMFControllerProxyServer::StartThread,
										  aStackSize, &params);
		threadSettings.SetCreateHeap(KMinHeapSize, aMaxHeapSize);
		threadSettings.SetOwner(EOwnerThread);
		threadSettings.SetPaging(TThreadCreateInfo::EUnpaged);
		
		error = iSubThread.Create(threadSettings);
		}
#endif

	if (error)
		{
		return error;
		}

	TRequestStatus rendezvous;
	iSubThread.Rendezvous(rendezvous);
	if (rendezvous != KRequestPending)
		{
		iSubThread.Kill(0);
		}
	else
		{
		iLogonAO->StartMonitoring(iSubThread);
		if (iLogonAO->iStatus != KRequestPending)
			{
			// Failed to logon
			iSubThread.RendezvousCancel(rendezvous);
			User::WaitForRequest(rendezvous);
			iSubThread.Kill(0);
			iSubThread.Close();
			return iLogonAO->iStatus.Int();
			}
		else
			{
			iSubThread.SetPriority(iThreadPriority);
			iSubThread.Resume();
			}
		}
		
	User::WaitForRequest(rendezvous); // wait for startup or death
	
	if (rendezvous != KErrNone)
		{
		iLogonAO->Cancel();
		iSubThread.Close();
		// if open failed, but we registered the heap, need to release
		if((iFlags&EFlagOpenedSharedHeap))
			{
			ReleaseHeap();
			}		
		}
		
	return rendezvous.Int();
	}

EXPORT_C void RMMFControllerProxy::Close()
	{
#ifdef _DEBUG
	_LIT(KMMFClientThreadPanic, "MMFClientThread");
#endif
	// check if thread was created
	TBool subThreadCreated = EFalse;
	TRequestStatus logoffStatus;
	TBool logoffFailed = EFalse;
	if (iSubThread.Handle() != KNullHandle)
		{
		subThreadCreated = ETrue;
		iLogonAO->Cancel();
		iSubThread.Logon(logoffStatus);
		
		if (logoffStatus == KErrNoMemory && iSubThread.ExitType() == EExitPending)
			{
			// Logon() call has failed because of a lack of memory
			logoffFailed = ETrue;
			}
		}

	// Close the controller and wait for its exit.
	// Close the session to signal the controller proxy server to shut down.
	RHandleBase::Close();
	
	// Now wait for the death of the subthread if we have a valid handle...
	if (subThreadCreated)
		{
		RProcess thisProcess;
		RProcess controllerProcess;
		iSubThread.Process(controllerProcess);	// ignore error, best try
		TBool secureDrmMode = thisProcess.Id() != controllerProcess.Id();
		thisProcess.Close();
		controllerProcess.Close();
				
		RTimer timer;
		TInt err = timer.CreateLocal();
		// If we managed to create the timer and logon to the thread, 
		// wait for both the death and the timeout to minimise the risk of deadlock
		if (!err && !logoffFailed)
			{
			TRequestStatus timeout;
			timer.After(timeout, KMmfControllerThreadShutdownTimeout);
			User::WaitForRequest(logoffStatus, timeout);
			if (logoffStatus == KRequestPending)
				{
				// we have timed out.  Kill the controller thread
				iSubThread.LogonCancel(logoffStatus);
				User::WaitForRequest(logoffStatus);
				
				if (!secureDrmMode)
					{
					// Controller server thread is created in current process
				#ifdef _DEBUG
					iSubThread.Panic(KMMFClientThreadPanic,KErrDied);
				#else
					iSubThread.Kill(KErrDied);
				#endif
					}
				else
					{
					// Controller server thread is created through DRM plugin server
					RMMFDRMPluginServerProxy server;
					// ignore all RMMFDRMPluginServerProxy errors, best try
					err = server.Open();
					if (err == KErrNone)
						{
					#ifdef _DEBUG
						server.PanicControllerThread(iSubThread.Id(), KMMFClientThreadPanic, KErrDied);
					#else
						server.KillControllerThread(iSubThread.Id(), KErrDied);
					#endif
						server.Close();
						}
					}
				}
			else
				{
				// subthread has exited. Cancel the timer.
				timer.Cancel();
				User::WaitForRequest(timeout);
				}
			}
		else
			{
			// We have no timer or we can't logon to the thread so we'll just poll the thread status a maximum
			// of 10 times and kill the thread if it hasn't exited after the polling
			for (TInt i=0; i<10 && iSubThread.ExitType() == EExitPending; ++i)
				{
				User::After(KMmfControllerThreadShutdownTimeout/10);	// wait for a while
				}
				
			if (iSubThread.ExitType() == EExitPending)
				{
				// The polling hasn't been succesful so we kill the thread
				if (!secureDrmMode)
					{
					iSubThread.Kill(KErrDied);
					}
				else
					{
					// Controller server thread is created through DRM plugin server
					RMMFDRMPluginServerProxy server;
					// ignore all RMMFDRMPluginServerProxy errors, best try
					err = server.Open();
					if (err == KErrNone)
						{
						server.KillControllerThread(iSubThread.Id(), KErrDied);
						}
					}
				}
				
			User::WaitForRequest(logoffStatus);
			}
		timer.Close();
		}

	// Close the handle to the controller thread
	iSubThread.Close();
	// Delete the Logon AO
	if (iLogonAO)
		{
		delete iLogonAO;
		iLogonAO = NULL;
		}
	// if this is last thread to be killed delete shared heap
	if((iFlags&EFlagOpenedSharedHeap))
		{
		ReleaseHeap();
		}	
	}

// Release the shared heap, should only be called if has previously been registered
// by this thread
void RMMFControllerProxy::ReleaseHeap()
	{
	__ASSERT_DEBUG((iFlags&EFlagOpenedSharedHeap), Panic(EPanicReleaseWithoutRegister));

	CMMFControllerHeap* contHeap = static_cast<CMMFControllerHeap*>(Dll::Tls());
	__ASSERT_DEBUG(contHeap!=NULL, Panic(EPanicHeapOpenWithoutTls));
	
	if(contHeap != NULL)
		{
		TInt refCount = contHeap->ReleaseHeap();
		if(refCount == 0)
			{  //no other controllers using the heap
			delete contHeap;
			Dll::SetTls(NULL);
			}
		}
		
	iFlags &= ~EFlagOpenedSharedHeap; // clear flag since we've released the heap
	}

EXPORT_C TInt RMMFControllerProxy::SendSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom) const
	{
	// Make sure we have been opened
	if (iSubThread.Handle() == 0)
		{
		return KErrNotReady;
		}
	else
		return SendReceiveResult(aFunction, aDestination, aDataTo1, aDataTo2, aDataFrom);
	}


EXPORT_C TInt RMMFControllerProxy::SendSync(TInt aFunction, const TIpcArgs& aIpcArgs) const
	{
	// Make sure we have been opened
	if (iSubThread.Handle() == 0)
		{
		return KErrNotReady;
		}
	else
		return RSessionBase::SendReceive(aFunction, aIpcArgs);
	}
	
EXPORT_C void RMMFControllerProxy::SendAsync(TInt aFunction, const TIpcArgs& aIpcArgs, TRequestStatus& aStatus) const
	{
	// Make sure we have been opened
	if (iSubThread.Handle() == 0)
		{
		TRequestStatus* status = &aStatus;
		User::RequestComplete(status, KErrNotReady);
		}
	else
		RSessionBase::SendReceive(aFunction, aIpcArgs, aStatus);
	}



EXPORT_C TInt RMMFControllerProxy::SendSync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2) const
	{
	// Make sure we have been opened
	if (iSubThread.Handle() == 0)
		{
		return KErrNotReady;
		}
	else
		return SendReceive(aFunction, aDestination, aDataTo1, aDataTo2);
	}

EXPORT_C void RMMFControllerProxy::SendAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TDes8& aDataFrom, TRequestStatus& aStatus) const
	{
	if (iSubThread.Handle() == 0)
		{
		TRequestStatus* stat = &aStatus;
		User::RequestComplete(stat, KErrNotReady);
		}
	else
		SendReceiveResult(aFunction, aDestination, aDataTo1, aDataTo2, aDataFrom, aStatus);
	}

EXPORT_C void RMMFControllerProxy::SendAsync(const TMMFMessageDestinationPckg& aDestination, TInt aFunction, const TDesC8& aDataTo1, const TDesC8& aDataTo2, TRequestStatus& aStatus) const
	{
	if (iSubThread.Handle() == 0)
		{
		TRequestStatus* stat = &aStatus;
		User::RequestComplete(stat, KErrNotReady);
		}
	else
		SendReceive(aFunction, aDestination, aDataTo1, aDataTo2, aStatus);
	}

EXPORT_C void RMMFControllerProxy::ReceiveEvents(TMMFEventPckg& aEvent, TRequestStatus& aStatus)
	{
	SendAsync(iDestinationPckg, EMMFControllerProxyReceiveEvents, KNullDesC8, KNullDesC8, aEvent, aStatus);
	}

EXPORT_C TInt RMMFControllerProxy::CancelReceiveEvents()
	{
	return SendSync(iDestinationPckg, EMMFControllerProxyCancelReceiveEvents, KNullDesC8, KNullDesC8);
	}

EXPORT_C TInt RMMFControllerProxy::SetThreadPriority(const TThreadPriority& aPriority) const
	{
	TInt err = KErrNone;

	if (iSubThread.Handle() == 0)
		{
		err = KErrNotReady;
		}
	else
		{
		if (iThreadPriority != aPriority)
			{
			// This is a const method so cast it away to store the priority
			RMMFControllerProxy* nonConstThis = const_cast<RMMFControllerProxy*>(this);
			nonConstThis->iThreadPriority = aPriority;
			}
			
		// check controller thread creation location
		RProcess thisProcess;
		RProcess controllerProcess;
		err = iSubThread.Process(controllerProcess);
		
		if (err == KErrNone)
			{
			if (thisProcess.Id() == controllerProcess.Id())
				{
				// Controller server thread is created in current process
				if (iSubThread.Priority() != iThreadPriority)
					{
					iSubThread.Suspend();
					iSubThread.SetPriority(iThreadPriority);
					iSubThread.Resume();
					}
				}
			else
				{
				// Controller server thread is created through DRM plugin server
				RMMFDRMPluginServerProxy server;
				err = server.Open();
				if (err == KErrNone)
					{
					err = server.SetThreadPriority(iSubThread.Id(), iThreadPriority);
					server.Close();
					}
				}
			}
		thisProcess.Close();
		controllerProcess.Close();
		}
	return err;
	}
	
void RMMFControllerProxy::ThreadTerminated()
	{
	// The controller subthread has died and the controller should be closed
	iSubThread.Close();
	}

TInt RMMFControllerProxy::DoCreateSessionForNoDRMCapClient(TUint aMaxHeapSize, TBool aUseSharedHeap, TUint aStackSize)
	{
	TThreadId tid;
	RMMFDRMPluginServerProxy server;
    TInt error = server.Open();
    
    if(!error)
    	{
    	error = server.LaunchControllerServer(aMaxHeapSize, aUseSharedHeap, tid, aStackSize);
    	}		    
    if(!error)
		{
		error = iSubThread.Open(tid, EOwnerThread);
		if(!error)
			{
			iLogonAO->StartMonitoring(iSubThread);
			if (iLogonAO->iStatus != KRequestPending)
				{
				// Failed to logon
				server.KillControllerThread(tid, 0);
				iSubThread.Close();
				error = iLogonAO->iStatus.Int();
				}
			}
		else
			{
			// Failed to open thread handle
			server.KillControllerThread(tid, 0);
			}
		}
	if(!error)
		{
		error = server.SetThreadPriority(tid, iThreadPriority);
		if(!error)
			{
			error = SetReturnedHandle(server.GetControllerSessionHandle());	
			}
		if(error)
			{
			// Failed to create session with controller
			iLogonAO->Cancel();
			server.KillControllerThread(tid, 0);
			iSubThread.Close();
			}
		}
    server.Close();
    return error;
	}


// RMMFCustomCommandsBase

/**
Constructor.

@param  aController
        A reference to the controller client class that will be used to send
        custom commands to the controller plugin.
@param  aInterfaceId
        The UID of the custom command interface that is provided by this client
        API class.

@since 7.0s
*/
EXPORT_C RMMFCustomCommandsBase::RMMFCustomCommandsBase(RMMFController& aController, TUid aInterfaceId)
	: iController(aController), iDestinationPckg(aInterfaceId)
	{
	}


// TMMFMessageDestination
EXPORT_C TMMFMessageDestination::TMMFMessageDestination()
	: iInterfaceId(KNullUid), iDestinationHandle(KMMFObjectHandleController)
	{
	}

EXPORT_C TMMFMessageDestination::TMMFMessageDestination(TUid aInterfaceId)
	: iInterfaceId(aInterfaceId), iDestinationHandle(KMMFObjectHandleController)
	{
	}

EXPORT_C TMMFMessageDestination::TMMFMessageDestination(TUid aInterfaceId, TInt aDestinationHandle)
	: iInterfaceId(aInterfaceId), iDestinationHandle(aDestinationHandle)
	{
	}

EXPORT_C TMMFMessageDestination::TMMFMessageDestination(const TMMFMessageDestination& aOther)
	: iInterfaceId(aOther.iInterfaceId), iDestinationHandle(aOther.iDestinationHandle)
	{
	}

EXPORT_C TUid TMMFMessageDestination::InterfaceId() const
	{
	return iInterfaceId;
	}

EXPORT_C TInt TMMFMessageDestination::DestinationHandle() const
	{
	return iDestinationHandle;
	}

EXPORT_C TBool TMMFMessageDestination::operator==(const TMMFMessageDestination& aOther) const
	{
	return ((iInterfaceId==aOther.iInterfaceId) && (iDestinationHandle==aOther.iDestinationHandle));
	}



// CMMFControllerProxySession
CMMFControllerProxySession* CMMFControllerProxySession::NewL()
	{
	CMMFControllerProxySession* s = new(ELeave) CMMFControllerProxySession;
	return s;
	}

void CMMFControllerProxySession::CreateL(const CMmfIpcServer& aServer)
	{
	CMmfIpcSession::CreateL(aServer);
	iServer = STATIC_CAST(CMMFControllerProxyServer*, (CONST_CAST(CMmfIpcServer*, &aServer)));
	iServer->SessionCreated();
	}

CMMFControllerProxySession::~CMMFControllerProxySession()
	{
	delete iController;
	delete iEventReceiver;
	iEvents.Close();
	iServer->SessionDestroyed();
	}



void CMMFControllerProxySession::ServiceL(const RMmfIpcMessage& aMessage)
	{
	TMMFMessage message(aMessage);
	// Get the destination info from the client.
	message.FetchDestinationL();

	if (message.Destination().InterfaceId() == KUidInterfaceMMFControllerProxy)
		{
		// Message for controller proxy so decode here
		TBool complete = EFalse;
		switch (message.Function())
			{
		case EMMFControllerProxyReceiveEvents:
			complete = ReceiveEventsL(message);
			break;
		case EMMFControllerProxyCancelReceiveEvents:
			complete = CancelReceiveEvents(message);
			break;
		case EMMFControllerProxyLoadControllerPluginByUid:
			complete = LoadControllerL(message);
			break;
		default:
			User::Leave(KErrNotSupported);
			}
		if (complete)
			message.Complete(KErrNone);
		}
	else
		{
		// Message for controller so forward on to controller baseclass
		if (iController)
			iController->HandleRequestL(message);
		else
			User::Leave(KErrNotReady);
		}
	}

CMMFControllerProxySession::CMMFControllerProxySession()
	{
	}

TBool CMMFControllerProxySession::ReceiveEventsL(TMMFMessage& aMessage)
	{
	if (iEventReceiver)
		User::Leave(KErrAlreadyExists);
	iEventReceiver = CMMFEventReceiver::NewL(aMessage);
	//send the next cached event (if any) to the client
	if (iEvents.Count() > 0)
		{
		TMMFEvent& event = iEvents[0];
		iEventReceiver->SendEvent(event);
		delete iEventReceiver;
		iEventReceiver=NULL;
		iEvents.Remove(0);
		}
	return EFalse;
	}

TBool CMMFControllerProxySession::CancelReceiveEvents(TMMFMessage& /*aMessage*/)
	{
	delete iEventReceiver;
	iEventReceiver = NULL;
	return ETrue;
	}

TInt CMMFControllerProxySession::SendEventToClient(const TMMFEvent& aEvent)
	{
	TInt error = KErrNone;
	if (iEventReceiver)
		{
		//send event to client now
		iEventReceiver->SendEvent(aEvent);
		delete iEventReceiver;
		iEventReceiver=NULL;
		error = KErrNone;
		}
	else
		{
		//queue the request for later
		TMMFEvent event(aEvent);
		//if we've exceeded the max number of cached messages, delete the first and append this one to the end
		if (iEvents.Count() >= KMMFControllerProxyMaxCachedMessages)
			iEvents.Remove(0);
		error = iEvents.Append(event);
		}
	return error;
	}

TBool CMMFControllerProxySession::LoadControllerL(TMMFMessage& aMessage)
	{
	TMMFUidPckg pckg;
	aMessage.ReadData1FromClientL(pckg);
	
	RThread clientThread;
	aMessage.iMessage.ClientL(clientThread);
	CleanupClosePushL(clientThread);
	iController = CMMFController::NewL(pckg(), *this, clientThread.Id());
	CleanupStack::PopAndDestroy(&clientThread);
	return ETrue;
	}



CMMFControllerProxyServer* CMMFControllerProxyServer::NewL(RServer2* aServer2)
	{
	CMMFControllerProxyServer* s = new(ELeave) CMMFControllerProxyServer();
	CleanupStack::PushL(s);
	s->ConstructL(aServer2);
	CleanupStack::Pop(s);
	return s;
	}

CMMFControllerProxyServer::CMMFControllerProxyServer() :
	CMmfIpcServer(EPriorityStandard, EGlobalSharableSessions)
	{
	}

void CMMFControllerProxyServer::ConstructL(RServer2* aServer2)
	{
	SetPinClientDescriptors(ETrue);
	
	StartL(KNullDesC);
	*aServer2 = CServer2::Server();
	
	iShutdownTimer = CMMFControllerProxyShutdown::NewL();
	iShutdownTimer->Start();
	}

CMMFControllerProxyServer::~CMMFControllerProxyServer()
	{
	delete iShutdownTimer;
	}

EXPORT_C TInt CMMFControllerProxyServer::StartThread(TAny* aParam)
	{
	TInt err = KErrNone;
	//create cleanupstack
	CTrapCleanup* cleanup=CTrapCleanup::New(); // get clean-up stack
	if (!cleanup)
		err = KErrNoMemory;
	if (!err)
		{
		TRAP(err, DoStartThreadL(aParam));
		}
	delete cleanup;
	return err;
	}
	
void CMMFControllerProxyServer::RenameControllerProxyThread()
	{
	RThread thread;
	TThreadId threadId;
	TName name;
	name.Append(KMMFControllerProxyServerName);
	threadId = thread.Id();
	name.AppendNum(threadId.Id(),EHex);
	User::RenameThread(name);
	}

void CMMFControllerProxyServer::DoStartThreadL(TAny* aParam)
	{
	TControllerProxyServerParams* params = static_cast<TControllerProxyServerParams*>(aParam);
	
	//Rename Current thread to unique name
	RenameControllerProxyThread();
	
#ifndef SYMBIAN_USE_CLIENT_HEAP
	TBool usingSharedHeap = params->iUsingSharedHeap; // take copy since params invalid after Rendezvous
	
	if( ! usingSharedHeap )
		{
		__UHEAP_MARK;
		}

#endif
	// create and install the active scheduler we need
	CActiveScheduler* s=new(ELeave) CActiveScheduler;
	CleanupStack::PushL(s);
	CActiveScheduler::Install(s);
	// create the server (leave it on the cleanup stack)
	CleanupStack::PushL(CMMFControllerProxyServer::NewL( params->iServer ) );
	// Initialisation complete, now signal the client
	RThread::Rendezvous(KErrNone);
	// Ready to run
	CActiveScheduler::Start();
	
	REComSession::FinalClose();
	
	// Cleanup the server and scheduler
	CleanupStack::PopAndDestroy(2, s);
#ifndef SYMBIAN_USE_CLIENT_HEAP
	if( ! usingSharedHeap )
		{
		__UHEAP_MARKEND;
		}
#endif
	}

TInt CMMFControllerProxyServer::RunError(TInt aError)
	{
	// Send error to the client
	Message().Complete(aError);
	ReStart();
	return KErrNone;
	}

CMmfIpcSession* CMMFControllerProxyServer::NewSessionL(const TVersion& aVersion) const
	{
	// Only one session is allowed to connect to us
	if (iHaveSession)
		User::Leave(KErrAlreadyExists);
	// Check that the version number of the client is correct
	if (!User::QueryVersionSupported(KMMFControllerProxyVersion, aVersion))
		User::Leave(KErrNotSupported);

	return CMMFControllerProxySession::NewL();
	}

void CMMFControllerProxyServer::SessionCreated()
	{
	iHaveSession = ETrue;
	// Stop the shutdown timer
	iShutdownTimer->Cancel();
	}

void CMMFControllerProxyServer::SessionDestroyed()
	{
	// Need to shut down
	iShutdownTimer->ShutdownNow();
	}

CMMFControllerProxyShutdown* CMMFControllerProxyShutdown::NewL() 
	{
	CMMFControllerProxyShutdown* s = new(ELeave) CMMFControllerProxyShutdown();
	CleanupStack::PushL(s);
	s->ConstructL();
	CleanupStack::Pop(s);
	return s;
	}

CMMFControllerProxyShutdown::CMMFControllerProxyShutdown() : 
	CTimer(EPriorityLow)
	{
	CActiveScheduler::Add(this);
	}

void CMMFControllerProxyShutdown::ConstructL()
	{
	CTimer::ConstructL();
	}

void CMMFControllerProxyShutdown::Start()
	{
	After(EMMFControllerProxyShutdownDelay);
	}

void CMMFControllerProxyShutdown::RunL()
	{
	ShutdownNow();
	}

void CMMFControllerProxyShutdown::ShutdownNow()
	{
	CActiveScheduler::Stop();
	}







CMMFEventReceiver* CMMFEventReceiver::NewL(const TMMFMessage& aMessage)
	{
	return new(ELeave) CMMFEventReceiver(aMessage);
	}

CMMFEventReceiver::~CMMFEventReceiver()
	{
	if (!(iMessage.IsCompleted()))
		iMessage.Complete(KErrDied);
	}

void CMMFEventReceiver::SendEvent(const TMMFEvent& aEvent)
	{
	TMMFEventPckg eventpckg(aEvent);
	TInt err = iMessage.WriteDataToClient(eventpckg);
	iMessage.Complete(err);
	}

CMMFEventReceiver::CMMFEventReceiver(const TMMFMessage& aMessage) : iMessage(aMessage)
	{
	}



// TMMFMessage
EXPORT_C TMMFMessage::TMMFMessage(const TMMFMessage& aMessage) :
	iMessage(aMessage.iMessage), 
#ifdef __MMF_USE_IPC_V2__
	iFunction(aMessage.iFunction),
#endif  // __MMF_USE_IPC_V2__
	iDestination(aMessage.iDestination), 
	iAmCompleted(aMessage.iAmCompleted)
	{
	}

EXPORT_C const TMMFMessageDestination& TMMFMessage::Destination()
	{
	return iDestination;
	}

EXPORT_C TInt TMMFMessage::Function()
	{
#ifdef __MMF_USE_IPC_V2__
	return iFunction;
#else
	return iMessage.Function();
#endif // __MMF_USE_IPC_V2__
	}

EXPORT_C TInt TMMFMessage::SizeOfData1FromClient()
	{
#ifdef __MMF_USE_IPC_V2__
	return iMessage.GetDesLength(1);
#else
	return iMessage.Client().GetDesLength(iMessage.Ptr1());
#endif // __MMF_USE_IPC_V2__
	}

EXPORT_C void TMMFMessage::ReadData1FromClientL(TDes8& aDes)
	{
#ifdef __MMF_USE_IPC_V2__
	iMessage.ReadL(1, aDes);
#else
	iMessage.ReadL(iMessage.Ptr1(), aDes);
#endif // __MMF_USE_IPC_V2__
	}

EXPORT_C TInt TMMFMessage::ReadData1FromClient(TDes8& aDes)
	{
	TRAPD(err, ReadData1FromClientL(aDes));
	return err;
	}

EXPORT_C TInt TMMFMessage::SizeOfData2FromClient()
	{
#ifdef __MMF_USE_IPC_V2__
	return iMessage.GetDesLength(2);
#else
	return iMessage.Client().GetDesLength(iMessage.Ptr2());
#endif // __MMF_USE_IPC_V2__
	}

EXPORT_C void TMMFMessage::ReadData2FromClientL(TDes8& aDes)
	{
#ifdef __MMF_USE_IPC_V2__
	iMessage.ReadL(2, aDes);
#else
	iMessage.ReadL(iMessage.Ptr2(), aDes);
#endif // __MMF_USE_IPC_V2__
	}

EXPORT_C TInt TMMFMessage::ReadData2FromClient(TDes8& aDes)
	{
	TRAPD(err, ReadData2FromClientL(aDes));
	return err;
	}

EXPORT_C void TMMFMessage::WriteDataToClientL(const TDesC8& aDes)
	{
#ifdef __MMF_USE_IPC_V2__
	iMessage.WriteL(3, aDes);
#else
	iMessage.WriteL(iMessage.Ptr3(), aDes);
#endif // __MMF_USE_IPC_V2__
	}

EXPORT_C TInt TMMFMessage::WriteDataToClient(const TDesC8& aDes)
	{
	TRAPD(err, WriteDataToClientL(aDes));
	return err;
	}

EXPORT_C void TMMFMessage::Complete(TInt aReason)
	{
	iMessage.Complete(aReason);
	iAmCompleted = ETrue;
	}

EXPORT_C TBool TMMFMessage::IsCompleted()
	{
	return iAmCompleted;
	}
	
EXPORT_C void TMMFMessage::AdoptFileHandleFromClientL(TInt aFsHandleIndex, TInt aFileHandleIndex, RFile& aFile)
	{
	User::LeaveIfError(aFile.AdoptFromClient(RMessage2(iMessage) , aFsHandleIndex, aFileHandleIndex));
	}

EXPORT_C TMMFMessage::TMMFMessage(const RMmfIpcMessage& aMessage) :
	iMessage(aMessage), 
#ifdef __MMF_USE_IPC_V2__
	iFunction(aMessage.Function()),
#endif // __MMF_USE_IPC_V2__
	iAmCompleted(EFalse)
	{
	}

EXPORT_C void TMMFMessage::FetchDestinationL()
	{
	// Read the destination info from the client
	TMMFMessageDestinationPckg pckg;
#ifdef __MMF_USE_IPC_V2__
	iMessage.ReadL(0, pckg);
#else
	iMessage.ReadL(iMessage.Ptr0(), pckg);
#endif // __MMF_USE_IPC_V2__
	iDestination = pckg();
	}


// CMMFObject

/**
Constructor.

@param  aInterfaceId
        The UID of the interface provided by this object.
@since 7.0s
*/
EXPORT_C CMMFObject::CMMFObject(TUid aInterfaceId)
	: iHandle(aInterfaceId, KMMFObjectHandleNull)
	{
	}

/**
Destructor.
*/
EXPORT_C CMMFObject::~CMMFObject()
	{
	}

/**
Returns the handle of the object.

@return The handle of this object.

@since  7.0s
*/
EXPORT_C const TMMFMessageDestination& CMMFObject::Handle()
	{
	return iHandle;
	}

/**
Compares two CMMFObjects by comparing their handles.

@param  aOther
        The object to be compared with this object.

@return A boolean indicating if the two CMMFObjects are the same. ETrue if they are the same,
        EFalse if the objects are different.
@since  7.0s
*/
EXPORT_C TBool CMMFObject::operator==(const CMMFObject& aOther)
	{
	return (iHandle==aOther.iHandle);
	}

void CMMFObject::SetHandle(const TMMFMessageDestination& aNewHandle)
	{
	iHandle = aNewHandle;
	}


// CMMFDataSourceHolder

/**
Constructor.

@param  aDataSource
        The data source to be wrapped.

@since  7.0s
*/
EXPORT_C CMMFDataSourceHolder::CMMFDataSourceHolder(MDataSource& aDataSource)
	: CMMFObject(KUidInterfaceMMFDataSourceHolder), iDataSource(&aDataSource)
	{
	}

/**
Destructor.

Note: This deletes the data source.

@since 7.0s
*/
EXPORT_C CMMFDataSourceHolder::~CMMFDataSourceHolder()
	{
	delete iDataSource;
	}

/**
Returns a reference to the data source.

@return The data source.

@since  7.0s
*/
EXPORT_C MDataSource& CMMFDataSourceHolder::DataSource()
	{
	return *iDataSource;
	}

/**
Implementation of the pure virtual function inherited from CMMFObject.

Passes the request directly to the data source.

@param  aMessage
        The message to be handled.

@since  7.0s
*/
EXPORT_C void CMMFDataSourceHolder::HandleRequest(TMMFMessage& aMessage)
	{
	iDataSource->SourceCustomCommand(aMessage);
	}


// CMMFDataSinkHolder

/**
Constructor.

@param  aDataSink
        The data sink to be wrapped.
@since 7.0s
*/
EXPORT_C CMMFDataSinkHolder::CMMFDataSinkHolder(MDataSink& aDataSink)
	: CMMFObject(KUidInterfaceMMFDataSinkHolder), iDataSink(&aDataSink)
	{
	}

/**
Destructor.

Note: This deletes the data sink.

@since  7.0s
*/
EXPORT_C CMMFDataSinkHolder::~CMMFDataSinkHolder()
	{
	delete iDataSink;
	}

/**
Returns a reference to the data sink.

@return The data sink.
@since 7.0s
*/
EXPORT_C MDataSink& CMMFDataSinkHolder::DataSink()
	{
	return *iDataSink;
	}

/**
Implementation of the pure virtual function inherited from CMMFObject.

Passes the request directly to the data sink.

@param  aMessage
        The message to be handled.

@since  7.0s
*/
EXPORT_C void CMMFDataSinkHolder::HandleRequest(TMMFMessage& aMessage)
	{
	iDataSink->SinkCustomCommand(aMessage);
	}


// CMMFCustomCommandParserBase
EXPORT_C TUid CMMFCustomCommandParserBase::InterfaceId()
	{
	return iInterfaceId;
	}

EXPORT_C CMMFCustomCommandParserBase::~CMMFCustomCommandParserBase()
	{
	}

EXPORT_C CMMFCustomCommandParserBase::CMMFCustomCommandParserBase(TUid aInterfaceId)
	: iInterfaceId(aInterfaceId)
	{
	}


// CMMFObjectContainer

/**
Constructor.

@since  7.0s
*/
EXPORT_C CMMFObjectContainer::CMMFObjectContainer()
	{
	iNextObjectHandle = KMMFObjectHandleFirstValid;
	}

/**
Destructor.

Deletes all objects owned by the container.

@since  7.0s
*/
EXPORT_C CMMFObjectContainer::~CMMFObjectContainer()
	{
	iObjects.ResetAndDestroy();
	iObjects.Close();
	}

/**
Add an object to the container.

Once the object has been added, its ownership is transferred to the container.

@param  aObject
        A reference to the object to be added to the container.

@return	An error code indicating if the function call was successful. If the return code is not KErrNone, then
		ownership of the object still remains with the caller.
@since  7.0s
*/
EXPORT_C TInt CMMFObjectContainer::AddMMFObject(CMMFObject& aObject)
	{
	// Check the object isn't already added
	if (aObject.Handle().DestinationHandle() != KMMFObjectHandleNull)
		return KErrAlreadyExists;

	TMMFMessageDestination newHandle(aObject.Handle().InterfaceId(), GenerateObjectHandle());
	// Set the object's handle
	aObject.SetHandle(newHandle);
	// Append the object to the array
	TInt error = iObjects.Append(&aObject);
	// If error occurred, reset object handle to NULL
	if (error)
		{
		TMMFMessageDestination evenNewerHandle(aObject.Handle().InterfaceId(), KMMFObjectHandleNull);
		aObject.SetHandle(evenNewerHandle);
		}
	return error;
	}

/**
Removes and destroys an object from the container.

This method ensures that the object is no longer in the container, and that it gets deleted.
Even if the object is not found in the container's array of objects, it will be deleted.

@param  aObject
        A reference to the object to be deleted.

@since  7.0s
*/
EXPORT_C void CMMFObjectContainer::RemoveAndDestroyMMFObject(CMMFObject& aObject)
	{
	TInt positionOfObjectInArray;
	TInt error = FindMMFObject(aObject, positionOfObjectInArray);
	if (!error)
		{
		iObjects.Remove(positionOfObjectInArray);
		}
	//else, we don't care since we're just saying we'll make sure the object
	//isn't in the array, and that it gets deleted.
	delete (&aObject);
	}

/**
Removes and destroys all objects from the container.

@since	7.0s
*/
EXPORT_C void CMMFObjectContainer::DeleteAllObjects()
	{
	iObjects.ResetAndDestroy();
	}

/**
Finds an object in the container using a handle.

@param  aObjectHandle
        The handle of the object to be located.
@param  aObjectFound
        A reference to a pointer to the object found in the container.

@return An error code indicating if the function call was successful. KErrNone on success, otherwise
        another of the system-wide error codes.
@since	7.0s
*/
EXPORT_C TInt CMMFObjectContainer::FindMMFObject(const TMMFMessageDestination& aObjectHandle, CMMFObject*& aObjectFound)
	{
	// Need to find the appropriate object in the array of CMMFObjects
	TInt error = KErrNotFound;
	for (TInt i=0; i<iObjects.Count(); i++)
		{
		CMMFObject* obj = iObjects[i];
		if (obj->Handle() == aObjectHandle)
			{
			error = KErrNone;
			aObjectFound = obj;
			break;
			}
		}
	return error;
	}

const RPointerArray<CMMFObject>& CMMFObjectContainer::MMFObjects()
	{
	return iObjects;
	}
	
TInt CMMFObjectContainer::FindMMFObject(const CMMFObject& aObject, TInt& aPositionInArray)
	{
	TInt error = KErrNotFound;
	for (TInt i=0; i<iObjects.Count(); i++)
		{
		CMMFObject* obj = iObjects[i];
		if (*obj == aObject)
			{
			error = KErrNone;
			aPositionInArray = i;
			break;
			}
		}
	return error;
	}

TInt CMMFObjectContainer::GenerateObjectHandle()
	{
	return iNextObjectHandle++;
	}


CLogonMonitor::CLogonMonitor(MLogonMonitorObserver* aLogonMonitorObserver) 
: CActive(EPriorityStandard)
	{
	iLogonMonitorObserver = aLogonMonitorObserver;
	}
	
void CLogonMonitor::ConstructL()
	{
	if (CActiveScheduler::Current()==0)
		{
		iScheduler = new (ELeave) CActiveScheduler;
		CActiveScheduler::Install(iScheduler);
		}
		
	CActiveScheduler::Add(this);
	}
	
CLogonMonitor* CLogonMonitor::NewL(MLogonMonitorObserver* aLogonMonitorObserver)
	{
	CLogonMonitor* self = new (ELeave) CLogonMonitor(aLogonMonitorObserver);
	CleanupStack::PushL(self);
	self->ConstructL();
	CleanupStack::Pop(self);
	return self;
	}

CLogonMonitor::~CLogonMonitor()
	{
	Cancel();
	
	if (iScheduler)
		{
		CActiveScheduler::Install(NULL);
		delete iScheduler;
		}
	}

void CLogonMonitor::StartMonitoring(RThread& aThread)
	{
	ASSERT(!iThread);
	
	iThread = &aThread;
	iThread->Logon(iStatus);
	SetActive();
	}

void CLogonMonitor::RunL()
	{
	iServer.Close();
	iLogonMonitorObserver->ThreadTerminated();
	}

void CLogonMonitor::DoCancel()
	{
	ASSERT(iThread);
	
	iThread->LogonCancel(iStatus);
	iThread = NULL;
	}

RServer2& CLogonMonitor::Server()
	{
	return iServer;
	}
	
CMMFControllerExtendedData::CMMFControllerExtendedData()
	: CMMFObject(KUidMMFControllerExtendedDataHolder), iSourceSinkInitData(NULL)
	{
	iClientThreadId = 0;
	iSecureDrmMode = EFalse;
	}

CMMFControllerExtendedData::~CMMFControllerExtendedData()
	{
	ResetSourceSinkInitData();
	}
	
void CMMFControllerExtendedData::SetSourceSinkInitData(HBufC8* aSourceSinkInitData)
	{
	ResetSourceSinkInitData();
	iSourceSinkInitData = aSourceSinkInitData;
	}

HBufC8* CMMFControllerExtendedData::SourceSinkInitData() const
	{
	return iSourceSinkInitData;
	}

void CMMFControllerExtendedData::ResetSourceSinkInitData()
	{
	if (iSourceSinkInitData)
		{
		delete iSourceSinkInitData;
		iSourceSinkInitData = NULL;
		}
	}

void CMMFControllerExtendedData::SetClientThreadId(TThreadId aClientThreadId)
	{
	iClientThreadId = aClientThreadId;
	}

TThreadId CMMFControllerExtendedData::ClientThreadId() const
	{
	return iClientThreadId;
	}

void CMMFControllerExtendedData::SetSecureDrmMode(TBool aSecureDrmMode)
	{
	iSecureDrmMode = aSecureDrmMode;
	}

TBool CMMFControllerExtendedData::SecureDrmMode() const
	{
	return iSecureDrmMode;
	}

void CMMFControllerExtendedData::HandleRequest(TMMFMessage& /*aMessage*/)
	{
	// This function is not suppose to be called.
#ifdef _DEBUG
	Panic(EPanicBadInvariant);
#endif
	}