A low-code highly-customizable APP interface customization method and device

Abstract

The present application relates to a kind of low code high customizable APP interface customization method and device. Including receiving APP interface customization demand, and adding the first code module for registering APP main form in APP script file;Parse the plurality of function modules and the layout information of each function module corresponding to APP interface customization demand, form the second code module with the plurality of function modules and corresponding layout information as first parameter, and add the second code module to the first code module in the APP script file after;Business logic is obtained by parsing APP interface customization demand, and the interaction between the plurality of function modules is determined according to business logic, form the third code module with the interaction as second parameter, and add the third code module to the second code module in the APP script file after;Run APP script file, obtain APP interface. The method of the present application improves the flexibility and individual degree of interface customization.

Description

Technical Field

[0001] The embodiments in this specification relate to the field of computer technology, and in particular to a low-code, highly customizable APP interface customization method and apparatus. Background Technology

[0002] In today's rapidly developing digital age, various software applications have permeated all industries. The graphical user interface (GUI), as the key window for user interaction with software, is crucially customizable. However, existing interface customization technologies face numerous challenges. While general interface customization models can meet some routine needs, they fall short when dealing with highly specialized software customization in specific fields. For example, in the field of CAE simulation software, users have specific requirements for apps, such as fixed simulation settings, simplified interface interaction, and customized post-processing evaluation. However, existing customization technologies, such as plug-in customization, have standardized interaction behaviors and limited scalability, making it difficult to meet these highly specialized display, interaction, and flexible customization needs. This severely restricts the application and development of software in complex business scenarios, hinders its ability to quickly adapt to constantly changing business needs, and impedes the integration of software into real business processes.

[0003] To address this issue, various customization methods have emerged: for example, the automatic generation method for simulation scene initialization and editing interface based on text mapping, which focuses on automatic interface generation but lacks overall customization flexibility and in-depth customization of business logic; the interface generated by the software interface format customization configuration method is limited by XML file structure and predefined rules, making it difficult for users to perform in-depth personalization.

[0004] Improving the flexibility and personalization of interface customization is a pressing technical problem that needs to be solved. Summary of the Invention

[0005] To address the problems existing in the prior art, this specification provides a low-code, highly customizable APP interface customization method and apparatus. First, the APP main window is registered. Then, functional modules are deployed in the APP main window. Next, the interaction relationships between the functional modules are deployed according to business logic. These are then formed into a script. Running the script yields the APP interface.

[0006] The specific technical solutions of the embodiments in this specification are as follows:

[0007] On the one hand, the embodiments of this specification provide a low-code, highly customizable method for customizing an APP interface, the method including:

[0008] Receive APP interface customization requests and add the first code module for registering the APP main window to the APP script file;

[0009] The multiple functional modules corresponding to the APP interface customization requirements and the layout information of each functional module are analyzed. The multiple functional modules and the corresponding layout information are used as the first parameter to form the second code module. The second code module is added after the first code module in the APP script file.

[0010] The business logic is obtained by parsing the APP interface customization requirements, and the interaction relationship between the multiple functional modules is determined according to the business logic. The interaction relationship is used as the second parameter to form a third code module, and the third code module is added after the second code module in the APP script file.

[0011] Run the APP script file to obtain the APP interface.

[0012] Furthermore, receiving APP interface customization requests and adding a first code module to the APP script file for registering the APP main window further includes:

[0013] Parse the received APP interface customization request to obtain the APP name;

[0014] Add host form code to the APP script file to create the host form;

[0015] Use the APP name as a parameter, and add the APP main form code for creating the APP main form with the APP name after the host form code.

[0016] Furthermore, before running the APP script file, the method further includes:

[0017] Add the running object of the functional module to the runtime environment of the APP script file, and record the correspondence between the name of the functional module and the running object;

[0018] The second code module, formed by using the multiple functional modules and their corresponding layout information as the first parameter, further includes:

[0019] Each functional module's name and layout information are used as the first parameter to construct the functional module deployment code that deploys each functional module in the APP's main window.

[0020] Adding the second code module to the first code module in the APP script file further includes:

[0021] Add the deployment code of each functional module sequentially after the first code module.

[0022] Furthermore, the interaction relationship includes the correspondence between the specified state of the first functional module and the action of the second functional module;

[0023] Using the interaction relationship as a second parameter to form a third code module further includes:

[0024] Create branch code to monitor whether the first functional module is in a specified state;

[0025] Create control code to control the second functional module to implement the action, and use the control code as the branch target of the branch code.

[0026] Furthermore, the branch code for monitoring whether the first functional module is in a specified state further includes:

[0027] Create status acquisition code to obtain the current status of the first functional module;

[0028] Create code to determine whether the output of the state acquisition code is the same as the specified state.

[0029] Furthermore, the method also includes:

[0030] Receive layout style adjustment instructions from the functional modules;

[0031] The layout style adjustment command is parsed to obtain the third parameter;

[0032] Modify the second code module according to the third parameter.

[0033] Furthermore, after running the APP script file and obtaining the APP interface, the method further includes:

[0034] Receive the APP script file adjustment instructions;

[0035] Adjust the APP script file according to the APP script file adjustment instructions, run the adjusted APP script file, and obtain the adjusted APP interface.

[0036] Furthermore, the APP script file is in Python script format.

[0037] On the other hand, embodiments of this specification also provide a low-code, highly customizable APP interface customization device, the device comprising:

[0038] The first code module addition unit is used to receive APP interface customization requirements and add the first code module for registering the APP main window to the APP script file;

[0039] The second code module adding unit is used to parse multiple functional modules and layout information of each functional module corresponding to the APP interface customization requirements, use the multiple functional modules and corresponding layout information as first parameters to form a second code module, and add the second code module after the first code module in the APP script file.

[0040] The third code module adding unit is used to parse the APP interface customization requirements to obtain business logic, determine the interaction relationship between the multiple functional modules according to the business logic, use the interaction relationship as the second parameter to form the third code module, and add the third code module after the second code module in the APP script file;

[0041] The APP script file execution unit is used to run the APP script file to obtain the APP interface.

[0042] On the other hand, embodiments of this specification also provide a computer program product, which includes a computer program that, when executed by a processor, implements the above-described method.

[0043] The method described in this specification has the following beneficial effects:

[0044] 1. High degree of customization flexibility: It provides rich form modules and a flexible messaging mechanism, supporting users to freely combine modules and expand business logic. Compared with some similar inventions that only provide limited customization options, the method of this specification allows users to quickly assemble interface forms like building blocks based on their own business needs, and to respond to various operations in a personalized manner through the messaging mechanism, achieving deep customization and meeting the needs of highly specialized business scenarios.

[0045] 2. Significantly Improved Development Efficiency: This is reflected in two aspects: a substantial reduction in development difficulty and code volume, and a significant shortening of the customization cycle. The method in the embodiments of this specification combines APP script files with pre-built functional modules, reducing development difficulty to the level of parsing requirements into keyword input, while also providing natural APP script files to support flexible customization. Compared with other inventions: some interface customization technologies that still rely on complex code writing significantly reduce development difficulty and shorten development cycles; some graphical configuration interfaces greatly improve flexibility and scalability.

[0046] 3. Strong functional scalability: The form modules are reusable and expandable, and the message mechanism runs through the entire simulation process. Unlike some similar inventions with relatively simple functions and difficulty in expansion, the method in the embodiments of this specification can easily cope with business changes. Without redeveloping the system, new functions can be added to the APP by adding or modifying functional modules and building message response code, adapting to constantly changing business needs. Attached Figure Description

[0047] To more clearly illustrate the technical solutions in the embodiments of this specification 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 the embodiments of this specification. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0048] Figure 1 The diagram shown is a flowchart illustrating a low-code, highly customizable APP interface customization method according to an embodiment of this specification.

[0049] Figure 2 The diagram shown is a flowchart illustrating how the user receives a custom APP interface request and adds a first code module for registering the APP main window in the APP script file in an embodiment of this specification.

[0050] Figure 3 The diagram shown is a flowchart illustrating the process of pre-building the runtime object of a functional module in the runtime environment of an APP script file in an embodiment of this specification.

[0051] Figure 4 The diagram shown is a flowchart illustrating the process of adjusting the layout and style of functional modules deployed in the APP in an embodiment of this specification.

[0052] Figure 5 The diagram shown is a flowchart illustrating how the interaction relationship is used as a second parameter to form a third code module in an embodiment of this specification.

