CN105094849B - A kind of resource transfer method and apparatus of plug-in unit - Google Patents
A kind of resource transfer method and apparatus of plug-in unit Download PDFInfo
- Publication number
- CN105094849B CN105094849B CN201510526626.0A CN201510526626A CN105094849B CN 105094849 B CN105094849 B CN 105094849B CN 201510526626 A CN201510526626 A CN 201510526626A CN 105094849 B CN105094849 B CN 105094849B
- Authority
- CN
- China
- Prior art keywords
- resource
- plug
- path information
- container
- module
- 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 39
- 238000002347 injection Methods 0.000 claims abstract description 24
- 239000007924 injection Substances 0.000 claims abstract description 24
- 230000007246 mechanism Effects 0.000 claims description 12
- 238000004806 packaging method and process Methods 0.000 claims description 12
- 230000001419 dependent effect Effects 0.000 claims description 10
- 238000011161 development Methods 0.000 abstract description 6
- 206010021703 Indifference Diseases 0.000 abstract 1
- 230000008569 process Effects 0.000 description 10
- 230000006870 function Effects 0.000 description 7
- 230000001960 triggered effect Effects 0.000 description 5
- 239000007943 implant Substances 0.000 description 3
- 238000010586 diagram Methods 0.000 description 2
- 230000006872 improvement Effects 0.000 description 2
- 239000000047 product Substances 0.000 description 2
- 239000000243 solution Substances 0.000 description 2
- 230000003068 static effect Effects 0.000 description 2
- 238000013459 approach Methods 0.000 description 1
- 238000004883 computer application Methods 0.000 description 1
- 239000000470 constituent Substances 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000012423 maintenance Methods 0.000 description 1
- 238000004519 manufacturing process Methods 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 238000012545 processing Methods 0.000 description 1
- 230000008439 repair process Effects 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000013589 supplement Substances 0.000 description 1
Landscapes
- Stored Programmes (AREA)
Abstract
The present invention provides a kind of resource transfer method and apparatus of plug-in unit, when wherein method includes: load plug-in unit, by the resource module of routing information of the routing information injection comprising container resource of plug-in resource；Plug-in unit resource to be referred to is traversed, calls the plug-in unit resource to be referred to from resource object set pointed by the resource module according to resource prefix information.The present invention can be realized in plug-in unit loading procedure to the indifference calling of plug-in resource and container resource, reduce development cost.
Description
[ technical field ] A method for producing a semiconductor device
The invention relates to the technical field of computer application, in particular to a method and a device for calling a plug-in resource.
[ background of the invention ]
With the increase of the number of users of the mobile terminal APP (application software) and the improvement of experience requirements, new functions need to be added to a product or functions need to be repaired continuously, so that the problem of large code amount and the requirement of dynamic release of functions are met in development, and then plug-in is generated, that is, functions of the product are packaged into plug-in release and loaded by a container serving as an application main body. However, the problem that the plug-in involves resource calling in the execution process is that how to conveniently make resource calling is a problem to be solved at present.
In addition to calling the plug-in resources, the container resources may also be called in the plug-in execution process, and if the container resources on which the plug-in depends are copied to the plug-in, the plug-in package size is increased, and higher development cost is brought by determining the dependence on the resources. If interfaces of resources are exposed on the container in advance for plug-in calling, developers need to know which resources called by the plug-in are plug-in and which are container, and development and maintenance costs are high.
[ summary of the invention ]
In view of this, the present invention provides a method and an apparatus for calling a resource of a plug-in, so as to conveniently implement resource calling and reduce development cost.
The specific technical scheme is as follows:
the invention provides a method for calling a plug-in resource, which comprises the following steps:
when the plug-in is loaded, the path information of the plug-in resource is injected into a resource module containing the path information of the container resource;
and traversing the resources referenced by the plug-ins, and calling the resources referenced by the plug-ins from the resource object set pointed by the resource modules according to the resource prefix information.
According to a preferred embodiment of the present invention, the resource module for injecting the path information of the plug-in resource into the path information including the container resource includes:
adding the path information of the plug-in resource to a resource module of the container through a reflection calling mechanism, wherein the resource module comprises the path information of the container resource; or,
and creating a resource module of the plug-in, and adding the path information of the plug-in resource and the path information of the container resource to the resource module of the plug-in through a reflection calling mechanism.
According to a preferred embodiment of the present invention, before injecting the path information of the plug-in resource into the resource module including the path information of the container resource, the method further includes:
and judging whether the path information of the plug-in resource exists in the resource module or not, if not, continuing to execute the resource module which injects the path information of the plug-in resource into the path information containing the container resource.
According to a preferred embodiment of the present invention, before injecting the path information of the plug-in resource into the resource module including the path information of the container resource, the method further includes:
and judging whether the plug-in contains the plug-in resource, if so, continuing to execute the resource module which injects the path information of the plug-in resource into the path information containing the container resource.
According to a preferred embodiment of the invention, the method further comprises:
when the plug-ins are compiled and packaged, resource prefix information in the application configuration file is read, different plug-ins correspond to different resource prefix information, and the plug-ins and the containers correspond to different resource prefix information.
According to a preferred embodiment of the invention, the method further comprises:
and when the plug-in is compiled and packaged, searching the container resource referenced by the plug-in according to the dependent package name in the plug-in source code.
According to a preferred embodiment of the invention, the method further comprises:
compiling and packaging the plug-in to generate a resource index file of the plug-in;
and merging the resource index file of the plug-in and the resource index file of the container.
The invention also provides a device for calling the resources of the plug-in, which comprises:
the resource injection unit is used for injecting the path information of the plug-in resource into a resource module containing the path information of the container resource when the plug-in is loaded;
and the resource calling unit is used for traversing the resources referenced by the plug-in and calling the resources referenced by the plug-in from the resource object set pointed by the resource module according to the resource prefix information.
According to a preferred embodiment of the present invention, when injecting the path information of the plug-in resource into the resource module including the path information of the container resource, the resource injection unit specifically executes:
adding the path information of the plug-in resource to a resource module of the container through a reflection calling mechanism, wherein the resource module comprises the path information of the container resource; or,
and creating a resource module of the plug-in, and adding the path information of the plug-in resource and the path information of the container resource to the resource module of the plug-in through a reflection calling mechanism.
According to a preferred embodiment of the invention, the apparatus further comprises:
a first judging unit, configured to, when the plug-in is loaded, judge whether path information of the plug-in resource already exists in the resource module, and if not, trigger the resource injecting unit to execute the operation of injecting the path information of the plug-in resource into the resource module including the path information of the container resource.
According to a preferred embodiment of the invention, the apparatus further comprises:
and the second judging unit is used for judging whether the plug-in contains the plug-in resource or not when the plug-in is loaded, and if so, triggering the resource injection unit to execute the operation of injecting the path information of the plug-in resource into the resource module containing the path information of the container resource.
According to a preferred embodiment of the invention, the apparatus further comprises:
and the prefix reading unit is used for reading the resource prefix information in the application configuration file when the plug-ins are compiled and packaged, wherein different plug-ins correspond to different resource prefix information, and the plug-ins and the container correspond to different resource prefix information.
According to a preferred embodiment of the invention, the apparatus further comprises:
and the resource searching unit is used for searching the container resource quoted by the plug-in according to the dependent package name in the plug-in source code when the plug-in is compiled and packaged.
According to a preferred embodiment of the invention, the apparatus further comprises:
and the file merging unit is used for merging the resource index file of the plug-in and the resource index file of the container after the plug-in is compiled and packaged to generate the resource index file of the plug-in.
According to the technical scheme, the plug-in resources are injected into the resource module containing the path information of the container resources, so that the resource module uniformly maintains the path information of the plug-in resources and the container resources, and the plug-in resources and the container resources can be indiscriminately called from the resource object set pointed by the resource module according to the resource prefix information in the plug-in loading process. Container resources do not need to be contained in the plug-in package, and developers do not need to know whether the resources quoted by the plug-ins are plug-ins or containers in advance, so that the method is more convenient to realize and reduces the development cost.
[ description of the drawings ]
FIG. 1 is a flow chart of a main method provided by an embodiment of the present invention;
fig. 2 is a structural diagram of an apparatus according to an embodiment of the present invention.
[ detailed description ] embodiments
In order to make the objects, technical solutions and advantages of the present invention more apparent, the present invention will be described in detail with reference to the accompanying drawings and specific embodiments.
The container involved in the embodiment of the invention is actually a main body of the application program and is responsible for accommodating various functions of services provided by the application program, and the container provides plug-in interfaces for outside and can supplement and repair the functions of the application program in a plug-in loading mode.
Fig. 1 is a flow chart of a main method provided by an embodiment of the present invention, and as shown in fig. 1, the method may include the following steps:
in 101, when a plug-in is loaded, path information of the plug-in resource is injected into a resource module containing path information of the container resource.
The resource module is mainly used for maintaining resource path information, and when each plug-in is loaded, the path information of the plug-in resource of the plug-in is injected into the resource module, and the resource module simultaneously contains the path information of the container resource. That is, the path information of the plug-in resource and the path information of the container resource are merged and maintained in the same resource module.
The injected procedure is actually a procedure of adding a resource object interface through a reflection calling mechanism. The method comprises the steps of firstly establishing a resource module aiming at the plug-ins, establishing a uniform resource module aiming at all the plug-ins in the embodiment of the invention, then adding the path information of the plug-in resources of each plug-in to the resource module, and adding the path information of the container resources to the resource module. Thus, the resource module contains the path information of the container resource and the path information of all the plug-in resources of the same application.
Since dynamic addition of resources is supported for some underlying resources of the operating system, such as the operating system after android5.0, but the adding system object interface is still hidden, path information of the plug-in resource can be directly added in the resource module of the container by adopting a reflection calling mechanism without additionally creating the resource module of the plug-in.
Before injecting the path information of the plug-in resource into the resource module, it may be first determined whether the path information of the plug-in resource already exists in the resource module, and if not, the path information of the plug-in resource is injected into the resource module containing the path information of the container resource; if so, no repeat implant is required.
In addition, whether the plug-in contains the plug-in resource can be judged firstly, and if yes, the path information of the plug-in resource is injected into the resource module; otherwise, no implant is needed. Taking an Android operating system as an example, the plug-in forms an apk package after being compiled and packaged, and if the plug-in contains plug-in resources, an arcc file exists in the apk package. For plug-ins in which the apk package does not contain an arcc file, resource injection need not be performed nor can it be performed.
Rewriting getResources interfaces in application, activity and service base classes, so that the getResources interfaces can return to the resource objects after the injection is executed in the resource module.
In 102, traversing the resources referenced by the plug-in, and calling the resources referenced by the plug-in from the resource object set pointed by the resource module according to the resource prefix information. In the embodiment of the invention, because the resource module maintains the plug-in resource and the container resource in a unified manner, the resource object set pointed by the resource module contains both the container resource and the plug-in resource, and when the resource is called in the plug-in execution process, the resource is called uniformly from the resource object set, namely the plug-in resource and the container resource are called indiscriminately, so that the transparent calling of the resource is realized.
In addition, since the resource object set pointed by the resource module includes both the container resource and the plug-in resource, the plug-in resource and the container resource need to be distinguished, and the identifier of the plug-in resource and the identifier of the container resource are ensured to be unique. For the resources of all applications except system resources, such as an Android operating system, the existing mechanism uniformly specifies the resource identifier as 0x7f, so that the container resource and the plug-in resource conflict in the identifier, that is, it cannot be specifically distinguished whether the container resource or the plug-in resource. In view of this situation, in the embodiment of the present invention, in a global application configuration file (such as android manifest. xml) in the plug-in source code, a node at the same level as application is added, for example, a node < package-identity: value ═ 1 > is added, where the node is resource prefix information and is used to identify a resource. Different plug-ins correspond to different resource prefix information, and the plug-ins and the containers correspond to different resource prefix information. Still take the node < package-id: value ═ 1 "> as an example, where the value takes 1, which may represent 0x7d, and when the value takes 2, which may represent 0x7e, and so on, values are taken backwards in sequence to allocate resource prefix information for the resource, and it is no longer mandatory to specify 0x7f as the identifier of other resources except the system resource.
Correspondingly, at the stage of compiling and packaging the plug-in, resource prefix information in the application configuration file is read, and the plug-in is compiled and packaged according to the resource prefix information. Therefore, in the plug-in loading process, when the specific resource quoted by the plug-in needs to be loaded, the corresponding resource can be searched from the resource object set pointed by the resource module according to the resource prefix information, and the resource can be called.
In addition, during the process of compiling and packaging the plug-in, if the plug-in is determined to reference the container resource, the plug-in may not be able to compile through because the resource cannot be found. For this case, in the embodiment of the present invention, the dependent package name may be specified under the resource path in the plug-in source code. For example, in the Android operating system, the plug-in source code defines a resource path in the form of "-I + resource path information", and in the embodiment of the present invention, a parameter "-real-app-package" may be added below the path to specify a dependent package name, where the dependent package is a container resource package referred to by the plug-in. Correspondingly, when the plug-in is compiled and packaged, the container resource quoted by the plug-in is searched according to the dependent package name in the plug-in source code, so that the resource quoted by the plug-in can be found, and the compiling can be carried out smoothly.
It should be noted that, in the process of compiling and packaging the plug-ins, the resource information referred by the plug-ins may be obtained from the layout file of the plug-ins. The resource types referenced by the plug-ins may include, but are not limited to: string class, color class, xml class, etc. The resources referenced by the plug-in can be own plug-in resources, can also be container resources, and can even be other plug-in resources in the same application. For example, in the plug-in layout file, there is an android, text @ string/net _ error ", where the referenced resource net _ error, if defined in a container, references the container resource.
When compiling and packaging the plug-in, in addition to compiling the static resource, compiling the java code to generate a resource index file (namely, an R-type file) is also carried out. After the plug-in resources are compiled and packaged, a plug-in R type file is generated, wherein the plug-in R type file only contains the plug-in resources, and if the java codes of the plug-ins refer to the resources of the container, the plug-ins cannot be compiled to pass. For the situation, in the embodiment of the present invention, after the plug-in resource is compiled to generate the plug-in R class file, the plug-in R class file and the container R class file are merged, so that the plug-in R class file includes the plug-in resource and the index of the container resource referred by the plug-in, thereby ensuring that the java code of the plug-in can be compiled correctly.
The above is a detailed description of the method provided by the present invention, and the following is a detailed description of the apparatus provided by the present invention.
Fig. 2 is a structural diagram of an apparatus according to an embodiment of the present invention, and as shown in fig. 2, the apparatus may include: the resource injection unit 01 and the resource calling unit 02 may further include a first judging unit 03, a second judging unit 04, a prefix reading unit 05, a resource searching unit 06, and a file merging unit 07. The main functions of each constituent unit are as follows:
when the plug-in is loaded, the resource injection unit 01 is responsible for injecting the path information of the plug-in resource into the resource module containing the path information of the container resource.
The resource module is mainly used for maintaining resource path information, and when each plug-in is loaded, the path information of the plug-in resource of the plug-in is injected into the resource module, and the resource module simultaneously contains the path information of the container resource. That is, the path information of the plug-in resource and the path information of the container resource are merged and maintained in the same resource module.
Specifically, the resource injection unit 01 may perform resource injection in, but is not limited to, the following two ways:
the first mode is as follows: and adding the path information of the plug-in resource to a resource module of the container through a reflection calling mechanism, wherein the resource module contains the path information of the container resource. This approach is applicable to cases where the bottom layer of the operating system supports dynamic addition of resources, such as the operating system after android 5.0.
The second mode is as follows: and creating a resource module of the plug-in, and adding the path information of the plug-in resource and the path information of the container resource to the resource module of the plug-in through a reflection calling mechanism. This applies to the case where the underlying layers of the operating system do not support dynamic addition of resources, such as the operating system prior to android 5.0. The resource modules created in this paradigm may be resource modules that are uniform for all plug-ins, i.e., all plug-ins share one resource module.
Further, before the resource injection unit 01 injects the path information of the plug-in resource into the resource module, the first judgment unit 03 may judge whether the path information of the plug-in resource already exists in the resource module, and if not, the resource injection unit 01 is triggered to perform an operation of injecting the path information of the plug-in resource into the resource module including the path information of the container resource; if so, no repeat implant is required.
Further, before the resource injection unit 01 injects the path information of the plug-in resource into the resource module, the second determination unit 04 may determine whether the plug-in includes the plug-in resource, and if so, the resource injection unit 01 is triggered to perform an operation of injecting the path information of the plug-in resource into the resource module including the path information of the container resource; otherwise the process of the resource injection unit 01 to perform the injection may not be triggered or prohibited.
The first judging means 03 and the second judging means 04 may be present alternatively or simultaneously. When the judgment operations are performed simultaneously, the judgment operations may be performed simultaneously, or the judgment operations may be performed sequentially. When the determination operations are performed simultaneously, the resource injection unit 01 is triggered to perform resource injection only when the determination results of the first determining unit 03 and the second determining unit 04 both satisfy the condition for triggering the resource injection unit 04. When the determination operation is performed sequentially, as an example in fig. 2, the first determining unit 03 and the second determining unit 04 perform the determination operation sequentially, and when the determination result of the first determining unit 03 is no, the second determining unit 04 performs the determination, and when the determination result of the second determining unit 04 is yes, the resource injecting unit 01 is triggered to perform the resource injection.
The resource calling unit 02 is responsible for traversing the resources referenced by the plug-in, and calling the resources referenced by the plug-in from the resource object set pointed by the resource module according to the resource prefix information.
In addition, since the resource object set pointed by the resource module includes both the container resource and the plug-in resource, the plug-in resource and the container resource need to be distinguished, and the identifier of the plug-in resource and the identifier of the container resource are ensured to be unique. For the resources of all applications except system resources, such as an Android operating system, the existing mechanism uniformly specifies the resource identifier as 0x7f, so that the container resource and the plug-in resource conflict in the identifier, that is, it cannot be specifically distinguished whether the container resource or the plug-in resource. In the embodiment of the present invention, a node at the same level as application is added to a global application configuration file (such as android manifest. xml) in a plug-in source code, for example, a node < package-identity: value ═ 1 > is added, where the node is resource prefix information and is used to identify a resource. Different plug-ins correspond to different resource prefix information, and the plug-ins and the containers correspond to different resource prefix information. Correspondingly, when compiling and packaging plug-ins, the prefix reading unit 05 in the embodiment of the present invention reads resource prefix information in an application configuration file (such as android manifest. xml), where different plug-ins correspond to different resource prefix information, and the plug-ins and the containers correspond to different resource prefix information. And compiling and packaging the plug-in according to the resource prefix information. Therefore, in the plug-in loading process, when the specific resource quoted by the plug-in needs to be loaded, the corresponding resource can be searched from the resource object set pointed by the resource module according to the resource prefix information, and the resource can be called.
In addition, during the process of compiling and packaging the plug-in, if the plug-in is determined to reference the container resource, the plug-in may not be able to compile through because the resource cannot be found. For this case, in the embodiment of the present invention, the dependent package name may be specified under the resource path in the plug-in source code. Correspondingly, when the plug-in is compiled and packaged, the resource searching unit 06 is responsible for searching the container resource referred by the plug-in according to the dependent package name in the plug-in source code, so that the resource referred by the plug-in can be found, and the compiling can be smoothly performed.
When compiling and packaging the plug-in, in addition to compiling the static resource, compiling the java code to generate a resource index file (namely, an R-type file) is also carried out. After the plug-in resources are compiled and packaged, a plug-in R type file is generated, wherein the plug-in R type file only contains the plug-in resources, and if the java codes of the plug-ins refer to the resources of the container, the plug-ins cannot be compiled to pass. For such a situation, in the embodiment of the present invention, the file merging unit 07 is responsible for merging the resource index file of the plug-in with the resource index file of the container after compiling and packaging the plug-in to generate the resource index file of the plug-in. Therefore, the resource index file of the plug-in contains the plug-in resource and the index of the container resource referenced by the plug-in, thereby ensuring that the java code of the plug-in can be compiled correctly.
The resource injection unit 01, the resource calling unit 02, the first judging unit 03 and the second judging unit 04 in the device can be arranged in a unit for loading the plug-in, and the prefix reading unit 05, the resource searching unit 06 and the file merging unit 07 can be arranged in a unit for compiling and packaging the plug-in.
In the embodiments provided in the present invention, it should be understood that the disclosed apparatus and method may be implemented in other ways. For example, the above-described device embodiments are merely illustrative, and for example, the division of the units is only one logical functional division, and other divisions may be realized in practice.
The units described as separate parts may or may not be physically separate, and parts displayed as units may or may not be physical units, may be located in one place, or may be distributed on a plurality of network units. Some or all of the units can be selected according to actual needs to achieve the purpose of the solution of the embodiment.
In addition, functional units in the embodiments of the present invention may be integrated into one processing unit, or each unit may exist alone physically, or two or more units are integrated into one unit. The integrated unit can be realized in a form of hardware, or in a form of hardware plus a software functional unit.
The integrated unit implemented in the form of a software functional unit may be stored in a computer readable storage medium. The software functional unit is stored in a storage medium and includes several instructions to enable a computer device (which may be a personal computer, a server, or a network device) or a processor (processor) to execute some steps of the methods according to the embodiments of the present invention. And the aforementioned storage medium includes: various media capable of storing program codes, such as a usb disk, a removable hard disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), a magnetic disk, or an optical disk.
The above description is only for the purpose of illustrating the preferred embodiments of the present invention and is not to be construed as limiting the invention, and any modifications, equivalents, improvements and the like made within the spirit and principle of the present invention should be included in the scope of the present invention.
Claims (12)
1. A method for calling a resource of a plug-in is characterized by comprising the following steps:
when the plug-in is loaded, the path information of the plug-in resource is injected into a resource module containing the path information of the container resource;
traversing the resources referenced by the plug-in, calling the resources referenced by the plug-in from the resource object set pointed by the resource module according to the resource prefix information,
wherein the resource module for injecting the path information of the plug-in resource into the path information containing the container resource comprises:
and creating a resource module of the plug-in, and adding the path information of the plug-in resource and the path information of the container resource to the resource module of the plug-in through a reflection calling mechanism.
2. The method of claim 1, further comprising, prior to the injecting path information for the plug-in resource into the resource module containing path information for the container resource:
and judging whether the path information of the plug-in resource exists in the resource module or not, if not, continuing to execute the resource module which injects the path information of the plug-in resource into the path information containing the container resource.
3. The method of claim 1, further comprising, prior to the injecting path information for the plug-in resource into the resource module containing path information for the container resource:
and judging whether the plug-in contains the plug-in resource, if so, continuing to execute the resource module which injects the path information of the plug-in resource into the path information containing the container resource.
4. The method of claim 1, further comprising:
when the plug-ins are compiled and packaged, resource prefix information in the application configuration file is read, different plug-ins correspond to different resource prefix information, and the plug-ins and the containers correspond to different resource prefix information.
5. The method of claim 1, further comprising:
and when the plug-in is compiled and packaged, searching the container resource referenced by the plug-in according to the dependent package name in the plug-in source code.
6. The method of claim 1, further comprising:
compiling and packaging the plug-in to generate a resource index file of the plug-in;
and merging the resource index file of the plug-in and the resource index file of the container.
7. A plug-in resource invocation apparatus, comprising:
the resource injection unit is used for injecting the path information of the plug-in resource into a resource module containing the path information of the container resource when the plug-in is loaded;
a resource calling unit, configured to traverse the resource referenced by the plug-in, and call the resource referenced by the plug-in from the resource object set pointed by the resource module according to the resource prefix information,
wherein, the resource injection unit, when injecting the path information of the plug-in resource into the resource module containing the path information of the container resource, specifically executes:
and creating a resource module of the plug-in, and adding the path information of the plug-in resource and the path information of the container resource to the resource module of the plug-in through a reflection calling mechanism.
8. The apparatus of claim 7, further comprising:
a first judging unit, configured to, when the plug-in is loaded, judge whether path information of the plug-in resource already exists in the resource module, and if not, trigger the resource injecting unit to execute the operation of injecting the path information of the plug-in resource into the resource module including the path information of the container resource.
9. The apparatus of claim 7, further comprising:
and the second judging unit is used for judging whether the plug-in contains the plug-in resource or not when the plug-in is loaded, and if so, triggering the resource injection unit to execute the operation of injecting the path information of the plug-in resource into the resource module containing the path information of the container resource.
10. The apparatus of claim 7, further comprising:
and the prefix reading unit is used for reading the resource prefix information in the application configuration file when the plug-ins are compiled and packaged, wherein different plug-ins correspond to different resource prefix information, and the plug-ins and the container correspond to different resource prefix information.
11. The apparatus of claim 7, further comprising:
and the resource searching unit is used for searching the container resource quoted by the plug-in according to the dependent package name in the plug-in source code when the plug-in is compiled and packaged.
12. The apparatus of claim 7, further comprising:
and the file merging unit is used for merging the resource index file of the plug-in and the resource index file of the container after the plug-in is compiled and packaged to generate the resource index file of the plug-in.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510526626.0A CN105094849B (en) | 2015-08-25 | 2015-08-25 | A kind of resource transfer method and apparatus of plug-in unit |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201510526626.0A CN105094849B (en) | 2015-08-25 | 2015-08-25 | A kind of resource transfer method and apparatus of plug-in unit |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN105094849A CN105094849A (en) | 2015-11-25 |
| CN105094849B true CN105094849B (en) | 2019-05-28 |
Family
ID=54575377
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201510526626.0A Active CN105094849B (en) | 2015-08-25 | 2015-08-25 | A kind of resource transfer method and apparatus of plug-in unit |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN105094849B (en) |
Families Citing this family (4)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN106874394B (en) * | 2017-01-13 | 2020-12-29 | 百度在线网络技术（北京）有限公司 | File packaging preprocessing method and equipment |
| CN107870789B (en) * | 2017-10-18 | 2021-01-26 | 福建天泉教育科技有限公司 | Method and terminal for packaging plug-ins |
| CN111124526B (en) * | 2018-11-01 | 2024-12-27 | 北京奇虎科技有限公司 | Dependency library management method, device, storage medium and computer equipment |
| CN114168294B (en) * | 2021-12-10 | 2024-07-02 | 北京字节跳动网络技术有限公司 | Method and device for distributing compiling resources, electronic equipment and storage medium |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8769622B2 (en) * | 2011-06-30 | 2014-07-01 | International Business Machines Corporation | Authentication and authorization methods for cloud computing security |
| CN104123151A (en) * | 2013-04-28 | 2014-10-29 | 百度在线网络技术（北京）有限公司 | Plug-in management method and device for application program in mobile terminal and mobile terminal |
| CN104536776A (en) * | 2014-11-28 | 2015-04-22 | 百度在线网络技术（北京）有限公司 | Method and device for running plug-in application in plug-in running environment at host end |
-
2015
- 2015-08-25 CN CN201510526626.0A patent/CN105094849B/en active Active
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US8769622B2 (en) * | 2011-06-30 | 2014-07-01 | International Business Machines Corporation | Authentication and authorization methods for cloud computing security |
| CN104123151A (en) * | 2013-04-28 | 2014-10-29 | 百度在线网络技术（北京）有限公司 | Plug-in management method and device for application program in mobile terminal and mobile terminal |
| CN104536776A (en) * | 2014-11-28 | 2015-04-22 | 百度在线网络技术（北京）有限公司 | Method and device for running plug-in application in plug-in running environment at host end |
Non-Patent Citations (1)
| Title |
|---|
| Resource Naming Convention for Android Library Projects;网友;《http://ikramu.com/blog/2013/01/20/resource-naming-convention-for-android-library-projects/》;20130120;第1页 |
Also Published As
| Publication number | Publication date |
|---|---|
| CN105094849A (en) | 2015-11-25 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN112799937B (en) | Method to automatically detect dependency conflicts in Maven projects based on GitHub | |
| US8307350B2 (en) | Multi level virtual function tables | |
| US7954096B2 (en) | Shared loader system and method | |
| CN110389829A (en) | Classification and distribution of extension objects in a multi-tenant environment | |
| US20140173574A1 (en) | Compilation dependency resolution from a diverse group of candidate resources | |
| CN105094849B (en) | A kind of resource transfer method and apparatus of plug-in unit | |
| JP2005293578A (en) | Test case inheritance controlled via attribute | |
| CN111475227A (en) | Service plug-in loading implementation method, device and terminal device | |
| US20150363195A1 (en) | Software package management | |
| CN113407362A (en) | SOMEIP communication intermediate layer implementation method and system based on SOA architecture of vehicle-mounted Android system | |
| CN108595246B (en) | A method, apparatus and device for running an application | |
| CN111736913B (en) | Class loading method and device | |
| CN116243923A (en) | A small program processing method, device and electronic equipment | |
| CN110941443B (en) | Method and device for modifying file name in SDK (software development kit) and electronic equipment | |
| KR20070067207A (en) | Runtime dynamic linking | |
| CN112748905B (en) | Method and device for initializing and calling basic library, electronic equipment and storage medium | |
| CN111984294A (en) | Service system updating method and device based on Groovy dynamic loading technology | |
| CN116679912A (en) | Code generation method, apparatus, device, storage medium, and computer program | |
| CN117435510B (en) | Automatic test method, terminal equipment and computer readable storage medium | |
| CN109933325A (en) | A kind of dex file construction method, apparatus and system | |
| CN112416418A (en) | Application component generation method and device, computer equipment and readable storage medium | |
| US7010454B1 (en) | Test services provider | |
| CN115129298B (en) | A method for injecting service instances and related equipment | |
| CN115904387A (en) | Program module compiling method, computer device and program product | |
| CN108008983B (en) | Multi-interface data processing method based on single process |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| C06 | Publication | ||
| PB01 | Publication | ||
| C10 | Entry into substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |