CN116301886A - Data processing method, device, electronic device, and computer-readable storage medium - Google Patents

Abstract

The application provides a data processing method, a data processing device, electronic equipment and a computer readable storage medium, and relates to the technical field of computers. The data processing method comprises the following steps: responding to a first operation command of a user based on a function list, and acquiring a command script corresponding to a target function selected by the first operation command; responding to a second operation command of a user based on an object list, and acquiring a target code corresponding to a target object selected by the second operation command; and running the command script to perform processing corresponding to the target function on the target code to obtain a processing result. The user can execute the command script corresponding to the target function on the target code corresponding to the target object by selecting the target object and the target function in the object list and the function list without manually inputting the command, so that the operation process of the user is simplified, and the operation difficulty of the user is reduced.

Description

Data processing method, device, electronic device, and computer-readable storage medium

technical field

The present application relates to the field of computer technology, and in particular, to a data processing method, device, electronic equipment, and computer-readable storage medium.

Background technique

In the existing software development process, it is necessary to perform operations such as compilation, verification, and version management on the code of a project. At present, the corresponding functions are usually realized through the input of various commands by the staff. That is to say, every time an operation is performed, it is necessary to enter the corresponding command to complete it. In the process of software development, it is often necessary to perform repeated operations such as compilation, verification, and version management on multiple projects, which makes the process of software development cumbersome and difficult to master. Inputting commands to implement operations such as compilation, verification, and version management is difficult for ordinary developers, time-consuming and error-prone.

Contents of the invention

The present application provides a data processing method, device, electronic equipment, and computer-readable storage medium to solve the problem in the prior art that requires staff to input various commands to implement operations such as compiling, verification, and version management, resulting in the process of software development. It is cumbersome, and it is difficult for ordinary developers to master the input commands to realize compilation, verification, version management and other operations, which is time-consuming and error-prone.

In the first aspect, the present application provides a data processing method, including: responding to the user's first operation command based on the function list, obtaining the command script corresponding to the target function selected by the first operation command; responding to the user's second operation command based on the object list The operation command is used to obtain the target code corresponding to the target object selected by the second operation command; to run the command script to perform processing corresponding to the target function on the target code to obtain a processing result.

In the embodiment of this application, by selecting the target object and target function in the object list and function list, the user can execute the command script corresponding to the target function for the target code corresponding to the target object, and no need to manually input commands, which simplifies the user's operation The process reduces the difficulty of user operation.

In combination with the technical solution provided in the first aspect above, in some possible implementation manners, if the target function is a first-type function, the object list includes an item list, and the item list includes one or more items, each The project corresponds to a project code, and each project includes at least one module; all modules under the same project share the same project code, and each module corresponds to a set of parameters. If the target object is a target project, the acquisition The target code corresponding to the target object selected by the second operation command includes: acquiring an item code of the target item, where the item code of the target item is the target code.

In the embodiment of the present application, since different types of functions require different target codes, when obtaining the target code corresponding to the target item, the method of obtaining the target code is determined according to the type of the target function, thereby improving the flexibility of the solution.

In combination with the technical solution provided in the first aspect above, in some possible implementation manners, if the target function is the second type of function, the object list includes an item list and a module list, and each item in the item list corresponds to A module list, each project corresponds to a project code, each module in the same module list shares the project code corresponding to the project corresponding to the module list, and each module corresponds to a set of parameters, if the target object includes the target project and the target module , the acquiring the target code corresponding to the target object selected by the second operation command includes: acquiring the item code corresponding to the target item, and acquiring the target parameter corresponding to the target module; according to the target parameter and the The item code corresponding to the target item is used to obtain the target code corresponding to the target object.

In the embodiment of the present application, since different types of functions require different target codes, when obtaining the target code corresponding to the target item, the method of obtaining the target code is determined according to the type of the target function, thereby improving the flexibility of the solution.

In combination with the technical solution provided in the first aspect above, in some possible implementation manners, obtaining the command script corresponding to the target function selected by the first operation command includes: obtaining the script that comes with the operating system and the first operation command The command script corresponding to the selected target function, or acquire the script corresponding to the target function selected by the first operation command included in the project corresponding to the target object.

In combination with the technical solution provided in the first aspect above, in some possible implementation manners, the responding to the user's first operation command based on the function list includes: responding to the user's first operation command based on the function list displayed on the visual interface.

In the embodiment of the present application, by setting a visual interface, the user can be more intuitive when selecting the target object and the target function, and further improve the user experience.

In combination with the technical solution provided in the first aspect above, in some possible implementations, the object list includes a project list, a module list, and a platform list, and the method further includes: responding to the user's operation of selecting a target function and a target platform, in The project list corresponding to the target platform is displayed in the visual interface; in response to the operation of selecting the target project by the user, it is judged whether the execution object of the target function is a project; if not, the target project corresponding to the project is displayed in the visual interface. list of modules.

In combination with the technical solution provided by the first aspect above, in some possible implementation manners, the visual interface further includes a determination option, and in response to the user's first operation command based on the function list, the user selects the first operation command to obtain the The command script corresponding to the target function; responding to the user's second operation command based on the object list, obtaining the target code corresponding to the target object selected by the second operation command, including: responding to the user's first operation instruction selecting the target function, selecting The second operation instruction of the target object and the operation of selecting the determination option, saving the target object and the target function selected by the user, and obtaining the target code corresponding to the target object and the command corresponding to the target function script.

