clientimpleventmanager.cpp

270的linux说明

	
	EnterCriticalSection(&m_cs);
	try
	{
		MapObserversOnSameEvent::iterator it = m_mapObserversOnSameEvent.find(hEvent);
		if(it != m_mapObserversOnSameEvent.end())
		{
			CObserversOnSameEvent *pObserversOnSameEvent = (*it).second;
			bRtn = pObserversOnSameEvent->SetTheEvent(pTheEvent);
		}
		else
		{

			//
			// No hHandle exists

			bRtn = false;
		}
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		bRtn = false;  
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("UpdateEventOfHandle") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
    return bRtn;
}

//add ObserverImpl *pObserver to Observe on CEventBind & eb
//return false if try to monitor more than 63 events
bool CClientImplEventManager::AddObserver(CEventBind & eb,ObserverImpl *pObserver)
{
	bool bRtn = true;
	HANDLE hEvent = eb.GetHandle();
	Event *pTheEvent = eb.GetTheEvent();

	EnterCriticalSection(&m_cs);
	try
	{
		MapObserversOnSameEvent::iterator it = m_mapObserversOnSameEvent.find(hEvent);
		if(it != m_mapObserversOnSameEvent.end())
		{
			//the event handle exist,add the observer to its observer_list
			(*it).second->AddObserver(pObserver);
		}
		else
		{
			//the event handle not exist
			//create a new CObserversOnSameEvent,add the observer to its observer_list, 
			CObserversOnSameEvent *pObserversOnSameEvent = new CObserversOnSameEvent(*pTheEvent);
			m_mapObserversOnSameEvent.insert(it, 
				pair<HANDLE, CObserversOnSameEvent * >(hEvent, pObserversOnSameEvent));
			pObserversOnSameEvent->AddObserver(pObserver);

			//Set add flag and set special event to notify monitoring thread
//			m_nThreadCtrlFlag = nADD_EVENT_FOR_MONITOR;
				
			//event handle is added / removed only by main thread
			bRtn = (bool)AddEvent2Monitor(hEvent);//return false if try to monitor more than 63 events
//cout<<"bfsh1\n";
			if(bRtn)
			{
//cout<<"brtn1"<<bRtn<<endl;
				//only when add event successed, need to notify monitor thread
				SetEvent(m_hCtrlEvent);
			}
//cout<<"brtn2"<<bRtn<<endl;
		}
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		bRtn = false;  
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("AddObserver") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
    return bRtn;
}

/*
fix scr255:Previously happen event is recieved when register an event.
tan li
2004-10-18
add parameter bRemoveEvent: return bRemoveEvent to indicate whether the observer_list for 
this event handle is empty and if so remove the event handle 
so that the server layer won't check this event again
*/
bool CClientImplEventManager::RemoveObserver(HANDLE hEvent, ObserverImpl *pObserver, BOOL &bRemoveEvent)
{	
	bool bRtn = true;
	bRemoveEvent = FALSE;
		
	EnterCriticalSection(&m_cs);
	try
	{
		MapObserversOnSameEvent::iterator it = m_mapObserversOnSameEvent.find(hEvent);
		if(it != m_mapObserversOnSameEvent.end())
		{
			//the event handle exist,remove the observer from its observer_list
			CObserversOnSameEvent *pObserversOnSameEvent = (*it).second;
			pObserversOnSameEvent->RemoveObserver(pObserver);

			if(0 == pObserversOnSameEvent->GetObservCount())
			{
				//the observer_list is empty
				//Set delete flag and set special event to notify monitoring thread
				bRemoveEvent = TRUE;
				m_mapObserversOnSameEvent.erase(it);
				delete pObserversOnSameEvent;

//				m_nThreadCtrlFlag = nDELETE_EVENT_FROM_MONITOR;
				//event handle is added / removed only by main thread
				DeleteEventFromMonitor(hEvent);
				SetEvent(m_hCtrlEvent);
			}
		}
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		bRtn = false;  
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("RemoveObserver") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
    return bRtn;
}

DWORD CClientImplEventManager::WaitForEvents()
{
	return WaitForMultipleObjects(m_nEventCount, m_arrayEventHandle, FALSE, INFINITE);
}
/*
DWORD WINAPI NotifyThreadProc(LPVOID lpParam)
{

	CObserversOnSameEvent *pObserversOnSameEvent = (CObserversOnSameEvent *)lpParam;

	pObserversOnSameEvent->NotifyAllObservers();

	return 0;
}*/


//notify all observers on this Underlaying event
bool CClientImplEventManager::OnUnderlayingEvent(int nEventIndex)
{
	bool bRtn = true;
		
	EnterCriticalSection(&m_cs);
	try
	{	
		HANDLE hEvent = m_arrayEventHandle[nEventIndex];
		
		MapObserversOnSameEvent::iterator it = m_mapObserversOnSameEvent.find(hEvent);
		if(it != m_mapObserversOnSameEvent.end())
		{			
			CObserversOnSameEvent *pObserversOnSameEvent = (*it).second;


/*			HANDLE hThread = CreateThread(NULL, 0, NotifyThreadProc, (void*)pObserversOnSameEvent, 0, 0);

			if(hThread != NULL)		
				CloseHandle(hThread);
*/

			pObserversOnSameEvent->NotifyAllObservers();
		}
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		bRtn = false;  
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("OnUnderlayingEvent") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
    return bRtn;
}


//to remove an event From Monitor
void CClientImplEventManager::DeleteEventFromMonitor(HANDLE hEvent)
{
	EnterCriticalSection(&m_cs);
	for(int i = 0; i < m_nEventCount; i++)
	{
		if(hEvent == m_arrayEventHandle[i])
		{
			for(int j = i; j < m_nEventCount - 1; j++)
				m_arrayEventHandle[j] = m_arrayEventHandle[j + 1];

			m_arrayEventHandle[--m_nEventCount] = 0;
			break;
		}
	}
	LeaveCriticalSection(&m_cs);
}


//given [(ServerObject *) + Event::EventType], find respondent (CEventBind *),
//if not exist, create it
//EventClientImpl * is not persistent while the underlying ServerObject * is
CEventBind *CClientImplEventManager::GetEventBind(EventClientImpl *pEvtCltImp, 
												  Event::EventType eType, BOOL bCreateNoneExist/* = TRUE*/)
{
	CEventBind *pEb = NULL;
	EnterCriticalSection(&m_cs);
	try
	{
		pEb = m_CltEventMapMgr.GetEventBind(pEvtCltImp, eType, bCreateNoneExist);
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("GetEventBind") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
	return pEb;
}

void CClientImplEventManager::RemoveEventBind(EventClientImpl *pEvtCltImp, Event::EventType eType)
{
	EnterCriticalSection(&m_cs);
	try
	{
		m_CltEventMapMgr.RemoveEventBind(pEvtCltImp, eType);
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("RemoveEventBind") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
}

bool CClientImplEventManager::HasAddedObserver(void *pSvrObj, Event::EventType eType)
{
	bool bRtn = false;
	EnterCriticalSection(&m_cs);
	try
	{
		bRtn = m_CltEventMapMgr.HasAddedObserver(pSvrObj, eType);
	}
	catch(...)
	{
		LeaveCriticalSection(&m_cs);
		IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CClientImplEventManager"), IntelMobileText("HasAddedObserver") );
        throw( ex ); 
	}
	LeaveCriticalSection(&m_cs);
	return bRtn;
}

CClientImplEventManager & CClientImplEventManager::GetClientImplEventManagerInst()
{
	return s_ClientImplEventManagerInst;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CEventBind::CEventBind(EventClientImpl *pCltImpl, Event::EventType eType)
{
	m_hEvent = CreateEvent (NULL,  // No security attributes
                               FALSE,  // Manual-reset event
                               FALSE,  // Initial state is signaled
                               NULL);

	m_pTheEvent = pCltImpl->CreateClassEvent(eType);
}

CEventBind::~CEventBind()
{
	delete m_pTheEvent;
	m_pTheEvent = NULL;
	CloseHandle(m_hEvent);
}

bool   CEventBind::SetTheEvent(Event & event)
{
	try
	{
		m_pTheEvent->SetObjectType(event.GetObjectType());
		m_pTheEvent->SetObjectKey(event.GetObjectKey());
		m_pTheEvent->SetClassType(event.GetClassType());
		m_pTheEvent->SetParentKey(event.GetParentKey());
	}
	catch (...)
	{
		return false;
	}

	return true;
}

Event* CEventBind::GetTheEvent()
{
	return m_pTheEvent;
}

HANDLE CEventBind::GetHandle()
{
	return m_hEvent;
}

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CObserversOnSameEvent::CObserversOnSameEvent(Event &theEvent)
	: m_theEvent(theEvent)
{
	InitializeCriticalSection(&m_csProtectList);
}

CObserversOnSameEvent::~CObserversOnSameEvent()
{
	DeleteCriticalSection(&m_csProtectList);
}

void CObserversOnSameEvent::AddObserver(ObserverImpl *pObserver)
{
	EnterCriticalSection(&m_csProtectList);
	m_lstObservers.push_back(pObserver);
	LeaveCriticalSection(&m_csProtectList);
}

void CObserversOnSameEvent::RemoveObserver(ObserverImpl *pObserver, 
										   BOOL bOnce /*= TRUE*/)
{
	EnterCriticalSection(&m_csProtectList);
	if(bOnce)
	{
		//for(ListObservers::iterator itr = m_lstObservers.begin(); itr != m_lstObservers.end(); itr++)
		ListObservers::iterator itr = find(m_lstObservers.begin(), m_lstObservers.end(), pObserver);
		if(itr != m_lstObservers.end())
			m_lstObservers.erase(itr);
	}
	else
		m_lstObservers.remove(pObserver);
	LeaveCriticalSection(&m_csProtectList);
}

void CObserversOnSameEvent::RemoveObservers()
{
	EnterCriticalSection(&m_csProtectList);
	m_lstObservers.clear();
	LeaveCriticalSection(&m_csProtectList);
}

int CObserversOnSameEvent::GetObservCount()
{
	int nCnt = 0;
	EnterCriticalSection(&m_csProtectList);
	nCnt = m_lstObservers.size();
	LeaveCriticalSection(&m_csProtectList);
	return nCnt;
}

const ObserverImpl* CObserversOnSameEvent::GetObserver(unsigned int nIndex)
{
	unsigned int iCount;
	EnterCriticalSection(&m_csProtectList);
	ListObservers::iterator it;
	for(it = m_lstObservers.begin(),iCount=0; it != m_lstObservers.end(), iCount<nIndex; it++, iCount++) ;
	
	if (it!=m_lstObservers.end())
	{
		LeaveCriticalSection(&m_csProtectList);
		return *it;
	}

	LeaveCriticalSection(&m_csProtectList);
	return NULL;
	
}

bool   CObserversOnSameEvent::SetTheEvent(Event & event)
{
	try
	{
		m_theEvent.SetObjectType(event.GetObjectType());
		m_theEvent.SetObjectKey(event.GetObjectKey());
		m_theEvent.SetClassType(event.GetClassType());
		m_theEvent.SetParentKey(event.GetParentKey());
	}
	catch (...)
	{
		return false;
	}

	return true;
}

bool CObserversOnSameEvent::NotifyAllObservers()
{
	bool bRtn = true;
	EnterCriticalSection(&m_csProtectList);
		
	try
	{
	//	SYSTEMTIME st;
	//	GetLocalTime(&st);
		time_t t = ::time(NULL);

		/*fix SCR #314 
SYSTEMTIME range: from year 1601 to year 30827 (on Windows Server 2003, Windows XP)

time_t range: from midnight, January 1, 1970 to Tue Jan 19 03:14:07 2038, 
sub-set of SYSTEMTIME range

if the input SYSTEMTIME or FILETIME is out of the range of time_t, 
FileTime2UnixTime and SystemTime2UnixTime return FALSE
*/
	/*	 if(!CTimeHelper::SystemTime2UnixTime(&st, &t))
			bRtn = false;
		else
	*/	{
			m_theEvent.SetTimestamp( t );

			ListObservers::iterator it;
			for(it = m_lstObservers.begin(); it != m_lstObservers.end(); it++)
			{	
				(*it)->Notify(m_theEvent);			
			}
		}
	}
	catch(...)
	{
		LeaveCriticalSection(&m_csProtectList);
		bRtn = false;  
		return bRtn;
		//IntelMobileException ex( IntelMobileText("Operation Error"), IntelMobileText("CObserversOnSameEvent"), IntelMobileText("NotifyAllObservers") );
        //throw( ex ); 
	}
	LeaveCriticalSection(&m_csProtectList);
	return bRtn;
}