sipxtapievents.cpp

基于sipfoundy 公司开发的sipx协议API

	OsLock eventLock(*g_pEventListenerLock) ;
	OsLock lock2(*g_pLineListenerLock);

	UtlVoidPtr* ptr ;

    if (hInst && pCallbackProc)
    {
	    UtlSListIterator itor(*g_pEventListeners) ;
	    while ((ptr = (UtlVoidPtr*) itor()) != NULL)
	    {
		    EVENT_LISTENER_DATA *pData = (EVENT_LISTENER_DATA*) ptr->getValue() ;
		    if ((pData->pCallbackProc == pCallbackProc) &&
			    (pData->pUserData == pUserData) && 
                (pData->pInst == (SIPX_INSTANCE_DATA*) hInst))
		    {
			    g_pEventListeners->removeReference(ptr) ;
			    delete pData ;
			    delete ptr ;

                rc = SIPX_RESULT_SUCCESS ;
                break ;
		    }
        }
	}

	return rc ;
}

SIPXTAPI_API SIPX_RESULT sipxListenerAdd(const SIPX_INST hInst, 
                                         CALLBACKPROC pCallbackProc, 
                                         void* pUserData) 
{
    OsSysLog::add(FAC_SIPXTAPI, PRI_INFO,
        "sipxListenerAdd hInst=%p pCallbackProc=%p pUserData=%p",
        hInst, pCallbackProc, pUserData);

    SIPX_RESULT rc = SIPX_RESULT_INVALID_ARGS ;

    OsLock lock(*g_pListenerLock) ;

    if (hInst && pCallbackProc)
    {
        CALL_LISTENER_DATA *pData = new CALL_LISTENER_DATA ;
        pData->pCallbackProc = pCallbackProc ;
        pData->pUserData = pUserData ;
        pData->pInst = (SIPX_INSTANCE_DATA*) hInst ;

        g_pListeners->append(new UtlVoidPtr(pData)) ;

        rc = SIPX_RESULT_SUCCESS ;
    }

    return rc;

}


SIPXTAPI_API SIPX_RESULT sipxListenerRemove(const SIPX_INST hInst,
                                            CALLBACKPROC pCallbackProc,
                                            void* pUserData)
{
    OsSysLog::add(FAC_SIPXTAPI, PRI_INFO,
        "sipxListenerRemove hInst=%p pCallbackProc=%p pUserData=%p",
        hInst, pCallbackProc, pUserData);

    SIPX_RESULT rc = SIPX_RESULT_INVALID_ARGS ;

    OsLock lock(*g_pListenerLock) ;

    UtlVoidPtr* ptr ;

    if (hInst && pCallbackProc)
    {
	    UtlSListIterator itor(*g_pListeners) ;
	    while ((ptr = (UtlVoidPtr*) itor()) != NULL)
	    {
		    CALL_LISTENER_DATA *pData = (CALL_LISTENER_DATA*) ptr->getValue() ;
		    if ((pData->pCallbackProc == pCallbackProc) &&
			    (pData->pUserData == pUserData) && 
                (pData->pInst == (SIPX_INSTANCE_DATA*) hInst))
            {
                            g_pListeners->removeReference(ptr) ;
                            delete pData ;
                            delete ptr ;

                rc = SIPX_RESULT_SUCCESS ;
                break ;
            }
        }
    }

    return rc ;
}


void sipxDumpListeners()
{
    OsLock lock(*g_pListenerLock) ;
    
    UtlVoidPtr* ptr ;

    printf("Dumping sipXtapi Listener List:\n") ;

	int count = 0 ;
	UtlSListIterator itor(*g_pListeners) ;
	while ((ptr = (UtlVoidPtr*) itor()) != NULL)
	{
		CALL_LISTENER_DATA *pData = (CALL_LISTENER_DATA*) ptr->getValue() ;

        printf("\tListener %02d: inst=%p proc=%p, data=%p\n",
                count, pData->pInst, pData->pCallbackProc, pData->pUserData) ;
        count++ ;
    }
}


static const char* MajorLineEventToString(SIPX_LINE_EVENT_TYPE_MAJOR eMajor)
{
    const char* str = "Unknown" ;

    switch (eMajor)
    {
        case SIPX_LINE_EVENT_REGISTERING:
            str = "REGISTERING";
            break;
        case SIPX_LINE_EVENT_REGISTERED:
                str = "REGISTERED";
                break ;
        case SIPX_LINE_EVENT_UNREGISTERING:
                str = "UNREGISTERING";
                break ;
        case SIPX_LINE_EVENT_UNREGISTERED:
                str = "UNREGISTERED";
                break ;
        case SIPX_LINE_EVENT_REGISTER_FAILED:
                str = "REGISTER_FAILED";
                break ;
        case SIPX_LINE_EVENT_PROVISIONED:
                str = "PROVISIONED";
                break ;
        case SIPX_LINE_EVENT_UNREGISTER_FAILED:
            str = "UNREGISTER_FAILED";
            break;
    }
    return str;
}