In combination with the technical solution provided in the first aspect above, in some possible implementation manners, the function list includes at least one function of downloading, updating, submitting, querying, compiling, debugging and publishing.

In a second aspect, the present application provides a project operating system, including: an acquisition module and a processing module. The acquisition module is used to respond to the user's first operation command based on the function list, and acquire the command script corresponding to the target function selected by the first operation command; the acquisition module is also used to respond to the user's second operation command based on the object list Obtaining the target code corresponding to the target object selected by the second operation command; the processing module is configured to run the command script to process the target code corresponding to the target function to obtain a processing result.

In the third aspect, the embodiment of the present application also provides an electronic device, including: a memory and a processor, the memory is connected to the processor; the memory is used to store programs; the processor is used to call The program stored in the memory is used to execute the method provided in the above embodiment of the first aspect and/or in combination with any possible implementation manner of the embodiment of the above first aspect.

In the fourth aspect, the embodiment of the present application also provides a computer-readable storage medium, on which a computer program is stored. When the computer program is run by a computer, it executes the above-mentioned embodiment of the first aspect and/or combines the above-mentioned first The method provided by any possible implementation manner of the aspect embodiment.

Description of drawings

In order to more clearly illustrate the technical solutions of the embodiments of the present application, the accompanying drawings that are required in the embodiments will be briefly introduced below. It should be understood that the following drawings only show some embodiments of the present application, and thus It should be regarded as a limitation on the scope, and those skilled in the art can also obtain other related drawings based on these drawings without creative work.

FIG. 1 is a schematic flow diagram of a data processing method shown in an embodiment of the present application;

FIG. 2 is a schematic structural diagram of a visual interface shown in an embodiment of the present application;

Fig. 3 is a flow structure block diagram of a project operating system shown in the embodiment of the present application;

Fig. 4 is a structural block diagram of an electronic device shown in an embodiment of the present application.

Detailed ways

The terms "first", "second", "third" and so on are only used for distinguishing descriptions, and do not represent sequence numbers, nor can they be understood as indicating or implying relative importance.

In addition, the terms "horizontal", "vertical", "overhanging" and the like do not mean that the components are absolutely horizontal or overhanging, but may be slightly inclined. For example, "horizontal" only means that its direction is more horizontal than "vertical", and it does not mean that the structure must be completely horizontal, but can be slightly inclined.

In the description of the present application, it should be noted that the orientation or positional relationship indicated by the terms "inner", "outer", "left", "right", "upper", "lower" etc. are based on the Orientation or positional relationship, or the orientation or positional relationship that the application product is usually placed in use, is only for the convenience of describing the application and simplifying the description, rather than indicating or implying that the referred device or element must have a specific orientation, in order to Specific orientation configurations and operations, therefore, are not to be construed as limitations on the application.

In the description of this application, unless otherwise clearly stipulated and limited, the terms "installation", "installation", "connection" and "connection" should be understood in a broad sense, for example, it can be a fixed connection or a detachable connection , or integrally connected; it may be mechanically connected or electrically connected; it may be directly connected or indirectly connected through an intermediary, and it may be the internal communication of two components.

The technical solutions of the present application will be described in detail below in conjunction with the accompanying drawings.

Please refer to FIG. 1 . FIG. 1 is a schematic flowchart of a data processing method provided by an embodiment of the present application. The steps included in it will be described below in conjunction with FIG. 1 .

S100: In response to a user's first operation command based on the function list, acquire a command script corresponding to a target function selected by the first operation command.

In one embodiment, the process of obtaining the command script corresponding to the target function selected by the first operation command may be to obtain the command script corresponding to the target function selected by the first operation command in the operating system, or to obtain the target object The script corresponding to the target function selected by the first operation command is included in the corresponding project.

Wherein, the location of the corresponding command script may be determined first according to the target function, and then the command script may be obtained from the operating system or from the project corresponding to the target object according to the determination.

S200: In response to a user's second operation command based on the object list, acquire a target code corresponding to a target object selected by the second operation command.

Among them, the target object can be any one of platform, project, and module. There can be multiple projects under one platform, and one project can correspond to multiple modules. The same platform corresponds to a compiler, each project corresponds to a project code, and each module corresponds to a set of parameters.

Specifically, the compilers and basic compilation options corresponding to projects under the same platform (the basic compilation options mentioned here are the options that must be passed in for source code compilation required by the master control manufacturer) are the same.

For example, when the compilers and basic compilation options used by the projects involved in the products of the same master control are the same, they should belong to one platform. In addition, chips designed by some master design manufacturers form a series. The cores used in this series of chips are the same, but the peripheral devices are slightly different, but the compilers and basic compilation options used in this series of chips are the same, and they also belong to the same platform. The platform is the same, but the main control is different. In the specific code implementation, it is often necessary to distinguish according to the main control, so the information of the main control model is often used. A platform may correspond to multiple masters. Therefore, the master list and the configuration file corresponding to the platform can be stored in the project operating system, so that they can be transferred to each project by script.

It should be noted that a project can be compiled with different compilers or basic compilation options, so a project is not necessarily only for one platform, that is, the same project can exist under multiple platforms at the same time.

Items can be classified according to Table 1.

Table 1

