Development method, device and equipment for automatic driving graphical application framework

Abstract

The invention relates to the technical field of development of automatic driving graphical application frameworks, and discloses a method, a device and equipment for developing an automatic driving graphical application framework. According to a compiling result and a monitoring result of at least one target client application, the at least one target client application is uniformly developed at the same time; the compiling process and the monitoring process can be executed in a unified mode, and errors can be processed and exceptions can be captured in a unified mode on the basis of the compiling result and the monitoring result of at least one target client application. Therefore, the development efficiency and the debugging efficiency can be improved, unified program maintenance and unified debugging are carried out on client applications of multiple platforms, more developers of a non-directional operating system can be assisted to easily and quickly start to develop, and finally the development process of a project is accelerated.

Description

Technical Field

[0001] The present invention relates to the technical field of development of an autonomous driving graphical application framework, and in particular to a method, device, and equipment for developing an autonomous driving graphical application framework. Background Art

[0002] With the development of autonomous driving application technology, the diversity and complexity of client interface applications are also increasing. Desktop applications are used as auxiliary applications in all aspects, and a universal desktop client development framework is urgently needed. Among them, cross-platform desktop client development is becoming more and more popular. The cross-platform desktop client development framework allows developers to run desktop applications on multiple operating systems.

[0003] In the related technologies, during the cross-platform desktop development process of autonomous driving, developers manually design the organizational structure, layered architecture, and adaptation API interface of the client application throughout the entire process, which affects the development efficiency of the desktop client and makes the development process more complicated and difficult to meet development needs. Summary of the invention

[0004] In view of this, the present invention provides a method, device, equipment and product for developing an autonomous driving graphical application framework to solve the problems that affect the development efficiency of the desktop client and cause the development process to be more complicated and difficult to meet development needs.

[0005] According to a first aspect, an embodiment of the present disclosure provides a method for developing an autonomous driving graphical application framework, the method comprising:

[0006] Receiving a framework development start instruction of at least one target client application and a source code corresponding to at least one target client application;

[0007] Based on the framework development startup instructions of at least one target client application, the source code of at least one target client application is compiled and monitored through the automated scaffolding, and the compilation result and the monitoring result are output;

[0008] At least one target client application is developed based on the compilation result and the monitoring result of the at least one target client application.

[0009] The disclosed embodiment uses the compilation result and monitoring result of at least one target client application to uniformly develop at least one target client application at the same time, and can uniformly execute the compilation process and the monitoring process, and then based on the compilation result and monitoring result of at least one target client application, can uniformly handle errors and uniformly capture exceptions. Therefore, the disclosed embodiment can improve development efficiency and debugging efficiency, uniformly perform program maintenance and unified debugging on client applications of multiple platforms, and can assist more non-directional operating system developers to easily and quickly get started with development, which is ultimately conducive to speeding up the development process of the project.

[0010] In some optional implementations, at least one target client application includes: a Windows platform client application, a MacOS platform client application, a Linux platform client application, and an Android platform client application;

[0011] Among them, the Windows platform client application is configured with the Windows operating system and automatically adapts to the Windows type API interface, the MacOS platform client application is configured with the MacOS operating system and automatically adapts to the MacOS type API interface, the Linux platform client application is configured with the Linux operating system and automatically adapts to the Linux type API interface, and the Android platform client application is configured with the Android operating system and automatically adapts to the Android type API interface.

[0012] By executing the above implementation method, various cumbersome and complex API interfaces are automatically adapted, which not only reduces the complexity of developers' manual adaptation projects, but also facilitates unified data management and enhances the versatility of data processing.

[0013] In some optional implementations, developing at least one target client application based on the compilation result and the monitoring result of at least one target client application includes:

[0014] Based on the compilation result and monitoring result of at least one target client application, determining whether it is necessary to call a debugging tool to debug the source code of each target client application;

[0015] If yes, debug the source code of each target client application by using a debugging tool, and develop at least one target client application based on the debugged source code of each target client application;

[0016] If not, at least one target client application is developed directly according to the source code of each target client application through the startup mode.

[0017] By executing the above implementation mode, the startup process is executed through the automated scaffolding, and the automated scaffolding background completes pre-compilation through a framework development startup instruction. According to the monitoring result of at least one target client application, it is determined whether to open the debugging tool, thereby avoiding the inefficient operation and time cost caused by manual compilation, manual debugging and manual startup. The correctness of the code is monitored in real time during the coding process. Developers can check the error situation during the development process and deal with it in time, avoiding repeated debugging work and improving development efficiency.

[0018] In some optional implementations, compiling and monitoring the source code of at least one target client application by automated scaffolding includes:

[0019] Through automated scaffolding, monitor whether there are any missing dependencies in the source code of at least one target client application;

[0020] If so, automatically download the dependencies and recompile the source code of at least one target client application through automated scaffolding;

[0021] If not, compile the source code of at least one target client application according to the custom rule or the template rule through the automated scaffolding, wherein when the custom rule conflicts with the template rule, the custom rule is used first.

[0022] By executing the above implementation method, it is helpful to simplify the overall operation process of compilation.

[0023] In some optional implementations, the method for developing an autonomous driving graphical application framework in the embodiments of the present disclosure further includes:

[0024] During the process of compiling the source code of at least one target client application, the cache data is cached in the client application through session cache, local cache or temporary cache, or cached in the underlying operating system through security cache or file cache.

[0025] In some optional implementations, the cache data in the end and the cache data of the underlying operating system are permanently stored or relationally stored through a mysql database or a SQLite database. Both the mysql database and the SQLite database include: a data entity unit, a data filtering unit, a data generation unit, a data service unit, a data storage unit, a data mapping unit, a data update unit, a data deletion unit, and a data query unit.

[0026] By executing the above implementation, it is beneficial to flexibly switch between different data storage modes.

[0027] In some optional implementations, the method for developing an autonomous driving graphical application framework in the embodiments of the present disclosure further includes:

[0028] receiving a development request instruction of at least one target client application;