static const char* MinorLineEventToString(SIPX_LINE_EVENT_TYPE_MINOR eMinor)
{
    const char* str = "Unknown" ;

    switch (eMinor)
    {
        
        case LINE_EVENT_REGISTERING_NORMAL                      :
            str = "REGISTERING_NORMAL";
            break;
        case LINE_EVENT_REGISTERED_NORMAL                       :
            str = "REGISTERED_NORMAL";
            break;
        case LINE_EVENT_UNREGISTERING_NORMAL                    :
            str = "UNREGISTERING_NORMAL";
            break;
        case LINE_EVENT_UNREGISTERED_NORMAL                     :
            str = "UNREGISTERED_NORMAL";
            break;
        case LINE_EVENT_REGISTER_FAILED_COULD_NOT_CONNECT       :
            str = "COULD NOT CONNECT";
            break;
        case LINE_EVENT_REGISTER_FAILED_NOT_AUTHORIZED          :
            str = "NOT AUTHORIZED";
            break;
        case LINE_EVENT_REGISTER_FAILED_TIMEOUT                 :
            str = "TIMEOUT FAILURE";
            break;
        case LINE_EVENT_UNREGISTER_FAILED_COULD_NOT_CONNECT     :
            str = "COULD NOT CONNECT";
            break;
        case LINE_EVENT_UNREGISTER_FAILED_NOT_AUTHORIZED        :
            str = "NOT AUTHORIZED";
            break;
        case LINE_EVENT_UNREGISTER_FAILED_TIMEOUT               :
            str = "TIMEOUT FAILURE";
            break;
        case LINE_EVENT_PROVISIONED_NORMAL                      :
            str = "PROVISIONED_NORMAL";
            break;
        default:
            break;
    }
    return str;
}

SIPXTAPI_API SIPX_RESULT sipxLineListenerAdd(const SIPX_INST hInst,
                                         LINECALLBACKPROC pCallbackProc,
                                         void* pUserData)
{
    OsSysLog::add(FAC_SIPXTAPI, PRI_INFO,
        "sipxLineListenerAdd hInst=%p pCallbackProc=%p pUserData=%p",
        hInst, pCallbackProc, pUserData);

   SIPX_RESULT rc = SIPX_RESULT_INVALID_ARGS ;

    OsLock lock(*g_pLineListenerLock) ;

    if (hInst && pCallbackProc)
    {
        LINE_LISTENER_DATA *pData = new LINE_LISTENER_DATA ;
        pData->pCallbackProc = pCallbackProc ;
        pData->pUserData = pUserData ;
        pData->pInst = (SIPX_INSTANCE_DATA*) hInst ;

        g_pLineListeners->append(new UtlVoidPtr(pData)) ;

        rc = SIPX_RESULT_SUCCESS ;
    }

    return rc;
}

SIPXTAPI_API SIPX_RESULT sipxLineListenerRemove(const SIPX_INST hInst,
                                            LINECALLBACKPROC pCallbackProc,
                                            void* pUserData)
{
    OsSysLog::add(FAC_SIPXTAPI, PRI_INFO,
        "sipxLineListenerRemove hInst=%p pCallbackProc=%p pUserData=%p",
        hInst, pCallbackProc, pUserData);

    SIPX_RESULT rc = SIPX_RESULT_INVALID_ARGS ;

    OsLock lock(*g_pLineListenerLock) ;

    UtlVoidPtr* ptr ;

    if (hInst && pCallbackProc)
    {
        UtlSListIterator itor(*g_pLineListeners) ;
        while ((ptr = (UtlVoidPtr*) itor()) != NULL)
        {
            LINE_LISTENER_DATA *pData = (LINE_LISTENER_DATA*) ptr->getValue() ;
            if ((pData->pCallbackProc == pCallbackProc) &&
                    (pData->pUserData == pUserData) &&
                    (pData->pInst == (SIPX_INSTANCE_DATA*) hInst))
            {
                g_pLineListeners->removeReference(ptr) ;
                delete pData ;
                delete ptr ;

                rc = SIPX_RESULT_SUCCESS ;
                break ;
            }
        }
    }

    return rc ;
}