As shown in Table 1, type 1 projects are common in some open source projects, such as uboot, linux kernel, busybox, etc., all of which have their own configuration commands. After configuration, a .config file will be generated. The differences between different products are in this .config.

Type 2 projects are commonly found in open source projects provided by some third parties. There is no need to modify the code, and only need to recompile with the corresponding compiler and compilation options for different products.

The third category of projects is common in self-developed projects. Since the company's products are generally planned by series, the codes of the same series or even different series may be mostly the same, but individual functions need to be distinguished or added or deleted. If precompiled macros are added to the code and compiled scripts, and different products use different compiled macros, it is also possible to share a project. It is obviously no problem to judge which compiled macros based on the product here, but it will bring great inconvenience to project management, because the product involves too much, so it needs to be subdivided. In practice, a compromise can be made, using the main control used by the product to distinguish compiled macros, and some related to the actual product, placed in the project code, and dynamically adapted according to the product model when the program is running.

The fourth type of project is common in self-developed projects, such as driver projects, tool sets, etc. The feature is that a project contains all kinds of driver modules or tool source codes. They are all independent, and they are put into a project only for the convenience of management.

A module is the smallest unit for compilation, and each module can be compiled, debugged, and compiled independently.

For different types of projects, the way of decomposing them into modules is also different.

For the above category 1 project, each product corresponding to the project corresponds to a module.

Among them, in order to facilitate subsequent enumeration of module names, an independent directory (such as Configs) can be created to place various configuration files named after different module names. The module name can use the product name or its abbreviation, or a noun that can reflect the characteristics of the module. For example, master control name, memory characteristics (type, frequency, size, etc.), memory chip characteristics (type, size, etc.), etc.

For the second type of project, because only the compiler and the basic compilation options are different, and the compiler and compilation options are issued through the compilation system, so that a project (a module) can be shared by different platforms, so the project name can be specified A personalized alias, and then save the alias as the module name in the project's configuration file for subsequent enumeration of modules. For a platform, the module list corresponding to this project can only include one module.

For the third type of project, the number of modules included in the module list corresponding to the project is the same as the number of types of masters corresponding to the operation requirements of multiple products corresponding to the project, and the parameters corresponding to the modules include the type of the master chip.

Optionally, because most of the codes of different modules are the same, only some function blocks are different due to different main controls, so the different parts can be organized into each function block and controlled by compiling macros, and then modify the compiling script of the project, Whether to define these compilation macros is determined according to the master passed in by the compilation system. In this way, you can set a personalized alias for the project name in the same way as the previous category 2 projects, and save the alias to the configuration file of the project for use by subsequent enumeration modules. When enumerating modules, combine each master name and the alias of the project as the module name.

For the fourth type of project, each sub-project is corresponding to the project as a module, and the number of modules corresponding to the project is the same as the number of sub-projects included in the project.

Optionally, each subproject can be compiled separately, so each subproject can correspond to a module. The module name can use the directory name of each sub-project.

Because when the target functions are different, the corresponding target objects are also different, and the implementation manners of acquiring the target code corresponding to the target object selected by the second operation command are also different. Specifically, the following two implementation manners are possible.

In the first implementation mode, if the target function is the first type of function, the object list includes a list of items, and the list of items includes one or more items, each item corresponds to an item code, and each item includes at least one module; All the modules in share the same project code, and each module corresponds to a set of parameters. If the target object is the target project, the specific process of obtaining the target code corresponding to the target object selected by the second operation command is to obtain the project code of the target project, and the target The item code of the item is the object code.

Among them, the first type of functions are functions that only need to be applied to the project code, such as downloading, updating, submitting, querying and other functions.

In the second implementation mode, if the target function is the second type of function, the object list includes a project list and a module list, each item in the project list corresponds to a module list, each item corresponds to a project code, and each item in the same module list Each module shares the project code corresponding to the project corresponding to the module list, and each module corresponds to a group of parameters. If the target object includes the target project and the target module, the specific process of obtaining the target code corresponding to the target object selected by the second operation command can be as follows : First obtain the project code corresponding to the target project and the target parameter corresponding to the target module; then obtain the target code corresponding to the target object according to the target parameter and the project code corresponding to the target project.

Among them, the second type of functions are functions that need to be applied to parameters corresponding to the modules, such as functions such as compilation, debugging, and release.

For example, when the target object is module 1 under project A, first obtain the project code of project A and the parameters corresponding to module 1. Then based on the parameters corresponding to module 1 and the project code of project A, the target code can be obtained.

In one embodiment, the object list may also include a platform list, each platform in the platform list includes at least one project, each project includes at least one module, the same platform corresponds to a compiler, and each project corresponds to a project code, Each module corresponds to a set of parameters. The target object includes the target platform, and the specific process of obtaining the target code corresponding to the target object selected by the second operation command can be divided into the following two cases.

In the first case, if the target function is the first type of function, for each item included in the target platform, the item code corresponding to the item is obtained, and the item code corresponding to each item is the target code.

In the second case, if the target function is the second type of function, for each project included in the target platform, obtain the project code corresponding to the project, and the parameters corresponding to each module included in the project; The project code corresponding to the project, and the parameters corresponding to each module included in each project, obtain the target code corresponding to the target object.

For example, when the target object is platform A, platform A includes two projects: project A and project B, and project A includes three modules: module 1, module 2, and module 3, and project B includes two modules: module 4 and module 5 hour.

