Method, system and device for effectively improving IOS software compiling and packaging speed and debugging efficiency, processor and storage medium

Abstract

The invention relates to a method for effectively improving IOS software compiling and packaging speed and debugging efficiency. The method comprises the following steps: generating a binary library; pushing the binary library to a remote library; performing hybrid compiling on the source code library and the binary library through the plug-in; and carrying out binary library debugging. The invention further relates to a system and device for effectively improving the IOS software compiling and packaging speed and debugging efficiency, a processor and a storage medium of the processor. According to the method, system and device for effectively improving the IOS software compiling and packaging speed and debugging efficiency, the processor and the computer readable storage medium of the processor, the method, system and device are suitable for ruby plug-ins of all ios apps, and the plug-ins support packaging single components into binary libraries; mixed compiling of a binary library and a source code library in a project is supported; a binary library is supported to debug source codes without switching; source code downloading management is supported; the method supports the dependency of an analysis component library, and is very wide in application range.

Description

Technical Field

[0001] The present invention relates to the field of app compilation, and in particular to the field of binarization, and specifically refers to a method, system, device, processor and computer-readable storage medium thereof for effectively improving IOS software compilation, packaging speed and debugging efficiency. Background Art

[0002] With the continuous development, the functions of apps are becoming more and more abundant. The rich functions bring more and more code and longer compilation and packaging time. Therefore, we hope to improve the compilation speed of apps.

[0003] Binarization means that you can pre-compile and package the component into a static / dynamic library. When integrating this component, you can directly use the binary package, thereby reducing the compilation time of the component source code and improving the overall compilation efficiency. Summary of the invention

[0004] The purpose of the present invention is to overcome the shortcomings of the above-mentioned prior art and provide a method, system, device, processor and computer-readable storage medium thereof which are simple to operate, fast to compile and have a wide range of applications for effectively improving the IOS software compilation, packaging speed and debugging efficiency.

[0005] In order to achieve the above objectives, the method, system, device, processor and computer-readable storage medium of the present invention for effectively improving the IOS software compilation and packaging speed and debugging efficiency are as follows:

[0006] The method for effectively improving the IOS software compilation, packaging speed and debugging efficiency is mainly characterized in that the method comprises the following steps:

[0007] (1) Generate binary library;

[0008] (2) Push the binary library to the remote library;

[0009] (3) Mixed compilation of source code libraries and binary libraries through plug-ins;

[0010] (4) Perform binary library debugging.

[0011] Preferably, the step (1) specifically comprises the following steps:

[0012] (1.1) Read the podspec file and create a working_directory;

[0013] (1.2) Read the parameters and build the pod file according to the parameters;

[0014] (1.3) Loop to build the framework that supports all platforms;

[0015] (1.4) Merge all frameworks into xcframework;

[0016] (1.5) Collect all resources to generate resource.bundle;

[0017] (1.6) Generate a new podfile based on the original podfile, xcframework and bundles;

[0018] (1.7) Place the new podfile, bundle, and xcframework into a folder with the same name as the component;

[0019] (1.8) Clean up the cache files in the directory.

[0020] Preferably, the step (2) specifically comprises the following steps:

[0021] (2.1) If you push to github, gitlab, bitbucket, or a remote library you built yourself, continue with step (2.2); if you push to the Jfrog platform, continue with step (2.3);

[0022] (2.2) Push the entire binary product to the remote repository, and push the podspec file to the index repository separately;

[0023] (2.3) Establish a remote repository of cocoapods type;

[0024] (2.4)Put podspec and xcframework in a folder and compress the folder.

[0025] Preferably, the step (3) specifically comprises the following steps:

[0026] (3.1) Analyze the podfile file of the project, obtain all dependencies, and obtain a list of all component libraries;

[0027] (3.2) Loop through all component libraries;

[0028] (3.3) Determine whether the binary library remote search has such a library. If so, proceed to step (3.4); otherwise, use the source code address of the library and proceed to step (3.5);

[0029] (3.4) Determine whether the library is in the whitelist. If so, use the source code address of the library and continue with step (3.5); otherwise, modify the library download address to a binary address and continue with step (3.5);

