CN115705227A

CN115705227A - Scene task execution method, device, equipment and storage medium

Info

Publication number: CN115705227A
Application number: CN202110927752.2A
Authority: CN
Inventors: 丁磊; 葛超
Original assignee: Human Horizons Shanghai Internet Technology Co Ltd
Current assignee: Human Horizons Shanghai Internet Technology Co Ltd
Priority date: 2021-08-12
Filing date: 2021-08-12
Publication date: 2023-02-17

Abstract

The embodiment of the application provides a method, a device, equipment and a storage medium for executing a scene task, wherein the method comprises the following steps: determining a target signal from a preset signal domain; monitoring a target signal according to a target trigger condition corresponding to the target signal; determining a target execution domain corresponding to the target signal under the condition that the monitored target signal meets a target trigger condition; and executing the task to be executed in the target execution domain. According to the technical scheme, the conversation scene can be automatically triggered based on the monitoring signal, so that an active conversation scene is realized.

Description

Scene task execution method, device, equipment and storage medium

Technical Field

The present application relates to the field of scene engine technologies, and in particular, to a method, an apparatus, a device, and a storage medium for executing a scene task.

Background

In the related art, a dialogue logic is written into a system in a hard coding mode, so that a vehicle-end voice dialogue scene is realized. For example, if navigation of a voice conversation is desired, the execution logic of the voice conversation and the vehicle component is written into the system. If the execution logic has an update, then the entire system needs to be updated. If a new dialog scene needs to be added, new dialog logic needs to be rearranged and written into the system, and the system is updated. This approach is very inflexible and cannot update iterations quickly.

Disclosure of Invention

The embodiment of the application provides a method, a device, equipment and a storage medium for executing a scene task, which are used for solving the problems in the related art, and the technical scheme is as follows:

in a first aspect, an embodiment of the present application provides a method for executing a scenario task, including:

determining a target signal from a preset signal domain;

monitoring a target signal according to a target trigger condition corresponding to the target signal;

determining a target execution domain corresponding to the target signal under the condition that the monitored target signal meets a target trigger condition;

and executing the task to be executed in the target execution domain.

In one embodiment, the method further comprises:

registering an execution domain to which a task to be executed with a signal monitoring requirement belongs to a signal domain;

a trigger condition is preset for the signal to be monitored.

In one embodiment, before executing the task to be executed in the target execution domain, the method further comprises:

and under the condition that the target signal is monitored to meet the target triggering condition, informing the target execution domain.

In one embodiment, executing a task to be executed in a target execution domain includes:

sending a task execution request to a scheduling thread pool so that the scheduling thread pool can acquire the global conversation context of the current user from the global conversation contexts of a plurality of users;

and executing the task to be executed in the target execution domain according to the global conversation context of the current user.

In a second aspect, an embodiment of the present application provides a device for executing a scene task, including:

the target signal determining module is used for determining a target signal from a preset signal domain;

the monitoring module is used for monitoring the target signal according to a target triggering condition corresponding to the target signal;

the target execution domain determining module is used for determining a target execution domain corresponding to the target signal under the condition that the monitored target signal meets the target triggering condition;

and the task execution module is used for executing the task to be executed in the target execution domain.

In one embodiment, the apparatus further comprises:

the registration module is used for registering an execution domain to which a task to be executed with a signal monitoring requirement belongs to a signal domain;

and the condition presetting module is used for presetting a trigger condition for the signal to be monitored.

In one embodiment, the apparatus further comprises:

and the notification module is used for notifying the target execution domain under the condition that the target signal is monitored to meet the target trigger condition before the task to be executed in the target execution domain is executed.

In one embodiment, the task execution module is specifically configured to:

In a third aspect, an embodiment of the present application further provides an electronic device, including:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein, the first and the second end of the pipe are connected with each other,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the above method.

In a fourth aspect, an embodiment of the present application further provides a computer-readable storage medium, in which a computer program is stored, and when the computer program is executed by a processor, the computer program implements the above method.

The advantages or benefits in the above technical solution at least include: the dialogue scene is automatically triggered based on the monitoring signal, so that an active dialogue scene is realized, a variable voice dialogue scene can be naturally isolated from a constant execution engine, iteration of dialogue logic and the execution engine are not influenced mutually, and quick iteration of the voice dialogue scene can be facilitated.

