//////////////////////////////////////////////////////////////////////////
// XMS_EVT_CALLOUT event handler (local make call out returns)
void OnCallOut(Acs_Evt_t *pAcsEvt)
{
Acs_CallControl_Data *pCallEvt = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
DJ_U32 *u32ErrCodeExt = (DJ_U32 *)&pCallEvt->m_PrivData;
TRACE(_T("Device[%02d][%02d][%02d] called out (ret=%d/%d)\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID,
pCallEvt->m_s32AcsEvtErrCode,
*u32ErrCodeExt);
if (pCallEvt->m_s32AcsEvtErrCode != 0)
{
CString strErr;
strErr.Format(_T("Device[%d][%d] make call failed! (ret=%d/%d)"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID,
pCallEvt->m_s32AcsEvtErrCode,
*u32ErrCodeExt);
g_pDlg->MessageBox(strErr, _T("MakeCall"), MB_OK|MB_ICONERROR);
int iDevice = pAcsEvt->m_DeviceID.m_s16ChannelID;
resetDeviceVoIP(iDevice);
g_pDlg->refreshListIP(iDevice);
}
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_CLEARCALL event handler (call dropped by local or remote)
void OnClearCall(Acs_Evt_t *pAcsEvt)
{
Acs_CallControl_Data *pCallEvt = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] call cleared (ret=%d)\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID,
pCallEvt->m_s32AcsEvtErrCode);
// if has Voice Device binded, unbind it
int iDeviceIP = pAcsEvt->m_DeviceID.m_s16ChannelID;
int iDeviceVoc = g_deviceVoIP[iDeviceIP].iVoiceDevice;
if (iDeviceVoc != -1)
{
MixerControlParam_t paramMixer = {0};
// send SetParam command
RetCode_t ret = XMS_ctsSetParam(g_acsHandle, &g_deviceVoIP[iDeviceIP].device,
VOIP_PARAM_RTPMIXER, sizeof(paramMixer), ¶mMixer);
g_deviceVoIP[iDeviceIP].iVoiceDevice = -1;
g_deviceVoc[iDeviceVoc].iVoIPDevice = -1;
g_pDlg->refreshListIP(iDeviceIP);
g_pDlg->refreshListVoc(iDeviceVoc);
}
}
// add end
// ----------------------------------------------------------------------------------------------------
void DispEventInfo ( Acs_Evt_t *pAcsEvt )
{
char TmpStr[256];
char TmpS[128];
Acs_Dev_List_Head_t * pAcsDevList = NULL;
Acs_UniFailure_Data * pAcsUniFailure = NULL;
sprintf ( TmpStr, "EVT(%4d) : ", pAcsEvt->m_s32EvtSize );
strcat ( TmpStr, GetString_EventType ( pAcsEvt->m_s32EventType ) );
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_OPEN_STREAM:
break;
case XMS_EVT_QUERY_DEVICE:
pAcsDevList = (Acs_Dev_List_Head_t *) FetchEventData(pAcsEvt);
sprintf ( TmpS, " (%s,%2d,%3d)",
GetString_DeviceMain(pAcsDevList->m_s32DeviceMain),
pAcsDevList->m_s32ModuleID,
pAcsDevList->m_s32DeviceNum );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_OPEN_DEVICE:
break;
case XMS_EVT_UNIFAILURE:
pAcsUniFailure = (Acs_UniFailure_Data *) FetchEventData(pAcsEvt);
sprintf ( TmpS, ": %s(0x%X) dev=(%s, %d, %d), %d ?=? %d+%d",
GetString_ErrorCode(pAcsUniFailure->m_s32AcsEvtErrCode), pAcsUniFailure->m_s32AcsEvtErrCode,
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain), pAcsEvt->m_DeviceID.m_s8ModuleID, pAcsEvt->m_DeviceID.m_s16ChannelID,
pAcsEvt->m_s32EvtSize, sizeof(Acs_Evt_t), sizeof(Acs_UniFailure_Data)
);
strcat ( TmpStr, TmpS );
AddMsg ( TmpStr );
// WriteMsgLog(TmpStr);
break;
default:
break;
}
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_ANSWERCALL event handler (local answer call returns)
void OnAnswerCall(Acs_Evt_t *pAcsEvt)
{
Acs_CallControl_Data *pCallEvt = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] call answered (ret=%d)\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID,
pCallEvt->m_s32AcsEvtErrCode);
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_SENDIODATA event handler (H.245 UserInputIndication/SIP INFO/RFC 2833 DTMF)
void OnSendIOData(Acs_Evt_t *pAcsEvt)
{
Acs_IO_Data *pIOEvt = (Acs_IO_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] send IO Data (type=%d) %s\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID,
pIOEvt->m_u16IoType,
pIOEvt->m_s32AcsEvtState?"succeeded":"failed");
}
//*****************************************************************************
//Name : Ack_SigMon
//Author : None
//Description : Signalling monitor event process
//Input : pAcsEvt
//Output : None
//Return : 0 - Success
// -1 - Failure
//*****************************************************************************
DJ_S32 Ack_SigMon(Acs_Evt_t* pAcsEvt)
{
DeviceID_t *pDev = &pAcsEvt->m_DeviceID;
PSMON_EVENT SMevt= NULL;
int index = Get_DeviceIndex(pDev);
if (index == -1)
{
return -1;
}
SMevt = (PSMON_EVENT)FetchEventData(pAcsEvt);
int iPos = g_pDevRes[index].iPos;
Show_Information(iPos, SMevt);
Show_Data(SMevt);
switch (SMevt->EventType)
{
case SMON_EVT_Call_Generate:
pdlg->m_DeviceInfo.SetItemText(iPos, 2, "Call_Generate");
pdlg->m_DeviceInfo.SetItemText(iPos, 3, SMevt->Caller_ID);
pdlg->m_DeviceInfo.SetItemText(iPos, 4, SMevt->Called_ID);
break;
case SMON_EVT_Call_Connect:
pdlg->m_DeviceInfo.SetItemText(iPos, 2, "Call_Connect");
break;
case SMON_EVT_Call_Disconnect:
pdlg->m_DeviceInfo.SetItemText(iPos, 2, "Call_Disconnect");
pdlg->m_DeviceInfo.SetItemText(iPos, 3, "");
pdlg->m_DeviceInfo.SetItemText(iPos, 4, "");
break;
case SMON_EVT_Call_Info:
pdlg->m_DeviceInfo.SetItemText(iPos, 2, "Call_Info");
break;
case SMON_Evt_Gen_Signal_Info:
pdlg->m_DeviceInfo.SetItemText(iPos, 2, "Gen_SignalInfo");
break;
case SMON_Evt_Raw_Signal_Info:
pdlg->m_DeviceInfo.SetItemText(iPos, 2, "Raw_SignalInfo");
break;
default:
break;
}
return 0;
}
//////////////////////////////////////////////////////////////////////////
// Get Param Event Handler
void OnGetParam(Acs_Evt_t *pAcsEvt)
{
TRACE(_T("Device[%02d][%02d][%02d] receive GetParam\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID);
if (g_pDlg->m_pdlgRtp->GetSafeHwnd() == NULL)
return;
Acs_ParamProc_Data *pParamEvt = (Acs_ParamProc_Data *)FetchEventData(pAcsEvt);
g_pDlg->m_pdlgRtp->SendMessage(UM_UPDATEDATA, pParamEvt->m_u16ParamCmdType, (LPARAM)FetchParamData(pAcsEvt));
}
bool CheckPlayEnd ( VOIP_STRUCT *pOneVOIP, Acs_Evt_t *pAcsEvt )
{
Acs_MediaProc_Data *pMediaData = NULL;
if ( pAcsEvt->m_s32EventType == XMS_EVT_PLAY )
{
pMediaData = (Acs_MediaProc_Data *) FetchEventData(pAcsEvt);
if ( pMediaData->m_u8TaskID == pOneVOIP->u8PlayTag )
return true;
}
return false;
}
// -------------------------------------------------------------------------------------------------
void HandleDevState ( Acs_Evt_t *pAcsEvt )
{
VOIP_STRUCT *pOneVOIP;
Acs_GeneralProc_Data *pGeneralData = NULL;
pGeneralData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOIP )
{
pOneVOIP = &M_OneVOIP(pAcsEvt->m_DeviceID);
pOneVOIP->iLineState = pGeneralData->m_s32DeviceState;
DrawMain_LineState( pOneVOIP );
}
}
//*****************************************************************************
//Name : EVT_Handler
//Author : None
//Description : Event handle for XMS system
//Input : esrParam - parameter
//Output : None
//Return : 1 - Success
// 0 - Failure
//*****************************************************************************
DJ_Void EVT_Handler(DJ_U32 esrParam)
{
Acs_Dev_List_Head_t* pAcsDevList = NULL;
Acs_Evt_t* pAcsEvt = NULL;
pAcsEvt = (Acs_Evt_t *)esrParam;
switch(pAcsEvt->m_s32EventType)
{
case XMS_EVT_QUERY_DEVICE:
if (!g_StartWorkFlag)
{
pAcsDevList = (Acs_Dev_List_Head_t *)FetchEventData(pAcsEvt);
switch (pAcsDevList->m_s32DeviceMain)
{
case XMS_DEVMAIN_INTERFACE_CH:
AddDeviceRes(pAcsDevList);
break;
}
}
break;
case XMS_EVT_QUERY_DEVICE_END:
if (!g_StartWorkFlag)
{
pdlg->m_BtnStart.EnableWindow();
InitDevice();
}
break;
case XMS_EVT_OPEN_DEVICE:
Ack_OpenDevice(pAcsEvt);
break;
case XMS_EVT_SIGMON:
if (g_StartWorkFlag)
{
Ack_SigMon(pAcsEvt);
}
break;
default:
break;
}
return;
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_DEVICESTATE event handler (VoIP call state changes)
void OnDeviceState(Acs_Evt_t *pAcsEvt)
{
Acs_GeneralProc_Data *pDeviceState = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] state changed to 0x%08X\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID,
pDeviceState->m_s32DeviceState);
if (pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOIP)
{
int iDevice = pAcsEvt->m_DeviceID.m_s16ChannelID;
g_deviceVoIP[iDevice].iState = pDeviceState->m_s32DeviceState;
switch (pDeviceState->m_s32DeviceState)
{
case DCS_FREE:
g_deviceVoIP[iDevice].iProtocol = 0;
g_deviceVoIP[iDevice].iState = DCS_FREE;
memset(&g_deviceVoIP[iDevice].addrCaller, 0, sizeof(XMS_VOIP_ADDR));
memset(&g_deviceVoIP[iDevice].addrCallee, 0, sizeof(XMS_VOIP_ADDR));
memset(&g_deviceVoIP[iDevice].szDtmf, 0, sizeof(g_deviceVoIP[iDevice].szDtmf));
// resetDeviceVoIP(iDevice);
break;
case DCS_CALLOUT:
break;
case DCS_CALLIN:
break;
case DCS_ALERTING:
break;
case DCS_CONNECT:
break;
case DCS_DISCONNECT:
break;
default:
break;
}
g_pDlg->refreshListIP(iDevice);
g_pDlg->refreshCtrlIP();
g_pDlg->refreshCtrlConf();
}
}
static void HandleDevState(Acs_Evt_t *pAcsEvt)
{
list *current = NULL;
long i;
Acs_GeneralProc_Data *pGeneralData = NULL;
pGeneralData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
if ((pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH) &&
(pAcsEvt->m_DeviceID.m_s16DeviceSub == XMS_DEVSUB_SS7_LINK))
{
if ((i = find(g_pLinkFirst, pAcsEvt->m_DeviceID, ¤t)) >= 0)
{
current->entry[i].u_info.m_LinkInfo.m_GeneralData = *pGeneralData;
}
if (ldebug_flag)
printstr(NULL,"Get ss7link state\n");
}
}
char My_GetIntfDtmfCode(Acs_Evt_t* pAcsEvt)
{
Acs_IO_Data *pIOData = NULL;
char *p;
if ( pAcsEvt->m_s32EventType == XMS_EVT_RECVIODATA ) /*IO Data事件*/
{
pIOData = (Acs_IO_Data *)FetchEventData(pAcsEvt);
if ( ( pIOData->m_u16IoType == XMS_IO_TYPE_DTMF )
&& ( pIOData->m_u16IoDataLen > 0 ) )
{
p = (char *)FetchIOData(pAcsEvt);
return *p;
}
}
return -1; // not a good DTMF
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_QUERY_DEVICE event handler
void OnQueryDevice(Acs_Evt_t *pAcsEvt)
{
Acs_Dev_List_Head_t *pAcsDevList = (Acs_Dev_List_Head_t *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d] query returned %d\n"),
pAcsDevList->m_s32ModuleID,
pAcsDevList->m_s32DeviceMain,
pAcsDevList->m_s32DeviceNum);
if (pAcsDevList->m_s32ModuleID != g_pDlg->m_iDSP)
return;
int iDevice;
DeviceID_t *pDevice = (DeviceID_t *)(pAcsDevList+1);
// save all the capable devices here
// Note: Device Module ID is ignored in this demo,
// which needs to be paid attention to in user's applications!
switch (pAcsDevList->m_s32DeviceMain)
{
case XMS_DEVMAIN_VOIP:
for (iDevice = 0; iDevice < pAcsDevList->m_s32DeviceNum && g_iVoIPDevNum < MAX_DEVICE_VOIP; ++iDevice)
{
g_deviceVoIP[g_iVoIPDevNum++].device = pDevice[iDevice];
}
break;
case XMS_DEVMAIN_VOICE:
for (iDevice = 0; iDevice < pAcsDevList->m_s32DeviceNum && g_iVocDevNum < MAX_DEVICE_VOICE; ++iDevice)
{
g_deviceVoc[g_iVocDevNum++].device = pDevice[iDevice];
}
break;
case XMS_DEVMAIN_CONFERENCE:
for (iDevice = 0; iDevice < pAcsDevList->m_s32DeviceNum && g_iConfDevNum < MAX_DEVICE_CONF; ++iDevice)
{
g_deviceConf[g_iConfDevNum++].device = pDevice[iDevice];
}
break;
}
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_CALLIN event handler (remote call incoming)
void OnCallIn(Acs_Evt_t *pAcsEvt)
{
Acs_CallControl_Data * pCallEvt = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] incoming call\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID);
if (pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOIP)
{
// update incoming call info
ASSERT(pCallEvt->m_PrivData.m_u32DataSize == sizeof(VoIPCallPrivate_t));
VoIPCallPrivate_t *paramVoIPCall = (VoIPCallPrivate_t *)&(pCallEvt->m_PrivData);
int iDevice = pAcsEvt->m_DeviceID.m_s16ChannelID;
g_deviceVoIP[iDevice].iProtocol = paramVoIPCall->m_s32Protocol;
strcpy(g_deviceVoIP[iDevice].addrCaller.tszTelNo, pCallEvt->m_s8CallingNum);
strcpy(g_deviceVoIP[iDevice].addrCaller.tszAddr, paramVoIPCall->m_s8CallerAddress);
g_deviceVoIP[iDevice].addrCaller.port = (USHORT)paramVoIPCall->m_s32CallerPort;
strcpy(g_deviceVoIP[iDevice].addrCaller.tszUserID, paramVoIPCall->m_s8CallerUserID);
strcpy(g_deviceVoIP[iDevice].addrCallee.tszTelNo, pCallEvt->m_s8CalledNum);
strcpy(g_deviceVoIP[iDevice].addrCallee.tszAddr, paramVoIPCall->m_s8CalleeAddress);
g_deviceVoIP[iDevice].addrCallee.port = (USHORT)paramVoIPCall->m_s32CalleePort;
strcpy(g_deviceVoIP[iDevice].addrCallee.tszUserID, paramVoIPCall->m_s8CalleeUserID);
// media caps (supported in v2.1.2)
char szMediaCaps[100] = {0};
for (int iCap = 0; iCap < paramVoIPCall->m_u8MediaCapNum; ++iCap)
sprintf(szMediaCaps+strlen(szMediaCaps), " %d", paramVoIPCall->m_u8MediaCapList[iCap]);
TRACE(_T("Media Caps(%d):%s\n"), paramVoIPCall->m_u8MediaCapNum, szMediaCaps);
g_pDlg->refreshListIP(iDevice);
}
}
// -------------------------------------------------------------------------------------------------
void HandleDevState ( Acs_Evt_t *pAcsEvt )
{
TRUNK_STRUCT *pOneTrunk;
PCM_STRUCT *pOnePcm;
Acs_GeneralProc_Data *pGeneralData = NULL;
pGeneralData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH )
{
pOneTrunk = &M_OneTrunk(pAcsEvt->m_DeviceID);
pOneTrunk->iLineState = pGeneralData->m_s32DeviceState;
DrawMain_LineState( pOneTrunk );
}
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_DIGITAL_PORT )
{
pOnePcm = &M_OnePcm(pAcsEvt->m_DeviceID);
pOnePcm->u8E1Type = (pGeneralData->m_s32DeviceState >> 16) & 0xFF;
pOnePcm->s32AlarmVal = (pGeneralData->m_s32DeviceState & 0xFFFF);
DrawPcm_TypeAndAlarm ( pOnePcm );
}
DJ_Void EvtHandler(DJ_U32 esrParam){
Acs_Evt_t * pAcsEvt = NULL;
Acs_Dev_List_Head_t * pAcsDevList = NULL;
DJ_S8 s8DspModID;
DJ_S32 s32Num;
pAcsEvt = (Acs_Evt_t *) esrParam;
VOICE_STRUCT * pOneVoice;
TRUNK_STRUCT * pOneTrunk;
char TmpStr[256];
Acs_GeneralProc_Data *pGeneralData = NULL;
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_QUERY_DEVICE:
{
pAcsDevList = ( Acs_Dev_List_Head_t *) FetchEventData(pAcsEvt);
s8DspModID = (DJ_S8) pAcsDevList->m_s32ModuleID;
s32Num = pAcsDevList->m_s32DeviceNum;
if (s8DspModID == cfg_iPartWorkModuleID)
{
switch (pAcsDevList->m_s32DeviceMain)
{
case XMS_DEVMAIN_VOICE:
if ( (AllDeviceRes[s8DspModID].lVocNum == 0) && (s32Num > 0) ) // the resources new added
{
AllDeviceRes[s8DspModID].pVoice = new VOICE_STRUCT[s32Num];
if( AllDeviceRes[s8DspModID].pVoice )
{
AllDeviceRes[s8DspModID].lVocNum = s32Num;
AllDeviceRes[s8DspModID].lVocOpened = 0;
AllDeviceRes[s8DspModID].lVocFreeNum = 0;
memset ( AllDeviceRes[s8DspModID].pVoice, 0, sizeof(VOICE_STRUCT)*s32Num );
DeviceID_t *pDev;
pDev = (DeviceID_t *)((BYTE *)pAcsDevList + sizeof(Acs_Dev_List_Head_t));
for ( int i = 0; i < s32Num; i ++ )
{
AllDeviceRes[s8DspModID].pVoice[i].deviceID = pDev[i];
AllDeviceRes[s8DspModID].pVoice[i].State = VOC_WAITOPEN;
}
}
}
break;
case XMS_DEVMAIN_INTERFACE_CH:
if ( (AllDeviceRes[s8DspModID].lTrunkNum == 0) && (s32Num > 0) ) // the resources new added
{
AllDeviceRes[s8DspModID].pTrunk = new TRUNK_STRUCT[s32Num];
if( AllDeviceRes[s8DspModID].pTrunk )
{
AllDeviceRes[s8DspModID].lTrunkNum = s32Num;
AllDeviceRes[s8DspModID].lTrunkOpened = 0;
memset ( AllDeviceRes[s8DspModID].pTrunk, 0, sizeof(TRUNK_STRUCT)*s32Num );
DeviceID_t *pDev;
pDev = (DeviceID_t *)((BYTE *)pAcsDevList + sizeof(Acs_Dev_List_Head_t));
for (int i = 0; i < s32Num; i ++ )
{
AllDeviceRes[s8DspModID].pTrunk[i].deviceID = pDev[i];
AllDeviceRes[s8DspModID].pTrunk[i].State = TRK_WAITOPEN;
}
}
}
break;
}
}
}
break;
case XMS_EVT_QUERY_ONE_DSP_END: //一个DSP上的资源搜索完毕，打开应用需要的设备
if (pAcsEvt->m_DeviceID.m_s8ModuleID == cfg_iPartWorkModuleID)
{
AllDeviceRes[pAcsEvt->m_DeviceID.m_s8ModuleID].lFlag = 1; // this DSP can use
s8DspModID = (DJ_S8) pAcsEvt->m_DeviceID.m_s8ModuleID;
// pVoice
for ( int i = 0; i < AllDeviceRes[s8DspModID].lVocNum; i++ )
{
pOneVoice = &AllDeviceRes[s8DspModID].pVoice[i];
if ( pOneVoice->State == VOC_WAITOPEN ) // not Open yet
{
if ( XMS_ctsOpenDevice ( g_acsHandle, &pOneVoice->deviceID, NULL ) < 0 )
{
MessageBox(NULL, "Voice open fail!", "XMS_ctsOpenDevice", MB_OK ) ;
}
}
}
// pTrunk
pdlg->m_ListTrunk.DeleteAllItems ();
for ( int j = 0; j < AllDeviceRes[s8DspModID].lTrunkNum; j++ )
{
pOneTrunk = &AllDeviceRes[s8DspModID].pTrunk[j];
pOneTrunk->iSeqID = j;
if ( pOneTrunk->State == TRK_WAITOPEN ) // not Open yet
{
if ( XMS_ctsOpenDevice ( g_acsHandle, &pOneTrunk->deviceID, NULL ) < 0 )
{
MessageBox(NULL, "Trunk open fail!", "XMS_ctsOpenDevice", MB_OK ) ;
}
}
//界面显示中继信息
sprintf ( TmpStr, "%3d", j );
pdlg->m_ListTrunk.InsertItem ( j, TmpStr );
sprintf ( TmpStr, "%d,%d", pOneTrunk->deviceID.m_s8ModuleID, pOneTrunk->deviceID.m_s16ChannelID );
pdlg->m_ListTrunk.SetItemText ( j, 1, TmpStr );
pdlg->m_ListTrunk.SetItemText ( j, 2, GetString_DeviceSub( pOneTrunk->deviceID.m_s16DeviceSub) );
pdlg->m_ListTrunk.SetItemText ( j, 3, GetString_LineState(pOneTrunk->iLineState) );
}
}
break;
case XMS_EVT_QUERY_REMOVE_ONE_DSP_END:
break;
case XMS_EVT_QUERY_DEVICE_END: // Query Device List End
break;
case XMS_EVT_OPEN_DEVICE:
OpenDeviceOK(&pAcsEvt->m_DeviceID );
break;
case XMS_EVT_CLOSE_DEVICE: // before Delete DSP, DSP send event CloseDevice to the APP; call XMS_ctsCloseDevicey() can generate this Event
break;
case XMS_EVT_DEVICESTATE:
pGeneralData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH )
{
pOneTrunk = &AllDeviceRes[pAcsEvt->m_DeviceID.m_s8ModuleID].pTrunk[pAcsEvt->m_DeviceID.m_s16ChannelID];
pOneTrunk->iLineState = pGeneralData->m_s32DeviceState;
pdlg->m_ListTrunk.SetItemText ( pOneTrunk->iSeqID, 3, GetString_LineState(pOneTrunk->iLineState) );
}
break;
case XMS_EVT_UNIFAILURE:
break;
default:
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH &&
pAcsEvt->m_DeviceID.m_s16DeviceSub == XMS_DEVSUB_ANALOG_USER)
{
pOneTrunk = &AllDeviceRes[pAcsEvt->m_DeviceID.m_s8ModuleID].pTrunk[pAcsEvt->m_DeviceID.m_s16ChannelID];
UserWork( pOneTrunk, pAcsEvt );
}else if (pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOICE)
{
DeviceID_t *pDevID;
pOneVoice = &AllDeviceRes[pAcsEvt->m_DeviceID.m_s8ModuleID].pVoice[pAcsEvt->m_DeviceID.m_s16ChannelID];
pDevID = &pOneVoice->UsedDevID;
if ( pDevID->m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH && pDevID->m_s16DeviceSub == XMS_DEVSUB_ANALOG_USER)
{
pOneTrunk = &AllDeviceRes[pDevID->m_s8ModuleID].pTrunk[pDevID->m_s16ChannelID];
UserWork ( pOneTrunk, pAcsEvt );
}
}
break;
}
}
DJ_Void EvtHandler(DJ_U32 esrParam)
{
Acs_Evt_t *pAcsEvt;
Acs_Dev_List_Head_t *pAcsDevList;
ACS_Digital_PortState_Data *pDigitState = NULL;
Acs_UniFailure_Data *pUniFailData = NULL;
WINDOW *win;
int height, width;
win = stdscr;
pAcsEvt= (Acs_Evt_t *)esrParam;
if (ldebug_flag)
{
/*print event*/
}
switch(pAcsEvt->m_s32EventType)
{
case XMS_EVT_QUERY_DEVICE:
pAcsDevList = (Acs_Dev_List_Head_t *)FetchEventData(pAcsEvt);
AddDeviceRes(pAcsDevList);
break;
case XMS_EVT_QUERY_ONE_DSP_END:
{
/*open all device*/
OpenAllDevice_Dsp(pAcsEvt->m_DeviceID.m_s8ModuleID);
}
break;
case XMS_EVT_QUERY_REMOVE_ONE_DSP_END:
{
/*delete Dsp from device table*/
remove(g_pPcmFirst, pAcsEvt->m_DeviceID.m_s8ModuleID);
remove(g_pLinkFirst, pAcsEvt->m_DeviceID.m_s8ModuleID);
}
break;
case XMS_EVT_QUERY_DEVICE_END:
break;
case XMS_EVT_OPEN_DEVICE:
OpenDeviceOK(&pAcsEvt->m_DeviceID);
break;
case XMS_EVT_CLOSE_DEVICE:
// CloseDeviceOK(&pAcsEvt->m_DeviceID);
break;
case XMS_EVT_DEVICESTATE:
HandleDevState(pAcsEvt);
break;
case XMS_EVT_UNIFAILURE:
if (ldebug_flag)
{
pUniFailData = (Acs_UniFailure_Data *)FetchEventData(pAcsEvt);
if (pUniFailData->m_s32AcsEvtState=-1)
{
if (pUniFailData->m_s32AcsEvtErrCode == ACSERR_LINKBROKEN)
{
getyx(win, height, width);
mvprintw(height, 0,"flow connection has been disconnected\n");
}
else if (pUniFailData->m_s32AcsEvtErrCode == ACSERR_GETRESFAIL)
{
getyx(win, height, width);
mvprintw(height, 0, "OpenDevic get device error,deviceType(%d,%d) ch(%d,%d)\n",
pAcsEvt->m_DeviceID.m_s16DeviceMain, pAcsEvt->m_DeviceID.m_s16DeviceSub,
pAcsEvt->m_DeviceID.m_s8ModuleID, pAcsEvt->m_DeviceID.m_s16ChannelID);
}
else if (pUniFailData->m_s32AcsEvtErrCode == ACSERR_DEVICEERR)
{
getyx(win, height, width);
mvprintw(height, 0, "api transfer device error\n");
}
}
break;
case XMS_EVT_CLASS_UNIFAILURE:
if (ldebug_flag)
{
pUniFailData = (Acs_UniFailure_Data *)FetchEventData(pAcsEvt);
if (pUniFailData->m_s32AcsEvtState == -1)
{
if(pUniFailData->m_s32AcsEvtErrCode == ACSERR_FAILSEND)
{
getyx(win, height, width);
mvprintw(height, 0, "send command to function module error\n");
}
}
}
}
break;
case XMS_EVT_E1STATE:
pDigitState = (ACS_Digital_PortState_Data *)FetchEventData(pAcsEvt);
saveDigitState(pAcsEvt, *pDigitState);
if (ldebug_flag)
{
// showDebugPCMState(pAcsEvt, *pDigitState);
}
break;
case XMS_EVT_SS7SendRawFrame:
if (ldebug_flag)
{
printstr(NULL, "recv send raw evt\n");
}
break;
case XMS_EVT_SS7RawFrame:
//if (ldebug_flag)
{
Acs_SS7RawFrame_Data *raw_data = NULL;
raw_data = (Acs_SS7RawFrame_Data *)FetchEventData(pAcsEvt);
}
break;
default:
break;
}
}
// -------------------------------------------------------
DJ_Void EvtHandler(DJ_U32 esrParam)
{
Acs_Evt_t * pAcsEvt = NULL;
Acs_Dev_List_Head_t * pAcsDevList = NULL;
Acs_GeneralProc_Data* pGeneral=NULL;
char TmpStr[256];
char * pStr = NULL;
pAcsEvt = (Acs_Evt_t *) esrParam;
DispEventInfo ( pAcsEvt );
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_OPEN_STREAM:
printf("");
break;
case XMS_EVT_QUERY_DEVICE:
if ( !bStartWorkFlag )
{
pAcsDevList = ( Acs_Dev_List_Head_t *) ( (DJ_S8 *)pAcsEvt + sizeof(Acs_Evt_t) );
//Add or modify device resource to pool when receive the device's event of the state changing
AddDeviceRes ( pAcsDevList );
}
break;
case XMS_EVT_QUERY_DEVICE_END: //get device list completely
if ( !bStartWorkFlag )
{
pGeneral = (Acs_GeneralProc_Data*)FetchEventData(pAcsEvt);
sprintf ( TmpStr, "Start work. DeviceNum = %d\n", TotalDevRes );
AddMsg ( MSG_TYPE_OTHER, TmpStr );
InitDeviceInfo();
bStartWorkFlag = true;
}
break;
case XMS_EVT_OPEN_DEVICE:
OpenDeviceOK ( &pAcsEvt->m_DeviceID );
break;
case XMS_EVT_CLOSE_DEVICE:
CloseDeviceOK ( &pAcsEvt->m_DeviceID );
pStr = GetString_DeviceAll(&pAcsEvt->m_DeviceID);
sprintf(TmpStr,"Close devcie evt: %s",pStr);
AfxMessageBox(TmpStr,NULL,MB_OK);
break;
case XMS_EVT_PLAYCSPREQ:
{
DJ_S32 r = 0;
char MsgStr[100]={0};
CSPPlayDataInfo_t playCSP={0};
Acs_CSPDataReq_Data * pCspReq = NULL;
if(g_cspPlay == 0)
{
break;
}
pCspReq = (Acs_CSPDataReq_Data *)FetchEventData(pAcsEvt);
if(g_cspFp == NULL)
{
g_cspFp = fopen(g_szCSPFile,"rb");
}
if(feof(g_cspFp))
{
fseek(g_cspFp,SEEK_SET,0);
TRACE("Seek to Set\n");
}
playCSP.m_u16DataLen = pCspReq->m_u16ReqCspDataLen;
playCSP.m_u8DataType = XMS_CSPPLAY_DATA_VOC;
playCSP.m_u8TaskID = (DJ_U8)(GetTickCount() % 128);
long rr = fread(g_szDataBuf,sizeof(char),playCSP.m_u16DataLen,g_cspFp);
TRACE("ReqDataLen = %d,sentData=%d\n",pCspReq->m_u16ReqCspDataLen,rr);
r = XMS_ctsSendCSPData(g_acsHandle, &DevOpened[iOpenedIndex1].DevID, &playCSP,g_szDataBuf,NULL);
if ( r < 0 )
{
sprintf ( MsgStr, "X(%d) XMS_ctsPlayCSP() FAIL! (%s)",
r, GetString_DeviceAll (&DevOpened[iOpenedIndex1].DevID) );
AddMsg ( MSG_TYPE_FUNCTION, MsgStr);
}
else
{
sprintf ( MsgStr, "XMS_ctsPlayCSP() OK! (%s)",
GetString_DeviceAll (&DevOpened[iOpenedIndex1].DevID));
AddMsg ( MSG_TYPE_FUNCTION, MsgStr );
}
}
break;
case XMS_EVT_CONTROLPLAY:
g_cspPlay = 0;
break;
case XMS_EVT_RECORDCSP:
{
Acs_MediaCSPProc_Data * pCSPData = NULL;
pCSPData = (Acs_MediaCSPProc_Data *)FetchEventData(pAcsEvt);
fwrite(pCSPData->m_u8StreamData,sizeof(char),pCSPData->m_u16DataLen,g_cspFp);
}
break;
default:
break;
}
}
// -------------------------------------------------------
void DispEventInfo ( Acs_Evt_t *pAcsEvt )
{
char TmpStr[512] = {0};
char TmpS[256] = {0};
char SendTiffFileName[ACS_MAX_FILE_NAME_LEN];
char RecvTiffFileName[ACS_MAX_FILE_NAME_LEN];
char dtmf='?';
Acs_Dev_List_Head_t * pAcsDevList = NULL;
Acs_UniFailure_Data * pAcsUniFailure = NULL;
Acs_GeneralProc_Data *pGeneralData = NULL;
Acs_CallControl_Data *pCallControl = NULL;
Acs_IO_Data *pIOData = NULL;
Acs_CAS_ExtraInfo_t *pCAS_ExtraInfo = NULL;
Acs_AnalogInterface_Data* pAnalogInterface=NULL;
Acs_CSPDataReq_Data* pCspReqData=NULL;
Acs_ParamProc_Data* pSetParam=NULL;
Acs_ParamProc_Data* pGetParam=NULL;
Acs_MediaProc_Data* pMedia=NULL;
Acs_ParamData_UserReadXmsBoardInfo* pBoardInfor=NULL;
sprintf ( TmpStr, "" );
strcat ( TmpStr, GetString_EventType ( pAcsEvt->m_s32EventType ) );
Acs_MediaProc_Data * pMediaData = (Acs_MediaProc_Data *)FetchEventData(pAcsEvt);
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_GETPARAM:
{
pGetParam = (Acs_ParamProc_Data*)FetchEventData(pAcsEvt);
pBoardInfor = (Acs_ParamData_UserReadXmsBoardInfo*)((char*)pGetParam+sizeof(Acs_ParamProc_Data));
}
break;
case XMS_EVT_DEV_TIMER:
{
char ioFskBuf[512];
int iFskLen;
char MsgStr[512];
memset(ioFskBuf,0,sizeof(ioFskBuf));
pdlg->GetDlgItemText(IDC_EDIT_CALLINGNUM,MsgStr,sizeof(MsgStr));
EncodeFskCaller(MsgStr,ioFskBuf,&iFskLen);
int r = XMS_ctsSendIOData ( g_acsHandle, &pAcsEvt->m_DeviceID,
XMS_IO_TYPE_FSK, (DJ_U16)iFskLen, (DJ_Void *) ioFskBuf );
if ( r < 0 )
{
sprintf ( MsgStr, "X(%d) XMS_ctsSendIOData( %s, %d, [%s] ) FAIL! (%s)",
r, "GTG ", g_iLen, TmpStr,
GetString_DeviceAll (&pAcsEvt->m_DeviceID) );
AddMsg ( MSG_TYPE_FUNCTION, MsgStr );
}
else
{
sprintf ( MsgStr, "XMS_ctsSendIOData( %s, %d, [%s] ) OK! (%s)",
"GTG ", g_iLen, TmpStr,
GetString_DeviceAll (&pAcsEvt->m_DeviceID) );
AddMsg ( MSG_TYPE_FUNCTION, MsgStr );
}
}
break;
case XMS_EVT_BUILDINDEX:
pMedia=(Acs_MediaProc_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS," EvtState=%d taskID=%d fileIndex=%u,%x",pMedia->m_s32AcsEvtState,pMedia->m_u8TaskID,pMedia->m_u32CurFileIndex,pMedia->m_u32CurFileIndex);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_PLAY:
pMedia=(Acs_MediaProc_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS," EvtState=%d Errcode=%d taskID=%d fileIndex=%d",pMedia->m_s32AcsEvtState,pMedia->m_s32AcsEvtErrCode,pMedia->m_u8TaskID,pMedia->m_u32CurFileIndex);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_SETPARAM:
pSetParam = (Acs_ParamProc_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS," CmdType=[%d]",pSetParam->m_u16ParamCmdType);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_UNLINKDEVICE:
pGeneralData = (Acs_GeneralProc_Data*) FetchEventData(pAcsEvt);
break;
case XMS_EVT_PLAYCSPREQ:
//
pCspReqData = (Acs_CSPDataReq_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS,"CSPPLAYREQ datalen =%d",pCspReqData->m_u16ReqCspDataLen);
strcat(TmpStr,TmpS);
break;
case XMS_EVT_ANALOG_INTERFACE:
pAnalogInterface = (Acs_AnalogInterface_Data*)FetchEventData(pAcsEvt);
sprintf(TmpS,"(%d,%s)",pAnalogInterface->m_u8AnalogInterfaceState,GetString_AnalogInterfaceState(pAcsEvt->m_DeviceID.m_s16DeviceSub,pAnalogInterface->m_u8AnalogInterfaceState));
strcat(TmpStr,TmpS);
break;
case XMS_EVT_SENDIODATA:
sprintf ( TmpS, " (%s,%s,MachineID:%2d,ModuleID:%3d,Ch:%d)",
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceMain,pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8MachineID,
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID );
/*strcat ( TmpStr, TmpS );
{
CmdParamData_AnalogTrunk_t cmdAnalogTrunk;
void*p =(void*)&cmdAnalogTrunk; ;
XMS_ctsSetParam(g_acsHandle,&pAcsEvt->m_DeviceID,ANALOGTRUNK_PARAM_UNBINDVOC,sizeof(CmdParamData_AnalogTrunk_t),p);
////
}*/
strcat(TmpStr,TmpS);
break;
case XMS_EVT_LINKDEVICE:
case XMS_EVT_CLEARCALL:
sprintf ( TmpS, " (%s,%s,MachineID:%2d,ModuleID:%3d,Ch:%d)",
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceMain,pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8MachineID,
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_OPEN_STREAM:
break;
case XMS_EVT_QUERY_DEVICE:
pAcsDevList = (Acs_Dev_List_Head_t *)FetchEventData(pAcsEvt);
sprintf ( TmpS, " (%s,%2d,%3d)",
GetString_DeviceMain(pAcsDevList->m_s32DeviceMain),
pAcsDevList->m_s32ModuleID,
pAcsDevList->m_s32DeviceNum );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_QUERY_ONE_DSP_START:
case XMS_EVT_QUERY_ONE_DSP_END:
sprintf ( TmpS, " (%d)", pAcsEvt->m_DeviceID.m_s8ModuleID );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_OPEN_DEVICE:
{
pGeneralData = (Acs_GeneralProc_Data*)FetchEventData(pAcsEvt);
int isize = sizeof(Acs_GeneralProc_Evt);
isize = sizeof(Acs_GeneralProc_Data);
sprintf ( TmpS, "(%s) CallID(%d,%d)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pAcsEvt->m_DeviceID.m_CallID.m_s32FlowType, pAcsEvt->m_DeviceID.m_CallID.m_s32FlowChannel );
strcat ( TmpStr, TmpS );
}
break;
case XMS_EVT_DEVICESTATE:
pGeneralData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) S=0x%X(%s)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pGeneralData->m_s32DeviceState, GetString_DeviceState(pGeneralData->m_s32DeviceState) );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_CALLIN:
pCallControl = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) (%s,%s)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pCallControl->m_s8CallingNum, pCallControl->m_s8CalledNum);
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_CALLOUT:
pCallControl = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) EvtState=%d, ErrCode=%d,ClearCause=%d) calling=%s called=%s", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pCallControl->m_s32AcsEvtState, pCallControl->m_s32AcsEvtErrCode, pCallControl->m_s32CallClearCause,pCallControl->m_s8CallingNum,pCallControl->m_s8CalledNum );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_RECVIODATA:
{
pIOData = (Acs_IO_Data *)FetchEventData(pAcsEvt);
//strcat ( TmpStr, TmpS );
//AddMsg ( MSG_TYPE_EVENT, TmpStr );
pdlg->GetDlgItem ( IDC_EDIT_SENDFAX )->GetWindowText ( SendTiffFileName, ACS_MAX_FILE_NAME_LEN-1 );
pdlg->GetDlgItem ( IDC_EDIT_RECEIVEFAX )->GetWindowText ( RecvTiffFileName, ACS_MAX_FILE_NAME_LEN-1 );
//sprintf ( s8LocalID, "DJ:83636988" );
if( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOIP)
{
//Fax Process....begin
switch (pIOData->m_u16IoType)
{
case XMS_IO_TYPE_VOIP_H245UII:
if (pIOData->m_u16IoDataLen == sizeof(Acs_VoIP_H245UII))
{
Acs_VoIP_H245UII *h245Uii = (Acs_VoIP_H245UII *)FetchIOData(pAcsEvt);
dtmf = h245Uii->m_s8Signal;
}
sprintf ( TmpS, "(%s) (%s,%d) [%c]", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen, dtmf );
break;
case XMS_IO_TYPE_VOIP_SIPINFO:
if (pIOData->m_u16IoDataLen == sizeof(Acs_VoIP_SIPINFO))
{
Acs_VoIP_SIPINFO *sipInfo = (Acs_VoIP_SIPINFO *)FetchIOData(pAcsEvt);
if (strcmp(sipInfo->m_s8ContentType, "application/dtmf") == 0)
sscanf(sipInfo->m_s8Body, "dtmf=%c", &dtmf);
}
sprintf ( TmpS, "(%s) (%s,%d) [%c]", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen, dtmf );
break;
case XMS_IO_TYPE_VOIP_RTPDTMF:
if (pIOData->m_u16IoDataLen == sizeof(Acs_VoIP_RTPDTMF))
{
Acs_VoIP_RTPDTMF *rtpDtmf = (Acs_VoIP_RTPDTMF *)FetchIOData(pAcsEvt);
dtmf = rtpDtmf->m_s8EventChar;
}
sprintf ( TmpS, "(%s) (%s,%d) [%c]", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen, dtmf );
break;
case XMS_IO_TYPE_VOIP_T38START:
if (pIOData->m_u16IoDataLen == sizeof(DJ_S32))
{
DJ_S32 *ret = (DJ_S32 *)FetchIOData(pAcsEvt);
if (*ret == 0)
{
pdlg->UpdateData();
if (g_iSendRecv == 0)//SendFax
{
//pdlg->m_lstIP.SetItemText(iDevice, 3, _T("Send Fax"));
XMS_ctsSendFax(g_acsHandle,
&DevOpened[iOpenedIndex1].DevID,
&DevOpened[iOpenedIndex2].DevID,
//&g_deviceVoIP[iDevice].device,
(DJ_S8 *)(LPCTSTR)SendTiffFileName, "1234", NULL);
sprintf ( TmpS, "(%s) (%s,%d) T38START SENDFAX", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen );
}
else
{
//pdlg->m_lstIP.SetItemText(iDevice, 3, _T("Recv Fax"));
XMS_ctsReceiveFax(g_acsHandle,
&DevOpened[iOpenedIndex1].DevID,
&DevOpened[iOpenedIndex2].DevID,
//&g_deviceVoIP[iDevice].device,
(DJ_S8 *)(LPCTSTR)RecvTiffFileName, "1234", NULL);
sprintf ( TmpS, "(%s) (%s,%d) T38START RECVFAX", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen );
}
}
}
break;
//default:
// sprintf ( TmpS, "(%s) (%s,%d) INVALID IOTYPE FOR VOIP", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
// GetString_IOType(pIOData->m_u16IoType), pIOData->m_u16IoDataLen );
// break;
}
//Fax Process....end
}
else //NO IP Device
{
char *p;
p = (char *)(pIOData) + sizeof(Acs_IO_Data);
switch( pIOData->m_u16IoType)
{
case XMS_IO_TYPE_DTMF:
sprintf ( TmpS, "(%s) (%s,%d) [%s]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
p );
break;
case XMS_IO_TYPE_GTG:
sprintf ( TmpS, "(%s) (%s,%d) [%c]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
*p );
break;
case XMS_IO_TYPE_FSK:
sprintf ( TmpS, "(%s) (%s,Len:%d) [%d][%d][%d][%s]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
p[0],p[1],p[2],p );
break;
case XMS_IO_TYPE_PVD:
sprintf ( TmpS, "(%s) (%s,%d) [%c]",
GetString_DeviceAll(&pAcsEvt->m_DeviceID),
GetString_IOType(pIOData->m_u16IoType),
pIOData->m_u16IoDataLen,
*p );
break;
default:
break;
}
}
}
strcat ( TmpStr, TmpS );
//AddMsg ( MSG_TYPE_EVENT, TmpStr );
break;
case XMS_EVT_CAS_MFC_START:
case XMS_EVT_CAS_MFC_END:
pCAS_ExtraInfo = (Acs_CAS_ExtraInfo_t *)FetchEventData(pAcsEvt);
sprintf ( TmpS, "(%s) KA=%d, KD=%d)", GetString_DeviceAll(&pAcsEvt->m_DeviceID),
pCAS_ExtraInfo->m_u8KA, pCAS_ExtraInfo->m_u8KD );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_UNIFAILURE:
pAcsUniFailure = (Acs_UniFailure_Data *)FetchEventData(pAcsEvt);
sprintf ( TmpS, ": %s(0x%X)", GetString_ErrorCode(pAcsUniFailure->m_s32AcsEvtErrCode), pAcsUniFailure->m_s32AcsEvtErrCode );
strcat ( TmpStr, TmpS );
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain != 0 )
{
//Unifailure event that some device link each other
sprintf ( TmpS, " (%s)", GetString_DeviceAll(&pAcsEvt->m_DeviceID) );
strcat ( TmpStr, TmpS );
}
break;
default:
break;
}
AddMsg ( MSG_TYPE_EVENT, TmpStr );
}
DJ_Void EvtHandler(DJ_U32 esrParam)
{
Acs_Evt_t * pAcsEvt = NULL;
Acs_Dev_List_Head_t * pAcsDevList = NULL;
pAcsEvt = (Acs_Evt_t *) esrParam;
DispEventInfo ( pAcsEvt );
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_QUERY_DEVICE:
if ( IsSysMod(pAcsEvt->m_DeviceID.m_s8ModuleID) )
{
pAcsDevList = ( Acs_Dev_List_Head_t *) FetchEventData(pAcsEvt);
//收到设备变化的事件，增加/调整 该设备资源
AddDeviceRes ( pAcsDevList );
}
break;
case XMS_EVT_QUERY_ONE_DSP_END:
if ( IsSysMod(pAcsEvt->m_DeviceID.m_s8ModuleID) )
{
AllDeviceRes[pAcsEvt->m_DeviceID.m_s8ModuleID].lFlag = 1; // 该DSP可以用了
OpenAllDevice_Dsp ( pAcsEvt->m_DeviceID.m_s8ModuleID );
RefreshMapTable ( );
ReDrawAll ();
}
break;
case XMS_EVT_QUERY_DEVICE_END: // 获取设备列表结束
break;
case XMS_EVT_OPEN_DEVICE:
OpenDeviceOK ( &pAcsEvt->m_DeviceID );
break;
case XMS_EVT_DEVICESTATE:
HandleDevState ( pAcsEvt );
break;
case XMS_EVT_UNIFAILURE:
// must handle this event in your real System
break;
default:
if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH )
{
TrunkWork ( &M_OneTrunk(pAcsEvt->m_DeviceID), pAcsEvt );
}
else if ( pAcsEvt->m_DeviceID.m_s16DeviceMain == XMS_DEVMAIN_VOICE )
{
DeviceID_t *pDevID;
pDevID = &M_OneVoice(pAcsEvt->m_DeviceID).UsedDevID;
if ( pDevID->m_s16DeviceMain == XMS_DEVMAIN_INTERFACE_CH )
{
TrunkWork ( &M_OneTrunk(*pDevID), pAcsEvt );
}
}
break;
}
}
void VOIPWork ( VOIP_STRUCT *pOneVOIP, Acs_Evt_t *pAcsEvt )
{
Acs_CallControl_Data *pCallControl = NULL;
VoIPCallPrivate_t *voipCallPrivate = NULL;
DeviceID_t FreeVocDeviceID;
char FileName[256];
char chTmpFilePath[256] = "";
if (pOneVOIP == NULL || pAcsEvt == NULL)
return;
if ( pAcsEvt->m_s32EventType == XMS_EVT_CLEARCALL ) /*拆线事件*/
{
if (cfg_iVoiceCheck == 1)
{
StopPlayFile(&pOneVOIP->VocDevID);
//删除录音文件
GetFilePathName(pOneVOIP, chTmpFilePath);
sprintf(FileName, "%s\\DemoRec.%0003d", chTmpFilePath, pOneVOIP->iSeqID);
DeleteFile(FileName);
}
ResetVOIP ( pOneVOIP, pAcsEvt );
Change_State(pOneVOIP, VOIP_FREE);
return ;
}
switch(pOneVOIP->State)
{
case VOIP_FREE:
if ( pAcsEvt->m_s32EventType == XMS_EVT_CALLIN ) /*呼入事件*/
{
pCallControl = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
ASSERT(pCallControl->m_PrivData.m_u32DataSize == sizeof(VoIPCallPrivate_t));
voipCallPrivate = (VoIPCallPrivate_t *)&(pCallControl->m_PrivData);
XMS_ctsAlertCall ( g_acsHandle, &pOneVOIP->deviceID, NULL );
XMS_ctsAnswerCallIn ( g_acsHandle, &pOneVOIP->deviceID, NULL );
pOneVOIP->iProtocol = voipCallPrivate->m_s32Protocol;
//Caller Info
strncpy(pOneVOIP->CallerAddr, voipCallPrivate->m_s8CallerAddress, sizeof(pOneVOIP->CallerAddr));
strncpy(pOneVOIP->CallerUserID, voipCallPrivate->m_s8CallerUserID, sizeof(pOneVOIP->CallerUserID));
strncpy ( pOneVOIP->CallerNum, pCallControl->m_s8CallingNum, sizeof(pOneVOIP->CallerNum));
pOneVOIP->iCallerPort = (unsigned short)voipCallPrivate->m_s32CallerPort;
//
//Callee Info
strncpy(pOneVOIP->CalleeAddr, voipCallPrivate->m_s8CalleeAddress, sizeof(pOneVOIP->CalleeAddr));
strncpy(pOneVOIP->CalleeUserID, voipCallPrivate->m_s8CalleeUserID, sizeof(pOneVOIP->CalleeUserID));
strncpy ( pOneVOIP->CalleeNum, pCallControl->m_s8CalledNum, sizeof(pOneVOIP->CalleeNum));
pOneVOIP->iCalleePort = (unsigned short)voipCallPrivate->m_s32CalleePort;
//
DrawMain_CallInfo( pOneVOIP );
Change_State ( pOneVOIP, VOIP_WAIT_ANSWERCALL );
}
break;
case VOIP_WAIT_ANSWERCALL:
if ( pAcsEvt->m_s32EventType == XMS_EVT_ANSWERCALL ) /*应答呼入完成事件*/
{
pCallControl = (Acs_CallControl_Data *)FetchEventData(pAcsEvt);
if (cfg_iVoiceCheck == 1)
{
if ( SearchOneFreeVoice ( pOneVOIP, &FreeVocDeviceID ) >= 0 )
{
pOneVOIP->u8PlayTag = 16;
pOneVOIP->VocDevID = FreeVocDeviceID;
M_OneVoice(FreeVocDeviceID).UsedDevID = pOneVOIP->deviceID;
DrawMain_VocInfo ( pOneVOIP );
GetFilePathName(pOneVOIP, chTmpFilePath);
sprintf(FileName, "%s\\DemoRec.%0003d", chTmpFilePath, pOneVOIP->iSeqID);
RecordFile ( pOneVOIP, FileName, 8000L*10, false);
Change_State ( pOneVOIP, VOIP_RECORDFILE );
}
}
else
{
Change_State ( pOneVOIP, VOIP_WAITHANGUP );
}
}
break;
case VOIP_RECORDFILE:
if ( CheckRecordEnd ( pOneVOIP, pAcsEvt) ) /*record完成事件*/
{
BindOneFreeVoice(pOneVOIP, pOneVOIP->VocDevID);
Change_State ( pOneVOIP, VOIP_WAITBINDOK);
}
break;
case VOIP_WAITBINDOK:
if (pAcsEvt->m_s32EventType == XMS_EVT_SETPARAM)
{
GetFilePathName(pOneVOIP, chTmpFilePath);
sprintf(FileName, "%s\\DemoRec.%0003d", chTmpFilePath, pOneVOIP->iSeqID);
pOneVOIP->u8PlayTag ++;
PlayFile ( &pOneVOIP->VocDevID, FileName, pOneVOIP->u8PlayTag, true );
Change_State (pOneVOIP, VOIP_PLAYRECORD);
}
break;
case VOIP_PLAYRECORD:
if ( CheckPlayEnd ( pOneVOIP, pAcsEvt) ) /*play完成事件*/
{
// 主动挂机
UnBindOneVoice(pOneVOIP);
XMS_ctsClearCall ( g_acsHandle, &pOneVOIP->deviceID, 0, NULL );
Change_State ( pOneVOIP, VOIP_WAITHANGUP );
}
break;
}
}
//////////////////////////////////////////////////////////////////////////
// XMS_EVT_RECVIODATA event handler (H.245 UserInputIndication/SIP INFO/RFC 2833 DTMF)
void OnRecvIOData(Acs_Evt_t *pAcsEvt)
{
Acs_IO_Data *pIOEvt = (Acs_IO_Data *)FetchEventData(pAcsEvt);
TRACE(_T("Device[%02d][%02d][%02d] receive IO Data\n"),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16DeviceMain,
pAcsEvt->m_DeviceID.m_s16ChannelID);
int iDevice = pAcsEvt->m_DeviceID.m_s16ChannelID;
int iDtmfLen = strlen(g_deviceVoIP[iDevice].szDtmf);
if (iDtmfLen >= sizeof(g_deviceVoIP[iDevice].szDtmf)-1)
{
memset(g_deviceVoIP[iDevice].szDtmf, 0, sizeof(g_deviceVoIP[iDevice].szDtmf));
iDtmfLen = 0;
}
char dtmf = '?';
switch (pIOEvt->m_u16IoType)
{
case XMS_IO_TYPE_VOIP_REGREQUEST:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_REGSTATE))
{
// check client's info
Acs_VoIP_REGSTATE *pRegRequest = (Acs_VoIP_REGSTATE *)FetchIOData(pAcsEvt);
TRACE(_T("Client registrates from: \"%s\" %s@%s:%d\n"),
pRegRequest->m_s8UserID, pRegRequest->m_s8TelNo, pRegRequest->m_s8Address, pRegRequest->m_u16Port);
// response to registration
// if authentication is disabled,
// set Acs_VoIP_REGRESP::m_u8Granted to 0/1 to grant/disgrant registration
// if authentication is enabled,
// set Acs_VoIP_REGRESP::m_u8Granted to 0, and fill Acs_VoIP_REGRESP::m_s8Password to authenticate,
// or
// set Acs_VoIP_REGRESP::m_u8Granted to 0, and leave Acs_VoIP_REGRESP::m_s8Password empty to disgrant registration,
// or
// set Acs_VoIP_REGRESP::m_u8Granted to 1 to grant registration without authenticating.
Acs_VoIP_REGRESP regResponse = {0};
regResponse.m_u16SlotID = pRegRequest->m_u16SlotID;
regResponse.m_u8Granted = 1;
// strcpy(regResponse.m_s8Password, "passwd");
XMS_ctsSendIOData(g_acsHandle, &g_deviceVoIP[iDevice].device, XMS_IO_TYPE_VOIP_REGRESPONSE,
sizeof(regResponse), ®Response);
}
break;
case XMS_IO_TYPE_VOIP_REGSTATE:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_REGSTATE))
{
Acs_VoIP_REGSTATE *pRegState = (Acs_VoIP_REGSTATE *)FetchIOData(pAcsEvt);
TRACE(_T("Client %s on slot(%d): %s@%s:%d\n"),
pRegState->m_u8State?_T("registered"):_T("unregistered"),
pRegState->m_u16SlotID,
pRegState->m_s8TelNo, pRegState->m_s8Address, pRegState->m_u16Port);
}
break;
case XMS_IO_TYPE_VOIP_H245UII:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_H245UII))
{
Acs_VoIP_H245UII *h245Uii = (Acs_VoIP_H245UII *)FetchIOData(pAcsEvt);
dtmf = h245Uii->m_s8Signal;
g_deviceVoIP[iDevice].szDtmf[iDtmfLen] = dtmf;
}
break;
case XMS_IO_TYPE_VOIP_SIPINFO:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_SIPINFO))
{
Acs_VoIP_SIPINFO *sipInfo = (Acs_VoIP_SIPINFO *)FetchIOData(pAcsEvt);
if (strcmp(sipInfo->m_s8ContentType, "application/dtmf") == 0)
sscanf(sipInfo->m_s8Body, "dtmf=%c", &dtmf);
g_deviceVoIP[iDevice].szDtmf[iDtmfLen] = dtmf;
}
break;
case XMS_IO_TYPE_VOIP_RTPDTMF:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_RTPDTMF))
{
Acs_VoIP_RTPDTMF *rtpDtmf = (Acs_VoIP_RTPDTMF *)FetchIOData(pAcsEvt);
dtmf = rtpDtmf->m_s8EventChar;
g_deviceVoIP[iDevice].szDtmf[iDtmfLen] = dtmf;
}
break;
case XMS_IO_TYPE_VOIP_RTPTONE:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_RTPTONE))
{
Acs_VoIP_RTPTONE *rtpTone = (Acs_VoIP_RTPTONE *)FetchIOData(pAcsEvt);
}
break;
case XMS_IO_TYPE_VOIP_REFER_NOTIFY:
if (pIOEvt->m_u16IoDataLen == sizeof(Acs_VoIP_ReferResult))
{
Acs_VoIP_ReferResult *pTransferResult = (Acs_VoIP_ReferResult *)FetchIOData(pAcsEvt);
TRACE("XMS_IO_TYPE_VOIP_REFER_NOTIFY state:%d reason:%d\n", pTransferResult->m_u8State, pTransferResult->m_u8Reason);
if(pTransferResult->m_u8State==17)
{
if(pTransferResult->m_u8Reason==23 || pTransferResult->m_u8Reason==24)
{
RetCode_t ret = XMS_ctsClearCall(g_acsHandle, &g_deviceVoIP[iDevice].device, 0, NULL);
}
else
{
VoIPCallModifyPrivate_t callModify = {0};
callModify.m_PrivateData.m_u32DataSize = sizeof(VoIPCallModifyPrivate_t);
callModify.m_u8MediaCapNum = 0;
// set media mode to send/recv
callModify.u8MediaMode = 0;
RetCode_t ret = XMS_ctsSendIOData(g_acsHandle, &g_deviceVoIP[iDevice].device, XMS_IO_TYPE_VOIP_CALLMODIFY, sizeof(VoIPCallModifyPrivate_t), (void*)&callModify);
}
}
}
break;
}
if (pIOEvt->m_u16IoType != XMS_IO_TYPE_VOIP_REGREQUEST &&
pIOEvt->m_u16IoType != XMS_IO_TYPE_VOIP_REGSTATE)
g_pDlg->refreshListIP(iDevice);
}
void DispEventInfo ( Acs_Evt_t *pAcsEvt )
{
char TmpStr[256]={0};
char TmpS[256]={0};
DeviceID_t *pLinkTrkDevID;
Acs_Dev_List_Head_t * pAcsDevList = NULL;
Acs_UniFailure_Data * pAcsUniFailure = NULL;
Acs_GeneralProc_Data * pAcsProcData=NULL;
sprintf ( TmpStr, "EVT(%4d) : ", pAcsEvt->m_s32EvtSize );
strcat ( TmpStr, GetString_EventType ( pAcsEvt->m_s32EventType ) );
switch ( pAcsEvt->m_s32EventType )
{
case XMS_EVT_OPEN_STREAM:
break;
case XMS_EVT_CALLOUT:
case XMS_EVT_CALLIN:
case XMS_EVT_ANALOG_INTERFACE:
case XMS_EVT_LINKDEVICE:
case XMS_EVT_UNLINKDEVICE:
case XMS_EVT_SETPARAM:
case XMS_EVT_PLAY:
case XMS_EVT_RECORD:
case XMS_EVT_OPEN_DEVICE:
case XMS_EVT_CONTROLPLAY:
case XMS_EVT_CONTROLRECORD:
case XMS_EVT_CLEARCALL:
case XMS_EVT_ANSWERCALL:
case XMS_EVT_CAS_MFC_START:
case XMS_EVT_CAS_MFC_END:
case XMS_EVT_SENDIODATA:
case XMS_EVT_DEV_TIMER:
sprintf ( TmpS, "(%s, %s, %d, %d)",
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID);
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_DEVICESTATE:
{
char StateStr[100]={0};
pAcsProcData = (Acs_GeneralProc_Data *)FetchEventData(pAcsEvt);
GetString_LineState ( StateStr, pAcsProcData->m_s32DeviceState );
sprintf ( TmpS, "(%s, %s, %d, %d), %s",
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID,
StateStr);
strcat ( TmpStr, TmpS );
}
break;
case XMS_EVT_RECVIODATA:
{
char *p;
Acs_IO_Data *pIOData = NULL;
pIOData = (Acs_IO_Data *)FetchEventData(pAcsEvt);
pLinkTrkDevID = &M_OneVoice(pAcsEvt->m_DeviceID).UsedDevID;
if ( ( pIOData->m_u16IoType == XMS_IO_TYPE_DTMF ) && ( pIOData->m_u16IoDataLen > 0 ) )
{
p = (char *)FetchIOData(pAcsEvt);
sprintf(TmpS,"[%c], (%s, %s, %d, %d), LinkTrk(%s, %s, %d, %d)",*p,
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID,
GetString_DeviceMain(pLinkTrkDevID->m_s16DeviceMain),
GetString_DeviceSub(pLinkTrkDevID->m_s16DeviceSub),
pLinkTrkDevID->m_s8ModuleID,
pLinkTrkDevID->m_s16ChannelID);
strcat ( TmpStr, TmpS );
}else if ( (pIOData->m_u16IoType == XMS_IO_TYPE_FSK) && (pIOData->m_u16IoDataLen > 0 ))
{
p = (char *)FetchIOData(pAcsEvt);
sprintf(TmpS,"[%s], (%s, %s, %d, %d), LinkTrk(%s, %s, %d, %d)",p,
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID,
GetString_DeviceMain(pLinkTrkDevID->m_s16DeviceMain),
GetString_DeviceSub(pLinkTrkDevID->m_s16DeviceSub),
pLinkTrkDevID->m_s8ModuleID,
pLinkTrkDevID->m_s16ChannelID);
strcat ( TmpStr, TmpS );
}else
{
sprintf(TmpS,", m_u16IoType:%d, (%s, %s, %d, %d)",
pIOData->m_u16IoType,
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain),
GetString_DeviceSub(pAcsEvt->m_DeviceID.m_s16DeviceSub),
pAcsEvt->m_DeviceID.m_s8ModuleID,
pAcsEvt->m_DeviceID.m_s16ChannelID);
strcat ( TmpStr, TmpS );
}
}
break;
case XMS_EVT_QUERY_DEVICE:
pAcsDevList = (Acs_Dev_List_Head_t *) FetchEventData(pAcsEvt);
sprintf ( TmpS, " (%s,%2d,%3d)", GetString_DeviceMain(pAcsDevList->m_s32DeviceMain),
pAcsDevList->m_s32ModuleID, pAcsDevList->m_s32DeviceNum );
strcat ( TmpStr, TmpS );
break;
case XMS_EVT_UNIFAILURE:
pAcsUniFailure = (Acs_UniFailure_Data *) FetchEventData(pAcsEvt);
sprintf ( TmpS, ": %s(0x%X) dev=(%s, %d, %d), %d ?=? %d+%d",
GetString_ErrorCode(pAcsUniFailure->m_s32AcsEvtErrCode), pAcsUniFailure->m_s32AcsEvtErrCode,
GetString_DeviceMain(pAcsEvt->m_DeviceID.m_s16DeviceMain), pAcsEvt->m_DeviceID.m_s8ModuleID, pAcsEvt->m_DeviceID.m_s16ChannelID,
pAcsEvt->m_s32EvtSize, sizeof(Acs_Evt_t), sizeof(Acs_UniFailure_Data) );
strcat ( TmpStr, TmpS );
break;
default:
break;
}
WriteLog(LEVEL_DEBUG, TmpStr);
}