[0030] (3.5) Use multi-threaded concurrent downloading;

[0031] (3.6) Verify whether the downloaded component library is complete;

[0032] (3.7) Generate project files;

[0033] (3.8) Write dependencies into the project and compile it.

[0034] Preferably, the step (4) specifically comprises the following steps:

[0035] (4.1) Analyze dependencies according to the project's podfile and obtain the version number of the binary component to be debugged;

[0036] (4.2) Find the component in the source code address according to the version number, download the source code of the corresponding version number and store it in the specified directory;

[0037] (4.3) Analyze the binary product and use the dwarfdum command to find the compilation path of the binary product;

[0038] (4.4) Associate source code and compilation path.

[0039] The system for realizing the above method to effectively improve the IOS software compilation, packaging speed and debugging efficiency is mainly characterized in that the system comprises:

[0040] The packaging module is used to package source code components into binary components;

[0041] A push module, connected to the packaging module, is used to push the binary library, source code library or compiled product to the remote end;

[0042] A switching debugging module is connected to the push module and is used to switch between source code and binary, and debug source code and binary without compilation;

[0043] A configuration management module, connected to the switching debugging module, is used to manage configurations and cope with different configurations in different projects and environments;

[0044] The source code management module is connected to the configuration management module and is used to download the same version of the source code of the component.

[0045] The device for effectively improving the IOS software compiling and packaging speed and debugging efficiency has the following main features: the device comprises:

[0046] a processor configured to execute computer executable instructions;

[0047] The memory stores one or more computer executable instructions. When the computer executable instructions are executed by the processor, the various steps of the above-mentioned method for effectively improving the IOS software compilation, packaging speed and debugging efficiency are implemented.

[0048] The processor for effectively improving the IOS software compilation, packaging and debugging efficiency has the main feature that the processor is configured to execute computer-executable instructions. When the computer-executable instructions are executed by the processor, the various steps of the above-mentioned method for effectively improving the IOS software compilation, packaging and debugging efficiency are implemented.

[0049] The main feature of the computer-readable storage medium is that a computer program is stored thereon, and the computer program can be executed by a processor to implement the various steps of the above-mentioned method for effectively improving the IOS software compilation, packaging speed and debugging efficiency.

[0050] The method, system, device, processor and computer-readable storage medium of the present invention are used to effectively improve the IOS software compilation and packaging speed and debugging efficiency. The plug-in is applicable to all ios app ruby ​​plug-ins. The plug-in supports packaging a single component into a binary library; supports mixed compilation of binary libraries and source code libraries in one project; supports debugging source code without switching between binary libraries; supports source code download management; supports analysis of component library dependencies, and has a wide range of applications. BRIEF DESCRIPTION OF THE DRAWINGS

[0051] Figure 1 The present invention is a schematic diagram of the structure of a system for effectively improving the IOS software compilation, packaging speed and debugging efficiency.

[0052] Figure 2 The present invention is a flowchart of a method for effectively improving IOS software compilation, packaging speed and debugging efficiency.

[0053] Figure 3 The present invention provides a flowchart for generating a binary library for a method of effectively improving IOS software compiling, packaging and debugging efficiency.

[0054] Figure 4 The present invention provides a flow chart of a method for implementing a mixed compilation of source code libraries and binary libraries through a plug-in to effectively improve the IOS software compilation, packaging speed and debugging efficiency. DETAILED DESCRIPTION

[0055] In order to more clearly describe the technical content of the present invention, further description is given below in conjunction with specific embodiments.

[0056] The method of the present invention effectively improves the IOS software compilation and packaging speed and debugging efficiency, including the following steps:

[0057] (1) Generate binary library;

[0058] (2) Push the binary library to the remote library;

[0059] (3) Mixed compilation of source code libraries and binary libraries through plug-ins;

[0060] (4) Perform binary library debugging.

[0061] As a preferred embodiment of the present invention, the step (1) specifically comprises the following steps:

[0062] (1.1) Read the podspec file and create a working_directory;

