// Copyright (c) 2001-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 "ImageClientMain.h"
#include "GenThreadRelay.h"
#include <ecom/ecom.h>

_LIT(KSubThreadName,"ICLThread");

//
// CThreadRelay
//
/**
 * Constructor for this class.
 *
 */
CThreadRelay::CThreadRelay()
	{
	}

/**
 * Construct for client side threaded relay. Create a thread and wait for the thread
 * to start up or panic. If the thread is successfully created start an undertaker
 * that listens for panics in the thread.
 * 
 * @param	"CSubThreadRelay* (*aFactoryFunctionL)(TThreadId aMainThreadId, TAny* aCodecParam)"
 *			A Facory function that will create a CSubThread derived object.
 * @param	"TAny* aCodecParam"
 *			Parameters to be used during the threaded relay's construction.
 *
 */
void CThreadRelay::ConstructL(CSubThreadRelay* (*aFactoryFunctionL)(TThreadId aMainThreadId, TAny* aCodecParam), TAny* aCodecParam)
	{
	//Get a pointer to this thread's heap
	RHeap& thisHeap = User::Heap();

	//Parameters to send to the sub thread
	TThreadRelayParam param;

	//Add the parameters for the codec
	param.iCodecParam = aCodecParam;

	//Add the factory function to create a CSubThreadDecoderRelay derived object
	param.iFactoryFunctionL = aFactoryFunctionL;

	//The sub thread must return a pointer for us to allow direct calls
	param.iSubThreadRelay = &iSubRelay;

	//Get the id of this thread
	RThread thisThread;
	TThreadId thisThreadId = thisThread.Id();
	param.iMainThreadId = thisThreadId;

	//Get a request to signal us after setup is complete
	TRequestStatus setupComplete = KRequestPending;
	param.iSetupComplete = &setupComplete;

	//current time and the "this" pointer for a unique key
	_LIT(KFormatString,"%S.%020Lu.%08X");
   	TName threadName;
 
	TTime now;
	now.HomeTime();

	threadName.Format(KFormatString, &KSubThreadName, now.Int64(), reinterpret_cast<TUint>(this));

	//Create a new thread for CSubThreadRelay using the same heap as this thread
	TInt result = iSubThread.Create(threadName,
		ThreadFunction,
		KSubThreadStackSize,
		&thisHeap,
		&param);
	if(result != KErrNone)
		User::Leave(result);

	//Run the thread under a lower priority
	iSubThread.SetPriority(KSubThreadPriority); 

	//Wait for thread startup to complete
	TRequestStatus threadStatus = KRequestPending;
	iSubThread.Logon(threadStatus);

	//Start the sub thread
	iSubThread.Resume();

	User::WaitForRequest(threadStatus, setupComplete);

	if(threadStatus!=KRequestPending)
		{
		//Thread creation failed
		TExitType type = iSubThread.ExitType();
		TInt reason = iSubThread.ExitReason();
		if(type==EExitKill)
			User::Leave(reason);
		else
			{
			ASSERT(type==EExitPanic);
			TExitCategoryName category = iSubThread.ExitCategory();
			User::Panic(category,reason);
			}
		}

	// Thread creation was successfull
	TInt error = iSubThread.LogonCancel(threadStatus);
	if(error != KErrNone)
		User::Leave(error); // There is no outstanding request

	User::WaitForRequest(threadStatus); //Eat the signal

	ASSERT(iSubRelay!=NULL);
	iSubRelay->SetSubThread(&iSubThread);
	
	iThreadCreated = ETrue;
	User::LeaveIfError(setupComplete.Int());

	//Create a listener that will monitor the thread
	iSubThreadUndertaker = CSubThreadUndertaker::NewL(iSubThread);
	}


/**
 * Destructor for this class. Calls the shutdown function for the thread.
 *
 */
CThreadRelay::~CThreadRelay()
	{
	Shutdown();
	}

