// Copyright (c) 1995-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 "openwfcthreadmanager.h"
#include "openwfcjobmanager.h"


COpenWfcMonitorThread::COpenWfcMonitorThread(COpenWfcJobManger& aManager):
iEndThread(EFalse),
iManager(aManager)
	{
	
	}

COpenWfcMonitorThread::~COpenWfcMonitorThread()
	{
	EndThread();
	TRequestStatus threadDies = KErrNone;
	iThread.Resume();
	iThread.Logon(threadDies);
	if (iThread.ExitType() == EExitPending || 
		threadDies != KRequestPending)
		{
		User::WaitForRequest(threadDies);
		}
	iThread.Close();
	iSemaphore.Close();
	}

void COpenWfcMonitorThread::ConstructL(TInt aScreenNumber)
	{
	TBuf <255> threadManagerName;
	/*
	 * At a given instant in time, one screen can have at most one monitor
	 * thread.  Test code will, for a given screen, destroy and re-create
	 * the monitor thread.
	 * 
	 * At appears that the thread, once killed off, still lingers in
	 * the OS for a short time.  The newly created thread fails to create
	 * if it shares the same name as the one that was killed but still is
	 * lingering around.
	 * 
	 * A unique name is needed.  This is guaranteed by using a thread name
	 * which includes a microsecond counter.  This counter wraps every hour,
	 * roughly.  This is comfortably outside the race condition above.
	 * 
	 * To make debugging easier, we also include the screen number in
	 * the thread name.
	 * 
	 * Thus, the thread name is:
	 * WFCMonitorThread_<ScreenNumber>_<MicrosecondCounter>
	 */
	_LIT(KThreadName, "WFCMonitorThread_%d_%d");
	TTime now;
	now.UniversalTime();
	TInt microseconds = I64LOW(now.Int64());
	threadManagerName.Format(KThreadName, aScreenNumber, microseconds);

	User::LeaveIfError(iThread.Create(threadManagerName, 
					   static_cast<TThreadFunction>(&COpenWfcMonitorThread::Main), 
			           KDefaultStackSize, 
			           NULL, 
			           this,
			           EOwnerProcess));	
	iThread.SetPriority(EPriorityNormal);
	User::LeaveIfError(iSemaphore.CreateLocal(0));
  Start();
	}

COpenWfcMonitorThread* COpenWfcMonitorThread::NewLC(TInt aNumber, COpenWfcJobManger& aManager)
	{
	COpenWfcMonitorThread* self = new(ELeave) COpenWfcMonitorThread(aManager);
	CleanupStack::PushL(self);
	self->ConstructL(aNumber);
	return(self);
	}

COpenWfcMonitorThread* COpenWfcMonitorThread::NewL(TInt aNumber, COpenWfcJobManger& aManager)
	{
	COpenWfcMonitorThread* self = COpenWfcMonitorThread::NewLC(aNumber, aManager);
	CleanupStack::Pop(self);
	return self;
	}

TInt COpenWfcMonitorThread::Main(TAny *aSelf)
	{
	COpenWfcMonitorThread* self = static_cast<COpenWfcMonitorThread*>(aSelf);
    return self->Run();
	}

void COpenWfcMonitorThread::Start()
	{
	iThread.Rendezvous(iThreadStatus);
	iThread.Resume();
	User::WaitForRequest(iThreadStatus);
	}

void COpenWfcMonitorThread::Resume()
	{
	iThread.Resume();
	}

void COpenWfcMonitorThread::EndThread()
	{
    iSemaphore.Signal();
	iEndThread = ETrue;
	}

void COpenWfcMonitorThread::Suspend()
	{
	iThread.Suspend();
	}

void COpenWfcMonitorThread::Signal()
    {
    iSemaphore.Signal();
    }

TInt COpenWfcMonitorThread::Run()
	{
	RThread::Rendezvous(KErrNone);
    JQLOG(("** START * COpenWfcMonitorThread::Run()"));
    while(!iEndThread)
        {
        JQLOG(("** WAIT FOR SIGNAL * CCOpenwfcMonitorThread::Run()"));
        iSemaphore.Wait();
        
        if (!iEndThread)
            {
            iManager.DoExecuteJob();
            }
        }

    /* Release any use of EGL by this thread. */
    eglReleaseThread();

    JQLOG(("** EXIT * COpenWfcMonitorThread::Run()"));
	return KErrNone;
	}