CN112306466A - AAR packet generation method, electronic device, and storage medium - Google Patents
AAR packet generation method, electronic device, and storage medium Download PDFInfo
- Publication number
- CN112306466A CN112306466A CN202011196655.2A CN202011196655A CN112306466A CN 112306466 A CN112306466 A CN 112306466A CN 202011196655 A CN202011196655 A CN 202011196655A CN 112306466 A CN112306466 A CN 112306466A
- Authority
- CN
- China
- Prior art keywords
- file
- aar
- merged
- files
- modules
- 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.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/20—Software design
- G06F8/24—Object-oriented
-
- 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
-
- 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
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)
Abstract
The embodiment of the application relates to the technical field of packaging, and discloses an AAR package generation method, electronic equipment and a storage medium. In the application, a gradle construction flow is used for constructing application items; obtaining a merged file based on the same type of files in the plurality of modules; storing the merged file into a subdirectory corresponding to a first built directory of the application project; and packaging the application item by utilizing the gradle construction flow to generate an AAR package. In the process of generating the AAR package in the existing gradle construction process, a merged file is obtained based on files of the same type in a plurality of modules, the merged file is stored in a subdirectory corresponding to an application project and is finally packaged into the AAR package, and the functions of the modules can be opened to a third party for use through the AAR package, so that when the third party uses the AAR package, a port of the AAR package does not need to be exposed, and the safety of the AAR package is improved. Meanwhile, the self-defining step is added in the gradle construction process construction in the prior art, and the whole process is simple and easy to operate.
Description
Technical Field
The embodiment of the application relates to the technical field of packaging, in particular to an AAR package generation method, electronic equipment and a storage medium.
Background
With the rapid Development of the mobile internet, due to the requirement of service Development, a mobile phone client will package some capabilities into a Software Development Kit (SDK) and open the SDK to a third party for use, so that the third party has the capabilities; at present, the business of the mobile phone client is more and more complex, the code amount is more and more, and the multi-module componentized engineering mode is more and more applied in practice, so that the mobile phone client has a plurality of modules, and the capacity required by a third party exists in each module; therefore, in order for a third party to obtain capabilities in multiple modules, one solution existing in the prior art is to generate a separate AAR package for each module using the gradle construction flow provided by the official tool, and the third party can implement these functions by introducing multiple AAR packages.
The inventor finds that at least the following problems exist in the prior art: due to the coupling of the services among a plurality of AAR packets, the interface in one AAR packet needs to be exposed to other AAR packets for use, so that the codes of the AAR packets cannot be confused, because the confusion can hide the interface of the AAR packet and cannot realize the connection among the AAR packets; therefore, in the prior art, the interfaces of a plurality of AAR packets must be exposed, and there are risks that the codes of the AAR packets are exposed, the interfaces of the AAR packets are miscalled by others, and the like.
Disclosure of Invention
An object of the embodiments of the present application is to provide an AAR packet generation method, an electronic device, and a storage medium, so that the security performance of an AAR packet is improved.
In order to solve the above technical problem, an embodiment of the present application provides an AAR packet generation method, including the following steps: constructing an application project by utilizing a gradle construction flow; obtaining a merged file based on the same type of files in the plurality of modules; storing the merged file into a subdirectory corresponding to a first built directory of the application project; and packaging the application item by utilizing the gradle construction flow to generate an AAR package.
An embodiment of the present application further provides an electronic device, including: at least one processor; and a memory communicatively coupled to the at least one processor; wherein the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the AAR packet generation method as described above.
Embodiments of the present application also provide a computer-readable storage medium storing a computer program that, when executed by a processor, implements the AAR package generation method described above.
Compared with the prior art, in the process of generating the AAR package in the existing gradle construction process, the merged files are obtained based on the files of the same type in the modules, are stored in the subdirectory corresponding to the first build directory of the application project, and are finally packaged into the AAR package, so that the functions of the modules can be opened to a third party for use through the AAR package, the ports of the AAR package do not need to be exposed when the third party uses the AAR package, the merged files in the AAR package can be confused, and the safety performance of the AAR package is improved. Meanwhile, the self-defining step is added in the gradle construction process construction in the prior art, and the whole process is simple and easy to operate.
In addition, obtaining a merged file based on the same type of files in the plurality of modules includes: and merging the files of the same type in the modules to obtain the merged file of the same type as the file.
Additionally, the types of the files in the plurality of modules include: res resource file, xml file, assets file, libs file; the merged file of the same type as the file includes: res resource merge file, xml merge file, assets merge file, libs merge file.
In addition, the res resource file is stored in the second built directory of each module.
In addition, each of the modules includes a txt file; obtaining a merged file based on the same type of files in the plurality of modules, including: generating a java file according to the txt file of each module; compiling each java file to generate the class file; and combining each class file to obtain a class combined file.
In addition, the generating a java file according to the txt file of each module includes: and traversing the resource id in each txt file, and generating the java file according to the resource id.
In addition, each module comprises jar files; after the class files are combined to obtain the class combined file, the method further comprises the following steps: packaging the class merged file by using a jar packaging command to obtain a class. And merging the jar files of the modules with the class.
In addition, after the storing the merged file into the subdirectory corresponding to the first build directory of the application project, the method further includes: obfuscating the merged file using the gradle construction process, wherein the obfuscated merged file includes: res resource merge file, class merge file, jar merge file, xml merge file.
Drawings
One or more embodiments are illustrated by way of example in the accompanying drawings, which correspond to the figures in which like reference numerals refer to similar elements and which are not to scale unless otherwise specified.
Fig. 1 is a schematic flow chart of an AAR packet generation method according to a first embodiment of the present application;
fig. 2 is a schematic flow chart of an AAR packet generation method according to a second embodiment of the present application;
fig. 3 is a schematic flow chart of an AAR packet generation method according to a third embodiment of the present application;
FIG. 4 is a flowchart illustrating a merging sequence of res resource file, class file, jar file, and xml file according to a third embodiment of the present application;
fig. 5 is a schematic structural diagram of an electronic device according to a fourth embodiment of the present application.
Detailed Description
To make the objects, technical solutions and advantages of the embodiments of the present application clearer, the embodiments of the present application will be described in detail below with reference to the accompanying drawings. However, it will be appreciated by those of ordinary skill in the art that in the examples of the present application, numerous technical details are set forth in order to provide a better understanding of the present application. However, the technical solution claimed in the present application can be implemented without these technical details and various changes and modifications based on the following embodiments. The following embodiments are divided for convenience of description, and should not constitute any limitation to the specific implementation manner of the present application, and the embodiments may be mutually incorporated and referred to without contradiction.
A first embodiment of the present application relates to an AAR packet generation method, and a specific flow is shown in fig. 1, which includes the following steps:
and step 101, constructing an application project by utilizing a gradle construction flow.
Specifically, the gradle construction process of this embodiment is an existing gradle construction process, and is a method for generating an AAR based on a single module provided on the android officer network, and as can be seen, only one AAR packet is generated for one module in the existing gradle construction process; in this embodiment, an existing gradle building flow is used to generate an AAR packet for a plurality of modules, that is, some custom steps are added to the existing gradle building flow, so that an AAR packet can be directly generated for a plurality of modules in the process of generating the AAR packet by using the existing gradle building flow, not only can the functions of the plurality of modules be integrated into one AAR packet be realized, but also the process of generating one AAR packet is simplified.
Specifically, the construction of an application item by using the gradle construction process is blank, and the application item has a first built directory which is provided with a plurality of subdirectories according to a preset rule. And a second built directory also exists in the modules, a plurality of subdirectories are also arranged in the second built directory according to a preset rule, and the subdirectories of the second built directory are used for storing various types of files for a subsequent merging process.
Specifically, the subdirectories of the second build directory store various types of files, so in this embodiment, the files of the subdirectories of the second build directory in each module are traversed respectively, and merged files are obtained based on the files of the same type in the modules; and then, storing the plurality of merged files into corresponding subdirectories of the first built directory of the application project respectively.
The sequence of the steps 101 and 102 may be set according to actual needs, and this embodiment is not particularly limited.
And 103, storing the merged file into a subdirectory corresponding to the first built directory of the application project. Specifically, a plurality of subdirectories of the first build directory of the application project are divided based on the type of the merged file. In this embodiment, after the merged file is obtained, the merged file is stored in the subdirectory corresponding to the first built directory according to the type of the merged file.
And 104, packaging the application item by using the gradle construction flow to generate an AAR package. Specifically, after the files are merged and stored in the subdirectories of the application items, the application items are packaged by using the existing gradle construction process to generate an AAR package, so that the functions of a plurality of modules are integrated into one AAR package, and the AAR package is convenient for a third party to use.
In this embodiment, in the process of generating the AAR package in the existing gradle construction process, the merged file is obtained based on the same type of files in the plurality of modules, and is stored in the directory corresponding to the application project, and is finally packaged into the AAR package, so that the functions of the plurality of modules can be opened to a third party for use through the AAR package, and thus, when the third party uses the AAR package, the port of the AAR package does not need to be exposed, and the security performance of the AAR package is improved. Meanwhile, the self-defining step is added in the gradle construction process in the prior art, and the whole process is simple and easy to operate.
In one example, deriving a merged file based on files of the same type in a plurality of modules includes: and merging the files of the same type in the modules to obtain merged files of the same type as the files. Specifically, in this embodiment, files of the same type are directly merged to obtain a merged file of the same type as the file, and the merging of the files can be realized only by adding the custom step in the existing gradle building process, which is relatively simple in process.
Specifically, the types of files in the plurality of modules include: res resource file, xml file, assets file, libs file; the merged file of the same type as the file includes: res resource merge file, xml merge file, assets merge file, libs merge file. That is to say, res resource files in a plurality of modules are directly merged to obtain an xml merged file, xml files in the plurality of modules are directly merged to obtain an xml merged file, assets files in the plurality of modules are directly merged to obtain an assets merged file, and libs files in the plurality of modules are directly merged to obtain a libs merged file. Specifically, the process of generating the xml merge file is as follows: and merging the xml files of each module through a manifest-merger tool to generate an xml merged file.
In one example, the res resource file is stored in the second built directory of each module. In this embodiment, the res resource file in the second build directory of each module is directly used, and compared with the method for acquiring the res resource file by using the source code, the method improves the speed of merging the res resource file, thereby improving the efficiency of the whole merged AAR.
In one example, each module includes a txt file; obtaining a merged file based on the same type of files in the plurality of modules, including: generating a java file according to the txt file of each module; compiling each java file to generate a class file; and merging each class file to obtain a class merged file. The method for generating the java file according to the txt file of each module comprises the following steps: and traversing the resource id in each txt file, and generating a java file according to the resource id. Specifically, the class merging file is generated based on txt files in a plurality of modules, java files are generated according to resource ids in the txt files, then a class file is generated through each java file, and finally a plurality of class files are merged to obtain a class merging file; and replacing resource ids of the txt files of the modules with class merging files of application items, so that the problem that the resource ids of the modules cannot be found due to the fact that names of different modules are inconsistent is solved.
In one example, each module includes jar files; after each class file is merged to obtain a class merged file, the method further comprises the following steps: packaging the class combined file by using a jar packaging command to obtain a class. And merging jar files of the modules with class. That is, the jar merge file is obtained by merging the jar file in each module and the class.
As can be seen from the above, the file types in the modules include: res resource files, xml files, assets files, libs files, txt files and jar files; the merging of files includes: res resource merge file, class merge file, jar merge file, xml merge file, assets merge file, libs merge file, and the step of generating various merge files is inserted into the gradle construction flow in the prior art, so that an AAR package is generated by utilizing the existing gradle construction flow for a third party to use.
Specifically, since the merge file of this embodiment includes a res resource merge file, an xml merge file, an assets merge file, a libs merge file, a class merge file, and a jar merge file, the subdirectory of the first build directory of the application project corresponds to the merge file of this type, that is, the subdirectory of the first build directory of the application project includes a res resource subdirectory, a class subdirectory, a jar subdirectory, an xml subdirectory, an assets subdirectory, and a libs subdirectory, so that the merge files of various types are stored in the corresponding subdirectories.
A second embodiment of the present application relates to an AAR packet generation method. The second embodiment is substantially the same as the first embodiment, with the main differences being: in the second embodiment of the present application, after storing the merged file in the subdirectory corresponding to the first built directory of the application project, the method further includes: building a flow confusion merge file by utilizing a gradle, wherein the merge file for confusion comprises the following steps: res resource merge file, class merge file, jar merge file, xml merge file. It should be noted that, the implementation details of the first embodiment are still valid in this embodiment, and are not described herein for avoiding redundancy.
A second embodiment of the present application relates to an AAR packet generation method, and a specific flow is shown in fig. 2, which includes the following steps:
and step 201, constructing the application project by utilizing the gradle construction flow.
And step 205, packaging the application item by using the gradle construction flow to generate an AAR package.
The steps 201, 202, 203, 205 are the same as the steps 101 to 104 of the first embodiment, and are not described herein again to avoid repetition.
Specifically, in the step 204, in the process of performing file obfuscation by using the existing gradle building flow, it is not necessary to obfuscate the assets merge file and the libs merge file, and therefore, the order of the step of merging the res resource file, the class file, the jar file, and the xml file and the step of merging the assets file and the libs file is not specifically limited herein, as long as only the res resource merge file, the class merge file, the jar merge file, and the xml merge file are obfuscated in the process of performing file obfuscation by using the existing gradle building flow, which is not specifically limited in this embodiment.
A third embodiment of the present application relates to an AAR packet generation method. The third embodiment is substantially the same as the second embodiment, with the main differences being: in the third embodiment of the present application, the merging order of each type of file is specifically defined. It should be noted that the implementation details of the second embodiment are still valid in this embodiment, and are not described herein for avoiding redundancy.
A third embodiment of the present application relates to an AAR packet generation method, and a specific flow is shown in fig. 3, which includes the following steps:
and step 301, constructing the application project by utilizing the gradle construction flow.
Specifically, the generation sequence of the four types of files, namely the res resource merge file, the class merge file, the jar merge file, and the xml merge file, is related to the sequence of the existing gradle construction flow processing file, and therefore, the generation sequence of the four types of merge files in this embodiment is as shown in fig. 4, and includes the following steps:
step 3021: and merging the res resource files to obtain res resource merged files.
Specifically, the res resource file in each module is stored in the second build directory in each module, before the res resource file is merged, the file of each module needs to be traversed, the res resource file is searched in the second build directory in each module, the res resource file under the second build directory of each module can be directly used, and compared with the method for acquiring the res resource file through a source code, the speed of merging the res resource file is increased, and therefore the speed of generating the AAR packet is increased.
Step 3022: and obtaining a class merging file based on the txt file.
Specifically, each module comprises a txt file; the step of obtaining the class merging file based on the txt file comprises the following steps: generating a java file according to the txt file in the built directory of each module; and compiling the java file to generate a class file.
Specifically, before a java file is generated according to the txt file in the second built directory of each module, a java file also exists in the second built directory of each module, and in this embodiment, after the java file is generated according to the txt file in the second built directory of each module, the newly generated java file is used to replace the original java file, and then the newly generated java file is compiled to generate a class file. The step of generating a java file according to the txt file in the second built directory of each module specifically comprises the following steps: and traversing the resource id in each txt file, and generating a java file according to the resource id of the txt file.
Step 3023: and obtaining jar merged files based on jar files in the modules.
Specifically, after obtaining the class merge file, the method further includes: packaging the class combined file by using a jar packaging command to obtain a class. Merging jar files in a plurality of modules, comprising: and merging jar files and class files of the modules to obtain jar merged files. It can be seen that, in the process of merging jar files in this embodiment, not only jar files in multiple modules are merged, but also class.
Step 3024: and merging the xml files in the modules to obtain an xml merged file.
Specifically, merging xml files in a plurality of modules includes: merging the xml files of the modules through a manifest-merger tool to generate an xml merged file. The xml file describes the large components of the android, and the xml files of the modules are merged through a manifest-merger tool to generate a new xml merged file, so that the xml merged file is stored in an xml subdirectory of a first build directory of the application project.
It should be noted that, except for special descriptions, the order of merging the various files is not specifically limited in this embodiment, and may be determined according to the order of processing files of the existing gradle building flow in practical applications.
Specifically, after the res resource merge file, the class merge file, the jar merge file and the xml merge file are obtained, the res resource merge file is stored in a res resource subdirectory of a first build directory of the application project, the class merge file is stored in a class subdirectory of the first build directory of the application project, the jar merge file is stored in a jar subdirectory of the first build directory of the application project, and the xml merge file is stored in an xml subdirectory of the first build directory of the application project.
Specifically, in an example, after each type of file is merged to generate a merged file, the merged file may be directly stored in a subdirectory corresponding to a first build directory of an application project, and the four types of merged files may be stored in the first build directory respectively; in another example, after all the four types of merged files are generated, the four types of merged files are stored in the subdirectory corresponding to the first build directory of the application project at the same time.
And step 304, constructing a flow confusion res resource merge file, a class merge file, a jar merge file and an xml merge file by using the gradle.
Specifically, after the res resource merged file, the class merged file, the jar merged file and the xml merged file are generated and before the assets merged file and the libs merged file are obtained, the res resource merged file, the class merged file, the jar merged file and the xml merged file are obfuscated by using a gradle construction process, so that the phenomenon that the assets merged file and the libs merged file which do not need to be obfuscated are obfuscated in an obfuscating process is avoided.
And 305, combining the assets file and the libs file to obtain an assets combined file and a libs combined file.
Specifically, after the assets merged file and the libs merged file are obtained, the assets merged file is stored in an assets subdirectory of the first build directory of the application project, and the libs merged file is stored in a libs subdirectory of the first build directory of the application project. It should be noted that, the order of merging the assets file and the libs file is not specifically limited in this embodiment, and in practical application, the order may be determined according to the order of the existing gradle construction flow processing file.
And 307, packaging the application item by using the gradle construction flow to generate an AAR package.
The steps of the above methods are divided for clarity, and the implementation may be combined into one step or split some steps, and the steps are divided into multiple steps, so long as the same logical relationship is included, which are all within the protection scope of the present patent; it is within the scope of the patent to add insignificant modifications to the algorithms or processes or to introduce insignificant design changes to the core design without changing the algorithms or processes.
A fourth embodiment of the present application relates to an electronic device, as shown in fig. 5, comprising at least one processor 402; and a memory 401 communicatively coupled to the at least one processor 402; the memory 401 stores instructions executable by the at least one processor 402, and the instructions are executed by the at least one processor 402 to enable the at least one processor 402 to execute the AAR packet generation method.
Where the memory 401 and the processor 402 are coupled by a bus, which may include any number of interconnected buses and bridges that couple one or more of the various circuits of the processor 402 and the memory 401 together. The bus may also connect various other circuits such as peripherals, voltage regulators, power management circuits, and the like, which are well known in the art, and therefore, will not be described any further herein. A bus interface provides an interface between the bus and the transceiver. The transceiver may be one element or a plurality of elements, such as a plurality of receivers and transmitters, providing a means for communicating with various other apparatus over a transmission medium. The data processed by the processor 402 is transmitted over a wireless medium through an antenna, which further receives the data and transmits the data to the processor 402.
The processor 402 is responsible for managing the bus and general processing and may also provide various functions including timing, peripheral interfaces, voltage regulation, power management, and other control functions. And memory 401 may be used to store data used by processor 402 in performing operations.
A fifth embodiment of the present application relates to a computer-readable storage medium storing a computer program. The computer program realizes the above-described method embodiments when executed by a processor.
That is, as can be understood by those skilled in the art, all or part of the steps in the method according to the above embodiments may be implemented by a program instructing related hardware, where the program is stored in a storage medium and includes several instructions to enable a device (which may be a single chip, a chip, or the like) or a processor (processor) to execute all or part of the steps in the method according to 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), a magnetic disk or an optical disk, and other various media capable of storing program codes.
It will be understood by those of ordinary skill in the art that the foregoing embodiments are specific examples for carrying out the present application, and that various changes in form and details may be made therein without departing from the spirit and scope of the present application in practice.
Claims (10)
1. An AAR packet generation method, comprising:
constructing an application project by utilizing a gradle construction flow;
obtaining a merged file based on the same type of files in the plurality of modules;
storing the merged file into a subdirectory corresponding to a first built directory of the application project;
and packaging the application item by utilizing the gradle construction flow to generate an AAR package.
2. The AAR package generation method of claim 1, wherein obtaining a merged file based on files of a same type in a plurality of modules comprises:
and merging the files of the same type in the modules to obtain the merged file of the same type as the file.
3. The AAR package generation method of claim 2, wherein the type of the file in a plurality of the modules comprises: res resource file, xml file, assets file, libs file; the merged file of the same type as the file includes: res resource merge file, xml merge file, assets merge file, libs merge file.
4. The AAR package generation method of claim 3, wherein the res resource file is stored in a second build directory of each of the modules.
5. The AAR packet generation method of claim 1, wherein each of the modules comprises a txt file; obtaining a merged file based on the same type of files in the plurality of modules, including:
generating a java file according to the txt file of each module;
compiling each java file to generate the class file;
and combining each class file to obtain a class combined file.
6. The AAR package generation method of claim 5, wherein said generating a java file from said txt file of each said module comprises:
and traversing the resource id in each txt file, and generating the java file according to the resource id.
7. The AAR package generation method of claim 5, wherein each of the modules comprises a jar file; after the class files are combined to obtain the class combined file, the method further comprises the following steps:
packaging the class merged file by using a jar packaging command to obtain a class.
And merging the jar files of the modules with the class.
8. The AAR package generation method of claim 1, wherein after storing the merged file in a subdirectory corresponding to the first build directory of the application project, the method further comprises:
obfuscating the merged file using the gradle construction process, wherein the obfuscated merged file includes: res resource merge file, class merge file, jar merge file, xml merge file.
9. An electronic device, comprising:
at least one processor; and the number of the first and second groups,
a memory communicatively coupled to the at least one processor; wherein the content of the first and second substances,
the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the AAR packet generation method of any of claims 1 to 8.
10. A computer-readable storage medium storing a computer program, wherein the computer program, when executed by a processor, implements the AAR packet generation method of any one of claims 1 to 8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011196655.2A CN112306466A (en) | 2020-10-30 | 2020-10-30 | AAR packet generation method, electronic device, and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202011196655.2A CN112306466A (en) | 2020-10-30 | 2020-10-30 | AAR packet generation method, electronic device, and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112306466A true CN112306466A (en) | 2021-02-02 |
Family
ID=74333309
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202011196655.2A Pending CN112306466A (en) | 2020-10-30 | 2020-10-30 | AAR packet generation method, electronic device, and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112306466A (en) |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113076146A (en) * | 2021-03-09 | 2021-07-06 | 北京一亩田新农网络科技有限公司 | Dynamic APK loading method, device, system and medium |
| CN113076146B (en) * | 2021-03-09 | 2024-06-07 | 北京一亩田新农网络科技有限公司 | Dynamic APK loading method, device, system and medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110502222A (en) * | 2019-07-23 | 2019-11-26 | 北京字节跳动网络技术有限公司 | AAR method, apparatus, medium and the equipment in outgoing dependence inner base library |
| CN111459892A (en) * | 2020-03-31 | 2020-07-28 | 民生科技有限责任公司 | Android system-based non-invasive aar merging method |
| CN111475199A (en) * | 2020-04-03 | 2020-07-31 | 北京金山云网络技术有限公司 | aar file generation method and device and electronic equipment |
-
2020
- 2020-10-30 CN CN202011196655.2A patent/CN112306466A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN110502222A (en) * | 2019-07-23 | 2019-11-26 | 北京字节跳动网络技术有限公司 | AAR method, apparatus, medium and the equipment in outgoing dependence inner base library |
| CN111459892A (en) * | 2020-03-31 | 2020-07-28 | 民生科技有限责任公司 | Android system-based non-invasive aar merging method |
| CN111475199A (en) * | 2020-04-03 | 2020-07-31 | 北京金山云网络技术有限公司 | aar file generation method and device and electronic equipment |
Non-Patent Citations (1)
| Title |
|---|
| LEEON: "合并AAR踩坑之旅", 《HTTPS://LEEON7.GITHUB.IO/2018/09/12/FAT-AAR/》 * |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113076146A (en) * | 2021-03-09 | 2021-07-06 | 北京一亩田新农网络科技有限公司 | Dynamic APK loading method, device, system and medium |
| CN113076146B (en) * | 2021-03-09 | 2024-06-07 | 北京一亩田新农网络科技有限公司 | Dynamic APK loading method, device, system and medium |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110189121B (en) | Data processing method and device, block chain client and block chain link point | |
| CN111201754A (en) | Apparatus for providing a collection of cryptographically protected and filtered and sorted transaction data sets of links of a blockchain | |
| CN103765853A (en) | Data modification for device communication channel packets | |
| CN106970820A (en) | Code storage method and code storage | |
| CN109074394B (en) | Method and system for distributed data storage with permanent integrity assurance | |
| CN105468709A (en) | Data inquiry device and data inquiry method based on HBase | |
| CN107622207B (en) | Encrypted system-level data structure | |
| CN111045722A (en) | Intelligent contract packaging method, device, system, computer equipment and storage medium | |
| CN112363997B (en) | Data version management method, device and storage medium | |
| EP3754945A1 (en) | Method for the generation of personalized profile packages in integrated circuit cards, corresponding system and computer program product | |
| US10606569B2 (en) | Declarative configuration elements | |
| CN111324645B (en) | Block chain data processing method and device | |
| CN112306466A (en) | AAR packet generation method, electronic device, and storage medium | |
| US7640260B2 (en) | Valid transformation expressions for structured data | |
| CN104915197A (en) | Method for developing AP middleware abiding by WOSA_XFS industry standard | |
| CN113364821B (en) | Function service access method, equipment and storage medium | |
| CN112363987A (en) | File compression method and device, file loading method and device and electronic equipment | |
| CN116235174A (en) | Apparatus and method for performing encryption algorithm | |
| CN113010377A (en) | Method and device for collecting operation logs of operation | |
| WO2006110987A1 (en) | System and method for efficient hosting of wireless applications by encoding application component definitions | |
| CN113742079B (en) | Method for realizing K8S seven-layer load balancing strategy and application | |
| CN109586901A (en) | A kind of key updating method and equipment | |
| KR102545640B1 (en) | Software development system and method of railway vehicle system | |
| CN113312026A (en) | App development method and system | |
| WO2023159900A1 (en) | Remote development method and device |
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 | ||
| WD01 | Invention patent application deemed withdrawn after publication |
Application publication date: 20210202 |
|
| WD01 | Invention patent application deemed withdrawn after publication |