/**
 * Terminate the thread. Since the WaitForRequest() suspend the thread, the undertaker
 * is terminated and logon to the thread locally. Send a shutdown message to the thread
 * and wait for it to terminate.
 *
 */
void CThreadRelay::Shutdown()
	{
	if(iThreadCreated)
		{
		ASSERT(iSubRelay!=NULL);
    	TRequestStatus functionRequest = KRequestPending;
	    TRequestStatus threadRequest = KRequestPending;

	    /*While a function call is in progress this thread is suspended
    	 *and the undertaker will not catch panics, listen for these here
	     */
	    iSubThread.Logon(threadRequest);

	    iSubRelay->RunFunctionInThread(functionRequest, KTerminationFunction, NULL);
    	TRequestStatus* functionCallRequest = iSubRelay->Status();
	    iSubThread.RequestComplete(functionCallRequest, KErrNone);
    	User::WaitForRequest(functionRequest); //At this stage the thread termination signal has been completed
    	User::WaitForRequest(threadRequest); //Eat the thread termination signal

        iThreadCreated = EFalse;
		}

    if(iSubThreadUndertaker)
		{
		iSubThreadUndertaker->Cancel();
		delete iSubThreadUndertaker; iSubThreadUndertaker = NULL;
		}

    iSubThread.Close();
	}

/**
 * Request a function to be executed in the codec thread. Wait for the function to
 * complete or a panic, since the WaitForRequest() suspend the thread(including the
 * undertaker).
 *
 * @param	"TInt aFunctionCode"
 *			The number of the function to execute in the codec thread.
 * @param	"TAny* aParameters"
 *			Parameters for function to be executed in the codec thread.
 * @return	"TInt"
 *			The leave code of the function in the sub thread.
 */
TInt CThreadRelay::RunFunction(TInt aFunctionCode, TAny* aParameters)
	{
	ASSERT(iSubRelay!=NULL);
	TRequestStatus functionRequest = KRequestPending;
	TRequestStatus threadRequest = KRequestPending;

	/*While a function call is in progress this thread is suspended
	 *and the undertaker will not catch panics, listen for these here
	 */
	iSubThread.Logon(threadRequest);

	iSubRelay->RunFunctionInThread(functionRequest, aFunctionCode, aParameters);
	TRequestStatus* functionCallRequest = iSubRelay->Status();
	iSubThread.RequestComplete(functionCallRequest, KErrNone);
	User::WaitForRequest(threadRequest, functionRequest);

	if(threadRequest!=KRequestPending)
		{
		TInt reason = iSubThread.ExitReason();
		TExitCategoryName category = iSubThread.ExitCategory();
		User::Panic(category,reason);
		}

	// Thread is still alive and well
	iSubThread.LogonCancel(threadRequest);
	User::WaitForRequest(threadRequest); //Eat the signal

	ASSERT(functionRequest!=KRequestPending);

	return functionRequest.Int();
	}


/**
 * Return a pointer to the sub thread relay object.
 *
 * @return	"CSubThreadRelay*"
 *			A pointer to the sub thread relay object.
 */
CSubThreadRelay* CThreadRelay::SubThreadRelay()
	{
	return iSubRelay;
	}

/**
 * Return a pointer to the sub thread.
 *
 * @return	"RThread*"
 *			A pointer to the sub thread.
 */
const RThread* CThreadRelay::SubThread() const
	{
	return &iSubThread;
	}


/**
 * Change the sub thread's priority.
 *
 * @param	"TThreadPriority aPriority"
 *			The new priority for the sub thread.
 */
void CThreadRelay::SetPriority(TThreadPriority aPriority) const
	{
	iSubThread.SetPriority(aPriority);
	}

/**
 * Main thread entry point for the codec thread.
 * Create a cleanup stack for the thread and process the codec
 * inside a trap for cleanup behaviour.
 *
 * @param	"TAny* aPtr"
 *			Parameters to be used for creating the thread.
 * @return	"TInt"
 *			The error code for thread termination.
 */