SIPXTAPI_API char* sipxConfigEventToString(SIPX_CONFIG_EVENT event, 
                                           char* szBuffer, 
                                           size_t nBuffer) 
{
    switch (event)
    {
        case CONFIG_UNKNOWN:
            SNPRINTF(szBuffer, nBuffer, "CONFIG_UNKNOWN") ;
            break ;
        case CONFIG_STUN_SUCCESS:
            SNPRINTF(szBuffer, nBuffer, "CONFIG_STUN_SUCCESS") ;
            break ;
        case CONFIG_STUN_FAILURE:
            SNPRINTF(szBuffer, nBuffer, "CONFIG_STUN_FAILURE") ;
            break ;
        default:
            SNPRINTF(szBuffer, nBuffer, "ERROR -- UNKNOWN EVENT") ;
            assert(FALSE) ;
            break ;
    }

    return szBuffer;
}


void sipxFireLineEvent(const void* pSrc,
                       const char* szLineIdentifier,
                       SIPX_LINE_EVENT_TYPE_MAJOR major,
                       SIPX_LINE_EVENT_TYPE_MINOR minor,
                       const char *bodyBytes )
{
    OsSysLog::add(FAC_SIPXTAPI, PRI_INFO,
        "sipxFireLineEvent pSrc=%p szLineIdentifier=%s major=%d",
        pSrc, szLineIdentifier, major);

	OsLock lock(*g_pLineListenerLock);
    SIPX_LINE_DATA* pLineData = NULL;
    SIPX_LINE hLine = SIPX_LINE_NULL ;

    hLine = sipxLineLookupHandle(szLineIdentifier);
    pLineData = sipxLineLookup(hLine, SIPX_LOCK_READ) ;
    if (pLineData)
    {
        UtlVoidPtr* ptr;
        // Report events to subscribe listeners
	    UtlSListIterator itor(*g_pLineListeners) ;	
        while ((ptr = (UtlVoidPtr*) itor()) != NULL)
        {
            LINE_LISTENER_DATA *pData = (LINE_LISTENER_DATA*) ptr->getValue() ;
            if (pData->pInst->pRefreshManager == pSrc)
            {
                pLineData->pInst = pData->pInst ;
                pData->pCallbackProc(hLine, (SIPX_LINE_EVENT_TYPE_MAJOR)(int)major, pData->pUserData) ;
            }
        }
        UtlSListIterator eventListenerItor(*g_pEventListeners);
        while ((ptr = (UtlVoidPtr*) eventListenerItor()) != NULL)
        {
            EVENT_LISTENER_DATA *pData = (EVENT_LISTENER_DATA*) ptr->getValue();
            if (pData->pInst->pRefreshManager == pSrc)
            {
                SIPX_LINESTATE_INFO lineInfo;
                
                memset((void*) &lineInfo, 0, sizeof(SIPX_LINESTATE_INFO));
                lineInfo.event = (SIPX_LINESTATE_EVENT)(int)major;
                lineInfo.cause = (SIPX_LINESTATE_CAUSE)(int)minor;
                lineInfo.hLine = hLine;
                lineInfo.nSize = sizeof(SIPX_LINESTATE_INFO);
                lineInfo.szBodyBytes = bodyBytes;

                // callback signature:  typedef bool (*SIPX_EVENT_CALLBACK_PROC)(SIPX_EVENT_CATEGORY category, void* pInfo, void* pUserData);
                pData->pCallbackProc(EVENT_CATEGORY_LINESTATE, &lineInfo, pData->pUserData);
            }
        }      
        sipxLineReleaseLock(pLineData, SIPX_LOCK_READ) ;  
    }

    if (SIPX_LINE_EVENT_UNREGISTERED == major)
    {
        sipxLineObjectFree(hLine);
    }                           
}

void sipxFireEvent(const void* pSrc, 
                   SIPX_EVENT_CATEGORY category, 
                   void* pInfo)
{
    OsSysLog::add(FAC_SIPXTAPI, PRI_INFO,
        "sipxFireEvent pSrc=%p category=%d pInfo=%p",
        pSrc, category, pInfo);

    bool bRet = false;
    
    UtlSListIterator eventListenerItor(*g_pEventListeners);
    UtlVoidPtr* ptr;
    
    while ((ptr = (UtlVoidPtr*) eventListenerItor()) != NULL)
    {
        EVENT_LISTENER_DATA *pData = (EVENT_LISTENER_DATA*) ptr->getValue();
        if (pData->pInst->pCallManager == pSrc || 
            pData->pInst->pRefreshManager == pSrc ||  
            pData->pInst->pLineManager == pSrc ||
            pData->pInst->pMessageObserver == pSrc)
        {
            pData->pCallbackProc(category, pInfo, pData->pUserData);
        }
    }
}