[0063] (1.2) Read the parameters and build the pod file according to the parameters;

[0064] (1.3) Loop to build the framework that supports all platforms;

[0065] (1.4) Merge all frameworks into xcframework;

[0066] (1.5) Collect all resources to generate resource.bundle;

[0067] (1.6) Generate a new podfile based on the original podfile, xcframework and bundles;

[0068] (1.7) Place the new podfile, bundle, and xcframework into a folder with the same name as the component;

[0069] (1.8) Clean up the cache files in the directory.

[0070] As a preferred embodiment of the present invention, the step (2) specifically comprises the following steps:

[0071] (2.1) If you push to github, gitlab, bitbucket, or a remote library you built yourself, continue with step (2.2); if you push to the Jfrog platform, continue with step (2.3);

[0072] (2.2) Push the entire binary product to the remote repository, and push the podspec file to the index repository separately;

[0073] (2.3) Establish a remote repository of cocoapods type;

[0074] (2.4)Put podspec and xcframework in a folder and compress the folder.

[0075] As a preferred embodiment of the present invention, the step (3) specifically comprises the following steps:

[0076] (3.1) Analyze the podfile file of the project, obtain all dependencies, and obtain a list of all component libraries;

[0077] (3.2) Loop through all component libraries;

[0078] (3.3) Determine whether the binary library remote search has such a library. If so, proceed to step (3.4); otherwise, use the source code address of the library and proceed to step (3.5);

[0079] (3.4) Determine whether the library is in the whitelist. If so, use the source code address of the library and continue with step (3.5); otherwise, modify the library download address to a binary address and continue with step (3.5);

[0080] (3.5) Use multi-threaded concurrent downloading;

[0081] (3.6) Verify whether the downloaded component library is complete;

[0082] (3.7) Generate project files;

[0083] (3.8) Write dependencies into the project and compile it.

[0084] As a preferred embodiment of the present invention, the step (4) specifically comprises the following steps:

[0085] (4.1) Analyze dependencies according to the project's podfile and obtain the version number of the binary component to be debugged;

[0086] (4.2) Find the component in the source code address according to the version number, download the source code of the corresponding version number and store it in the specified directory;

[0087] (4.3) Analyze the binary product and use the dwarfdum command to find the compilation path of the binary product;

[0088] (4.4) Associate source code and compilation path.

[0089] The system of the present invention that implements the above method to effectively improve the IOS software compilation, packaging speed and debugging efficiency, wherein the system comprises:

[0090] The packaging module is used to package source code components into binary components;

[0091] A push module, connected to the packaging module, is used to push the binary library, source code library or compiled product to the remote end;

[0092] A switching debugging module is connected to the push module and is used to switch between source code and binary, and debug source code and binary without compilation;

[0093] A configuration management module, connected to the switching debugging module, is used to manage configurations and cope with different configurations in different projects and environments;

[0094] The source code management module is connected to the configuration management module and is used to download the same version of the source code of the component.

[0095] The device of the present invention is used to effectively improve the IOS software compilation, packaging speed and debugging efficiency, wherein the device comprises:

[0096] a processor configured to execute computer executable instructions;

[0097] The memory stores one or more computer executable instructions. When the computer executable instructions are executed by the processor, the various steps of the above-mentioned method for effectively improving the IOS software compilation, packaging speed and debugging efficiency are implemented.

[0098] The processor of the present invention is used to effectively improve the IOS software compilation, packaging and debugging efficiency, wherein the processor is configured to execute computer executable instructions. When the computer executable instructions are executed by the processor, the various steps of the above-mentioned method for effectively improving the IOS software compilation, packaging and debugging efficiency are implemented.

[0099] The computer-readable storage medium of the present invention stores a computer program thereon, and the computer program can be executed by a processor to implement the various steps of the above-mentioned method for effectively improving the IOS software compilation, packaging speed and debugging efficiency.

[0100] In the specific implementation of the present invention, the technical solution includes the following modules:

[0101] The packaging module is used to package source code components into binary components;

