The SwitchKit Application Programming Interface (API) provides a high-level interface between the application and the EXS API, to facilitate rapid switch-to-application integration. This straightforward C/C++ language API is based on industry standards, and provides automatic configuration and redundancy control, descriptive logs, and error messages. It extracts the EXS API suite into a C/C++ Library format. This feature enables you to support EXS messaging as well as administrative messages (between the application and the Low-Level Communicator (LLC) with all the benefits of a high-level language API.
The power of SwitchKit allows you to concentrate your efforts on building your telephony applications, without dealing with complex configuration requirements or administrative tasks. It enhances applications by providing increased reliability and seamless integration of multiple applications and multiple hosts. The flexibility of SwitchKit allows you to have control over low-level administrative tasks. In short, SwitchKit lets you address the call processing aspects of your solutions as you see fit, giving you the power to implement new services easily, quickly, and profitably.
SwitchKit significantly reduces development time. You do not have to be concerned with management APIs and can focus on only the messages that relate to call control.
SwitchKit not only eliminates the need to develop switch management services, but it is simple to modify and it also provides a robust, feature-rich management system with real-time monitoring and system set-up. Providing switch management separate from the switching platform and applications allows the system to remain modular. Therefore, upgrades, modifications, and customizations to any single module can be implemented without affecting the other modules, or requiring subsequent changes.
SwitchKit API adds considerable openness and programmability to the CSP. It provides access to the EXS API through C structures or C++ classes. Programming through the SwitchKit API allows the you to focus on functional parts of the code without concern for system-level details such as checksums and message length. This translation reduces the overall amount of code necessary to program an application and simplifies commands from an internal hex format into English-like statements.
SwitchKit’s asynchronous call-processing model uses common state machine call flows to allow you to easily modify call programming. SwitchKit’s call processing model uses stacks of event handlers, which allow events associated with the call to "trickle down" the stack until finding an applicable command. This stacking allows the code to remain modular, enabling new handlers to be added for new features and enhancements, and/or to handle unique protocols in different countries or systems.
Another feature of SwitchKit API that significantly reduces programming time is Inter-Application Messaging (IAM). IAM allows applications, and components within them, to communicate using SwitchKit API messages. Without SwitchKit, you would need to write your own interfaces for communications between your applications, and from applications to other components such as a billing system. However, SwitchKit allows you to use the same messaging interface for all communication, which reduces complexity, development time, and training.
Because SwitchKit supports a wide variety of operating systems, IAM facilitates communication between applications running on different computers and operating systems. SwitchKit also provides programmability for intelligent channel allocations, which allow applications to select appropriate outgoing ports. Typically, an application must manage channel idle/busy states and implement intelligence to route them. SwitchKit manages this process across all applications, allowing you to choose from a number of selection schemes, including the following:
• Round Robin
• Least Recently Used
• Most Recently Used
• Ascending/Descending
Intelligent Channel Allocation
Channels are allocated to applications upon demand, based on the most available resource in the requested group or set of groups. Intelligent channel allocations can be used between and across applications, because they may be sharing the same trunks. SwitchKit also load shares messaging and channel allotments across applications, based on a programmable load factor that is under application control. Conversely, you can program the system not to load share if another scheme is more appropriate.
Some functions shown in the API function header files are for internal use only. Among those functions are:
• sk_openFile()
• sk_getSwitchmgrId()
• sk_downloadFile()
• sk_newConfig()