Method and apparatus for constructing project development space required for an iOS application

Abstract

This invention discloses a method and apparatus for constructing a project development space required for iOS applications, relating to the field of mobile internet technology. One specific embodiment of the method includes: acquiring and displaying application parameters required for the project development space visually; adding the application parameters to one or more scripts according to a pre-determined parameter addition strategy; driving one or more scripts to integrate the project base template and project components associated with the application parameters into project data for the iOS system application; generating a project development space based on the project data; and binding the project data to the project development space, enabling application developers to improve the business function development of the iOS system application based on the project development space. By constructing the project development space with a single click through a customizable visual method, the efficiency of iOS application development is improved, and the manpower and time costs of iOS application development are reduced.

Description

Technical Field

[0001] This invention relates to the field of mobile internet technology, and in particular to a method and apparatus for constructing a project development space required for iOS applications. Background Technology

[0002] In iOS application development, it's typically necessary to create a raw project space within the development tools, and then add business logic based on that raw project space. Generally, the raw project space can contain basic project information for the application or basic components related to the application, such as third-party libraries for handling network requests, images, databases, user interfaces, etc.

[0003] Currently, the method for building the original project space usually involves developers configuring the application information contained in the original project space and manually driving commands to obtain basic components. This involves many manual steps, resulting in low efficiency in building the original project space, wasting manpower and time, and affecting the efficiency of application development. Summary of the Invention

[0004] In view of this, embodiments of the present invention provide a method and apparatus for constructing a project development space required for an iOS application. This method and apparatus can visually acquire and display the application parameters required for the project development space. According to a pre-determined parameter addition strategy, the application parameters are added to one or more scripts. One or more scripts are then driven to integrate the project base template and project components associated with the application parameters into the application's project data for the iOS system. Based on the project data, a project development space is generated, and the project data is bound to the project development space, enabling application developers to improve the business functionality development of the iOS system application based on the project development space. By constructing the project development space with a single click using a customizable visual method, the efficiency of iOS application development is improved, and the manpower and time costs of iOS application development are reduced.

[0005] To achieve the above objectives, according to one aspect of the present invention, a method for constructing a project development space required for an iOS application is provided, characterized by comprising: in response to generating a project development space required for developing an iOS system application, acquiring and displaying application parameters required for the project development space in a visual manner; adding the application parameters to one or more scripts according to a predetermined parameter addition strategy; driving one or more of the scripts to integrate the project base template and project components associated with the application parameters into project data for the iOS system application, generating a project development space based on the project data, and binding the project data to the project development space, so that the application developer can improve the business function development of the iOS system application based on the project development space.

[0006] Optionally, the step of obtaining and displaying the application parameters required for the project development space through visualization includes: displaying an editable page with multiple editable items through visualization, and receiving application parameters input or selected by the application developer through each editable item that have not appeared in other editable items; wherein the application parameters include any one or more of project information, project basic template identifier, and project component identifier.

[0007] Optionally, the method for constructing the project development space required by the iOS application further includes: visually displaying multiple custom component identifiers corresponding to one or more of the editable items; receiving application parameters selected by the application developer that have not appeared in other editable items through each of the editable items includes: receiving the application developer's selection operation on any one or more unselected custom component identifiers corresponding to any of the editable items, and obtaining and displaying the application parameters of the custom component identifiers targeted by the selection operation.

[0008] Optionally, the step of integrating the project components associated with the application parameters into the project data of an iOS system application includes: for the case where the project component is the project component corresponding to the custom component identifier, obtaining a preset module configuration file, wherein the preset module configuration file is configured with one or more general component identifiers; adding one or more custom component identifiers selected by the editable items to the preset module configuration file through a first script; and reading the general component identifiers and custom component identifiers in the module configuration file through a second script, and using instructions to pull the general components corresponding to the general component identifiers and the custom components corresponding to the custom component identifiers into the project data.

[0009] Optionally, driving one or more scripts to integrate the project base template associated with the application parameters into the application's project data for the iOS system includes: when the application parameters include a project base template identifier, determining the code repository indicated by the project base template identifier, and driving a third script to pull the project base code corresponding to the project base template identifier from the code repository; and integrating the project base code into the project data.

[0010] Optionally, the step of driving one or more scripts to integrate the project base template associated with the application parameters into the project data of the iOS system application further includes: when the application parameters contain multiple application version types, wherein each application version type indicates a test version or a release version; using the third script to obtain the multiple application version types; for each obtained application version type, performing the following: adding the version configuration information of the application version type to the project base code, and integrating the project base code with the added version configuration information into the project data.

[0011] Optionally, if the application has multiple application version types, for any one of the application version types, the following steps are performed: based on the project development space corresponding to the application and the code corresponding to the application version type, a matching target version is generated for the application version type.

[0012] Optionally, adding the application parameters to one or more scripts according to a predetermined parameter addition strategy includes: reading the script corresponding to the script identifier using a preset first calling interface and a script identifier; obtaining one or more application parameters associated with the script; and adding one or more application parameters to the script using a preset second calling interface, so that the script performs operations associated with one or more application parameters.

[0013] Optionally, one or more of the scripts contain tool instructions for one or more preset tools; driving one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the application in the iOS system includes: using the script to detect whether one or more preset tools have been installed, and if so, using the tool instructions of one or more preset tools contained in the script to execute the step of integrating the project base template and project components associated with the application parameters into the project data of the application in the iOS system.

