cstatst32.cpp

csta协议的开发

CString CMainWind::AddConnectionID (ConnectionID_t connectionID) {
  CString eventString;  
  char callID [15];

  eventString = "Call ID: ";
  sprintf (callID, "%ld", connectionID.callID);
  eventString += callID;
  eventString += " Device ID: ";
  eventString += connectionID.deviceID;
  // JYL
  SetMyDeviceID(connectionID.deviceID);
  

  switch (connectionID.devIDType) {
    case STATIC_ID :
      eventString += "  Static ID";
      break;
    case DYNAMIC_ID :
      eventString += "  Dynamic ID";
      break;
    default :
      eventString += "  Unknown Type";
      break;
  }
  return (eventString);
}

CString CMainWind::AddDeviceID (DeviceID_t deviceID) {
  CString eventString;  

  eventString = "Device ID: ";
  eventString += deviceID;
  return (eventString);
}

CString CMainWind::AddExtendedDeviceID (ExtendedDeviceID_t extendedDeviceID) {
  CString eventString;  

  eventString = "Device ID: ";
  eventString += extendedDeviceID.deviceID;
  eventString += "  Type: ";
  switch (extendedDeviceID.deviceIDType) {
    case DEVICE_IDENTIFIER :
      eventString += "DEVICE IDENTIFIER";
      break;
    case IMPLICIT_PUBLIC :
      eventString += "IMPLICIT PUBLIC";
      break;
    case EXPLICIT_PUBLIC_UNKNOWN :
      eventString += "EXPLICIT PUBLIC UNKNOWN";
      break;
    case EXPLICIT_PUBLIC_INTERNATIONAL :
      eventString += "EXPLICIT PUBLIC INTERNATIONAL";
      break;
    case EXPLICIT_PUBLIC_NATIONAL :
      eventString += "EXPLICIT PUBLIC NATIONAL";
      break;
    case EXPLICIT_PUBLIC_NETWORK_SPECIFIC :
      eventString += "EXPLICIT PUBLIC NETWORK SPECIFIC";
      break;
    case EXPLICIT_PUBLIC_SUBSCRIBER :
      eventString += "EXPLICIT PUBLIC SUBSCRIBER";
      break;
    case EXPLICIT_PUBLIC_ABBREVIATED :
      eventString += "EXPLICIT PUBLIC ABBREVIATED";
      break;
    case IMPLICIT_PRIVATE :
      eventString += "IMPLICIT PRIVATE";
      break;
    case EXPLICIT_PRIVATE_UNKNOWN :
      eventString += "EXPLICIT UNKNOWN";
      break;
    case EXPLICIT_PRIVATE_LEVEL3_REGIONAL_NUMBER :
      eventString += "EXPLICIT PRIVATE LEVEL 3 REGIONAL NUMBER";
      break;
    case EXPLICIT_PRIVATE_LEVEL2_REGIONAL_NUMBER :
      eventString += "EXPLICIT PRIVATE LEVEL 2 REGIONAL NUMBER";
      break;
    case EXPLICIT_PRIVATE_LEVEL1_REGIONAL_NUMBER :
      eventString += "EXPLICIT PRIVATE LEVEL 1 REGIONAL NUMBER";
      break;
    case EXPLICIT_PRIVATE_PTN_SPECIFIC_NUMBER :
      eventString += "EXPLICIT PRIVATE PTN SPECIFIC NUMBER";
      break;
    case EXPLICIT_PRIVATE_LOCAL_NUMBER :
      eventString += "EXPLICIT PRIVATE LOCAL NUMBER";
      break;
    case EXPLICIT_PRIVATE_ABBREVIATED :
      eventString += "EXPLICIT PRIVATE ABBREVIATED";
      break;
    case OTHER_PLAN :
      eventString += "OTHER PLAN";
      break;
    case TRUNK_IDENTIFIER :
      eventString += "TRUNK IDENTIFIER";
      break;
    case TRUNK_GROUP_IDENTIFIER :
      eventString += "TRUNK GROUP IDENTIFIER";
      break;
    default :
      eventString += "Unknown Type";
      break;
  }
  eventString += "  Status: ";
  switch (extendedDeviceID.deviceIDStatus) {
    case ID_PROVIDED :
      eventString += "ID PROVIDED";
      break;
    case ID_NOT_KNOWN :
      eventString += "ID NOT KNOWN";
      break;
    case ID_NOT_REQUIRED :
      eventString += "ID NOT REQUIRED";
      break;
    default :
      eventString += "Unknown status";
      break;
  }
  return (eventString);
}

