CN112748916A - Functional module componentization method and device based on custom protocol - Google Patents
Functional module componentization method and device based on custom protocol Download PDFInfo
- Publication number
- CN112748916A CN112748916A CN202110045269.1A CN202110045269A CN112748916A CN 112748916 A CN112748916 A CN 112748916A CN 202110045269 A CN202110045269 A CN 202110045269A CN 112748916 A CN112748916 A CN 112748916A
- Authority
- CN
- China
- Prior art keywords
- external
- component
- main
- coco
- item
- 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.)
- Granted
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/30—Creation or generation of source code
- G06F8/31—Programming languages or programming paradigms
-
- 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)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Computing Systems (AREA)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
- Computer And Data Communications (AREA)
Abstract
The application discloses a functional module modularization method and a device based on a custom protocol, and the method comprises an external method for realizing a target function by mounting a main project; when the coco components need to call the external methods, the external methods are called through the common entry class of the main item, wherein the coco components are the components which are called by the main item and packaged by the function classes which completely realize a certain function. The application solves the problem that the simple cocoapods are split into modules as the modules to be used by users and are not convenient for continuously using the functions of other modules.
Description
Technical Field
The application relates to the field of application program development, in particular to a functional module componentization method and device based on a custom protocol.
Background
The development of the iOS project inevitably requires the use of a third-party open source library, when the third-party library is used, besides the need of importing source codes, integrating the dependent libraries also requires manual configuration, and when the third-party library is updated, the project also needs to be manually updated, which is very troublesome. Thus, CocoaPods is provided, which can save the time for setting and updating the open source library of the third party, through CocoaPods, the dependent library of the third party can be managed uniformly, and the configuration and the update can be completed only through a few simple lines of commands.
The principle of CocoaPods is to place all dependent libraries in another project named Pods and then let the main project depend on the Pods project, thus moving the source management work from the main project to the Pods project.
The inventor finds that the modules which are simply separated from CocoaPods are used as the users when the CocoaPods are used for project development, and the functions of other modules are not convenient to continue to use. I.e., the CocoaPods component does not enable dynamic extension of functionality.
Disclosure of Invention
The main purpose of the present application is to provide a method and an apparatus for assembling functional modules based on a custom protocol, which solve the problem that the function of other modules is not convenient to continue using as a user the module that has been split by simple coco appds.
In order to achieve the above object, according to a first aspect of the present application, a method for componentizing a custom protocol-based functional module is provided.
The functional module componentization method based on the custom protocol comprises the following steps:
the main project is mounted with an external method for realizing the target function;
when the coco components need to call the external methods, the external methods are called through the common entry class of the main item, wherein the coco components are the components which are called by the main item and packaged by the function classes which completely realize a certain function.
Optionally, before the cocoadods component needs to call the external method, the method further includes:
declaring the external method in a cocoadods component by way of a null implementation;
the external methods are declared in the common entry class of the main item by means of including method implementations.
Optionally, the declaring the external method in the cocoobjects component by a null implementation manner includes:
declaring the external method in a header file of a coco objects component;
the external methods are declared by way of a null implementation in the executable code file of the cocoobjects component.
Optionally, the declaring, in the public entry class of the main item, the external method by means of including method implementation includes:
declaring the external method in a header file of a common entry class of the primary item;
the external methods are declared by means of inclusion of a method implementation in an executable code file of the common entry class of the main item.
Optionally, the external method is a respective proxy method maintained by each main item, and the cocoobjects component is an independent component that can be called by each main item.
Optionally, the external method mounted on each main project may be dynamically replaced.
Optionally, the cocoobjects component is a component packaged by a network communication module, and the external method is a network communication agent.
In order to achieve the above object, according to a second aspect of the present application, another functional module componentization apparatus based on a custom protocol is provided.
The functional module modularization device based on the custom protocol comprises:
the mounting module is used for mounting an external method for realizing the target function on the main project;
and the calling module is used for calling the external method through the common entry class of the main item when the coco objects need to call the external method, wherein the coco objects are called by the main item and are packaged by the functional classes which are called by the main item and completely realize a certain function.
Optionally, the apparatus further comprises:
a first declaration module, configured to declare, in a coco component, the external method in a null implementation manner before the coco component needs to call the external method;
and the second declaration module is used for declaring the external method in a mode of containing method implementation in the public entry class of the main item before the cocoadods component needs to call the external method.
Optionally, the first declaration module includes:
a first header declaring unit for declaring said external method in a header of a cocoobjects component;
a first code file declaring unit for declaring said external method by means of a null implementation in an executable code file of the cocoobjects component.
Optionally, the second lighting module includes:
a second header declaring unit for declaring the external method in a header of a common entry class of the main item;
a second code file declaring unit for declaring said external method by means of an inclusion method implementation in an executable code file of a common entry class of said main item.
Optionally, the external method is a respective proxy method maintained by each main item, and the cocoobjects component is an independent component that can be called by each main item.
Optionally, the external method mounted on each main project may be dynamically replaced.
Optionally, the cocoobjects component is a component packaged by a network communication module, and the external method is a network communication agent.
In order to achieve the above object, according to a third aspect of the present application, there is provided a computer-readable storage medium storing computer instructions for causing the computer to execute the customized protocol-based function module componentization method according to any one of the first aspects.
In order to achieve the above object, according to a fourth aspect of the present application, there is provided an electronic apparatus comprising: at least one processor; and a memory communicatively coupled to the at least one processor; wherein the memory stores a computer program executable by the at least one processor, the computer program being executable by the at least one processor to cause the at least one processor to perform the method of assembling a custom protocol based functional module according to any of the first aspect.
In the embodiment of the application, in the functional module componentization method and device based on the custom protocol, the main item can mount an external method, and the cocoapods component can call the external method through the public entry class of the main item. Equivalently, by means of a self-defined protocol, the cocoadods component can call an external method (the external method mounted in the main project) when being used as a user; i.e. the extension of the functions of the coco modules components can be realized.
Drawings
The accompanying drawings, which are incorporated in and constitute a part of this application, serve to provide a further understanding of the application and to enable other features, objects, and advantages of the application to be more apparent. The drawings and their description illustrate the embodiments of the invention and do not limit it. In the drawings:
FIG. 1 is a flow chart of a method for assembling a custom protocol-based functional module according to an embodiment of the present application;
FIG. 2 is a block diagram of a functional module componentization apparatus based on a custom protocol according to an embodiment of the present application;
FIG. 3 is a block diagram of another apparatus for assembling custom protocol-based function modules according to an embodiment of the present application;
FIG. 4 shows a schematic structural diagram of an electronic device according to an embodiment of the present application;
FIG. 5 shows a schematic structural diagram of a computer-readable storage medium according to an embodiment of the present application.
Detailed Description
In order to make the technical solutions better understood by those skilled in the art, the technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only partial embodiments of the present application, but not all embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
It should be noted that the terms "first," "second," and the like in the description and claims of this application and in the drawings described above are used for distinguishing between similar elements and not necessarily for describing a particular sequential or chronological order. It should be understood that the data so used may be interchanged under appropriate circumstances such that embodiments of the application described herein may be used. Furthermore, the terms "comprises," "comprising," and "having," and any variations thereof, are intended to cover a non-exclusive inclusion, such that a process, method, system, article, or apparatus that comprises a list of steps or elements is not necessarily limited to those steps or elements expressly listed, but may include other steps or elements not expressly listed or inherent to such process, method, article, or apparatus.
It should be noted that the embodiments and features of the embodiments in the present application may be combined with each other without conflict. The present application will be described in detail below with reference to the embodiments with reference to the attached drawings.
It should be noted that, in the original coco objects framework, the coco objects component can only be called by the main item, as the coco objects are called by the user, but the coco objects component cannot call the external method. The embodiment provides a custom protocol for the problem, and can realize that the cocoadods component can be used as a user and simultaneously realize dynamic expansion of functions by using other external methods.
According to an embodiment of the present application, a functional module componentization method based on a custom protocol is provided, as shown in fig. 1, the method includes the following steps:
s101, an external method for realizing target functions by mounting a main project.
Where the main item corresponds to the main program of an item and the external methods are some proxy solutions for the functional components called by the main item. For example, the external method may be a network communication agent of the network communication module.
Each main project can mount an external method meeting the corresponding service requirement. The external methods are dynamically replaceable, such as replaceable, deleted, added, etc. And the external method can be realized or not, and the realization of the proxied functional module is not influenced. For the above example, the proxied function module is a network communication module, and the external method is a network communication proxy.
S102, when the cocoobjects component needs to call the external method, the external method is called through the public entry class of the main item.
Wherein the cocoobjects component is a component packaged by a function class called by the main item and fully realizing a certain function. The function class of a certain function can be a network communication function class, a data calculation function class, a data storage class and the like.
It should be noted that before the ocoapods component can call the external method through the common entry class of the main item, some previous configuration is needed. The method specifically comprises the following steps:
firstly, declaring the external method in a coco objects component in a null implementation mode;
the null implementation is that there is no implementation code for external methods in the cocoapods component that are mounted on the primary item. The specific declaration process is as follows: declaring the external method in a header file of a coco objects component; the external method is declared in the executable code file of the cocoobjects component by means of null implementation, namely, the null is left in the external method and no function is implemented.
Specific claim examples are given for illustration:
the external method is declared in the header file (.h file) of the cocoobjects component as follows:
-(NSDictionary*)dictionaryForProxy；
wherein NSDictionary is an external method
Declaring the external method by means of a null implementation in an (executable code file) m-file of a cocoobjects component as follows:
-(NSDictionary*)dictionaryForProxy{return@{}；}
it can be seen that there is no specific method implementation code for the external method in the m file.
Second, the external methods are declared in the common entry class of the main item by means of containment method implementation.
One main item corresponds to one common entry class, i.e. one item corresponds to one common entry class. The specific 'containing method implementation mode declaration' is to declare the external method in a header file of a common entry class of the main item; the external methods are declared in the executable code file of the common entry class of the main item by means of containing method implementations, i.e. implementation code of the external methods is included inside.
Specific examples are given for illustration:
the external method is declared in the header file (.h) of the common entry class of the main item as follows:
-(NSDictionary*)dictionaryForProxy；
declaring in an executable code file (.m) of a common entry class of the main item, by means of a containment method implementation, the external method as follows:
it can be seen that the executable code file of the common entry class of the main item contains the specific implementation code of the external method.
Based on the foregoing configuration, when the cocoadods component needs to call the external method, the common entry class of the main item calls the external method.
A description of a specific calling procedure is given in connection with the example of the above steps, as follows:
where appdomain is the common entry class of the APP item, corresponding to the foregoing example, the header file of the common entry class is appdomain.h, and the executable code file of the common entry class is appdomain.m. The method in this embodiment can be applied to APP component development, and therefore the application scenario is taken as an example for explanation.
It should be noted that, the above description is directed to one functional component, and in practical applications, each component that needs to be functionally expanded may implement the function expansion by mounting the functional component in the above manner.
From the above description, it can be seen that, in the functional module componentization method based on the custom protocol according to the embodiment of the present application, the main item may mount an external method, and the cocoadods component may call the external method through the common entry class of the main item. Equivalently, by means of a self-defined protocol, the cocoadods component can call an external method (the external method mounted in the main project) when being used as a user; i.e. the extension of the functions of the coco modules components can be realized.
Further, it should be noted that, in practical applications, the external method is a respective proxy method maintained by each main item, and the cocoapods component is an independent component that can be called by each main item. It is understood that the coco objects are relatively general functional objects that can be called by various main items, and the coco objects do not know which main item is called. The external method is an agent scheme which is required by each main project and belongs to personalized requirements, and the external method is mounted on the main project, and other main projects cannot be used. The method of the embodiment of the application can meet the requirement that different main projects may or may not need the agent scheme; and the required proxy solution may also be an implementation of a different proxy solution.
In the embodiment of the application, the proxy method required to be called by the coco component is not directly combined with the coco component into one component, because the proxy methods required by different main items may be different, the coco component can be called by all the main items, if the called proxy method is directly combined with the coco component into one component, the coco component can only be called by the main item requiring the same proxy method, other main items cannot be used, or the requirement of the self personalized proxy method cannot be met by using the other main items. Therefore, the method of the embodiment of the application is very flexible, does not affect the calling of cocoadods components by each main project, and can meet the personalized requirements of different main projects on different proxy methods.
Finally, beneficial effects of the functional module componentization method based on the custom protocol are summarized as follows:
1. on the basis of the cocopods framework, the scheme breaks through barriers between components and between the components and a main project (main project) through a self-defined protocol method, and the components can flexibly mount the implementation of partial functions to the outside (main project) without realizing the implementation of the partial functions by themselves: an external method implementation is invoked.
2. The component is not required to contact a third party to realize: the declaration of external methods is made in the component by way of a null implementation.
3. No new couplings have been added to the components that have been split: the split cocoadods component does not need to depend on other implementations.
It should be noted that the steps illustrated in the flowcharts of the figures may be performed in a computer system such as a set of computer-executable instructions and that, although a logical order is illustrated in the flowcharts, in some cases, the steps illustrated or described may be performed in an order different than presented herein.
According to an embodiment of the present application, there is also provided a functional module componentization apparatus based on a custom protocol for implementing the method in fig. 1, as shown in fig. 2, the apparatus includes:
a mounting module 21 for mounting an external method for realizing a target function on a main project;
and the calling module 22 is used for calling the external method through the common entry class of the main item when the coco objects need to call the external method, wherein the coco objects are the objects formed by packaging the function classes which are called by the main item and completely realize a certain function.
From the above description, it can be seen that, in the functional module assembly apparatus based on the custom protocol according to the embodiment of the present application, the main item may mount an external method, and the cocoapods component may call the external method through the common entry class of the main item. Equivalently, by means of a self-defined protocol, the cocoadods component can call an external method (the external method mounted in the main project) when being used as a user; i.e. the extension of the functions of the coco modules components can be realized.
Further, as shown in fig. 3, the apparatus further includes:
a first declaring module 23, configured to declare, in a coco component, the external method by way of a null implementation before the coco component needs to call the external method;
a second declaring module 24, configured to declare the external method by including a method implementation in the common entry class of the main item before the cocoadods component needs to call the external method.
Further, as shown in fig. 3, the first declaration module 23 includes:
a first header declaring unit 231 for declaring the external method in a header of a coco components;
a first code file declaring unit 232 for declaring said external methods by means of a null implementation in an executable code file of the cocoobjects component.
Further, as shown in fig. 3, the second lighting module 24 includes:
a second header declaring unit 241 for declaring the external method in a header of the common entry class of the main item;
a second code file declaring unit 242 for declaring said external method by means of a method implementation included in an executable code file of a common entry class of said main item.
Further, the external methods are respective proxy methods maintained by the respective main items, and the cocoobjects components are independent components that can be called by the respective main items.
Further, the external methods mounted on the respective primary projects can be dynamically replaced.
Further, the cocoobjects component is a component packaged by a network communication module, and the external method is a network communication agent.
Specifically, the specific process of implementing the functions of each unit and module in the device in the embodiment of the present application may refer to the related description in the method embodiment, and is not described herein again.
Fig. 4 shows a schematic structural diagram of an electronic device 300 according to an embodiment of the application, the electronic device 300 comprising a processor 310 and a memory 320 arranged to store computer executable instructions (computer readable program code).
The memory 320 may be an electronic memory such as a flash memory, an EEPROM (electrically erasable and programmable read only memory), an EPROM, a hard disk, or a ROM, among others. The memory 320 has a storage space 330 in which computer readable program code 331 is stored. For example, the storage space 330 for storing the computer readable program code may include respective computer readable program codes 331 respectively for implementing various steps in the above custom protocol-based functional module componentization method. The computer readable program code 331 may be read from or written to one or more computer program products. These computer program products comprise a program code carrier such as a hard disk, a Compact Disc (CD), a memory card or a floppy disk. Such a computer program product is typically a computer readable storage medium such as described in fig. 5.
FIG. 5 shows a schematic diagram of a computer-readable storage medium according to an embodiment of the present application. The computer readable storage medium 400 stores computer readable program code 331 for performing the steps of the method according to the present application, which is readable by the processor 310 of the electronic device 300, and when the computer readable program code 331 is executed by the electronic device 300, causes the electronic device 300 to perform the steps of the method described above, and in particular, the computer readable program code 331 stored in the computer readable storage medium can perform the customized protocol based function module componentization method shown in the above embodiments. The computer readable program code 331 may be compressed in a suitable form.
It will be apparent to those skilled in the art that the modules or steps of the present application described above may be implemented by a general purpose computing device, they may be centralized on a single computing device or distributed across a network of multiple computing devices, and they may alternatively be implemented by program code executable by a computing device, such that they may be stored in a storage device and executed by a computing device, or fabricated separately as individual integrated circuit modules, or fabricated as a single integrated circuit module from multiple modules or steps. Thus, the present application is not limited to any specific combination of hardware and software.
The above description is only a preferred embodiment of the present application and is not intended to limit the present application, and various modifications and changes may be made by those skilled in the art. Any modification, equivalent replacement, improvement and the like made within the spirit and principle of the present application shall be included in the protection scope of the present application.
Claims (10)
1. A functional module componentization method based on a custom protocol is characterized by comprising the following steps:
the main project is mounted with an external method for realizing the target function;
when the coco components need to call the external methods, the external methods are called through the common entry class of the main item, wherein the coco components are the components which are called by the main item and packaged by the function classes which completely realize a certain function.
2. The custom protocol based function module componentization method of claim 1, wherein before when a cocoadods component needs to call the external method, the method further comprises:
declaring the external method in a cocoadods component by way of a null implementation;
the external methods are declared in the common entry class of the main item by means of including method implementations.
3. The method for componentizing custom protocol-based functional module according to claim 2, wherein said declaring said external method by means of null implementation in a cocoadods component comprises:
declaring the external method in a header file of a coco objects component;
the external methods are declared by way of a null implementation in the executable code file of the cocoobjects component.
4. The method of claim 2, wherein declaring the external method in a common entry class of the main project by means of a containment method implementation comprises:
declaring the external method in a header file of a common entry class of the primary item;
the external methods are declared by means of inclusion of a method implementation in an executable code file of the common entry class of the main item.
5. The custom protocol based function module componentization method of claim 1, wherein said external methods are respective proxy methods maintained for each primary item, and said cocoadods components are independent components that each primary item can call.
6. The method of claim 5, wherein external methods mounted on each master project are dynamically replaceable.
7. The method of claim 1, wherein the cocoadods component is a network communication module packaged component, and the external method is a network communication agent.
8. A custom protocol based functional module componentization apparatus, comprising:
the mounting module is used for mounting an external method for realizing the target function on the main project;
and the calling module is used for calling the external method through the common entry class of the main item when the coco objects need to call the external method, wherein the coco objects are called by the main item and are packaged by the functional classes which are called by the main item and completely realize a certain function.
9. An electronic device, wherein the electronic device comprises: a processor; and a memory arranged to store computer executable instructions that when executed cause the processor to perform the custom protocol based functional module componentization method of any of claims 1-7.
10. A computer readable storage medium, wherein the computer readable storage medium stores one or more programs which, when executed by a processor, implement the custom protocol-based functional module componentization method of any of claims 1-7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110045269.1A CN112748916B (en) | 2021-01-13 | 2021-01-13 | Functional module componentization method and device based on custom protocol |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202110045269.1A CN112748916B (en) | 2021-01-13 | 2021-01-13 | Functional module componentization method and device based on custom protocol |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112748916A true CN112748916A (en) | 2021-05-04 |
| CN112748916B CN112748916B (en) | 2022-08-23 |
Family
ID=75651762
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202110045269.1A Active CN112748916B (en) | 2021-01-13 | 2021-01-13 | Functional module componentization method and device based on custom protocol |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112748916B (en) |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104331368A (en) * | 2014-11-18 | 2015-02-04 | 合肥康捷信息科技有限公司 | Method for performing static analysis on C++ virtual function call upon cfg (configuration) files |
| CN106897215A (en) * | 2017-01-20 | 2017-06-27 | 华南理工大学 | A kind of method gathered based on WebView webpages loading performance and user behavior flow data |
| CN107577483A (en) * | 2017-08-31 | 2018-01-12 | 武汉斗鱼网络科技有限公司 | Component engineering calls method, storage medium, equipment and the system of main works code |
| US20180081693A1 (en) * | 2016-09-22 | 2018-03-22 | Groupon, Inc. | Mobile service applications |
| CN109614320A (en) * | 2018-11-16 | 2019-04-12 | 福建天泉教育科技有限公司 | A kind of method and terminal detecting code interface accuracy |
| CN110764778A (en) * | 2019-10-21 | 2020-02-07 | 深圳市珍爱捷云信息技术有限公司 | Pre-compiling method, device, equipment and storage medium in application construction |
-
2021
- 2021-01-13 CN CN202110045269.1A patent/CN112748916B/en active Active
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN104331368A (en) * | 2014-11-18 | 2015-02-04 | 合肥康捷信息科技有限公司 | Method for performing static analysis on C++ virtual function call upon cfg (configuration) files |
| US20180081693A1 (en) * | 2016-09-22 | 2018-03-22 | Groupon, Inc. | Mobile service applications |
| CN106897215A (en) * | 2017-01-20 | 2017-06-27 | 华南理工大学 | A kind of method gathered based on WebView webpages loading performance and user behavior flow data |
| CN107577483A (en) * | 2017-08-31 | 2018-01-12 | 武汉斗鱼网络科技有限公司 | Component engineering calls method, storage medium, equipment and the system of main works code |
| CN109614320A (en) * | 2018-11-16 | 2019-04-12 | 福建天泉教育科技有限公司 | A kind of method and terminal detecting code interface accuracy |
| CN110764778A (en) * | 2019-10-21 | 2020-02-07 | 深圳市珍爱捷云信息技术有限公司 | Pre-compiling method, device, equipment and storage medium in application construction |
Non-Patent Citations (4)
| Title |
|---|
| IGOR KULMAN: ""Using CocoaPods to just build frameworks for use elsewhere"", 《HTTPS://BLOG.KULMAN.SK/USING-PODS-TO-JUST-BUILD-FRAMEWORKS/》 * |
| IOS开发之旅: ""CocoaPods实现模块化开发"", 《HTTPS://JUEJIN.CN/POST/6844903847756824584》 * |
| VINCEN??: ""C#：扩展方法和外部方法"", 《HTTPS://BLOG.CSDN.NET/WEIXIN_34060299/ARTICLE/DETAILS/92306769》 * |
| 王杨帅: ""MES中基于WebClient的声明式服务调用框架"", 《电子技术与软件工程》 * |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112748916B (en) | 2022-08-23 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN104714828A (en) | Methods and devices for installing and operating application | |
| CN104156225B (en) | A kind of method for down loading of installation kit, system and server | |
| CN104750528B (en) | A kind of assembly management method and apparatus in Android program | |
| CN104750555A (en) | Management method and device for progresses in Android program | |
| CN111399840B (en) | Module development method and device | |
| KR20040022459A (en) | System and method for field downloading a wireless communication device software code section | |
| CN108228147A (en) | A kind of performance data journal obtaining method and device | |
| EP2842044A1 (en) | Platform runtime abstraction | |
| CN112417051A (en) | Container arrangement engine resource management method and device, readable medium and electronic equipment | |
| CN104834541A (en) | Function module mounting method, mounting system and mounting system updating method | |
| CN113296871A (en) | Method, equipment and system for processing container group instance | |
| CN109343970B (en) | Application program-based operation method and device, electronic equipment and computer medium | |
| CN112748916B (en) | Functional module componentization method and device based on custom protocol | |
| CN112685020A (en) | Method and device for dynamically creating service interface, electronic equipment and storage medium | |
| CN112306507A (en) | Picture resource processing method, device, terminal and storage medium | |
| CN116755788A (en) | On-line rule modification method, device, equipment and storage medium | |
| CN113743879A (en) | Automatic rule processing method, system and related equipment | |
| CN116107590A (en) | Implementation method and system for compatible micro-service and monomer architecture in software product development and deployment | |
| CN110266501B (en) | Block chain node device and block chain network system | |
| CN114358936A (en) | Intelligent contract operation method based on micro-service block chain | |
| CN113050962A (en) | Mobile service upgrading method, device and terminal | |
| CN111209613A (en) | Rapid design method and system of intelligent product | |
| CN110780864A (en) | Control method and device for class method replacement, storage medium and electronic equipment | |
| CN111221547A (en) | Client updating progress monitoring method, storage medium, electronic device and system | |
| CN108958795A (en) | BootLoader code huge profit method and development board in a kind of embedded system |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| GR01 | Patent grant | ||
| GR01 | Patent grant |