[0029] Based on the development request instruction, IPC communication files or http communication files are generated through the communication middle layer, communication core layer, and communication adaptation layer in sequence;

[0030] Send IPC communication files or http communication files to the server;

[0031] If an error occurs in an IPC communication file or an http communication file, the erroneous IPC communication file or http communication file returned by the server is sent to at least one target client application through the communication core layer and the communication middle layer in sequence.

[0032] By executing the above implementation, the underlying communication structure is comprehensively and uniformly optimized, and a communication intermediate layer is introduced, which can process data in batches, and can filter and intercept data during data transmission, greatly improving the efficiency and security of communication. At the same time, the disclosed embodiment supports IPC communication files and http communication files, that is, supports the adaptation of IPC and HTTP protocols, so that the application layer can flexibly choose according to needs, and the underlying structure can automatically adapt to these two protocols, ensuring the stability and isolation of communication.

[0033] In some optional implementations, the method for developing an autonomous driving graphical application framework in the embodiments of the present disclosure further includes:

[0034] At least one target client application is developed through a background processing slot, a view interface slot, and a tool slot of at least one target client application.

[0035] In some optional implementations, after developing at least one target client application, the method further includes:

[0036] Open at least one target client application and receive a plug-in loading trigger instruction and a target loading file;

[0037] Based on the plug-in loading trigger instruction, the target loading file is decompressed to obtain the plug-in view and plug-in program;

[0038] Loading the plug-in view into an interface of at least one target client application, and running the plug-in program in the program background;

[0039] updating at least one target client application after the plugin is loaded;

[0040] After the plug-in is loaded, if a plug-in uninstall trigger instruction is received, the plug-in view and plug-in program are deleted at the same time.

[0041] By executing the above implementation mode and designing a slot loading mechanism, it is beneficial for the target client application to be able to be easily and flexibly expanded.

[0042] In some optional implementations, running the plug-in program in the program background includes:

[0043] Monitor whether the plug-in is compatible with the main application;

[0044] If so, load the plug-in in the main application;

[0045] If not, based on the context object attribute information and the main application business information, the incompatibility problem between the plug-in program and the application program is handled through a preset compatibility processing action.

[0046] By executing the above implementation, it is helpful to optimize the compatibility experience and interaction experience between the main application and the plug-in.

[0047] In some optional implementations, the method for developing an autonomous driving graphical application framework in the embodiments of the present disclosure further includes:

[0048] receiving packaging instructions for each target client application;

[0049] Merge the program files corresponding to each target client application;

[0050] Check whether the program file corresponding to each target client application is a plug-in program;

[0051] If yes, compile and encode the program files corresponding to each target client application in sequence to generate a plug-in extension executable file for each target client application;

[0052] If not, the program files corresponding to each target client application are parsed, compressed, and packaged in sequence, and a factory-configured executable file of each target client application is generated.

[0053] By executing the above implementation, convenient packaging of different platform clients and operation modes is achieved through a packaging instruction of the target client application. This packaging instruction cleverly integrates public configuration and targeted configuration. After type verification, it can automatically call the underlying packaging mechanism and accurately output the executable files required by the respective platform clients. If a plug-in needs to be generated, based on the packaging instruction, the plug-in compressed package is automatically created. These compressed packages can be easily loaded into independent applications and run as extensions, thereby further enriching the application functions.

[0054] In some optional embodiments, at least one target client application is configured on the desktop of the autonomous driving vehicle terminal.

[0055] According to a second aspect, an embodiment of the present disclosure provides a device for developing an autonomous driving graphical application framework, the device comprising:

[0056] A receiving module, used to receive a framework development startup instruction of at least one target client application and a source code corresponding to at least one target client application;

[0057] A compilation module, for developing startup instructions based on the framework of at least one target client application, compiling and monitoring the source code of at least one target client application through an automated scaffold, and outputting compilation results and monitoring results;

[0058] The development module is used to develop at least one target client application based on the compilation result and the monitoring result of at least one target client application.

[0059] According to a third aspect, an embodiment of the present disclosure provides a computer device, including:

[0060] The memory and the processor are communicatively connected to each other, the memory stores computer instructions, and the processor executes the method for developing an autonomous driving graphical application framework in the first aspect or any embodiment of the aspect by executing the computer instructions.

[0061] According to the fourth aspect, an embodiment of the present disclosure provides a computer-readable storage medium, on which computer instructions are stored, and the computer instructions are used to enable a computer to execute the method for developing an autonomous driving graphical application framework in the first aspect or any embodiment of the first aspect. BRIEF DESCRIPTION OF THE DRAWINGS

[0062] In order to more clearly illustrate the specific implementation methods of the present invention or the technical solutions in the prior art, the drawings required for use in the specific implementation methods or the description of the prior art will be briefly introduced below. Obviously, the drawings described below are some implementation methods of the present invention. For ordinary technicians in this field, other drawings can be obtained based on these drawings without paying creative work.

[0063] Figure 1 is a flowchart of a method for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0064] Figure 2 is a flowchart of another method for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0065] Figure 3 is another schematic diagram of an automated startup process according to an embodiment of the present invention;

[0066] Figure 4is a flowchart of another method for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0067] Figure 5 is another schematic diagram of an automated compilation process according to an embodiment of the present invention;

[0068] Figure 6 is a schematic diagram of different caching methods according to an embodiment of the present invention;

[0069] Figure 7 is a schematic diagram of different database functional units according to an embodiment of the present invention;

[0070] Figure 8 is a schematic diagram of program execution according to an embodiment of the present invention;

[0071] Fig. 9 is a flowchart of another method for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0072] Fig.10 is a schematic diagram of unified communications according to an embodiment of the present invention;

[0073] Fig.11 is a schematic diagram of different functional slots according to an embodiment of the present invention;

[0074] Fig.12 is a flowchart of another method for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0075] Fig.13 is a schematic diagram of inserting a slot in a target client application according to an embodiment of the present invention;

[0076] Fig.14 is a schematic diagram of information related to context objects according to an embodiment of the present invention;

