CN111459892B - Noninvasive aar merging method based on android system - Google Patents
Noninvasive aar merging method based on android system Download PDFInfo
- Publication number
- CN111459892B CN111459892B CN202010243008.6A CN202010243008A CN111459892B CN 111459892 B CN111459892 B CN 111459892B CN 202010243008 A CN202010243008 A CN 202010243008A CN 111459892 B CN111459892 B CN 111459892B
- Authority
- CN
- China
- Prior art keywords
- merging
- aar
- file
- files
- read
- 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 45
- 230000006835 compression Effects 0.000 claims abstract description 20
- 238000007906 compression Methods 0.000 claims abstract description 20
- 230000008569 process Effects 0.000 claims abstract description 12
- 230000006870 function Effects 0.000 claims abstract description 11
- 238000010276 construction Methods 0.000 claims abstract description 9
- 230000010354 integration Effects 0.000 claims abstract description 9
- 101150067361 Aars1 gene Proteins 0.000 claims description 10
- 235000010627 Phaseolus vulgaris Nutrition 0.000 claims description 6
- 244000046052 Phaseolus vulgaris Species 0.000 claims description 6
- 230000006837 decompression Effects 0.000 claims description 3
- 238000004806 packaging method and process Methods 0.000 claims description 3
- 230000002159 abnormal effect Effects 0.000 claims description 2
- 230000000007 visual effect Effects 0.000 abstract description 3
- 238000011161 development Methods 0.000 description 4
- 230000006978 adaptation Effects 0.000 description 3
- 230000000694 effects Effects 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 238000012986 modification Methods 0.000 description 3
- 230000004048 modification Effects 0.000 description 3
- 230000007547 defect Effects 0.000 description 2
- 238000012217 deletion Methods 0.000 description 2
- 230000037430 deletion Effects 0.000 description 2
- 239000000543 intermediate Substances 0.000 description 2
- 230000009545 invasion Effects 0.000 description 2
- 238000011835 investigation Methods 0.000 description 2
- 238000012856 packing Methods 0.000 description 2
- 238000007792 addition Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 238000012858 packaging process Methods 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
Classifications
-
- 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
- G06F16/164—File meta data generation
-
- 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/11—File system administration, e.g. details of archiving or snapshots
- G06F16/113—Details of archiving
-
- 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/17—Details of further file system functions
- G06F16/174—Redundancy elimination performed by the file system
- G06F16/1744—Redundancy elimination performed by the file system using compression, e.g. sparse files
Abstract
The invention provides a non-invasive aar merging method based on an android system, which relates to the technical field of the android system, and the method merges a plurality of aar compression packets into 1 aar compression packet, and the merging process does not invade the whole construction and task sequence of the system, and the functions of all aar compression packets can be integrated only by integrating the merged aar compression packets during integration; because the method is not invasive, no dependence is generated on system tasks; by adopting a file merging method, gradle compatibility of each version is very good; the merging mode is that all aar needing to be merged are put into a designated directory, and the built command is executed to obtain the merged aar, so that the feeling of people is more visual. The technical scheme provided by the invention is suitable for aar merging processes.
Description
[ Field of technology ]
The invention relates to the technical field of android systems, in particular to a noninvasive aar merging method based on an android system.
[ Background Art ]
In the development process of Android, a module may be written for a certain function alone, and other projects want to use the function of the module, and the aar compressed files of the module are integrated. However, for decoupling, many modules are usually generated during development, so that aar packets are many, and steps and workload of other people become complicated and complicated due to the increase of aar packets during integration, so that the error rate is increased, and the development efficiency is affected.
During integration, the scheme in the prior art utilizes system tasks, is very invasive, certain file storage paths can be changed along with the continuous updating of gradle plug-ins, the execution sequence of the system tasks can be adjusted, certain system tasks can be changed and even deleted, the existing codes cannot be operated, the existing codes can be continuously used only through continuous adaptation, and the scheme cannot be continuously used normally once a certain task system is not exposed to a developer due to the strong dependency on the system tasks. Therefore, the integration method has the defects of strong dependence on system tasks, strong adaptability to different versions because initiative is not in the hands of the user, almost adaptation to all versions, and reading of a large amount of official documents and source codes to continuously maintain the project.
Therefore, there is a need to develop a non-invasive aar merging method based on the android system, which merges a plurality of (unlimited) aar compression packs into 1 aar compression pack, so as to solve or alleviate one or more of the above-mentioned problems.
[ Invention ]
In view of this, the invention provides a non-invasive aar merging method based on android system, which can merge a plurality of aar compression packets into 1 aar compression packet, and the merging process does not invade the whole construction of the system, and can integrate the functions of all aar compression packets only by integrating the merged aar compression packets during integration.
On the one hand, the invention provides a non-invasive aar merging method based on an android system, which is characterized in that the method merges a plurality of aar compression packets into 1 aar compression packet, the merging process does not invade the whole construction and task sequence of the system, and the functions of all aar compression packets can be integrated only by integrating the aar compression packets after merging during integration.
Aspects and any one of the possible implementations as described above, further provide an implementation, the specific steps of the method include:
s1, creating an empty module m under an Android project, wherein m is any name;
s2, creating an empty folder under the module m, and naming the empty folder as aars;
S3, placing all aar files to be combined into a aars folder;
s4, checking aars all aar files under the folder;
S5, sequentially decompressing aars all aar files under the folder;
S6, respectively merging the class. Jar, the manifest file, the third party jar package, the asset file, the dynamic library, the confusion file and the resource file; the class, the manifest file, the third-party jar package, the asset file, the dynamic library, the confusion file and the resource file can be combined simultaneously when being combined, and can be combined according to any sequence;
s7, executing the build command by the system, and generating a combined aar file, wherein the file path is under the m/merge_ aar path.
In the aspect and any possible implementation manner described above, further providing an implementation manner, when the class. Jar is merged in S6, decompressing all classes. Jar to be merged and then placing under the catalog m/build/INTERMEDIATES/javac/debug (release)/compileDebugJavaWithJavac/classes; the merging principle of class. Jar is that repetition is not allowed, a file with a heavy name is encountered, and an exception prompt is thrown.
The aspects and any possible implementation manner as described above further provide an implementation manner, where the merging of the manifest files in S6 is implemented by using a tool class InvokeManifestMerger of system merge, and the function doFullTaskAction () for executing the merge task in the tool class is called and executed by reflection;
the merging principle of the manifest file is de-duplication merging, and if the attribute of the duplicate name is encountered, the attribute of the main project is preferentially used.
In the aspect and any possible implementation manner described above, there is further provided an implementation manner, when merging the third party jar packets in S6, copying all jar packets to be merged aar to the m/libs path without decompression;
the third party jar package merging principle is overlay merging, and for a file with a double name, the later read file overlays the first read file.
In the aspect and any possible implementation manner as described above, further providing an implementation manner, when the asset files are combined in S6, copying all subfiles in assets folders in all to-be-combined aar under the m/src/main/assets path;
The principle of asset file merging is overlay merging, and for a rename file, an earlier read file is overlaid by a later read file.
In the aspect and any possible implementation manner described above, further providing an implementation manner, when the dynamic libraries are merged in S6, copying all subfiles under the jni directory in all to-be-merged aar to under the m/src/main/jniLibs path;
The dynamic library merging principle is overlay merging, and for a file with a double name, the later read file overlays the earlier read file.
In the aspect and any possible implementation manner described above, further providing an implementation manner, when merging the confusion files in S6, reading the content in the proguard. Txt files in aar to be merged, sequentially writing the content in the m/proguard-files, modifying the consumerProguardFiles configuration information of the build. Gradle, and typing the confusion files into a new aar package;
the merging principle of the confusing file is not to de-duplicate and merge.
In the aspect and any possible implementation manner described above, further providing an implementation manner, when merging the resource files in S6, adopting a merging principle of overlay merging for layout, drawable, mipmap and xml files in the resource files, and overlaying the read file with the read file; for the value files in the resource files, adopting a merging principle of de-duplication merging, and for the tags with the duplicate names, only recording the first read;
the reading mode of the values file is as follows: analyzing all values.xml files to be combined aar, packaging the tags into beans, and adding the beans into a tag object set; before adding, judging whether the tag is added, if so, ignoring the tag; after all the labels are analyzed, traversing the label object set, and writing the labels in the label object set into m/src/main/res/values.
Aspects and any of the possible implementations described above, further provide an implementation in groovy language and implementing the merging of aar in plug-in form.
In another aspect, the present invention provides a storage medium storing a program, wherein the program, when executed, causes an associated apparatus to perform the steps of the method as described in any one of the preceding claims.
Compared with the prior art, the invention can obtain the following technical effects: the merging aar process has no invasion to the whole construction process of the system, does not need to care about the construction process of the system task, and does not depend on the system task; because the method of file merging is adopted, gradle compatibility of each version is very good; the merging mode is that all aar needing to be merged are put into a designated directory, and the built command is executed to obtain the merged aar, so that the feeling of people is more visual.
Of course, it is not necessary for any of the products embodying the invention to achieve all of the technical effects described above at the same time.
[ Description of the drawings ]
In order to more clearly illustrate the technical solutions of the embodiments of the present invention, the drawings that are needed in the embodiments will be briefly described below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and that other drawings can be obtained according to these drawings without inventive effort for a person skilled in the art.
Fig. 1 is a flowchart of a non-invasive aar merging method based on the android system according to an embodiment of the present invention.
[ Detailed description ] of the invention
For a better understanding of the technical solution of the present invention, the following detailed description of the embodiments of the present invention refers to the accompanying drawings.
It should be understood that the described embodiments are merely some, but not all, embodiments of the 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.
The terminology used in the embodiments of the invention is for the purpose of describing particular embodiments only and is not intended to be limiting of the invention. As used in this application and the appended claims, the singular forms "a," "an," and "the" are intended to include the plural forms as well, unless the context clearly indicates otherwise.
Aiming at the defects of the prior art, a plurality of (unlimited) aar compression packets are combined into 1 aar compression packet, and all aar functions can be integrated only by integrating aar after the combination during integration, so that the problems of complex integration work and easy error in the prior art are solved.
The aar file is essentially a compressed file that contains asset files, resource files, manifest files, dynamic libraries, third party jar packages, obfuscation files, classes jar packages of Java, etc. The essence of the invention is that each aar is decompressed, all the decompressed files are combined, and finally packaged into a new aar package. The asset file, the resource file, the manifest file, the dynamic library and the third-party jar package adopt an overlaid merging strategy, the confusion file adopts a merging strategy without duplication, the manifest file and the resource file adopt a merging strategy without duplication, the resource name of the duplicate name is printed in a log form, the classes jar package of Java does not allow duplication, and if the duplicate is found, error reporting prompt is carried out.
Aar combining: steps 1-3 need to be realized manually, and all the steps from step 4 are processed by the plug-in unit;
1. creating an empty module (namely a module) under the Android project, wherein the name of the module can be arbitrary;
2. Creating an empty folder under the empty module, named aars;
3. Placing all aar files to be combined into the aars folder;
4. checking all aar files under the module/aars folder;
5. sequentially decompressing aar compressed packets;
6. Merging class; the class file is a class file set generated after javac is compiled, and can be decompressed and placed under the catalog module/build/INTERMEDIATES/javac/debug (release)/compileDebugJavaWithJavac/classes, and all class information is contained when a new aar is packed; the merging principle of class. Jar is that repetition is not allowed, a file with a complete rename is encountered, and an abnormal prompt is thrown;
7. Merging the manifest files; invokeManifestMerger is utilized, which is a tool class for system merge, and all android management.xml needing to be merged is input, but the function doFullTaskAction () for executing the merge task is not public and needs to be executed by reflection; the merging principle of the list file is de-duplication merging, and if the attribute of the duplicate name is encountered, the attribute of the main project is preferentially used;
8. Combining the third party jar package, namely copying the jar package (if any) in aar to the mode/libs path, directly copying without decompression, and packaging the new aar to contain all information in the third party jar package; the third party jar package merging principle is coverage merging, and for a file with a double name, a file read later will cover a file read first;
9. Merging asset files, which is to copy all subfiles in assets folder (if any) in aar under the module/src/main/assets path; when packing the new aar, all asset files will be contained; the asset file merging principle is overlay merging, and for a rename file, an earlier read file is overlaid by a later read file;
10. Merging the dynamic libraries, namely copying all subfiles (if any) under the jni directory in aar to the mudule/src/main/jniLibs path, and packing all information of the dynamic libraries when new aar is packed; the dynamic library merging principle is overlay merging, and the files read first are overlaid when the files with the same names are read later;
11. Merging the confusion files; reading the content of a program. Txt file (if any) in aar, sequentially writing the content into a module/proguard-rule. Pro file, modifying consumerProguardFiles configuration information of the build. Gradle, and entering the confusion file into a new aar package; the merging principle of the confusion file is that the merging is not carried out, and as all aar are level and have no primary and secondary parts, the problem of repeated confusion rule is transmitted to the system task for processing, and the outside is not required to be concerned;
12. Merging the resource files; the resource files are divided into several types, namely layout, drawable, mipmap, xml and values; the merging principle adopted by the layout, drawable, mipmap and xml is that the files read later are overlapped and merged, and the files read earlier are overlapped; for values, the merging principle is de-duplication merging, and for full-renamed labels, the merging principle is recording once, if the labels and attributes which are the same are read many times, only recording the first read; the specific reading mode is to analyze all aar values.xml files, package the labels into beans, add the beans into a collection, judge whether the labels are added before adding, if so, ignore the labels, and prevent the occurrence of the rename labels and the system error by using the labels added for the first time. When all labels are analyzed, traversing the label object set, writing the label object set into the module/src/main/res/values/xml files one by one, and not needing to distinguish xml files of different types such as string, color, style and the like, and creating strings, color, xml and the like in daily development so as to distinguish resource types, thereby facilitating the addition, deletion and investigation, but since the label object set is driven into a new aar, no links of adding, deletion and investigation are added, the file types are not required to be distinguished, and the same file can be written in all;
13. The steps are the core links of merging aar files, when the steps are processed, the Mac system executes the build command/gradlew module, the Windows system executes the build command gradlew module, and the merged aar files can be generated, and the file path is under the mode/merge_ aar path.
In the above steps, the order of 6 to 12 is not fixed and can be performed simultaneously. And, all modules above are the names of empty modules.
According to the scheme provided by the invention, the given plurality aar of compressed packages are decompressed respectively, the files are combined one by one, the new aar is generated by utilizing the original packaging process of the system, the system task is not transformed, and the compatibility problem caused by updating the system plug-in is avoided. And the method does not relate to open source codes, and solves the problem of resource conflict among a plurality of aar compressed packets. The resource conflict problem arises from resource files with duplicate names in multiple modules. The solution is as follows: the reference module is used (which module can be configured by a user to be used as the reference module), all repeated resource files refer to the files of the reference module, the names of the repeated resource files are printed out in the combined log, and the user can modify the names or ignore the names according to the log.
The groovy language is the best implementation mode at present, the language is simple, the Java is seamlessly compatible, the function of combining aar is realized in a plug-in mode, and no improvement is made to the original technology. Project fat-aar of aar is merged on github, and the implementation scheme is that the construction task of an android system and the characteristics of groovy language are utilized, and a custom task is added before or after a specific system task to respectively merge files such as an asset file, a resource file, a manifest file, a dynamic library, a third party jar package, a confusion file, a Java classes jar package and the like. However, the fat-aar item modifies the sequence of system tasks, inserts some custom tasks into the system tasks, and even the system tasks themselves, so that once the Android compiling plug-in is upgraded, the item code is likely to need to follow the adaptation, which is very troublesome. The method does not modify the sequence and codes of any system task, has no influence on the original task, does not influence the project no matter how the Android compiling plug-in is upgraded, can be directly used, and is a non-invasive merging scheme.
Advantages of the present invention over the prior art include:
1. the merging aar process has no invasion to the whole construction process of the system, does not need to care about the construction process of the system task, and does not depend on the system task;
2. because the method of file merging is adopted, gradle compatibility of each version is very good;
3. the merging mode is that all aar needing to be merged are put into a designated directory, and the built command is executed to obtain the merged aar, so that the feeling of people is more visual.
The non-invasive aar merging method based on the android system provided by the embodiment of the application is described in detail. The above description of embodiments is only for aiding in the understanding of the method of the present application and its core ideas; meanwhile, as those skilled in the art will have variations in the specific embodiments and application scope in accordance with the ideas of the present application, the present description should not be construed as limiting the present application in view of the above.
Certain terms are used throughout the description and claims to refer to particular components. Those of skill in the art will appreciate that a hardware manufacturer may refer to the same component by different names. The description and claims do not take the form of an element differentiated by name, but rather by functionality. As referred to throughout the specification and claims, the terms "comprising," including, "and" includes "are intended to be interpreted as" including/comprising, but not limited to. By "substantially" is meant that within an acceptable error range, a person skilled in the art is able to solve the technical problem within a certain error range, substantially achieving the technical effect. The description hereinafter sets forth a preferred embodiment for practicing the application, but is not intended to limit the scope of the application, as the description is given for the purpose of illustrating the general principles of the application. The scope of the application is defined by the appended claims.
It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a product or system that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such product or system. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a commodity or system comprising such elements.
It should be understood that the term "and/or" as used herein is merely one relationship describing the association of the associated objects, meaning that there may be three relationships, e.g., a and/or B, may represent: a exists alone, A and B exist together, and B exists alone. In addition, the character "/" herein generally indicates that the front and rear associated objects are an "or" relationship.
While the foregoing description illustrates and describes the preferred embodiments of the present application, it is to be understood that the application is not limited to the forms disclosed herein, but is not to be construed as limited to other embodiments, and is capable of numerous other combinations, modifications and environments and is capable of changes or modifications within the scope of the inventive concept as expressed herein, either as a result of the foregoing teachings or as a result of the knowledge or technology of the relevant art. And that modifications and variations which do not depart from the spirit and scope of the application are intended to be within the scope of the appended claims.
Claims (9)
1. The non-invasive aar merging method based on the android system is characterized in that the method merges a plurality of aar compression packages into 1 aar compression package, the merging process does not invade the whole construction and task sequence of the system, and the functions of all aar compression packages can be integrated only by integrating the aar compression packages after merging during integration;
The method comprises the following specific steps:
s1, creating an empty module m under an Android project, wherein m is any name;
s2, creating an empty folder under the module m, and naming the empty folder as aars;
S3, placing all aar files to be combined into a aars folder;
S4, sequentially decompressing aars all aar files under the folder;
s5, respectively merging the class. Jar, the manifest file, the third party jar package, the asset file, the dynamic library, the confusion file and the resource file; the class, the manifest file, the third-party jar package, the asset file, the dynamic library, the confusion file and the resource file can be combined simultaneously when being combined, and can be combined according to any sequence;
The merging principle of class. Jar is that repetition is not allowed, a file with a complete rename is encountered, and an abnormal prompt is thrown; the merging principle of the list files is de-duplication merging, and if the attribute of the duplicate name is encountered, the attribute of the main project is preferentially used; the third party jar package merging principle is coverage merging, and for a file with a duplicate name, a file read later will cover a file read first; the asset file merging principle is overlay merging, and for a rename file, an earlier read file is overlaid by a later read file; the dynamic library merging principle is coverage merging, and for files which are read after the file with the duplicate name and are read first by coverage; the merging principle of the confusion file is that merging is not repeated; adopting a merging principle of overlay merging for layout, drawable, mipmap and xml files in the resource files, and overlaying the read files with the read files; for the value files in the resource files, adopting a merging principle of de-duplication merging, and for the tags with the duplicate names, only recording the first read;
S6, executing/gradlew module by the system, namely generating a combined aar file by using a build command, wherein the file path is under the m/merge_ aar path;
The merging method does not modify the sequence and codes of any system task, has no influence on the original task, does not influence the project no matter how the Android compiling plug-in is upgraded, can be directly used, and is a non-invasive merging scheme.
2. The method for non-invasive aar merging based on android system as claimed in claim 1, wherein when merging class. Jar in step S5, all classes to be merged are decompressed and then put into the corresponding directory of class. Jar files under module m.
3. The android system-based non-invasive aar merging method according to claim 1, wherein the merging of the manifest files in step S5 is implemented by using a tool class InvokeManifestMerger of system merging tasks, and the function doFullTaskAction () for executing the merging task in the tool class is called by reflection.
4. The android system-based non-invasive aar merging method according to claim 1, wherein when merging the third party jar packets in step S5, all jar packets to be merged aar are copied under the m/libs path without decompression.
5. The android system-based non-invasive aar merging method according to claim 1, wherein when merging the asset files in step S5, all subfiles in the assets folder in all to-be-merged aar are copied under the corresponding paths of the asset files in module m.
6. The android system-based non-invasive aar merging method according to claim 1, wherein when merging the dynamic libraries in step S5, all subfiles under the jni directory in all to-be-merged aar are copied under the m/src/main/jniLibs path.
7. The method according to claim 1, wherein when merging the confusion files in step S5, the content in the proguard. Txt files in aar to be merged is read, and written into the m/proguard-rule. Pro file in turn, and the consumerProguardFiles configuration information of the build. Gradle is modified, and the confusion files are entered into a new aar package.
8. The android system-based non-invasive aar merging method of claim 1, wherein the reading mode of the values file is as follows: analyzing all values.xml files to be combined aar, packaging the tags into beans, and adding the beans into a tag object set; before adding, judging whether the tag is added, if so, ignoring the tag; and after all the labels are analyzed, traversing the label object set, and writing the labels in the label object set into the values.xml file of the module m one by one.
9. A storage medium storing a program which, when executed, causes an associated device to perform the steps of the method of any one of claims 1-8.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010243008.6A CN111459892B (en) | 2020-03-31 | 2020-03-31 | Noninvasive aar merging method based on android system |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010243008.6A CN111459892B (en) | 2020-03-31 | 2020-03-31 | Noninvasive aar merging method based on android system |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN111459892A CN111459892A (en) | 2020-07-28 |
| CN111459892B true CN111459892B (en) | 2024-05-07 |
Family
ID=71685125
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010243008.6A Active CN111459892B (en) | 2020-03-31 | 2020-03-31 | Noninvasive aar merging method based on android system |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN111459892B (en) |
Families Citing this family (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN112306466A (en) * | 2020-10-30 | 2021-02-02 | 中移（杭州）信息技术有限公司 | AAR packet generation method, electronic device, and storage medium |
| CN112416372A (en) * | 2020-11-16 | 2021-02-26 | 五八同城信息技术有限公司 | AAR modification construction method and device, electronic equipment and storage medium |
| CN112540788A (en) * | 2020-12-03 | 2021-03-23 | 南方电网数字电网研究院有限公司 | Method compatible with multi-manufacturer unmanned aerial vehicle flight control application apps |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2017151546A1 (en) * | 2016-03-01 | 2017-09-08 | 650 Industries, Inc. | Method and apparatus for loading multiple differing versions of a native library into a native environment |
| CN109542445A (en) * | 2017-08-01 | 2019-03-29 | 北京京东尚科信息技术有限公司 | A kind of method and apparatus that Android plug-in unit melts hair |
| CN110321131A (en) * | 2019-07-05 | 2019-10-11 | 北京百佑科技有限公司 | Service Component packaging method, system and server |
| CN110457045A (en) * | 2019-08-16 | 2019-11-15 | 百度在线网络技术（北京）有限公司 | Modularization merges Compilation Method, device, equipment and storage medium |
| CN110502222A (en) * | 2019-07-23 | 2019-11-26 | 北京字节跳动网络技术有限公司 | AAR method, apparatus, medium and the equipment in outgoing dependence inner base library |
-
2020
- 2020-03-31 CN CN202010243008.6A patent/CN111459892B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| WO2017151546A1 (en) * | 2016-03-01 | 2017-09-08 | 650 Industries, Inc. | Method and apparatus for loading multiple differing versions of a native library into a native environment |
| CN109542445A (en) * | 2017-08-01 | 2019-03-29 | 北京京东尚科信息技术有限公司 | A kind of method and apparatus that Android plug-in unit melts hair |
| CN110321131A (en) * | 2019-07-05 | 2019-10-11 | 北京百佑科技有限公司 | Service Component packaging method, system and server |
| CN110502222A (en) * | 2019-07-23 | 2019-11-26 | 北京字节跳动网络技术有限公司 | AAR method, apparatus, medium and the equipment in outgoing dependence inner base library |
| CN110457045A (en) * | 2019-08-16 | 2019-11-15 | 百度在线网络技术（北京）有限公司 | Modularization merges Compilation Method, device, equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN111459892A (en) | 2020-07-28 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN111459892B (en) | Noninvasive aar merging method based on android system | |
| US5617533A (en) | System and method for determining whether a software package conforms to packaging rules and requirements | |
| US6941546B2 (en) | Method and apparatus for testing a software component using an abstraction matrix | |
| US7694284B2 (en) | Shareable, bidirectional mechanism for conversion between object model and XML | |
| CN105723341B (en) | Realization method and system for layout engine and the memory model of script engine | |
| EP1628228A2 (en) | User-Specified Spreadsheet Functions | |
| US7584462B2 (en) | System for optimizing application start-up | |
| US20110161938A1 (en) | Including defect content in source code and producing quality reports from the same | |
| JP4146590B2 (en) | Apparatus, method and recording medium for task-oriented applications | |
| Sellink et al. | Restructuring of COBOL/CICS legacy systems | |
| JP2007323573A (en) | Functional test script generator | |
| US20130055291A1 (en) | Describing native application programming interfaces of an operating system with metadata | |
| AU2005203386A1 (en) | Test automation stack layering | |
| TW201619820A (en) | Projecting native application programming interfaces of an operating system into other programming languages | |
| CN1987783A (en) | System and method for emulating server pages | |
| CN104778033A (en) | Construction method and device of building block type software | |
| US9658845B2 (en) | Generating a where-used objects list for updating data | |
| CN106775824A (en) | A kind of application file packaging system and method with channel information | |
| CN1875343B (en) | System and method for establishing software suite | |
| Moldovan et al. | Openuidl, a user interface description language for runtime omni-channel user interfaces | |
| US8713550B2 (en) | Methods, devices and software applications for facilitating a development of a computer program | |
| JP2008269280A (en) | Software development support system, development support method and program | |
| WO2014074903A1 (en) | Dynamic model-based management tooling | |
| Morris et al. | Validation Testing System: Reusable Software Component Design | |
| CN113656000A (en) | Webpage processing 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 | ||
| GR01 | Patent grant |