Dynamic scenario scheme configuration method and related device
Patent Information
- Authority / Receiving Office
- CN · China
- Patent Type
- Patents(China)
- Current Assignee / Owner
- ZKTECO CO LTD
- Filing Date
- 2024-06-20
- Publication Date
- 2026-06-26
Smart Images
Figure CN118445017B_ABST
Abstract
Description
Technical Field
[0001] This application relates to the field of system configuration technology, and in particular to a dynamic scenario configuration method and related equipment. Background Technology
[0002] In practical applications, to provide users with an immersive experience, dynamic scenes need to be generated in real time based on user interactions and actions. For example, during gameplay, the scene needs to constantly change with the game's progress and player behavior to maintain fun and challenge. Various scenes need to be dynamically generated to simulate realistic situations. Currently, the technologies commonly used for dynamic scene generation and management include hard-coded configuration files or using databases to store scene configuration information.
[0003] For example, many commercial software systems may use fixed-format JSON or XML files. These files are often created during system deployment and manually updated by developers or administrators when configuration changes are needed. Additionally, some systems may use databases to dynamically access scenario configuration information, with backend logic handling scenario changes. While these methods provide scenario configuration management to some extent, they typically require direct intervention from programmers or technical personnel to configure dynamic scenarios. Furthermore, updating scenario configurations often necessitates restarting the system or reloading the scenario configuration files, resulting in a lack of flexibility and significantly impacting system agility and responsiveness. Summary of the Invention
[0004] This application aims to at least solve one of the aforementioned technical defects. In view of this, this application provides a dynamic scene configuration method and related equipment to solve the technical defect in the prior art that makes it difficult to flexibly implement dynamic scene configuration.
[0005] A dynamic scene configuration method includes:
[0006] Based on the scenario configuration requirements, determine the first target scenario configuration file;
[0007] The first target scene configuration file is preprocessed to obtain the second target scene configuration file;
[0008] Based on the second scene configuration file, a user interface corresponding to the scene configuration requirements is dynamically generated;
[0009] The system monitors changes in scene configuration parameters of the generated user interface in real time and updates the scene configuration scheme of the generated user interface in real time based on the monitoring results.
[0010] Preferably, the preprocessing of the first target scene configuration file to obtain the second target scene configuration file includes:
[0011] Load the configuration file for the first target scene;
[0012] The first target scene configuration file is parsed, and the parsing result of the first target scene configuration file is used as the second target scene configuration file.
[0013] Preferably, the step of dynamically generating a user interface corresponding to the scene configuration requirements based on the second scene configuration file includes:
[0014] Based on the second target scene configuration file, construct the user interface components;
[0015] Based on the second target scenario configuration file, determine the scenarios where the user interface is available under the current conditions;
[0016] Based on the scenario configuration requirements and the scenarios available to the user interface under the current conditions, the display status of user interface elements is dynamically adjusted.
[0017] Preferably, the step of real-time monitoring of changes in the scene configuration parameters of the generated user interface and real-time updating the scene configuration scheme of the generated user interface based on the monitoring results includes:
[0018] Real-time monitoring of changes in scene configuration parameters of the generated user interface, and identification of scene configuration parameters that have changed in the generated user interface;
[0019] Based on the changed scene configuration parameters in the generated user interface, the second target scene configuration file is reloaded to obtain the third target scene configuration file;
[0020] The user interface is reconfigured based on the third target scene configuration file to build a new scene.
[0021] Preferably, the step of real-time monitoring of changes in the scene configuration parameters of the generated user interface and real-time updating the scene configuration scheme of the generated user interface based on the monitoring results includes:
[0022] Real-time monitoring of changes in scene configuration parameters of the generated user interface, and identification of scene configuration parameters that have changed in the generated user interface;
[0023] Context analysis is performed on the scene configuration parameters that have changed in the generated user interface to obtain the analysis results of the scene configuration parameters that have changed in the generated user interface.
[0024] Based on the analysis results of the changed scene configuration parameters in the generated user interface, adjust the generated user interface.
[0025] Preferably, the method further includes:
[0026] Display visual interface elements so that users can choose whether to manually trigger the scene configuration update operation.
[0027] Preferably, the method further includes:
[0028] Based on the changes in scene configuration parameters in the generated user interface, the configuration of the same scene on different platforms is synchronized.
[0029] Provide feedback on scene updates to the user interface.
[0030] A dynamic scene configuration device, comprising:
[0031] The determination unit is used to determine the first target scenario configuration file based on the scenario configuration requirements;
[0032] The preprocessing unit is used to preprocess the first target scene configuration file to obtain the second target scene configuration file;
[0033] The configuration unit is used to dynamically generate a user interface corresponding to the scenario configuration requirements based on the second scenario configuration file.
[0034] The update unit is used to monitor changes in the scene configuration parameters of the generated user interface in real time, and update the scene configuration scheme of the generated user interface in real time based on the monitoring results.
[0035] A dynamic scene configuration device includes: one or more processors, and a memory;
[0036] The memory stores computer-readable instructions, which, when executed by the one or more processors, implement the steps of the dynamic scene scheme configuration method as described above.
[0037] A readable storage medium storing computer-readable instructions, which, when executed by one or more processors, cause the one or more processors to perform the steps of the dynamic scene scheme configuration method as described above.
[0038] As can be seen from the above-described technical solutions, when dynamic scenario configuration is required, the method provided in this application embodiment can determine a first target scenario configuration file based on scenario configuration requirements. The first target scenario configuration file can include relevant information for scenario configuration. Therefore, the required scenario can be efficiently configured based on the first target scenario configuration file. However, in practical applications, the first target scenario configuration file may not be directly loaded for scenario configuration. Therefore, after determining the first target scenario configuration file, it can be further preprocessed to obtain a second target scenario configuration file. Then, based on the second scenario configuration file, a user interface corresponding to the scenario configuration requirements can be dynamically generated. Furthermore, in practical applications, the already configured scenario may change due to user needs or scenario changes. Therefore, the method provided in this application embodiment can also monitor changes in the scenario configuration parameters of the generated user interface in real time. Changes in the scenario configuration parameters of the user interface will cause changes in the scenario. Therefore, the scenario configuration scheme of the generated user interface can be updated in real time based on the monitoring results.
[0039] As described above, when dynamic scenario configuration is required, the method provided in this application embodiment can define scenario parameters by creating a configuration file, which offers greater flexibility than traditional hard-coding methods. Users can directly update or add new scenario configurations in the scenario configuration file without code changes, making system maintenance and upgrades more convenient and faster. This is more convenient than traditional methods that require recompiling and deploying the application. Furthermore, it supports real-time updates of scenario configurations. Any changes read from the scenario configuration file are immediately reflected in the user interface without restarting the application or reloading the entire page. This is particularly advantageous in application scenarios requiring rapid response to environmental changes. Furthermore, this application can dynamically enable or disable specific scenarios by evaluating factors such as the user's geographical location and language preferences, providing a more personalized user experience. Customized interfaces and functions can be provided for different user groups, thereby improving user satisfaction and system efficiency. It allows non-developers to directly configure scenarios through the scenario configuration file, reducing reliance on professional development resources and lowering development and maintenance costs. In addition, since configuration updates take effect immediately, system downtime and related operating costs are reduced. Furthermore, the method provided in this application embodiment ensures high modularity and scalability. As business needs grow, new scenarios can be easily added to the XML configuration file without modifying existing system code. This design supports long-term business development and can easily adapt to future technological changes. Furthermore, because scenarios can be dynamically adjusted based on user language and region settings, the method provided in this application is particularly suitable for multilingual and multi-regional deployments. It allows the same system to be deployed globally without creating different versions for each region or language, greatly improving deployment efficiency and market coverage. Attached Figure Description
[0040] To more clearly illustrate the technical solutions in the embodiments of this application or the prior art, the drawings used in the description of the embodiments or the prior art will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.
[0041] Figure 1 A flowchart illustrating a method for configuring dynamic scene schemes provided in this application embodiment;
[0042] Figure 2 This is a schematic diagram of a dynamic scene configuration device as exemplified in an embodiment of this application;
[0043] Figure 3This is a hardware structure block diagram of a dynamic scene scheme configuration device disclosed in an embodiment of this application. Detailed Implementation
[0044] The technical solutions of the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.
[0045] In practical applications, many commercial software systems, such as video surveillance systems and smart home systems, typically use fixed-format JSON or XML files. These files are created during system deployment and manually updated by developers or administrators when scene configurations need to be modified. Additionally, some systems may use databases to dynamically store scene configuration information, using backend logic to handle changes in dynamic scenes. While these methods provide scene configuration management capabilities to some extent, they usually require direct intervention from programmers or technical personnel, and updating scene configurations often necessitates restarting the system or reloading the scene configuration files, significantly impacting system flexibility and responsiveness.
[0046] In traditional scenario configuration management methods, such as hard-coded or database-based solutions, modifications to scenarios once deployed often involve complex program changes or database operations. These methods lack flexibility and cannot quickly adapt to changes in the runtime environment or users' immediate needs. For applications that require frequent updates to scenario configurations, traditional methods typically involve cumbersome deployment processes. For example, modifying JSON or XML configuration files may require manually reloading these files or restarting the service, which is not only time-consuming but may also cause service interruptions.
[0047] In most traditional scene management systems, user interaction capabilities are limited by preset scene configurations. Users cannot dynamically adjust scenes based on personal preferences or specific conditions, such as geographical location or language used, which restricts user experience and the applicability of the application.
[0048] In practical applications, existing scenario configuration methods often require professional technicians to configure and update scenarios, increasing the cost and complexity of system maintenance. For non-technical users, this method has a relatively high technical threshold, making it inconvenient for ordinary administrators or end users to manage scenario settings themselves.
[0049] Given that most current dynamic scenario configuration solutions struggle to adapt to complex and ever-changing business needs, this application proposes a dynamic scenario configuration scheme. When dynamic scenario configuration is required, the method provided in this application allows defining scenario parameters through a configuration file, offering greater flexibility than traditional hard-coding methods. Users can update or add new scenario configurations directly in the scenario configuration file without code changes, making system maintenance and upgrades more convenient and efficient. This is significantly more convenient than traditional methods that require recompiling and deploying the application. Furthermore, it supports real-time updates of scenario configurations. Any changes read from the scenario configuration file are immediately reflected in the user interface without restarting the application or reloading the entire page. This is particularly advantageous in application scenarios requiring rapid response to environmental changes. Furthermore, this application can dynamically enable or disable specific scenarios by evaluating factors such as the user's geographical location and language preferences, providing a more personalized user experience. Customized interfaces and functions can be provided for different user groups, thereby improving user satisfaction and system efficiency. It allows non-developers to configure scenarios directly through the scenario configuration file, reducing reliance on professional development resources and lowering development and maintenance costs. Furthermore, since configuration updates take effect immediately, system downtime and related operational costs are reduced. Moreover, the method provided in this application embodiment ensures high modularity and scalability. As business needs grow, new scenarios can be easily added to the XML configuration file without modifying existing system code. This design supports long-term business development and can easily adapt to future technological changes; furthermore, since scenarios can be dynamically adjusted based on user language and regional settings, the method provided in this application embodiment is particularly suitable for multilingual and multi-regional deployments. It allows the same system to be deployed globally without creating different versions for each region or language, greatly improving deployment efficiency and market coverage.
[0050] The methods provided in this application can be used in a variety of general-purpose or special-purpose computing device environments or configurations. For example: personal computers, server computers, handheld or portable devices, tablet devices, multiprocessor devices, distributed computing environments including any of the above devices, etc.
[0051] This application provides a dynamic scene configuration method, which can be applied to various scene configuration systems, as well as to various computer terminals or smart terminals. The execution entity can be the processor or server of the computer terminal or smart terminal.
[0052] The following is combined with Figure 1 This document describes the process of configuring a dynamic scene scheme according to embodiments of this application, such as... Figure 1As shown, the process may include the following steps:
[0053] Step S101: Determine the first target scenario configuration file based on the scenario configuration requirements.
[0054] Specifically, in practical applications, different user groups may have different needs for scene configuration. In order to dynamically complete scene configuration according to different scene configuration requirements, we can consider creating corresponding scene configuration files based on scene configuration requirements, so that different scene configuration files can be configured according to different user needs, thereby realizing dynamic configuration of different scenes.
[0055] The first target scenario configuration file may include scenario configuration information corresponding to the scenario configuration requirements. For example, the first target scenario configuration file may include at least one scenario configuration parameter.
[0056] For example, the first target scene configuration file may include information about scene elements, including a unique identifier for each scene, a readable name for each scene, the path to the main image for each scene, the path to the title image for each scene, a brief description of the functions of each scene, and the conditions for starting or disabling the scene.
[0057] Therefore, the process of determining the first target scenario configuration file based on scenario configuration requirements can be as follows:
[0058] Create a target format file, which may include information about scene elements, including a unique identifier for each scene, a readable name for each scene, the path to the main image for each scene, the path to the title image for each scene, a brief description of the function of each scene, and the conditions for starting or disabling the scene.
[0059] The target format can be XML. XML stands for Extensible Markup Language, a markup language format. XML format files have the following characteristics:
[0060] 1. Self-descriptive: It can clearly describe the structure and meaning of the data.
[0061] 2. Structured: Organizing data in a hierarchical manner.
[0062] 3. Platform independence: It can be used on different operating systems and programming languages.
[0063] 4. Scalability: Allows users to define their own tags according to specific needs.
[0064] XML format files can typically be used in the following scenarios:
[0065] 1. Data exchange: Transferring and sharing data between different systems.
[0066] 2. Configuration file: Stores the application's configuration information.
[0067] 3. Document Format: Defines the document structure for a specific type.
[0068] XML format can provide a standardized and flexible way to represent and transmit data.
[0069] Therefore, in practical applications, scene configuration files in XML format can be created according to scene configuration requirements, so that the scene can be dynamically configured based on the created XML format file.
[0070] For example, you can create a file named scene-config.xml in an appropriate directory on the server, such as / config, or in your local development environment, and define some scene elements in that file. For example, you can define the following scene elements in a file named scene-config.xml:
[0071] (1) <code>: A unique identifier for each scene. The unique identifier for a scene is generally used for internal reference within the program.
[0072] (2) <name>: A human-readable name for the scene, primarily used for display on the interface.
[0073] (3) <sceneimg>The main image path of the scene, used for the visual presentation of the interface.
[0074] (4) <titleimg>: The path to the scene's title image, used for display in lists or menus.
[0075] (5) <description>A detailed description of the scene's function helps users understand its purpose.
[0076] (6) <condition>It supports complex logic definitions based on multiple conditions, such as language, geolocation, time, user permission level, and device type.
[0077] The first target configuration file can include relevant information about the various scene elements as described above.
[0078] For example, an embodiment of this application provides a scenario configuration file example of using AI intelligent analysis capabilities to quickly retrieve targets based on personnel characteristics; and simultaneously using face detection and dynamic face database search, combined with GIS positioning to achieve personnel trajectory tracking:
[0079] xml
[0080] <sceneitems>
[0081] <sceneitem>
[0082] <code> faceSearch< / code>
[0083] <name> Target retrieval< / name>
[0084] <skip> sceneCenter_faceSearchScene< / skip>
[0085] <sceneimg> / images / scene / img.png< / sceneimg>
[0086] <titleimg> / images / scene / faceSearch.png< / titleimg>
[0087] <description>
[0088] Utilizing AI intelligent analysis capabilities, it can quickly retrieve targets based on personnel characteristics; at the same time, based on face detection and dynamic face database search, combined with GIS positioning, it can track personnel trajectories.
[0089] < / description>
[0090] <condition> location == 'city_center'< / condition>
[0091] < / sceneitem>
[0092] < / sceneitems> .
[0093] For example, when designing a configuration system based on XML scene configuration files, the structure and description of configuration nodes are very important. The following is an example of the node structure and description of a scene-config.xml file from an embodiment of this application:
[0094] (1) Root node:
[0095] • <sceneitems>This is the root node, which contains a collection of all scene items.
[0096] (2) Child nodes:
[0097] • <sceneitem>: Represents a configuration item for a single scene. Each scene item includes the following child nodes:
[0098] • <code>A unique identifier or code for a scene, used to reference a specific scene in the system.
[0099] • <name>The display name of the scene, used to display it in the user interface.
[0100] • <skip>: Identifiers used when a scene needs to jump to other specific scenes or functions.
[0101] • <sceneimg>: Image file paths related to the scene, used to enhance the visual presentation of the scene in the user interface.
[0102] • <titleimg>The image file path for the scene title, used for displaying the scene selection interface.
[0103] • <description>A detailed description of the scene's function and purpose helps users understand the scene's role.
[0104] • <condition>Define the conditions for enabling or disabling scenarios, such as based on language, geographical location, etc.
[0105] Step S102: Preprocess the first target scene configuration file to obtain the second target scene configuration file.
[0106] Specifically, in practical applications, file formats from different systems or applications may be incompatible. To ensure the compatibility of the scenario configuration file, or to remove unnecessary information, correct erroneous data formats, or make the data structure more suitable for subsequent processing, after determining the first target scenario configuration file, it can be preprocessed. This allows for the selection of truly important parts of the configuration file, enabling more efficient use of its content. Alternatively, it can be customized according to the specific target scenario, such as adding, deleting, or modifying certain parameters to meet specific operating conditions or functional requirements. In some special application scenarios, it may be necessary to merge multiple related configuration files, split a large configuration file into more manageable parts, or perform security-related processing on the first target scenario configuration file, such as encrypting sensitive information or adjusting access permission settings. Therefore, preprocessing makes the structure of the first target configuration file clearer and its logic more reasonable, facilitating subsequent management and maintenance. After preprocessing the first target scenario configuration file, the second target scenario configuration file can be obtained.
[0107] For example, the scene configuration file in XML format created above can be dynamically loaded: for example, XMLHttpRequest can be used to request the scene-config.xml file from the server, and it needs to be ensured that the requested processing logic can include the handling of various states, such as successful loading, error handling, etc.
[0108] After dynamically loading the created XML-formatted scene configuration file, you can use DOMParser to parse the XML-formatted scene configuration file to obtain the XML text. After parsing, you can transform the parsed XML text into easily manipulated JavaScript objects or structures, such as objects that use scene codes as keys.
[0109] Step S103: Based on the second scene configuration file, dynamically generate a user interface corresponding to the scene configuration requirements.
[0110] Specifically, as described above, the method provided in this application embodiment can preprocess the created first target scene configuration file to obtain a second target scene configuration file, which may include scene configuration information created according to scene configuration requirements.
[0111] For example, the second target scene configuration file may include information about the layout and hierarchy of scene elements. The second target scene configuration file clarifies the position and interrelationship of each user interface component and describes various attributes of scene elements, such as size, color, and font. These attributes determine the appearance and style of the user interface. The second target scene configuration file may also contain functional settings related to scene elements. For example, it may include the operation or event response corresponding to a certain button, thereby giving the user interface specific interactive capabilities. Through the second target scene configuration file, data can be associated with scene elements to ensure that the user interface can correctly display and process the relevant data.
[0112] Therefore, after determining the second target scenario configuration file, a user interface corresponding to the scenario configuration requirements can be dynamically generated based on the second target scenario configuration file. Furthermore, the user interface can be flexibly adjusted and customized by modifying the second target scenario configuration file without large-scale code modifications, thus improving development efficiency and maintainability.
[0113] Step S104: Monitor the changes in the scene configuration parameters of the generated user interface in real time, and update the scene configuration scheme of the generated user interface in real time based on the monitoring results.
[0114] Specifically, in practical applications, user needs may change dynamically, and the scene configuration requirements of the user interface may also change dynamically. To ensure that the scene can be updated in real time according to changes in scene configuration requirements, it is necessary to monitor changes in user interface scene layout parameters in real time. This ensures that changes caused by user operations or external factors are immediately reflected on the interface, providing real-time feedback to users and improving the interactive experience. The interface can dynamically adapt to different situations and conditions, such as different device states and network environments, to ensure consistency between the interface display and the actual state throughout the system, avoiding discrepancies between the displayed and actual conditions. It also allows for timely adjustment of resource allocation and rendering strategies based on parameter changes, improving system efficiency and performance. Furthermore, it enables the timely detection and handling of abnormal parameter changes, reducing potential errors and failures. Additionally, it allows for flexible adjustments based on user needs or specific scenarios, enhancing the system's customizability. Moreover, relevant functional modules can obtain the latest interface status information in a timely manner, thus enabling better collaboration.
[0115] Therefore, in practical applications, the changes in the scene configuration parameters of the generated user interface can be monitored in real time, and the scene configuration scheme of the generated user interface can be updated in real time based on the monitoring results, so that the scene can be configured in real time according to the scene configuration requirements.
[0116] In practical applications, to achieve real-time monitoring of changes in scene configuration parameters on the user interface and real-time updates to the scene configuration scheme, the following steps can be taken:
[0117] 1. Establish a monitoring mechanism: Use appropriate technologies or frameworks to monitor changes in relevant parameters, such as event listening and data binding.
[0118] 2. Trigger an update event: When a change in parameters is detected, an update event is triggered.
[0119] 3. Data processing: Obtain the changed parameter values and perform corresponding processing and transformation to adapt to the needs of the scenario configuration.
[0120] 4. Update configuration data: Modify the relevant data in the scene configuration file based on the processed parameter values.
[0121] 5. Notification of UI Refresh: Sends a notification to the system or framework that generates the user interface, informing it that the interface needs to be re-rendered to reflect the new configuration.
[0122] 6. Interface Regeneration: Based on the updated scene configuration scheme, regenerate the user interface to display the new scene layout.
[0123] In practice, this may involve various technologies and tools, including programming languages, front-end frameworks, and data communication, to ensure real-time performance and accuracy. Simultaneously, performance optimization and exception handling must be considered to guarantee the stable operation of the entire system.
[0124] For example, in practical applications, changes in key scenario configuration parameters can be monitored, such as changes in location or language. Machine learning algorithms can then be used to trigger context-aware adjustments to these key scenario configuration parameters, automatically resetting the scenario configuration.
[0125] Alternatively, when a change in key scenario configuration parameters is detected, the process of reloading the XML scenario configuration file can be automatically triggered, and the updated XML scenario configuration file can be parsed and the interface elements refreshed to reflect the new configuration.
[0126] As can be seen from the above-described technical solutions, when dynamic scenario configuration is required, the method provided in this application embodiment can define scenario parameters by creating a configuration file, which offers greater flexibility than traditional hard-coding methods. Users can directly update or add new scenario configurations in the scenario configuration file without code changes, making system maintenance and upgrades more convenient and faster. This is more convenient than traditional methods that require recompiling and deploying the application. Furthermore, it supports real-time updates of scenario configurations. Any changes read from the scenario configuration file are immediately reflected on the user interface without restarting the application or reloading the entire page. This is particularly advantageous in application scenarios requiring rapid response to environmental changes. Furthermore, this application can dynamically enable or disable specific scenarios by evaluating factors such as the user's geographical location and language preferences, providing a more personalized user experience. Customized interfaces and functions can be provided for different user groups, thereby improving user satisfaction and system efficiency. It allows non-developers to directly configure scenarios through the scenario configuration file, reducing reliance on professional development resources and lowering development and maintenance costs. In addition, since configuration updates take effect immediately, system downtime and related operating costs are reduced. Furthermore, the method provided in this application embodiment ensures high modularity and scalability. As business needs grow, new scenarios can be easily added to the XML configuration file without modifying existing system code. This design supports long-term business development and can easily adapt to future technological changes. Furthermore, because scenarios can be dynamically adjusted based on user language and region settings, the method provided in this application is particularly suitable for multilingual and multi-regional deployments. It allows the same system to be deployed globally without creating different versions for each region or language, greatly improving deployment efficiency and market coverage.
[0127] As can be seen from the technical solutions described above, the method provided in this application embodiment can preprocess the first target scene configuration file to obtain a second target scene configuration file. The process will be described below, and it may include the following:
[0128] Step S201: Load the first target scene configuration file.
[0129] Specifically, as described above, the first target scenario configuration file includes scenario configuration information corresponding to the scenario configuration requirements. In order to understand this scenario configuration information, the first target scenario configuration file can be loaded.
[0130] Loading the configuration file for the first target scene will yield the following important information:
[0131] 1. Interface layout structure: Clearly define the position and organization of each scene element (such as buttons, text boxes, images, etc.).
[0132] 2. Element attributes: such as the element's size, color, font, style and other detailed attribute information.
[0133] 3. Interaction rules: including the triggering conditions of various events and the corresponding operations or responses.
[0134] 4. Data Association: Configuration related to data, such as data source and data mapping relationships, to ensure correct display and processing of data.
[0135] 5. Functional module configuration: Parameter settings and activation status of relevant functional modules.
[0136] 6. Permission settings: Permission rules for different users or roles in this scenario.
[0137] 7. Dynamic effects configuration: such as settings for animation effects, transition effects, etc.
[0138] 8. Scenario-specific rules and constraints: Ensure that the scenario operates and behaves as expected.
[0139] Step S202: Parse the first target scene configuration file to obtain the parsing result of the first target scene configuration file as the second target scene configuration file.
[0140] Specifically, as described above, loading the first target scene configuration file allows you to learn some important scene configuration information. Furthermore, if you need to learn more detailed scene configuration information, you may need to further parse the first target scene configuration file after loading it, so as to obtain the parsing result of the first target scene configuration file and use it as the second target scene configuration file.
[0141] The following content can be obtained by parsing the configuration file of the first target scene:
[0142] 1. Definition of UI elements: such as the types and names of various controls and components.
[0143] 2. Layout information: including the arrangement of elements, hierarchical relationships, etc.
[0144] 3. Style attributes: such as color, font, size and other appearance attributes.
[0145] 4. Behavioral rules: the interactive actions of elements, event response methods, etc.
[0146] 5. Data association information: data binding relationships, data processing rules, etc.
[0147] 6. Condition settings: Display or behavior configuration under specific conditions.
[0148] 7. Resource references: such as the paths or identifiers of resources like images and fonts.
[0149] 8. Permission configuration details: Permission rules for different roles or users.
[0150] 9. Dynamic parameters: Some parameter values that can be dynamically adjusted to achieve dynamic effects or adaptive adjustments.
[0151] As can be seen from the technical solutions described above, after determining the first target scene configuration file, in order to determine detailed and specific scene configuration information, the method provided in this application embodiment can preprocess the first target scene configuration file to obtain the second target scene configuration file, thereby allowing for more information about the scene configuration requirements.
[0152] As can be seen from the technical solutions described above, the method provided in this application embodiment can dynamically generate a user interface corresponding to the scene configuration requirements based on the second scene configuration file. The process will be described below, and it may include the following:
[0153] Step S301: Construct user interface components based on the second target scene configuration file.
[0154] Specifically, as described above, the method provided in this application embodiment can obtain a second target scene configuration file by loading and parsing a first scene configuration file. The second target scene configuration file is scene configuration information created based on user needs.
[0155] To ensure that user interfaces built under different circumstances adhere to unified specifications and designs, maintaining overall consistency, after determining the second target scenario configuration file, user interface components can be built based on this configuration file. This helps avoid repetitive manual coding to create interface components, allowing for rapid generation directly from the configuration file, saving development time. Furthermore, the interface can be flexibly adjusted according to different scenarios and needs without large-scale code modifications; customization can be achieved simply by changing the configuration file. Moreover, when modifications or updates to the interface are needed, only adjustments to the configuration file are required, reducing maintenance difficulty and costs. It can also quickly adapt to various usage scenarios and business requirements, improving the system's adaptability and versatility.
[0156] Therefore, the scene configuration can be well completed through the second target scene configuration file.
[0157] For example, in practical applications, a second target scenario configuration file can be read and parsed to extract information such as the type, attributes, and position of the interface components. Based on this parsed information, corresponding interface component objects, such as buttons and text boxes, can be created in the programming environment, and their attributes, such as size, color, and text content, can be set. These components are then organized and arranged according to the layout specified in the second target scenario configuration file. Interaction relationships between components, such as event listeners and response handling, are established to achieve the corresponding functions. During the construction of interface components, it may be necessary to continuously adjust and refine them based on the details in the configuration file until a user interface component that meets the requirements is finally constructed.
[0158] Step S302: Based on the second target scenario configuration file, determine the scenarios available to the user interface under the current conditions.
[0159] Specifically, as described above, the second target configuration file may include information about complex logical definitions of multiple condition combinations, such as information related to user permission boundaries.
[0160] Therefore, after determining the second target scenario configuration file, the scenarios available to the user interface under the current conditions can be determined based on the second target scenario configuration file, so that the user interface can be configured according to the scenarios available to the user interface under the current conditions.
[0161] Step S303: Based on the scenario configuration requirements and the scenarios available to the user interface under the current conditions, dynamically adjust the display status of the user interface elements.
[0162] Specifically, as described above, the method provided in this application embodiment can construct user interface components based on a second target configuration file and determine the scenarios that the user interface can use under the current conditions based on the second target scenario configuration file. Therefore, after determining the scenarios that the user interface can use under the current conditions, the display state of user interface elements can be dynamically adjusted according to the scenario configuration requirements and the scenarios that the user interface can use under the current conditions, so as to dynamically generate a scenario corresponding to the scenario configuration requirements, thereby forming a user interface.
[0163] For example, in practical applications, user interface components such as buttons, image displays, and descriptive text can be created based on scenario configuration requirements. Conditional logic is used to determine which scenarios are available or displayed under the current conditions; this logic can be obtained from parsed XML text. Real-time visual feedback can be implemented, such as charts displaying system status and scenario configuration effects. The display status of interface elements can also be dynamically adjusted based on user language settings, geographical location, and other conditions. Users can also customize scenario configuration parameters through a graphical interface, such as adding custom conditions, selecting specific images, or editing descriptions.
[0164] As can be seen from the technical solutions described above, the method provided in this application embodiment can construct user interface components based on the second target configuration file, determine the scenarios that the user interface can use under the current conditions based on the second target scenario configuration file, and dynamically adjust the display state of user interface elements according to scenario configuration requirements to achieve dynamic configuration of the scenario. It can display only relevant elements according to the user's current operation scenario or needs, reduce interference, and allow the user to focus more on important information. It can avoid the interface from appearing cluttered due to too many irrelevant elements, making the interface clearer and cleaner. It can ensure that users can quickly find the required elements in specific scenarios, improving operational efficiency. For example, on mobile devices and desktop devices, the display state can be flexibly adjusted according to scenario requirements to better adapt to different usage environments. Unnecessary elements can be not displayed, reducing resource consumption. The display state can be dynamically adjusted according to different user preferences or roles to provide personalized services. When scenario requirements change, the state of interface elements can be quickly adjusted to maintain the timeliness and adaptability of the system. The element display state can be managed through configuration instead of modifying multiple places in the code, which is convenient for subsequent maintenance and updates.
[0165] As can be seen from the technical solutions described above, the method provided in this application embodiment can monitor the changes in scene configuration parameters of the generated user interface in real time, and update the scene configuration scheme of the generated user interface in real time based on the monitoring results. The following describes one implementation of this process, which may include the following:
[0166] Step S401: Monitor the changes in scene configuration parameters of the generated user interface in real time, and determine the scene configuration parameters that have changed in the generated user interface.
[0167] Specifically, in practical applications, scenario configuration parameters typically include the following common parameters:
[0168] 1. Layout parameters: such as the position, size, and arrangement of interface elements.
[0169] 2. Color parameters: background color, element color, etc.
[0170] 3. Font parameters: font type, size, color, etc.
[0171] 4. Image parameters: Image resource path, etc.
[0172] 5. Interaction parameters: such as the response method for click events.
[0173] 6. Data association parameters: Information related to binding with specific data.
[0174] 7. Visibility parameter: Whether an element is visible and the display conditions.
[0175] 8. Animation parameters: type of animation effect, speed, etc.
[0176] 9. Permission parameters: Permission settings for different users or roles.
[0177] 10. Status parameters: such as the enabled / disabled status of an element.
[0178] 11. Component parameters: Properties of a specific component, such as the number of rows in a list.
[0179] 12. Network-related parameters: such as connection settings, etc.
[0180] 13. Performance parameters: such as rendering quality, resource loading strategy, etc.
[0181] In practical applications, one or more of the above-mentioned scenario configuration parameters may change at different stages. When the scenario configuration parameters change, the scenario may change. Therefore, in order to achieve dynamic adjustment of the scenario, in practical applications, the changes in the scenario configuration parameters of the generated user interface can be monitored in real time, and the changed scenario configuration parameters in the generated user interface can be determined so that the scenario can be dynamically adjusted based on the changed scenario configuration parameters in the generated user interface.
[0182] In practical applications, a polling mechanism can be used to periodically read the scenario configuration file and compare it with previous versions to identify changed parameters. File monitoring mechanisms provided by the operating system or programming language can be utilized to receive timely notifications when the configuration file changes. Alternatively, a data structure or object associated with the configuration file can be established to continuously track its state at runtime, immediately detecting any parameter changes. Specialized configuration management frameworks or tools can also be used, as they typically have real-time monitoring and notification capabilities. After detecting changes, the differences between the before and after configuration data can be compared to determine the changed scenario configuration parameters. Specific identifiers or tags can also be set for each parameter to quickly pinpoint the specific changed parameter when a change is detected.
[0183] Step S402: Based on the changed scene configuration parameters in the generated user interface, reload the second target scene configuration file to obtain the third target scene configuration file.
[0184] Specifically, as described above, the method provided in this application embodiment can monitor the changes in scene configuration parameters of the generated user interface in real time and determine the scene configuration parameters that have changed in the generated user interface. The changes in scene configuration parameters in the generated user interface indicate that the corresponding scene configuration needs to be adjusted. Therefore, after determining the changes in scene configuration parameters in the generated user interface, the second target scene configuration file can be reloaded based on the changes in scene configuration parameters in the generated user interface to adjust the corresponding scene configuration parameters in the second target scene configuration file, thereby obtaining the third target scene configuration file.
[0185] Step S403: Reconfigure the user interface according to the third target scene configuration file to build a new scene.
[0186] Specifically, as described above, the method provided in this application embodiment can reload the second target scene configuration file to determine the third target scene configuration file based on the changed scene configuration parameters in the generated user interface. Therefore, the third target scene configuration file includes specific information after the scene configuration parameters are updated. Thus, after obtaining the third target scene configuration file, the user interface can be reconfigured based on the third target scene configuration file to construct a new scene.
[0187] As can be seen from the technical solutions described above, the method provided in this application can monitor changes in the scene configuration parameters of the generated user interface in real time and update the scene configuration scheme of the generated user interface in real time based on the monitoring results. It can quickly respond to changes in different scene requirements, ensuring the system always maintains optimal adaptability. It ensures the user interface always conforms to the user's current operating environment and expectations, providing a smoother and more consistent experience. It eliminates the need for frequent manual code modifications to adapt to changes; automatic updates of configuration parameters are sufficient, reducing labor costs. Real-time adjustments avoid the adverse effects of delays, allowing the system to keep up with actual conditions. It allows for personalized customization and expansion in different scenarios to meet various special needs, avoiding interface anomalies caused by untimely or incorrect manual modifications, enhancing system stability. Non-technical personnel can also participate in interface optimization by adjusting configuration parameters, promoting cross-professional collaboration. New scene configuration schemes can be quickly applied to the user interface, accelerating the speed of feature rollout and adjustments.
[0188] As can be seen from the technical solutions described above, the method provided in this application embodiment can monitor the changes in scene configuration parameters of the generated user interface in real time, and update the scene configuration scheme of the generated user interface in real time based on the monitoring results. The following describes another implementation of this process, which may include the following:
[0189] Step S501: Monitor the changes in scene configuration parameters of the generated user interface in real time, and determine the scene configuration parameters that have changed in the generated user interface.
[0190] Specifically, in practical applications, scenario configuration parameters typically include the following common parameters:
[0191] 1. Layout parameters: such as the position, size, and arrangement of interface elements.
[0192] 2. Color parameters: background color, element color, etc.
[0193] 3. Font parameters: font type, size, color, etc.
[0194] 4. Image parameters: Image resource path, etc.
[0195] 5. Interaction parameters: such as the response method for click events.
[0196] 6. Data association parameters: Information related to binding with specific data.
[0197] 7. Visibility parameter: Whether an element is visible and the display conditions.
[0198] 8. Animation parameters: type of animation effect, speed, etc.
[0199] 9. Permission parameters: Permission settings for different users or roles.
[0200] 10. Status parameters: such as the enabled / disabled status of an element.
[0201] 11. Component parameters: Properties of a specific component, such as the number of rows in a list.
[0202] 12. Network-related parameters: such as connection settings, etc.
[0203] 13. Performance parameters: such as rendering quality, resource loading strategy, etc.
[0204] In practical applications, one or more of the above-mentioned scenario configuration parameters may change at different stages. When the scenario configuration parameters change, the scenario may change. Therefore, in order to achieve dynamic adjustment of the scenario, in practical applications, the changes in the scenario configuration parameters of the generated user interface can be monitored in real time, and the changed scenario configuration parameters in the generated user interface can be determined so that the scenario can be dynamically adjusted based on the changed scenario configuration parameters in the generated user interface.
[0205] In practical applications, a polling mechanism can be used to periodically read the scenario configuration file and compare it with previous versions to identify changed parameters. File monitoring mechanisms provided by the operating system or programming language can be utilized to receive timely notifications when the configuration file changes. Alternatively, a data structure or object associated with the configuration file can be established to continuously track its state at runtime, immediately detecting any parameter changes. Specialized configuration management frameworks or tools can also be used, as they typically have real-time monitoring and notification capabilities. After detecting changes, the differences between the before and after configuration data can be compared to determine the changed scenario configuration parameters. Specific identifiers or tags can also be set for each parameter to quickly pinpoint the specific changed parameter when a change is detected.
[0206] In practical applications, a mapping relationship can be established between scene configuration parameters and interface elements to monitor changes in the scene configuration parameters corresponding to the interface elements. When scene configuration parameters change, it can be checked whether related interface elements are directly affected; for example, changes in size parameters will affect the size of elements. The state of the user interface before and after changes in scene configuration parameters can also be compared to understand whether the scene configuration parameters have changed. If the attributes, positions, visibility, etc., of certain elements have changed, it indicates an impact. Monitoring points can be set for key scene configuration parameters, and when these parameters change, the corresponding interface elements can be actively checked for corresponding changes. Simulation tests can be conducted, running the user interface under different parameter configurations and observing the changes to determine if an impact has occurred. The function and purpose of the parameters can be analyzed to determine whether their changes might lead to changes in the interface presentation. Visualization tools or debugging methods can also be used to intuitively view the differences in the user interface before and after parameter changes to assess the impact.
[0207] Step S502: Perform context analysis on the scene configuration parameters that have changed in the generated user interface to obtain the analysis results of the scene configuration parameters that have changed in the generated user interface.
[0208] Specifically, in practical applications, to better understand the relationship between changed scenario configuration parameters and the entire user interface and user scenarios, and thus more accurately assess their impact, contextual analysis can be performed on the changed scenario configuration parameters in the generated user interface. This analysis determines whether the changed parameters have an isolated impact or will trigger a chain reaction, allowing for more appropriate countermeasures. Contextual analysis also helps identify potential problems or conflicts; for example, changes in certain scenario configuration parameters may cause inconsistencies with other related elements or functions. Furthermore, it provides a deeper understanding of users' actual needs and expectations regarding these parameter changes in specific scenarios, making adjustments more aligned with user intent. Contextual analysis of changed scenario configuration parameters in the generated user interface provides more targeted directions and basis for subsequent optimization and improvement, avoiding blindly handling parameter changes. It helps determine the position and role of changed scenario configuration parameters within the overall system architecture and business processes, enabling better coordination of various aspects of work. Finally, it facilitates more comprehensive and reasonable decision-making, considering not only the immediate impact but also long-term effects and system stability.
[0209] Therefore, after determining the scene configuration parameters that have changed in the generated user interface, context analysis can be performed on the scene configuration parameters that have changed in the generated user interface, thereby obtaining the analysis results of the scene configuration parameters that have changed in the generated user interface.
[0210] Step S503: Adjust the generated user interface based on the analysis results of the changed scene configuration parameters in the generated user interface.
[0211] Specifically, as described above, the method provided in this application embodiment can perform context analysis on the scene configuration parameters that have changed in the generated user interface to obtain the analysis results of the scene configuration parameters that have changed in the generated user interface. Furthermore, the generated user interface can be adjusted based on the analysis results of the scene configuration parameters that have changed in the generated user interface.
[0212] As can be seen from the technical solutions described above, the method provided in this application embodiment can determine the scene configuration parameters that have changed in the generated user interface and perform context analysis on them, and adjust the generated user interface based on the analysis results of the scene configuration parameters that have changed in the generated user interface.
[0213] In practical applications, the method provided in this application embodiment can also display visual interface elements so that users can choose whether to manually trigger the scene configuration update operation.
[0214] Furthermore, the method provided in this application embodiment can also synchronize the configuration of the same scene on different platforms based on the scene configuration parameters that have changed in the generated user interface; it can also provide feedback on the scene update status of the user interface.
[0215] For example, the method provided in this application embodiment can provide users with interface elements, such as a "reload" button, allowing users to manually trigger the scene configuration update operation. Visual or textual feedback can also be provided to confirm that the system has updated the scene configuration according to the latest settings. Furthermore, the method provided in this application embodiment can also support cross-platform scene configuration synchronization, effectively ensuring seamless synchronization of scene configurations across multiple platforms, such as mobile, desktop, and web terminals. The method provided in this application embodiment can also provide an API interface, allowing external systems, such as smart home control centers and enterprise resource planning systems, to read and modify scene configurations to match different application scenario requirements.
[0216] The dynamic scene scheme configuration device provided in the embodiments of this application is described below. The dynamic scene scheme configuration device described below and the dynamic scene scheme configuration method described above can be referred to in correspondence.
[0217] See Figure 2 , Figure 2 This is a schematic diagram of a dynamic scene configuration device disclosed in an embodiment of this application.
[0218] like Figure 2 As shown, the dynamic scene configuration device may include:
[0219] The determining unit 101 is used to determine the first target scenario configuration file based on the scenario configuration requirements;
[0220] Preprocessing unit 102 is used to preprocess the first target scene configuration file to obtain the second target scene configuration file;
[0221] Configuration unit 103 is used to dynamically generate a user interface corresponding to the scenario configuration requirements based on the second scenario configuration file;
[0222] The update unit 104 is used to monitor the changes in the scene configuration parameters of the generated user interface in real time, and update the scene configuration scheme of the generated user interface in real time based on the monitoring results.
[0223] As can be seen from the above-described technical solutions, when dynamic scene configuration is required, the device provided in this application embodiment can determine a first target scene configuration file based on scene configuration requirements. The first target scene configuration file can include relevant information for scene configuration. Therefore, the required scene can be efficiently configured based on the first target scene configuration file. However, in practical applications, the first target scene configuration file may not be directly loaded for scene configuration. Therefore, after determining the first target scene configuration file, it can be further preprocessed to obtain a second target scene configuration file. Then, based on the second scene configuration file, a user interface corresponding to the scene configuration requirements can be dynamically generated. Furthermore, in practical applications, the configured scene may change due to user needs or scene changes. Therefore, the device provided in this application embodiment can also monitor changes in the scene configuration parameters of the generated user interface in real time. Changes in the scene configuration parameters of the user interface will cause scene changes. Therefore, the scene configuration scheme of the generated user interface can be updated in real time based on the monitoring results.
[0224] As described above, when dynamic scenario configuration is required, the device provided in this application embodiment can define scenario parameters by creating a configuration file. This method offers greater flexibility than traditional hard-coding schemes. Users can directly update or add new scenario configurations in the scenario configuration file without code changes, making system maintenance and upgrades more convenient and faster. This is more convenient than traditional methods that require recompiling and deploying the application. Furthermore, it supports real-time updates of scenario configurations. Any changes read from the scenario configuration file are immediately reflected on the user interface without restarting the application or reloading the entire page. This is particularly advantageous in application scenarios requiring rapid response to environmental changes. Furthermore, the device provided in this application embodiment can dynamically enable or disable specific scenarios by evaluating factors such as the user's geographical location and language preferences, providing a more personalized user experience. It can provide customized interfaces and functions for different user groups, thereby improving user satisfaction and system efficiency. It allows non-developers to directly configure scenarios through the scenario configuration file, reducing reliance on professional development resources and lowering development and maintenance costs. In addition, since configuration updates take effect immediately, it also reduces system downtime and related operating costs. Furthermore, the apparatus provided in this application embodiment ensures a high degree of modularity and scalability. As business needs grow, new scenarios can be easily added to the XML configuration file without modifying existing system code. This design supports long-term business development and can easily adapt to future technological changes. Furthermore, since scenarios can be dynamically adjusted based on user language and regional settings, the apparatus provided in this application embodiment is particularly suitable for multilingual and multi-regional deployments. It allows the same system to be deployed globally without creating different versions for each region or language, greatly improving deployment efficiency and market coverage.
[0225] The specific processing flow of each unit included in the aforementioned dynamic scene configuration device can be found in the previous section on dynamic scene configuration methods, and will not be repeated here.
[0226] The dynamic scene configuration device provided in this application embodiment can be applied to dynamic scene configuration devices, such as terminals: mobile phones, computers, etc. Optionally, Figure 3 The hardware structure block diagram of the dynamic scene solution configuration device is shown. (Refer to...) Figure 3 The hardware structure of the dynamic scene scheme configuration device may include: at least one processor 1, at least one communication interface 2, at least one memory 3, and at least one communication bus 4.
[0227] In this embodiment, the number of processor 1, communication interface 2, memory 3, and communication bus 4 is at least one, and processor 1, communication interface 2, and memory 3 communicate with each other through communication bus 4.
[0228] Processor 1 may be a central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application.
[0229] Memory 3 may include high-speed RAM, and may also include non-volatile memory, such as at least one disk storage device;
[0230] The memory stores a program, which the processor can call. The program is used to implement the various processing flows in the aforementioned terminal dynamic scene configuration scheme.
[0231] This application embodiment also provides a readable storage medium that can store a program suitable for processor execution, the program being used to: implement the various processing flows of the aforementioned terminal in the dynamic scene configuration scheme.
[0232] Finally, it should be noted that in this document, relational terms such as "first" and "second" are used only to distinguish one entity or operation from another, and do not necessarily require or imply any such actual relationship or order between these entities or operations. Furthermore, the terms "comprising," "including," or any other variations thereof are intended to cover non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements includes not only those elements but also other elements not expressly listed, or elements inherent to such a process, method, article, or apparatus. Without further limitations, an element defined by the phrase "comprising one..." does not exclude the presence of other identical elements in the process, method, article, or apparatus that includes said element.
[0233] The various embodiments in this specification are described in a progressive manner, with each embodiment focusing on the differences from other embodiments. The same or similar parts between the various embodiments can be referred to each other.
[0234] The above description of the disclosed embodiments enables those skilled in the art to make or use this application. Various modifications to these embodiments will be readily apparent to those skilled in the art, and the general principles defined herein may be implemented in other embodiments without departing from the spirit or scope of this application. Various embodiments can be combined with each other. Therefore, this application is not to be limited to the embodiments shown herein, but is to be accorded the widest scope consistent with the principles and novel features disclosed herein.< / condition> < / description> < / titleimg> < / sceneimg> < / skip> < / name> < / code> < / sceneitem> < / sceneitems> < / condition> < / description> < / titleimg> < / sceneimg> < / name> < / code>
Claims
1. A dynamic scene scheme configuration method, characterized in that, include: Based on the scenario configuration requirements, determine the first target scenario configuration file; The first target scene configuration file is preprocessed to obtain the second target scene configuration file; Based on the second target scene configuration file, a user interface corresponding to the scene configuration requirements is dynamically generated; The scene configuration parameters of the generated user interface are monitored in real time, and the scene configuration scheme of the generated user interface is updated in real time based on the monitoring results. The real-time monitoring of changes in the scene configuration parameters of the generated user interface, and the real-time updating of the scene configuration scheme of the generated user interface based on the monitoring results, includes: Real-time monitoring of changes in scene configuration parameters of the generated user interface, and identification of scene configuration parameters that have changed in the generated user interface; Based on the changed scene configuration parameters in the generated user interface, the second target scene configuration file is reloaded to obtain the third target scene configuration file; The user interface is reconfigured based on the third target scene configuration file to build a new scene; The method of real-time monitoring of changes in scene configuration parameters of the generated user interface and real-time updating the scene configuration scheme of the generated user interface based on the monitoring results also includes: Real-time monitoring of changes in scene configuration parameters of the generated user interface, and identification of scene configuration parameters that have changed in the generated user interface; Context analysis is performed on the scene configuration parameters that have changed in the generated user interface to obtain the analysis results of the scene configuration parameters that have changed in the generated user interface. Based on the analysis results of the changed scene configuration parameters in the generated user interface, adjust the generated user interface.
2. The method according to claim 1, characterized in that, The step of preprocessing the first target scene configuration file to obtain the second target scene configuration file includes: Load the configuration file for the first target scene; The first target scene configuration file is parsed, and the parsing result of the first target scene configuration file is used as the second target scene configuration file.
3. The method according to claim 1, characterized in that, The step of dynamically generating a user interface corresponding to the scenario configuration requirements based on the second target scenario configuration file includes: Based on the second target scene configuration file, construct the user interface components; Based on the second target scenario configuration file, determine the scenarios where the user interface is available under the current conditions; Based on the scenario configuration requirements and the scenarios available to the user interface under the current conditions, the display status of user interface elements is dynamically adjusted.
4. The method according to claim 1, characterized in that, The method also includes: Display visual interface elements so that users can choose whether to manually trigger the scene configuration update operation.
5. The method according to claim 1, characterized in that, The method also includes: Based on the changes in scene configuration parameters in the generated user interface, the configuration of the same scene on different platforms is synchronized. Provide feedback on scene updates to the user interface.
6. A dynamic scene configuration device, characterized in that, include: The determination unit is used to determine the first target scenario configuration file based on the scenario configuration requirements; The preprocessing unit is used to preprocess the first target scene configuration file to obtain the second target scene configuration file; The configuration unit is used to dynamically generate a user interface corresponding to the scenario configuration requirements based on the second target scenario configuration file. The update unit is used to monitor changes in the scene configuration parameters of the generated user interface in real time, and update the scene configuration scheme of the generated user interface in real time based on the monitoring results. The update unit is specifically used to monitor the changes in scene configuration parameters of the generated user interface in real time, and determine the scene configuration parameters that have changed in the generated user interface; based on the scene configuration parameters that have changed in the generated user interface, the second target scene configuration file is reloaded to obtain the third target scene configuration file; The user interface is reconfigured based on the third target scene configuration file to build a new scene; The method of real-time monitoring of changes in scene configuration parameters of the generated user interface and real-time updating the scene configuration scheme of the generated user interface based on the monitoring results also includes: Real-time monitoring of changes in scene configuration parameters of the generated user interface, and identification of scene configuration parameters that have changed in the generated user interface; Context analysis is performed on the scene configuration parameters that have changed in the generated user interface to obtain the analysis results of the scene configuration parameters that have changed in the generated user interface. Based on the analysis results of the changed scene configuration parameters in the generated user interface, adjust the generated user interface.
7. A dynamic scene configuration device, characterized in that, include: One or more processors, and memory; The memory stores computer-readable instructions, which, when executed by the one or more processors, implement the steps of the dynamic scene scheme configuration method as described in any one of claims 1 to 5.
8. A readable storage medium, characterized in that: The readable storage medium stores computer-readable instructions, which, when executed by one or more processors, cause the one or more processors to implement the steps of the dynamic scene scheme configuration method as described in any one of claims 1 to 5.