WO2023216872A1 - 应用于IoT设备的事件处理方法及装置 - Google Patents
应用于IoT设备的事件处理方法及装置 Download PDFInfo
- Publication number
- WO2023216872A1 WO2023216872A1 PCT/CN2023/090607 CN2023090607W WO2023216872A1 WO 2023216872 A1 WO2023216872 A1 WO 2023216872A1 CN 2023090607 W CN2023090607 W CN 2023090607W WO 2023216872 A1 WO2023216872 A1 WO 2023216872A1
- Authority
- WO
- WIPO (PCT)
- Prior art keywords
- data
- event
- service
- client
- event processing
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Ceased
Links
Classifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/544—Buffers; Shared memory; Pipes
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/542—Event management; Broadcasting; Multicasting; Notifications
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/448—Execution paradigms, e.g. implementations of programming paradigms
- G06F9/4482—Procedural
- G06F9/4484—Executing subprograms
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/46—Multiprogramming arrangements
- G06F9/54—Interprogram communication
- G06F9/547—Remote procedure calls [RPC]; Web services
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/541—Client-server
-
- G—PHYSICS
- G06—COMPUTING OR CALCULATING; COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F2209/00—Indexing scheme relating to G06F9/00
- G06F2209/54—Indexing scheme relating to G06F9/54
- G06F2209/549—Remote execution
Definitions
- the present disclosure relates to the field of data processing technology, and in particular, to an event processing method and device applied to IoT devices.
- the event processing method applied to IoT devices includes: obtaining the call data of the service event passed in by the subroutine through the call interface. Query the executor identifier corresponding to the interface type of the calling interface in the shared container; the executor identifier is registered to the shared container when the device client configures the corresponding executor. If the execution body identifier is queried, the service event is intercepted, and the calling data is written into the shared container. The event data matching the execution body in the call data is read and transmitted to the device client, so that at least one target application is called by the device client for event processing.
- One or more embodiments of this specification provide an event processing device applied to IoT devices, including: a call data acquisition module configured to obtain call data of service events passed in by a subroutine through a call interface.
- the executor identity query module is configured to query the executor identity corresponding to the interface type of the calling interface in the shared container; the executor identity is registered to the shared container when the device client configures the corresponding executor. If the execution body identifier is queried, a call data writing module is run.
- the call data writing module is configured to intercept the service event and write the call data into the shared container.
- the event data transmission module is configured to read the event data matching the execution body in the call data and transmit it to the device client, so as to call at least one target application through the device client for event processing.
- One or more embodiments of the present specification provide an event processing device applied to an IoT device, including: a processor; and a memory configured to store computer-executable instructions that, when executed, cause The processor: obtains the calling data of the service event passed in by the subprogram through the calling interface. Query the executor identifier corresponding to the interface type of the calling interface in the shared container; the executor identifier is registered to the shared container when the device client configures the corresponding executor. If the execution body identifier is queried, the service event is intercepted, and the calling data is written into the shared container. The event data matching the execution body in the call data is read and transmitted to the device client, so that at least one target application is called by the device client for event processing.
- One or more embodiments of this specification provide a storage medium for storing computer-executable instructions.
- the computer-executable instructions When executed by a processor, the computer-executable instructions implement the following process: Obtain service events passed in by a subroutine through a calling interface. call data. Query the executor identifier corresponding to the interface type of the calling interface in the shared container; the executor identifier is registered to the shared container when the device client configures the corresponding executor. If the execution body identifier is queried, the service event is intercepted, and the calling data is written into the shared container. The event data matching the execution body in the call data is read and transmitted to the device client, so that at least one target application is called by the device client for event processing.
- Figure 1 is a processing flow chart of an event processing method applied to IoT devices provided by one or more embodiments of this specification;
- FIG. 2 is a schematic diagram of an event processing method applied to IoT devices provided by one or more embodiments of this specification;
- Figure 3 is a processing flow chart of an event processing method applied to IoT devices in a ticket purchase navigation scenario provided by one or more embodiments of this specification;
- Figure 4 is a processing flow chart of an event processing method applied to IoT devices in a vehicle-mounted IoT device scenario provided by one or more embodiments of this specification;
- FIG. 5 is a schematic diagram of an event processing device applied to IoT devices provided by one or more embodiments of this specification;
- Figure 6 is a schematic structural diagram of an event processing device applied to an IoT device according to one or more embodiments of this specification.
- This specification provides an embodiment of an event processing method applied to IoT devices: Referring to Figure 1, the event processing method applied to IoT devices provided in this embodiment is applied to a service client deployed by IoT devices, specifically including steps S102 to Step S108.
- Step S102 Obtain the calling data of the service event passed in by the subprogram through the calling interface.
- subprograms in third-party applications running on the device terminal can only interact with the third-party application when running. Using the application mechanism of the third-party application cannot link with the device application running on the terminal device. Affects the flexibility of device applications in device terminal configuration. If the existing IPC (Inter-Process Communication) communication method is used to transmit the data of the subprogram to the IoT device, the device provider of the IoT device needs to integrate the SDK (Software Development Kit) of the subprogram. The extended configuration is in the device client of the IoT device, and the access cost is high and the convenience is low.
- IPC Inter-Process Communication
- the event processing method applied to IoT devices transmits the call data based on the subroutine run by the service client to the IoT device configured with the service client through the intermediate client, that is, the service client deployed by the IoT device. And in order to ensure that the IoT device can perform event processing based on the call data of the subroutine, and to avoid affecting the user experience due to the inability of the IoT device to perform event processing based on the call data when the subroutine call data is transmitted to the IoT device, the service client obtains the subroutine. After the call data is passed in, it is first determined whether the IoT device has the ability to perform event processing based on the call data.
- the service event data in the call data is transmitted to the device client to process the event through at least one target application of the device client. Processing, in this way, the data of the subroutine is transmitted to the IoT device, so that event processing can be performed through the device application of the IoT device, thereby improving the flexibility of the device application of the IoT device.
- the IoT devices described in this embodiment include, but are not limited to, at least one of the following: vehicle terminals installed on the vehicle, terminal equipment external to the vehicle, smart speakers, unmanned vending machines, autonomous radios, interactive advertising screens, POS equipment, and smart Smart home appliances such as TVs and smart refrigerators.
- the IoT device includes a vehicle-mounted IoT device; the vehicle-mounted IoT device includes a vehicle-mounted terminal configured in the vehicle, and/or a terminal device external to the vehicle.
- the IoT devices are provided by equipment providers, which include manufacturers, sellers of terminal equipment, and/or service operators and maintenance parties of terminal equipment.
- the subprogram (small program) refers to an application package or application component that is mounted on the application platform or loaded and installed by the application platform. From a service perspective, the subprogram has the ability to independently provide self-closed-loop services, such as running on A sub-application with self-closed-loop capabilities that provides vehicle-related services or ordering services within the application.
- the IoT device is deployed with a device client and a service client; the service client is an operating framework or operating engine provided for IoT devices.
- the service client is used to run subprograms; the device client refers to a collection of system applications on which the terminal device itself depends.
- the device client configures the access portal of the subroutine; when detecting that the access portal of the configured subroutine is triggered, the device client calls the service client deployed by the IoT device.
- the service interface provided by the client and an access request to the subprogram are passed in, so that the service client loads the subprogram based on the access request; or, the service client configures the access entry of the subprogram .
- the device provider of the IoT device registers the device through the server (the server corresponding to the service client).
- the service client is deployed on the IoT device to access the subroutine through the service client.
- the service client can be run independently on the IoT device as an application, or can be run as a toolkit on the host application deployed on the IoT device (an application registered by the device provider through the server), in a child configured through the host application.
- the service client is called to load the subroutine.
- the server is used to cooperate with the service client deployed by the IoT device to perform device login processing and subroutine access processing for the IoT device.
- the server After the device provider registers the device through the server, the server stores the device information of the IoT device.
- the use of the service client by the IoT device needs to be activated to ensure that the IoT device has the ability to pass the service
- the client has permission to access subprograms.
- the IoT device is activated in the following manner: according to the device activation instruction submitted by the device client, data to be verified is collected.
- the device client is deployed on the IoT device.
- the entered data to be verified is collected, and the collected data is collected.
- the verification data is uploaded to the server.
- the server compares the data to be verified uploaded by the service client with the pre-stored device data of the device provider, and returns the verification result to the device client. If the device client receives the data downloaded from the server, If the verification result sent by the server passes the verification, the data to be verified will be stored in the shared container as the device information of the IoT device; if the verification result issued by the server does not pass the verification, a verification failure reminder will be displayed.
- the information to be verified includes the product identification corresponding to the IoT device, the equipment identification and/or the application identification entered by the equipment provider (the application identification of the host application).
- the vehicle-mounted IoT device is configured with a device client and a service client based on the vehicle provider's registration on the server when it leaves the factory.
- Vehicle-mounted IoT devices need to be activated.
- the car owner submits device activation instructions through the device client configured with the vehicle-mounted IoT device.
- the device client collects data to be verified including device identification and other data according to the device activation instructions, and provides the data to be verified through the server.
- the IPC is uploaded to the server, so that after receiving the data to be verified, the server verifies whether the data to be verified matches the device information stored by the vehicle provider when registering the device on the server; and sends the match to the device client through IPC Result; when the service client receives a verification result that passes the verification, it will store the data to be verified as the device information of the vehicle-mounted IoT device; if it receives a verification result that fails the verification, it will display a verification failure reminder through the vehicle-mounted IoT device.
- the user submits event processing instructions for service events through the subprogram during the process of accessing the subprogram.
- the subprogram performs event processing by calling other services.
- it is necessary to pass in The data is called to cause the corresponding service to perform event processing.
- the subroutine determines the calling data of the service event in the following manner: service processing is performed based on the service data input by the user through the subroutine. , obtain the service processing result; if the event processing instruction for the service event submitted by the user through the subroutine is received, the call data is determined in the service processing result according to the event processing instruction.
- the user inputs service data or service instructions through the subroutine for service processing, and obtains the service processing results.
- the event access entrance for optional service events can be displayed based on the configuration of the subroutine. If received If the user accesses the event access entry of any of the optional service events displayed through the subroutine, the call data for event processing is determined in the service processing result based on the service event. And the calling data is passed in by calling the calling interface corresponding to the service event.
- the user accesses the ticketing subroutine through the access portal of the ticketing subroutine configured on the device client of the vehicle-mounted IoT device.
- the service interface provided by the service container passes in the access instruction to the ticketing subroutine, and the service container loads the ticketing subroutine based on the access instruction; after the user purchases a ticket through the ticketing subroutine, the purchased ticket information includes location data and Ticket time and other related information; when displaying ticket information to the user, in order to improve the user's perception of the services provided by the subroutine, the user is shown the access entrance to the navigation service.
- the subroutine detects that the access entrance to the navigation service is triggered. In this case, the location data and ticket time are determined as the calling data for navigation event processing, and passed to the service container through the navigation interface.
- Step S104 Query the execution body identifier corresponding to the interface type of the calling interface in the shared container.
- the shared container includes a storage container capable of data interaction and data sharing between processes, such as ContentProvider (content provider).
- ContentProvider content provider
- the call data is transmitted to the device client, so that the device client calls multiple target applications for event processing, thereby improving the usage of the target applications.
- the processing causes event processing to fail, which affects the access experience to the subprogram.
- the executor identifier is registered to the shared container when the device client configures the corresponding executor; in an optional implementation provided by this embodiment, the following method is used to register the executor identifier: obtain The configuration information passed in by the device client to configure the execution body corresponding to the execution body identification;
- the execution body identifier is written into the shared container.
- the device client After configuring the execution body, the device client passes the execution body ID to the service client through the service interface provided by the service client. After obtaining the configuration information carrying the execution body ID, the service client combines the execution body ID with the execution body ID. The device information of the IoT device is correspondingly stored in the shared container.
- the call data of the service event passed in by the subprogram through the call interface is written into the shared container.
- the execution body identifier corresponding to the interface type of the calling interface is queried in the shared container. .
- the subroutine passes the calling data of the service event to the ContentProvider through the calling interface.
- the ContentObserver content observer
- the service client reads the calling data according to the detection result, and Query in the ContentProvider whether there is an execution body identifier corresponding to the interface type of the calling interface, that is, query whether the device client has the ability to process events based on the calling data.
- the service event is intercepted, that is, the calling data is intercepted, and the calling information is written into the shared container.
- the execution body identifier is not queried, the following operations are performed: determine the target service based on the service event application, and perform event processing of the service event based on the call data in the target service application; the at least one target application configures a service interface of the service client; the target service application is configured for the IoT device third-party usage.
- execution body ID corresponding to the interface type of the calling interface in the shared container. If the execution body ID is queried, it indicates that the device client has the processing capability for event processing, and the service event will be intercepted; if the executor ID is not found, Execution body identification, event processing is performed based on the pre-event processing process, that is, the target service application is determined based on the service event, and the device client calls the target service application to perform event processing of the service event based on the call data.
- the navigation interface of the service client is called and the ticketing time for the navigation service and the location data of the ticketing agency are passed to the ContentProvider.
- the service client detects in the ContentObserver that the ContentProvider writes the ticketing time. and location data, query the navigation identification in the ContentProvider. If the navigation identification is not found, call the third-party navigation application configured on the vehicle IoT device or the navigation application integrated in the service client to navigate to the ticket agency; if the navigation identification is found , then intercept ticketing information and location data of ticketing agencies.
- Step S106 If the execution body identifier is queried, intercept the service event and write the call data into the shared container.
- the service event will be intercepted, that is, the service client will intercept the call of the third-party application (target service application) for event processing, and store the event in the shared container.
- the call data is stored correspondingly with the execution body identifier.
- the call data is written into the shared container in a manner corresponding to the execution body identifier.
- the call data is written into the shared container in the following manner. Enter the shared container: construct a key-value pair with the execution body identifier as the primary key and the call data as the key value; write the key-value pair into the shared container.
- execution body identification and call data are written into the shared container in the form of key-value pairs.
- the navigation identifier the application identifier of the navigation application
- write the key-value pair Enter ContentProvider After intercepting the ticket information and the location data of the ticket agency, use the navigation identifier (the application identifier of the navigation application) as the main key, construct a key-value pair with the ticket information and the location data of the ticket information as the key value, and write the key-value pair Enter ContentProvider.
- Step S108 Read the event data matching the execution body in the call data and transmit it to the device client, so that at least one target application is called by the device client for event processing.
- the device client is deployed on the IoT device.
- the target application includes a device application that is configured when the IoT device leaves the factory and configures the service interface of the service client; in addition, it may also include a third party that is not configured at the factory but configures the service interface of the service client. Application; the target application configures the service interface of the service client.
- the event data matching the execution body in the call data is first read, and then the event data is transmitted to the device client, so that the device client performs event processing based on the navigation application that deploys the service interface of the service client.
- taking navigation events as an example when reading the event data matching the execution body in the call data and transmitting it to the device client, the Call the location data matching the navigation execution body in the data, and transmit the location data to the device client of the IoT device; further, in the process of the device server client calling at least one target application for event processing, perform the following Operation: Load the navigation application configured by the device client, and transmit the location data to the navigation application, so that the navigation application uses the device location data of the IoT device as the starting location data, and uses the location as the starting location data.
- the data is the termination location data for navigation processing; wherein, the navigation application configures the service interface of the service client.
- the location data matching the navigation execution body in the call data is read and sent to the device client.
- the device client loads the configured configuration of the device client.
- the navigation application of the service interface of the service client collects the device location data of the IoT device and performs navigation processing based on the device location data and location data.
- the ContentObserver detects that the ContentProvider writes a navigation identifier as the primary key, and the ticket information and the location data of the ticketing agency are key-value pairs, it reads the event data in the key-value pair and transmits the event data to the device client. So that the device client loads the corresponding navigation service based on the navigation identifier, and performs navigation processing on the location data of the ticketing agency based on the navigation service.
- the device client After receiving the event data, the device client can call multiple target applications for event processing.
- the call data is written After entering the shared container, the call data is transmitted to the device client to call at least one target application through the device client for event processing.
- the data is transmitted from the service client to the device client through the shared container, that is, the call data or event data is correspondingly transferred from the service client to the device client through the shared container.
- the process is transferred to the corresponding process of the device client.
- the device client can perform event processing based on multiple target applications; in an optional implementation provided by this embodiment, the device client calls at least one of the following methods: The target application performs event processing: determining the first target application and the second target application that load the event data;
- the device client of a vehicle-mounted IoT device calls the first target application and the second target application for event processing
- the device client calls the navigation service and weather service configured by the device client after obtaining the location data.
- the location data is transferred to the navigation service, so that the navigation service performs navigation processing based on the location data and the terminal location data of the vehicle terminal, and the location data is transferred to the weather service, so that the weather service broadcasts the weather at the location corresponding to the location data.
- the device client can configure at least one target application for the execution body.
- the device client can configure at least one target application for the execution body.
- the event data matching the execution body or the call data associated with the execution body identification (key-value pair) of the execution body Read multiple target applications configured for the execution body, and perform event processing for each target application based on application attributes and event data (or call data) of each target application.
- the service client After the service client transmits event data to the device client, in order to improve the subprogram's awareness of data transmission, it synchronizes the data transmission results to the subprogram through a callback function.
- equipment manufacturers that provide vehicle-mounted IoT devices register vehicle-mounted IoT devices through the AMPE (Alipay Mini-Program Engine) platform and select subprograms open to vehicle-mounted IoT devices.
- Equipment manufacturers can choose The subroutine is a subroutine registered by the subroutine provider to the subroutine pool of the AMPE platform; after the equipment manufacturer chooses to configure an open subroutine for the vehicle IoT device, the AMPE client (service client) is integrated based on the subroutine selected by the equipment manufacturer. , so that the device manufacturer configures the AMPE client on the vehicle-mounted IoT device when configuring the vehicle-mounted IoT device, so that the user can access the subroutine through the AMPE client configured on the vehicle-mounted IoT device.
- the AMPE client is configured in a third-party application configured on the device client of the vehicle-mounted IoT device.
- the third-party application is configured with an access entrance for the subprogram.
- the user In the process of accessing the subprogram through the vehicle-mounted IoT device, the user first triggers the access entry of the subprogram through the device client configured with the vehicle-mounted IoT device; when the device client detects that the access entry of the subprogram is triggered, it sends a request to the AMPE client.
- the provided service interface passes in the access instruction to the subroutine.
- the AMPE client loads the subroutine on the vehicle-mounted IoT device; after the user obtains the service processing result by accessing the subroutine for service processing, The subroutine submits event processing instructions for service events.
- the call interface After the subroutine determines the call data in the service processing result according to the event processing instructions, the call interface based on the event type corresponding to the service event passes the call data to the AMPE client; the AMPE client After receiving the call data, query the execution body identification corresponding to the event type in the shared container; if the execution body identification is queried, intercept the calling data, write the calling data and execution body identification into the shared container, read the calling data and execute The event data matched by the execution body corresponding to the body ID is transmitted to the device client. After receiving the event data, the device client performs event processing based on the target application corresponding to the execution body ID contained in the event data.
- Step S302 The device client obtains the trigger operation of the user's access to the ticketing subprogram, and transmits the access request to the ticketing subprogram to the service interface provided by the service client.
- Step S304 The service client loads the ticketing subroutine on the vehicle-mounted IoT device based on the access request.
- Step S306 The ticket purchase subroutine performs ticket purchase processing on the user based on the ticket purchase request submitted by the user, and obtains the ticket purchase result.
- Step S308 The ticket purchase subroutine obtains the navigation request for the navigation event submitted by the user on the ticket purchase result display page.
- Step S310 The ticket purchase subroutine determines the ticket location data and ticket time contained in the ticket purchase result as call data based on the navigation request, and calls the navigation interface to pass the call data to the service client.
- Step S312 If the service client queries the navigation application identifier in the shared container, it intercepts the call data and stores the navigation application identifier and the call data in the shared container in the form of key-value pairs.
- navigation service processing is performed based on the navigation application integrated in the service client.
- Step S314 transmit the navigation application identification and calling data to the device client.
- Step S316 The device client performs navigation processing on the ticket location data in the call data based on the navigation application corresponding to the navigation application identifier.
- the navigation application is an application configured on the device client.
- the following takes the application of an event processing method for IoT devices provided in this embodiment in a vehicle-mounted IoT device scenario as an example to further explain the event processing method provided by this embodiment for IoT devices. See Figure 4.
- the event processing method applied to the IoT device in the vehicle-mounted IoT device scenario specifically includes the following steps S402 to S422.
- Step S402 According to the device activation instruction submitted by the device client deployed on the vehicle-mounted IoT device, the data to be verified is obtained and the data to be verified is sent to the server for device verification.
- Step S404 According to the verification result issued by the server, the information to be verified is stored in the shared container as the device information of the vehicle-mounted IoT device.
- Step S406 Execute the callback function to return an activation result of successful activation to the device client.
- Step S408 Obtain the configuration information of the execution body corresponding to the configuration execution body identifier passed in by the device client by calling the service interface configured by the service client.
- Step S410 Based on the configuration information, write the execution body identifier into the shared container to complete the registration of the execution body.
- Step S412 After writing the execution body identifier into the shared container, execute the callback function to return a successful registration result to the device client.
- Step S414 If it is detected that the call data of the service event passed in by the subprogram written in the shared container through the call interface is detected, the execution body identifier corresponding to the interface type of the call interface is queried in the shared container.
- Step S416 If the execution body identifier is queried, the service event is intercepted.
- Step S418 Construct a key-value pair based on the execution body identifier and the call data, and write the key-value pair into the shared container.
- Step S420 Read the event data matching the execution body in the call data and transmit it to the device client based on the shared container, so that the device client performs event processing based on the event data based on the first target application and the second target application.
- step S420 may also be replaced by transmitting the calling data to the device client based on the shared container.
- Step S422 Execute the callback function to return the data transmission result to the subroutine.
- the event processing method applied to IoT devices configures a common
- the shared container realizes data transmission between the service client and the device client, that is, the service client performs data transmission between the processes corresponding to the core device client; on the other hand, the device client receives the transmitted
- the data can be processed through multiple target applications of the service interface of the service client.
- the linkage between the applet and the device application configured by the IoT device is realized, which solves the limitation of one-to-one data transmission of the subroutine and improves the IoT
- the service awareness of the equipment provider improves the flexibility of equipment applications.
- FIG. 5 a schematic diagram of an event processing device applied to IoT devices provided in this embodiment is shown.
- the description is relatively simple. For relevant parts, please refer to the corresponding description of the method embodiment provided above.
- the device embodiments described below are merely illustrative.
- This embodiment provides an event processing device applied to IoT devices, including: a call data acquisition module 502, configured to obtain the call data of service events passed in by a subroutine through a call interface; an execution body identification query module 504, configured To query the executor identifier corresponding to the interface type of the calling interface in the shared container; the executor identifier is registered to the shared container when the device client configures the corresponding executor; if the executor identifier is queried , then run the call data writing module 506, which is configured to intercept the service event and write the call data to the shared container; the event data transmission module 508 is configured to The event data matching the execution body in the call data is read and transmitted to the device client, so that at least one target application is called by the device client for event processing.
- a call data acquisition module 502 configured to obtain the call data of service events passed in by a subroutine through a call interface
- an execution body identification query module 504 configured To query the executor identifier corresponding to the interface type of the calling interface in the shared
- This specification provides an example of an event processing device applied to IoT devices as follows: Corresponding to the above-described event processing method applied to IoT devices, based on the same technical concept, one or more embodiments of this specification also provide an An event processing device applied to IoT devices.
- the event processing device applied to IoT devices is used to execute the event processing method applied to IoT devices provided above.
- Figure 6 is an application provided by one or more embodiments of this specification. Structural diagram of event processing equipment for IoT devices.
- an event processing device applied to an IoT device including: As shown in Figure 6, the event processing device applied to an IoT device may vary greatly due to different configurations or performance, and may include one or more The above processor 601 and memory 602, the memory 602 may store one or more storage application programs or data. Among them, the memory 602 may be short-term storage or persistent storage.
- the application program stored in memory 602 may include one or more modules (not shown), each module may include a series of computer-executable instructions applied in an event processing device of the IoT device.
- the processor 601 may be configured to communicate with the memory 602 and execute a series of computer-executable instructions in the memory 602 on an event processing device applied to the IoT device.
- Event processing devices applied to IoT devices may also include one or more power supplies 603, one or more wired or wireless network interfaces 604, one or more input/output interfaces 605, one or more keyboards 606, etc.
- an event processing device applied to an IoT device includes a memory, and one or more programs, wherein one or more programs are stored in the memory, and the one or more programs may include one or more The above modules, and each module may include a series of computer-executable instructions corresponding to an event processing device applied to an IoT device, and configured to be executed by one or more processors
- more than one program contains computer executable instructions for performing the following: obtaining the calling data of the service event passed in by the subroutine through the calling interface; querying the execution body identifier corresponding to the interface type of the calling interface in the shared container; The entity identifier is registered to the shared container when the device client configures the corresponding execution entity; if the execution entity identifier is queried, the service event is intercepted and the call data is written into the shared container; read The event data matching the execution body in the call data is obtained and transmitted to the device client, so that at least one target application is called by the device client for event processing.
- An example of a storage medium provided in this specification is as follows: Corresponding to the above-described event processing method applied to IoT devices, based on the same technical concept, one or more embodiments of this specification also provide a storage medium.
- the storage medium provided by this embodiment is used to store computer-executable instructions.
- the computer-executable instructions When executed by the processor, the computer-executable instructions implement the following process: obtain the call data of the service event passed in by the subroutine through the call interface;
- the executor identifier corresponding to the interface type of the calling interface in the shared container; the executor identifier is registered to the shared container when the device client configures the corresponding executor; if the executor identifier is queried, Then intercept the service event and write the call data to the shared container; read the event data matching the execution body in the call data and transmit it to the device client to pass the device
- the client calls at least one target application for event processing.
- a programmable logic device such as a field programmable gate array (FPGA)
- FPGA field programmable gate array
- HDL Hardware Description Language
- HDL high-density circuit Hardware Description Language
- ABEL Advanced Boolean Expression Language
- AHDL Altera Hardware Description Language
- Confluence CUPL
- HDCal Component-Dielectric
- JHDL Java Hardware Description Language
- Lava Lava
- Lola MyHDL
- PALASM RHDL
- VHDL Very-High-Speed Integrated Circuit Hardware Description Language
- Verilog Verilog
- the controller may be implemented in any suitable manner, for example, the controller may take the form of, for example, a microprocessor or processor and a computer readable medium storing computer readable program code (eg, software or firmware) executable by the (micro)processor. , logic gates, switches, Application Specific Integrated Circuit (ASIC), programmable logic controllers and embedded microcontrollers.
- controllers include but are not limited to the following microcontrollers: ARC 625D, Atmel AT91SAM, For Microchip PIC18F26K20 and Silicone Labs C8051F320, the memory controller can also be implemented as part of the memory's control logic.
- the controller in addition to implementing the controller in the form of pure computer-readable program code, the controller can be completely programmed with logic gates, switches, application-specific integrated circuits, programmable logic controllers and embedded logic by logically programming the method steps. Microcontroller, etc. to achieve the same function. Therefore, this controller can be considered as a hardware component, and the devices included therein for implementing various functions can also be considered as structures within the hardware component. Or even, the means for implementing various functions can be considered as structures within hardware components as well as software modules implementing the methods.
- a typical implementation device is a computer.
- the computer may be, for example, a personal computer, a laptop computer, a cellular phone, a camera phone, a smartphone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or A combination of any of these devices.
- one or more embodiments of this specification may be provided as a method, system, or computer program product. Accordingly, one or more embodiments of the present disclosure may take the form of an entirely hardware embodiment, an entirely software embodiment, or an embodiment that combines software and hardware aspects. Furthermore, the present description may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk memory, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.
- computer-usable storage media including, but not limited to, disk memory, CD-ROM, optical storage, etc.
- These computer program instructions may also be stored in a computer-readable memory that causes a computer or other programmable data processing apparatus to operate in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including the instruction means, the instructions
- the device implements one process or multiple processes in the flow chart and/or one method in the block diagram A function specified in a box or boxes.
- These computer program instructions may also be loaded onto a computer or other programmable data processing device, causing a series of operating steps to be performed on the computer or other programmable device to produce computer-implemented processing, thereby executing on the computer or other programmable device.
- Instructions provide steps for implementing the functions specified in a process or processes of a flowchart diagram and/or a block or blocks of a block diagram.
- a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.
- processors CPUs
- input/output interfaces network interfaces
- memory volatile and non-volatile memory
- Memory may include non-permanent storage in computer-readable media, random access memory (RAM) and/or non-volatile memory in the form of read-only memory (ROM) or flash memory (flash RAM). Memory is an example of computer-readable media.
- RAM random access memory
- ROM read-only memory
- flash RAM flash random access memory
- Computer-readable media includes both persistent and non-volatile, removable and non-removable media that can be implemented by any method or technology for storage of information.
- Information may be computer-readable instructions, data structures, modules of programs, or other data.
- Examples of computer storage media include, but are not limited to, phase change memory (PRAM), static random access memory (SRAM), dynamic random access memory (DRAM), other types of random access memory (RAM), and read-only memory.
- PRAM phase change memory
- SRAM static random access memory
- DRAM dynamic random access memory
- RAM random access memory
- read-only memory read-only memory
- ROM read-only memory
- EEPROM electrically erasable programmable read-only memory
- flash memory or other memory technology
- compact disc read-only memory CD-ROM
- DVD digital versatile disc
- Magnetic tape cassettes tape disk storage or other magnetic storage devices or any other non-transmission medium can be used to store information that can be accessed by a computing device.
- computer-readable media does not include transitory media, such as modulated data signals and carrier waves.
- One or more embodiments of this specification may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer.
- program modules include routines, programs, objects, components, data structures, etc. that perform specific tasks or implement specific abstract data types.
- One or more embodiments of the present specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices connected through a communications network.
- program modules may be located in both local and remote computer storage media including storage devices.
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Multimedia (AREA)
- Stored Programmes (AREA)
- Information Transfer Between Computers (AREA)
Abstract
Description
Claims (13)
- 一种应用于IoT设备的事件处理方法,应用于IoT设备部署的服务客户端,包括:获取子程序通过调用接口传入的服务事件的调用数据;在共享容器中查询所述调用接口的接口类型对应的执行体标识;所述执行体标识在设备客户端配置对应执行体的情况下注册至所述共享容器;若查询到所述执行体标识,则拦截所述服务事件,并将所述调用数据写入所述共享容器;读取所述调用数据中与所述执行体匹配的事件数据并向所述设备客户端传输,以通过所述设备客户端调用至少一个目标应用进行事件处理。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述执行体标识采用如下方式注册至所述共享容器:获取所述设备客户端传入的配置所述执行体标识对应的执行体的配置信息;基于所述配置信息的获取,将所述执行体标识写入所述共享容器。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述将所述调用数据写入所述共享容器,包括:以所述执行体标识为主键、所述调用数据为键值构建键值对;将所述键值对写入所述共享容器。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述设备客户端部署于所述IoT设备;所述获取子程序通过调用接口传入的服务事件的调用数据步骤执行之前,还包括:根据所述设备客户端提交的设备激活指令,采集待验证数据;将所述待验证数据向服务端上传,以核验所述待验证数据与所述IoT设备所属设备提供方对所述IoT设备进行设备注册时录入的设备信息是否一致;接收所述服务端下发的验证结果,并通过回调函数向所述设备客户端返回所述验证结果。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述读取所述调用数据中与所述执行体匹配的事件数据并向所述设备客户端传输,包括:读取所述调用数据中与导航执行体匹配的位置数据,并将所述位置数据向所述IoT设备的设备客户端传输;相应的,所述调用至少一个目标应用进行事件处理,包括:加载所述设备客户端配置的导航应用,将所述位置数据传输至所述导航应用,以使所述导航应用以所述IoT设备的设备位置数据为起始位置数据,以所述位置数据为终止位置数据进行导航处理;其中,所述导航应用配置所述服务客户端的服务接口。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述调用至少一个目标应用进行事件处理,包括:确定加载所述事件数据的第一目标应用和第二目标应用;将所述事件数据输入所述第一目标应用和所述第二目标应用,以基于所述第一目标应用的应用属性加载所述事件数据,以及,基于所述第二目标应用的应用属性加载所述 事件数据。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,若未查询到所述执行体标识,执行如下操作:基于所述服务事件确定目标服务应用,并在所述目标服务应用基于所述调用数据进行所述服务事件的事件处理;所述至少一个目标应用配置所述服务客户端的服务接口;所述目标服务应用为所述IoT设备配置的第三方应用。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述设备客户端部署于所述IoT设备,所述设备客户端配置所述子程序的访问入口;其中,所述设备客户端在检测到配置的子程序的访问入口被触发的情况下,调用所述IoT设备部署的所述服务客户端提供的服务接口的方式传入对所述子程序的访问请求,以使所述服务客户端基于所述访问请求加载所述子程序。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述服务事件的调用数据,采用如下方式确定:根据用户通过所述子程序输入的服务数据进行服务处理,获得服务处理结果;若接收到所述用户通过所述子程序提交的对所述服务事件的事件处理指令,根据所述事件处理指令,在所述服务处理结果中确定所述调用数据。
- 根据权利要求1所述的应用于IoT设备的事件处理方法,所述IoT设备包括车载IoT设备;其中,所述车载IoT设备包括车辆配置的车机终端和/或车辆外接的终端设备。
- 一种应用于IoT设备的事件处理装置,包括:调用数据获取模块,被配置为获取子程序通过调用接口传入的服务事件的调用数据;执行体标识查询模块,被配置为在共享容器中查询所述调用接口的接口类型对应的执行体标识;所述执行体标识在设备客户端配置对应执行体的情况下注册至所述共享容器;若查询到所述执行体标识,则运行调用数据写入模块,所述调用数据写入模块,被配置为拦截所述服务事件,并将所述调用数据写入所述共享容器;事件数据传输模块,被配置为读取所述调用数据中与所述执行体匹配的事件数据并向所述设备客户端传输,以通过所述设备客户端调用至少一个目标应用进行事件处理。
- 一种应用于IoT设备的事件处理设备,包括:处理器;以及,被配置为存储计算机可执行指令的存储器,所述计算机可执行指令在被执行时使所述处理器:获取子程序通过调用接口传入的服务事件的调用数据;在共享容器中查询所述调用接口的接口类型对应的执行体标识;所述执行体标识在设备客户端配置对应执行体的情况下注册至所述共享容器;若查询到所述执行体标识,则拦截所述服务事件,并将所述调用数据写入所述共享容器;读取所述调用数据中与所述执行体匹配的事件数据并向所述设备客户端传输,以通过所述设备客户端调用至少一个目标应用进行事件处理。
- 一种存储介质,用于存储计算机可执行指令,所述计算机可执行指令在被处理器执行时实现以下流程:获取子程序通过调用接口传入的服务事件的调用数据;在共享容器中查询所述调用接口的接口类型对应的执行体标识;所述执行体标识在设备客户端配置对应执行体的情况下注册至所述共享容器;若查询到所述执行体标识,则拦截所述服务事件,并将所述调用数据写入所述共享容器;读取所述调用数据中与所述执行体匹配的事件数据并向所述设备客户端传输,以通过所述设备客户端调用至少一个目标应用进行事件处理。
Priority Applications (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| EP23802646.2A EP4524743A4 (en) | 2022-05-07 | 2023-04-25 | EVENT PROCESSING METHOD AND APPARATUS APPLIED TO IoT DEVICE |
| US18/863,548 US20250298677A1 (en) | 2022-05-07 | 2023-04-25 | Event processing method and apparatus applied to iot device |
Applications Claiming Priority (2)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202210493654.7 | 2022-05-07 | ||
| CN202210493654.7A CN114816800B (zh) | 2022-05-07 | 2022-05-07 | 应用于IoT设备的事件处理方法及装置 |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| WO2023216872A1 true WO2023216872A1 (zh) | 2023-11-16 |
Family
ID=82511789
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| PCT/CN2023/090607 Ceased WO2023216872A1 (zh) | 2022-05-07 | 2023-04-25 | 应用于IoT设备的事件处理方法及装置 |
Country Status (4)
| Country | Link |
|---|---|
| US (1) | US20250298677A1 (zh) |
| EP (1) | EP4524743A4 (zh) |
| CN (2) | CN114816800B (zh) |
| WO (1) | WO2023216872A1 (zh) |
Families Citing this family (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN114816800B (zh) * | 2022-05-07 | 2024-08-27 | 支付宝(杭州)信息技术有限公司 | 应用于IoT设备的事件处理方法及装置 |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN107612909A (zh) * | 2017-09-18 | 2018-01-19 | 阿里巴巴集团控股有限公司 | 关于物联网设备的信息交互方法、装置及设备 |
| US20180150341A1 (en) * | 2016-11-28 | 2018-05-31 | Amazon Technologies, Inc. | Remote invocation of code execution in a localized device coordinator |
| CN113454969A (zh) * | 2020-12-31 | 2021-09-28 | 商汤国际私人有限公司 | 信息交互方法和装置、设备、系统及存储介质 |
| EP3929749A1 (fr) * | 2020-06-26 | 2021-12-29 | Bull Sas | Procede et dispositif d'execution distante de programmes d'objet connecte dans un reseau local |
| CN114816800A (zh) * | 2022-05-07 | 2022-07-29 | 支付宝(杭州)信息技术有限公司 | 应用于IoT设备的事件处理方法及装置 |
Family Cites Families (10)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7562341B2 (en) * | 2004-05-24 | 2009-07-14 | Sap Ag | Deploy callback system with bidirectional containers |
| US9762556B2 (en) * | 2015-01-09 | 2017-09-12 | Verisign, Inc. | Registering, managing, and communicating with IOT devices using domain name system processes |
| US20160205106A1 (en) * | 2015-01-12 | 2016-07-14 | Verisign, Inc. | Systems and methods for providing iot services |
| WO2019018482A1 (en) * | 2017-07-20 | 2019-01-24 | Cisco Technology, Inc. | MANAGING A DISTRIBUTED NETWORK OF FUNCTION EXECUTION ENVIRONMENTS |
| CN108681473A (zh) * | 2018-05-18 | 2018-10-19 | 广州酷狗计算机科技有限公司 | 应用程序生成、运行方法、装置、计算机设备和存储介质 |
| US10599486B1 (en) * | 2018-09-21 | 2020-03-24 | Citrix Systems, Inc. | Systems and methods for intercepting and enhancing SaaS application calls via embedded browser |
| CN110309005B (zh) * | 2019-06-28 | 2022-03-25 | 百度在线网络技术(北京)有限公司 | 一种功能调用方法、装置、终端设备及存储介质 |
| US11307911B2 (en) * | 2020-05-29 | 2022-04-19 | Microsoft Technology Licensing, Llc | File upload modifications for client side applications |
| CN113282833B (zh) * | 2021-06-15 | 2023-03-24 | 支付宝(杭州)信息技术有限公司 | 车票处理方法及装置 |
| CN114281432A (zh) * | 2021-11-23 | 2022-04-05 | 招银云创信息技术有限公司 | 应用程序执行方法、装置、计算机设备和存储介质 |
-
2022
- 2022-05-07 CN CN202210493654.7A patent/CN114816800B/zh active Active
- 2022-05-07 CN CN202411080528.4A patent/CN118779133A/zh active Pending
-
2023
- 2023-04-25 US US18/863,548 patent/US20250298677A1/en active Pending
- 2023-04-25 WO PCT/CN2023/090607 patent/WO2023216872A1/zh not_active Ceased
- 2023-04-25 EP EP23802646.2A patent/EP4524743A4/en active Pending
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20180150341A1 (en) * | 2016-11-28 | 2018-05-31 | Amazon Technologies, Inc. | Remote invocation of code execution in a localized device coordinator |
| CN107612909A (zh) * | 2017-09-18 | 2018-01-19 | 阿里巴巴集团控股有限公司 | 关于物联网设备的信息交互方法、装置及设备 |
| EP3929749A1 (fr) * | 2020-06-26 | 2021-12-29 | Bull Sas | Procede et dispositif d'execution distante de programmes d'objet connecte dans un reseau local |
| CN113454969A (zh) * | 2020-12-31 | 2021-09-28 | 商汤国际私人有限公司 | 信息交互方法和装置、设备、系统及存储介质 |
| CN114816800A (zh) * | 2022-05-07 | 2022-07-29 | 支付宝(杭州)信息技术有限公司 | 应用于IoT设备的事件处理方法及装置 |
Non-Patent Citations (1)
| Title |
|---|
| See also references of EP4524743A4 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN114816800A (zh) | 2022-07-29 |
| EP4524743A4 (en) | 2025-08-27 |
| CN118779133A (zh) | 2024-10-15 |
| EP4524743A1 (en) | 2025-03-19 |
| US20250298677A1 (en) | 2025-09-25 |
| CN114816800B (zh) | 2024-08-27 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US9635129B2 (en) | Automatic application discovery, download, integration and launch | |
| US10038771B2 (en) | Extending features of one device to another | |
| US20200341617A1 (en) | Program Orchestration Method and Electronic Device | |
| CN111611022B (zh) | 小程序应用的数据处理方法、装置、设备及系统 | |
| CN114546843B (zh) | 程序调试处理方法及装置 | |
| WO2023151439A1 (zh) | 账户登录处理 | |
| WO2023151440A1 (zh) | 程序更新处理 | |
| CN113836540A (zh) | 管理应用权限的方法、设备、存储介质和程序产品 | |
| CN114443173B (zh) | 子程序加载处理方法及装置 | |
| WO2023216872A1 (zh) | 应用于IoT设备的事件处理方法及装置 | |
| CN110046052A (zh) | 一种服务调用方法及装置 | |
| WO2023179182A1 (zh) | 设备分屏适配处理 | |
| CN113672784B (zh) | 基于区块链的车辆信息处理方法、装置及系统 | |
| CN117041980B (zh) | 一种网元管理方法、装置、存储介质及电子设备 | |
| CN114500300B (zh) | 服务注册处理方法及装置 | |
| CN118170564A (zh) | 一种小程序的处理方法、装置及设备 | |
| CN112306469A (zh) | 一种无障碍组件构建方法、装置、设备及存储介质 | |
| CN115269954A (zh) | 数据处理方法及装置 | |
| CN114546524B (zh) | 应用权限处理方法及装置 | |
| CN114579216A (zh) | 一种小程序能力使用方法、装置以及设备 | |
| US20230336551A1 (en) | Method and device for providing web page using captive portal | |
| CN111581612B (zh) | 小程序应用的登录态数据处理方法、装置、设备及系统 | |
| CN120255971B (zh) | 一种交互实现方法和电子设备 | |
| US20250377927A1 (en) | Program executing method, electronic device and storage medium | |
| CN114968457A (zh) | 应用于子程序的表单处理方法及装置 |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| 121 | Ep: the epo has been informed by wipo that ep was designated in this application |
Ref document number: 23802646 Country of ref document: EP Kind code of ref document: A1 |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 18863548 Country of ref document: US |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 2023802646 Country of ref document: EP |
|
| NENP | Non-entry into the national phase |
Ref country code: DE |
|
| ENP | Entry into the national phase |
Ref document number: 2023802646 Country of ref document: EP Effective date: 20241209 |
|
| WWE | Wipo information: entry into national phase |
Ref document number: 11202407757R Country of ref document: SG |
|
| WWP | Wipo information: published in national office |
Ref document number: 18863548 Country of ref document: US |