[0014] To achieve the above objectives, according to a second aspect of the present invention, an apparatus for building a project development space required for an iOS application is provided, characterized in that it includes: a parameter acquisition module, a configuration script module, and a space building module; wherein,

[0015] The parameter acquisition module is used to obtain and display the application parameters required for the project development space in a visual manner in response to generating the project development space required for developing iOS system applications.

[0016] The configuration script module is used to add the application parameters to one or more scripts according to a pre-determined parameter addition strategy;

[0017] The construction space module is used to drive one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the iOS system application, and generate a project development space based on the project data, and bind the project data to the project development space so that the application developer can improve the business function development of the iOS system application based on the project development space.

[0018] Optionally, the parameter acquisition module acquires and displays the application parameters required by the project development space in a visual manner, including: displaying an editable page with multiple editable items in a visual manner, and receiving application parameters input or selected by the application developer through each editable item that have not appeared in other editable items; wherein the application parameters include any one or more of project information, project basic template identifier, and project component identifier.

[0019] Optionally, the parameter acquisition module is further configured to display, in a visual manner, multiple custom component identifiers corresponding to one or more of the editable items; the step of receiving application parameters selected by the application developer for each editable item that have not appeared in other editable items includes: receiving the application developer's selection operation for any one or more unselected custom component identifiers corresponding to any editable item, and acquiring and displaying the application parameters of the custom component identifiers targeted by the selection operation.

[0020] Optionally, the step of integrating the project components associated with the application parameters into the project data of an iOS system application includes: for the case where the project component is the project component corresponding to the custom component identifier, obtaining a preset module configuration file, wherein the preset module configuration file is configured with one or more general component identifiers; adding one or more custom component identifiers selected by the editable items to the preset module configuration file through a first script; and reading the general component identifiers and custom component identifiers in the module configuration file through a second script, and using instructions to pull the general components corresponding to the general component identifiers and the custom components corresponding to the custom component identifiers into the project data.

[0021] Optionally, the construction space module drives one or more scripts to integrate the project base template associated with the application parameters into the project data of the iOS system application, including: when the application parameters include a project base template identifier, determining the code library indicated by the project base template identifier, and driving a third script to pull the project base code corresponding to the project base template identifier from the code library; and integrating the project base code into the project data.

[0022] Optionally, the construction space module drives one or more scripts to integrate the project base template associated with the application parameters into the project data of the iOS system application, further including: when the application parameters contain multiple application version types, wherein each application version type indicates a test version or a release version; using the third script to obtain the multiple application version types; for each obtained application version type, performing the following: adding the version configuration information of the application version type to the project base code, and integrating the project base code with the added version configuration information into the project data.

[0023] Optionally, if the application has multiple application version types, the building space module performs the following for any one of the application version types: based on the project development space corresponding to the application and the code corresponding to the application version type, generate a matching target version for the application version type.

[0024] Optionally, the configuration script module adds the application parameters to one or more scripts according to a predetermined parameter addition strategy, including: reading the script corresponding to the script identifier using a preset first calling interface and a script identifier; obtaining one or more application parameters associated with the script, and adding one or more application parameters to the script using a preset second calling interface, so that the script performs operations associated with one or more application parameters.

[0025] Optionally, the construction space module includes tool instructions of one or more preset tools included in the script; driving one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the application in the iOS system includes: using the script to detect whether one or more preset tools have been installed, and if so, using the tool instructions of one or more preset tools included in the script to execute the step of integrating the project base template and project components associated with the application parameters into the project data of the application in the iOS system.

[0026] To achieve the above objectives, according to a third aspect of the present invention, an electronic device for building a project development space required for an iOS application is provided, characterized in that it includes: one or more processors; and a storage device for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement any of the methods described above for building a project development space required for an iOS application.

[0027] To achieve the above objectives, according to a fourth aspect of the present invention, a computer-readable medium is provided having a computer program stored thereon, characterized in that, when the program is executed by a processor, it implements any of the methods described above for constructing a project development space required for an iOS application.

[0028] To achieve the above objectives, according to a fifth aspect of the present invention, a computer program product is provided, comprising a computer program, characterized in that, when the program is executed by a processor, it implements any of the methods described above for constructing a project development space required for an iOS application.

[0029] One embodiment of the above invention has the following advantages or beneficial effects: it can obtain and display the application parameters required for the project development space in a visual manner; according to a predetermined parameter addition strategy, it adds the application parameters to one or more scripts; it drives one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the iOS system application, and generates the project development space based on the project data, binding the project data to the project development space, so that the application developer can improve the business function development of the iOS system application based on the project development space. By building the project development space with a single click in a custom visual manner, the efficiency of iOS application development is improved, and the manpower and time costs of iOS application development are reduced.

[0030] The further effects of the aforementioned unconventional alternative methods will be explained below in conjunction with specific implementation methods. Attached Figure Description

[0031] The accompanying drawings are provided to better understand the invention and are not intended to unduly limit the scope of the invention. Wherein:

[0032] Figure 1 This is a flowchart illustrating a method for constructing a project development space required for an iOS application, according to an embodiment of the present invention.

[0033] Figure 2 This is a schematic diagram illustrating the process of constructing a project development space required for an iOS application, according to an embodiment of the present invention.

[0034] Figure 3 This is a schematic diagram of a process for constructing a project development space using a visual plugin, provided by an embodiment of the present invention;

