cstatst32.cpp

csta协议的开发

        case CSTA_QUERY_CALL_MONITOR_CONF :
          CstaQueryCallMonitorConfEvent ();
          return (0);
        default :
          sprintf (str1, "unknowType : %d",
               m_cstaEvent.eventHeader.eventType);
          eventString += str1;
          break;
      }
      break;
    case CSTAEVENTREPORT :
      eventString = "CSTA REPORT ";
      switch (m_cstaEvent.eventHeader.eventType) {
        case CSTA_SYS_STAT :
          CstaSysStatEvent ();
          return (0);
        case CSTA_SYS_STAT_ENDED :
          CstaSysStatEndedEvent ();
          return (0);
        case CSTA_ROUTE_REGISTER_ABORT :
          CstaRouteRegisterAbortEvent();
          return (0);
        case CSTA_ROUTE_USED :
          CstaRouteUsedEvent();
          return (0);
        case CSTA_ROUTE_END :
          CstaRouteEndEvent();
          return (0);
		case CSTA_PRIVATE :
          CstaPrivateEvent ();
          return (0);
        default :
          sprintf (str1, "unknowType : %d",
               m_cstaEvent.eventHeader.eventType);
          eventString += str1;
          break;
      }
      break;
    default :
      sprintf (str1, "unknowClass : %d, unknowType : %d",
           m_cstaEvent.eventHeader.eventClass, m_cstaEvent.eventHeader.eventType);
      eventString = str1;
      break;
  }
  DisplayTheEvent (eventString);
  return (0);
}

/*
 *
 * AcsEnumServerNames : this function list all the server name of CSTA type
 * and create a list of CServer objects. If no server is found the function
 * return FALSE;
 *
 */
 
class CServName : public CObject {
public:
  char m_sName[50];
};

CObList *pServList;

/*BOOL FAR PASCAL  EnumServerCallback (char *serverName,
									 unsigned long LParam)
{ 
	CServName* pServ = new CServName; 
	strcpy (pServ->m_sName, serverName);
	pServList->AddTail((CObject*)pServ);
	return (1);
};*/

Boolean EnumServerCallback (	char  *serverName, unsigned long lParam)
{ 
	if ( (serverName != NULL) && (serverName[0] != '\0') )
	{
		CServName* pServ = NULL;
		pServ = new CServName;
	
		strcpy (pServ->m_sName, serverName);
		pServList->AddTail((CObject*)pServ);
//		MessageBox(  NULL, serverName, "Callback", MB_ICONSTOP);
		return TRUE;
	}
	return FALSE;
};

BOOL CMainWind::AcsEnumServerNames ()
{         
	CObList servList;
	pServList = &servList;
	int rc;     
	unsigned long lParam = 0;
    CServer *pServer = NULL;       
    CServName* pServName = NULL;
	
	m_nbServer = 0;
	while (!servList.IsEmpty())
		delete (CServName*)servList.RemoveHead();
	//CWinApp *pApp = AfxGetApp ();
	// MakeProcInstance is obsolete in win32
    //FARPROC proc = NULL;
	//proc =	MakeProcInstance ((FARPROC)EnumServerCallback,(HINSTANCE)pApp->m_hInstance);  
	lParam = 1;

	//::MessageBox(  NULL, "Pt1", "toto", MB_ICONSTOP);

	rc = acsEnumServerNames ( ST_CSTA, (EnumServerNamesCB)EnumServerCallback, lParam);
	//rc = acsEnumServerNames ( ST_CSTA, (EnumServerNamesCB)proc, lParam);


	if (rc != 0)
	{
		MessageBoxError ("acsEnumServerNames", rc);
	}	
	//FreeProcInstance (proc);
	while (!m_lServer.IsEmpty ())
		delete (CServer *)m_lServer.RemoveHead (); 
	m_nbServer = servList.GetCount();
	if (servList.IsEmpty())
	{
		CErrorDlg errorDlg;
		errorDlg.m_sErrorTitle = "acsEnumServerNames"; 
		errorDlg.m_sError = "No server found";
		errorDlg.DoModal ();
		return (FALSE);
	}
	while (!servList.IsEmpty())
	{
		pServer = new CServer;
		m_lServer.AddTail (pServer);  
		pServName = (CServName*)servList.RemoveHead();
		pServer->m_sServerName = pServName->m_sName;
		delete pServName;
		pServer->m_sStreamType = ST_CSTA;
	}
	return (TRUE);
}