If the target function is the first type of function, respectively obtain the item codes corresponding to item A and item B respectively, and the target codes include the item codes corresponding to item A and item B respectively.

If the target function is the second type of function, for project A, first obtain the project code of project A, and the corresponding parameters of module 1, module 2, and module 3 respectively. Then according to the parameters corresponding to module 1 and the project code of project A, the first target code is obtained; according to the parameters corresponding to module 2 and the project code of project A, the second target code is obtained; according to the parameters corresponding to module 3 and the project of project A code to get the third object code. For project B, first obtain the project code of project B, and the corresponding parameters of module 4 and module 5 respectively. Then according to the parameters corresponding to module 4 and the project code of project B, the fourth target code is obtained; according to the parameters corresponding to module 5 and the project code of project B, the fifth target code is obtained. Wherein, the object code includes a first object code, a second object code, a third object code, a fourth object code, and a fifth object code.

S300: Run the command script to process the target code corresponding to the target function, and obtain a processing result.

After the command script and the target code are obtained, the target code can be processed corresponding to the target function by running the command script, and the processing result can be obtained.

To process a project, you generally have to first enter the local directory of the project. Some functions, such as updating, submitting, querying, etc., do not require the participation of the project's own scripts, because these operations are related to the tools (such as git or svn) used by the project to host the code server. Therefore, these operations only need to call the compilation server installation corresponding tools. However, some functions such as compilation, debugging, release, etc. require the participation of the command script that comes with the project, and the function and the list of modules that need to be operated need to be passed to the command script.

Functions that do not require the participation of the project's own scripts, such as update, submission, and common queries (such as project version and submission log, status (whether there are local modifications), local modified content, etc.) can be used in git or svn tools Single or a combination of multiple commands to achieve. More complex queries (such as how many commits have not been updated on the hosting server, specific modification content, checking whether the compilation results of each module of the project have been published, etc.), can be completed through scripts combined with commands in git or svn tools.

For the aforementioned four project types, a common script can be used to complete compilation, debugging, and release. That is to say, when adding projects later, you only need to set a simple script to download and execute the general script, and then you can realize the compilation, debugging, and release of each project, which simplifies the project maintenance work. Since this general script needs to support the three functions of compiling, debugging, and publishing, when calling this general script, you need to pass in various parameters, as shown in Table 2:

Table 2

The parameters passed by the three commands have the command itself, platform name, project name, and module list. The command itself is used to tell the generic script which branch of processing to enter to operate on. The combination of platform name, project name, and module can be guaranteed to be unique, that is, as long as the file named "module" is saved according to the directory structure of "platform name/project name/module", all the files of a certain platform can be guaranteed. Modules are placed under the "platform name" directory without conflicts.

The specific compilation process is related to the project type in Table 1.

For the first type of project, first copy the configuration file corresponding to the module to compile the dependent configuration file for the project, and then run the compile command to compile.

For the second type of project, pass the compiler and compilation options to the compilation command to compile.

For the third type of project, pass the master control name, compiler and compilation options to the compilation command and compile. In the project compilation script, the master control name can be used to distinguish which function blocks are compiled into it. Since this type of module name is prefixed with the master name, the master name can be extracted from the module name.

For the fourth type of project, enter the subdirectory with the same name of each module, and run the compile command to compile.

It is difficult for general scripts to determine which of the previous four categories a project belongs to. You can configure the project type in the project configuration file, and the general script can be obtained from the configuration file.

After the compilation is successful, the general script can copy the compilation result to "<specified directory>/<platform name>/<project name>/<module>". If the compilation result is a library, you also need to copy the header file. Among them, "<specified directory>" is used to share the compiled libraries and tools with other projects, so that they can follow the "<platform name>/<project name>/<module>" from the "<specified directory>". >" rule to find dependent libraries and header files.

The function of debugging is to verify whether the result of the previous compilation works as expected. The process of debugging is: first enter the directory where the local project is located, run the general script, and copy the compilation results generated by the compilation to "<debugging directory>/<platform name>/<project name>/<module>" one by one according to the module list . "<debug directory>" is the temporary directory created by the product program, which is generally stipulated by the program packaging environment. The script for making the product program obtains resources from this directory, compiles them into the application program, or packs them into the image file.

The function of publishing is to submit the previously verified compilation results to the publishing server for use by other developers. The compilation result may be a library, a tool, or some other files (such as uboot, kernel, etc., which are executable after compilation). If the compiled result is a library, you also need to submit the header file for inclusion by other developers. Libraries are divided into static libraries and dynamic libraries. Static libraries are used for linking when compiling applications. Dynamic libraries need to be released together with applications for dynamic loading by applications.

The publishing process is to first download the previously submitted version from the "project compilation result corresponds to the URL on the publishing server" to the directory specified locally, and then enter the directory where the local project is located, and compile the result according to the module list Copy them to the local specified directory one by one, the specific path can be "<specified directory>/<platform name>/<project name>/<module>", if the result of compilation is a library, you also need to copy the header file to " <module>" directory. Finally, go to "<specified directory>" and submit the modified files to the publishing server. The aforementioned publishing process can be completed using scripts.