[0053] Figure 6 The diagram shown is a flowchart illustrating the process of creating branch code to monitor whether the first functional module is in a specified state in an embodiment of this specification.

[0054] Figure 7 The diagram shown is a structural schematic of a low-code, highly customizable APP interface customization device according to an embodiment of this specification.

[0055] Figure 8 The diagram shown is a structural schematic of the computer device in an embodiment of this specification.

[0056] [Explanation of Figure Markers]:

[0057] 701. Add a unit to the first code module;

[0058] 702. Add units to the second code module;

[0059] 703. Add unit to the third code module;

[0060] 704, APP script file execution unit;

[0061] 802. Computer equipment;

[0062] 804. Processing equipment;

[0063] 806. Storage resources;

[0064] 808. Drive mechanism;

[0065] 810. Input / Output Module;

[0066] 812. Input devices;

[0067] 814. Output devices;

[0068] 816. Presentation equipment;

[0069] 818. Graphical User Interface;

[0070] 820. Network interface;

[0071] 822. Communication link;

[0072] 824. Communication bus. Detailed Implementation

[0073] The technical solutions in the embodiments of this specification will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of the embodiments of this specification, and not all embodiments. Based on the embodiments of this specification, all other embodiments obtained by those skilled in the art without creative effort are within the protection scope of the embodiments of this specification.

[0074] It should be noted that the terms "first," "second," etc., in the description, claims, and accompanying drawings of the embodiments herein are used to distinguish similar objects and are not necessarily used to describe a specific order or sequence. It should be understood that such data can be interchanged where appropriate so that embodiments of the embodiments described herein can be implemented in orders other than those illustrated or described herein. Furthermore, the terms "comprising" and "having," and any variations thereof, are intended to cover non-exclusive inclusion; for example, a process, method, apparatus, product, or device that includes a series of steps or units is not necessarily limited to those steps or units explicitly listed, but may include other steps or units not explicitly listed or inherent to such processes, methods, products, or devices.

[0075] It should be noted that the acquisition, storage, use, and processing of data in the technical solutions of the embodiments in this specification all comply with the relevant provisions of national laws and regulations.

[0076] It should be noted that in the embodiments of this specification, certain software, components, models and other existing solutions in the industry may be mentioned. These should be regarded as exemplary and are only intended to illustrate the feasibility of implementing the technical solution of this application. However, they do not mean that the applicant has used or necessarily used the solution.

[0077] To address the problems existing in the prior art, this specification provides a low-code, highly customizable APP interface customization method. It develops an assembly-style customization mode, develops a customization framework and low-code, reusable, and extensible form modules, and parses the user's APP interface customization requirements into simple APP script files, which can be directly run to obtain a customized APP. Figure 1 The diagram illustrates a low-code, highly customizable app interface customization method according to an embodiment of this specification. It describes the process of parsing app interface customization requirements, constructing an app script file, and running the script file to obtain the app interface. The order of steps listed in the embodiment is merely one possible execution order among many and does not represent the only possible order. In actual system or device products, the methods shown in the embodiment or the accompanying drawings can be executed sequentially or in parallel. Specifically, as shown... Figure 1 As shown, a pre-trained machine learning model deployed in a computer can execute this method, which may include:

[0078] Step 101: Receive the APP interface customization requirements and add the first code module for registering the APP main window in the APP script file;

[0079] Step 102: Analyze the multiple functional modules corresponding to the APP interface customization requirements and the layout information of each functional module, use the multiple functional modules and the corresponding layout information as the first parameter to form the second code module, and add the second code module after the first code module in the APP script file;

[0080] Step 103: Analyze the APP interface customization requirements to obtain business logic, determine the interaction relationship between the multiple functional modules according to the business logic, use the interaction relationship as the second parameter to form a third code module, and add the third code module after the second code module in the APP script file;

[0081] Step 104: Run the APP script file to obtain the APP interface.

[0082] In the embodiments of this specification, the APP interface customization requirements can be in text form. These requirements can be parsed using a large language model to obtain the APP name, required functional modules, layout information of the functional modules, and business logic. Users can select the corresponding functional modules to add to the main window according to their actual needs, and set the relative positions of the functional modules through parameters. For example, if three functional modules are all set to 'LEFT', they will be arranged in a column from top to bottom. The layout will automatically adapt to the container size (such as window scaling, different device screen sizes).