TInt CThreadRelay::ThreadFunction(TAny* aPtr)
	{
	TInt error = KErrNone;

	// Create a cleanup stack for the thread
	CTrapCleanup* cleanupStack = CTrapCleanup::New();
	if(cleanupStack)
		{
		//Connnect to the bitmap server
		error = RFbsSession::Connect();

		if(error==KErrNone)
			{
			//Run the plugin in a trap
			TRAP(error, ThreadTrapFunctionL(aPtr));
			RFbsSession::Disconnect();
			}
		}
	else
		error = KErrNoMemory;

	delete cleanupStack;

	return error;
	}

/**
 * Function for codec thread execution. Create an active scheduler for the thread
 * and start the function call listener. If the thread is successfully created signal
 * the main thread that the thread creation was successfull.
 *
 * @param	"TAny* aPtr"
 *			A pointer to a TThreadRelayParam object containing the startup parameters
 *          for the thread.
 */
void CThreadRelay::ThreadTrapFunctionL(TAny* aPtr)
	{
	//Create an active scheduler for the thread
	CActiveScheduler* scheduler = new (ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);
	CActiveScheduler::Install( scheduler );

	//Call a Factory function to create a CSubThreadRelay derived object
	TThreadRelayParam* threadRelayParam;
	threadRelayParam = STATIC_CAST(TThreadRelayParam*, aPtr);

	//A factory function that will create a CSubThreadRelay derived object
	CSubThreadRelay* (*FactoryFunctionL) (TThreadId aMainThreadId, TAny* aCodecParam);
	FactoryFunctionL = threadRelayParam->iFactoryFunctionL;

	CSubThreadRelay* subThreadRelay;
	//Call the factory function
	subThreadRelay = FactoryFunctionL(threadRelayParam->iMainThreadId, threadRelayParam->iCodecParam);
	CleanupStack::PushL(subThreadRelay);

	//Send a pointer to the sub thread relay back to the main thread
	*threadRelayParam->iSubThreadRelay = subThreadRelay;

	subThreadRelay->Prime();

	// Send a signal to the main thread that the setup was completed
	subThreadRelay->SignalSetupComplete(threadRelayParam->iSetupComplete);

	CActiveScheduler::Start();	

	CleanupStack::PopAndDestroy(2,scheduler); //subThreadRelay, scheduler
	REComSession::FinalClose();
	}

//
// CSubThreadRelay
//
/**
 * Open a connection to the main (caller) thread.
 *
 */
void CSubThreadRelay::ConstructL(TThreadId aMainThreadId)
	{
	User::LeaveIfError(iMainThread.Open(aMainThreadId));
	}

/**
 * Constructor for this class.
 * Add the function call listener to the active scheduler.
 *
 */
CSubThreadRelay::CSubThreadRelay():
	CActive(EPriorityStandard)
	{
	CActiveScheduler::Add(this);
	}

/**
 * Destructor for this class.
 * Close the connection to the main thread.
 *
 */
CSubThreadRelay::~CSubThreadRelay()
	{
	iMainThread.Close();
	}

/**
 * Cancel the function call listener.
 *
 */
void CSubThreadRelay::DoCancel()
	{
	}

/**
 * Send a signal to the main thread to indicate that the thread startup
 * was successfull.
 *
 */
void CSubThreadRelay::SignalSetupComplete(TRequestStatus* aSetupComplete)
	{
	iMainThread.RequestComplete(aSetupComplete, KErrNone);
	}

/**
 * Prime the function call listener.
 *
 */
void CSubThreadRelay::Prime()
	{
	ASSERT(IsActive() == EFalse);
	iStatus = KRequestPending;
	SetActive();
	}