[0077] Fig.15 is a flowchart of another method for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0078] Fig.16 is a schematic diagram of one-click packaging of each target client application according to an embodiment of the present invention;

[0079] Fig.17 is a structural block diagram of a device for developing an autonomous driving graphical application framework according to an embodiment of the present invention;

[0080] Fig.18 Schematic diagram of the hardware structure of a computer device according to an embodiment of the present invention. DETAILED DESCRIPTION

[0081] In order to make the purpose, technical solution and advantages of the embodiments of the present invention clearer, the technical solution in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those skilled in the art without creative work are within the scope of protection of the present invention.

[0082] In the field of autonomous driving, tool application is an indispensable component. In traditional development practices, native desktop technologies such as C++'s Qt, Python's PyQT and other GUIs are required, which makes the construction and development work cumbersome and diverse, and the development difficulty and threshold are greatly increased. There is no unified special solution. When developing an application framework on a cross-platform desktop, developers are required to build and develop multi-platform application tools.

[0083] Therefore, in the process of cross-platform desktop development of autonomous driving, developers manually design the organizational structure, layered architecture, and adaptation API interface of the client application throughout the process, which affects the development efficiency of the desktop client and makes the development process more complicated and difficult to meet development needs.

[0084] Based on the above problems, this framework encapsulates the underlying layer and unifies the desktop client application development method. The upper-level application does not need to worry about the construction and underlying call logic and processing process, and reduces the difficulty so that developers from all walks of life can easily get started and quickly build autonomous driving desktop client tools. The development of tools is upgraded from the underlying technology system to framework development, and a full set of out-of-the-box cross-platform functional systems such as building, development, packaging, and publishing are provided. Developers only need to complete the development of the tool business itself to quickly complete the development of a multi-platform desktop client tool.

[0085] According to an embodiment of the present invention, an embodiment of a method for developing an autonomous driving graphical application framework is provided. It should be noted that the steps shown in the flowchart of the accompanying drawings can be executed in a computer system such as a set of computer executable instructions, and although a logical order is shown in the flowchart, in some cases, the steps shown or described may be executed in an order different from that shown here.

[0086] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used in computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, and autonomous driving vehicle terminals, etc. Figure 1 is a flow chart of a method for developing an autonomous driving graphical application framework according to an embodiment of the present invention. Figure 1 As shown, the process includes the following steps:

[0087] Step S101, receiving a framework development start instruction of at least one target client application and a source code corresponding to at least one target client application.

[0088] Specifically, the number of types of target client applications can be one or more, and in the embodiment of the present disclosure, framework development start instructions for one or more target client applications and source codes corresponding to one or more target client applications can be received simultaneously. When there is one type of target client application, the embodiment of the present disclosure develops the framework of the one type of target client application, and when there are multiple types of target client applications, the embodiment of the present disclosure develops the frameworks of the multiple types of target client applications simultaneously.

[0089] Specifically, with the technological development of autonomous driving applications, the diversity and complexity of client interface tools are also increasing. Interface tools are used as auxiliary applications in all aspects, and a set of general tool development frameworks for application in autonomous driving vehicle terminals is urgently needed.

[0090] In a specific example, at least one target client application in the embodiment of the present disclosure is configured on the desktop of the autonomous driving vehicle terminal. The embodiment of the present disclosure develops an autonomous driving graphical application framework on the desktop of the autonomous driving vehicle terminal.

[0091] Furthermore, the target client application can be a WeChat client application, a Weibo client application, a Douyin video client application, a Meituan client application, a Web browser client application, etc. The framework of the target client application is the bottom layer of at least one target client application built using the Elctron bottom layer tool, and further, the development method of the autonomous driving graphical application framework of the embodiment of the present disclosure performs unified encapsulation on the API interfaces of different bottom operating systems to provide a consistent application framework. The framework development startup instruction comes from an external computer device, and is used to instruct the computer device to automatically develop a framework of at least one target client application.

[0092] In a specific example, at least one target client application includes: a Windows platform client application, a MacOS platform client application, a Linux platform client application, and an Android platform client application;

[0093] Among them, the Windows platform client application is configured with the Windows operating system and automatically adapts to the Windows type API interface, the MacOS platform client application is configured with the MacOS operating system and automatically adapts to the MacOS type API interface, the Linux platform client application is configured with the Linux operating system and automatically adapts to the Linux type API interface, and the Android platform client application is configured with the Android operating system and automatically adapts to the Android type API interface.

[0094] Specifically, for example, usually for a Web browser platform, if the Windows operating system is configured, it is a Windows platform client application, if the MacOS operating system is configured, it is a MacOS platform client application, if the Linux operating system is configured, it is a Linux platform client application, and if the Android operating system is configured, it is an Android platform client application. For another example, for a WeChat client application, if the Android operating system is configured, it is an Android platform client application. For another example, some commonly used platform client applications installed through Apple mobile phones are basically configured with the MacOS platform operating system. For another example, the platform client applications for detection installed on some detection devices are configured with the Linux operating system.

[0095] Furthermore, in the traditional method, since the operating systems of various client application platforms are different, developers are usually required to use various cumbersome and complicated API interfaces to access the corresponding client application platform to realize data transmission, which is inefficient.

[0096] The disclosed embodiment automatically adapts at least one target client application to a matching API interface. For example, for a Windows platform client application configured with a Windows operating system, the API interface of the Windows operating system type is automatically adapted. The automatic adaptation method not only reduces the complexity of manual adaptation projects for developers, but also facilitates unified data management and enhances the versatility of data processing.

[0097] Step S102, based on the framework development startup instruction of at least one target client application, compile and monitor the source code of at least one target client application through the automated scaffolding, and output the compilation result and the monitoring result.

[0098] Specifically, automated scaffolding in programming usually refers to a project template tool that is used to automatically create and maintain a standardized programming project structure.

[0099] Specifically, in the traditional way, manual development cannot provide full-link support for debugging, and complex manual configuration and operation are required, especially in the debugging stage, which requires frequent packaging, resulting in additional workload and time, and ultimately affecting development efficiency. To this end, the disclosed embodiment designs an automated scaffolding, which compiles and monitors the source code of at least one target client application at the same time, so that the development process and debugging process are simplified and accelerated.