Optionally, if you need to add a master control, first determine whether the compiler and basic compilation options of the master control are the same as those of an existing platform. If so, add the master control to the "Master Control List and Platform Corresponding Configuration File". If the newly added master control has new items to be added, the items are added according to the rules. If the newly added master control belongs to a new platform, create a new platform directory (which can be named after this master control) under the platform configuration directory, and add the corresponding project configuration file under it.

In one embodiment, a visual interface may also be included. By setting the visual interface, the user can select the target object and the target function more intuitively, and further improve the user experience. Correspondingly, responding to the user's first operation command based on the function list includes: responding to the user's first operation command based on the function list displayed on the visual interface. Similarly, responding to the user's second operation command based on the object list includes: responding to the user's second operation command based on the object list displayed in the visual interface.

Wherein, the visual interface may include a platform list, a project list, a function list, and in addition, a module list.

The function list may include at least one function of downloading, updating, submitting, querying, compiling, debugging and publishing.

For ease of understanding, the visual interface includes a platform list, a project list, a module list, and a function list as an example for illustration, please refer to FIG. 2 . For the convenience of subsequent operations, a directory (such as Platforms) can be created in the project operating system to store platform-related configurations. Create a directory for each platform under this directory, name the directory with the platform name, and then create a configuration file under the platform directory to record the names of all projects contained in the platform (considering that some project names are relatively long, you can use abbreviated abbreviated name, easy to remember), and the URL (UniformResource Locator, Uniform Resource Locator) of the project on the code server.

The list of platform names in the menu can be obtained by enumerating the directory names named after the platform names created earlier. If all platform configurations are placed in the Platforms directory, just traverse all the directories in this directory to obtain the directory name, and each directory name is a platform name.

The project list includes project names of all projects corresponding to the selected platform. Wherein, the project name can be obtained by analyzing the configuration file under the directory of the selected platform.

The module list includes the module names corresponding to all the modules contained in the selected project.

The module name can be obtained by going to the local directory of the selected project, and then running the default "list modules" script.

Specifically, for category 1 projects, if all product-related or module-specific configurations corresponding to the project are placed in the Configs directory of their respective projects, then traverse all the files in the Configs directory to obtain each file in the Configs directory name, each file name is a module name.

For type 2 projects, just get the module name from the project configuration file.

For the third type of project, the project alias is obtained from the project configuration file, and then each master control name corresponding to the platform is added to the alias as the module name. Wherein, the quantity of the main control is the same as the quantity of the modules.

For the fourth type of project, traverse all directories under the project directory to obtain the directory name, and each directory name is a module name.

Specifically, when the object list includes a project list, a module list and a platform list, the project list corresponding to the target platform may be displayed on the visual interface in response to the user's operation of selecting the target function and the target platform. Then, in response to the user's operation of selecting the target item, it is judged whether the object of execution of the target function is the item; if not, a list of modules corresponding to the target item is displayed in the visual interface.

Wherein, after the selection of the target object and the target function is completed, the user can click the "Confirm" menu to execute S100 and S200. If the user selects "Cancel", the menu interface will be exited in response to the user's operation.

Optionally, since the visual interface also includes a determination option, in response to the user's first operation command based on the function list, obtain the command script corresponding to the target function selected by the first operation command; and in response to the user's second operation command based on the object list, The process of obtaining the target code corresponding to the target object selected by the second operation command may be: in response to the user's operation of selecting the first operation instruction of the target function, the second operation instruction of selecting the target object, and selecting the confirmation option, saving the target object selected by the user and the target function, and obtain the target code corresponding to the target object and the command script corresponding to the target function.

In one embodiment, the implementation of the visual interface may be as follows: firstly, the script is used to obtain the information required for building the visual interface, and a filled json file (marked as: MenuFile.json) is obtained.

Since the required functions can be determined in advance, the content of the "command list" can be directly set, that is, each function corresponds to a name.

The field value of "<platform name i>" in the visual interface is obtained by traversing all directories under the Platforms directory (all platform configurations are placed under the Platforms directory) to obtain the directory name.

The value of the field "<project name j>" in the visual interface is obtained by analyzing the configuration files in each platform directory under the Platforms directory. It should be noted that "<project name j>" and "<platform name i>" corresponding relationship.

"<module k>" in the visual interface is obtained through the script of the corresponding project. When operating for the first time, you need to download the corresponding project to a specific local directory, and then call the script in the project to obtain the module list. After that, if the module of the project changes, the script must be called to reacquire the module list and update to the json file. Among them, the local specific directory can be selected according to actual needs, and it is not limited here.

After obtaining the information required to build the visual interface through the script, you can use the script to fill in the MenuFile.json file. After the MenuFile.json is filled in, the initial selected state of the menu item can be realized by modifying the status code of each option in the file. For example, a status code of 1 may indicate that it is selected, and a status code of 0 may indicate that it is not selected. Modifying each option and its status code in the file can be realized through a text editor or a specially developed Linux or Windows tool.

Because json files are easy to use and widely used, there are many open source projects that can analyze json files. Therefore, it is very appropriate to use json files as configuration files for building visual interfaces.

The json file saves a series of objects, and each object exists as a key-value pair. The key is generally a string, and the value can be a simple string or a value, or an object or an array. Since there are many forms of values, the description of the same thing, the way of writing the json file will also be diversified. For example, the json file content can be:

where "..." is an ellipsis.