[0083] In the embodiments of this specification, a large amount of historical data can be used to train the machine learning model so that the machine learning model can correctly parse the APP interface customization requirements and build the correct code to form the APP script file.

[0084] In the embodiments described in this specification, the APP script file is in Python script format, but it can also be other types of script files.

[0085] In the embodiments described in this specification, such as Figure 2 As shown, receiving APP interface customization requests and adding a first code module to the APP script file for registering the APP main window further includes:

[0086] Step 201: Parse the received APP interface customization requirements to obtain the APP name;

[0087] Step 202: Add host form code to the APP script file to create the host form;

[0088] Step 203: Using the APP name as a parameter, add the APP main form code for creating the APP main form with the APP name after the host form code.

[0089] For example, the host form code and the APP main form code can be:

[0090] appHostWindow=IEHostWindow();

[0091] appHostWindow.set_app_title("xxx");

[0092] appHostWindow.show();

[0093] xx_window = xxMainWindow();

[0094] appHostWindow.set_app_main_window(xx_window);

[0095] xx_window.show();

[0096] app.exec();

[0097] In some other embodiments of this specification, the APP interface customization requirements may also include user modifications to the main window properties, such as title, size, color, style, and icon. The main window properties can be obtained by parsing the APP interface customization requirements, and then the main window properties can be used as parameters to construct code that modifies the main window properties. This code is then added to the APP script file so that when the APP script file is run, the corresponding code is automatically executed to modify the main window properties.

[0098] In the embodiments described in this specification, the functional modules are pre-structured in the runtime environment of the APP script file. Specifically, such as... Figure 3 As shown, before running the APP script file, the method further includes:

[0099] Step 301: Add the running object of the functional module to the running environment of the APP script file, and record the correspondence between the name of the functional module and the running object;

[0100] The second code module, formed by using the multiple functional modules and their corresponding layout information as the first parameter, further includes:

[0101] Step 302: Using the name and layout information of each functional module as the first parameter, construct the functional module deployment code for deploying each functional module in the main window of the APP;

[0102] Adding the second code module to the first code module in the APP script file further includes:

[0103] Step 303: Add the deployment code of each functional module to the first code module in sequence.

[0104] In the embodiments described in this specification, the functional modules include, but are not limited to, an engineering management module, a data navigation module, a display module, a log module, a form module, and a message module. The module functions cover the main interface elements required by general-purpose simulation software. The runtime objects of these functional modules are deployed in the runtime environment of the APP script file, so that the APP script file can call the runtime objects of the functional modules to implement their functions.

[0105] In the embodiments of this specification, the name and layout of the functional module are used as the first parameters to construct the functional module deployment code for deploying the functional module. For example, the deployment code of the functional module can be:

[0106] #Add project management module and layout

[0107] self.add_module(title='Business Activity Subject Selection',object=self._project_manager,layout='DOCK_LEFT')

[0108] #Add data navigation module and layout

[0109] self.add_module(title='Simulation Simulation', object=self._simulation_manager, layout='DOCK_LEFT')

[0110] #Add information output module and layout

[0111] self.add_module(title='Information Output', object=self._logger_manager, layout='DOCK_LEFT')

[0112] #Add and layout the graphics display module

[0113] self.add_module(title='Graphic display', object=self._graphic_manager, layout='DOCK_CENTER')

[0114] In some other embodiments of this specification, users are also allowed to adjust the layout and style of functional modules deployed in the APP. Specifically, such as... Figure 4 As shown, the method further includes:

[0115] Step 401: Receive the layout style adjustment instruction from the functional module;

[0116] Step 402: Parse the layout style adjustment command to obtain the third parameter;

[0117] Step 403: Modify the second code module according to the third parameter.

[0118] In the embodiments of this specification, the third parameter is used to adjust the layout and style of the corresponding functional modules. Therefore, the second code module that deploys multiple functional modules is modified according to the third parameter. For example, code for adjusting the layout and style of the corresponding functional modules according to the third parameter is added to the second code module, so that when the APP script is run, the code in the second code module can adjust the layout and style of the corresponding functional modules according to the third parameter.

[0119] In the embodiments described in this specification, the interaction relationship includes the correspondence between the specified state of the first functional module and the action of the second functional module;