[0100] Step S103: developing at least one target client application based on the compilation result and the monitoring result of the at least one target client application.

[0101] The disclosed embodiment uses the compilation results and monitoring results of at least one target client application to uniformly develop at least one target client application at the same time. For example, at least one target client application is installed on the desktop of the mobile terminal currently used by the user, and the compilation process and the monitoring process can be uniformly executed. Then, based on the compilation results and monitoring results of at least one target client application, errors can be uniformly handled and exceptions can be uniformly captured. Therefore, the disclosed embodiment can improve development efficiency and debugging efficiency, uniformly perform program maintenance and unified debugging of client applications on multiple platforms, and can assist more developers of non-directional operating systems to easily and quickly get started with development, which is ultimately conducive to speeding up the development process of the project.

[0102] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used in computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, etc. Figure 2 is a flow chart of a method for developing an autonomous driving graphical application framework according to an embodiment of the present invention. In the above step S103, based on the compilation result and monitoring result of at least one target client application, at least one target client application is developed, such as Figure 2 As shown, the process includes the following steps:

[0103] Step S1031 : based on the compilation result and monitoring result of at least one target client application, it is determined whether a debugging tool needs to be called to debug the source code of each target client application.

[0104] Step S1032: If yes, debug the source code of each target client application by using a debugging tool, and develop at least one target client application based on the debugged source code of each target client application.

[0105] Step S1033: if not, develop at least one target client application directly according to the source code of each target client application through the startup mode.

[0106] Specifically, Figure 3As shown, the startup process is described through the automated scaffolding execution. Through a framework development startup instruction, the automated scaffolding background completes pre-compilation, and determines whether to open the debugging tool based on the monitoring result of at least one target client application, thereby avoiding the inefficient operation and time cost caused by manual compilation, manual debugging and manual startup. The correctness of the code is monitored in real time during the coding process. Developers can view errors during the development process and handle them in time, avoiding repeated debugging work and improving development efficiency.

[0107] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used in computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, etc. Figure 4 is a flow chart of a method for developing an autonomous driving graphical application framework according to an embodiment of the present invention. In the above step S102, the source code of the at least one target client application is compiled and monitored by an automated scaffolding, such as Figure 4 As shown, the process includes the following steps:

[0108] Step S1021, monitoring whether there is any missing dependency in the source code of at least one target client application through automated scaffolding.

[0109] Step S1022: If yes, automatically download the source code of at least one target client application through the automated scaffolding and recompile the source code.

[0110] Step S1023: if not, compile the source code of at least one target client application according to the custom rule or the template rule through the automated scaffolding, wherein when the custom rule conflicts with the template rule, the custom rule is used first.

[0111] Specifically, Figure 5 As shown in the figure, the automatic compilation process through automated scaffolding is described. During the compilation process, it automatically detects whether the dependencies are met. When there are missing dependencies, the dependencies are automatically downloaded through automated tools and compiled again. The compilation rules are automatically merged into custom rules and template rules. When custom rules and template rules conflict, custom rules are limited. When the compilation rules are read successfully, the program is automatically compiled through the automated scaffolding to generate the product after programming. After the automated scaffolding automates the same and repetitive work, developers do not need to care about the compilation process. They focus on the compilation configuration side and edit the configuration file once, which is the basic principle of lasting effect, simplifying the overall operation process of compilation.

[0112] In some optional implementations, the method for developing an autonomous driving graphical application framework in the embodiments of the present disclosure further includes:

[0113] During the process of compiling the source code of at least one target client application, the cache data is cached in the client application through session cache, local cache or temporary cache, or cached in the underlying operating system through secure storage or file storage.

[0114] In a specific example, the session cache method, local cache method, or temporary cache method always follows the above-mentioned data automatic adaptation principle when caching data, or caching multiple operating systems through a secure storage method or a file storage method.

[0115] The client application on the Windows platform is configured with the Windows operating system and automatically adapts to the Windows type API interface. The client application on the MacOS platform is configured with the MacOS operating system and automatically adapts to the MacOS type API interface. The client application on the Linux platform is configured with the Linux operating system and automatically adapts to the Linux type API interface. The client application on the Android platform is configured with the Android operating system and automatically adapts to the Android type API interface.

[0116] Specifically, with the development of technology and the deepening of application, cache management plays an increasingly important role in software development. At present, cache methods are diverse and decentralized, lacking a unified management and operation method, which leads to messy project codes, difficult maintenance, and is not conducive to the versatility and scalability of applications. Therefore, the embodiments of the present disclosure propose a unified cache management method to solve the above problems.

[0117] like Figure 6 As shown, the cache modes are uniformly divided into two categories: end-side cache and system cache, and diversified cache modes are provided for different scenarios. At the same time, the disclosed embodiment designs a set of consistent operation API interfaces to simplify the use of cache, reduce the complexity of the project, and enhance versatility.

[0118] exist Figure 6 In the session cache method (sessionStorage), it is suitable for caching data during the session storage period in the client application. When the user closes the browser or tab, the data will be cleared. This cache method is suitable for storing temporary information, such as user login status, form data, etc.

[0119] exist Figure 6 In the local caching method (localStorage), it is suitable for caching long-term valid data in the client application. Even if the browser is closed or the device is restarted, the data will not be lost. This caching method is suitable for storing user preferences, application configurations, and other information that needs to be saved for a long time.

[0120] exist Figure 6 In the long-term cache method (Memory), it is suitable for caching temporary data that does not need to be persisted in the client application. This data exists during the program running and will be automatically cleared when the program ends. This cache method is suitable for storing intermediate results and temporary variables in the calculation process.

[0121] exist Figure 6 In the secure caching mode (File), in the underlying operating system, the user needs to enter the system password to access it, ensuring the security of the data. This caching mode is suitable for storing sensitive information, such as user passwords, payment information, etc. Through encryption and permission control, the disclosed embodiment ensures that authorized users can access this data.