[0102] Push module, used to push binary libraries, source code libraries, compiled products, etc. to the remote end;

[0103] Switch debugging module, used for switching between source code and binary, and debugging of source code and binary without compilation;

[0104] Configuration management module, used to manage configurations and deal with different configurations in different projects and environments;

[0105] The source code management module is used to download the same version of the source code of the component, and can view, delete, etc.

[0106] The specific steps of this technical solution are as follows:

[0107] (1) Generate binary library:

[0108] It is used to package the component source code library into a binary library, supporting both local code packaging and remote code packaging.

[0109] The principle is to generate a binary library with the same version as the one in the podspec file of each source code library.

[0110] Implementation:

[0111] (1.1) According to the podspec file of the component library, pull the source code of the same version as the version in the podspec.

[0112] (1.2) Provide build parameters, such as whether to build static libraries or dynamic libraries, local packaging or remote packaging, whether to include subspec, whether to package Release or Debug version, etc., and generate the corresponding Xcode project according to the parameters.

[0113] (1.3) Determine the supported platforms based on the podspec file, loop all platforms, execute the xcodebuild command in sequence, and generate a framework that supports each platform.

[0114] (1.4) Package all resource files in the component library to generate resource.bundle.

[0115] (1.5)Merge the frameworks of all platforms, then merge resource.bundle to generate xcframework.

[0116] (1.6) Modify the configuration items in the original podspec according to the path of the newly generated product and generate a podspec file for the binary library.

[0117] (1.7)The podspec file and the xcframework library together constitute the final product.

[0118] The entire packaging process does not need to be associated with the git repository, and the packaged product can be used directly locally.

[0119] The specific applications are as follows:

[0120] 1. Switch to the directory containing the component library podspec;

[0121] 2. Run the plug-in command to complete the packaging:

[0122] Pod bin xcframework*.podspec --spec-sources=*--subspecs=*-force=*--configuration=*--enable-bitcode=*--local.

[0123] (2) Pushing of binary libraries:

[0124] The function is to push the binary library to a remote library, which supports pushing to git, bitbucket, or self-built remote libraries or Jfrog platform

[0125] The principle is to adopt a dual private source single version solution, that is, for the same component library, its tag has both a binary library and a source code library. The binary library is stored in a remote library, and the source code library is stored in another remote library.

[0126] Implementation:

[0127] (2.1) If you are pushing to github, gitlab, bitbucket, or a remote repository you built yourself, push the entire binary product to the remote repository. Then push the podspec file separately to the index repository.

[0128] (2.2) If you push to the Jfrog platform, you need to create a remote repository of the cocoapods type first;

[0129] (2.3) Then put podspec and xcframework in a folder and compress the folder.

[0130] The plugin encapsulates the curl command and passes in the frog repository name, directory level, binary compressed package, etc. as parameters. Jfrog's cocoapods-type repository will automatically parse the podspec file and automatically build an index library. It does not need to manually build an index library and then push the podspec like a git repository or a self-built repository, which saves these steps.

[0131] The specific applications are as follows:

[0132] Completed with one command: pod bin repo push <repo-name> <binaryfolder>.

[0133] (3) Mixed compilation of binary libraries and source code libraries:

[0134] In order not to affect components that are not connected to the binary library, the plug-in supports mixed compilation of source code libraries and binary libraries. A project may have both binary libraries and source code libraries, and the binary libraries and source code libraries are stored in different sources. One command pulls the binary library and source code library to the local for compilation.

[0135] The principle is to encapsulate the commands for pulling source code libraries and binary libraries in the plug-in at the same time. In the underlying implementation of cocoapods, the download is replaced according to the configuration file.

[0136] Implementation:

[0137] For iOS apps that use cocoapods to manage components, you need to execute commands such as podinstall or pod update to re-pull the components every time the components change.

[0138] (3.1) Distinguish which libraries are pulled binary libraries and which libraries are pulled source code libraries. The plug-in will distinguish the codes internally and also supports directly providing a source code whitelist list.

[0139] (3.2) Get a list of all component libraries that the project depends on: Analyze the project's podfile file and get all dependencies.