The foregoing summary is provided for the purpose of description only and is not intended to be limiting in any way. In addition to the illustrative aspects, embodiments, and features described above, further aspects, embodiments, and features of the present application will be readily apparent by reference to the drawings and following detailed description.

Drawings

In the drawings, like reference characters designate like or similar parts or elements throughout the several views unless otherwise specified. The figures are not necessarily to scale. It is appreciated that these drawings depict only some embodiments in accordance with the disclosure and are not to be considered limiting of its scope.

Fig. 1 is a flowchart of a method for executing a scenario task according to an embodiment of the present application;

FIG. 2 is a diagram illustrating an example of an application of a method for executing a scenario task according to an embodiment of the present application;

FIG. 3 is a diagram of another application example of a method for executing a scenario task according to an embodiment of the present application;

FIG. 4 is a block diagram of an apparatus for executing a scene task according to an embodiment of the present disclosure;

FIG. 5 is a block diagram of an apparatus for executing a scenario task according to another embodiment of the present application;

fig. 6 is a schematic diagram of an electronic device according to an embodiment of the application.

Detailed Description

In the following, only certain exemplary embodiments are briefly described. As those skilled in the art would realize, the described embodiments may be modified in various different ways, all without departing from the spirit or scope of the present application. Accordingly, the drawings and description are to be regarded as illustrative in nature, and not as restrictive.

An embodiment of the present application provides a method for executing a scene task, as shown in fig. 1, the method includes:

step S101: determining a target signal from a preset signal domain;

step S102: monitoring a target signal according to a target trigger condition corresponding to the target signal;

step S103: determining a target execution domain corresponding to the target signal under the condition that the target signal is monitored to meet a target trigger condition;

step S104: and executing the task to be executed in the target execution domain.

The preset Signal domain (Signal) can be used for carrying modal data of Vehicle sensing equipment, modal data of environment sensing (V2X) equipment, modal data of wearable equipment and other equipment, and is a Signal pool which can be arranged, observed and dispatched. There may be a plurality of signal fields, and one device corresponds to one signal field, and is used for buffering the signal mode data of the device. Thus, the signal domain is a container of a large number of signals.

The task to be executed is generated by performing modal arrangement on modal data in at least one action domain; each modality data in the same scope has the same or associated data type. And the signal domain is a scope. The execution domain is generated by logically arranging at least one task to be executed.

The scope may also include a parameter domain (Param), a Tag domain (Tag), a Service domain (Service), a hidden domain (Mask), and a Sandbox domain (Sandbox), among others.

Illustratively, the parameter domain may be used to store parameters transmitted by a scenario domain, an execution domain, a task to be executed, and the like when scheduling a runtime across blocks. The label domain can be used for bearing a user big data portrait centered on data, such as labels of age, sex, hobbies, behavior habits and the like, and is a user label pool formed by a plurality of labels. There may be multiple tag fields, one for each user, to cache the user's large data representation.

The contextual dialog and the interactive scenario script need to call an Application Programming Interface (API) of an Application in the system and a service outside the system, and the service domain is used for encapsulating the calling details of the service and arranging data returned by the service. The applications in the system can include navigation, multimedia, radio (FM), account numbers, digital cars and the like, and the services outside the system can serve scenes of car enterprises, such as the geek world, and can also serve third parties, such as Artificial Intelligence (AI) service irobot.

The hidden field may be used to carry a dialog context corresponding to a current semantic input, multiplexed or regenerated by the dialog and interactive scenes as needed, while the hidden field is bound to the execution fields, and each execution field is bound to a hidden field for carrying the dialog context of the execution field.

A sandbox domain may carry the global dialog context of a device or a user, which is a super context for isolating programmable data of different devices or different users. It is understood that during the execution of the task in the execution domain, data is generated, which is stored as a dialog context in the hidden domain, and the hidden domain is bound to the execution domain to record the dialog. The sandbox domain stores the global dialog context, including all the dialog contexts.

The modality organization can determine how to operate the modality data in the scope to produce the human to be executed. The modal arrangement may be an operation such as a comparison operation, an inclusion operation, an assignment operation, and the like. The task to be executed is a basic dialogue or service scene unit, does not support independent execution, and is a minimum unit forming an execution domain. The tasks to be executed may be standard tasks, i.e., tasks composed of a set of conditions and an execution group, or may be logical tasks, i.e., logical block tasks composed of logical conditions such as if, elseif, else, and foreach, or may include simple tasks, i.e., tasks for quickly finding an assignment (value) by a key (key) and changing the state to END (END) or RETURN (RETURN).