[0035] Figure 4 This is a schematic diagram of the structure of a device for building a project development space required for an iOS application, provided in one embodiment of the present invention;

[0036] Figure 5This is an exemplary system architecture diagram in which embodiments of the present invention can be applied;

[0037] Figure 6 This is a schematic diagram of the structure of a computer system suitable for implementing terminal devices or servers of the present invention. Detailed Implementation

[0038] The following description, in conjunction with the accompanying drawings, illustrates exemplary embodiments of the present invention, including various details to aid understanding. These details should be considered merely exemplary. Therefore, those skilled in the art will recognize that various changes and modifications can be made to the embodiments described herein without departing from the scope and spirit of the invention. Similarly, for clarity and brevity, descriptions of well-known functions and structures are omitted in the following description.

[0039] In existing iOS application development projects, CocoaPods can be used to manage the integration of common components (such as third-party libraries) and custom components. However, current methods require developers to manually write configuration information (e.g., dependencies between components) in the Podfile. Furthermore, the integration of basic functionalities, utility classes, common resource files, and the basic project framework is also handled manually. Typically, when creating a new project development space (.xcworkspace) using Xcode, manual operations are performed on a single project, target, and scheme. Generating the .xcworkspace using `pod install` or `pod update` also requires manual execution. In some application scenarios, project development can differentiate between test and production environments using multiple targets, each with its own scheme configuration; existing target creation methods also require manual handling. Therefore, it's clear that the current methods for building project development spaces (.xcworkspaces) involve multiple steps and operations that developers must perform manually, resulting in low efficiency and wasted manpower and time.

[0040] In view of this, such as Figure 1 As shown, this embodiment of the invention provides a method for constructing a project development space required for an iOS application, which may include the following steps:

[0041] Step S101: In response to generating the project development space required for developing applications for the iOS system, the application parameters required for the project development space are obtained and displayed in a visual manner.

[0042] Specifically, one embodiment of the present invention is to automatically build the project development space required for developing iOS applications through a visualization plugin, including obtaining and displaying the application parameters required for the project development space in a visualization manner, which greatly improves the efficiency of building the project development space, thereby improving the efficiency of developing iOS applications.

[0043] The visualization plugin provides the ability to automatically build project development spaces for user pages and business logic implementation.

[0044] Furthermore, the visualization plugin provides a user interface that allows application developers (i.e., the party using the visualization plugin) to input (edit information or select options, etc.) the required application parameters through the user interface; that is, to obtain and display the application parameters required for the project development space in a visual manner; wherein, the application parameters include any one or more of the following: project information (e.g., project name: projName, project identifier bundle id: bundleId, development language: language, project file directory: projPath, organization name: orgName, organization identifier: orgIdName, etc.), project basic template identifier (e.g., the git repository address corresponding to the project basic template: templateGitRepoUrl), and project component identifier (e.g., custom component string name: moduleNamesStr, general component identifier, e.g., the name corresponding to a third-party library: openModuleNames, the third-party library name string: openModuleNamesStr, etc.).

[0045] Furthermore, application developers can directly input project information (e.g., project name: projName, etc.) through text boxes (editable items) provided on the editable page, or allow selection from a list of component identifiers (editable items) provided on the editable page. This invention does not prioritize input based on the editable page. That is, the process of visually acquiring and displaying the application parameters required for the project development space includes: visually displaying an editable page with multiple editable items, and receiving application parameters input or selected by the application developer that have not appeared in other editable items through each editable item; wherein the application parameters include project information, project basic template identifiers, and project component identifiers, any one or more of these. The editable options can be related; for example, for multiple component identifiers displayed on the visual page, selected (checked) component identifiers can be set to a "non-editable" state (e.g., graying out the option), i.e., selected application parameters that have not appeared in other editable items.

[0046] Furthermore, for custom components, multiple custom component identifiers corresponding to one or more editable items are displayed visually. The step of receiving application parameters selected by the application developer for each editable item that have not appeared in other editable items includes: receiving the application developer's selection operation for any one or more unselected custom component identifiers corresponding to any editable item, and obtaining and displaying the application parameters of the custom component identifier targeted by the selection operation. Custom components can be components customized by the application developer according to the application's functional requirements, such as routing components, message bus components, network service components, screen adaptation components, etc. This invention does not limit the specific content of general components and custom components. Preferably, the page can display the relationships (e.g., dependencies) between multiple custom components, allowing the application developer to determine these relationships through the page. Therefore, in addition to selecting the custom components required for business needs, the developer can also select multiple components based on their relationships. Thus, by displaying multiple custom component identifiers on the page, the application developer can select the required custom components without manually configuring the identifiers, relationships, and other information of the custom components in the podfile configuration file. This improves the development efficiency of iOS applications. That is, a preset module configuration file is obtained, wherein the preset module configuration file is configured with one or more general component identifiers; and one or more custom component identifiers selected by the editable items are added to the preset module configuration file using a first script. The preset module configuration file can be a podfile included in the Cocoapods tool. The first script (e.g., a Ruby or Shell script) adds the component identifiers selected by the application developer obtained from the visualization page to the podfile. It is understood that the podfile can be used to configure general component identifiers, custom component identifiers, and / or the relationships between component identifiers, thereby further using the information configured in the podfile to obtain the components corresponding to the component identifiers using the Cocoapods tool.

[0047] Step S102: Add the application parameters to one or more scripts according to the predetermined parameter addition strategy.

