CN118409786B - Method, device, equipment and medium for configuring dynamic link library based on multiple processes - Google Patents
Method, device, equipment and medium for configuring dynamic link library based on multiple processes Download PDFInfo
- Publication number
- CN118409786B CN118409786B CN202410890400.8A CN202410890400A CN118409786B CN 118409786 B CN118409786 B CN 118409786B CN 202410890400 A CN202410890400 A CN 202410890400A CN 118409786 B CN118409786 B CN 118409786B
- Authority
- CN
- China
- Prior art keywords
- dynamic link
- application program
- target
- file name
- function
- 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 148
- 230000006870 function Effects 0.000 claims abstract description 161
- 230000015654 memory Effects 0.000 claims description 26
- 238000004590 computer program Methods 0.000 claims description 6
- 238000012544 monitoring process Methods 0.000 claims description 6
- 238000010926 purge Methods 0.000 claims description 6
- 238000004891 communication Methods 0.000 claims description 5
- 230000001419 dependent effect Effects 0.000 abstract description 22
- 238000004886 process control Methods 0.000 abstract description 2
- 238000010586 diagram Methods 0.000 description 8
- 238000003491 array Methods 0.000 description 3
- 230000002159 abnormal effect Effects 0.000 description 2
- 230000005856 abnormality Effects 0.000 description 2
- 238000012217 deletion Methods 0.000 description 2
- 230000037430 deletion Effects 0.000 description 2
- 238000011161 development Methods 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 239000007787 solid Substances 0.000 description 2
- 239000002699 waste material Substances 0.000 description 2
- 238000010276 construction Methods 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 238000010295 mobile communication Methods 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000004806 packaging method and process Methods 0.000 description 1
- 238000012856 packing Methods 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/30—Monitoring
- G06F11/3003—Monitoring arrangements specially adapted to the computing system or computing system component being monitored
- G06F11/3017—Monitoring arrangements specially adapted to the computing system or computing system component being monitored where the computing system is implementing multitasking
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F16/00—Information retrieval; Database structures therefor; File system structures therefor
- G06F16/10—File systems; File servers
- G06F16/16—File or folder operations, e.g. details of user interfaces specifically adapted to file systems
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44505—Configuring for program initiating, e.g. using registry, configuration files
- G06F9/4451—User profiles; Roaming
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F9/00—Arrangements for program control, e.g. control units
- G06F9/06—Arrangements for program control, e.g. control units using stored programs, i.e. using an internal store of processing equipment to receive or retain programs
- G06F9/44—Arrangements for executing specific programs
- G06F9/445—Program loading or initiating
- G06F9/44521—Dynamic linking or loading; Link editing at or after load time, e.g. Java class loading
Landscapes
- Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Software Systems (AREA)
- Physics & Mathematics (AREA)
- General Engineering & Computer Science (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Mathematical Physics (AREA)
- Human Computer Interaction (AREA)
- Data Mining & Analysis (AREA)
- Databases & Information Systems (AREA)
- Quality & Reliability (AREA)
- Computer Security & Cryptography (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention relates to the technical field of application process control, and discloses a method, a device, equipment and a medium for configuring a dynamic link library based on multiple processes; and simultaneously calling a preset dynamic link file copy function, and copying all dynamic link files in the original resource directory to the private directory of the target application program so that the target application program can realize a corresponding target operation function through each target process. According to the method, different processes are created for different functions, the processes are independent from each other, different dependent files are started through the different processes, each process can be enabled to independently load and use the required dynamic link file version, and even though the dependent files with the same name are used, stable operation of the function modules of the APP can be guaranteed.
Description
Technical Field
The invention relates to the technical field of application process control, in particular to a method, a device, equipment and a medium for configuring a dynamic link library based on multiple processes.
Background
The number of dependency libraries that need to be introduced by android applications when accessing more third party products is increasing. These dependency libraries may include, but are not limited to, java classes, resource files, dynamic dependency libraries, and the like. Thus, conflicts between different dependent libraries, such as class conflicts, resource conflicts, dynamic link library conflicts, and the like, are prone to occur. Among them, dynamic link library conflict (also called so library conflict) mainly occurs in the case where so libraries of the same name are used in different dependent libraries (i.e., the names of the same dependent library are the same).
The technical scheme for solving the conflict of the so library is as follows: (1) The conflicting providers are allowed to use the same NDK version when compiling the generated so library, or to statically link the conflicting libraries when compiling the so library. The disadvantages are that: the relying provider does not want to use the PICKFIRST command of gradle with modifying the so files, waiting too long, etc. (2), the PICKFIRST command of gradle will ignore other conflicting, homonymous so files by only keeping the first found so library file and packing it into the final APK, and will not be packed into the final APK, since there is only one, so there is no conflict with other relying libraries. The disadvantages are that: when a plurality of dependent libraries respectively need the sofiles of different versions, the PICKFIRST method only reserves the first sofile, so that the sofiles of another version cannot be loaded, and only one sofile with the same name can be loaded in the same process, and the dependent libraries A and B cannot work normally in the same process at the same time although the dependent conflict is solved, and finally, the APP operation is abnormal.
Disclosure of Invention
In view of the above, the present invention provides a method, apparatus, device and medium for configuring a dynamic link library based on multiple processes, so as to solve the problem of ensuring normal dependency of homonymy dependent files without depending on a provider, thereby avoiding abnormal operation of an APP due to homonymy dependency during operation.
In a first aspect, the present invention provides a method for configuring a dynamic link library based on multiple processes, which is applied to a terminal device, where the terminal device is preconfigured with an android application program project structure, and a plurality of dependency library files under an original resource directory of the android application program project structure respectively include corresponding dynamic link files, and a dependency library folder preconfigured in the configuration file, where the method includes:
When the operation of a target application program is monitored, monitoring a plurality of target operation functions which are currently executed by the target application program at the same time; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively;
creating target processes respectively corresponding to each target operation function, simultaneously calling a preset dynamic link file copy function, and copying all dynamic link files under the original resource directory to a private directory of a target application program so that the target application program can realize the corresponding target operation function through each target process.
In the embodiment, when an application program runs, a plurality of target running functions executed before the execution are monitored, the processes and the needed dependency libraries thereof are dynamically managed, an independent target process is created for each functional module during the running, each process loads a needed specific version of the so library, namely the condition of conflict of the homonymous dependency libraries in the related technology is avoided, the so library under the original resource directory is copied to the private directory of the application program by utilizing a preset dynamic link file copy function, and the stable running of the functional module of the APP application program can be ensured no matter whether the homonymous dependency files exist or not.
In an alternative embodiment, the calling a preset dynamic link file copy function copies all dynamic link files under the original resource directory to a private directory of the target application program, including:
Calling a preset dynamic link file copy function to acquire a private directory path of a target application program;
The file name of the dynamic link file is obtained, and a first dynamic link file name list is generated;
The file names of all dynamic links in the private directory of the target application program are obtained according to the private directory path, and a second dynamic link file name list is generated;
and copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path according to the first dynamic link file name list and the second dynamic link file name list.
According to the embodiment, the private directory path of the target application program is obtained by calling the preset dynamic link file copying function, the first dynamic link file name list and the second dynamic link file name list are respectively generated, and the required dynamic link files are copied to the private directory of the target application program by comparing the first dynamic link file name list with the second dynamic link file name list, so that each target process can independently use the required dynamic link library files, and because each process has independent files in the private directory, resource competition among the processes is effectively reduced.
In an alternative embodiment, the copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path according to the first dynamic link file name list and the second dynamic link file name list includes:
Calling a preset file name comparison function to obtain a mark value corresponding to each dynamic link file name in the first dynamic link file name list; the marking value is used for indicating whether the corresponding dynamic link file name needs to be copied or not;
and copying the dynamic link file marked to be copied to the private directory of the target application program according to the private directory path according to the marking value corresponding to the dynamic link file name.
In the embodiment, each dynamic link file name is marked by calling a preset file name comparison function, so that the dynamic link files needing to be copied are effectively screened out. The method not only simplifies the file copying process, but also avoids unnecessary file copying operation, and saves storage space and system resources. And the different dynamic link files are marked independently, so that only the dynamic link files required by the operation of the target application program are copied, and the operation efficiency of the target application program is improved.
In an alternative embodiment, the copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path according to the first dynamic link file name list and the second dynamic link file name list includes:
Calling a preset file clearing function, and clearing all dynamic link files in the private directory of the target application program according to the second dynamic link file name list;
and copying the files corresponding to each dynamic link file name in the first dynamic link file name list to the private directory of the target application program in sequence according to the private directory path.
In the embodiment, the required dynamic link files are copied according to the designated private directory path through the marking value, so that the target process is ensured to have independent dynamic link library files in the private directory, resource competition among processes is avoided, independent running efficiency of the processes is improved, and because each process runs the required independent files in the private directory, safety risks are further reduced, and safety and reliability of the system are ensured.
In an optional implementation manner, the calling a preset file name comparison function to obtain a flag value corresponding to each dynamic link file name in the first dynamic link file name list includes:
calling a preset file name comparison function to read byte information of each dynamic link file name in the first dynamic link file name list as a first byte information set;
reading byte information of each dynamic link file name in the second dynamic link file name list as a second byte information set;
And traversing the first byte information set by taking byte information in the second byte information set as a target reference byte; when any byte information which is the same as the target reference byte exists in the first byte information set, marking the byte information which is the same as the target reference byte as to be copied; marking byte information in the first byte information set, which is different from the target reference byte, as non-copy.
According to the embodiment, the files to be copied are determined by comparing the file name information in the dynamic link file name list, so that the accuracy of file copying is improved, the file name information is used as a comparison standard, the complete files are not required to be compared, efficient comparison searching is guaranteed on the basis of accuracy, and the waste of computing resources is reduced.
In an alternative embodiment, the preset dynamic link file copy function, the preset file purge function, and the preset file name comparison function are all encapsulated in the same object instance;
And the object instance is also encapsulated with a dynamic link loading function, which is used for loading a dynamic link file existing in the private directory of the target application program so that the target process runs the corresponding target running function through the dynamic link file.
In this embodiment, by creating an object instance and integrating all related functions, the preset dynamic link file copy function, the preset file removal function, the dynamic link loading function, and the preset file name comparison function and data into one object, when the object instance is called, the operation can be quickly performed, and if the related code of a specific function needs to be improved, only the content in the same object instance is modified, so that the implementation of other function instances is not affected.
In a second aspect, the present invention provides an apparatus for configuring a dynamic link library based on multiple processes, where the apparatus includes:
The program monitoring module is used for monitoring a plurality of target operation functions which are currently executed by the target application program simultaneously when the target application program is monitored to operate; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively;
And the multi-process function operation module is used for creating target processes respectively corresponding to each target operation function, calling a preset dynamic link file copy function at the same time, and copying all dynamic link files under the original resource directory to a private directory of a target application program so that the target application program can realize the corresponding target operation function through each target process at the same time.
In a third aspect, the present invention provides a computer device comprising: the memory and the processor are in communication connection, computer instructions are stored in the memory, and the processor executes the computer instructions, so that the method based on the multi-process configuration dynamic link library according to the first aspect or any implementation mode corresponding to the first aspect is executed.
In a fourth aspect, the present invention provides a computer readable storage medium having stored thereon computer instructions for causing a computer to perform the method of configuring a dynamic link library based on multiple processes of the first aspect or any of its corresponding embodiments.
In a fifth aspect, the present invention provides a computer program product comprising computer instructions for causing a computer to perform the method of the first aspect or any of its corresponding embodiments based on a multi-process configuration dynamic link library.
Drawings
In order to more clearly illustrate the embodiments of the present invention or the technical solutions in the prior art, the drawings that are needed in the description of the embodiments or the prior art will be briefly described, and it is obvious that the drawings in the description below are some embodiments of the present invention, and other drawings can be obtained according to the drawings without inventive effort for a person skilled in the art.
FIG. 1 is a flow diagram of a method for configuring a dynamic link library based on multiple processes according to an embodiment of the present invention;
FIG. 2 is a schematic diagram of an android project structure based on a method of configuring a dynamic link library in multiple processes according to an embodiment of the present invention;
FIG. 3 is another schematic diagram of an android project structure based on a method of multi-process configuration of dynamic link libraries according to an embodiment of the invention;
FIG. 4 is another schematic diagram of an android project structure based on a method of multi-process configuration of dynamic link libraries according to an embodiment of the invention;
FIG. 5 is a flow diagram of another method for configuring a dynamic link library based on multiple processes according to an embodiment of the present invention;
FIG. 6 is a block diagram of an apparatus for dynamically linking libraries based on multi-process configuration, according to an embodiment of the present invention;
fig. 7 is a schematic diagram of a hardware structure of a computer device according to an embodiment of the present invention.
Detailed Description
For the purpose of making the objects, technical solutions and advantages of the embodiments of the present invention more apparent, the technical solutions of the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention, and it is apparent that the described embodiments are some embodiments of the present invention, but not all embodiments of the present invention. All other embodiments, which can be made by those skilled in the art based on the embodiments of the invention without making any inventive effort, are intended to be within the scope of the invention.
With the business development of different enterprises, the number of dependence libraries which need to be introduced is gradually increased when the android APP is accessed to more third-party products. The dependent objects that may be contained in these dependent libraries include, but are not limited to, java classes, resource files, and dynamic link libraries (so libraries), among others. Conflicts, such as class conflicts, resource conflicts, dynamic link library conflicts, and the like, easily occur between different dependent libraries, wherein the reason for the dynamic link library conflicts (i.e., so library conflicts) is that so libraries with the same name are used in different dependent libraries, i.e., the names of different versions of the same dependent library are the same.
In the related art, there are two main ways of solving the above-mentioned homonymy dependency library conflict. The first way may be to coordinate conflicting relying providers to have them use the same NDK version when compiling the generated so library, or to statically link conflicting libraries when compiling the so library. In this way, coordinating dependency providers (e.g., software companies) to modify their dependency libraries tend to be very low in feasibility, and the dependency providers are unwilling to coordinate and have too long a latency. The second way may be to keep the so-libraries of only one dependency library, removing the so-libraries in other conflicting dependency libraries. For example, using the PICKFIRST command of gradle, the command may allow the APP to package only the first so library into the final apk file when compiling and packaging if there are conflicting so libraries. In this way, when multiple dependent libraries are hard dependent on different versions of the so library respectively, for example, the dependent library a must use the version 1.0 so library, while the dependent library B must use the version 1.1 so library, and since only one same-name so library can be loaded in the same process, the solution can cause that the APP cannot use the dependent library a and the dependent library B at the same time during running.
The embodiment of the invention provides a method for configuring a dynamic link library based on multiple processes, which is applied to a scene of an application program needing to integrate multiple third-party dependency libraries or a scene of an application program needing to simultaneously operate multiple complex function modules.
In accordance with an embodiment of the present invention, there is provided an embodiment of a method for configuring a dynamic link library based on multiple processes, it being noted that the steps illustrated in the flowchart of the figures may be performed in a computer system, such as a set of computer executable instructions, and that although a logical order is illustrated in the flowchart, in some cases the steps illustrated or described may be performed in an order other than that illustrated herein.
In this embodiment, a method for configuring a dynamic link library based on multiple processes is provided, and the method is applied to a terminal device, where the terminal device is preconfigured with an android application project structure, and a plurality of dependency library files under an original resource directory of the android application project structure respectively include corresponding dynamic link files, and dependency library folders preconfigured in the configuration files, and fig. 1 is a flowchart of the method for configuring a dynamic link library based on multiple processes according to an embodiment of the present invention, and as shown in fig. 1, the flowchart includes the following steps:
Step S101, monitoring a plurality of target operation functions which are currently executed by a target application program simultaneously when the operation of the target application program is monitored; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively.
Note that, in this embodiment, the project structure of the android application refers to a project directory structure created by using the android development tool when developing the android application, and at least includes a resource file (e.g.,/res,/assets), a configuration file (e.g.,/build. Gradle), a file (e.g.,/src) storing source code, and the like.
In this embodiment, the original resource directory (/ assets /) is used to store the original files needed by the application, that is, the dynamic link files included in the multiple dependency library files respectively in this embodiment, and the dynamic dependency files (so files) are loaded in the android system when the application program runs, so as to provide corresponding functions.
In the configuration file (/ build. Gradle) of this embodiment, the dependency library folder is preconfigured. It can be understood that the dependency library is declared in the build. Gradle file, so that the android application program project structure can automatically manage the dependency item, and the library files required by project construction are ensured to exist, so that the dependency needs to be preconfigured for the introduction of the dependency. Illustratively, the incoming declaration in the configuration file may refer to the following format:
implementation'D1'；
implementation'D2'；
Wherein, materialization represents a key in the build. Gradle file for declaring the library on which the project depends, D1 or D2 represents the identifier of a specific different dependent library file.
For example, in this embodiment, the android application project structure may refer to fig. 2, where two dependency library folders D1 and D2 are set under the/assets directory, and different dependency library files D1 and D2 are preconfigured in the build.
Specifically, referring to fig. 3, D1 includes a dynamic link file a.so, and referring to fig. 4 and D2, it should be noted that the dynamic link file a.so in the present embodiment is a homonymy dependent file, but a.so in D1 is a file of substantially version 1, and a.so in D2 is a file of substantially version 2.
It should be noted that, the target application refers to an executing android application, that is, application software installed and run on the mobile device by the user. The target application needs to implement multiple functions at runtime, each of which may depend on a different third party library, such as a music playing application, where music playing is being performed, but where the user opens a audio book channel and clicks on audio book playing, so both play cases need to rely on the same file for dynamic playback, but are not essentially the same running function. Therefore, the embodiment monitors a plurality of target running functions which are currently executed by the target application program at the same time, so as to determine the number of target processes which need to be created.
Step S102, creating target processes respectively corresponding to each target operation function, simultaneously calling a preset dynamic link file copy function, and copying all dynamic link files under the original resource directory to a private directory of a target application program so that the target application program can realize the corresponding target operation function through each target process.
It can be understood that the purpose of creating the target processes respectively corresponding to each target running function is to avoid conflict of the same-name dependency library, in the android operating system, if different functions of the same application program depend on library files with the same name but different versions at the same time, the conflict can be caused, and by creating independent processes for each target running function, each process can be ensured to load the required specific version library files, so that the independence and stability of the android application program function module are ensured. In this embodiment, the target process is created by the android operating system in the terminal device.
It should be noted that, the preset dynamic link file copy function refers to a function predefined in the program, which is used to copy the dynamic link file (so file) under the original resource directory to the private directory of the target application program. By calling the preset dynamic link file copy function, each function module can load the required dynamic link file from the private directory instead of directly loading the dynamic link file from the original resource directory when the application program runs.
It can be understood that the android operating system has advanced authority management on the private directory of the application program, only the application program can access the files in the private directory thereof, so that the dynamic link files are copied from the original resource directory to the private directory of the target application program, and the required library files are loaded through the independent process of each functional module, so that other application programs or malicious software can be prevented from modifying the required dynamic link files, the operation safety of the android system is improved, meanwhile, the independent process accesses the independent private directory of the application program, the access logic is clearer, the complexity of file loading is reduced, and the operation stability of the program is further improved.
In the embodiment, when an application program runs, a plurality of target running functions executed before the execution are monitored, the processes and the needed dependency libraries thereof are dynamically managed, an independent target process is created for each functional module during the running, each process loads a needed specific version of the so library, namely the condition of conflict of the homonymous dependency libraries in the related technology is avoided, the so library under the original resource directory is copied to the private directory of the application program by utilizing a preset dynamic link file copy function, and the stable running of the functional module of the APP application program can be ensured no matter whether the homonymous dependency files exist or not.
The embodiment also provides a method for configuring a dynamic link library based on multiple processes, which can be used for the terminal equipment, and the flow comprises the following steps:
Step S501, monitoring a plurality of target running functions currently executed by a target application program when the running of the target application program is monitored; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively. Please refer to step S101 in the embodiment shown in fig. 1 in detail, which is not described herein.
Step S502, creating target processes respectively corresponding to each target running function; and simultaneously calling a preset dynamic link file copy function, and copying all dynamic link files under the original resource directory to a private directory of a target application program so that the target application program can realize a corresponding target operation function through each target process.
Specifically, referring to fig. 5, the foregoing method may call a preset dynamic link file copy function at the same time, copy all dynamic link files under the original resource directory to the private directory of the target application program, including:
Step S5021, calling a preset dynamic link file copy function to obtain a private directory path of a target application program.
It should be noted that, in this embodiment, the preset dynamic link file copy function is substantially implemented in the source code, and the main function of the preset dynamic link file copy function is to process the copy operation of the dynamic link library file.
Specifically, when the private directory path of the target application program is acquired, the existence of the private directory of the application program is determined first, a directory verification function can be called to ensure the existence of the private directory, and if the private directory exists, the private directory path is created. An example code example of step S5031 in the present embodiment is as follows:
val privateDir = File(privateDirPath) ；
FileUtils.createOrExistsDir(privateDir)；
Wherein FileUtils. CreateOrExistsDir (PRIVATEDIR) is called in the code to ensure that private directories exist. FileUtils.createOrExistsDir provides one of the functions pre-written for technical documentation or by the developer. For example PRIVATEDIRPATH is/data/com. Example. App/lib/, the code will check and create the private directory.
Step S5022, obtaining the file name of the dynamic link file, and generating a first dynamic link file name list.
Specifically, in this embodiment, a list including all the file names of the dynamically linked library that need to be copied is obtained, and a first dynamically linked file name list is generated, which is used to represent all the dynamically linked library files that are needed by the application program.
Step S5023, the file names of all dynamic links in the private directory of the target application program are obtained according to the private directory path, and a second dynamic link file name list is generated.
Step S5024, copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path according to the first dynamic link file name list and the second dynamic link file name list.
Specifically, in this embodiment, all the second dynamic link files in the private directory are obtained and checked, and compared with the first dynamic link file names in the Apk package, and according to the comparison result, the dynamic link files to be copied are copied to the private directory of the target application program according to the private directory path.
According to the embodiment, the private directory path of the target application program is obtained by calling the preset dynamic link file copying function, the first dynamic link file name list and the second dynamic link file name list are respectively generated, and the required dynamic link files are copied to the private directory of the target application program by comparing the first dynamic link file name list with the second dynamic link file name list, so that each target process can independently use the required dynamic link library files, and because each process has independent files in the private directory, resource competition among the processes is effectively reduced.
Specifically, in an embodiment, step S5024 includes:
a1, calling a preset file name comparison function to obtain a mark value corresponding to each dynamic link file name in the first dynamic link file name list; the tag value is used to indicate whether the corresponding dynamically linked filename needs to be copied.
A2, copying the dynamic link file marked to be copied to the private directory of the target application program according to the private directory path according to the marking value corresponding to the dynamic link file name.
In the embodiment, each dynamic link file name is marked by calling a preset file name comparison function, so that the dynamic link files needing to be copied are effectively screened out. The method not only simplifies the file copying process, but also avoids unnecessary file copying operation, and saves storage space and system resources. And the different dynamic link files are marked independently, so that only the dynamic link files required by the operation of the target application program are copied, and the operation efficiency of the target application program is improved.
An example code of step A1 in this embodiment is as follows:
varneedToCopy=false
for (fileName in copyFileNames) {
val assetFilePath = "$assetPath${File.separator}$fileName"
val assetFileStream = context.assets.open(assetFilePath
val privateFile = File(privateDirPath, fileName)
if (!privateFile.exists() || !isFileContentSame(assetFileStream, FileInputStream(privateFile))) {
needToCopy = true break
}
}
The boolean variable needToCopy is defined first, and as a flag value, an initial value is false, which is used to indicate whether a File copy is needed, and for loop traversal copyFileNames is used to traverse each fileName in the list, in the loop, ASSETFILEPATH, ASSETFILEPATH is constructed to be a path formed by splicing ASSETPATH, file separator and fileName, and a resource File is opened through context. If PRIVATEFILE does not exist, needToCopy is set to true and the loop is jumped out. The dynamic link file is marked through needToCopy variables and the process of circulating traversal, and only the file is copied when necessary, so that the repeated copying of the files with the same content is avoided.
In an alternative embodiment, step A1 specifically includes: calling a preset file name comparison function to read byte information of each dynamic link file name in the first dynamic link file name list as a first byte information set; reading byte information of each dynamic link file name in the second dynamic link file name list as a second byte information set; and traversing the first byte information set by taking byte information in the second byte information set as a target reference byte; when any byte information which is the same as the target reference byte exists in the first byte information set, marking the byte information which is the same as the target reference byte as to be copied; marking byte information in the first byte information set, which is different from the target reference byte, as non-copy.
In an alternative implementation manner of this embodiment, specific exemplary codes of step A1 are as follows:
privatefunisFileContentSame(
inputStream1:InputStream,
inputStream2:FileInputStream):Boolean{
returninputStream1.use{input1->inputStream2.use{input2->input1.readBytes().contentEquals(input2.readBytes())
}
}
}
The isFileContentSame function receives two input parameters inputStream and inputStream (the input parameters in this embodiment are a first dynamically linked file name list and a second dynamically linked file name list), and uses the use function to ensure that the input streams are correctly closed after use, so as to effectively avoid resource leakage, and in use blocks, all bytes of the two input streams are respectively read and converted into byte arrays. The contents of the two byte arrays are compared using the contentEquals method, if the two byte arrays are the same, the function returns true, otherwise returns false.
According to the embodiment, the files to be copied are determined by comparing the file name information in the dynamic link file name list, so that the accuracy of file copying is improved, the file name information is used as a comparison standard, the complete files are not required to be compared, efficient comparison searching is guaranteed on the basis of accuracy, and the waste of computing resources is reduced.
An example code of step A2 in this embodiment is as follows:
if (needToCopy) {
privateDir.listFiles { _, name ->name.endsWith(".so") }?,forEach { it.delete() }
for (fileName in copyFileNames)
{ val assetsFileName = "$assetPath${File.separator}$fileName"
context.assets.open(assetsFileName).use { assetInputStream ->val privateFile = File(privateDirPath, fileName)
FileOutputStream(privateFile).use { outputStream ->assetInputStream.copyTo(outputStream)
}
}
}
}
Wherein needToCopy is a flag value indicating whether the corresponding dynamically linked file name needs to be copied, and according to the judging condition if (needToCopy), if needToCopy is true, continuing to execute the subsequent operation, and traversing copyFileNames each file name in the list (comparison result): and constructing ASSETSFILENAME, namely adding a file name to an original resource directory address, opening a dynamic link file input stream assetInputStream corresponding to ASSETSFILENAME, creating a file PRIVATEFILE corresponding to the file name under a private directory path PRIVATEDIRPATH, copying the content in the dynamic link file input stream into PRIVATEFILE by using a file output stream outputStream, and completing the whole process of copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path. The use statement is used for automatically managing the opening and closing of resources (input stream and output stream), so that the code copying process is simplified, the speed is high, and the safety of dynamically linking file copying is ensured.
In another embodiment, step S5024 comprises:
And B1, calling a preset file clearing function, and clearing all dynamic link files in the private directory of the target application program according to the second dynamic link file name list.
And B2, copying the files corresponding to each dynamic link file name in the first dynamic link file name list to the private directory of the target application program in sequence according to the private directory path.
In step B1 of this embodiment, the preset file removal function may be used before step A2, and may also be used in a process of copying the dynamic link file alone, where in a code implementation process, only one preset file removal function needs to be written alone, where main parameters of the preset file removal function include: the logic of the preset file clearing function may be to obtain the private directory path of the target application program, list all files in the private directory, filter out all files meeting the specific extension, and traverse and delete all files meeting the conditions. The preset file clearing function returns a boolean value, true: indicating successful deletion of all eligible files; false: indicating an error in the deletion process. The specific code example is not described herein, and when the preset file clearing function needs to be called, the preset file clearing function statement is set before the step A2, so that after the preset file name comparison function is called, the dynamic link file under the private directory is cleared in time, and occupation of memory resources is reduced.
In step B2 of this embodiment, only one single copy list is created, and all the first dynamic link file names are stored in the single copy list, and are sequentially copied to the private directory of the target application program according to the private directory path, which is not described in detail herein.
In the embodiment, the required dynamic link files are copied according to the designated private directory path through the marking value, so that the target process is ensured to have independent dynamic link library files in the private directory, resource competition among processes is avoided, independent running efficiency of the processes is improved, and because each process runs the required independent files in the private directory, safety risks are further reduced, and safety and reliability of the system are ensured.
In an alternative embodiment, the preset dynamic link file copy function, the preset file purge function, and the preset file name comparison function are all encapsulated in the same object instance;
And the object instance is also encapsulated with a dynamic link loading function, which is used for loading a dynamic link file existing in the private directory of the target application program so that the target process runs the corresponding target running function through the dynamic link file.
It should be noted that, the object instance (e.g. DynamicSoLoadUtils) may be understood as a specific object created by a class, where the object instance in this embodiment includes a series of related functions and attributes, and is used to encapsulate a preset dynamic link file copy function (e.g. copyContentFile), the preset file purge function (e.g. clearOldFiles), a dynamic link load function (e.g. system. Load), and the preset file name comparison function (e.g. isFileContentSame), where the object instance is specifically used to manage operations such as loading, comparing, copying, and purging of a dynamic link file.
In addition, the dynamic link loading function is used for loading the dynamic link file existing in the private directory of the target application program, and the function is a function which can be directly called in the technical document of the android operating system.
The code example of the dynamic link loading function of this embodiment is as follows:
for(filenameincopyFileNames){
System.load(privateDirPath+File.separator+filename)
}
true
}catch(t:Throwable){
t.printStackTrace()
false
}
}
The code traverses each file name to load the corresponding dynamic link file through the system.load function, if an abnormality occurs in the loading process, the abnormality is captured and printed into the operation log, and the function returns to false to indicate that the loading is failed.
In this embodiment, by creating an object instance and integrating all related functions, the preset dynamic link file copy function, the preset file removal function, the dynamic link loading function, and the preset file name comparison function and data into one object, when the object instance is called, the operation can be quickly performed, and if the related code of a specific function needs to be improved, only the content in the same object instance is modified, so that the implementation of other function instances is not affected.
According to the method for configuring the dynamic link library based on the multiple processes, when an App runs, when a function F1 is used, a process P1 is started, when the P1 process is initialized, A.so in a assets/D1 directory is copied into a private directory of the App on a current running device (for example, data/com.sample.app/D1, wherein com.sample.app represents a package name of the App), the so is loaded, and after loading is completed, the function F1 can be normally used in the P1 process. If the function F2 is used, the process P2 is started in the same way, and the two processes are not interfered with each other and are independent of each other, so that two different functions are simultaneously realized, and the more the functions are, the more the processes are started, the embodiment only takes two processes as an example, but is not limited thereto.
In this embodiment, a device for configuring a dynamic link library based on multiple processes is further provided, and the device is used to implement the foregoing embodiments and preferred embodiments, which are not described herein. As used below, the term "module" may be a combination of software and/or hardware that implements a predetermined function. While the means described in the following embodiments are preferably implemented in software, implementation in hardware, or a combination of software and hardware, is also possible and contemplated.
The embodiment provides a device for configuring a dynamic link library based on multiple processes, as shown in fig. 6, including:
A program monitoring module 601, configured to monitor, when it is monitored that a target application program runs, a plurality of target running functions that are currently executed by the target application program simultaneously; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively;
And the multi-process function operation module 602 is configured to create a target process corresponding to each target operation function, and call a preset dynamic link file copy function at the same time, and copy all dynamic link files in the original resource directory to a private directory of a target application program, so that the target application program realizes the corresponding target operation function through each target process at the same time.
In an alternative embodiment, the multi-process function execution module 602 includes:
the private directory path acquisition unit is used for calling a preset dynamic link file copy function to acquire a private directory path of the target application program;
The first dynamic link file name list generation unit is used for acquiring the file names of the dynamic link files and generating a first dynamic link file name list;
The second dynamic link file name list generating unit is used for acquiring all dynamic link file names in the private directory of the target application program according to the private directory path and generating a second dynamic link file name list;
And the file copying unit is used for copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path according to the first dynamic link file name list and the second dynamic link file name list.
In an alternative embodiment, the file copy unit includes:
A file marking subunit, configured to call a preset file name comparison function, and obtain a marking value corresponding to each dynamic link file name in the first dynamic link file name list; the marking value is used for indicating whether the corresponding dynamic link file name needs to be copied or not;
And the marking copy subunit is used for copying the dynamic link file marked to be copied to the private directory of the target application program according to the private directory path according to the marking value corresponding to the dynamic link file name.
In an alternative embodiment, the file copy unit includes:
A file clearing subunit, configured to call a preset file clearing function, and clear all the dynamically linked files in the private directory of the target application program according to the second dynamically linked file name list;
And the file complete copying subunit is used for copying the files corresponding to each dynamic link file name in the first dynamic link file name list to the private directory of the target application program in sequence according to the private directory path.
In an alternative embodiment, the file marking subunit comprises: calling a preset file name comparison function to read byte information of each dynamic link file name in the first dynamic link file name list as a first byte information set; reading byte information of each dynamic link file name in the second dynamic link file name list as a second byte information set; and traversing the first byte information set by taking byte information in the second byte information set as a target reference byte; when any byte information which is the same as the target reference byte exists in the first byte information set, marking the byte information which is the same as the target reference byte as to be copied; marking byte information in the first byte information set, which is different from the target reference byte, as non-copy.
In an alternative embodiment, the preset dynamic link file copy function, the preset file purge function, and the preset file name comparison function are all encapsulated in the same object instance;
And the object instance is also encapsulated with a dynamic link loading function, which is used for loading a dynamic link file existing in the private directory of the target application program so that the target process runs the corresponding target running function through the dynamic link file.
Further functional descriptions of the above respective modules and units are the same as those of the above corresponding embodiments, and are not repeated here.
The apparatus of the present embodiment based on a multi-process configuration dynamic link library is presented in the form of functional units, where the units refer to ASIC (APPlication SPECIFIC INTEGRATED Circuit ) circuits, processors and memories executing one or more software or fixed programs, and/or other devices that can provide the above-described functions.
The embodiment of the invention also provides a computer device which is provided with the device based on the multi-process configuration dynamic link library shown in the figure 6.
Referring to fig. 7, fig. 7 is a schematic structural diagram of a computer device according to an alternative embodiment of the present invention, as shown in fig. 7, the computer device includes: one or more processors 10, memory 20, and interfaces for connecting the various components, including high-speed interfaces and low-speed interfaces. The various components are communicatively coupled to each other using different buses and may be mounted on a common motherboard or in other manners as desired. The processor may process instructions executing within the computer device, including instructions stored in or on memory to display graphical information of the GUI on an external input/output device, such as a display device coupled to the interface. In some alternative embodiments, multiple processors and/or multiple buses may be used, if desired, along with multiple memories and multiple memories. Also, multiple computer devices may be connected, each providing a portion of the necessary operations (e.g., as a server array, a set of blade servers, or a multiprocessor system). One processor 10 is illustrated in fig. 7.
The processor 10 may be a central processor, a network processor, or a combination thereof. The processor 10 may further include a hardware chip, among others. The hardware chip may be an application specific 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.
Wherein the memory 20 stores instructions executable by the at least one processor 10 to cause the at least one processor 10 to perform a method for implementing the embodiments described above.
The memory 20 may include a storage program area that may store an operating system, at least one application program required for functions, and a storage data area; the storage data area may store data created according to the use of the computer device, etc. In addition, the memory 20 may include high-speed random access memory, and may also include non-transitory memory, such as at least one magnetic disk storage device, flash memory device, or other non-transitory solid-state storage device. In some alternative embodiments, memory 20 may optionally include memory located remotely from processor 10, which may be connected to the computer device via a network. Examples of such networks include, but are not limited to, the internet, intranets, local area networks, mobile communication networks, and combinations thereof.
Memory 20 may include volatile memory, such as random access memory; the memory may also include non-volatile memory, such as flash memory, hard disk, or solid state disk; the memory 20 may also comprise a combination of the above types of memories.
The computer device also includes a communication interface 30 for the computer device to communicate with other devices or communication networks.
The embodiments of the present invention also provide a computer readable storage medium, and the method according to the embodiments of the present invention described above may be implemented in hardware, firmware, or as a computer code which may be recorded on a storage medium, or as original stored in a remote storage medium or a non-transitory machine readable storage medium downloaded through a network and to be stored in a local storage medium, so that the method described herein may be stored on such software process on a storage medium using a general purpose computer, a special purpose processor, or programmable or special purpose hardware. The storage medium can be a magnetic disk, an optical disk, a read-only memory, a random access memory, a flash memory, a hard disk, a solid state disk or the like; further, the storage medium may also comprise a combination of memories of the kind described above. It will be appreciated that a computer, processor, microprocessor controller or programmable hardware includes a storage element that can store or receive software or computer code that, when accessed and executed by the computer, processor or hardware, implements the methods illustrated by the above embodiments.
Portions of the present invention may be implemented as a computer program product, such as computer program instructions, which when executed by a computer, may invoke or provide methods and/or aspects in accordance with the present invention by way of operation of the computer. Those skilled in the art will appreciate that the form of computer program instructions present in a computer readable medium includes, but is not limited to, source files, executable files, installation package files, etc., and accordingly, the manner in which the computer program instructions are executed by a computer includes, but is not limited to: the computer directly executes the instruction, or the computer compiles the instruction and then executes the corresponding compiled program, or the computer reads and executes the instruction, or the computer reads and installs the instruction and then executes the corresponding installed program. Herein, a computer-readable medium may be any available computer-readable storage medium or communication medium that can be accessed by a computer.
Although the embodiments of the present invention have been described with reference to the accompanying drawings, various modifications and variations may be made by those skilled in the art without departing from the spirit and scope of the invention, and such modifications and variations fall within the scope of the appended claims.
Claims (10)
1. The method is characterized by being applied to terminal equipment, wherein the terminal equipment is pre-configured with an android application program project structure, a plurality of dependency library files under an original resource directory of the android application program project structure respectively comprise corresponding dynamic link files, and a dependency library folder pre-configured in the configuration file;
the method comprises the following steps:
When the operation of a target application program is monitored, monitoring a plurality of target operation functions which are currently executed by the target application program at the same time; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively;
creating target processes respectively corresponding to each target operation function, simultaneously calling a preset dynamic link file copy function, and copying all dynamic link files under the original resource directory to a private directory of a target application program so that the target application program can realize the corresponding target operation function through each target process.
2. The method according to claim 1, wherein the calling a preset dynamic link file copy function copies all dynamic link files in the original resource directory to a private directory of the target application program, specifically comprising:
Calling a preset dynamic link file copy function to acquire a private directory path of a target application program;
The file name of the dynamic link file is obtained, and a first dynamic link file name list is generated;
The file names of all dynamic links in the private directory of the target application program are obtained according to the private directory path, and a second dynamic link file name list is generated;
and copying the dynamic link file to be copied to the private directory of the target application program according to the private directory path according to the first dynamic link file name list and the second dynamic link file name list.
3. The method according to claim 2, wherein the copying the dynamically linked file to be copied to the private directory of the target application program according to the private directory path according to the first dynamically linked file name list and the second dynamically linked file name list specifically includes:
Calling a preset file name comparison function to obtain a mark value corresponding to each dynamic link file name in the first dynamic link file name list; the marking value is used for indicating whether the corresponding dynamic link file name needs to be copied or not;
and copying the dynamic link file marked to be copied to the private directory of the target application program according to the private directory path according to the marking value corresponding to the dynamic link file name.
4. The method according to claim 2, wherein the copying the dynamically linked file to be copied to the private directory of the target application program according to the private directory path according to the first dynamically linked file name list and the second dynamically linked file name list specifically includes:
Calling a preset file clearing function, and clearing all dynamic link files in the private directory of the target application program according to the second dynamic link file name list;
and copying the files corresponding to each dynamic link file name in the first dynamic link file name list to the private directory of the target application program in sequence according to the private directory path.
5. The method according to claim 3 or 4, wherein calling a preset file name comparison function to obtain a flag value corresponding to each dynamically linked file name in the first dynamically linked file name list specifically includes:
calling a preset file name comparison function to read byte information of each dynamic link file name in the first dynamic link file name list as a first byte information set;
reading byte information of each dynamic link file name in the second dynamic link file name list as a second byte information set;
And traversing the first byte information set by taking byte information in the second byte information set as a target reference byte; when any byte information which is the same as the target reference byte exists in the first byte information set, marking the byte information which is the same as the target reference byte as to be copied; marking byte information in the first byte information set, which is different from the target reference byte, as non-copy.
6. The method of claim 5, wherein the preset dynamic link file copy function, the preset file purge function, and the preset filename comparison function are all encapsulated in the same object instance;
And the object instance is also encapsulated with a dynamic link loading function, which is used for loading a dynamic link file existing in the private directory of the target application program so that the target process runs the corresponding target running function through the dynamic link file.
7. The device for configuring the dynamic link library based on the multiple processes is characterized by being applied to terminal equipment, wherein the terminal equipment is pre-configured with an android application program project structure, dependency library files under an original resource directory of the android application program project structure respectively comprise corresponding dynamic link files, and a dependency library folder is pre-configured in the configuration files;
The device comprises:
The program monitoring module is used for monitoring a plurality of target operation functions which are currently executed by the target application program simultaneously when the target application program is monitored to operate; when the target application program realizes each target operation function, the target application program depends on a dependency library corresponding to each target operation function respectively;
And the multi-process function operation module is used for creating target processes respectively corresponding to each target operation function, calling a preset dynamic link file copy function at the same time, and copying all dynamic link files under the original resource directory to a private directory of a target application program so that the target application program can realize the corresponding target operation function through each target process at the same time.
8. A computer device, comprising:
A memory and a processor in communication with each other, the memory having stored therein computer instructions that, upon execution, perform the method of any of claims 1-6 based on a multi-process configuration dynamic link library.
9. A computer-readable storage medium having stored thereon computer instructions for causing a computer to perform the method of any one of claims 1-6 based on a multi-process configuration dynamic link library.
10. A computer program product comprising computer instructions for causing a computer to perform the method of configuring a dynamic link library based on multiple processes of any one of claims 1-6.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410890400.8A CN118409786B (en) | 2024-07-04 | 2024-07-04 | Method, device, equipment and medium for configuring dynamic link library based on multiple processes |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202410890400.8A CN118409786B (en) | 2024-07-04 | 2024-07-04 | Method, device, equipment and medium for configuring dynamic link library based on multiple processes |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN118409786A CN118409786A (en) | 2024-07-30 |
| CN118409786B true CN118409786B (en) | 2024-08-30 |
Family
ID=91991123
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202410890400.8A Active CN118409786B (en) | 2024-07-04 | 2024-07-04 | Method, device, equipment and medium for configuring dynamic link library based on multiple processes |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN118409786B (en) |
Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109324881A (en) * | 2018-08-22 | 2019-02-12 | 深圳点猫科技有限公司 | A kind of packaging method and electronic equipment of front end programming project |
| CN111400256A (en) * | 2020-03-16 | 2020-07-10 | 北京五八信息技术有限公司 | Method and device for calling resource file by application program |
Family Cites Families (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US7546305B2 (en) * | 2001-04-13 | 2009-06-09 | Oracle International Corporation | File archival |
| CN114527987A (en) * | 2022-01-11 | 2022-05-24 | 广州文远知行科技有限公司 | Application software package generation method and device, computer equipment and storage medium |
| CN116594644A (en) * | 2023-05-05 | 2023-08-15 | 中国工商银行股份有限公司 | Android system-based application program hot update method and device |
| CN117407048B (en) * | 2023-12-14 | 2024-03-12 | 江西飞尚科技有限公司 | Flow configuration method and system of plug-in data processing software |
-
2024
- 2024-07-04 CN CN202410890400.8A patent/CN118409786B/en active Active
Patent Citations (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109324881A (en) * | 2018-08-22 | 2019-02-12 | 深圳点猫科技有限公司 | A kind of packaging method and electronic equipment of front end programming project |
| CN111400256A (en) * | 2020-03-16 | 2020-07-10 | 北京五八信息技术有限公司 | Method and device for calling resource file by application program |
Also Published As
| Publication number | Publication date |
|---|---|
| CN118409786A (en) | 2024-07-30 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US11599654B2 (en) | Method and apparatus for authority control, computer device and storage medium | |
| CN105723341A (en) | Interface for representing bindings between objects in a web browser's layout engine memory space and objects in a scripting engine memory space | |
| CN112256359A (en) | Microservice merging method, apparatus, electronic device and readable storage medium | |
| US20090249311A1 (en) | Sharing a native module of compiled code using an abstraction module of interpreted code in a virtual machine environment | |
| CN111176717A (en) | Method and device for generating installation package and electronic equipment | |
| CN111651169B (en) | Block chain intelligent contract operation method and system based on web container | |
| CN111309335A (en) | Plug-in application compiling method and device and computer readable storage medium | |
| CN114490103B (en) | Method, device and electronic device for calling operating system interface | |
| CN117591136A (en) | Storage image generation method, device, computer equipment and storage medium | |
| CN112416612A (en) | Service calling method and device, computer equipment and readable storage medium | |
| CN115543486A (en) | Cold start delay optimization method, device and equipment for serverless computing | |
| CN110941443A (en) | Method and device for modifying file name in SDK and electronic equipment | |
| CN118377585B (en) | Method, device, medium and equipment for applying Docker container in android system | |
| CN118409786B (en) | Method, device, equipment and medium for configuring dynamic link library based on multiple processes | |
| CN118567705A (en) | DKMS-based closed source kernel module generation method and DKMS-based closed source kernel module generation system | |
| CN117707543A (en) | Application installation package manufacturing and installation method, computing device and storage medium | |
| CN113760442A (en) | An application operation and access method, device and device | |
| CN105393216B (en) | Run-time memory is adjusted | |
| CN113778535B (en) | Cloud host operation verification method, system, equipment and storage medium | |
| CN117170640A (en) | A component management method, device and readable storage medium for a low-code platform | |
| CN110058876B (en) | Method, device, server and storage medium for expanding compatibility of wireshark software | |
| CN113641389A (en) | Software upgrading method, device and equipment based on OpenCPU | |
| CN116774988B (en) | Method and device for releasing frame package mode symbol dependence | |
| CN114443316B (en) | Object access method and device and electronic equipment | |
| RU2521265C2 (en) | System and method for automatic processing of software system errors |
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 |