Therefore, a service developer can determine a task to be executed according to a service requirement, call modal data in a corresponding action domain according to the task requirement of the task to be executed, and perform operation to generate the task to be executed. Further, an execution domain may be generated by logically arranging one or more tasks to be executed.

The logical orchestration may include referencing (using) or embedding (embed) the tasks to be executed in the execution domain. Depending on the logical arrangement, the execution domains may include simple domains, complex domains, and aggregate domains.

The simple domain comprises one or more first tasks to be executed, wherein the first tasks to be executed are used for realizing a single-turn dialogue service, namely the simple domain is used for bearing an executable single-turn dialogue or a simple active service scene or a passive service scene. The complex domain comprises one or more second tasks to be executed, and the second tasks to be executed are used for realizing multi-turn dialogue services, namely the complex domain is used for carrying executable multi-turn contextual dialogues or complex interactive service scenes. The aggregation domain includes one or more first tasks to be executed and one or more second tasks to be executed, that is, the complex domain is used for bearing executable multi-turn, cross-domain and aggregation scenario type conversations, or an interactive service scenario aggregated by a plurality of single, isolated and incoherent capability points, service segments, scenario segments and the like. The execution domain can schedule one task to be executed or schedule a plurality of tasks to be executed.

The orchestration of the various domains is separate from the execution engine. Independent of the execution engine, the producer (device) of the signal constantly registers the signal with the signal domain, from which the watcher of the signal subscribes to the signal of interest (registers the watcher). Wherein observation is understood to be monitoring or listening. The process of registering a watcher can include: registering an execution domain to which a task to be executed with a signal monitoring requirement belongs to a signal domain; a trigger condition is preset for the signal to be monitored. All signals that have a registered watcher can be targeted.

Illustratively, the observers may be integrated according to the user scene version information.

In one embodiment, step S104 may be preceded by: and under the condition that the target signal is monitored to meet the target triggering condition, informing the target execution domain.

The execution engine will proceed according to the registration signal and the registered watcher during execution. For example: the vehicle speed is used as a target signal, the vehicle speed is constantly changed, the target execution domain which has registered the signal can monitor the vehicle speed change, or a trigger condition of the vehicle speed change is preset when the target signal is registered, and when the vehicle speed change meets the trigger condition (target trigger condition), the target execution domain is informed.

In one embodiment, step S104 may include: sending a task execution request to a scheduling thread pool so that the scheduling thread pool can acquire the global conversation context of the current user from the global conversation contexts of a plurality of users; and executing the task to be executed in the target execution domain according to the global conversation context of the current user.

Wherein the global conversation context for the plurality of users is stored in a database of the scope-holder. Illustratively, in the database of the scope holder, the global conversation context of each user and each device is included, and the global conversation context of the current user can be obtained according to the identity of the current user. Further, the database of the scope holder also includes data structures such as an executable scenario script (schema), a sandbox domain, a signal domain, a tag domain, a registered listener, a request session, and the like, and the application is executed by the engine.

In one application example, the method may be used to perform standard tasks, as shown in FIG. 2. Specifically, when monitoring that the target signal satisfies the target trigger condition, the active engine notifies the target execution domain (observer) and submits the job to the signal trigger, so that the signal trigger performs job scheduling to execute each task in the target execution domain.

In addition, under the condition that a target signal is monitored to meet a target triggering condition, the active engine sends a task execution request to the scheduling thread pool so that the scheduling thread pool can acquire the global conversation context (the sandbox domain of the current user) of the current user from the global conversation contexts (the database of the scope holder) of a plurality of users; and enabling the signal trigger to carry out job scheduling, and executing the task to be executed in the target execution domain according to the global conversation context of the current user.

Further, the signal trigger performs job scheduling, and executes the task to be executed in the target execution domain according to the global dialog context of the current user, including: a new session (dialog) and a bound session, and the current dialog context (hidden domain) is searched from the global dialog context (sandbox domain of the current user) of the current user according to the print. Based on the above descriptions about hidden and sandboxed domains, the global dialog context of the current user is stored in the sandboxed domain of the user, and each dialog corresponds to a dialog context stored in the corresponding hidden domain. The print is generated by the engine and has a one-to-one binding relationship with the hidden domain, so that the print is a password for searching the hidden domain by the engine, and the hidden domain corresponding to the print can be searched from the sandbox domain of the current user according to the print. And under the condition that the hidden domain is searched, reusing the hidden domain, and under the condition that the hidden domain is not searched, newly building a hidden domain.

Among them, binding a session can be understood as: a semantic request is generated by an engine to generate a session, the session binds references of an executable scene script (schema), a sandbox domain, a signal domain and a label domain, binds hidden domain references multiplexed or generated by the engine, and binds a request domain, a response domain, a parameter domain and a service domain dynamically generated by the engine. The session is bound by the scope holder through a Thread Local variable (Thread Local) mechanism to the identity rid of the scope holder, and the successor of the scope holder searches the session quickly and conveniently from the global context through the rid. The engine maintains the relation between rid and time domain (session) through the Thread Local mechanism.

Further, the signal trigger performs job scheduling to execute each task in the target execution domain, and further includes: and performing task iteration and execution on the tasks to be executed in the target execution domain, wherein the task iteration and execution comprise sequential execution/return or ending/jumping. Specifically, by the task execution factory. In this application example, the task to be executed is a standard task. The execution condition set can perform condition determination and macro execution according to a plurality of existing IF expressions (nesting of no more than two layers can be supported). Wherein, during the macro execution process, the macro is searched by means of reference (using). When the execution result of the condition determination of the execution group is true (true), the execution group executes the standard task, such as executing a service (calling an API of an application in the system or an off-system service), executing evaluation according to the evaluation expression, and executing an action according to the condition. Performing actions includes performing assignments, performing NLGs, performing guidance, and the like. The NLG public key can be searched in a quoted mode, NLG is executed, a dialogue result is returned to the user, the guidance public key can be searched in a quoted mode, guidance is executed, and a guidance result is returned to the user.

After the task is executed, the data in the process is decoded, and the data is called back to the listener for caching, and then the session is unbound.

In yet another application example, the method may be used to perform simple tasks, as shown in FIG. 3. Specifically, when monitoring that the target signal satisfies the target trigger condition, the active engine notifies the target execution domain (observer) and submits the job to the signal trigger, so that the signal trigger performs job scheduling to execute each task in the target execution domain.

Further, the signal trigger performs job scheduling, and executes the task to be executed in the target execution domain according to the global dialog context of the current user, including: a new session (dialog) and a bound session, and the current dialog context (hidden domain) is searched from the global dialog context (sandbox domain of the current user) of the current user according to the print. Based on the above descriptions about hidden and sandboxed domains, the global dialog context of the current user is stored in the sandboxed domain of the user, and each dialog corresponds to a dialog context stored in the corresponding hidden domain. The print is generated by the engine and has a one-to-one binding relationship with the hidden domain, so that the print is a password for the engine to search the hidden domain, and the hidden domain corresponding to the print can be searched from the sandbox domain of the current user according to the print. And under the condition that the hidden domain is searched, reusing the hidden domain, and under the condition that the hidden domain is not searched, newly building a hidden domain.

Further, the signal trigger performs job scheduling to execute each task in the target execution domain, and the method further includes: and performing task iteration and execution on the tasks to be executed in the target execution domain, wherein the task iteration and execution comprise sequential execution/return or ending/jumping. Specifically, by the task execution factory. In this application example, the task to be executed is a simple task. If the valuation is performed according to the valuation expression, the action is performed according to the condition. Performing actions includes performing assignments, performing NLGs, performing boot, etc. The NLG public key can be searched in a reference mode, NLG is executed, a dialogue result is returned to the user, the guidance public key can be searched in the reference mode, guidance is executed, and a guidance result is returned to the user.

After the task is executed, the data in the process is decoded, and the data is called back to the listener for caching, and then the conversation is unbound.

According to the implementation method of the embodiment of the application, various data (such as vehicle data, user data, environment data and the like) in the use process of the vehicle can be comprehensively obtained, and after the data is abstracted (in the form of modal data), the data is classified (readable, writable, readable and writable) and stored in the action domain. Then, the service developer can arrange the modal data in the action domain according to the actual requirement to generate a functional unit (task to be executed); a plurality of functional units are arranged/combined to form a relatively complete service unit, and are classified and stored in the execution domain. Therefore, service developers can conveniently arrange various conversation logics according to actual requirements so as to realize corresponding active conversation scenes.