[0048] Specifically, according to the description of step S101, various application parameters are obtained through visualization. Further, using a visualization plugin as an example, the obtained application parameters are added to one or more scripts. These scripts are used to perform various operations such as subsequent component integration and building project development spaces. The scripts can be written in Ruby (an object-oriented programming scripting language) or shell scripting.

[0049] In one embodiment of the present invention, according to a predetermined parameter addition strategy, the application parameters are added to one or more scripts, including: reading the script corresponding to the script identifier using a preset first calling interface and a script identifier; obtaining one or more application parameters associated with the script, and adding one or more application parameters to the script using a preset second calling interface, so that the script performs operations associated with one or more application parameters. The preset first calling interface can be: Bundle.main.path(forResource:"script identifier",ofType:"rb"); ofType:"rb" indicates that the script type is a Ruby script; that is, the script corresponding to the script identifier is read using the preset first calling interface and the script identifier; furthermore, one or more application parameters can be added to the script using async (i.e., the preset second calling interface); for example, async contains the following information, where multiple required application parameters can be passed in via arguments:[String] and added to the script.

[0050] static func async(envPath:String?=nil,scriptPath:String,arguments:[String]?=nil,...){DispatchQueue.global().async}

[0051] In one embodiment of the present invention, the visualization plugin is divided into two parts: a user page as described in step S101, and a business logic part. The business logic part can use the Process class to pass in the environment variables and parameters required for the business functions of the visualization plugin, thereby executing shell or Ruby scripts. Preferably, a script containing multiple functions is pre-written and added to the project data (e.g., the project data can be a preset file directory). The script is read using the Bundle.main.path(forResource:"script identifier",ofType:"rb") method. After reading, the script can be executed asynchronously using the CommandRunner class based on Process. CommandRunner provides both synchronous and asynchronous methods to load the script. Internally, it encapsulates the system environment variables that Process and Pipe scripts depend on for execution. Since the environments of the tools called by the script (e.g., CocoaPods, git, Ruby, etc.) are generally installed in a preset directory, it is also necessary to add the preset directory (e.g., system directory, etc.) and application parameters to the corresponding script using the preset second calling interface async. Application parameters associated with multiple scripts include, for example: project name: projName, project identifier bundle id: bundleId, development language: language, project base template xcodeproj file directory: projPath, organization name: orgName, organization id name: orgIdName, custom component name: moduleNames, general component name: openModuleNames, third-party library name string: openModuleNamesStr, template project git repository address: templateGitRepoUrl, etc.

[0052] Step S103: Drive one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the iOS system application, generate a project development space based on the project data, and bind the project data to the project development space so that the application developer can improve the business function development of the iOS system application based on the project development space.

[0053] In one embodiment of the present invention, preferably, multiple scripts are constructed, with different scripts implementing different functions. This improves the modular management and maintainability of the visualization plugin.

[0054] For example: a first script adds one or more of the custom component identifiers selected from the editable items to the preset module configuration file; a second script reads the general component identifiers and custom component identifiers from the module configuration file, and uses instructions to retrieve the general components corresponding to the general component identifiers and the custom components corresponding to the custom component identifiers into the project data; a third script retrieves the project base code corresponding to the project base template identifier from the code repository; and a fourth script can be used to build the project development space. It is understood that the first, second, third, and fourth scripts can also belong to the same script file depending on the application scenario.

[0055] Furthermore, the preset module configuration file contains one or more generic component identifiers (e.g., file identifiers for multiple third-party library files). The preset module configuration file can be a podfile included in the CocoaPods tool. The podfile can be used to configure generic component identifiers, custom component identifiers, and / or the relationships between component identifiers. The CocoaPods tool retrieves the component corresponding to each component identifier based on the information configured in the podfile. Furthermore, a first script adds one or more custom component identifiers selected from the editable items to the preset module configuration file. That is, the first script adds the custom component identifiers of user-selected custom components received from the page, and / or the relationships between components, to the podfile, overcoming the inefficiency and low accuracy problems caused by manually configuring generic component identifiers, custom component identifiers, and / or the relationships between component identifiers.

[0056] Furthermore, the second script reads the general component identifier and custom component identifier from the module configuration file, and uses instructions to pull the general component corresponding to the general component identifier and the custom component corresponding to the custom component identifier into the project data. The second script may include CocoaPods tool's `pod` command. Based on the association between the general component identifier, the custom component identifier, and / or the component identifiers, it pulls the general component corresponding to the general component identifier and the custom component corresponding to the custom component identifier into the project data, thus completing the import of the required general and custom components for the project. This script automatically integrates general and custom components, overcoming the inefficiency caused by manually executing tool instructions.

[0057] Furthermore, driving one or more scripts to integrate the project base template associated with the application parameters into the application's project data for the iOS system includes: when the application parameters include a project base template identifier, determining the code repository indicated by the project base template identifier, and driving a third script to pull the project base code corresponding to the project base template identifier from the code repository; and integrating the project base code into the project data. The project base template may contain basic functional classes, utility classes, general resources, and project base frameworks associated with the iOS application to be developed. Detailed content associated with the project base template (e.g., code) can be downloaded from a code repository, such as a Git repository. Therefore, the project base template identifier is passed to the third script to determine whether the third script executes a Git command to obtain the corresponding project base code, for example, the Git command is `git clone templateGitRepoUrl`; `templateGitRepoUrl` is an example of the project base template identifier. Furthermore, the project base code is integrated into the project data (project data, for example, a preset folder). Specifically, project data can include project project files (.xcodeproj). The xcodeproj tool included in CocoaPods can be used to re-edit the project's .xcodeproj project file using Ruby scripts according to the syntax format, thereby adding the information corresponding to the project's basic code to the project project file and generating a new .xcodeproj.