/*
 *
 * CstaUniversalFailureConf : this function provides a generic negative
 * response from the server/switch for a previous requested service.
 *
 */
 
void CMainWind::CstaUniversalFailureConfEvent (CSTAUniversalFailure_t universalFailure) {
  CString eventString;
  char str1 [40];

  eventString = "CSTA CONFIRM Failure ";
  switch (universalFailure) {
    case GENERIC_UNSPECIFIED :
      eventString += "GENERIC_UNSPECIFIED";
      break;
    case GENERIC_OPERATION :
      eventString += "GENERIC_OPERATION";
      break;
    case REQUEST_INCOMPATIBLE_WITH_OBJECT :
      eventString += "REQUEST_INCOMPATIBLE_WITH_OBJECT";
      break;
    case VALUE_OUT_OF_RANGE :
      eventString += "VALUE_OUT_OF_RANGE";
      break;
    case OBJECT_NOT_KNOWN :
      eventString += "OBJECT_NOT_KNOWN";
      break;
    case INVALID_CALLING_DEVICE :
      eventString += "INVALID_CALLING_DEVICE";
      break;
    case INVALID_CALLED_DEVICE :
      eventString += "INVALID_CALLED_DEVICE";
      break;
    case INVALID_FORWARDING_DESTINATION :
      eventString += "INVALID_FORWARDING_DESTINATION";
      break;
    case PRIVILEGE_VIOLATION_ON_SPECIFIED_DEVICE :
      eventString += "PRIVILEGE_VIOLATION_ON_SPECIFIED_DEVICE";
      break;
    case PRIVILEGE_VIOLATION_ON_CALLED_DEVICE :
      eventString += "PRIVILEGE_VIOLATION_ON_CALLED_DEVICE";
      break;
    case PRIVILEGE_VIOLATION_ON_CALLING_DEVICE :
      eventString += "PRIVILEGE_VIOLATION_ON_CALLING_DEVICE";
      break;
    case INVALID_CSTA_CALL_IDENTIFIER :
      eventString += "INVALID_CSTA_CALL_IDENTIFIER";
      break;
    case INVALID_CSTA_DEVICE_IDENTIFIER :
      eventString += "INVALID_CSTA_DEVICE_IDENTIFIER";
      break;
    case INVALID_CSTA_CONNECTION_IDENTIFIER :
      eventString += "INVALID_CSTA_CONNECTION_IDENTIFIER";
      break;
    case INVALID_DESTINATION :
      eventString += "INVALID_DESTINATION";
      break;
    case INVALID_FEATURE :
      eventString += "INVALID_FEATURE";
      break;
    case INVALID_ALLOCATION_STATE :
      eventString += "INVALID_ALLOCATION_STATE";
      break;
    case INVALID_CROSS_REF_ID :
      eventString += "INVALID_CROSS_REF_ID";
      break;
    case INVALID_OBJECT_TYPE :
      eventString += "INVALID_OBJECT_TYPE";
      break;
    case SECURITY_VIOLATION :
      eventString += "SECURITY_VIOLATION";
      break;
    case GENERIC_STATE_INCOMPATIBILITY :
      eventString += "GENERIC_STATE_INCOMPATIBILITY";
      break;
    case INVALID_OBJECT_STATE :
      eventString += "INVALID_OBJECT_STATE";
      break;
    case INVALID_CONNECTION_ID_FOR_ACTIVE_CALL :
      eventString += "INVALID_CONNECTION_ID_FOR_ACTIVE_CALL";
      break;
    case NO_ACTIVE_CALL :
      eventString += "NO_ACTIVE_CALL";
      break;
    case NO_HELD_CALL :
      eventString += "NO_HELD_CALL";
      break;
    case NO_CALL_TO_CLEAR :
      eventString += "NO_CALL_TO_CLEAR";
      break;
    case NO_CONNECTION_TO_CLEAR :
      eventString += "NO_CONNECTION_TO_CLEAR";
      break;
    case NO_CALL_TO_ANSWER :
      eventString += "NO_CALL_TO_ANSWER";
      break;
    case NO_CALL_TO_COMPLETE :
      eventString += "NO_CALL_TO_COMPLETE";
      break;
    case GENERIC_SYSTEM_RESOURCE_AVAILABILITY :
      eventString += "GENERIC_SYSTEM_RESOURCE_AVAILABILITY";
      break;
    case SERVICE_BUSY :
      eventString += "SERVICE_BUSY";
      break;
    case RESOURCE_BUSY :
      eventString += "RESOURCE_BUSY";
      break;
    case RESOURCE_OUT_OF_SERVICE :
      eventString += "RESOURCE_OUT_OF_SERVICE";
      break;
    case NETWORK_BUSY :
      eventString += "NETWORK_BUSY";
      break;
    case NETWORK_OUT_OF_SERVICE :
      eventString += "NETWORK_OUT_OF_SERVICE";
      break;
    case OVERALL_MONITOR_LIMIT_EXCEEDED :
      eventString += "OVERALL_MONITOR_LIMIT_EXCEEDED";
      break;
    case CONFERENCE_MEMBER_LIMIT_EXCEEDED :
      eventString += "CONFERENCE_MEMBER_LIMIT_EXCEEDED";
      break;
    case GENERIC_SUBSCRIBED_RESOURCE_AVAILABILITY :
      eventString += "GENERIC_SUBSCRIBED_RESOURCE_AVAILABILITY";
      break;
    case OBJECT_MONITOR_LIMIT_EXCEEDED :
      eventString += "OBJECT_MONITOR_LIMIT_EXCEEDED";
      break;
    case EXTERNAL_TRUNK_LIMIT_EXCEEDED :
      eventString += "EXTERNAL_TRUNK_LIMIT_EXCEEDED";
      break;
    case OUTSTANDING_REQUEST_LIMIT_EXCEEDED :
      eventString += "OUTSTANDING_REQUEST_LIMIT_EXCEEDED";
      break;
    case GENERIC_PERFORMANCE_MANAGEMENT :
      eventString += "GENERIC_PERFORMANCE_MANAGEMENT";
      break;
    case PERFORMANCE_LIMIT_EXCEEDED :
      eventString += "PERFORMANCE_LIMIT_EXCEEDED";
      break;
    case SEQUENCE_NUMBER_VIOLATED :
      eventString += "SEQUENCE_NUMBER_VIOLATED";
      break;
    case TIME_STAMP_VIOLATED :
      eventString += "TIME_STAMP_VIOLATED";
      break;
    case PAC_VIOLATED :
      eventString += "PAC_VIOLATED";
      break;
    case SEAL_VIOLATED :
      eventString += "SEAL_VIOLATED";
      break;
    case GENERIC_UNSPECIFIED_REJECTION :
      eventString += "GENERIC_UNSPECIFIED_REJECTION";
      break;
    case GENERIC_OPERATION_REJECTION :
      eventString += "GENERIC_OPERATION_REJECTION";
      break;
    case DUPLICATE_INVOCATION_REJECTION :
      eventString += "DUPLICATE_INVOCATION_REJECTION";
      break;
    case UNRECOGNIZED_OPERATION_REJECTION :
      eventString += "UNRECOGNIZED_OPERATION_REJECTION";
      break;
    case MISTYPED_ARGUMENT_REJECTION :
      eventString += "MISTYPED_ARGUMENT_REJECTION";
      break;
    case RESOURCE_LIMITATION_REJECTION :
      eventString += "RESOURCE_LIMITATION_REJECTION";
      break;
    case ACS_HANDLE_TERMINATION_REJECTION :
      eventString += "ACS_HANDLE_TERMINATION_REJECTION";
      break;
    case SERVICE_TERMINATION_REJECTION :
      eventString += "SERVICE_TERMINATION_REJECTION";
      break;
    case REQUEST_TIMEOUT_REJECTION :
      eventString += "REQUEST_TIMEOUT_REJECTION";
      break;
    case REQUESTS_ON_DEVICE_EXCEEDED_REJECTION :
      eventString += "REQUESTS_ON_DEVICE_EXCEEDED_REJECTION";
      break;
    default :
      sprintf (str1, "%d", universalFailure);
      eventString += str1;
      break;
  }
  DisplayTheEvent (eventString);
  return;
}