[0140] (3.3) Get the address of the source code library and the address of the binary library: support reading directly from the project's podfile file, and also support not writing it in the podfile but writing it in another configuration file.

[0141] The plugin provides a self-named configuration file, in which you can configure whether the project is debug or release, configure the source code library address, configure the binary library address, etc.

[0142] (3.4) Replace the download address: Search according to the priority principle of using the source code library when there is no binary library and using the binary library first when there is a binary library. The plug-in provides a use_source_pod whitelist list. If you add components to the list, the source code will still be used even if there is a binary library.

[0143] First, traverse the component library list in the remote library of the binary library. If the corresponding library can be found, check whether the library is added to the whitelist of use_sourceys_pod. If it is not added to the whitelist, the plug-in will replace the download address of the library with the address in the binary remote library. If the component is not found in the binary remote library, it will not be replaced.

[0144] (3.5) Download library: The plug-in supports multi-threaded concurrent download of component libraries. The source code library and binary library share a thread pool. Multi-threaded operation improves the download speed of components.

[0145] The specific applications are as follows:

[0146] 1. Each project has a built-in configuration file podfile, and the plug-in is introduced in the podfile;

[0147] 2. Specify the addresses of the binary library and source library in podfile;

[0148] 3. If a component library already has a binary library but you don’t want to use it, configure set_use_sources_pod provided in the plug-in and fill in the component source code whitelist library list.

[0149] 4. One command starts pod bin install.

[0150] (4) Binary library debugging / source code debugging:

[0151] The purpose is to increase the speed of binary compilation, but debugging becomes very difficult. For components that use binary libraries, if you debug at breakpoints, all of them are assembly code. In order to see the source code during debugging. The general practice is to modify the binary component whitelist, then re-update and pull the source code component library, and then recompile. This is time-consuming and troublesome. This solution hopes to implement source code debugging of binary libraries during compilation and operation, without modifying the configuration or recompiling during the whole process.

[0152] The principle is that when Xcode compiles the binary of the Debug version, a field in the binary stores the file address of the source code corresponding to the binary. When you set a breakpoint in Xcode for debugging, Xcode will open the corresponding source code file according to the source code file address stored in this field in the binary and display the source code file on the UI. Therefore, the binary is replaced with the source code library in the binary compilation address to achieve this.

[0153] Implementation:

[0154] (4.1) Analyze dependencies according to the project's podfile and obtain the version number of the binary component to be debugged;

[0155] (4.2) According to the version number, find the component at the source code address, download the source code of the corresponding version number, and store it in the specified directory after downloading;

[0156] (4.3) Analyze the binary product and use the dwarfdum command to find the compilation path of the binary product. This compilation path is the path that the Xcode system will look for when the breakpoint occurs;

[0157] (4.4) Associate the source code with the compilation path. You can directly put the source code into this compilation path, or use the ln -s soft link command to link the source code with this compilation path;

[0158] (4.5) After the link is successful, when Xcode searches this directory during a breakpoint, you can enter the source code to view it.

[0159] During the project compilation and operation, you can complete the link with one command at any time to realize the source code debugging of the binary library. There is no need to modify the configuration during the whole process. Switch the binary library back to the source code library and then compile and run again.

[0160] The specific applications are as follows:

[0161] In the project directory, one line of command can be completed: pod bin source code <podname>.

[0162] This technical solution also supports the configuration of a whitelist, but also provides a better way, which can automatically achieve "use binary when binary is available, and use source code when binary is not available" without the user providing a whitelist.

[0163] This technical solution also supports multiple environments and multiple configurations:

[0164] The plugin is suitable for all iOS apps that use cocoapods to manage components. However, there are certainly many differences between different companies, different projects, and different projects. Even different developers in the same project may have different needs. Based on this, the plugin supports multiple sets of configurations. It supports different configuration files in different environments. In the project directory, you can specify the configuration you need when executing podbin init. In the configuration file, there are three default configurations: compilation environment configuration, source code private source, and binary private source. All possible differences are supported.