[0058] Furthermore, when the application parameters include multiple application version types, each application version type indicates a test version or a production version. The third script is used to obtain the multiple application version types. For each obtained application version type, the following steps are performed: adding the version configuration information of the application version type to the project's base code, and integrating the project's base code with the added version configuration information into the project data. Typically, in application development, it is often necessary to configure multiple version types to meet the needs of different development stages, such as test versions and production versions (e.g., production versions) corresponding to different development stages. Furthermore, the third script is driven to obtain the multiple application version types, and the xcodeproj tool is used to add the version configuration information of different application version types to the .xcodeproj project file contained in the project's base code, and the project's base code (containing the .xcodeproj project file) with the added version configuration information is integrated into the project data. It is understood that the code corresponding to different application version types is different; therefore, the project development space constructed through the embodiments of this invention can manage and match the code to different application version types.

[0059] Furthermore, if the application has multiple application version types, for any one of the application version types, the following steps are performed: based on the project development space corresponding to the application and the code corresponding to the application version type, a matching target version is generated for the application version type. For example, based on the project development space and the code of multiple test versions, multiple test versions can be generated; based on the project development space and the code of the release version, a release version can be generated, etc.

[0060] like Figure 2 As shown, this embodiment of the invention provides a method for constructing a project development space required for an iOS application, which may include the following steps:

[0061] Step S201: Use a script to detect whether one or more preset tools are installed.

[0062] Specifically, in one embodiment of the present invention, the required preset tools include git, CocoaPods, etc., and a script can be used to detect whether tools such as git and CocoaPods are installed. The detection method can be through calling an interface in the script or obtaining installation information from the system. It is understood that since the script needs to execute preset instructions contained in the preset tools to complete a variety of operations, such as using the git clone templateGitRepoUrl command to obtain the basic code of the project from the git code repository, or using pod install to build the project's .xcworkspace file (project development space), it can be seen that detecting whether one or more preset tools are installed improves the reliability of the script, thereby improving the efficiency of building the project development space.

[0063] Step S202: Utilize the tool instructions of one or more preset tools contained in the script to execute the project data of the application system application, which integrates the project base template and project components associated with the application parameters.

[0064] Specifically, the description of using tool instructions from one or more preset tools included in the script to integrate the project base template and project components associated with the application parameters into the project data of the iOS system application is consistent with the description of this part in step S103, and will not be repeated here. For example: create and write a podfile configuration file, and configure all project components (general components and custom components) in the podfile file, so that the CocoaPods tool can perform the step of integrating project components into the project data of the iOS system application based on the podfile configuration file.

[0065] Step S203: Obtain the plurality of application version types; for each obtained application version type, perform the following: add the version configuration information of the application version type to the project basic framework, and integrate the project basic framework with the added version configuration information into the project data.

[0066] Specifically, the description of adding the application version type's version configuration information to the project's basic framework and integrating the project's basic framework with the added version configuration information into the project data is consistent with the description of this part in step S103, and will not be repeated here. For example, if the application version type includes test version and release version, then an .xcodeproj file can be created using the xcodeproj script, the basic project template can be added to the project, and targets for the test version and release version can be created using the configuration information.

[0067] Step S204: Generate a project development space based on the project data.

[0068] Specifically, the `pod install` command can be used to generate the `.xcworkspace` file corresponding to the project development space. Application developers can then open the `.xcworkspace` file to further develop the application's business logic. Therefore, this invention overcomes the inefficiency caused by manual configuration and generation of the application's development space, which previously required manual configuration by application developers, by using a visual plugin to generate the application's development space with a single click, thus improving the efficiency of iOS application development.

[0069] The description of steps S201-S204 is as follows: one or more scripts contain tool instructions for one or more preset tools; drive one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the application in the iOS system, including: using the script to detect whether one or more preset tools have been installed, and if so, using the tool instructions of one or more preset tools contained in the script to execute the step of integrating the project base template and project components associated with the application parameters into the project data of the application in the iOS system.

[0070] like Figure 3 As shown, this embodiment of the invention provides a method for building an iOS application project development space through a visual plugin, which may include the following steps;

[0071] Step S301: Integrate common components, custom components, project base templates, and configuration information required to build various application version types into the project data through a visual plugin.

[0072] Step S302: Build an iOS application project development space based on project data.

[0073] Specifically, the descriptions of steps S301-S302 are consistent with those of steps S101-S103, and will not be repeated here.

[0074] Furthermore, in one embodiment of the present invention, the visualization plugin can be integrated into other applications as a standalone application or as a functional module. The following example illustrates this using the visualization plugin as a standalone application, where the plugin serves as the entry point to open another application for editing. When creating the application project for the visualization plugin using Xcode, two classes are automatically generated: SourceEditorExtension and SourceEditorCommand. The SourceEditorExtension class controls the extension's lifecycle; the SourceEditorCommand class retrieves the content being edited by Xcode and performs corresponding content replacements. This class includes the performCommandWithInvocation method, which retrieves the code of the currently edited content. Therefore, the business logic of the visualization plugin can include: creating a new XCSourceEditorCommand class, overriding the performCommandWithInvocation method in this custom class. Specifically, the visualization plugin can be implemented as an independent application, for example, using URLScheme, where the scheme can be defined as xxplugin: / / . Based on the new project command passed from the Xcode tool menu, the URL corresponding to the custom scheme is given, for example: xxplugin: / / new_app. Then, the system's application programming interface NSWr okspace.share.open(url) is used to open the application where the visualization plugin is located and jump to the new_app new project interface, and then further perform the relevant operations for writing the visualization plugin.