/*
 *
 * CstaAlternateCall : this service provides a higher level, compound action
 * of the Hold Call service followed by Retrieve Call Service.
 *
 */
 
void CMainWind::CstaAlternateCall () {
  CAlternateCallDlg dlg;
  
  dlg.m_nActiveDeviceType = (int)DYNAMIC_ID;
  dlg.m_nOtherDeviceType = (int)DYNAMIC_ID;

  //JYL
  dlg.m_sActiveDevice = myDeviceId;
  dlg.m_sOtherDevice = myDeviceId;
  dlg.m_sOtherCall = heldCallID;
  dlg.m_sActiveCall = mainCallID;
  //JYL

  if (dlg.DoModal () == IDOK) {
    ConnectionID_t activeCall;
    ConnectionID_t otherCall; 

    activeCall.callID = atol (dlg.m_sActiveCall);
    strcpy (activeCall.deviceID, dlg.m_sActiveDevice);
    activeCall.devIDType = (ConnectionID_Device_t)dlg.m_nActiveDeviceType;
    otherCall.callID = atol (dlg.m_sOtherCall);
    strcpy (otherCall.deviceID, dlg.m_sOtherDevice);
    otherCall.devIDType = (ConnectionID_Device_t)dlg.m_nOtherDeviceType;
    m_nRetCode = cstaAlternateCall (m_acsHandle,
                    0,
                    &activeCall,
                    &otherCall,
                    pPrivateData);
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaAlternateCall", m_nRetCode);
      return;
    }
    CString eventString;
    
	DisplayEventTitle ("CSTA REQUEST Alternate Call");
    eventString =  " Active Call ID: " + dlg.m_sActiveCall;
    eventString += " Active Device ID: " + dlg.m_sActiveDevice;
    eventString += " Other Call ID: " + dlg.m_sOtherCall;
    eventString += " Other Device ID: " + dlg.m_sOtherDevice;
    DisplayTheEvent (eventString);
  }
  return; 
}