[0122] exist Figure 6 In the file caching mode (safeStorage), in the underlying operating system, cache is performed in the user directory to save large files or unstructured data. This caching mode is suitable for storing file resources such as pictures, videos, and documents. Through the file path and naming standard method, it is convenient for the embodiment of the present disclosure to manage and access these files.

[0123] The cache mechanism of the above-mentioned different cache methods is conducive to the unified management and operation of cache data of different operating systems, which not only improves the convenience, simplicity and consistency of unified data management, but also improves the development efficiency of the desktop client application framework.

[0124] In some optional implementations, the cache data in the end and the cache data of the underlying operating system are permanently stored or relationally stored through a mysql database or a SQLite database. Both the mysql database and the SQLite database include: a data entity unit, a data filtering unit, a data generation unit, a data service unit, a data storage unit, a data mapping unit, a data update unit, a data deletion unit, and a data query unit.

[0125] Specifically, after introducing the above Figure 6 After the different cache mechanisms in, in order to ensure the persistence and relational storage of data, the embodiment of the present disclosure provides two storage solutions: sqlite and mysql. Figure 7 As shown, it includes a mysql database or a SQLite database. Both databases include: a data entity unit (Entity), a data filtering unit (Where), a data generating unit (sql converter), a data service unit (Service), a data saving unit (Save), a data mapping unit (data Mapping), a data updating unit (Update), a data deleting unit (Delete), and a data query unit (Query).

[0126] Furthermore, in the design of the storage layer, the disclosed embodiment deeply encapsulates the add, delete, modify and query unit, and is equipped with efficient data mapping and SQL conversion tools. This allows the application layer to completely break away from the underlying implementation, adopt a unified operation method, and flexibly switch between the two data storage methods.

[0127] like Figure 8 As shown, it is a schematic diagram of the data operation flow process of MySQL database or SQLite database. This method not only brings unprecedented convenience to the data operation of desktop application development, but also greatly simplifies the complex process of data operation, so that developers can focus more on the implementation of business logic without spending too much energy on the data operation level. In addition, the disclosed embodiment always automatically adapts to the API interface corresponding to different operating systems, that is, by unifying the API interface, encapsulating the underlying operation and flexibly switching the data storage method, it provides an efficient, convenient and reliable data operation experience for desktop application development.

[0128] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used in computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, etc. Fig. 9 is a flow chart of a method for developing an autonomous driving graphical application framework according to an embodiment of the present invention. Fig. 9 As shown, the process also includes the following steps:

[0129] Step S901: receiving a development request instruction of at least one target client application.

[0130] Specifically, at least one target client application comes from an external computer device input, that is, a client application development request instruction input by a user into the computer device.

[0131] Step S902, based on the development request instruction, generate an IPC communication file or an http communication file through the communication middle layer, the communication core layer, and the communication adaptation layer in sequence.

[0132] Specifically, the communication middle layer, the communication core layer, and the communication adaptation layer all belong to the underlying communication structure of the computer device. IPC communication files and http communication files are two different types of communication files.

[0133] Step S903, sending the IPC communication file or the http communication file to the server.

[0134] Specifically, the server is a server of at least one target client application, and sending the IPC communication file or the http communication file to the server facilitates the underlying communication structure of the computer device to establish a communication connection with the server, which is beneficial for users to use the target client application.

[0135] Step S904: if an error occurs in the IPC communication file or the http communication file, the erroneous IPC communication file or the http communication file returned by the server is sent to at least one target client application through the communication core layer and the communication middle layer in sequence.

[0136] Specifically, in the field of inter-program communication, due to the existence of various protocols, there is a lack of isolation in communication and debugging methods are not universal. In order to address these problems, the embodiments of the present disclosure perform comprehensive and unified optimization processing on the underlying communication structure, and introduce a communication middle layer, which can process data in batches, and can filter and intercept data during data transmission, greatly improving the efficiency and security of communication. At the same time, the embodiments of the present disclosure support IPC communication files and http communication files, that is, support the adaptation of IPC and HTTP protocols, so that the application layer can flexibly choose according to needs, and the underlying structure can automatically adapt to these two protocols, ensuring the stability and isolation of communication.

[0137] In some optional implementations, during at least one target client application communication process, an IPC communication file or an http communication file may be directly generated through the communication core layer and the communication adaptation layer based on a development request instruction.

[0138] In some optional implementations, during the communication process of at least one target client application, if an IPC communication file or an http communication file has an error, the error IPC communication file or the http communication file returned by the server is sent to at least one target client application through the communication core layer in sequence.

[0139] In some optional implementations, the error IPC communication file or http communication file returned by the server is received by an error file receiving unit.

[0140] Specifically, in terms of error handling, the embodiments of the present disclosure provide some error collection mechanisms. Once an error occurs in an IPC communication file or an http communication file, the error file receiving unit of the underlying operating system can quickly collect error information, which is convenient for developers to trace and view, thereby quickly locating errors and solving error problems. Therefore, the embodiments of the present disclosure avoid developers spending too much time on communication details due to troubleshooting errors one by one, and the embodiments of the present disclosure not only simplifies the communication process, but also improves the reliability and ease of use of communication, bringing developers a more efficient and convenient development experience.

[0141] like Fig.10 The figure is a schematic diagram of the communication process of the embodiment of the present disclosure.

[0142] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used for computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, etc., and also includes the following steps: developing at least one target client application through the background processing slot, view interface slot and tool slot of at least one target client application.

