resourcebase.h

symbian平台S60_2nd_FP2_SC rtp实现

/////////////////////////////////////////////////////////////////////
#ifndef __RESOURCEBASE_H__
#define __RESOURCEBASE_H__

#include <e32std.h>
#include <e32des8.h>
#include <e32base.h>

#include <string.h>
#define INFINITE 0

class CTThread :public CBase
{
public:
	CTThread( char *aName,
		TThreadFunction     aFunction,
		TAny *              thrdParam,
		TInt                creationFlag = 0	// run immediately
		)
	{
		int nLen =strlen(aName);
		HBufC16* buf16 = HBufC16::New(nLen);

		CleanupStack::PushL(buf16);	
		buf16->Des().Copy((TUint16*)aName, nLen);
		buf16->Des().ZeroTerminate();
		TInt ret = m_thread.Create(buf16->Des(),aFunction,4096,16*1024, 16*1024*256,thrdParam, EOwnerProcess);
		CleanupStack::PopAndDestroy();

		if( ret == KErrNone )
		{
			m_valid = 1;
			if( creationFlag == 0)
			{
				m_thread.Resume();
			}
			else
			{
				m_thread.Suspend();
			}
			m_threadId = m_thread.Id();
		}
		else
		{
			m_valid = 0;
			m_threadId = -1;
		}
	}

	TBool IsValid()
	{
		return m_valid == 1;
	}

	TInt Resume()
	{
		if( IsValid() )
		{
			m_thread.Resume();
			return 1;
		}
		return 0;
	}

	TInt Continue()
	{
		if( IsValid() )
		{
			m_thread.Resume();
			return 1;
		}
		return 0;
	}

	TInt Suspend()
	{
		if( IsValid() )
		{
			m_thread.Suspend ();
			return 1;
		}
		return 0;
	}

	TThreadId GetRealId()
	{
		return m_threadId;
	}

	//这里存在隐患，kill只能在自己线程中调用，而现在无法找到当前线程是否为该线程。
	void Exit(TInt exitCode)
	{
		if( IsValid() )
		{
			m_thread.Kill (exitCode);
			m_valid = 0;
		}
	}

	TBool Kill(TInt exitCode)
	{
		if( IsValid() )
		{
			m_thread.Kill (exitCode);
			m_valid = 0;
			return 1;
		}
		return 0;
	}



	TBool GetExitCode(TInt &exitCode)
	{
		exitCode = m_thread.ExitReason();
		return 1;
	}

	TBool Terminate(TInt exitCode)
	{
		if( IsValid() )
		{
			m_thread.Kill (exitCode);
			m_valid = 0;
			return 1;
		}
		return 0;
	}

	TBool SetPriority( TThreadPriority nPriority )
	{
		if( IsValid() )
		{
			m_thread.SetPriority (nPriority);
			return 1;
		}
		return 0;
	}

	TInt GetPriority()
	{
		TThreadPriority aPriority = m_thread.Priority();
		return aPriority;
	}

private:
	
	RThread                m_thread;
	TThreadId              m_threadId ;
	TInt                   m_valid;
};

///////////////////////////////////////////////////////////////////////////////
// TMutex Class
class CTMutex
{
public:
	CTMutex(const char *name = NULL, TBool initOwner = FALSE )
	{
		m_mutex.CreateLocal(EOwnerProcess);
	}
	
	~CTMutex()
	{
		m_mutex.Close ();
	}

	TBool Lock(TInt timeout = -1 )
	{ 
		m_mutex.Wait ();
		return 1;
	}

	TBool Unlock()
	{ 
		m_mutex.Signal ();
		return 1;
	}
// IsHeld 没有实现注释 by ZHAOSONG
//	TBool IsLocked()
//	{ 
//		return m_mutex.IsHeld();
//	}
private:
	RMutex m_mutex;
};


class CTCriticalSection
{
public:
	CTCriticalSection()  { m_cs.CreateLocal ();	}
	~CTCriticalSection() { m_cs.Close();	}

	void Lock()			 { m_cs.Wait (); }
	void Unlock()		 { m_cs.Signal (); }
	void Enter()		 { Lock();	}
	void Leave()		 { Unlock();}

private:
	RCriticalSection m_cs;

};

class CTSemaphore
{
public:
	CTSemaphore(long  initCnt,
		long  maxCnt = 2048,
		const char *name = NULL)
	{	
		if( initCnt>2048)
			initCnt = 2048;
		m_sp.CreateLocal (initCnt);
	}
	~CTSemaphore()
	{
		m_sp.Close ();
	}

	void Wait(TInt timeout = -1 )
	{ 
	//	return m_sp.Wait (timeout);
	//	return m_sp.Wait();
		m_sp.Wait();
	}

	TBool Post(long relCnt = 1)
	{ 
		m_sp.Signal (relCnt);
		return 1;
	}

	void Lock(TInt timeout = INFINITE)
	{ 
	//	return Wait( timeout );
	//	return Wait();
		Wait();
	}

	TBool Unlock() 
	{	
		return Post(1);
	}
private:
	RSemaphore m_sp;

};
#endif // !__RESOURCEBASE_H__