[0075] Furthermore, the visualization plugin's functionality comprises two parts: the user interface and business logic. The user interface, including interaction and rendering, can be written in Swift, which offers advantages such as concise and easy-to-maintain interface design. The business logic can utilize the Process class to handle operations such as passing in environment variables required for business functions and executing one or more Shell and Ruby scripts.

[0076] Furthermore, the installation and use of the visualization plugin can be carried out using the following steps: 1) Obtain the installation package of the visualization plugin XXPlugin. 2) Check whether the installation environment meets the requirements of the visualization plugin, such as checking the Xcode version, macOS version, etc.; 3) Check the installation status of the preset tools that the visualization plugin depends on, such as checking the CocoaPods version, git permissions, Ruby / shell runtime environment, etc.; 4) Execute the installation of the visualization plugin.

[0077] like Figure 4 As shown, this embodiment of the invention provides a device 400 for building a project development space required for an iOS application, including: a parameter acquisition module 401, a configuration script module 402, and a space building module 403; wherein,

[0078] The parameter acquisition module 401 is used to obtain and display the application parameters required for the project development space in a visual manner in response to generating the project development space required for developing iOS system applications.

[0079] The configuration script module 402 is used to add the application parameters to one or more scripts according to a pre-determined parameter addition strategy;

[0080] The construction space module 403 is used to drive one or more of the scripts to integrate the project base template and project components associated with the application parameters into the project data of the iOS system application, and generate a project development space based on the project data, and bind the project data to the project development space so that the application developer can improve the business function development of the iOS system application based on the project development space.

[0081] Optionally, the parameter acquisition module 401 acquires and displays the application parameters required by the project development space in a visual manner, including: displaying an editable page with multiple editable items in a visual manner, and receiving application parameters input or selected by the application developer through each editable item that have not appeared in other editable items; wherein the application parameters include any one or more of project information, project basic template identifier, and project component identifier.

[0082] Optionally, the configuration script module 402 adds the application parameters to one or more scripts according to a predetermined parameter addition strategy, including: reading the script corresponding to the script identifier using a preset first calling interface and a script identifier; obtaining one or more application parameters associated with the script, and adding one or more application parameters to the script using a preset second calling interface, so that the script performs operations associated with one or more application parameters.

[0083] This invention also provides an electronic device for building a project development space required for an iOS application, comprising: one or more processors; and a storage device for storing one or more programs, wherein when the one or more programs are executed by the one or more processors, the one or more processors implement the method provided in any of the above embodiments.

[0084] This invention also provides a computer-readable medium having a computer program stored thereon, which, when executed by a processor, implements the method provided in any of the above embodiments.

[0085] This invention also provides a computer program product, including a computer program, characterized in that the program, when executed by a processor, implements the method provided in any of the above embodiments.

[0086] Figure 5 An exemplary system architecture 500 is shown, which illustrates a method for constructing a project development space required for an iOS application or an apparatus for constructing a project development space required for an iOS application to which embodiments of the present invention can be applied.

[0087] like Figure 5 As shown, system architecture 500 may include terminal devices 501, 502, and 503, a network 504, and a server 505. Network 504 serves as the medium for providing communication links between terminal devices 501, 502, and 503 and server 505. Network 504 may include various connection types, such as wired or wireless communication links, or fiber optic cables, etc.

[0088] Users can use terminal devices 501, 502, and 503 to interact with server 505 via network 504 to receive or send messages, etc. Various client applications can be installed on terminal devices 501, 502, and 503, such as e-commerce client applications, web browser applications, search applications, instant messaging tools, and email clients.

[0089] Terminal devices 501, 502, and 503 can be various electronic devices with displays and supporting various client applications, including but not limited to smartphones, tablets, laptops, and desktop computers.

[0090] Server 505 can be a server that provides various services, such as a backend management server that supports client applications used by users through terminal devices 501, 502, and 503. The backend management server can process requests for one or more types of project data required to build the project development space and return the requested project data (such as project component data, project base code, etc.) to the terminal devices.

[0091] It should be noted that the method for constructing the project development space required for iOS applications provided in this embodiment of the invention is generally executed by terminal devices 501, 502, and 503. Correspondingly, the device for constructing the project development space required for iOS applications is generally located in terminal devices 501, 502, and 503.

[0092] It should be understood that Figure 5 The number of terminal devices, networks, and servers shown is merely illustrative. Depending on implementation needs, any number of terminal devices, networks, and servers can be included.

[0093] The following is for reference. Figure 6 It shows a schematic diagram of the structure of a computer system 600 suitable for implementing a terminal device of the present invention. Figure 6 The terminal device shown is merely an example and should not impose any limitations on the functionality and scope of use of the embodiments of the present invention.