[0143] Specifically, the background processing slot is a background functional unit of at least one target client application, the view interface slot is a functional unit on the interface of at least one target client application, and the tool slot is an auxiliary tool of at least one target client application. Fig.11 The following are some schematic diagrams of the target client application slots. Fig.11 In the , the background processing slots include: verification, middleware, precompilation, notification, scheduled tasks, exception monitoring and other functional slots. The view interface slots include: main view, configuration, animation, menu, command panel, interaction, theme, run stop, debugging and other functional slots. The tool slots include: extension tools, up and down toolbars, quick operations, ordinary interface operations, program records (log), smart kits and other tool slots. In other words, the background processing slot is committed to meeting the business logic requirements of verification, scheduled tasks, exception monitoring, middleware and many other customized business logic requirements, providing developers with flexible and powerful backend processing capabilities. Secondly, the view interface slot focuses on the replacement and expansion of interface elements, allowing developers to easily realize the personalized customization of the view interface, and then be able to design a unique user interface. Finally, the tool slot further enhances the practicality and convenience of the suite by expanding the functional boundaries of the suite, such as adding toolbars, quick operations and other practical functions.

[0144] Specifically, the embodiments of the present disclosure introduce a slot mechanism and provide a variety of slots with different functions, which not only provides a convenient way for the plug-in module to replace or expand the functions of the main application, but also makes the control of the application functions flexible and free. Therefore, through the clever use of the slot mechanism, it is conducive to achieving accurate control of at least one target client application function, which in turn helps to enhance the development experience of developers.

[0145] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used in computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, etc. Fig.12 As shown, the following steps are also included:

[0146] Step S1201: open at least one target client application and receive a plug-in loading trigger instruction and a target loading file.

[0147] Specifically, in the currently installed target client application, in addition, a new extension function is added, and the extension function is installed in the target client application through a plug-in, and receives a plug-in loading trigger instruction and a corresponding target loading file sent from an external computer device.

[0148] Step S1202: based on the plug-in loading trigger instruction, decompress the target loading file to obtain the plug-in view and the plug-in program.

[0149] Specifically, the plug-in view is an icon displayed on at least one target client application, and the plug-in program is the program code of the plug-in.

[0150] Step S1203: Load the plug-in view into the interface of at least one target client application, and run the plug-in program in the program background.

[0151] Step S1204: updating at least one target client application after the plug-in is loaded.

[0152] Specifically, the plug-in program is loaded and run to ensure that the plug-in can run normally in the program background.

[0153] Step S1205: After the plug-in is loaded, if a plug-in uninstall trigger instruction is received, the plug-in view and the plug-in program are deleted at the same time.

[0154] Specifically, after the plug-in is loaded, it is unloaded in time to ensure the on-demand loading and purity of the plug-in.

[0155] The embodiment of the present disclosure uses a plug-in loading mechanism to facilitate the convenient and flexible expansion of target client applications. Fig.13 , which is a flowchart of at least one target client application. Fig.13 In the process, when a plug-in loading trigger instruction is received, the target loading file to be loaded is decompressed and decrypted, and two parts are obtained by decompression, namely the plug-in view and the plug-in program. The obtained plug-in view will be loaded into the interface of the target client application, and the program code will be loaded into the desktop program background for execution, providing support for interface operations, and obtaining an extended application after the application is updated. With the loading mechanism, the extension and combination of the program will become diverse and sound.

[0156] In some optional implementations, the above step S1203, running the plug-in program in the program background, includes:

[0157] Step a1, monitoring whether the plug-in program is compatible with the main application;

[0158] Step a2: If yes, load the plug-in program in the main application;

[0159] Step a3: if not, based on the context object attribute information and the main application business information, the incompatibility problem between the plug-in program and the application program is processed through a preset compatibility processing action.

[0160] Specifically, in the current software architecture design, the compatibility of the plug-in and the security of the main application are important considerations. Therefore, the disclosed embodiment provides a global event mechanism and a context object framework to optimize the compatibility experience and interaction experience between the main application and the plug-in.

[0161] In the disclosed embodiment, a context object is introduced into the plug-in to improve the compatibility between the main application and the plug-in. The context object acts as an information bridge between the plug-in and the main application, so that the plug-in can easily access the public information of the main application, including but not limited to the status, configuration, resources, etc. of the main application, which are very important for the normal operation of the plug-in. The context object provides an interface for information access, through which the context object attribute information and the main application business information are accessed. Through the context object attribute information and the main application business information, the plug-in is allowed to interact with the main application without directly calling the main application code. The disclosed embodiment introduces a context object into the plug-in, which not only improves the compatibility between the main application and the plug-in (that is, the plug-in introduces a context object to complete the expansion or customization of the functions required by the target client application without destroying the main application structure), but also ensures the security of the main application and improves the independence of the plug-in.

[0162] like Fig.14 As shown in the figure, it is a schematic diagram of the relevant information of the context object. Fig.14 In the context, the attributes are the context object attribute information, and the methods are the main application business information. The context object attribute information includes: root: string is the root directory, projectName: string is the project name, version: string is the version:, args: object is the main application custom information, view: object is the application view, config: object is the application configuration information, communication: Object is the communication object information, and the main application business information includes: getBusinessData(): Object is the client business information, updateBusinessData(businessData: Object): Boolea is the business update information, closeView(view: object): Boolean is to close the view slot, refersh(view: Object): Boolean is to refresh the plug-in status.

[0163] Furthermore, by presetting the compatibility processing action to handle the incompatibility problem between the plug-in program and the application program, it is equivalent to constructing a set of global event mechanisms in the disclosed embodiment, which allows the plug-in to monitor various events issued by the main application and execute corresponding actions when the event occurs. In the disclosed embodiment, these events can be triggered by user operations or caused by changes in the state of the underlying operating system, and they together constitute an information flow network between the main application and the plug-in.

[0164] The disclosed embodiment can obtain the state changes of the main application in real time through the global event mechanism and respond as needed. This response can be to update its own interface display or to execute specific business logic. At the same time, the plug-in can also notify the main application of changes in its internal state by triggering events, thereby realizing two-way information interaction.

[0165] The global event mechanism in the disclosed embodiment greatly reduces the coupling between the main application and the plug-in. The traditional tight coupling method often leads to complex code structure and difficult maintenance, while the global event mechanism enables the main application and the plug-in to be developed and upgraded independently through decoupling. This not only improves development efficiency, but also enhances the scalability and maintainability of the system.