[0120] According to one embodiment of this specification, such as Figure 5 As shown, using the interaction relationship as a second parameter to form a third code module further includes:

[0121] Step 501: Create branch code to monitor whether the first functional module is in a specified state;

[0122] Step 502: Create control code to control the second functional module to implement the action, and use the control code as the branch target of the branch code.

[0123] In the embodiments of this specification, the specified state of the first functional module includes, but is not limited to, the first functional module outputting a result of a specified type, the first functional module sending a specified message, and the action of the second functional module includes, but is not limited to, using the result of the first functional module as input to execute the function of the second functional module, and triggering the execution of the second functional module.

[0124] In the embodiments of this specification, when a user submits a custom request for the APP interface, they can specify the correspondence between a specified state of the first functional module and the action of the second functional module. The neural network model is responsible for parsing and obtaining the correspondence, then creating branch code to monitor whether the first functional module is in the specified state, and creating control code to control the second functional module to perform the corresponding action, and using the control code as the target branch of the branch code.

[0125] In the embodiments described in this specification, such as Figure 6 As shown, the branch code for monitoring whether the first functional module is in a specified state further includes:

[0126] Step 601: Create status acquisition code to obtain the current status of the first functional module;

[0127] Step 602: Create judgment code to determine whether the output of the state acquisition code is the same as the specified state.

[0128] For example, when the project management module sends a "PROJECT_ACTIVITY_CHANGED" message, it indicates that the currently active project has changed, and the display status and content of the navigation data module and the graphics display module need to be refreshed synchronously. At this time, the third code module can be:

[0129] def handle_message(self,sender,msg_type,msg_id,data):

[0130] # Handling messages sent by the project management module

[0131] if sender == 'Project':

[0132] #Service Switching Message

[0133] if msg_type==IEMsg.PROJECT_ACTIVITY_CHANGED:

[0134] #Refresh navigation data area and graphics area

[0135] current_activity=data['activity_name']

[0136] current_work_dir=data['activity_directory']

[0137] current_config=data['activity_config']

[0138] self._simulation_manager.show_activity(current_activity,current_work_dir,

[0139] current_config)

[0140] self._graphic_manager.update(current_work_dir,'ALL')

[0141] self._graphic_manager.clear('HIGHLIGHT')

[0142] According to one embodiment of this specification, after running the APP script file and obtaining the APP interface, the method further includes:

[0143] Receive the APP script file adjustment instructions;

[0144] Adjust the APP script file according to the APP script file adjustment instructions, run the adjusted APP script file, and obtain the adjusted APP interface.

[0145] In the embodiments of this specification, the adjustment instructions may include the name of the deployed functional module, the style of the functional module, the layout of the functional module, the interaction relationship between the functional modules, etc., and the embodiments of this specification do not impose any limitations.

[0146] The parameters adjusted in the adjustment instructions can be extracted, and the parameters in the code of the APP script file can be modified according to the parameters to adjust the APP script file. Then, the file can be run again for the user to see the effect.

[0147] Based on the same inventive concept, embodiments of this specification also provide a low-code, highly customizable APP interface customization device, such as... Figure 7 As shown, it includes:

[0148] The first code module addition unit 701 is used to receive APP interface customization requirements and add the first code module for registering the APP main window in the APP script file;

[0149] The second code module adding unit 702 is used to parse multiple functional modules and layout information of each functional module corresponding to the APP interface customization requirements, use the multiple functional modules and corresponding layout information as first parameters to form a second code module, and add the second code module after the first code module in the APP script file.

[0150] The third code module adding unit 703 is used to parse the APP interface customization requirements to obtain business logic, determine the interaction relationship between the multiple functional modules according to the business logic, use the interaction relationship as the second parameter to form the third code module, and add the third code module after the second code module in the APP script file.

[0151] The APP script file execution unit 704 is used to run the APP script file to obtain the APP interface.

[0152] The beneficial effects obtained by the above-described device are the same as those obtained by the above-described method, and will not be described in detail in the embodiments of this specification.

[0153] like Figure 8The diagram shown is a structural schematic of a computer device according to an embodiment of this specification. The methods of this invention can be applied to the computer device in this embodiment. The computer device 802 may include one or more processing devices 804, such as one or more central processing units (CPUs), each of which can implement one or more hardware threads.