[0094] like Figure 6 As shown, the computer system 600 includes a central processing unit (CPU) 601, which can perform various appropriate actions and processes based on programs stored in read-only memory (ROM) 602 or programs loaded from storage section 608 into random access memory (RAM) 603. The RAM 603 also stores various programs and data required for the operation of the system 600. The CPU 601, ROM 602, and RAM 603 are interconnected via a bus 604. An input / output (I / O) interface 605 is also connected to the bus 604.

[0095] The following components are connected to I / O interface 605: an input section 606 including a keyboard, mouse, etc.; an output section 607 including a cathode ray tube (CRT), liquid crystal display (LCD), etc., and speakers, etc.; a storage section 608 including a hard disk, etc.; and a communication section 609 including a network interface card such as a LAN card, modem, etc. The communication section 609 performs communication processing via a network such as the Internet. A drive 610 is also connected to I / O interface 605 as needed. A removable medium 611, such as a disk, optical disk, magneto-optical disk, semiconductor memory, etc., is installed on drive 610 as needed so that computer programs read from it can be installed into storage section 608 as needed.

[0096] In particular, according to the embodiments disclosed in this invention, the processes described above with reference to the flowcharts can be implemented as computer software programs. For example, embodiments disclosed in this invention include a computer program product comprising a computer program carried on a computer-readable medium, the computer program containing program code for performing the methods shown in the flowcharts. In such embodiments, the computer program can be downloaded and installed from a network via communication section 609, and / or installed from removable medium 611. When the computer program is executed by central processing unit (CPU) 601, it performs the functions defined above in the system of this invention.

[0097] It should be noted that the computer-readable medium shown in this invention can be a computer-readable signal medium or a computer-readable storage medium, or any combination thereof. A computer-readable storage medium can be, for example,—but not limited to—an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination thereof. More specific examples of a computer-readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer disk, a hard disk, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fiber, portable compact disk read-only memory (CD-ROM), optical storage device, magnetic storage device, or any suitable combination thereof. In this invention, a computer-readable storage medium can be any tangible medium containing or storing a program that can be used by or in conjunction with an instruction execution system, apparatus, or device. In this invention, a computer-readable signal medium can include a data signal propagated in baseband or as part of a carrier wave, carrying computer-readable program code. Such propagated data signals can take various forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination thereof. Computer-readable signal media can also be any computer-readable medium other than computer-readable storage media, which can send, propagate, or transmit a program for use by or in connection with an instruction execution system, apparatus, or device. The program code contained on the computer-readable medium can be transmitted using any suitable medium, including but not limited to: wireless, wire, optical fiber, RF, etc., or any suitable combination thereof.

[0098] The flowcharts and block diagrams in the accompanying drawings illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in a flowchart or block diagram may represent a module, segment, or portion of code containing one or more executable instructions for implementing a specified logical function. It should also be noted that in some alternative implementations, the functions indicated in the blocks may occur in a different order than those indicated in the drawings. For example, two consecutively indicated blocks may actually be executed substantially in parallel, and they may sometimes be executed in reverse order, depending on the functions involved. It should also be noted that each block in a block diagram or flowchart, and combinations of blocks in a block diagram or flowchart, may be implemented using a dedicated hardware-based system that performs the specified function or operation, or using a combination of dedicated hardware and computer instructions.

[0099] The modules and / or units described in the embodiments of the present invention can be implemented in software or hardware. The described modules and / or units can also be housed in a processor; for example, a processor may be described as including a parameter acquisition module, a configuration script module, and a build space module. The names of these modules do not necessarily limit the module itself; for example, the configuration script module may also be described as "a module that adds the application parameters to one or more scripts according to a predetermined parameter addition strategy."

[0100] In another aspect, the present invention also provides a computer-readable medium, which may be included in the device described in the above embodiments; or it may exist independently and not assembled into the device. The computer-readable medium carries one or more programs that, when executed by the device, cause the device to include: in response to generating a project development space required for developing an application for an iOS system, acquiring and displaying application parameters required for the project development space in a visual manner; adding the application parameters to one or more scripts according to a predetermined parameter addition strategy; driving one or more of the scripts to integrate the project base template and project components associated with the application parameters into project data for an iOS system application, generating a project development space based on the project data, and binding the project data to the project development space, so that the application developer can improve the business function development of the iOS system application based on the project development space.

[0101] In embodiments of the present invention, application parameters required for the project development space are obtained and displayed visually. Based on a pre-determined parameter addition strategy, the application parameters are added to one or more scripts. These scripts then drive the integration of the project base template and project components associated with the application parameters into project data for an iOS application. A project development space is generated based on this project data, and the project data is bound to the project development space, enabling application developers to refine the business functions of the iOS application based on this space. This one-click construction of the project development space through a customizable visual method improves the efficiency of iOS application development and reduces the manpower and time costs associated with iOS application development.

[0102] The specific embodiments described above do not constitute a limitation on the scope of protection of this invention. Those skilled in the art should understand that various modifications, combinations, sub-combinations, and substitutions can occur depending on design requirements and other factors. Any modifications, equivalent substitutions, and improvements made within the spirit and principles of this invention should be included within the scope of protection of this invention.

Claims