[0165] This solution also supports self-built libraries, but we also support uploading to JFrog Artifactory.

[0166] The specific steps are as follows:

[0167] First, create a remote repository of the cocoapods type;

[0168] Put podspec and xcframework in a folder and compress the folder;

[0169] The plugin encapsulates the curl command and passes in the frog repository name, directory level, binary compressed package, etc. as parameters. Jfrog's cocoapods-type repository will automatically parse the podspec file and automatically build an index library. It does not need to manually build an index library and then push the podspec like a git repository or a self-built repository, which saves these steps.

[0170] The specific implementation scheme of this embodiment can refer to the relevant description in the above embodiment, which will not be repeated here.

[0171] It can be understood that the same or similar parts of the above embodiments can be referenced to each other, and the contents not described in detail in some embodiments can refer to the same or similar contents in other embodiments.

[0172] It should be noted that, in the description of the present invention, the terms "first", "second", etc. are only used for descriptive purposes and cannot be understood as indicating or implying relative importance. In addition, in the description of the present invention, unless otherwise specified, the meaning of "plurality" refers to at least two.

[0173] Any process or method description in a flowchart or otherwise described herein may be understood to represent a module, segment or portion of code that includes one or more executable instructions for implementing the steps of a specific logical function or process, and the scope of the preferred embodiments of the present invention includes alternative implementations in which functions may not be performed in the order shown or discussed, including performing functions in a substantially simultaneous manner or in the reverse order depending on the functions involved, which should be understood by those skilled in the art to which the embodiments of the present invention belong.

[0174] It should be understood that the various parts of the present invention can be implemented by hardware, software, firmware or a combination thereof. In the above-mentioned embodiments, a plurality of steps or methods can be implemented by software or firmware stored in a memory and executed by a suitable instruction execution device. For example, if implemented by hardware, as in another embodiment, it can be implemented by any one of the following technologies known in the art or their combination: a discrete logic circuit having a logic gate circuit for implementing a logic function for a data signal, a dedicated integrated circuit having a suitable combination of logic gate circuits, a programmable gate array (PGA), a field programmable gate array (FPGA), etc.

[0175] A person skilled in the art may understand that all or part of the steps in the method for implementing the above-mentioned embodiment may be completed by instructing related hardware through a program, and the corresponding program may be stored in a computer-readable storage medium, which, when executed, includes one of the steps of the method embodiment or a combination thereof.

[0176] In addition, each functional unit in each embodiment of the present invention may be integrated into a processing module, or each unit may exist physically separately, or two or more units may be integrated into one module. The above-mentioned integrated module may be implemented in the form of hardware or in the form of a software functional module. If the integrated module is implemented in the form of a software functional module and sold or used as an independent product, it may also be stored in a computer-readable storage medium.

[0177] The storage medium mentioned above can be a read-only memory, a magnetic disk or an optical disk, etc.

[0178] In the description of this specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" means that the specific features, structures, materials or characteristics described in conjunction with the embodiment or example are included in at least one embodiment or example of the present invention. In this specification, the schematic representation of the above terms does not necessarily refer to the same embodiment or example. Moreover, the specific features, structures, materials or characteristics described can be combined in any one or more embodiments or examples in a suitable manner.

[0179] The method, system, device, processor and computer-readable storage medium of the present invention are used to effectively improve the IOS software compilation and packaging speed and debugging efficiency. The plug-in is applicable to all ios app ruby ​​plug-ins. The plug-in supports packaging a single component into a binary library; supports mixed compilation of binary libraries and source code libraries in one project; supports debugging source code without switching between binary libraries; supports source code download management; supports analysis of component library dependencies, and has a wide range of applications.

[0180] In this specification, the present invention has been described with reference to specific embodiments thereof. However, it is apparent that various modifications and variations may be made without departing from the spirit and scope of the present invention. Therefore, the specification and drawings should be regarded as illustrative rather than restrictive.< / podname> < / binaryfolder> < / repo-name>

Claims

