Shared-Container Event Processing for SDK-Free IoT Devices
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing IoT devices face limitations in efficiently processing events from third-party applications due to the need for software development kits (SDKs) and high access costs, which affect flexibility and user experience.
Innovation Solution
An event processing method and apparatus that utilizes a shared container to intercept and manage call data from subprograms, determining executive identifiers, and transmitting event data to device clients for processing by target applications, enhancing flexibility and reducing SDK integration requirements.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If SDK integration is used to process events from third-party applications, then event processing capability is improved, but device complexity and access costs increase
Solution Approach 1:
The patent introduces a shared container as an intermediary component that sits between third-party subprograms and target applications. This shared container enables event data exchange without requiring direct SDK integration between each subprogram and target application, thereby reducing overall system complexity while maintaining event processing capability.
Solution Approach 2:
The shared container serves as a universal interface that can handle events from multiple different subprograms and route them to multiple different target applications. This multi-functional component replaces the need for multiple specific SDK integrations, simplifying the system architecture while preserving adaptability.
2Adaptability or versatility
If multiple target applications are integrated to handle diverse events, then functionality is improved, but system complexity increases
Solution Approach 1:
The patent segments the event processing system into distinct functional modules: event subscription modules in subprograms, a shared container for event routing, and target application execution modules. This segmentation allows multiple target applications to be integrated through a standardized interface in the shared container, reducing architectural complexity while maintaining diverse functionality.
Solution Approach 2:
The shared container acts as a mediator that manages communications between multiple subprograms and multiple target applications. It handles event routing, data formatting, and coordination, thereby simplifying the integration of multiple target applications while preserving system functionality.
3Productivity
If event data is transmitted directly from subprogram to target application, then processing efficiency is improved, but access costs and integration difficulty increase
Solution Approach 1:
The shared container serves as an efficient intermediary that enables direct event data transmission from subprograms to target applications without requiring complex point-to-point integrations. It provides a standardized access interface that reduces integration difficulty and access costs while maintaining high processing efficiency through direct data passage.
Solution Approach 2:
The shared container creates a virtual copy or representation of the event data interface, allowing multiple target applications to access event data through a unified interface without requiring direct connections to each subprogram. This copying mechanism reduces access costs while preserving efficient data transmission.
Data Source
AI summary
Embodiments of this specification provide an event processing method and apparatus that are applied to an IoT device. The event processing method applied to an IoT device includes: obtaining call data that are of a service event and that are transferred by a subprogram through a call interface; querying, in a shared container, an executive identifier corresponding to an interface type of the call interface, where the executive identifier is registered in the shared container when a device client is configured with a corresponding executive; if the executive identifier is obtained through querying, intercepting the service event, and writing the call data into the shared container; and reading event data matching the executive in the call data, and transmitting the event data to the device client, so that the device client calls at least one target application to perform event processing.