CN115658140A - SDK packaging method, device, terminal and storage medium - Google Patents
SDK packaging method, device, terminal and storage medium Download PDFInfo
- Publication number
- CN115658140A CN115658140A CN202211673423.0A CN202211673423A CN115658140A CN 115658140 A CN115658140 A CN 115658140A CN 202211673423 A CN202211673423 A CN 202211673423A CN 115658140 A CN115658140 A CN 115658140A
- Authority
- CN
- China
- Prior art keywords
- target
- sdk
- packaging
- compiling
- plist file
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
- 238000004806 packaging method and process Methods 0.000 title claims abstract description 68
- 238000000034 method Methods 0.000 title claims abstract description 38
- 238000013515 script Methods 0.000 claims abstract description 63
- 238000012856 packing Methods 0.000 claims abstract description 48
- 238000007781 pre-processing Methods 0.000 claims abstract description 22
- 238000004590 computer program Methods 0.000 claims 1
- 238000010586 diagram Methods 0.000 description 7
- 230000008569 process Effects 0.000 description 6
- 238000012423 maintenance Methods 0.000 description 4
- 238000011161 development Methods 0.000 description 3
- 238000013461 design Methods 0.000 description 2
- 238000012986 modification Methods 0.000 description 2
- 230000004048 modification Effects 0.000 description 2
- 230000009286 beneficial effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004891 communication Methods 0.000 description 1
- 238000012790 confirmation Methods 0.000 description 1
- 230000008878 coupling Effects 0.000 description 1
- 238000010168 coupling process Methods 0.000 description 1
- 238000005859 coupling reaction Methods 0.000 description 1
- 230000000694 effects Effects 0.000 description 1
- 238000005516 engineering process Methods 0.000 description 1
- 230000006872 improvement Effects 0.000 description 1
- 230000003993 interaction Effects 0.000 description 1
- 230000014759 maintenance of location Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
- 230000003068 static effect Effects 0.000 description 1
- 238000006467 substitution reaction Methods 0.000 description 1
- 238000013024 troubleshooting Methods 0.000 description 1
Images
Landscapes
- Stored Programmes (AREA)
Abstract
The invention discloses a packing method, a device, a terminal and a storage medium of an SDK, wherein the packing method of the SDK comprises the following steps: storing a target instruction required by a compiling and packaging link corresponding to a target SDK into a target medium carrier when performing a script automatic preprocessing link corresponding to the target SDK; and then, when a compiling and packing ring corresponding to the target SDK is carried out, the target instruction is obtained from the target media carrier, and compiling and packing of the target SDK are completed based on the target instruction, so that when the SDK is packed, the instruction can be transmitted between the script automatic preprocessing link and the compiling and packing link through the target media carrier, the compatibility of the compiling and packing link is improved, and the problem that a packing code cannot be universally used in any packing environment is solved.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a method, an apparatus, a terminal, and a storage medium for packing an SDK.
Background
When packing the SDK, the parameters required in the compilation and packing process started by the IDE are usually actively acquired by the IDE itself, but cannot be directly transferred by the external Shell script. In general, the parameters required by the IDE can only directly modify config configuration inside the IDE, so that the parameters required by the IDE can only be written in the engineering of the IDE itself in advance. However, in modern collaboration, the IDE engineering is maintained by multiple persons, and if parameters required by the IDE are directly written into the IDE, many problems are easily caused, for example, in the collaboration of multiple persons, configuration conflicts occur at high frequency; only one part of parameters cannot be maintained, when the Shell script modifies the parameters, the parameters need to be manually modified again in the IDE, and data redundancy and high maintenance cost are easily caused; poor compatibility of the operating environment (a problem arises when one person is replaced by another computer); instructions and parameters cannot be changed dynamically (can only be written to death); the manual maintenance cost is high (manual modification is needed); data redundancy (maintaining multiple copies of data), etc. It can be seen that the prior art is prime for improvement.
Disclosure of Invention
In order to solve the above technical problem, a first aspect of the present invention discloses a packing method for an SDK, where the method includes:
storing a target instruction required by a compiling and packaging link corresponding to a target SDK into a target medium carrier when performing a script automatic preprocessing link corresponding to the target SDK;
and when the compiling and packaging link corresponding to the target SDK is carried out, acquiring the target instruction from the target media carrier, and finishing the compiling and packaging of the target SDK based on the target instruction.
The second aspect of the present invention discloses a packing apparatus for SDK, the apparatus comprising:
the storage module is used for storing a target instruction required by a compiling and packaging link corresponding to the target SDK into a target medium carrier when a script automatic preprocessing link corresponding to the target SDK is carried out;
and the obtaining module is used for obtaining the target instruction from the target media carrier when a compiling and packaging loop corresponding to the target SDK is carried out, and completing compiling and packaging of the target SDK based on the target instruction.
The third aspect of the present invention discloses a packing terminal for SDK, the terminal comprising:
a memory storing executable program code;
a processor coupled with the memory;
the processor calls the executable program codes stored in the memory to execute part or all of the steps in the packing method of the SDK disclosed by the first aspect of the invention.
In a fourth aspect, the present invention discloses a computer storage medium, which stores computer instructions, and when the computer instructions are called, the computer instructions are used to perform some or all of the steps in the packaging method of the SDK disclosed in the first aspect of the present invention.
Compared with the prior art, the embodiment of the invention has the following beneficial effects:
in the embodiment of the invention, when the automatic script preprocessing link corresponding to the target SDK is carried out, a target instruction required by the compiling and packaging link corresponding to the target SDK is stored in a target medium carrier; and then, when a compiling and packing link corresponding to the target SDK is carried out, the target instruction is obtained from the target media carrier, and the compiling and packing of the target SDK are completed based on the target instruction, so that when the SDK is packed, the instruction can be transmitted between the script automatic preprocessing link and the compiling and packing link through the target media carrier, the compatibility of the compiling and packing link is improved, and the problem that one packed code cannot be universally used in any packing environment is solved.
Drawings
In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings needed to be used in the description of the embodiments will be briefly introduced below, and it is obvious that the drawings in the following description are only some embodiments of the present invention, and it is obvious for those skilled in the art to obtain other drawings based on these drawings without creative efforts.
Fig. 1 is a schematic flowchart of a packing method of an SDK according to an embodiment of the present invention;
FIG. 2 is a diagram illustrating a packing method for an SDK according to an embodiment of the present invention in comparison with a packing method for an existing SDK;
FIG. 3 is a schematic structural diagram of an SDK packing apparatus according to an embodiment of the present invention;
fig. 4 is a schematic structural diagram of a SDK packaging terminal according to an embodiment of the present invention;
fig. 5 is a schematic structural diagram of a computer storage medium according to an embodiment of the present invention.
Detailed Description
In order to make the technical solutions of the present invention better understood, the technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the drawings in the embodiments of the present invention, and it is obvious that the described embodiments are only a part of the embodiments of the present invention, and not all of the 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 invention.
The terms "first," "second," and the like in the description and claims of the present invention and in the above-described drawings are used for distinguishing between different objects and not for describing a particular order. Furthermore, the terms "include" and "have," as well as any variations thereof, are intended to cover non-exclusive inclusions. For example, a process, method, apparatus, article, or article that comprises a list of steps or elements is not limited to only those steps or elements listed, but may alternatively include other steps or elements not listed, or inherent to such process, method, article, or article.
Reference herein to "an embodiment" means that a particular feature, structure, or characteristic described in connection with the embodiment can be included in at least one embodiment of the invention. The appearances of the phrase in various places in the specification are not necessarily all referring to the same embodiment, nor are separate or alternative embodiments mutually exclusive of other embodiments. It is explicitly and implicitly understood by one skilled in the art that the embodiments described herein can be combined with other embodiments.
The invention discloses a packing method, a packing device, a packing terminal and a storage medium of an SDK (software development kit). When a script corresponding to a target SDK automatically preprocesses a link, a target instruction required by a compiling and packing link corresponding to the target SDK is stored in a target medium carrier; and then, when a compiling and packing link corresponding to the target SDK is carried out, the target instruction is obtained from the target media carrier, and the compiling and packing of the target SDK are completed based on the target instruction, so that when the SDK is packed, the instruction can be transmitted between the script automatic preprocessing link and the compiling and packing link through the target media carrier, the compatibility of the compiling and packing link is improved, and the problem that one packed code cannot be universally used in any packing environment is solved. The following are detailed descriptions.
Description of related art terms:
MacOS: operating system developed by apple Inc. and running on apple computer
IDE: an integrated development environment (integrated development environment) is an application program for providing a program development environment, and generally includes tools such as a code editor, a compiler, a debugger, and a graphical user interface
Xcode: xcode is an integrated development tool (IDE) running on the operating system MacOS, developed by AppleInc
And (3) SDK: software Development Kit, software Development Kit
framework: one existing form of SDK on iOS platforms, typically ends with a.frame suffix. The framework inside contains header file, configuration table, multi-structure document package. There are two types of dynamic library and static library
Script language: a programming language for controlling software applications, scripts are typically stored in text (e.g., ASCII) and are interpreted or compiled only when called.
Coupling: refers to the phenomenon that two or more systems or two motion forms interact with each other through interaction to combine
Decoupling: the common decoupling method is to ignore or simplify one system or motion with less influence on the problem to be researched, and only analyze the main system or motion.
Shell: a command language, and a programming language.
Shell script: shellscript (shell script), is a script program written using shell.
Plist document: the attribute table file (Plist) is a file format that is typically used to store user settings and may also be used to store bundled information.
Example one
Referring to fig. 1, fig. 1 is a schematic flow chart illustrating a packing method of an SDK according to an embodiment of the present invention. As shown in fig. 1, the packing method of the SDK may include the following operations:
101. storing a target instruction required by a compiling and packaging link corresponding to a target SDK into a target medium carrier when performing a script automatic preprocessing link corresponding to the target SDK;
102. and when the compiling and packaging link corresponding to the target SDK is carried out, acquiring the target instruction from the target media carrier, and finishing the compiling and packaging of the target SDK based on the target instruction.
In an alternative embodiment, the target media carrier is a plist file.
In an optional embodiment, the storing, in an object media carrier, an object instruction required for a compiling and packaging link corresponding to the object SDK includes:
storing a target instruction required by a compiling and packaging link corresponding to the target SDK into a first plist file, wherein the first plist file is in a folder where a target Shell script is located, and the target Shell script is the Shell script used for achieving an automatic script preprocessing link corresponding to the target SDK;
storing the path of the first plist file in a folder where the target Shell script is located into a second plist file, wherein the second plist file is in a folder where a target IDE is located, and the target IDE is an IDE for realizing a compiling and packaging link corresponding to the target SDK;
in an alternative embodiment, the retrieving the target instructions from the target media carrier comprises:
acquiring a path of the first plist file in a folder where the target Shell script is located from the second plist file;
and searching the first plist file from the folder where the target Shell script is located according to the path of the first plist file in the folder where the target Shell script is located, and then acquiring the target instruction from the first plist file.
In an optional embodiment, the storing the path of the first plist file in the folder where the target Shell script is located to a second plist file includes:
and storing the path of the first plist file in the folder where the target Shell script is located into an appointed field of a second plist file.
In an optional embodiment, the obtaining, from the second plist file, a path of the first plist file in a folder where the target Shell script is located includes:
and acquiring a path of the first plist file in a folder where the target Shell script is located from an appointed field of the second plist file.
In an optional embodiment, the step of storing a target instruction required by a compiling and packaging link corresponding to a target SDK into a target media carrier when performing a script automation preprocessing link corresponding to the target SDK and the step of obtaining the target instruction from the target media carrier and completing the compiling and packaging of the target SDK based on the target instruction are implemented by adding logic in a corresponding script when performing the compiling and packaging link corresponding to the target SDK.
The following description is made with reference to fig. 2 for the purpose of designing the present application:
the main design goals of the solution of the present application are:
(1) Specific parameters are not maintained within the IDE folder. Neither write-down in IDE nor retention in folder, which would otherwise create a conflict in multi-person maintenance.
(2) Specific parameters are set in the Shell script. Only one copy is maintained, firstly, data redundancy is solved, and secondly, when data changes, the IDE reads the latest data naturally.
The main scheme of the application is as follows:
(1) By utilizing IDE characteristics, although the IDE does not know the external Shell script path, the IDE naturally knows 'where' the IDE is located, and therefore, an AutoReleaseSellTempplist. As a medium carrier for transferring temporary instructions and parameters.
(2) The plist table is essentially a file, but the plist file is selected here, because the plist file has the characteristic of being read in a key value mode more efficiently, and meanwhile, regular codes do not need to be written additionally for analysis and reading, and labor cost is saved.
(3) Plist table now being responsible for registering parameters, can register the specific parameters needed, point (1) mentions that when the IDE is running, it can find them and read the specific parameters. However, our solution, which does not consider "scratch pad instructions and parameters at this point", also needs to solve the problem of "data redundancy" because the solution aims to "maintain only one copy of data". The problems of high maintenance cost, high possibility of errors of data and higher troubleshooting cost caused by data redundancy are solved.
(4) Based on the point (3), two design points are continuously proposed: firstly, an instruction and a parameter are maintained in the Shell script environment, and therefore a ReleaseSetup. Plist is specially maintained for specific instructions and data. Plist only maintains the folder Path of the Shell script without repeatedly maintaining the same data, and the Path field name key value is as ReleaseSetup _ Path. This "ReleaseSetup _ Path" will be used as a "contract, protocol, rule" to string between the Shell script and the IDE. The IDE reads the contents through a key called "ReleaseSetup _ Path", and the Shell performs "leave-message", i.e. pre-configuration, through a key called "ReleaseSetup _ Path".
(5) In the Shell script, a configuration write logic for autoreleasesheltepplist is newly added: that is, the Shell script writes a "ReleaseSetup _ Path" convention field in the auto releaseshelltempempplist, plist to "ReleaseSetup.
(6) In the IDE, the newly added logic reads the Path of the IDE project, then finds the plist table, and then reads the logic of the 'ReleaseSetup _ Path' convention field from the AutoReleaseSellTempplist.
For the purpose of understanding the scheme of the present application, the following description is continued with respect to the scheme of the present application:
in the process of packaging the SDK by the iOS platform, two links of 'script automation preprocessing' and 'compiling and packaging' exist. The former is responsible for operations such as version notification, path analysis, branch switching, check and confirmation, and the latter is responsible for generating a frame packet.
However, there is a problem that communication is difficult between the two links for the following reasons:
firstly, the automatic preprocessing of script belongs to the Shell environment, and the compiling packing belongs to the Xcode environment, and two environment operation back all is an independent program, and the memory space is independent each other, can't read each other.
And secondly, compiling and packaging programs, namely the code paths of the Shell scripts cannot be known, and if the paths are not known, the programs cannot be actively moved to a specific position to be read.
Based on the problems, the problem that the 'script automatic preprocessing' link cannot transmit instructions to the 'compiling and packaging' link is caused.
And the instruction is transmitted in order to adapt to different packaging environments in the 'compiling and packaging' link.
In enterprise collaboration, especially large enterprises, due to the large number of developers, the process of packaging the SDK may occur in different programmer's computer environments, and in different computer environments, the script path and the compiling and packaging path are basically different.
Each developer needs to manually configure a read path of "compile and package", that is, a path of "fixed write", according to the package environment before packing the SDK. The 'compiling and packaging' lacks compatibility, and a packaging code cannot be universally used in any packaging environment.
Because the path of the project corresponding to the compiling and packaging needs to be uniformly configured in the 'script automatic preprocessing', the characteristic can be used as an instruction source for transmitting instructions to an Xcode environment in the 'compiling and packaging' link so as to remove the strong dependence of the 'compiling and packaging' link on the instructions.
Meanwhile, a medium carrier is needed, the instructions are temporarily stored in the medium carrier and read by the user when the compiling and packaging are started, and the process is similar to a 'message'.
The storage path of the media is also very elaborated, and two characteristics of a known compiling and packaging engineering path of 'script automatic preprocessing', and a natural known path of the 'compiling and packaging' engineering are utilized, so that a media carrier is newly built under the path of the 'compiling and packaging' engineering in advance, and the 'script automatic preprocessing' link 'message' configuration and the 'compiling and packaging' link reading are facilitated.
Through the two key operations, the compatibility and the universality of the compiling and packaging link code are improved.
In addition, the scheme of the application can also be expressed as:
firstly, in a project corresponding to a compiling and packaging link, an AutoReleaseStollTempplist.
Second, a specific keyword convention is performed in the plist table, such as a ReleaseSetup _ Path keyword.
And thirdly, newly adding configuration logic for an AutoReleaseSellTempList table in 'script automatic preprocessing', uniformly storing relevant instructions required by 'compiling and packaging' link into the plist table, wherein the operation can be understood as 'leaving a message'. The logging needs to strictly follow a specific keyword convention.
And fourthly, adding a new logic into the Xcode built-in script in the 'compiling and packaging' link, wherein the logic is to access a path where the self project is located, and the logic is to read aiming at the AutoReleaseStollTempplist.
In conclusion, by using the newly-built media carrier as the intermediate file and using the specific keyword convention as the value reading protocol, the effect of instruction transmission from the Shell environment to the Xcode environment across environments can be realized, and the Shell environment and the Xcode environment are still independent and have no pourability.
Example two
Referring to fig. 3, fig. 3 is a schematic structural diagram of an SDK packaging apparatus according to an embodiment of the present invention. As shown in fig. 3, the packing means of the SDK may include:
the storage module 201 is configured to store, in a target media carrier, a target instruction required by a compiling and packaging link corresponding to a target SDK when performing a script automation preprocessing link corresponding to the target SDK;
an obtaining module 202, configured to obtain the target instruction from the target media carrier when performing a compiling and packaging loop corresponding to the target SDK, and complete compiling and packaging of the target SDK based on the target instruction.
For the specific description of the packing apparatus of the SDK, reference may be made to the specific description of the packing method of the SDK, which is not described in detail herein.
EXAMPLE III
Referring to fig. 4, fig. 4 is a schematic structural diagram of a SDK packaging terminal according to an embodiment of the present invention. As shown in fig. 4, the SDK packaging terminal may include:
a memory 301 storing executable program code;
a processor 302 coupled to the memory 301;
the processor 302 calls the executable program code stored in the memory 301 to execute the steps in the packing method of the SDK disclosed in the embodiment of the present invention.
Example four
Referring to fig. 5, fig. 5 is a schematic structural diagram of a computer storage medium according to an embodiment of the disclosure. As shown in fig. 5, an embodiment of the present invention discloses a computer storage medium 401, where the computer storage medium 401 stores computer instructions, and when the computer instructions are called, the computer instructions are used to execute steps in the packing method of an SDK disclosed in an embodiment of the present invention.
The above-described embodiments of the apparatus are merely illustrative, and the modules described as separate parts may or may not be physically separate, and the parts displayed as modules may or may not be physical modules, may be located in one place, or may be distributed on a plurality of network modules. Some or all of the modules may be selected according to actual needs to achieve the purpose of the solution of the present embodiment. One of ordinary skill in the art can understand and implement it without inventive effort.
Through the above detailed description of the embodiments, those skilled in the art will clearly understand that each embodiment may be implemented by software plus a necessary general hardware platform, and may also be implemented by hardware. Based on this understanding, the above technical solutions may be embodied in the form of a software product, which may be stored in a computer-readable storage medium, where the storage medium includes a Read-only memory (ROM), a Random Access Memory (RAM), a programmable Read-only memory (PROM), an erasable programmable Read-only memory (EPROM), a One-time programmable Read-only memory (OTPROM), an Electrically erasable rewritable Read-only memory (EEPROM), a Read-only disk (compact-Read-only-ROM, CD-ROM) or other optical disk memory, a magnetic disk memory, a tape memory, or any other computer-readable medium capable of carrying or storing data.
Finally, it should be noted that: the packing method, apparatus, terminal and storage medium for SDK disclosed in the embodiments of the present invention are only preferred embodiments of the present invention, and are only used for illustrating the technical solutions of the present invention, not for limiting the same; although the present invention has been described in detail with reference to the foregoing embodiments, it will be understood by those skilled in the art; the technical solutions described in the foregoing embodiments may still be modified, or some technical features may be equivalently replaced; and the modifications or the substitutions do not make the essence of the corresponding technical solutions depart from the spirit and scope of the technical solutions of the embodiments of the present invention.
Claims (10)
1. A packing method of an SDK, the method comprising:
storing a target instruction required by a compiling and packaging link corresponding to a target SDK into a target medium carrier when performing a script automatic preprocessing link corresponding to the target SDK;
and acquiring the target instruction from the target media carrier when performing a compiling and packaging link corresponding to the target SDK, and completing compiling and packaging of the target SDK based on the target instruction.
2. The packaging method of the SDK according to claim 1, wherein the target media carrier is a plist file.
3. The packaging method of the SDK according to claim 2, wherein the storing the target instruction required by the compiling and packaging link corresponding to the target SDK into a target media carrier includes:
storing a target instruction required by a compiling and packaging link corresponding to the target SDK into a first plist file, wherein the first plist file is in a folder where a target Shell script is located, and the target Shell script is the Shell script used for achieving an automatic script preprocessing link corresponding to the target SDK;
and storing the path of the first plist file in the folder where the target Shell script is located into a second plist file, wherein the second plist file is in the folder where the target IDE is located, and the target IDE is the IDE for realizing the compiling and packaging link corresponding to the target SDK.
4. The method for packaging an SDK according to claim 3, wherein the obtaining the target instruction from the target media bearer comprises:
acquiring a path of the first plist file in a folder where the target Shell script is located from the second plist file;
and searching the first plist file from the folder where the target Shell script is located according to the path of the first plist file in the folder where the target Shell script is located, and then obtaining the target instruction from the first plist file.
5. The packaging method of the SDK according to claim 4, wherein the storing the path of the first plist file in the folder where the target Shell script is located to a second plist file comprises:
and storing the path of the first plist file in the folder where the target Shell script is located into an appointed field of a second plist file.
6. The packaging method of the SDK according to claim 5, wherein the obtaining the path of the first plist file in the folder where the target Shell script is located from the second plist file comprises:
and acquiring a path of the first plist file in a folder where the target Shell script is located from an appointed field of the second plist file.
7. The method for packaging the SDK according to claim 6, wherein the step of storing the target instruction required by the compiling and packaging link corresponding to the target SDK into a target media carrier when performing the script automation preprocessing loop corresponding to the target SDK, and the step of obtaining the target instruction from the target media carrier and completing the compiling and packaging of the target SDK based on the target instruction when performing the compiling and packaging loop corresponding to the target SDK are implemented by adding logic to the corresponding script.
8. An apparatus for packing an SDK, the apparatus comprising:
the storage module is used for storing a target instruction required by a compiling and packaging link corresponding to a target SDK into a target medium carrier when performing script automatic preprocessing link corresponding to the target SDK;
and the obtaining module is used for obtaining the target instruction from the target media carrier when the compiling and packaging link corresponding to the target SDK is carried out, and finishing the compiling and packaging of the target SDK based on the target instruction.
9. A packing terminal for an SDK, the terminal comprising:
a memory storing executable program code;
a processor coupled with the memory;
the processor calls the executable program code stored in the memory to perform the packing method of the SDK of any of claims 1-7.
10. A computer-readable storage medium, in which a computer program is stored, which, when being executed by a processor, implements the packing method of the SDK according to any one of claims 1 to 7.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211673423.0A CN115658140A (en) | 2022-12-26 | 2022-12-26 | SDK packaging method, device, terminal and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211673423.0A CN115658140A (en) | 2022-12-26 | 2022-12-26 | SDK packaging method, device, terminal and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN115658140A true CN115658140A (en) | 2023-01-31 |
Family
ID=85023362
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211673423.0A Pending CN115658140A (en) | 2022-12-26 | 2022-12-26 | SDK packaging method, device, terminal and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN115658140A (en) |
Cited By (1)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117033287A (en) * | 2023-10-08 | 2023-11-10 | 易方信息科技股份有限公司 | Multi-bus communication method, system, equipment and storage medium based on SDK (software development kit) package |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108469957A (en) * | 2018-03-08 | 2018-08-31 | 平安科技（深圳）有限公司 | Using packing method for uploading, device, computer equipment and storage medium |
| CN109491664A (en) * | 2018-11-08 | 2019-03-19 | 腾讯科技（深圳）有限公司 | Generation method, device, equipment and the storage medium of iOS application program |
| CN115509607A (en) * | 2022-11-23 | 2022-12-23 | 易方信息科技股份有限公司 | Method for transmitting instructions from iOS-end packaging project to packaging script across environments |
-
2022
- 2022-12-26 CN CN202211673423.0A patent/CN115658140A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN108469957A (en) * | 2018-03-08 | 2018-08-31 | 平安科技（深圳）有限公司 | Using packing method for uploading, device, computer equipment and storage medium |
| CN109491664A (en) * | 2018-11-08 | 2019-03-19 | 腾讯科技（深圳）有限公司 | Generation method, device, equipment and the storage medium of iOS application program |
| CN115509607A (en) * | 2022-11-23 | 2022-12-23 | 易方信息科技股份有限公司 | Method for transmitting instructions from iOS-end packaging project to packaging script across environments |
Cited By (2)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN117033287A (en) * | 2023-10-08 | 2023-11-10 | 易方信息科技股份有限公司 | Multi-bus communication method, system, equipment and storage medium based on SDK (software development kit) package |
| CN117033287B (en) * | 2023-10-08 | 2024-02-13 | 易方信息科技股份有限公司 | Multi-bus communication method, system, equipment and storage medium based on SDK (software development kit) package |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| US10331425B2 (en) | Automated source code adaption to inject features between platform versions | |
| US11579856B2 (en) | Multi-chip compatible compiling method and device | |
| US20150339119A1 (en) | System and Method Thereof for Creating Dynamically Attachable and Detachable Binary Files | |
| US8776024B2 (en) | Software application fine-tuning method, system, and corresponding computer program product | |
| JP4638484B2 (en) | Data integrity in data processing equipment | |
| CN110673837B (en) | Code repairing method and device, electronic equipment and computer readable storage medium | |
| US20080163266A1 (en) | Mechanism for transparently interfacing with a third party version control system | |
| US11288062B2 (en) | Automatic source code refactoring | |
| US11429372B2 (en) | Application program updating method, apparatus, system, medium and device | |
| KR20130017337A (en) | Hybrid app development platform architecture and test method of the same, and computer-readable recording medium with program for the same | |
| US10579366B2 (en) | Data upgrade framework for distributed systems | |
| CN115629971A (en) | Application development system and method | |
| CN115658140A (en) | SDK packaging method, device, terminal and storage medium | |
| EP3866443A1 (en) | Opc ua server, system operating using opc ua, and method of executing opc ua system | |
| CN112835587A (en) | Compiling integration method and device | |
| CN115509607B (en) | Method for transmitting instructions from iOS (internet operating system) end packaging project to packaging script across environments | |
| CN114816418A (en) | Method, device, equipment and medium for building embedded operating system | |
| CN114816475A (en) | Method, device, equipment and medium for updating embedded operating system | |
| CN109947407B (en) | Data acquisition method and device | |
| CN113485692A (en) | Big data componentization development method and device based on component store | |
| CN113504913B (en) | Automatic Adobe Flex code conversion method | |
| CN114866451B (en) | iOS end route communication improvement method, device, storage medium and equipment | |
| KR101670726B1 (en) | Method for code conversion using debugging information of intermediate language code, apparatus and computer-readable recording medium with program therefor | |
| CN112181432B (en) | System for realizing modular packing processing of bundle in REACTNATIVE framework | |
| WO2007144891A1 (en) | A method for the distribution of software processes to a plurality of computers |
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 | ||
| RJ01 | Rejection of invention patent application after publication | ||
| RJ01 | Rejection of invention patent application after publication |
Application publication date: 20230131 |