CN113467803B - Application program repairing method, related device and equipment - Google Patents
Application program repairing method, related device and equipment Download PDFInfo
- Publication number
- CN113467803B CN113467803B CN202110722068.0A CN202110722068A CN113467803B CN 113467803 B CN113467803 B CN 113467803B CN 202110722068 A CN202110722068 A CN 202110722068A CN 113467803 B CN113467803 B CN 113467803B
- Authority
- CN
- China
- Prior art keywords
- script
- modified
- application program
- patch package
- file
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Active
Links
- 238000000034 method Methods 0.000 title claims abstract description 377
- 238000013515 script Methods 0.000 claims abstract description 405
- 230000008439 repair process Effects 0.000 claims abstract description 35
- 238000004806 packaging method and process Methods 0.000 claims abstract description 26
- 230000004044 response Effects 0.000 claims abstract description 19
- 238000012546 transfer Methods 0.000 claims description 32
- 238000012856 packing Methods 0.000 claims description 8
- 238000012986 modification Methods 0.000 description 19
- 230000004048 modification Effects 0.000 description 19
- 238000010586 diagram Methods 0.000 description 12
- 230000006870 function Effects 0.000 description 11
- 230000005540 biological transmission Effects 0.000 description 9
- 230000006835 compression Effects 0.000 description 9
- 238000007906 compression Methods 0.000 description 7
- 238000012423 maintenance Methods 0.000 description 5
- 230000008878 coupling Effects 0.000 description 3
- 238000010168 coupling process Methods 0.000 description 3
- 238000005859 coupling reaction Methods 0.000 description 3
- 238000012545 processing Methods 0.000 description 3
- 230000008859 change Effects 0.000 description 2
- 238000004891 communication Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 230000008569 process Effects 0.000 description 2
- 238000013528 artificial neural network Methods 0.000 description 1
- 238000010276 construction Methods 0.000 description 1
- 230000006837 decompression Effects 0.000 description 1
- 238000011161 development Methods 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 230000009191 jumping Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000000007 visual effect Effects 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Landscapes
- Engineering & Computer Science (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
- Information Transfer Between Computers (AREA)
Abstract
The application discloses a repair method of an application program, and a related device and equipment, wherein the repair method of the application program comprises the following steps: the server acquires the modified script code; compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files correspond to the modified methods one by one; and packaging script files corresponding to the modified methods to obtain a latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the fact that the latest patch package comprises the script files corresponding to the modified methods. According to the scheme, the user can be prevented from manually downloading and updating the application program, the operation steps of the user are reduced, and the repairing experience and efficiency of the application program are improved.
Description
Technical Field
The present invention relates to the technical field of application program repair, and in particular, to an application program repair method, and related devices and equipment.
Background
With the rapid development of internet technology, the functions of internet technology are more and more diversified and efficient. In the process of using the application program, the user needs to increase the convenience degree of the application program.
In the application process, some program errors or program iterations often occur in the application program, and at this time, a programmer is required to repair and update the application program. At present, a common repairing and updating mode is to make a user download and install again to replace an application program which is originally required to be repaired and updated by constructing a repaired installation package.
However, the above method often requires the user to perform complicated operation, which is easy to bring inconvenience to the user and leads to easy loss of the user.
Disclosure of Invention
The application program repairing method, the related device and the equipment are provided, and the problem that more complicated operations are brought to a user by repairing and updating the application program in the prior art is solved.
The application provides a method for repairing an application program, which comprises the following steps: the server acquires the modified script code; compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files correspond to the modified methods one by one; and packaging script files corresponding to the modified methods to obtain a latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the fact that the latest patch package comprises the script files corresponding to the modified methods.
The step of compiling the modified script code by utilizing a multi-platform compiler to generate a script file with a set format comprises the following steps: and compiling the modified script codes by using a KotlenJs compiler to generate a script file in a Javascript format.
The method comprises the steps of compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the steps of the script files corresponding to the modified methods comprise: compiling the modified script codes based on the dimension of each Kotlen module by a Kotlen js compiler to obtain a plurality of compiling scripts; splitting the compiling script based on the method contained in each compiling script to obtain a script file corresponding to each modified method; wherein each modified method corresponds to a script file.
The step of packing script files corresponding to the modified methods to obtain the latest patch package comprises the following steps: comparing the script code before modification with the script code after modification to obtain a new method and a changed method in the script code after modification; naming script files corresponding to the newly added method and the changed method according to the class names of the original method corresponding to the newly added method and the changed method and the concatenation of the method signatures; and packaging the named script file to obtain the latest patch package.
The method comprises the steps of compiling the modified script codes by utilizing a multi-platform compiler, and generating script files with set formats, wherein the method further comprises the following steps: when the script code of the application program is constructed, a preset transfer logic is inserted into each original method entry of the script code, so that when a task corresponding to the original method of the application program is executed, whether the task is executed by executing the original method is judged by executing the preset transfer logic in the original method.
The application program repairing method further comprises the following steps: script code of the application is built through Kotlin.
The application also provides a method for repairing the application program, which comprises the following steps: the client terminal starts an application program and acquires the latest patch package from the server; responding to the latest patch package which comprises script files corresponding to the modified methods, and repairing the application program based on the script files; wherein, the latest patch package is script codes after the server acquires the modification; compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, and packaging the script files corresponding to the modified methods, wherein the script files correspond to the modified methods one by one.
The method for repairing the application program based on the script files comprises the following steps of: the task corresponding to the original method of the application program is executed by executing preset transfer logic at the original method entrance of the application program, so as to judge whether the task is executed by executing the original method.
The method for repairing the application program based on the script files comprises the following steps of: unpacking the latest patch package to obtain script files corresponding to the modified methods in response to the fact that the latest patch package comprises the modified script files; and recording the file path of each script file based on the naming of the script file to obtain a record table. Judging whether a spliced record of a class name and a method signature corresponding to the original method exists in a record table or not by executing preset transfer logic; and if the record table has the same record of the class name corresponding to the original method and the concatenation of the method signature, executing the task corresponding to the original method by executing the modified script file.
The step of executing the task corresponding to the original method by executing the modified script file comprises the following steps: acquiring a file path of the script file after modification corresponding to the original method from a record table; acquiring a modified script file based on the file path; and executing the modified script file.
The application also provides a repairing device of the application program, which comprises: the acquisition module is used for acquiring the modified script code; the compiling module is used for compiling the modified script codes by utilizing the multi-platform compiler to generate script files with set formats, wherein the script files correspond to the modified methods one by one; and the packaging module is used for packaging the script files corresponding to the modified methods to obtain the latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the fact that the latest patch package comprises the script files corresponding to the modified methods.
The application also provides a repairing device of the application program, which comprises: the starting module is used for starting the application program and acquiring the latest patch package from the server; the repair module is used for responding to the script files corresponding to the modified methods included in the latest patch package and repairing the application program based on the script files; wherein, the latest patch package is script codes after the server acquires the modification; compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, and packaging the script files corresponding to the modified methods, wherein the script files correspond to the modified methods one by one.
The application also provides an electronic device, which comprises a memory and a processor which are mutually coupled, wherein the processor is used for executing program instructions stored in the memory so as to realize the repairing method of any application program.
The application also provides a computer readable storage medium having program instructions stored thereon, which when executed by a processor implement a repair method for any one of the above-mentioned applications.
According to the scheme, the modified script code is obtained; and compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files correspond to the modified methods one by one, so that the repairing method of the embodiment can be applied to repairing the application programs of multiple platforms, the situation that developers independently compile and repair the platforms is avoided, the repairing workload of the developers is reduced, the repairing efficiency of the application programs of the platforms is improved, and the project maintenance cost is reduced. The method and the system also package script files corresponding to the modified methods to obtain the latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the latest patch package comprising the script files corresponding to the modified methods, thereby avoiding related operations of downloading and updating the application program by a user, reducing user operation steps and improving repair experience and efficiency.
Drawings
FIG. 1 is a flow chart of a first embodiment of a repair method for an application of the present application;
FIG. 2 is a flow chart of a second embodiment of a repair method for an application of the present application;
FIG. 3 is a schematic diagram of a transmission network of an application scenario in FIG. 2;
fig. 4 is a data flow diagram of data transmission performed by each terminal in the transmission network in the application scenario of fig. 3;
FIG. 5 is a flow chart of a third embodiment of a repair method for an application of the present application;
FIG. 6 is a flow chart of a fourth embodiment of a repair method for an application of the present application;
FIG. 7 is a schematic diagram of a framework of one embodiment of a prosthetic device of the application;
FIG. 8 is a schematic diagram of a framework of another embodiment of a prosthetic device of the application;
FIG. 9 is a schematic diagram of a frame of an embodiment of an electronic device of the present application;
FIG. 10 is a schematic diagram of a framework of one embodiment of a computer-readable storage medium of the present application.
Detailed Description
The following describes the embodiments of the present application in detail with reference to the drawings.
In the following description, for purposes of explanation and not limitation, specific details are set forth such as the particular system architecture, interfaces, techniques, etc., in order to provide a thorough understanding of the present application.
The terms "system" and "network" are often used interchangeably herein. The term "and/or" is merely one association relationship describing the associated object, and three relationships may exist, for example, a and/or B may: a exists alone, A and B exist together, and B exists alone. In addition, the character "/" herein is generally an or relationship between the front and rear related objects. Further, "more" than two or more than two herein.
Referring to fig. 1, fig. 1 is a flowchart of a first embodiment of a repairing method for an application program of the present application.
Step S11: and acquiring the modified script code.
The embodiment is applied to an application scene after an application program has been installed on a client terminal. The server obtains the modified script code. The script code is used for constructing the application program, and the current application program is repaired or updated by acquiring and applying the modified script code.
The application programs of the present embodiment include application programs provided on a mobile terminal, a PC terminal or other intelligent terminals, such as APP on a mobile terminal, and the specific type is not limited herein.
Step S12: and compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files are in one-to-one correspondence with the modified methods.
And compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats. Wherein, the multi-platform compiler refers to a compiler which can compile a plurality of application formats or can apply compiled script codes to a plurality of platforms, for example: android platform, ios platform, nodeJs desktop/server application platform, java desktop/server application platform or other platforms, etc. While the multi-platform compiler may include a GCC (GNU Compiler Collection) compiler, a kotlenjs compiler, or other multi-platform compiler.
The script files in the set format may include script files in Javascript format, script files in VBS (Microsoft Visual Basic Script Edition) format, script files in bat format, or script files in other formats. The specific setting format can be set based on the type of the multi-platform compiler and/or the platform needing to be applied.
The method of the present embodiment is code content corresponding to each functional task that needs to be executed in the running of script code, for example: in script code in the form of JAVA, the methods may be main methods or other callable program methods, each of which implements at least one functional task.
The obtained script files with the set formats are in one-to-one correspondence with the modified methods, that is, each script file with the set formats is used for realizing one modified method.
Step S13: and packaging script files corresponding to the modified methods to obtain a latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the fact that the latest patch package comprises the script files corresponding to the modified methods.
After script files in a plurality of set formats corresponding to the modified methods one by one are obtained, the script files corresponding to the modified methods are packaged to obtain the latest patch package, so that when the client terminal starts an application program, the latest patch package can be obtained from the server, and the application program is repaired based on the script files in response to the fact that the latest patch package comprises the script files corresponding to the modified methods.
In a specific application scenario, a plurality of script files in a set format may be packaged into a latest patch package in a Zip compression manner. In another specific application scenario, a win10 compression manner may also be used to package a plurality of script files in a set format into a latest patch package. The packing mode of the step can adopt different compression software to carry out compression packing.
When the client terminal starts the application program, the latest patch package is automatically acquired from the server to update and repair, so that a user can finish repairing the application program when starting the application program, related operations of downloading and updating the application program by the user are avoided, user operation steps are reduced, and repairing experience and efficiency are improved.
By the method, the repairing method of the application program of the embodiment obtains the modified script code; and compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files correspond to the modified methods one by one, so that the repairing method of the embodiment can be applied to repairing the application programs of multiple platforms, the situation that developers independently compile and repair the platforms is avoided, the repairing workload of the developers is reduced, the repairing efficiency of the application programs of the platforms is improved, and the project maintenance cost is reduced. The method also packages the script files corresponding to the modified methods to obtain the latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the latest patch package comprising the script files corresponding to the modified methods, thereby avoiding related operations of downloading and updating the application program by a user, reducing user operation steps and improving repair experience and efficiency.
Referring to fig. 2, fig. 2 is a flowchart of a second embodiment of a repairing method of an application program of the present application.
Step S21: when the script code of the application program is constructed, preset transfer logic is inserted into each original method entry of the script code.
When the script code of the application program is constructed, a section of preset transit logic is inserted in advance at the entrance of each original method in the script code of the application program. The preset transfer logic is located at the entrance of each method, so that when an application program is run, the preset transfer logic at the entrance of the method can be executed first before each task corresponding to a certain method is run, and therefore whether the task to be executed next is based on the script file corresponding to the existing method or the script file corresponding to the modified method can be determined to be executed based on the preset transfer logic.
When the script code of the application program is constructed, the script code of the application program can be constructed through the Kotlen, so that the multi-platform applicability of the Kotlen is applicable to multiple platforms.
Step S22: and receiving manual modification of the script code of the application program to obtain the modified script code.
After the application program is built, the application program is installed on the client terminal. The server receives the script code modified by the developer/human method of the script code of the application. In a specific application scenario, the modified script code may be generated by modifying the script code of the currently installed application program after a program error of the currently installed application program or the current application program needs to be updated is found manually, and the modified script code is transmitted to the server, so that the server obtains the modified script code.
The modified script code is the code modified by the whole application program, and comprises all modified methods and unmodified methods. In other embodiments, the method of the script code of the application program can be modified through the trained neural network, so that the server obtains the modified script code. Whereas the modification of the script code can also be based on kotlen.
Step S23: and compiling the modified script codes based on the dimension of each Kotlen module through a Kotlen Js compiler to obtain a plurality of compiling scripts, and splitting the compiling scripts based on the methods contained in each compiling script to obtain script files corresponding to each modified method.
Compiling the whole modified script code to generate a script file. Specifically, the modified script code may be compiled by a kotlenjs compiler to obtain a plurality of compiled scripts. And splitting the compiled scripts based on the methods contained in each compiled script to obtain script files corresponding to the modified methods. Kotlin is a programming language and can be used for developing application programs such as Android, JVM and the like. Kotlin is a cross-platform language, and can be compiled into byte codes or codes which can be run by other platforms through a compiler, such as Java byte codes, c executable files, javaScript codes and the like, so that the multi-platform application is realized. The KotlenJs compiler is used to compile the Kotlen language.
The kotlenjs compiler compiles the modified script code based on the dimension of each kotlen module to obtain a compiling script corresponding to each kotlen module. The developer divides script codes of the application program based on different functions of the product service to obtain a plurality of divided files, wherein each divided file corresponds to one Kotlen module, namely, each compiled script corresponds to one divided file.
In a specific application scenario, when the script code of the application program is divided into a barrage function file, a comment function file and a gift function file, the kotlenjs compiler compiles the modified script code according to the division of the barrage function file, the comment function file and the gift function file to obtain 3 compiled scripts corresponding to the modified barrage function file, the comment function file and the gift function file. In this embodiment, the file type of the compiled script may be a Javascript script file (abbreviated as a js file), and in other embodiments, the file types of the compiled script and the script file may be adjusted based on the type of the application platform, so that the compiled script and the script file are suitable for the corresponding platform, thereby improving the multi-platform applicability of repairing the application program.
After compiling the modified script codes to obtain a plurality of compiling scripts, splitting each compiling script based on the number of methods contained in each compiling script to obtain a plurality of script files, wherein each modified method corresponds to one script file. The script file may be a Javascript file. Specifically, js codes of each method can be copied to a separate file for storage, so that a Javascript script file corresponding to each modified method is obtained.
In a specific application scenario, when 100 methods are included in one compiled script, the compiled script is split into 100 script files based on each method.
Step S24: comparing the current script code with the modified script code to obtain a newly added method and a modified method in the modified script code, naming script files corresponding to the newly added method and the modified method according to the class names of the original method corresponding to the newly added method and the modified method and the concatenation of the method signatures, and packaging the named script files to obtain the latest patch package.
Comparing the current script code with the modified script code, the repaired code change can be obtained, and a newly added method, a changed method and a removed method in the modification can be obtained based on the changed code. And finding out all script files corresponding to the newly added method and the changed method according to the class name and the concatenation of the method signature, and packaging the script files into the latest patch package. Because of the calling relationship between the methods, the removed method is not executed after executing according to the newly added method and the changed method, so that the removed method can be ignored in the step.
In a specific application scenario, the current script code and the modified script code can be compared through a version control tool, and the repaired code change can be obtained. The version control tools comprise versions of git, svn and the like.
In a specific application scenario, a Zip compression mode may be adopted to package all script files corresponding to the newly added method and the changed method into the latest patch package. In another specific application scenario, a win10 compression mode may also be used to package all script files corresponding to the newly added method and the changed method into the latest patch package. The packing manner of the step can adopt different compression software and/or packing software for compression and/or packing.
Naming script files corresponding to the newly added method and the changed method according to the class names of the original method corresponding to the newly added method and the changed method and the splicing of the method signatures, and packaging the named script files to obtain the latest patch package. The class name of the method in Kotlin is unique, the method signature in the class is also unique, and the concatenation of the class name and the method signature can be used as the name to ensure that the naming of the modified method is not repeated, and the modified methods do not have homonymous conflicts. The original method of this embodiment refers to a method of initial script code that is installed on a client terminal for the first time after an application program is constructed. The application program can be repaired for many times in practical application, and besides the original method of the original application program is named as an original method signature, all names in the follow-up repair process are the class names of the original method and the splice of the method signatures.
In other embodiments, the script file of each method may be named based on the class name of the original method corresponding to each method and the concatenation of the method signature in the modified script code, then the current script code is compared with the modified script code to obtain a new method, a modified method and a removed method, and the class name of the original method corresponding to the modified method and the concatenation of the method signature are used to obtain the corresponding named script file based on the new method, so as to obtain the new method and the modified script file corresponding to the modified method.
By the method, the client terminal can update the application program when the application program is started. Referring to fig. 3-4, fig. 3 is a schematic structural diagram of a transmission network of an application scenario in fig. 2; fig. 4 is a data flow diagram of data transmission by each terminal in the transmission network in the application scenario of fig. 3.
The transmission network 30 of the present embodiment includes a server 31 and a plurality of client terminals 32, wherein each client terminal 32 is communicatively connected to the server 31.
The server 31 inserts preset relay logic at each of the original method portals when constructing script codes of the application programs. After completion of the construction, the server 31 transmits the script code of the application program to the plurality of client terminals 32, and each client terminal 32 receives the script code of the application program and installs the application program based on the script code.
The server 31 obtains the modified script code. The server 31 then compiles the modified entire script code to generate a compiled script. The server 31 splits the compiled script to obtain script files corresponding to the modified methods. Specifically, the modified script codes can be compiled by a kotlenjs compiler based on the dimension of each kotlen module to obtain a plurality of compiling scripts, and the compiling scripts are split based on the methods contained in each compiling script to obtain script files corresponding to each modified method.
Subsequently, the server 31 acquires and names a method newly added and a method changed in the modified script code. Specifically, the server 31 compares the script code before modification with the script code after modification, and acquires a method newly added and a method changed in the script code after modification. And naming script files corresponding to the newly added method and the changed method according to the class names of the original method corresponding to the newly added method and the changed method and the concatenation of the method signatures.
The server 31 packages the named script file to obtain the latest patch package. The server 31 then transmits the latest patch package to the client terminal 32.
The client terminal 32 starts an application program, obtains the latest patch package from the server 31, and unpacks the latest patch package in response to the latest patch package including the modified script file, thereby obtaining script files corresponding to the modified methods.
The client terminal 32 records the file path of each script file based on the name of the script file, and obtains a record table. And executing the task corresponding to the original method of the application program by executing the preset transfer logic first so as to judge whether the task is executed by executing the original method. Specifically, whether a record of splicing of the class name and the method signature corresponding to the original method exists in a record table is judged by executing preset transfer logic, and if the record of splicing of the class name and the method signature corresponding to the original method exists in the record table, a task corresponding to the original method is executed by executing the modified script file. Thereby completing the repair of the application.
By the method, when the script code of the application program is constructed, the preset transfer logic is inserted into each original method entry of the script code, and the preset transfer logic at the method entry can be executed first before each task corresponding to a certain method is executed, so that whether the task to be executed next is based on the script file corresponding to the existing method or the script file corresponding to the modified method can be determined based on the preset transfer logic. According to the method, the modified script codes are obtained, the modified script codes are compiled by the KotlenJs compiler based on the dimension of each Kotlen module, a plurality of compiling scripts are obtained, the compiling scripts are split based on the method contained in each compiling script, and script files corresponding to each modified method are obtained, so that the multi-platform adaptability of the KotlenJs compiler can be utilized to enable unified restoration of multi-platform application programs, and restoration efficiency is improved. The method and the device avoid the independent compiling and repairing of the developer aiming at each platform, reduce the repairing workload of the developer, further improve the repairing efficiency of the application programs of each platform and reduce the project maintenance cost.
Referring to fig. 5, fig. 5 is a flowchart of a third embodiment of a repairing method of an application program of the present application.
Step S51: and starting an application program, and acquiring the latest patch package from the server.
The client terminal starts the application program and acquires the latest patch package from the server, wherein the latest patch package is automatically acquired from the server when the application program on the client terminal is started each time so as to judge whether the application program needs to be repaired or not, thereby avoiding the related operation of downloading and updating the application program by a user by the user, reducing the operation steps of the user and improving the repairing experience and efficiency of the application program.
After the client terminal obtains the latest patch package, the client terminal may unpack the latest patch package based on a packing mode of the server, for example: when the server generates the latest patch package in a compressed mode, the client terminal unpacks in an decompressing mode.
Step S52: responding to the latest patch package which comprises script files corresponding to the modified methods, and repairing the application program based on the script files, wherein the latest patch package is obtained by the server through the modified script codes; compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, and packaging the script files corresponding to the modified methods, wherein the script files correspond to the modified methods one by one.
After unpacking the latest patch package, the server judges whether the latest patch package comprises script files corresponding to the modified methods, and if so, the server repairs the application program based on the script files in the latest patch package. If the latest patch package is blank, the starting of the application program does not relate to the restoration of the script code, and the application program does not respond. In other embodiments, whether the latest patch package includes script files corresponding to the modified methods may also be determined by determining whether the latest patch package before unpacking is blank.
The latest patch package in this embodiment is obtained by compiling the modified script code by using a multi-platform compiler after the server obtains the modified script code, generating a script file in a set format, and packaging the script files corresponding to the modified methods, where the script file corresponds to the modified methods one by one. The specific steps of generating the latest patch package by the server may refer to the embodiment of fig. 1, and will not be described herein.
By the method, when the application program is started, the latest patch package is obtained from the server; responding to the latest patch package to include script files corresponding to the modified methods, and repairing the application program based on the script files; therefore, related operations of downloading and updating the application program manually by a user can be avoided, the operation steps of the user are reduced, and the repairing experience and efficiency are improved. The latest patch package is the script code after the server acquires the modification; and compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, and packaging the script files corresponding to the modified methods. Therefore, the repairing method of the embodiment can be applied to repairing application programs of multiple platforms, the situation that developers independently compile and repair each platform is avoided, repairing workload of the developers is reduced, repairing efficiency of the application programs of each platform is improved, and project maintenance cost is reduced.
Referring to fig. 6, fig. 6 is a flowchart of a fourth embodiment of a repairing method of an application program of the present application.
The client terminal downloads the original script code of the application program and installs the original script code so as to set the application program on the client terminal. And when the script code of the application program is constructed, a section of preset transit logic is inserted in advance at the entrance of each method in the script code of the application program. The preset transfer logic is located at the entrance of each method, so that when an application program is run, the preset transfer logic at the entrance of the method can be executed first before each task corresponding to a certain method is run, and therefore whether the task to be executed next is based on the script file corresponding to the existing method or the script file corresponding to the modified method can be determined to be executed based on the preset transfer logic.
Step S61: and starting an application program, and acquiring the latest patch package from the server.
The client terminal starts the application program and acquires the latest patch package from the server, wherein the latest patch package is automatically acquired from the server when the application program on the client terminal is started each time so as to judge whether the application program needs to be repaired or not, thereby avoiding the related operation of downloading and updating the application program by a user by the user, reducing the operation steps of the user and improving the repairing experience and efficiency of the application program.
The step of generating the latest patch package by the server is referred to any of the foregoing embodiments, and will not be described herein.
Step S62: and unpacking the latest patch package in response to the fact that the latest patch package comprises the modified script files, obtaining script files corresponding to the modified methods, and recording file paths of the script files based on naming of the script files to obtain a record table.
Judging whether the latest patch package comprises a modified script file or not, and if the latest patch package comprises the modified script file, indicating that a program error exists in the application program and that the application program needs to be repaired. If the latest patch package is a blank patch package or does not comprise a modified script file, the method indicates that no program error exists in the current application program and repair is not needed.
And unpacking the latest patch package to obtain script files corresponding to the modified methods in response to the fact that the latest patch package comprises the modified script files. In a specific application scenario, when the server compresses and packages by adopting a Zip compression mode to obtain the latest patch package, the embodiment may also decompress and unpack the latest patch package by adopting a Zip decompression mode. In other embodiments, in this document, unpacking the latest patch package may be performed before the step of determining whether the latest patch package includes the modified script file, so as to determine whether the latest patch package includes the modified script file.
After the script files corresponding to the multiple modified methods are obtained, the file paths of the script files are recorded based on the naming of the script files, and a record table is obtained. Specifically, script files corresponding to the modified methods are stored in a storage device of the client terminal, and are recorded into a record table according to the naming of each script file.
In a specific application scenario, the record table may be a hash record table, where the hash table is a key-value pair, where a key is a class name of an original method and a spliced name of a method signature, and a value is a file path of a script file, so that the file path of each script file is recorded through the hash record table based on the naming of the script file.
Step S63: judging whether a record of splicing of the class name and the method signature corresponding to the original method exists in the record table by executing preset transfer logic, and executing a task corresponding to the original method by executing the modified script file if the record of splicing of the class name and the method signature corresponding to the original method exists in the record table.
When the application program of the client terminal is started, the script files corresponding to the modified methods are recorded, and when the application program specifically runs, the corresponding methods are executed to execute related functional tasks. When the script code is constructed, a section of preset transfer logic is inserted in advance at the entrance of each method, and then the preset transfer logic is executed first before the corresponding method is executed. Specifically, the preset transfer logic is: and inquiring whether the record table in the step S62 contains records with the same splicing name or not according to the class name of the original method corresponding to the current method and the splicing of the original method signature. If not, the original logic of the current method is continued to be executed, which indicates that the current method does not need to be repaired. If the hash record table contains a name, which indicates that the current method needs to be replaced, logic of the current method is abandoned, and the modified script file is skipped to execute the functional task.
The specific steps of executing the functional task by jumping the modified script file are as follows: acquiring a file path of the script file after modification corresponding to the original method from a record table; acquiring a modified script file based on the file path; and executing the modified script file.
In a specific application scenario, a file path of a script file corresponding to the splicing of the class name of the original method corresponding to the current method and the original method signature is obtained from a record table, the script file is read from a storage device of the client terminal based on the file path, and the script file is executed through a general engine, so that the functional task is executed. The current method logic is not being executed.
In a specific application scenario, a file path of a JS file corresponding to the class name of the original method corresponding to the current method and the concatenation of the original method signature is obtained from a hash record table, so that the script file stored in the equipment is read through the file path, and then the JS file is executed through engines such as a general JavaScript engine (such as a JavaScript core or other JS engine) and the like, so that the execution of the corresponding functional task is completed.
In this embodiment, the transmission network between the server and the client terminal and the data flow of the data transmission are the same as those of the embodiment of fig. 2, please refer to the foregoing, and the description is omitted here.
Through the steps, the method for repairing the application program in the embodiment obtains the latest patch package from the server by starting the application program, and can realize automatic repair of the business program, thereby avoiding related operations of downloading and updating the application program by a user, reducing operation steps of the user, and improving repair experience and efficiency. And unpacking the latest patch package to obtain script files corresponding to the modified methods in response to the fact that the latest patch package comprises the modified script files, recording file paths of the script files based on the names of the script files to obtain a record table, judging whether spliced records of class names and method signatures corresponding to the original methods exist in the record table through executing preset transfer logic, and if the record table contains the same record as the spliced records of the class names and the method signatures corresponding to the original methods, executing tasks corresponding to the original methods through executing the modified script files to realize the restoration of the application program based on the preset transfer logic. The latest patch package in the embodiment is obtained through a KotlenJs compiler, and the multi-platform applicability of the KotlenJs compiler can be utilized to uniformly repair the multi-platform application programs, so that the repair efficiency is improved. The method and the device avoid the independent compiling and repairing of the developer aiming at each platform, reduce the repairing workload of the developer, further improve the repairing efficiency of the application programs of each platform and reduce the project maintenance cost.
Referring to fig. 7, fig. 7 is a schematic diagram of a repairing apparatus according to an embodiment of the application program. The application repairing apparatus 70 includes an acquisition module 71, a compiling module 72, and a packaging module 73. An acquisition module 71 for acquiring the modified script code; the compiling module 72 is configured to compile the modified script code by using a multi-platform compiler, and generate a script file with a set format, where the script file corresponds to the modified methods one by one; and the packaging module 73 is configured to package the script files corresponding to the modified methods to obtain a latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from the server, and the application program is repaired based on the script files in response to the latest patch package including the script files corresponding to the modified methods.
The compiling module 72 is further configured to compile the modified script code by using a kotlenjs compiler to generate a script file in Javascript format.
The compiling module 72 is further configured to compile the modified script code based on the dimension of each kotlen module by using a kotlenjs compiler, so as to obtain a plurality of compiling scripts; splitting the compiling script based on the method contained in each compiling script to obtain a script file corresponding to each modified method; wherein each modified method corresponds to a script file.
The packaging module 73 is further configured to compare the script code before modification with the script code after modification, and obtain a method newly added and a method changed in the script code after modification; naming script files corresponding to the newly added method and the changed method according to the class names of the original method corresponding to the newly added method and the changed method and the concatenation of the method signatures; and packaging the named script file to obtain the latest patch package.
The obtaining module 71 is further configured to insert preset transfer logic into each original method entry of the script code when the script code of the application program is constructed, so that when executing a task corresponding to the original method of the application program, it is determined whether to execute the task by executing the original method by executing the preset transfer logic in the original method.
The acquisition module 71 is also used to construct script code for the application by Kotlin.
According to the scheme, the user can be prevented from manually downloading and updating the application program, the operation steps of the user are reduced, and the repairing experience and efficiency of the application program are improved.
Referring to fig. 8, fig. 8 is a schematic diagram of a repairing apparatus according to another embodiment of the application program.
The repairing device 80 of the application program comprises a starting module 81 and a repairing module 82. The starting module 81 is used for starting an application program and acquiring the latest patch package from a server; the repair module 82 is configured to repair the application program based on the script file in response to the latest patch package including the script files corresponding to the modified methods; wherein, the latest patch package is script codes after the server acquires the modification; compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, and packaging the script files corresponding to the modified methods, wherein the script files correspond to the modified methods one by one.
The repair module 82 is further configured to execute a task corresponding to the original method of the application program by executing preset relay logic at an entry of the original method of the application program, so as to determine whether to execute the task by executing the original method.
The repair module 82 is further configured to unpack the latest patch package in response to the latest patch package including the modified script file, to obtain script files corresponding to the modified methods; and recording the file path of each script file based on the naming of the script file to obtain a record table. Judging whether a spliced record of a class name and a method signature corresponding to the original method exists in a record table or not by executing preset transfer logic; and if the record table has the same record of the class name corresponding to the original method and the concatenation of the method signature, executing the task corresponding to the original method by executing the modified script file.
The repair module 82 is further configured to obtain a file path of the script file after modification corresponding to the original method from the record table; acquiring a modified script file based on the file path; and executing the modified script file.
According to the scheme, the user can be prevented from manually downloading and updating the application program, the operation steps of the user are reduced, and the repairing experience and efficiency of the application program are improved.
Referring to fig. 9, fig. 9 is a schematic frame diagram of an embodiment of an electronic device of the present application. The electronic device 90 comprises a memory 91 and a processor 92 coupled to each other, the processor 92 being adapted to execute program instructions stored in the memory 91 for implementing the steps of the method for repairing an application of any of the first, second, third and fourth embodiments described above. In one particular implementation scenario, electronic device 90 may include, but is not limited to: the microcomputer and the server, and the electronic device 90 may also include a mobile device such as a notebook computer and a tablet computer, which is not limited herein.
In particular, the processor 92 is operative to control itself and the memory 91 to implement the steps of the repair method embodiment of any of the application programs described above. The processor 92 may also be referred to as a CPU (Central Processing Unit ). The processor 92 may be an integrated circuit chip with signal processing capabilities. The processor 92 may also be a general purpose processor, a digital signal processor (Digital Signal Processor, DSP), an application specific integrated circuit (Application Specific Integrated Circuit, ASIC), a Field programmable gate array (Field-Programmable Gate Array, FPGA) or other programmable logic device, discrete gate or transistor logic device, discrete hardware components. A general purpose processor may be a microprocessor or the processor may be any conventional processor or the like. In addition, the processor 92 may be commonly implemented by an integrated circuit chip.
According to the scheme, the user can be prevented from manually downloading and updating the application program, the operation steps of the user are reduced, and the repairing experience and efficiency of the application program are improved.
Referring to fig. 10, fig. 10 is a schematic diagram illustrating a framework of an embodiment of a computer readable storage medium according to the present application. The computer-readable storage medium 100 stores program instructions 1001 executable by a processor, the program instructions 1001 being for implementing the steps of the method for repairing an application of any of the first, second, third and fourth embodiments described above.
According to the scheme, the user can be prevented from manually downloading and updating the application program, the operation steps of the user are reduced, and the repairing experience and efficiency of the application program are improved.
In the several embodiments provided in the present application, it should be understood that the disclosed methods and apparatus may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of modules or units is merely a logical functional division, and there may be additional divisions of actual implementation, e.g., units or components may be combined or integrated into another system, or some features may be omitted, or not performed. Alternatively, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices or units, which may be in electrical, mechanical, or other forms.
The elements illustrated as separate elements may or may not be physically separate, and elements shown as elements may or may not be physical elements, may be located in one place, or may be distributed over network elements. Some or all of the units may be selected according to actual needs to achieve the purpose of the embodiment.
In addition, each functional unit in each embodiment of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.
The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present application may be embodied essentially or in part or all or part of the technical solution contributing to the prior art or in the form of a software product stored in a storage medium, including several instructions to cause a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor (processor) to perform all or part of the steps of the methods of the embodiments of the present application. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-Only Memory (ROM), a random access Memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.
Claims (11)
1. A method for repairing an application program, the method comprising:
the server acquires the modified script code;
compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files are in one-to-one correspondence with the modified methods;
packaging the script files corresponding to the modified methods to obtain a latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from a server, and the application program is repaired based on the script files in response to the latest patch package comprising the script files corresponding to the modified methods;
the step of packing the script files corresponding to the modified methods to obtain the latest patch package comprises the following steps:
comparing the current script code with the modified script code to obtain a new method and a new changing method in the modified script code; naming script files corresponding to the new method and the changed method according to the class names of the original methods corresponding to the new method and the changed method and the concatenation of the method signatures; packaging the named script file to obtain the latest patch package;
The step of compiling the modified script code by using a multi-platform compiler to generate a script file with a set format further comprises the following steps:
when the script code of the application program is constructed, a preset transfer logic is inserted into each original method entry of the script code, so that when a task corresponding to an original method of the application program is executed, whether the task is executed by executing the original method is judged by executing the preset transfer logic in the original method.
2. The method for repairing an application program according to claim 1, wherein the step of compiling the modified script code using a multi-platform compiler to generate a script file in a set format comprises:
and compiling the modified script codes by using a KotlenJs compiler to generate a script file in a Javascript format.
3. The method for repairing an application program according to claim 1, wherein the step of compiling the modified script code with a multi-platform compiler to generate a script file in a set format, wherein the script file corresponds to the modified methods comprises:
Compiling the modified script codes based on the dimension of each Kotlen module by a Kotlen js compiler to obtain a plurality of compiling scripts;
splitting the compiling script based on the method contained in each compiling script to obtain a script file corresponding to each modified method;
wherein each modified method corresponds to a script file.
4. A method of repairing an application according to any one of claims 1-3, further comprising:
script code of the application is constructed through Kotlin.
5. A method for repairing an application program, the method comprising:
the client terminal starts the application program and acquires the latest patch package from the server;
responding to the latest patch package which comprises script files corresponding to a plurality of modified methods, and repairing the application program based on the script files;
the latest patch package is used for comparing the current script code with the modified script code to obtain a new method and a new changing method in the modified script code; naming script files corresponding to the new method and the changed method according to the class names of the original methods corresponding to the new method and the changed method and the concatenation of the method signatures; packaging the named script files, wherein the script files correspond to the modified methods one by one;
The step of repairing the application program based on the script file comprises the following steps of:
executing tasks corresponding to the original methods of the application program by executing preset transfer logic at the original method entrance of the application program, so as to judge whether the tasks are executed by executing the original methods.
6. The method for repairing an application program according to claim 5, wherein the step of repairing the application program based on the script file in response to the latest patch package including the script file corresponding to the modified methods includes:
unpacking the latest patch package to obtain script files corresponding to the modified methods in response to the fact that the latest patch package comprises the modified script files;
recording the file path of each script file based on the naming of the script file to obtain a record table;
judging whether a spliced record of a class name and a method signature corresponding to the original method exists in the record table or not by executing the preset transfer logic;
And if the record table has the record with the same class name and method signature corresponding to the original method, executing the task corresponding to the original method by executing the modified script file.
7. The method for repairing an application program according to claim 6, wherein the step of executing the task corresponding to the original method by executing the modified script file comprises:
acquiring a file path of the modified script file corresponding to the original method from the record table;
acquiring the modified script file based on the file path;
and executing the modified script file.
8. An application repair device, the application repair device comprising:
the acquisition module is used for acquiring the modified script code;
the compiling module is used for compiling the modified script codes by utilizing a multi-platform compiler to generate script files with set formats, wherein the script files are in one-to-one correspondence with the modified methods;
the packaging module is used for packaging the script files corresponding to the modified methods to obtain a latest patch package, so that when the client terminal starts the application program, the latest patch package is obtained from a server, and the application program is repaired based on the script files in response to the fact that the latest patch package comprises the script files corresponding to the modified methods;
The step of packing the script files corresponding to the modified methods to obtain the latest patch package comprises the following steps:
comparing the current script code with the modified script code to obtain a new method and a new changing method in the modified script code; naming script files corresponding to the new method and the changed method according to the class names of the original methods corresponding to the new method and the changed method and the concatenation of the method signatures; packaging the named script file to obtain the latest patch package;
the step of compiling the modified script code by using a multi-platform compiler to generate a script file with a set format further comprises the following steps:
when the script code of the application program is constructed, a preset transfer logic is inserted into each original method entry of the script code, so that when a task corresponding to an original method of the application program is executed, whether the task is executed by executing the original method is judged by executing the preset transfer logic in the original method.
9. An application repair device, the application repair device comprising:
The starting module is used for starting the application program and acquiring the latest patch package from the server;
the repairing module is used for responding to script files corresponding to the modified methods included in the latest patch package and repairing the application program based on the script files; the latest patch package is used for comparing the current script code with the modified script code to obtain a new method and a new changing method in the modified script code; naming script files corresponding to the new method and the changed method according to the class names of the original methods corresponding to the new method and the changed method and the concatenation of the method signatures; packaging the named script files, wherein the script files correspond to the modified methods one by one;
the step of repairing the application program based on the script file comprises the following steps of:
executing tasks corresponding to the original methods of the application program by executing preset transfer logic at the original method entrance of the application program, so as to judge whether the tasks are executed by executing the original methods.
10. An electronic device comprising a memory and a processor coupled to each other, the processor being configured to execute program instructions stored in the memory to implement the method of repairing an application according to any one of claims 1 to 4 or the method of repairing an application according to any one of claims 5 to 7.
11. A computer readable storage medium having stored thereon program instructions, which when executed by a processor, implement the method of repairing an application according to any of claims 1 to 4 or the method of repairing an application according to any of claims 5 to 7.
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN202110722068.0A CN113467803B (en) | 2021-06-28 | 2021-06-28 | Application program repairing method, related device and equipment |
Applications Claiming Priority (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
CN202110722068.0A CN113467803B (en) | 2021-06-28 | 2021-06-28 | Application program repairing method, related device and equipment |
Publications (2)
Publication Number | Publication Date |
---|---|
CN113467803A CN113467803A (en) | 2021-10-01 |
CN113467803B true CN113467803B (en) | 2024-03-01 |
Family
ID=77873420
Family Applications (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
CN202110722068.0A Active CN113467803B (en) | 2021-06-28 | 2021-06-28 | Application program repairing method, related device and equipment |
Country Status (1)
Country | Link |
---|---|
CN (1) | CN113467803B (en) |
Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2246782A1 (en) * | 2009-04-30 | 2010-11-03 | Sap Ag | Application modification framework |
CN103853589A (en) * | 2014-02-26 | 2014-06-11 | 上海爱数软件有限公司 | Cross-platform system compiling and building method |
CN111488169A (en) * | 2020-04-07 | 2020-08-04 | 网易(杭州)网络有限公司 | Method and device for hot updating of application program, storage medium and electronic equipment |
CN111666096A (en) * | 2020-07-02 | 2020-09-15 | 腾讯科技(深圳)有限公司 | Hot updating method and device for target application, storage medium and electronic equipment |
-
2021
- 2021-06-28 CN CN202110722068.0A patent/CN113467803B/en active Active
Patent Citations (4)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
EP2246782A1 (en) * | 2009-04-30 | 2010-11-03 | Sap Ag | Application modification framework |
CN103853589A (en) * | 2014-02-26 | 2014-06-11 | 上海爱数软件有限公司 | Cross-platform system compiling and building method |
CN111488169A (en) * | 2020-04-07 | 2020-08-04 | 网易(杭州)网络有限公司 | Method and device for hot updating of application program, storage medium and electronic equipment |
CN111666096A (en) * | 2020-07-02 | 2020-09-15 | 腾讯科技(深圳)有限公司 | Hot updating method and device for target application, storage medium and electronic equipment |
Also Published As
Publication number | Publication date |
---|---|
CN113467803A (en) | 2021-10-01 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US10296323B2 (en) | System and method for fast initial and incremental deployment of apps | |
CN111367510B (en) | Android function module development method and device | |
US8612947B2 (en) | System and method for remotely compiling multi-platform native applications for mobile devices | |
EP3410296A1 (en) | Starting method and device for embedded device | |
US20020169591A1 (en) | Module for developing wireless device applications using an integrated emulator | |
CN104991793A (en) | Method, device and system used for application program subpackage | |
CN109032638A (en) | Hot update method, server and the mobile terminal of mobile application software | |
US10866803B2 (en) | Generating interaction libraries | |
CN112631622A (en) | Application installation method and device, server and computer readable medium | |
CN105159732A (en) | Method for installing or updating application program in mobile terminal and mobile terminal | |
CN108132808B (en) | Channel package generation method and device | |
CN112148297A (en) | Intelligent server encryption and packaging method and device | |
CN111061486B (en) | Android application program increment method | |
CN116009959B (en) | Flash item transplanting method, device and system and storage medium | |
CN113467803B (en) | Application program repairing method, related device and equipment | |
CN113641389B (en) | Software upgrading method, device and equipment based on OpenCPU | |
CN112685048B (en) | Application program packaging method, electronic device and storage medium | |
CN113157329A (en) | Method, system, server and storage medium for starting application | |
CN114529066A (en) | Updating method, device and equipment of Flutter application and storage medium | |
CN112596751A (en) | Compiling method, terminal, server and storage medium of application program installation package | |
CN112506519A (en) | Compiling method of application program, mobile terminal and server | |
CN110362320B (en) | Command implementation method and device of application development platform | |
CN115168175A (en) | Program error solving method, device, electronic equipment and storage medium | |
CN113849202A (en) | Drive adaptation method and device for kernel upgrading of operating system and electronic equipment | |
CN113849181A (en) | Cross compiling tool chain construction method and device, electronic equipment and storage medium |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
PB01 | Publication | ||
PB01 | Publication | ||
SE01 | Entry into force of request for substantive examination | ||
SE01 | Entry into force of request for substantive examination | ||
GR01 | Patent grant | ||
GR01 | Patent grant |