[0154] The computer device 802 may also include any storage resource 806 for storing any kind of information such as code, settings, data, etc.

[0155] Non-limiting, for example, storage resource 806 may include any one or more of the following: any type of RAM, any type of ROM, flash memory device, hard disk, optical disk, etc.

[0156] More generally, any storage resource can use any technology to store information.

[0157] Furthermore, any storage resource can provide volatile or non-volatile retention of information.

[0158] Furthermore, any storage resource can represent a fixed or removable component of the computer device 802.

[0159] In one scenario, when processing device 804 executes associated instructions stored in any storage resource or combination of storage resources, computer device 802 can perform any operation of the associated instructions. Computer device 802 also includes one or more drive mechanisms 808 for interacting with any storage resource, such as hard disk drive mechanisms, optical disk drive mechanisms, etc.

[0160] Computer device 802 may also include an input / output module 810 (I / O) for receiving various inputs (via input device 812) and providing various outputs (via output device 814). A specific output mechanism may include a presentation device 816 and an associated graphical user interface (GUI) 818. In other embodiments, the input / output module 810 (I / O), input device 812, and output device 814 may be omitted, and the device may function solely as a computer device within a network. Computer device 802 may also include one or more network interfaces 820 for exchanging data with other devices via one or more communication links 822. One or more communication buses 824 couple the components described above together.

[0161] Communication link 822 can be implemented in any way, such as via a local area network (LAN), a wide area network (WAN) (e.g., the Internet), a point-to-point connection, or any combination thereof. Communication link 822 may include any combination of hardwired links, wireless links, routers, gateway functions, name servers, etc., governed by any protocol or combination of protocols.

[0162] This specification also provides a computer-readable storage medium storing a computer program that, when executed by a processor, implements the above-described method.

[0163] This specification also provides computer-readable instructions, wherein when a processor executes the instructions, the program therein causes the processor to perform the above-described method.

[0164] It should be understood that in the various embodiments of this specification, the sequence number of each process does not imply the order of execution. The execution order of each process should be determined by its function and internal logic, and should not constitute any limitation on the implementation process of the embodiments of this specification.

[0165] It should also be understood that, in the embodiments of this specification, the term "and / or" is merely a description of the relationship between related objects, indicating that three relationships can exist. For example, A and / or B can represent: A existing alone, A and B existing simultaneously, and B existing alone. Furthermore, in the embodiments of this specification, the character " / " generally indicates that the preceding and following related objects have an "or" relationship.

[0166] Those skilled in the art will recognize that the units and algorithm steps of the various examples described in conjunction with the embodiments disclosed in this specification can be implemented in electronic hardware, computer software, or a combination of both. To clearly illustrate the interchangeability of hardware and software, the components and steps of each example have been generally described in terms of functionality in the foregoing description. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementations should not be considered beyond the scope of the embodiments in this specification.

[0167] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working processes of the systems, devices, and units described above can be referred to the corresponding processes in the foregoing method embodiments, and will not be repeated here.

[0168] In the embodiments provided in this specification, it should be understood that the disclosed systems, apparatuses, and methods can be implemented in other ways. For example, the apparatus embodiments described above are merely illustrative; for instance, the division of units is only a logical functional division, and in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the couplings or direct couplings or communication connections shown or discussed may be indirect couplings or communication connections through some interfaces, devices, or units, or they may be electrical, mechanical, or other forms of connection.

[0169] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of the embodiments described in this specification, depending on actual needs.

[0170] Furthermore, the functional units in the various embodiments of this specification can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit. The integrated unit can be implemented in hardware or as a software functional unit.

[0171] If the integrated unit is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solutions of the embodiments of this specification, in essence, or the parts that contribute to the prior art, or all or part of the technical solutions, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods described in the various embodiments of this specification. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0172] This specification describes the principles and implementation methods of the embodiments using specific examples. The above descriptions of the embodiments are only for the purpose of helping to understand the methods and core ideas of the embodiments in this specification. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of the embodiments in this specification. Therefore, the content of this specification should not be construed as a limitation on the embodiments in this specification.

Claims