/*
BOOL CMainWind::AcsEnumServerNames () {         
  CObList servList;
  pServList = &servList;
  int rc;     
  unsigned long lParam;
    CServer *pServer;       
    CServName* pServName;
                 
  m_nbServer = 0;
  while (!servList.IsEmpty())
    delete (CServName*)servList.RemoveHead();
  CWinApp *pApp = AfxGetApp ();
   FARPROC proc = MakeProcInstance ((FARPROC)EnumServerCallback,
                   (HINSTANCE)pApp->m_hInstance); 
  MessageBoxError ("before acsEnumServerNames", NULL);
  lParam = 1;
  rc = acsEnumServerNames ( ST_CSTA, (EnumServerNamesCB)proc, lParam);
  if (rc != 0) {
    MessageBoxError ("acsEnumServerNames", rc);
  }

  FreeProcInstance (proc);
  while (!m_lServer.IsEmpty ())
    delete (CServer *)m_lServer.RemoveHead (); 
  m_nbServer = servList.GetCount();
  if (servList.IsEmpty()) {
    CErrorDlg errorDlg;
    
    errorDlg.m_sErrorTitle = "acsEnumServerNames"; 
    errorDlg.m_sError = "No server found";
    errorDlg.DoModal ();
    return (FALSE);
  }
  while (!servList.IsEmpty()) {
    pServer = new CServer;
    
    m_lServer.AddTail (pServer);  
    pServName = (CServName*)servList.RemoveHead();
    pServer->m_sServerName = pServName->m_sName;
    delete pServName;
    pServer->m_sStreamType = ST_CSTA;
  }
  return (TRUE);
}*/



void CMainWind::CstaGetApiCaps () {
  m_nRetCode = cstaGetAPICaps (m_acsHandle,
                (InvokeID_t)0);
  if (m_nRetCode < 0) {
    MessageBoxError ("cstaGetAPICaps", m_nRetCode);
    return;
  }
  DisplayEventTitle ("CSTA REQUEST Get API Caps");
  return;
}

char *ApiCapsTable [] = {"alternateCall ",
             "answerCall ",
             "callCompletion",
             "clearCall",
             "clearConnection",
             "conferenceCall",
             "consultationCall",
             "deflectCall",
             "parkCall",
             "pickupCall",
             "groupPickupCall",
             "holdCall",
             "makeCall",
             "makePredictiveCall",
             "queryMwi",
             "queryDnd",
             "queryFwd",
             "queryAgentState",
             "queryLastNumber",
             "queryDeviceInfo",
             "reconnectCall",
             "retrieveCall",
             "setMwi",
             "setDnd",
             "setFwd",
             "setAgentState",
             "transferCall",
             "eventReport",
             "callClearedEvent",
             "conferencedEvent",
             "connectionClearedEvent",
             "deliveredEvent",
             "divertedEvent",
             "establishedEvent",
             "failedEvent",
             "heldEvent",
             "networkReachedEvent",
             "originatedEvent",
             "queuedEvent",
             "retrievedEvent",
             "serviceInitiatedEvent",
             "transferredEvent",
             "callInformationEvent",
             "doNotDisturbEvent",
             "forwardingEvent",
             "messageWaitingEvent",
             "loggedOnEvent",
             "loggedOffEvent",
             "notReadyEvent",
             "readyEvent",
             "workNotReadyEvent",
             "workReadyEvent",
             "backInServiceEvent",
             "outOfServiceEvent",
             "privateEvent",
             "routeRequestEvent",
             "reRoute",
             "routeSelect",
             "routeUsedEvent",
             "routeEndEvent",
             "monitorDevice",
             "monitorCall",
             "monitorCallsViaDevice",
             "changeMonitorFilter",
             "monitorStop",
             "monitorEnded",
             "snapshotDeviceReq",
             "snapshotCallReq",
             "escapeService",
             "privateStatusEvent",
             "escapeServiceEvent",
             "escapeServiceConf",
             "sendPrivateEvent",
             "sysStatReq",
             "sysStatStart",
             "sysStatStop",
             "changeSysStatFilter",
             "sysStatReqEvent",
             "sysStatReqConf",
             "sysStatEvent"
};

void CMainWind::CstaGetApiCapsConfEvent () {
  CString eventString;
  short *pApiCaps;
    
  DisplayTheEvent ("CSTA CONFIRM Get API Caps :");
  pApiCaps = (short *)&m_cstaEvent.event.cstaConfirmation.u.getAPICaps;
  for (int i = 0; i < 79; i++) {
    if (pApiCaps [i]) {
      eventString = "                         ";
      eventString += ApiCapsTable [i];
      DisplayString (eventString);
    }
  }
}