Compared with the prior art in which the dialogue logic is hard-coded and written down or configured through a form, in the execution method of the embodiment of the application, due to the fact that the design process of the business unit (dialogue logic) is disassembled, abstracted and modeled, the script language based on the XML can be obtained, and then the human-computer dialogue process suitable for the use habit of the user can be developed and iterated on line quickly based on the script language, so that the design of the business unit can be completed completely by a developer on line, and the business unit can be deployed to a vehicle end quickly through a heating updating operation channel.

In addition, the variable dialogue logic (the arrangement of domains) and the invariable execution engine are naturally isolated, and the iteration of the dialogue logic and the execution engine are not influenced mutually, so that the quick iteration of the dialogue logic can be facilitated.

An embodiment of the present application further provides an apparatus for executing a scene task, as shown in fig. 4, the apparatus includes:

a target signal determination module 401, configured to determine a target signal from a preset signal domain;

a monitoring module 402, configured to monitor a target signal according to a target trigger condition corresponding to the target signal;

a target execution domain determining module 403, configured to determine a target execution domain corresponding to the target signal when it is monitored that the target signal meets the target trigger condition;

and a task execution module 404, configured to execute the task to be executed in the target execution domain.

In one embodiment, as shown in fig. 5, the apparatus further comprises:

a registration module 501, configured to register an execution domain to which a task to be executed that has a signal monitoring requirement belongs to a signal domain;

the condition presetting module 502 is configured to preset a trigger condition for a signal to be monitored.

In one embodiment, as shown in fig. 5, the apparatus further comprises:

a notifying module 503, configured to notify the target execution domain when it is monitored that the target signal meets the target trigger condition before executing the task to be executed in the target execution domain.

In one embodiment, the task execution module 404 is specifically configured to: sending a task execution request to a scheduling thread pool so that the scheduling thread pool can acquire the global conversation context of the current user from the global conversation contexts of a plurality of users; and executing the task to be executed in the target execution domain according to the global conversation context of the current user.

The functions of the modules in the apparatuses in the embodiment of the present application may refer to the corresponding descriptions in the above methods, and are not described herein again.

Fig. 6 shows a block diagram of an electronic device according to an embodiment of the present application. As shown in fig. 6, the apparatus includes: a memory 601 and a processor 602, the memory 601 having stored therein instructions executable on the processor 602. The processor 602, when executing the instructions, implements any of the methods in the embodiments described above. The number of the memory 601 and the processor 602 may be one or more. The terminal or server is intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The terminal or server may also represent various forms of mobile devices, such as personal digital processing, cellular phones, smart phones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions, are meant to be examples only, and are not meant to limit implementations of the present application that are described and/or claimed herein.

The device may further include a communication interface 603 for communicating with an external device for data interactive transmission. The various devices are interconnected using different buses and may be mounted on a common motherboard or in other manners as desired. The processor 602 may process instructions for execution within the terminal or server, including instructions stored in or on a memory to display graphical information of a GUI on an external input/output device (such as a display device coupled to an interface). In other embodiments, multiple processors and/or multiple buses may be used, along with multiple memories and multiple memories, as desired. Also, multiple terminals or servers may be connected, with each device providing portions of the necessary operations (e.g., as an array of servers, a group of blade servers, or a multi-processor system). The bus may be divided into an address bus, a data bus, a control bus, etc. For ease of illustration, only one thick line is shown in FIG. 6, but this is not intended to represent only one bus or type of bus.

Optionally, in a specific implementation, if the memory 601, the processor 602, and the communication interface 603 are integrated on a chip, the memory 601, the processor 602, and the communication interface 603 may complete mutual communication through an internal interface.

It should be understood that the processor may be a Central Processing Unit (CPU), other general purpose processor, a Digital Signal Processor (DSP), an Application Specific Integrated Circuit (ASIC), a Field Programmable Gate Array (FPGA) or other Programmable logic device, discrete Gate or transistor logic, discrete hardware components, etc. A general purpose processor may be a microprocessor or any conventional processor or the like. It is noted that the processor may be an advanced reduced instruction set machine (ARM) architecture supported processor.

Embodiments of the present application provide a computer-readable storage medium (such as the above-mentioned memory 601), which stores computer instructions, and when executed by a processor, the program implements the method provided in the embodiments of the present application.

Optionally, the memory 601 may include a program storage area and a data storage area, wherein the program storage area may store an operating system and an application program required by at least one function; the storage data area may store data created according to the use of a terminal or a server, and the like. Further, the memory 601 may include high speed random access memory, and may also include non-transitory memory, such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid state storage device. In some embodiments, memory 601 may optionally include memory located remotely from processor 602, which may be connected to a terminal or server via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.