[0166] In the disclosed embodiment, compatible processing actions are preset, and these preset compatible processing actions include open action (open), close action (close), hide action (hide), display action (show), loaded (loading action), unresponsive action (unresponsive), crashed action (crashed), and error (error handling action).

[0167] In this embodiment, a method for developing an autonomous driving graphical application framework is provided, which can be used in computer devices such as mobile phones, tablet computers, desktop computers, portable notebooks, servers, etc. Fig.15 is a flow chart of a method for developing an autonomous driving graphical application framework according to an embodiment of the present invention. Fig.15 As shown, it also includes:

[0168] Step S151, receiving a packaging instruction for each target client application.

[0169] Step S152: merging program files corresponding to each target client application.

[0170] Specifically, for example, at least one target client application is a Windows platform client application, a MacOS platform client application, a Linux platform client application, and an Android platform client application, and program files corresponding to these target client applications are merged.

[0171] Step S153: Check whether the program file corresponding to each target client application is a plug-in program.

[0172] Step S154: If yes, compile and encode the program files corresponding to each target client application in sequence to generate a plug-in extension executable file for each target client application.

[0173] Specifically, if the program file corresponding to each target client application is a plug-in program, the plug-in files are compiled and encoded step by step to generate a plug-in extension executable file for each target client application. If the target client application is a Windows platform client application, the corresponding plug-in extension executable file is generated as an exe file; if the target client application is a MacOS platform client application, the corresponding plug-in extension executable file is generated as a dmg file; if the target client application is a Linux platform client application, the corresponding plug-in extension executable file is generated as a deb file; if the target client application is an Android platform client application, the corresponding plug-in extension executable file is generated as a dex file.

[0174] Step S155: if not, parse, compress, and package the program files corresponding to each target client application in sequence, and generate a factory-configured executable file for each target client application.

[0175] Specifically, if the program file corresponding to each target client application is not a plug-in program, a corresponding factory-configured executable file is generated. Similarly, if the target client application is a Windows platform client application, the corresponding target client application executable file is generated as an exe file; if the target client application is a MacOS platform client application, the corresponding target client application executable file is generated as a dmg file; if the target client application is a Linux platform client application, the corresponding target client application executable file is generated as a deb file; if the target client application is an Android platform client application, the corresponding target client application executable file is generated as a dex file.

[0176] Therefore, the disclosed embodiment realizes convenient packaging of different platform clients and operation modes through a packaging instruction of the target client application. This packaging instruction cleverly integrates the public configuration and the directional configuration. After type verification, it can automatically call the underlying packaging mechanism and accurately output the executable files required by the respective platform clients. If a plug-in needs to be generated, based on the packaging instruction, the plug-in compressed package is automatically created. These compressed packages can be easily loaded into independent applications and run as extension programs, thereby further enriching the application functions.

[0177] Similarly, for the Web browser platform, the packaging instructions of the target client application can also integrate the resources required by the Web to generate HTML, CSS, and JS files that can be directly executed by the browser. The embodiment of the present disclosure is adapted to the multi-platform packaging mechanism, and the whole process is efficient and concise. Fig.16 As shown in FIG. 1 , a schematic diagram of one-click packaging of target client applications is shown.

[0178] In this embodiment, a development device for an autonomous driving graphical application framework is also provided, which is used to implement the above-mentioned embodiments and preferred implementation modes, and will not be repeated here. As used below, the term "module" may be a combination of software and / or hardware that implements a predetermined function. Although the devices described in the following embodiments are preferably implemented in software, the implementation of hardware, or a combination of software and hardware, is also possible and conceivable.

[0179] This embodiment provides a device for developing an autonomous driving graphical application framework, such as Fig.17 As shown, including:

[0180] A receiving module 171, configured to receive a framework development start instruction for at least one target client application and a source code corresponding to at least one target client application;

[0181] A compiling module 172, for compiling and monitoring the source code of at least one target client application based on the framework development startup instruction of at least one target client application through an automated scaffold, and outputting the compilation result and the monitoring result;

[0182] The development module 173 is used to develop at least one target client application based on the compilation result and the monitoring result of at least one target client application.

[0183] The further functional description of each of the above modules and units is the same as that of the above corresponding embodiments and will not be repeated here.

[0184] The development device of the client application framework in this embodiment is presented in the form of a functional unit, where the unit refers to an ASIC (Application Specific Integrated Circuit) circuit, a processor and memory that executes one or more software or fixed programs, and / or other devices that can provide the above functions.

[0185] The embodiment of the present invention also provides a computer device having the above Fig.18 The development device of the autonomous driving graphical application framework shown.

[0186] See also Fig.18 , Fig.18 is a schematic diagram of the structure of a computer device provided by an optional embodiment of the present invention, such as Fig.18 As shown, the computer device includes: one or more processors 10, a memory 20, and interfaces for connecting various components, including high-speed interfaces and low-speed interfaces. Various components are connected to each other using different buses for communication, and can be installed on a common mainboard or installed in other ways as needed. The processor can process the instructions executed in the computer device, including instructions stored in or on the memory to display the graphical information of the GUI on an external input / output device (such as, a display device coupled to the interface). In some optional embodiments, if necessary, multiple processors and / or multiple buses can be used together with multiple memories and multiple memories. Similarly, multiple computer devices can be connected, and each device provides some necessary operations (for example, as a server array, a group of blade servers, or a multi-processor system). Fig.18 A processor 10 is taken as an example.

[0187] The processor 10 may be a central processing unit, a network processor or a combination thereof. The processor 10 may further include a hardware chip. The hardware chip may be a dedicated integrated circuit, a programmable logic device or a combination thereof. The programmable logic device may be a complex programmable logic device, a field programmable gate array, a general purpose array logic or any combination thereof.

[0188] The memory 20 stores instructions executable by at least one processor 10, so that the at least one processor 10 executes the method shown in the above embodiment.