The left side of the colon (:) is the key, and the right side is the value, forming a key-value pair.

Everything enclosed by {} is an object, and {} can be omitted in some cases. Each key-value pair is an object whether it is enclosed in {} or not.

Arrays are enclosed in []. The members in the array can be numbers, strings or objects, etc., and the members are separated by commas.

Fields enclosed by <> are to be replaced with actual values.

The status code is a number (such as 0,1,2), indicating the state of the corresponding menu being selected: not selected (such as represented by the number 0), selected but not highlighted (such as represented by the number 1), selected and highlighted (as indicated by the number 2).

The above exemplified json files are for ease of understanding only, and are not intended to limit this application.

The previous section describes how to generate the configuration file of the visual interface. The following example illustrates how to implement the visual interface through the configuration file MenuFile.json under the Linux operating system.

According to the characteristics of the json file, it can be parsed into a structure array, and the hierarchy is preserved through nesting. For example, to parse the json file MenuFile.json, its first-level structure (denoted as stMenuFile) contains an array of command structures (denoted as astCommands[i], where the value of i ranges from 0 to the number of commands minus 1) and each platform structure array (Denoted as astPlatforms[i], i ranges from 0 to the number of platforms minus 1). The command structure contains status codes and specific command strings. The platform structure contains a status code and an array of project structures (denoted as astProjects[j], j takes a value from 0 to the number of projects minus 1), while the project structure array contains a status code and an array of module structures (denoted as astModules [k], k ranges from 0 to the number of modules minus 1); the module structure contains the status code and the specific module name string. Through this nesting method, it can not only include all the key-value pairs in the json file, but also retain the hierarchy. When parsing a json file into a structure array for the first time, you can set the status code of the first item in each list to be selected and highlighted.

If the server is based on the Linux operating system (this is generally the case in embedded development environments), developers can remotely log in to the server for development through terminal simulation software (such as Xshell, Putty, SecureCRT, etc.), so when designing a visual interface, you also need to consider your own Whether the terminal emulation software used supports interface display. It has been verified by the inventors that both the open-source ncurses library and the popular Python can support interface display, and the example here is only for easy understanding, and should not be used as a limitation to this application.

Since the open-source ncurses library supports both keyboard and mouse operations, it is easy to write programs that meet the requirements. The following will illustrate the design of the visual interface based on the ncurses library. Since the ncurses library is written in C language, it is necessary to convert the structure obtained by parsing the json file MenuFile.json into a format supported by C language. You can use C language to develop a tool for parsing json files and implementing menu operations, use shell scripts to call the tool, present the visual interface to project developers, and respond to user operations on the visual interface.

The menu items in the same list can be selected multiple times, and there are dependencies between the upper and lower lists (such as platform list and project list), which makes menu operations complicated. The "command list" only needs to support single selection. "Platform List", "Project List" and "Module List" can all support multi-selection. The "Project List" depends on the currently selected "Platform Name", while the "Module List" depends on the currently selected "Project Name", that is, the current "Project List" includes all the projects included in the currently selected platform. The "Module List" of the "Module List" includes all the modules included in the currently selected project.

In order to improve user experience, in one embodiment, the display of selected and unselected menu items should be differentiated, for example, it can be distinguished by font color, and the selected option is set to display red, and the unselected option is displayed black. The examples here are only for ease of understanding, and are not intended to limit the application.

Since the "platform list", "project list" and "module list" can all support multi-selection, for menu items that support multi-selection, multiple menu items in the same list may be selected, and the menu list of the next level and One of the items is related, and the display of this item should be different. For example, the color used when the font is displayed is selected, and the background color is also set to a different color (such as blue). After the visual interface design is completed, the user can use the arrow keys or the mouse to select the menu. The difference between using the arrow keys and the mouse operation is: using the arrow keys can only move up, down, left, and right to different menu items one by one, and will not move out of the menu items; while using the mouse, you can move to any position on the screen, and the mouse may fall. outside the menu item. Which menu item the mouse cursor falls on is determined by judging whether the coordinates of the mouse cursor on the screen fall within the range of the menu item.

When using the keyboard to operate, for the convenience of the user, when using the arrow keys to move the cursor to a menu item, you can add a color (such as green) to the background of the menu item to distinguish it. It should be noted that the The background color needs to be different from the aforementioned: the background color displayed on the item associated with the lower menu list and the currently selected option.

Use the keyboard to operate, and you can set the Enter key to confirm, that is, when the user clicks the Enter key, it is considered that the currently selected menu item is to be operated. The examples here are only for ease of understanding, and are not intended to limit the application.

When using the mouse to operate, since the mouse cursor itself is a symbol that can be used to remind the user, when using the mouse to operate, when the mouse is moved to the menu item, it is not necessary to add color to the background of the menu item.

Use the mouse to operate, and you can set the left button of the mouse to confirm, that is, when the user clicks the left button of the mouse, it is considered that the currently selected menu item is to be operated. The examples here are only for ease of understanding, and are not intended to limit the application.

When the user performs a confirmation operation, change the display state of the selected menu item. If the menu item has not been selected before, the menu item will appear in the selected state, and the menu item can be highlighted (such as the background color when it is selected) ). At the same time, the next-level menu changes accordingly. For example, when the user selects item A in the item list, item A will be presented as selected, item A will be highlighted, and all modules corresponding to item A will be displayed in the module list.