1. A method of constructing a project development space required for an iOS application, characterized by, The method comprises the following steps: in response to generating a project development space required for developing an application of an iOS system, acquiring and displaying application parameters required by the project development space in a visual manner; adding the application parameters to one or more scripts according to a predetermined parameter adding strategy; driving one or more scripts to integrate a project component associated with the application parameters into project data of the application of the iOS system, and to generate a project development space based on the project data, and to bind the project data to the project development space, so that an application developer perfects business function development of the application of the iOS system based on the project development space; wherein the integration of the project component associated with the application parameters into the project data of the application of the iOS system comprises: in the case that the project component is a custom component identifier, acquiring a preset module configuration file, wherein the preset module configuration file is configured with one or more general component identifiers; adding the custom component identifier selected by one or more editable items to the preset module configuration file through a first script; reading the general component identifiers and the custom component identifiers in the module configuration file through a second script, and pulling the general components corresponding to the general component identifiers and the custom components corresponding to the custom component identifiers into the project data by using instructions.

2. The method of claim 1, wherein: the acquiring and displaying of the application parameters required by the project development space in a visual manner comprises: displaying an editable page comprising a plurality of editable items in a visual manner, and receiving, through each of the editable items, an application parameter input or selected by an application developer and not appearing in other editable items; wherein the application parameter comprises any one or more of project information, a project base template identifier, and a project component identifier.

3. The method of claim 2, wherein: the method further comprises displaying a plurality of custom component identifiers corresponding to one or more of the editable items in a visual manner; the receiving, through each of the editable items, of the application parameter selected by the application developer and not appearing in other editable items comprises: receiving a selection operation of any one or more of the custom component identifiers corresponding to any of the editable items and not selected, and acquiring and displaying an application parameter of the custom component identifier targeted by the selection operation.

4. The method of claim 1, wherein: the driving of one or more scripts to integrate the project base template associated with the application parameters into the project data of the application of the iOS system comprises: in the case that the application parameter comprises a project base template identifier, determining a code library indicated by the project base template identifier, and driving a third script to pull a project base code corresponding to the project base template identifier from the code library; and integrating the project base code into the project data.

5. The method of claim 4, wherein: The driving one or more scripts associated with the application parameters integrates the project data of the application of the iOS system, further comprising: In the case that the application parameters contain a plurality of application version types, each of which indicates a test version or an online version; Obtaining the plurality of application version types by using the third script; For each of the obtained application version types, performing: Adding the version configuration information of the application version type to the project base code, and integrating the project base code added with the version configuration information into the project data.

6. The method of claim 5, wherein, Further comprising: In the case that the application exists a plurality of application version types, For any one of the application version types, performing: Generating a matching target version for the application version type based on the project development space corresponding to the application and the code corresponding to the application version type.

7. The method of claim 1, wherein The adding the application parameters into one or more scripts according to the predetermined parameter adding strategy comprises: Reading the script corresponding to the script identifier by using a preset first calling interface and the script identifier; Obtaining one or more application parameters associated with the script, and adding one or more application parameters into the script by using a preset second calling interface, so that the script performs an operation associated with one or more application parameters.

8. The method of claim 1, wherein One or more tool instructions of one or more preset tools contained in one or more scripts; Driving one or more scripts to integrate the project base template and the project component associated with the application parameters into the project data of the application of the iOS system comprises: Using the tool instructions of one or more preset tools contained in the script to perform the step of integrating the project base template and the project component associated with the application parameters into the project data of the application of the iOS system, if the one or more preset tools are installed.

9. A construction device of a project development space required for an iOS application, characterized by, Comprising: An obtaining parameter module, a configuration script module and a construction space module; wherein The obtaining parameter module is configured to, in response to generating a project development space required for developing an application of the iOS system, obtain and display application parameters required for the project development space in a visual manner; The configuration script module is configured to add the application parameters into one or more scripts according to a predetermined parameter adding strategy; The construction space module is configured to drive one or more scripts to integrate the project base template and the project component associated with the application parameters into the project data of the application of the iOS system, and generate a project development space based on the project data, and bind the project data to the project development space, so that an application developer perfects the business function development of the application of the iOS system based on the project development space; The construction space module is configured to integrate the project component associated with the application parameters into the project data of the application of the iOS system, comprising: In a case where the project component is a self-defined component, a preset module configuration file is obtained, wherein the preset module configuration file is configured with one or more general component identifiers; The first script is used to add the self-defined component identifier selected by one or more editable items to the preset module configuration file; The second script is used to read the general component identifier and the self-defined component identifier in the module configuration file, and use an instruction to pull the general component corresponding to the general component identifier and the self-defined component corresponding to the self-defined component identifier into the project data.

10. The apparatus of claim 9, wherein The obtaining parameter module obtains and displays the application parameters required by the project development space in a visual manner, including: An editable page including one or more editable items is displayed in a visual manner, and each editable item receives an application parameter input or selected by an application developer and not appearing in other editable items; wherein the application parameter includes any one or more of project information, project basic template identifier and project component identifier.

11. The apparatus of claim 9, wherein The configuration script module adds the application parameter to one or more scripts according to a predetermined parameter adding strategy, including: A preset first calling interface and a script identifier are used to read a script corresponding to the script identifier; One or more application parameters associated with the script are obtained, and a preset second calling interface is used to add one or more application parameters to the script, so that the script performs an operation associated with one or more application parameters.

12. An electronic device, comprising: including: one or more processors; a storage device for storing one or more programs, When the one or more programs are executed by the one or more processors, the one or more processors implement the method of any one of claims 1-8.

13. A computer readable medium having stored thereon a computer program, characterized in that, The program is executed by the processor to implement the method of any one of claims 1-8.

14. A computer program product comprising a computer program, characterized in that, The program is executed by the processor to implement the method of any one of claims 1-8.

Images