1. A low-code, highly customizable method for customizing an app interface, characterized in that: The method includes: Receive APP interface customization requests and add the first code module for registering the APP main window to the APP script file; The multiple functional modules corresponding to the APP interface customization requirements and the layout information of each functional module are analyzed. The multiple functional modules and the corresponding layout information are used as the first parameter to form the second code module. The second code module is added after the first code module in the APP script file. The business logic is obtained by parsing the APP interface customization requirements, and the interaction relationship between the multiple functional modules is determined according to the business logic. The interaction relationship is used as the second parameter to form a third code module, and the third code module is added after the second code module in the APP script file. Run the APP script file to obtain the APP interface; Receiving APP interface customization requests and adding a first code module to the APP script file for registering the APP main window further includes: Parse the received APP interface customization request to obtain the APP name; Add host form code to the APP script file to create the host form; Use the APP name as a parameter, and add the APP main form code for creating the APP main form with the APP name after the host form code; Before running the APP script file, the method further includes: Add the running object of the functional module to the runtime environment of the APP script file, and record the correspondence between the name of the functional module and the running object; The second code module, formed by using the multiple functional modules and their corresponding layout information as the first parameter, further includes: Each functional module's name and layout information are used as the first parameter to construct the functional module deployment code that deploys each functional module in the APP's main window. Adding the second code module to the first code module in the APP script file further includes: Add the deployment code of each functional module sequentially after the first code module; The interaction relationship includes the correspondence between the specified state of the first functional module and the action of the second functional module; Using the interaction relationship as a second parameter to form a third code module further includes: Create branch code to monitor whether the first functional module is in a specified state; Create control code to control the second functional module to implement the action, and use the control code as the branch target of the branch code.

2. The method according to claim 1, characterized in that, The branch code for monitoring whether the first functional module is in a specified state further includes: Create status acquisition code to obtain the current status of the first functional module; Create code to determine whether the output of the state acquisition code is the same as the specified state.

3. The method according to claim 1, characterized in that, The method further includes: Receive layout style adjustment instructions from the functional modules; The layout style adjustment command is parsed to obtain the third parameter; Modify the second code module according to the third parameter.

4. The method according to claim 1, characterized in that, After running the APP script file and obtaining the APP interface, the method further includes: Receive the APP script file adjustment instructions; Adjust the APP script file according to the APP script file adjustment instructions, run the adjusted APP script file, and obtain the adjusted APP interface.

5. The method according to claim 1, characterized in that, The APP script file is in Python script format.

6. A low-code, highly customizable APP interface customization device, characterized in that, The device includes: The first code module addition unit is used to receive APP interface customization requirements and add the first code module for registering the APP main window to the APP script file; The second code module adding unit is used to parse multiple functional modules corresponding to the APP interface customization requirements and the layout information of each functional module, use the multiple functional modules and the corresponding layout information as the first parameter to form the second code module, and add the second code module after the first code module in the APP script file. The third code module adding unit is used to parse the APP interface customization requirements to obtain business logic, determine the interaction relationship between the multiple functional modules according to the business logic, use the interaction relationship as the second parameter to form the third code module, and add the third code module after the second code module in the APP script file; An APP script file execution unit is used to run the APP script file to obtain the APP interface; Receiving APP interface customization requests and adding a first code module to the APP script file for registering the APP main window further includes: Parse the received APP interface customization request to obtain the APP name; Add host form code to the APP script file to create the host form; Use the APP name as a parameter, and add the APP main form code for creating the APP main form with the APP name after the host form code; Before running the APP script file, the device is also used to: Add the running object of the functional module to the runtime environment of the APP script file, and record the correspondence between the name of the functional module and the running object; The second code module, formed by using the multiple functional modules and their corresponding layout information as the first parameter, further includes: Each functional module's name and layout information are used as the first parameter to construct the functional module deployment code that deploys each functional module in the APP's main window. Adding the second code module to the first code module in the APP script file further includes: Add the deployment code of each functional module sequentially after the first code module; The interaction relationship includes the correspondence between the specified state of the first functional module and the action of the second functional module; Using the interaction relationship as a second parameter to form a third code module further includes: Create branch code to monitor whether the first functional module is in a specified state; Create control code to control the second functional module to implement the action, and use the control code as the branch target of the branch code.

7. A computer program product, characterized in that, The computer program product includes a computer program that, when executed by a processor, implements the method of any one of claims 1 to 5.

Images