If the menu item has been selected before but not in the highlighted state, the menu item will be highlighted, and the next level menu will change accordingly.

If the menu item has been selected and highlighted before, the menu item will appear as unselected, and the selected menu item before or after the same list will be highlighted, and the next level menu will change accordingly. If there are no other selected menu items, the lower level menu is hidden.

In short, the displayed content of the lower-level menu item is associated with the selected and highlighted menu item of the upper-level menu item.

Each menu item in the same list is single-selected. If another one is selected, the state of the previously selected menu should automatically become unselected, and the next-level menu will change accordingly.

It should be noted that in the list of options that can be selected multiple times, there is an option of "<all>". Simply checking the "<all>" option means that all options in that list are checked. At this point, the original highlighted menu item remains unchanged. When "<All>" is selected, and then "<All>" is unselected, it means that all subsequent items are not selected, and correspondingly, the lower menu items are hidden accordingly. Whether you check "<all>" or uncheck "<all>", you can continue to check or uncheck all subsequent items individually. When not all the following items are selected, the "<all>" item is set as unselected.

Wherein, the menu item "all" is a virtual menu item, and it is meaningless to display and highlight it, so the highlight may not be displayed. When the user selects a menu each time, it can be judged whether the menu item currently selected by the user is a "confirm" or "cancel" menu item. If it is the "Confirm" menu item, save the status modification of each menu item to the MenuFile.json file, and if it is the "Cancel" menu item, exit directly.

Based on the same inventive concept, the present application also provides an item operating system. As shown in FIG. 3 , the item operating system 100 includes an acquisition module 110 and a processing module 120 .

The obtaining module 110 is configured to obtain a command script corresponding to a target function selected by the first operation command in response to a user's first operation command based on the function list.

The acquisition module 110 is further configured to acquire the target code corresponding to the target object selected by the second operation command in response to the user's second operation command based on the object list.

The processing module 120 is configured to run the command script to perform processing corresponding to the target function on the target code to obtain a processing result.

The acquisition module 110 is specifically configured to if the target function is a first-type function, the object list includes a list of items, and the list of items includes one or more items, each of which corresponds to an item code, and each of the items The project includes at least one module; all modules under the same project share the same project code, and each module corresponds to a set of parameters. If the target object is the target project, obtain the project code of the target project, and the The item code is the object code.

The acquisition module 110 is specifically used to if the target function is a second type of function, the object list includes a project list and a module list, each item in the project list corresponds to a module list, and each item corresponds to a project code , each module in the same module list shares the project code corresponding to the project corresponding to the module list, and each module corresponds to a set of parameters. If the target object includes a target project and a target module, obtain the project code corresponding to the target project, And acquiring the target parameter corresponding to the target module; obtaining the target code corresponding to the target object according to the target parameter and the project code corresponding to the target item.

The acquiring module 110 is specifically configured to acquire the command script corresponding to the target function selected by the first operation command in the operating system, or acquire the command script corresponding to the first operation in the item corresponding to the target object. The script corresponding to the target function selected by the command.

The obtaining module 110 is specifically configured to respond to a user's first operation command based on the function list displayed in the visual interface.

The acquisition module 110 is also used to respond to the user's operation of selecting the target function and the target platform, display the item list corresponding to the target platform in the visual interface; respond to the user's operation of selecting the target item, and determine the execution object of the target function Whether it is a project; if not, a list of modules corresponding to the target project is displayed on the visual interface.

The obtaining module 110 is further configured to include a determination option in the visual interface, responding to the user's operation of selecting the first operation instruction of the target function, selecting the second operation instruction of the target object, and selecting the determination option, The target object and the target function selected by the user are saved, and the target code corresponding to the target object and the command script corresponding to the target function are acquired.

In one embodiment, the function list includes at least one function of downloading, updating, submitting, querying, compiling, debugging and publishing.

The project operating system 100 provided by the embodiment of the present application has the same realization principle and technical effect as the aforementioned data processing method embodiment. For a brief description, for the parts not mentioned in the project operating system embodiment, refer to the aforementioned data processing Corresponding content in the method embodiment.

Please refer to FIG. 4 , which is an electronic device 200 provided in an embodiment of the present application. The electronic device 200 includes: a transceiver 210 , a memory 220 , a communication bus 230 , and a processor 240 .

The components of the transceiver 210, the memory 220, and the processor 240 are directly or indirectly electrically connected to each other to realize data transmission or interaction. For example, these components can be electrically connected to each other through one or more communication buses 230 or signal lines. Wherein, the transceiver 210 is used for sending and receiving data. The memory 220 is used to store computer programs, such as the software function modules shown in FIG. 3 , that is, the project operating system 100 . Wherein, the project operating system 100 includes at least one software function module that can be stored in the memory 220 in the form of software or firmware (firmware) or solidified in the operating system (operating system, OS) of the electronic device 200 . The processor 240 is configured to execute executable modules stored in the memory 220 , such as software function modules or computer programs included in the project operating system 100 . At this time, the processor 240 is configured to respond to the user's first operation command based on the function list, and obtain the command script corresponding to the target function selected by the first operation command; respond to the user's second operation command based on the object list, and obtain the The target code corresponding to the target object selected by the second operation command; running the command script to perform processing corresponding to the target function on the target code to obtain a processing result.

