Unified Communication API Framework for Call Control
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current call control and media control systems require developers to deal with low-level details and irrelevant events, making the coding process cumbersome and inefficient, as they need to handle every event regardless of the object's state, leading to complex and inefficient application logic.
Innovation Solution
A unified communication framework that provides a higher-level abstraction using a unified communication API built on top of standards-based call control and media control APIs, which dispatches events only based on the type and state of the application, allowing developers to focus on business logic and reducing the need to handle low-level details.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If developers use standards-based call control and media control APIs directly, then system compatibility and interoperability are improved, but coding complexity and development time increase due to handling low-level details and all events regardless of state
Solution Approach 1:
The patent introduces an event-driven framework as an intermediary layer between the standards-based APIs and the application logic. This framework subscribes to events from the call control and media control APIs, filters them based on application state, and dispatches only relevant events to the application. This mediator abstracts away the complexity of handling all low-level events while maintaining full compatibility with the standards-based APIs.
Solution Approach 2:
The framework segments the event handling process into distinct phases: event subscription, event filtering based on state, and event dispatching. By separating these concerns, the system can maintain compatibility with standards-based APIs while simplifying the application developer's workload by only processing relevant events in the appropriate state context.
2Reliability
If developers handle every event from call control and media control APIs, then complete event processing is achieved, but development efficiency decreases due to cumbersome coding and irrelevant event handling
Solution Approach 1:
The framework dynamically adjusts event processing behavior based on the application's current state. Instead of statically handling all events, the system dynamically filters and dispatches only the events that are relevant to the current state. This dynamic approach maintains reliable event processing for the active state while eliminating unnecessary processing of irrelevant events, thereby improving development efficiency.
Solution Approach 2:
The framework implements a feedback mechanism where the application state continuously influences which events are processed. The state information provides feedback to the event handling mechanism, allowing it to intelligently determine which events are relevant and should be dispatched. This feedback loop ensures complete processing of relevant events while filtering out irrelevant ones, balancing reliability with productivity.
3Ease of operation
If developers manage low-level event details manually, then direct control over call control and media control is achieved, but ease of operation decreases due to cumbersome coding processes
Solution Approach 1:
The framework provides self-service by automatically subscribing to events from the call control and media control APIs, maintaining state information, and filtering events based on the current state. This eliminates the need for developers to manually manage low-level event details while maintaining direct control over call control and media control functionality. The framework handles the complex bookkeeping work automatically, greatly improving ease of operation.
Data Source
Figure 1
Figure 2A~2C
Figure 3A
AI summary
A communication system and method include a server hosting an interactive voice response or self-help application in a Java virtual machine. The communication application is programmed with a unified communication API, which is provided by a unified application framework. The API provides a set of unified class objects for call control and media control. The unified class objects are constructed from class object primitives of individual standards-based Java call control API and media control API. The constructs are a structured and restricted set conforming to the object model of the application and its states. The API has a unified event handler for both call and media controls and dispatches events to the application based on the type of event and the application state of the object model.