In the description of the present specification, reference to the description of "one embodiment," "some embodiments," "an example," "a specific example," or "some examples" or the like means that a particular feature, structure, material, or characteristic described in connection with the embodiment or example is included in at least one embodiment or example of the present application. Furthermore, the particular features, structures, materials, or characteristics described may be combined in any suitable manner in any one or more embodiments or examples. Furthermore, various embodiments or examples and features of different embodiments or examples described in this specification can be combined and combined by one skilled in the art without contradiction.

Furthermore, the terms "first", "second" and "first" are used for descriptive purposes only and are not to be construed as indicating or implying relative importance or to implicitly indicate the number of technical features indicated. Thus, a feature defined as "first" or "second" may explicitly or implicitly include at least one such feature. In the description of the present application, "a plurality" means two or more unless specifically limited otherwise.

Any process or method descriptions in flow charts or otherwise described herein may be understood as representing modules, segments, or portions of code which include one or more (two or more) executable instructions for implementing specific logical functions or steps in the process. And the scope of the preferred embodiments of the present application includes other implementations in which functions may be performed out of the order shown or discussed, including substantially concurrently or in reverse order, depending on the functionality involved.

The logic and/or steps represented in the flowcharts or otherwise described herein, such as an ordered listing of executable instructions that can be considered to implement logical functions, can be embodied in any computer-readable medium for use by or in connection with an instruction execution system, apparatus, or device, such as a computer-based system, processor-containing system, or other system that can fetch the instructions from the instruction execution system, apparatus, or device and execute the instructions.

It should be understood that portions of the present application may be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, various steps or methods may be implemented in software or firmware stored in a memory and executed by a suitable instruction execution system. All or part of the steps of the method of the above embodiments may be implemented by hardware that is configured to be instructed to perform the relevant steps by a program, which may be stored in a computer-readable storage medium, and which, when executed, includes one or a combination of the steps of the method embodiments.

In addition, functional units in the embodiments of the present application may be integrated into one processing module, or each unit may exist alone physically, or two or more units are integrated into one module. The integrated module can be realized in a hardware mode, and can also be realized in a software functional module mode. The above-described integrated module, if implemented in the form of a software functional module and sold or used as a separate product, may also be stored in a computer-readable storage medium. The storage medium may be a read-only memory, a magnetic or optical disk, or the like.

The above description is only for the specific embodiments of the present application, but the scope of the present application is not limited thereto, and any person skilled in the art can easily conceive various changes or substitutions within the technical scope of the present application, and these should be covered by the scope of the present application. Therefore, the protection scope of the present application shall be subject to the protection scope of the claims.

Claims

1. A method for executing a scene task, comprising:

determining a target signal from a preset signal domain;

monitoring the target signal according to a target trigger condition corresponding to the target signal;

determining a target execution domain corresponding to the target signal under the condition that the target signal is monitored to meet the target trigger condition;

and executing the task to be executed in the target execution domain.

2. The method of claim 1, further comprising:

registering an execution domain to which a task to be executed with a signal monitoring requirement belongs to the signal domain;

a trigger condition is preset for the signal to be monitored.

3. The execution method according to claim 1, wherein before executing the task to be executed in the target execution domain, further comprising:

and under the condition that the object signal is monitored to meet the object triggering condition, informing the object execution domain.

4. The execution method of claim 3, wherein executing the task to be executed in the target execution domain comprises:

5. An apparatus for executing a scenario task, comprising:

the target execution domain determining module is used for determining a target execution domain corresponding to the target signal under the condition that the target signal is monitored to meet the target triggering condition;

and the task execution module is used for executing the tasks to be executed in the target execution domain.

6. The executive device of claim 5, further comprising:

the registration module is used for registering an execution domain to which a task to be executed with a signal monitoring requirement belongs to the signal domain;

7. The execution apparatus of claim 5, further comprising:

and the notification module is used for notifying the target execution domain when a target signal is monitored to meet the target trigger condition before the task to be executed in the target execution domain is executed.

8. The execution device of claim 7, wherein the task execution module is specifically configured to:

9. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1 to 4.

10. A computer-readable storage medium, in which a computer program is stored which, when being executed by a processor, carries out the method according to any one of claims 1 to 4.