Wherein, memory 220 can be, but not limited to, random access memory (Random Access Memory, RAM), read-only memory (Read Only Memory, ROM), programmable read-only memory (Programmable Read-OnlyMemory, PROM), erasable Erasable Programmable Read-Only Memory (EPROM), Electric Erasable Programmable Read-Only Memory (EEPROM), NOR Flash, NAND Flash ), Embedded MultiMedia Card (eMMC), etc.

The processor 240 may be an integrated circuit chip with signal processing capability. Above-mentioned processor can be general-purpose processor, comprises central processing unit (Central Processing Unit, CPU), network processor (NetworkProcessor, NP) etc.; Can also be Digital Signal Processor (Digital Signal Processor, DSP), ASIC (Application Specific Integrated Circuit, ASIC), Field Programmable Gate Array (Field Programmable Gate Array, FPGA) or other programmable logic devices, discrete gate or transistor logic devices, discrete hardware components. Various methods, steps, and logic block diagrams disclosed in the embodiments of the present application may be implemented or executed. The general purpose processor may be a microprocessor or the processor 240 may be any conventional processor or the like.

Wherein, the above-mentioned electronic device 200 includes but not limited to a personal computer, a server, and the like.

The embodiment of the present application also provides a non-volatile computer-readable storage medium (hereinafter referred to as storage medium), on which a computer program is stored, and when the computer program is run by a computer such as the above-mentioned electronic device 200, the The data processing method shown above. The computer-readable storage medium includes: U disk, mobile hard disk, read-only memory (Read-Only Memory, ROM), random access memory (Random Access Memory, RAM), magnetic disk or optical disk, etc., which can store program codes. medium.

The above descriptions are only preferred embodiments of the present application, and are not intended to limit the present application. For those skilled in the art, there may be various modifications and changes in the present application. Any modifications, equivalent replacements, improvements, etc. made within the spirit and principles of this application shall be included within the protection scope of this application.

Claims (10)

1. A method of data processing, comprising:

responding to a first operation command of a user based on a function list, and acquiring a command script corresponding to a target function selected by the first operation command;

Responding to a second operation command of a user based on an object list, and acquiring a target code corresponding to a target object selected by the second operation command;

and running the command script to perform processing corresponding to the target function on the target code to obtain a processing result.

2. The method of claim 1, wherein if the target function is a first type of function, the object list comprises an item list, the item list comprising one or more items, each item corresponding to an item code, each item comprising at least one module; all modules under the same item share the same item code, each module corresponds to a group of parameters, and if the target object is a target item, the obtaining the target code corresponding to the target object selected by the second operation command includes:

and acquiring the item code of the target item, wherein the item code of the target item is the target code.

3. The method according to claim 1, wherein if the target function is a second type of function, the object list includes an item list and a module list, each item in the item list corresponds to a module list, each item corresponds to an item code, each module in the same module list shares the item code corresponding to the item corresponding to the module list, each module corresponds to a set of parameters, and if the target object includes a target item and a target module, the acquiring the target code corresponding to the target object selected by the second operation command includes:

Acquiring item codes corresponding to the target items and target parameters corresponding to the target modules;

and obtaining the target code corresponding to the target object according to the target parameter and the item code corresponding to the target item.

4. The method of claim 1, wherein obtaining a command script corresponding to the target function selected by the first operation command comprises:

and acquiring a command script corresponding to the target function selected by the first operation command, which is carried by the operating system, or acquiring a script corresponding to the target function selected by the first operation command, which is carried by the item corresponding to the target object.

5. The method of claim 1, wherein responding to the first user operation command based on the function list comprises:

and responding to a first operation command of the user based on the function list displayed in the visual interface.

6. The method of claim 5, wherein the list of objects comprises a list of items, a list of modules, and a list of platforms, the method further comprising:

responding to the operation of selecting a target function and a target platform by a user, and displaying a project list corresponding to the target platform in the visual interface;

Responding to the operation of selecting a target item by a user, and judging whether an execution object of the target function is the item; and if not, displaying a module list corresponding to the target item in the visual interface.

7. The method according to claim 6, wherein the visual interface further comprises a determination option, and the response user obtains a command script corresponding to a target function selected by the first operation command based on the first operation command of the function list; responding to a second operation command of a user based on an object list, and acquiring an object code corresponding to an object selected by the second operation command, wherein the method comprises the following steps:

responding to a first operation instruction of selecting the target function by a user, a second operation instruction of selecting the target object and selecting the determination option, storing the target object and the target function selected by the user, and acquiring a target code corresponding to the target object and a command script corresponding to the target function.

8. An item operating system, comprising:

the acquisition module is used for responding to a first operation command of a user based on a function list and acquiring a command script corresponding to a target function selected by the first operation command;

The acquisition module is further used for responding to a second operation command of the user based on the object list and acquiring a target code corresponding to a target object selected by the second operation command;

and the processing module is used for running the command script so as to perform processing corresponding to the target function on the target code to obtain a processing result.

9. An electronic device, comprising: the device comprises a memory and a processor, wherein the memory is connected with the processor;

the memory is used for storing programs;

the processor is configured to invoke a program stored in the memory to perform the method according to any of claims 1-7.

10. A computer-readable storage medium, on which a computer program is stored, which computer program, when being run by a computer, performs the method according to any one of claims 1-7.

Images