/*
 *
 * CstaAlternateCallConfEvent : this event provides the positive response from
 * the server for a previous alternate call request.
 *
 */

void CMainWind::CstaAlternateCallConfEvent () {
  DisplayTheEvent ("CSTA CONFIRM Alternate Call");
  return;
}
 
/*
 *
 * CstaAnswerCall : this function will connect an alerting call at the
 * device which is alerting. The call must be associated with a device
 * that can answer a call without requiring physical user manipulation.
 *
 */

void CMainWind::CstaAnswerCall () {
  CAnswerCallDlg dlg;
  
  dlg.m_nDeviceType = (int)DYNAMIC_ID;
  //JYL
  dlg.m_sDeviceID = myDeviceId;
  dlg.m_sCallID = mainCallID;
  //JYL

  if (dlg.DoModal () == IDOK) {
    ConnectionID_t connectionID;  

    connectionID.callID = atol (dlg.m_sCallID);
    strcpy (connectionID.deviceID, dlg.m_sDeviceID);
    connectionID.devIDType = (ConnectionID_Device_t)dlg.m_nDeviceType;
    m_nRetCode = cstaAnswerCall (m_acsHandle,
            (InvokeID_t)0,
            (ConnectionID_t FAR *)&connectionID,
            pPrivateData);
    if (m_nRetCode < 0) {
      MessageBoxError ("cstaAnswerCall", m_nRetCode);
      return;
    }
    CString eventString;
    
	DisplayEventTitle ("CSTA REQUEST Answer Call");
    eventString = "  Call ID: " + dlg.m_sCallID;
    eventString += " Device ID: " + dlg.m_sDeviceID;
    DisplayTheEvent (eventString);
  }
  return;
}

/*
 *
 * CstaAnswerCallConfEvent : this event provides the positive response from
 * the server for a previous answer call request.
 *
 */
 
void CMainWind::CstaAnswerCallConfEvent () {
  DisplayTheEvent ("CSTA CONFIRM Answer Call");
  return;
}

/*
 *
 * CstaCallCompletion : this service invoke specific switch features that may
 * complete a call that would otherwise fail.
 *
 */
 
void CMainWind::CstaCallCompletion