/**
 * Execute a function in the sub thread. Signal the leave result of the function
 * to the main thread. If the termination function is called stop the active
 * scheduler for the sub thread. (This will cause the thread to terminate)
 *
 */
void CSubThreadRelay::RunL()
	{
	ASSERT(iStatus == KErrNone);

	TInt error = KErrNone;
	//Thread termination function called
	if(iFunctionCode == KTerminationFunction)
		CActiveScheduler::Stop();
	else
		{
		Prime();
		TRAP(error, RunFunctionL(iFunctionCode, iFunctionParams));
		}
	TRequestStatus *status = iCallingStatus;
	iMainThread.RequestComplete(status, error);
	}

/**
 * Save the function number and parameters for an outstanding function call in the
 * codec thread.
 *
 * @param	"TRequestStatus& aCallingStatus"
 *			Request to signal the main thread when the function call has completed.
 * @param	"TInt aFunctionCode"
 *			The function number to execute.
 * @param	"TAny* aParameters"
 *			Parameters to the function to execute.
 */
void CSubThreadRelay::RunFunctionInThread(TRequestStatus& aCallingStatus, TInt aFunctionCode, TAny* aParameters)
	{
	iCallingStatus = &aCallingStatus;
	iFunctionCode = aFunctionCode;
	iFunctionParams = aParameters;
	}

/**
 * Store a pointer to the codec thread object.
 *
 * @param	"RThread* aSubThread"
 *			A pointer to the codec thread object.
 */
void CSubThreadRelay::SetSubThread(RThread* aSubThread)
	{
	iSubThread = aSubThread;
	}

/**
 * Return a pointer to the function call listener's request status.
 * Signal this from the main thread to request a function to be executed 
 * in the thread after a call to RunFunctionInThread().
 *
 * @return	"TRequestStatus*"
 *			Request to signal the start of execution of a function in the thread.
 */
TRequestStatus* CSubThreadRelay::Status()
	{
	return &iStatus;
	}

//
//CSubThreadUndertaker
//
/**
 * Factory function for the class.
 * 
 * @param	"RThread& aSubThread"
 *			A thread to monitor for panics
 */
CSubThreadUndertaker* CSubThreadUndertaker::NewL(RThread& aSubThread)
	{
	CSubThreadUndertaker* self;
	self = new (ELeave) CSubThreadUndertaker(&aSubThread);
	return self;
	}

/**
 * Constructor for the class.
 * Add the object to the active scheduler, activate and logon to the
 * thread to monitor for panics
 * 
 * @param	"RThread* aSubThread"
 *			A thread to monitor for panics
 */
CSubThreadUndertaker::CSubThreadUndertaker(RThread* aSubThread) :
	CActive(CActive::EPriorityIdle),
	iSubThread(aSubThread)
	{
	//Add ourself to the active scheduler
	CActiveScheduler::Add(this);

	iSubThread = aSubThread;

	ASSERT(IsActive()==EFalse);
	iStatus = KRequestPending;
	SetActive();

	//Logon to the thread so we will receive signals
	iSubThread->Logon(iStatus);
	}

/**
 * Destructor for this class.
 * Make sure that the undertaker was cancelled before deleted. 
 */
CSubThreadUndertaker::~CSubThreadUndertaker()
	{
	Cancel();
	}

/**
 * This function is triggered when the thread being monitored terminates.
 * If the thread being monitored panic, panic this thread.
 *
 */
void CSubThreadUndertaker::RunL()
	{
	ASSERT(iSubThread != NULL);
	//If we got here the thread has exited
	TInt reason = iSubThread->ExitReason();
	TExitCategoryName category = iSubThread->ExitCategory();
	User::Panic(category, reason);
	}

/**
 * Stop monitoring the thread for panics. This function is executed by
 * calling Cancel() and has to be done before the object is deleted.
 *
 */
void CSubThreadUndertaker::DoCancel()
	{
	iSubThread->LogonCancel(iStatus);
	}