void CMainWind::CstaGetDeviceList () {
  if (m_bFirstPass) {
    CGetDeviceListDlg dlg;
    
    dlg.m_nLevel = (int)CSTA_HOME_WORK_TOP - 1;
    if (dlg.DoModal () != IDOK)
      return;
    m_nLevel = (CSTALevel_t)(dlg.m_nLevel + 1);
    m_nIndex = -1;
    m_nCount = 1;
    m_bFirstPass = FALSE;
  }
  m_nRetCode = cstaGetDeviceList (m_acsHandle,
                  0,
                  m_nIndex,
                  m_nLevel);
  if (m_nRetCode < 0) {
    MessageBoxError ("cstaGetDeviceList", m_nRetCode);
    return;
  }
  CString eventString;
  
  eventString = "CSTA REQUEST Get Device List: Level = ";
  switch (m_nLevel) {
    case CSTA_HOME_WORK_TOP :
      eventString += "Home Work Top";
      break;
    case CSTA_AWAY_WORK_TOP :
      eventString += "Away Work Top";
      break;
    case CSTA_DEVICE_DEVICE_MONITOR :
      eventString += "Device Device Monitor";
      break;
    case CSTA_CALL_DEVICE_MONITOR :
      eventString += "Call Device Monitor";
      break;
    case CSTA_CALL_CONTROL :
      eventString += "Call Control";
      break;
    case CSTA_ROUTING :
      eventString += "Routing";
      break;
    case CSTA_CALL_CALL_MONITOR :
      eventString += "Call Call Monitor";
      break;
  }
  DisplayTheEvent (eventString);
  return;
}

void CMainWind::CstaGetDeviceListConfEvent () {
  CString eventString;
  char str [20];
  
  eventString = "CSTA CONFIRM Get Device List : SDB Level = ";
  switch (m_cstaEvent.event.cstaConfirmation.u.getDeviceList.driverSdbLevel) {
    case NO_SDB_CHECKING :
      eventString += "No SDB Checking";
      break;
    case ACS_ONLY :
      eventString += "ACS Only";
      break;
    case ACS_AND_CSTA_CHECKING :
      eventString += "ACS And CSTA Checking";
      break;
    default :
      eventString += "Unknown Type ";
      sprintf (str, "%d", m_cstaEvent.event.cstaConfirmation.u.getDeviceList.driverSdbLevel);
      eventString += str;
      break;
  }
  eventString += "    Level: ";
  switch (m_cstaEvent.event.cstaConfirmation.u.getDeviceList.level) {
    case CSTA_HOME_WORK_TOP :
      eventString += "Home Work Top";
      break;
    case CSTA_AWAY_WORK_TOP :
      eventString += "Away Work Top";
      break;
    case CSTA_DEVICE_DEVICE_MONITOR :
      eventString += "Device Device Monitor";
      break;
    case CSTA_CALL_DEVICE_MONITOR :
      eventString += "Call Device Monitor";
      break;
    case CSTA_CALL_CONTROL :
      eventString += "Call Control";
      break;
    case CSTA_ROUTING :
      eventString += "Routing";
      break;
    case CSTA_CALL_CALL_MONITOR :
      eventString += "Call Call Monitor";
      break;
    default :
      eventString += "  Unknown Type ";
      sprintf (str, "%d", m_cstaEvent.event.cstaConfirmation.u.getDeviceList.level);
      eventString += str;
      break;
  }
  DisplayTheEvent (eventString);
  DeviceList_t *deviceList;
  
  deviceList = &m_cstaEvent.event.cstaConfirmation.u.getDeviceList.devList;
  for (short i = 0; i < deviceList->count; i++) {
    eventString = "           Device Index: ";
    sprintf (str, "%ld ", m_nCount);
    eventString += str;
    eventString += "   Device: ";
    eventString += deviceList->device [i];
    DisplayString (eventString);
    m_nCount++;
  }                            
  m_nIndex = m_cstaEvent.event.cstaConfirmation.u.getDeviceList.index;
  if (m_nIndex != -1)
    CstaGetDeviceList ();
  return;
}

void CMainWind::CstaQueryCallMonitor () {
  m_nRetCode = cstaQueryCallMonitor (m_acsHandle,
                     (InvokeID_t)0);
  if (m_nRetCode < 0) {
    MessageBoxError ("cstaGetAPICaps", m_nRetCode);
    return;
  }
  DisplayEventTitle ("CSTA REQUEST Query Call Monitor");
  return;
}

void CMainWind::CstaQueryCallMonitorConfEvent () {
  CString eventString;
    
  eventString = "CSTA CONFIRM Query Call Monitor: ";
  if (m_cstaEvent.event.cstaConfirmation.u.queryCallMonitor.callMonitor)
    eventString += "ON";
  else
    eventString += "OFF";
  DisplayTheEvent (eventString);
}

//===========================================================================
//===========================================================================
//  
//      Switching function services
//

////////  Basic call control services    ////////