1. A method for effectively improving the speed of IOS software compilation, packaging and debugging, characterized in that: The method comprises the following steps: (1) Generate binary library; (2) Push the binary library to the remote library; (3) Mixed compilation of source code libraries and binary libraries through plug-ins; (4) Perform binary library debugging.

2. The method for effectively improving the IOS software compiling, packaging and debugging efficiency according to claim 1, characterized in that: The step (1) specifically comprises the following steps: (1.1) Read the podspec file and create a working_directory; (1.2) Read the parameters and build the pod file according to the parameters; (1.3) Loop to build the framework that supports all platforms; (1.4) Merge all frameworks into xcframework; (1.5) Collect all resources to generate resource.bundle; (1.6) Generate a new podfile based on the original podfile, xcframework and bundles; (1.7) Place the new podfile, bundle, and xcframework into a folder with the same name as the component; (1.8) Clean up the cache files in the directory.

3. The method for effectively improving IOS software compiling, packaging and debugging efficiency according to claim 1, characterized in that: The step (2) specifically comprises the following steps: (2.1) If you push to github, gitlab, bitbucket, or a remote library you built yourself, continue with step (2.2); if you push to the Jfrog platform, continue with step (2.3); (2.2) Push the entire binary product to the remote repository, and push the podspec file to the index repository separately; (2.3) Establish a remote repository of cocoapods type; (2.4)Put podspec and xcframework in a folder and compress the folder.

4. The method for effectively improving IOS software compiling, packaging and debugging efficiency according to claim 1, characterized in that: The step (3) specifically comprises the following steps: (3.1) Analyze the podfile file of the project, obtain all dependencies, and obtain a list of all component libraries; (3.2) Loop through all component libraries; (3.3) Determine whether the binary library remote search has such a library. If so, proceed to step (3.4); otherwise, use the source code address of the library and proceed to step (3.5); (3.4) Determine whether the library is in the whitelist. If so, use the source code address of the library and continue with step (3.5); otherwise, modify the library download address to a binary address and continue with step (3.5); (3.5) Use multi-threaded concurrent downloading; (3.6) Verify whether the downloaded component library is complete; (3.7) Generate project files; (3.8) Write dependencies into the project and compile it.

5. The method for effectively improving IOS software compiling, packaging and debugging efficiency according to claim 1, characterized in that: The step (4) specifically comprises the following steps: (4.1) Analyze dependencies according to the project's podfile and obtain the version number of the binary component to be debugged; (4.2) Find the component in the source code address according to the version number, download the source code of the corresponding version number and store it in the specified directory; (4.3) Analyze the binary product and use the dwarfdum command to find the compilation path of the binary product; (4.4) Associate source code and compilation path.

6. A system for implementing the method of claim 1 to effectively improve IOS software compilation, packaging and debugging efficiency, characterized in that: The system comprises: The packaging module is used to package source code components into binary components; A push module, connected to the packaging module, is used to push the binary library, source code library or compiled product to the remote end; A switching debugging module is connected to the push module and is used to switch between source code and binary, and debug source code and binary without compilation; A configuration management module, connected to the switching debugging module, is used to manage configurations and cope with different configurations in different projects and environments; The source code management module is connected to the configuration management module and is used to download the same version of the source code of the component.

7. A device for effectively improving the speed of IOS software compilation, packaging and debugging, characterized in that: The device comprises: a processor configured to execute computer executable instructions; A memory storing one or more computer executable instructions, which, when executed by the processor, implements the steps of the method for effectively improving the IOS software compilation, packaging speed and debugging efficiency as described in any one of claims 1 to 5.

8. A processor for effectively improving the speed of IOS software compilation, packaging and debugging, characterized in that: The processor is configured to execute computer executable instructions. When the computer executable instructions are executed by the processor, the steps of the method for effectively improving the IOS software compilation, packaging speed and debugging efficiency as described in any one of claims 1 to 5 are implemented.

9. A computer-readable storage medium, characterized in that: A computer program is stored thereon, and the computer program can be executed by a processor to implement the various steps of the method for effectively improving the IOS software compilation, packaging speed and debugging efficiency as described in any one of claims 1 to 5.

Images