[0189] The memory 20 may include a program storage area and a data storage area, wherein the program storage area may store an operating system, an application required for at least one function; the data storage area may store data created according to the use of the computer device, etc. In addition, the memory 20 may include a high-speed random access memory, and may also include a non-transient memory, such as at least one disk storage device, a flash memory device, or other non-transient solid-state storage device. In some optional embodiments, the memory 20 may optionally include a memory remotely arranged relative to the processor 10, and these remote memories may be connected to the computer device via a network. Examples of the above-mentioned network include, but are not limited to, the Internet, an intranet, a local area network, a mobile communication network, and combinations thereof.

[0190] The memory 20 may include a volatile memory, such as a random access memory; the memory may also include a non-volatile memory, such as a flash memory, a hard disk or a solid state drive; the memory 20 may also include a combination of the above types of memory.

[0191] The computer device further comprises a communication interface 30 for the computer device to communicate with other devices or a communication network.

[0192] The embodiment of the present invention also provides a computer-readable storage medium. The method according to the embodiment of the present invention can be implemented in hardware, firmware, or can be implemented as a computer code that can be recorded in a storage medium, or can be implemented as a computer code that is originally stored in a remote storage medium or a non-temporary machine-readable storage medium and will be stored in a local storage medium through a network download, so that the method described herein can be stored in such software processing on a storage medium using a general-purpose computer, a dedicated processor, or programmable or dedicated hardware. Among them, the storage medium can be a magnetic disk, an optical disk, a read-only storage memory, a random access memory, a flash memory, a hard disk or a solid-state hard disk, etc.; further, the storage medium can also include a combination of the above types of memories. It can be understood that a computer, a processor, a microprocessor controller, or programmable hardware includes a storage component that can store or receive software or computer code. When the software or computer code is accessed and executed by a computer, a processor, or hardware, the method shown in the above embodiment is implemented.

[0193] Although the embodiments of the present invention have been described in conjunction with the accompanying drawings, those skilled in the art may make various modifications and variations without departing from the spirit and scope of the present invention, and such modifications and variations are all within the scope defined by the appended claims.

Claims

1. A method for developing an autonomous driving graphical application framework, characterized in that: The method comprises: Receive a framework development start instruction for at least one target client application and source code corresponding to the at least one target client application; Based on the framework development startup instruction of the at least one target client application, compile and monitor the source code of the at least one target client application through the automated scaffolding, and output the compilation result and the monitoring result; Based on the compilation result and the monitoring result of the at least one target client application, the at least one target client application is developed.

2. The method according to claim 1, characterized in that The at least one target client application includes: a Windows platform client application, a MacOS platform client application, a Linux platform client application, and an Android platform client application; Among them, the Windows platform client application configures the Windows operating system and automatically adapts to Windows type API interfaces, the MacOS platform client application configures the MacOS operating system and automatically adapts to MacOS type API interfaces, the Linux platform client application configures the Linux operating system and automatically adapts to Linux type API interfaces, and the Android platform client application configures the Android operating system and automatically adapts to Android type API interfaces.

3. The method according to claim 1, characterized in that Developing the at least one target client application based on the compilation result and the monitoring result of the at least one target client application includes: Based on the compilation result and the monitoring result of the at least one target client application, determining whether it is necessary to call a debugging tool to debug the source code of each target client application; If yes, debugging the source code of each target client application by using the debugging tool, and developing the at least one target client application based on the debugged source code of each target client application; If not, the at least one target client application is developed directly according to the source code of each target client application through the startup mode.

4. The method according to claim 1, characterized in that: Compiling and monitoring the source code of the at least one target client application through an automated scaffolding includes: Monitoring, by automated scaffolding, whether the source code of the at least one target client application has any missing dependencies; If so, automatically downloading the source code of the dependency and recompiling the at least one target client application through the automated scaffolding; If not, the source code of the at least one target client application is compiled according to the custom rule or the template rule through the automated scaffolding, wherein when the custom rule conflicts with the template rule, the custom rule is used first.

5. The method according to claim 1, characterized in that Also includes: Receiving a development request instruction of the at least one target client application; Based on the development request instruction, an IPC communication file or an http communication file is generated through the communication middle layer, the communication core layer, and the communication adaptation layer in sequence; Sending the IPC communication file or the http communication file to the server; If an error occurs in the IPC communication file or the http communication file, the error IPC communication file or the http communication file returned by the server is sent to the at least one target client application through the communication core layer and the communication intermediate layer in sequence.

6. The method according to claim 1, characterized in that After developing the at least one target client application, the method further includes: Opening the at least one target client application and receiving a plug-in loading trigger instruction and a target loading file; Based on the plug-in loading trigger instruction, decompress the target loading file to obtain a plug-in view and a plug-in program; Loading the plug-in view into the interface of the at least one target client application, and running the plug-in program in the program background; Updating the at least one target client application after the plug-in is loaded; After the plug-in is loaded, if a plug-in uninstall trigger instruction is received, the plug-in view and the plug-in program are deleted at the same time.

7. The method according to claim 6, characterized in that Running the plug-in program in the program background includes: Monitoring whether the plug-in program is compatible with the main application; If so, loading the plug-in program in the main application; If not, based on the context object attribute information and the main application business information, the incompatibility problem between the plug-in program and the application program is processed through a preset compatibility processing action.

8. A device for developing an autonomous driving graphical application framework, characterized in that: The device comprises: A receiving module, configured to receive a framework development start instruction for at least one target client application and a source code corresponding to the at least one target client application; A compiling module, configured to compile and monitor the source code of the at least one target client application based on the framework development startup instruction of the at least one target client application through an automated scaffold, and output the compilation result and the monitoring result; A development module is used to develop the at least one target client application based on the compilation result and the monitoring result of the at least one target client application.

9. A computer device, characterized in that: include: A memory and a processor, wherein the memory and the processor are communicatively connected to each other, the memory stores computer instructions, and the processor executes the method for developing an autonomous driving graphical application framework according to any one of claims 1 to 7 by executing the computer instructions.

10. A computer-readable storage medium, characterized in that: The computer-readable storage medium stores computer instructions, and the computer instructions are used to enable a computer to execute the method for developing an autonomous driving graphical application framework according to any one of claims 1 to 7.

Images