CN112527306B - Method, device, equipment and medium for realizing independence of modules in project development - Google Patents

Abstract

The embodiment of the invention discloses a method, a device, equipment and a medium for realizing the independence of modules in project development. Traversing a currently associated target item to obtain each functional module included in the target item; determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene; after the target compiling task item is triggered, compiling operation is carried out on the associated target functional module under the corresponding compiling requirement scene. The method can determine the function modules to be compiled under different compiling requirement scenes, and generate compiling task items corresponding to the different compiling requirement scenes, so that when the task items are triggered, only the associated function modules under the compiling requirement scenes corresponding to the task items can be compiled. The method realizes the independence of compiling the functional modules in the developed project, effectively shortens the compiling time in the project development, and improves the project development efficiency.

Description

Method, device, equipment and medium for realizing independence of modules in project development

Technical Field

The embodiment of the invention relates to the technical field of application software project development, in particular to a method, a device, equipment and a medium for realizing the independence of modules in project development.

Background

Along with the popularization of the new generation android packaging/publishing technology Android App Bundle, the development of the application software project based on the AAB organization architecture is also becoming more and more popular. The function modules developed based on the AAB organization architecture comprise dynamic modules, and the dynamic modules have the characteristics that when a user installs the opened application software for the first time, the user does not need to install the application software together, and the user can dynamically download and install the application software when the function modules are needed. Meanwhile, in project development based on an AAB organization architecture, the architecture of the project can be clearer along with the introduction of the dynamic module, and a user can download the dynamic module as required to reduce the size of an application package, so that the method is equivalent to realizing the independence of downloading and installing the functional module when the user uses the functional module.

Generally, for development of application software projects oriented to an android system, it is required to compile a developed functional module in a development stage and install the compiled functional module on a terminal device to view an operation effect. The existing compiling and installing implementation of the functional modules is mainly based on the compiling function of the project development platform, however, in the compiling mode, when compiling requirements exist (such as developing a certain functional module or modifying a certain functional module), all functional modules in developed application software need to be compiled each time, and then all modules after compiling need to be installed when installing.

With the existing compiling and installing mode, for the development of medium and large projects, the code scale of the project is larger and larger along with the iteration of the projects, and the time occupied by compiling and installing in the daily development process is longer. For example, some medium-to-large project compilations and installations may take 10 minutes or even longer, thereby severely impacting the project development efficiency of the application software.

Disclosure of Invention

In view of this, the embodiments of the present invention provide a method, apparatus, device, and medium for implementing module independence in project development, so as to shorten the compiling and installing time of the functional module in the developed project, and improve the project development efficiency.

In a first aspect, an embodiment of the present invention provides a method for implementing independence of modules in project development, including:

traversing the currently associated target item to obtain each functional module included in the target item;

Determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene;

After the target compiling task item is triggered, compiling operation is carried out on the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

In a second aspect, an embodiment of the present invention provides an apparatus for implementing independence of modules in project development, including:

the information acquisition module is used for traversing the currently associated target item to acquire each functional module included in the target item;

The information generation module is used for determining attribution division of each functional module in each preset compiling requirement scene and generating compiling task items corresponding to each compiling requirement scene;

And the compiling execution module is used for carrying out compiling operation on the associated target functional module under the corresponding compiling requirement scene after the target compiling task item is triggered, wherein the target compiling task item is any compiling task item.

In a third aspect, an embodiment of the present invention provides a computer apparatus, including:

one or more processors;

a storage means for storing one or more programs;

The one or more programs are executed by the one or more processors, so that the one or more processors implement the method for implementing independence of modules in project development provided by the embodiment of the first aspect of the present invention.

In a fourth aspect, an embodiment of the present invention provides a computer readable storage medium having stored thereon a computer program, which when executed by a processor, implements a method for implementing independence of modules in development of a project provided by an embodiment of the first aspect of the present invention.

In the method, the device, the equipment and the medium for realizing the independence of the modules in the project development, which are provided by the embodiment of the invention, the currently associated target project is traversed firstly to obtain each functional module included in the target project; then determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene; and finally, after the target compiling task item is triggered, compiling the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item. Compared with the conventional method for compiling the developed project, the technical scheme can determine the function modules to be compiled in different compiling requirement scenes according to different compiling requirement scenes, and generate compiling task items corresponding to different compiling requirement scenes, so that when the task items are triggered, only the associated function modules in the compiling requirement scenes corresponding to the task items can be compiled. The method realizes the independence of compiling the functional modules in the developed project, effectively shortens the compiling time in the project development, and improves the project development efficiency.

Drawings

FIG. 1 is a schematic flow chart of a method for implementing module independence in project development according to an embodiment of the invention;

FIG. 1a shows a diagram of a prior AAB dynamic module-based modular project architecture in android application project development;

fig. 2 is a schematic flow chart of a method for implementing module independence in project development according to a second embodiment of the present invention;

FIG. 2a is a diagram showing the effect of compiling a task item presentation in a method according to a second embodiment of the present invention;

FIG. 2b is a flowchart of the implementation of compiling a target dynamic module in the implementation of the module in the development of the project according to the second embodiment of the invention;

FIG. 2c is a diagram showing comparison of effects of the functional modules according to the embodiment of the present invention when the functional modules are compiled by using several different compiling methods;

FIG. 2d is a flow chart showing the implementation of the function module installation determination in the alternative embodiment of the second embodiment of the present invention;

fig. 2e is a diagram showing the effect of the function module in the present alternative embodiment when the function module is installed on a terminal device with a different android system version number;

Fig. 3 is a block diagram of a module independence implementation device in project development according to a third embodiment of the present invention;

fig. 4 is a schematic hardware structure of a computer device according to a fourth embodiment of the present invention.

Detailed Description

In order to make the objects, technical solutions and advantages of the present invention more apparent, the following detailed description of the embodiments of the present invention will be given with reference to the accompanying drawings. It should be understood that the described embodiments are merely some, but not all, embodiments of the invention. Furthermore, embodiments of the invention and features of the embodiments may be combined with each other without conflict.

In the description of the present application, it should be understood that the terms "first," "second," "third," and the like are used merely to distinguish between similar objects and are not necessarily used to describe a particular order or sequence, nor should they be construed to indicate or imply relative importance. The specific meaning of the above terms in the present application can be understood by those of ordinary skill in the art according to the specific circumstances.

Example 1

Fig. 1 is a schematic flow chart of a method for implementing module independence in project development, which is provided in an embodiment of the present invention, and is suitable for the case of performing independent management on functional modules in a developed project.

The application background of the method for realizing the independence of the modules in the project development provided by the embodiment can be described as follows: the android operating system is a conventional operating system on which the existing normal work of the intelligent mobile terminal (such as a smart phone, a tablet and the like) depends. When the application software is developed on the Android Studio of the Android application software development platform, after new functional codes are added or existing codes are modified in the application software, the compiling tool carried by the Android Studio is required to re-compile the functional modules used in the application software, and then the compiled files are re-installed (installed in the development stage) on the mobile terminal.

In order to better understand the compiling process based on the Android Studio platform with a compiling tool, fig. 1a shows a structure diagram of an existing modularized project based on an AAB dynamic module in Android application software project development, and in combination with the structure diagram, shows a description of an implementation process of compiling operation by an existing official: first, the project architecture based on the AAB Dynamic module is different from the original conventional Android modular architecture in that Dynamic-feature modules, such as the Dynamic module a and the Dynamic module B in fig. 1a, are introduced, and these Dynamic modules are next-come APP modules. Then, when the compilation is executed in the Android Studio, if the compilation mode defaults to be compiled by the self-contained compilation tool and the version of the Android operating system on the connected terminal device is above the set version number (such as Android 5.0), all the functional modules in the App module are needed for the existing compilation implementation, and all the dynamic modules participate in the execution of the compilation task, namely: operations of app assembleDebug: dynamicfeature-a assembleDebug: dynamicfeature-b assemble Debug are performed. Three compiled files in apk format can then be obtained: base.apk, dynamicfeature-a.apk, dynamicfeature-b.apk; finally, the installation of the obtained compiled files to the terminal equipment is realized by running an installation instruction.

For the development project of the middle-large-sized android application software, the compiling mode is adopted for compiling, and the development efficiency of the whole project is greatly influenced due to the complex compiling process. Based on the above, the embodiment provides an independent implementation method of modules in project development, so as to optimize compiling and even installing of functional modules in the developed project.

It should be noted that, the method for implementing module independence in project development provided in this embodiment may be used as a plug-in, and before compiling and even installing and managing the functional module in the target project, the formed plug-in needs to be introduced into the project selected to be managed independently. Specifically, the plug-in for executing the method provided by the embodiment can be combined into the project to be independently managed through the corresponding path configuration. Illustratively, the path configuration performed may be: the xxxx and yyyy can be information items related to the items, such as item names, and the like, and can be filled differently according to different items. Thereafter, a configuration operation of presenting the content of the introduced plug-in one step is required, for example: apply plug in,' xxxx. Yyy. Mobile. Android. Tool.

The project after the configuration is equivalent to the function of independent management of compiling and even installing the functional module by adopting the method provided by the embodiment of the invention, and specifically, as shown in fig. 1, the method for realizing the independent module in project development provided by the embodiment of the invention specifically comprises the following operations:

s101, traversing the currently associated target item to obtain each functional module included in the target item.

In this embodiment, the target item may be specifically regarded as an item that performs the above plug-in configuration operation, and may be regarded as an item currently associated with this embodiment, and the item may be directly traversed through this step, so that all App modules and dynamic modules included in the target item may be filtered out.

S102, determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene.

It should be noted that, in this embodiment, a compiling requirement scenario that may exist when a functional module is programmed may be preset according to a main use situation frequently encountered in a project development process, and it may be known that functional modules that need to perform a compiling operation under different compiling requirement scenarios may be different, and this step may perform attribution division from a functional module to different compiling requirement scenarios in each obtained functional module. And then respectively generating related compiling task items corresponding to different compiling requirement scenes.

Specifically, the step can determine which functional modules are suitable for compiling under the compiling requirement scenes through the related scene description information corresponding to the different compiling requirement scenes, and then generate the compiling task item triggering the compiling of the associated functional modules. Wherein the compiled task item may be presented in a view area of the project development tool for a developer to click on when needed.

The functional modules are further optimized in this embodiment, for example, each functional module may be optimized to have a corresponding module attribute, where the module attribute is basic or dynamic.

It should be noted that, in the process of performing the function module traversal in S101, the module attribute of each function module may be determined according to some prefix information of the function module, an App module with prefix information of "com.

Meanwhile, the further optimizing the compiling requirement scene according to the embodiment may include: compiling and installing all the functional modules with module attributes as basic types, recompiling all the functional modules with module attributes as basic types and installing all the functional modules, recompiling any functional module with module attributes as dynamic types and installing all the functional modules, recompiling all the functional modules with module attributes as dynamic types and installing all the functional modules; in a requirement scene that only any functional module with the dynamic module attribute is recompiled and all functional modules are installed, each functional module with the dynamic module attribute is correspondingly provided with a compiling task item.

In this embodiment, 5 compiling requirement scenes with different requirement conditions are given, through the operation of this step, the functional modules classified under the compiling requirement scenes can be determined for each compiling requirement scene, and for the compiling requirement scenes with only compiling and installing module attributes as basic type all functional modules, this step can classify the attribution of all the functional modules with module attributes as basic type into the compiling requirement scenes.

For another example, for compiling requirement scenes of only recompiling any functional module with a dynamic module attribute and installing all functional modules, the functional modules with the dynamic module attribute can be respectively regarded as an independent individual attribution to be divided into scenes, and meanwhile, for the requirement scenes, a compiling task item can be respectively generated for each functional module, namely, the compiling task items with the same number as the dynamic functional modules exist in the requirement scenes.

It can be seen that, the compiled installation requirements are also attached to each compiling requirement scene, and the embodiment further provides an installation implementation of the functional module, and the installation implementation can realize the installation of the functional module to the terminal device according to the installation requirements in the compiling requirement scene in the installation stage of the provided method.

Further, each compiling task item is contained in a view area presented in a first compiling task list on a development platform on which the target item depends; the naming information of the compiling task item at least comprises: and parameter names of the target items, a construction type buildType and requirement scene description information.

In addition, the embodiment can further optimize and limit the compiling task item. Specifically, the compiled task item generated in this step may be included as a subtask in a first compiled task list, where the first compiled task list may be shown in a development platform on which the target item depends, and mainly shown in a view area of the development platform.

Taking an Android Studio of a development platform as an example, after a plug-in including the method provided by the embodiment is introduced into the target item through configuration, after the target item is integrally refreshed, a first compiling task list may be displayed in a Gradle view on the right side of the Android Studio, and each compiling task item generated according to a compiling requirement scene in this step may be displayed under the first compiling task list.

Meanwhile, the present embodiment also defines naming information of the compiling task items, for each compiling task item, the naming of the task item includes the parameter name flag and the construction type buildType of the target item, and then includes description information of the compiling requirement scene corresponding to the compiling task item, for example, a compiling task item named GpEngDebug _ runOnlyBase, gpEngDebug is the description information of flag+ buildType and runOnlyBase in the target item, and only compiles basic function modules.

And S103, after the target compiling task item is triggered, compiling the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

The method specifically realizes the monitoring of the compiling task item and the compiling and executing of the target function module related to the compiling task item.

Specifically, each compiling task item generated in the above manner may be triggered by an operation (such as double-clicking the compiling task item) of the developer, and this step may monitor whether the developer performs a triggering operation on each compiling task item, and consider the compiling task item in which the triggering operation is monitored as a target compiling task item. The target compiling task item corresponds to one of the compiling requirement scenes, and the corresponding compiling requirement scene has the associated function module, which is recorded as the target function module in this embodiment, and after determining the target function module, the compiling operation on the target function module can be started in this step.

Compared with a conventional method for compiling developed projects, the method for realizing the independence of the modules in project development provided by the embodiment of the invention can determine the function modules to be compiled in different compiling requirement scenes according to different compiling requirement scenes, and generate compiling task items corresponding to different compiling requirement scenes, so that when the task items are triggered, only the associated function modules in the compiling requirement scenes corresponding to the task items can be compiled. The method realizes the independence of compiling the functional modules in the developed project, effectively shortens the compiling time in the project development, and improves the project development efficiency.

Example two

Fig. 2 is a flow chart of an implementation method for module independence in project development according to a second embodiment of the present invention, where optimization is performed based on the foregoing embodiment, and in this embodiment, determining the attribution division of each functional module in each preset compiling requirement scene, and generating a compiling task item corresponding to each compiling requirement scene is further specified as follows: analyzing and determining module attributes of the functional modules; aiming at each compiling requirement scene, determining a functional module belonging to the compiling requirement scene according to the module attribute and scene description information of the compiling requirement scene; and generating compiling task items required by compiling the associated functional modules according to compiling generation rules corresponding to the compiling requirement scenes.

In addition, the embodiment also optimizes and includes each dynamic module with dynamic module attribute extracted from each functional module after each functional module included in the target item is obtained; and respectively generating upgrade compiling task items corresponding to the dynamic modules according to a preset upgrade compiling generating rule.

Meanwhile, on the basis of the optimization, the method further comprises the step of executing the compiling operation of the target dynamic module corresponding to the target upgrading compiling task item after determining that the running condition of the target upgrading compiling task item is met currently, wherein the target upgrading compiling task item is any upgrading compiling task item.

As shown in fig. 2, the method for implementing module independence in project development provided in the second embodiment of the present invention specifically includes the following operations:

s201, traversing the currently associated target item to obtain each functional module included in the target item.

Illustratively, a plug-in comprising the method provided by the present embodiment is introduced into the developed project, which corresponds to the currently associated target project, after which functional modules with different module properties can be obtained through the present step.

The following S202 to S204 in this embodiment give specific implementation of generating a compiling task item.

S202, analyzing and determining module attributes of the functional modules.

In this embodiment, the above-obtained functional modules may be analyzed, thereby obtaining the module attribute of each functional module.

S203, determining a functional module belonging to each compiling requirement scene according to the module attribute and scene description information of the compiling requirement scene.

In this embodiment, the compiling requirement scene set according to the main usage field Jing Yuxian that may occur in the development process is mainly expressed by the corresponding scene description information, and this step and S204 described below may be equivalent to the operations performed on each compiling requirement scene.

Specifically, for each compiling requirement scene, the corresponding scene description information includes the related description of the functional module expected to be compiled in the compiling requirement scene, so that after the module attribute of each functional module is known, the analysis of the scene description information can determine which functional modules are associated in the corresponding compiling requirement scene.

For example, assuming that one compiling requirement scene is all functional modules with dynamic module attribute only, and all functional modules are installed, it can be analyzed from the corresponding scene description information that the functional module expected to be compiled in the compiling requirement scene is all functional modules with dynamic module attribute, so that all functional modules with dynamic module attribute can be determined as the functional module attributed under the compiling requirement scene.

S204, according to the compiling generation rule corresponding to the compiling requirement scene, compiling task items required by compiling the associated functional modules are generated.

It can be understood that when the compiling requirement scenes are different, the corresponding compiling generation rules are different, and the setting of the compiling generation rules can be specifically considered to be related to the functional modules associated with the compiling requirement scenes, for example, the compiling generation rules may include extraction control of code information of each functional module to be compiled, and the control information for extracting the code information in the compiling generation rules corresponding to the different compiling requirement scenes may be different.

Through the operation of the step, corresponding compiling task items can be respectively generated for different compiling requirement scenes, and the generated compiling task items can be mainly used for being displayed to developers so as to trigger the compiling of the functional modules related to the compiling requirement scenes through the operation of the developers.

In this embodiment, S205 and S206 mainly provide another generation implementation of forming a compiling task item, where another form of compiling task item to be generated in this embodiment may be equivalent to an upgrade of the generated compiling task item on the compiling implementation, but the form of compiling task item depends on the execution of the generated compiling task item when the executing is triggered.

S205, extracting each dynamic module with the dynamic module attribute from each functional module.

The present step may be regarded as the parallel step of S202, and the steps also need to be executed after S201, so it is to be understood that, in the method flow step provided in this embodiment, the sequence number of each step is not limited to the specific execution sequence of the related steps, and the specific execution sequence of each step is mainly related to the specific execution logic of the method provided in this embodiment.

In this step, after each function module is obtained in S201, all the function modules whose module attribute is dynamic may be further extracted from each function module, and these function modules may be referred to as dynamic modules. It can be seen that the compiling task item in another form generated in this step and S206 described below is only specific to the functional module whose module attribute is dynamic, and each compiling task item generated in this form corresponds to one dynamic module.

S206, generating upgrade compiling task items respectively corresponding to the dynamic modules according to preset upgrade compiling generating rules.

It should be noted that, in this embodiment, each compiling task item generated by this step is actually equivalent to another upgrade of each dynamic module based on the corresponding compiling task item, and this embodiment records the generating rule adopted for generating these compiling task items as an upgrade compiling generating rule, and correspondingly records the finally generated compiling task item as an upgrade compiling task item. Meanwhile, when the upgrade compiling task item is generated through the step, the upgrade compiling task item is only aimed at each dynamic module, and the limitation of compiling requirement scenes does not exist.

Specifically, the upgrade compiling generation rule in the step can be mainly used for limiting code information extraction of the corresponding dynamic modules when different upgrade compiling task items are generated, and the relevant upgrade compiling task items of different dynamic modules are correspondingly generated by extracting the code information of the different dynamic modules.

In addition, the present embodiment further defines the upgrade compiling task item, for example, the present embodiment optimizes that each upgrade compiling task item generated above is included in the second compiling task list, and then is also presented in the view area of the development platform on which the target item depends. For example, the second compiled task list and the first compiled task item may correspond to two parallel task lists, which may be simultaneously presented in a view area of a development platform on which the target item depends.

The present embodiment may employ naming information similar to the compiled task items described above to conduct the relevant naming of the task items. Because the upgrade compiling task item is only aimed at the dynamic module, the corresponding compiling requirement scene can be defaulted to be any functional module with the dynamic attribute of only the recompilation module, and all the functional modules are installed. Therefore, the naming of the upgrade compiling task item can include related information of the flag+ buildType, and further includes related expression of the functional description information corresponding to the task item, for example, the functional row description information is the recompilation of the dynamic module 1, and the related expression of the upgrade compiling task item in the naming of the upgrade compiling task item can be runAll _ updateLite _ dunamicfeature1.

Fig. 2a is an effect display diagram of a compiled task item presentation in a method according to a second embodiment of the present invention. As shown in fig. 2a, mainly a Gradle view area under the Android Studio of the development platform is given, where the view area includes a first compiled task list 21 named rundynamic and a second compiled task list 22 named rundynamiclite. It can be seen that, the rundynamic list includes the compiling task items 211 corresponding to 5 types of compiling requirement scenes, wherein only any functional module with dynamic attribute is recompiled, and the functional modules with dynamic attribute corresponding to each module in the requirement scenes of all the functional modules are installed to respectively present one compiling task item; the rundynamiclite list mainly includes upgrade compiling task items 221 corresponding to each dynamic module.

S207, after the fact that the target compiling task item is triggered is monitored, compiling operation is carried out on the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

In this embodiment, after the execution logic is in S204, the triggering monitoring of each compiling task item under the first compiling task list may be specifically implemented, and when any compiling task item is monitored to be triggered, each target function module associated with the triggered target compiling task item may be compiled.

S208, after determining that the running condition of the target upgrading and compiling task item is met currently, executing the compiling operation of the target dynamic module corresponding to the target upgrading and compiling task item, wherein the target upgrading and compiling task item is any upgrading and compiling task item.

In this embodiment, after the execution logic is in S206, the method specifically may implement monitoring of the running condition of each upgrade compiling task item under the second compiling task list, and executing the compiling operation of the target dynamic module corresponding to the target upgrade compiling task item that meets the running condition, where the target upgrade compiling task item is any upgrade compiling task item.

In this embodiment, the running condition for triggering the execution of the compiling operation of the target dynamic module may be specifically set according to the association relationship between the upgrade compiling task item and the compiling task item, and it is considered that the upgrade compiling task item is an upgrade of the compiling task item in the compiling operation process, so that when the running condition is set, an influence of whether the execution of the compiling task item has on the upgrade compiling task item needs to be considered.

The embodiment further optimizes the running condition of the target upgrade compiling task item as: and monitoring that the target upgrading compiling task item is triggered and started, and performing compiling operation on the target dynamic module associated with the target compiling task item based on the corresponding compiling task item.

Specifically, the operation condition includes two stages of determination, one stage is to monitor that the target upgrade compiling task item presented in the view area is triggered by the developer through the triggering operation, and the second stage is to determine that the dynamic module corresponding to the triggered target upgrade compiling task item has performed the compiling operation based on the compiling task item corresponding to the dynamic module.

It can be understood that the compiling operation performed by the step on the target dynamic module may be considered as an optimization upgrade when the compiling operation is performed based on the corresponding compiling task item, and the compiling operation of the target dynamic module implemented by the step takes shorter compiling time than when the compiling operation is performed based on the compiling task item. In addition, when the developer is monitored to trigger the target upgrading compiling task item, but the target dynamic module associated with the target upgrading task item does not realize compiling operation based on the associated compiling task item, message prompt that the dynamic module cannot be compiled through the task item can be carried out on the current interface of the development platform on which the target item depends.

It should be noted that, the core idea of the present embodiment for upgrading the compiling task item with respect to the compiling task item of the dynamic module may be described as follows: for the functional module a with dynamic module attribute, when the independent compiling of the functional module is implemented by adopting the compiling task item related to the functional module a, the compiling instruction to be executed can be expressed as Dynamicfeature-a: assembleDebug, and the compiling process of the compiling task item is analyzed, so that each functional module based on the module attribute and many subtasks in the library module in the project architecture shown in fig. 1a can be found, and when the subtasks are compiled, some time-consuming tasks (such as javac and kotlinc) can be executed, and particularly, some variables in a target project can be updated in real time, but when the compiling is performed again, the compiling dependence can cause unnecessary compiling time even if each dynamic module is compiled independently. The method for compiling the sub-tasks of the dynamic module can only realize compiling the sub-tasks related to the dynamic module in a compiling stage when only the code of the dynamic module is changed, and other related modules with unchanged interior can directly multiplex the information compiled before.

Specifically, fig. 2b shows a flowchart of the implementation of compiling a target dynamic module in the implementation of the module independence in the project development according to the second embodiment of the present invention. As shown in fig. 2b, the present embodiment further embodies the compiling operation performed on the target dynamic module corresponding to the target upgrade compiling task item as follows:

S2081, determining an associated module on which the compiling operation of the target dynamic module depends.

Based on the related description of the core ideas of the design upgrading compiling task item, when the compiling operation of the target dynamic module is realized through the target upgrading compiling task item, each associated module on which the compiling operation is dependent on the target dynamic module can be determined through the step.

S2082, when the compiling of the target dynamic module is started, the compiling of each associated module is skipped, and the current compiling information of the target dynamic module is obtained.

After the compiling operation of the target dynamic module is started, the determined execution parameters corresponding to the associated module can be directly set as false or a command line for skipping the associated module can be directly generated, so that the compiling execution of the associated module can be skipped, and therefore, only some subtasks of the target dynamic module can be compiled, and current compiling information related to the target dynamic module can be generated.

S2083, multiplexing historical compiling information of each associated module and combining the current compiling information to form a compiling file of the compiling operation.

The step can acquire the historical compiling information for the related module from a pre-cache directory, multiplex the historical compiling information, and combine the historical compiling information with the current compiling information determined in the step to form a compiling file corresponding to the compiling operation for the target dynamic module.

According to the method for realizing the independence of the modules in the project development, provided by the embodiment of the invention, the generation operation of the compiling task item is embodied, and the generation operation of the upgrading compiling task item in another form required by compiling the functional module is increased through optimization. According to the method provided by the embodiment, the compiling operation of the functional module in the target project is independent according to the compiling requirement scene, so that the time spent by compiling the functional module is saved, and the independent compiling operation for the dynamic module is further upgraded and compiled again. Therefore, the time spent by independent compiling of the dynamic modules is saved to the maximum extent, the development efficiency of the project is further effectively improved, and the development period of the project is shortened.

Fig. 2c is an exemplary diagram showing an effect comparison of the functional modules compiled by several different compiling methods according to the embodiment of the present invention. AS shown in fig. 2c, the effect of the compiling time spent on compiling a dynamic module by using different compiling modes in the target item is mainly shown in the figure, wherein the item of the module 23 shown in fig. 2c mainly includes 4 different dynamic modules, the item of the run button 24 of the AS is equivalent to the compiling time spent on compiling by using the existing compiling mode, the item of the runDynamic is equivalent to the compiling time spent on compiling a compiling task item based on the first compiling task list in the compiling method provided by the embodiment, and the item of the runDynamicLite is equivalent to the compiling time spent on compiling a compiling task item based on the upgrading compiling task item in the second compiling task list in the compiling method provided by the embodiment.

It can be seen that the run button 24 of the AS takes the longest compile time to compile each dynamic module, runDynamic takes a significantly shorter compile time to compile each dynamic module than in the prior art, and runDynamicLite takes the shortest compile time to compile each dynamic module. The effect comparison chart provided in fig. 2c of the present embodiment further illustrates that the project development efficiency is effectively improved when the method provided in the present embodiment is adopted to implement independent compiling of modules.

Meanwhile, as an optional embodiment of the second embodiment of the present invention, on the basis of the method for implementing the independence of the modules in the project development provided in the foregoing embodiment, related operations of implementing the independence of the functional modules in installation are further added in an optimized manner, as shown in fig. 2 provided in the second embodiment, the present optional embodiment further includes the following operations for implementing the independence of the functional modules in installation operations:

It will be understood that the following steps in this alternative embodiment may be specifically performed after S103 in the foregoing embodiment is performed, or may be performed after S207 or S208 in this embodiment is performed, which is specifically configured to implement the installation operation of the compiled file formed after the function module is compiled on the terminal device, and may implement the self-starting of the target item on the terminal device after the installation is completed.

S209, after the compiling operation of the functional module to be compiled is completed, the correspondingly formed compiling file is cached in the set file directory.

In this embodiment, the function module to be compiled in this step may specifically refer to a target function module corresponding to a target compiling task item after being triggered, or may refer to a target dynamic module corresponding to a target upgrading compiling task item after meeting an operation condition, and after monitoring that the function module to be compiled completes a compiling operation, the function module to be compiled in this step may directly cache a compiling file formed by compiling into a file directory.

The file directory is under the root directory of the target item. The file directory may be preset, and the file directory may be empty at the time of initial setting. For example, a compiled file in apk format generated after the function module to be compiled completes the compiling operation may be placed under the build/rundynamic/this file directory of the root directory, where rundynamic may be regarded as a file name of the file directory of the cached compiled file, and the file name may be set accordingly according to the naming of the task list including the compiled task item.

In this embodiment, in addition to the compiled files of each function module currently compiled, apk compiled files of other function modules not currently compiled are also cached in the file directory, where the compiled files may be historical compiled files that have been stored in the file directory before, and may be directly multiplexed during installation operation, and if compiled files of some function modules are not yet stored in the file directory, the compiling operation of these function modules is automatically triggered, so that related compiled files are generated and stored in the file directory.

S210, selecting a file to be installed from the file catalog according to the determined installation form, and executing the installation operation of the file to be installed to a target terminal and the starting operation of the target item.

After the functional module to be compiled is compiled, the embodiment can automatically execute the installation operation of the functional module to the terminal equipment. It should be understood that, according to the above description of the compiling requirement scenarios in this embodiment, the relevant restrictions for installing the functional modules are included in different compiling requirement scenarios, and all the functional modules in the target item need to be installed in each compiling requirement scenario.

Therefore, the present embodiment is basically equivalent to automatic installation of all the functional modules in the target project, but on the basis of independently compiling the functional modules by the method of the present embodiment, the present embodiment can flexibly determine the installation form corresponding to the installation operation, and when the installation of all the functional modules to the terminal device is implemented by different installation forms, the compiling files to be substantially installed may be different, and compared with the current conventional installation mode, the independent installation of the modules provided in the present embodiment shortens the installation time of the project to a certain extent.

In this embodiment, the target terminal may specifically refer to a terminal device to be installed with a target item, where an android operating system is installed on the target terminal.

Specifically, this step may be automatically performed after implementing S209 above, and in order to implement all the installation of the functional modules in the target project to the target terminal, this step may first determine an installation form according to the version of the android system installed on the target terminal, then select, according to the installation form, a File to be installed from the compiled files in the File directory, and finally install the File to be installed to the target terminal by calling an installation instruction (for example, void installPackages (List < File > apks, boolean reinstall, list < String > installOptions) form, and then execute Shell command monkey-P PACKAGENAME 1 to open a top page of the application software formed by the target project on the target terminal, so as to implement the start operation of the target project on the target terminal.

Further, fig. 2d shows a flowchart for implementing the function module installation determination in the second alternative embodiment of the present invention, and as shown in fig. 2d, the alternative embodiment specifically includes selecting a file to be installed from the file directory according to the determined installation form, and executing the installation operation of the file to be installed to the target terminal and the starting operation of the target item:

s2101, determining a target terminal to be installed.

Specifically, the present embodiment can select a plurality of terminal apparatuses as the installation apparatuses of the target item, which can each be regarded as the target terminal to be installed. It can be known that in the project development, the terminal device to be installed and the computer device adopted by the development target project may be connected through a universal serial bus data line, which devices are connected with the computer device adopted by the development target project may be automatically identified in this step, for example, a Bridge may be established through AndroidDebugBridge, so as to identify that an adb-linked device list exists, and finally, the identified terminal device may be used as the target terminal in this step.

S2102, determining whether the target item is first installed to the target terminal, if so, executing S2103; if not, S2104 is performed.

After the target terminal is determined in the above steps, whether the target item is installed on the target terminal or not can be detected through the step, so that whether the target item is installed on the target terminal for the first time is determined. And performs different operations under different determination results, e.g., S2103 may be performed when it is determined to be the first installation, and S2104 may be performed when it is determined to be the non-first installation.

S2103, determining that the installation form is full installation, and taking compiled files corresponding to all the functional modules in the file catalogue as files to be installed.

In the step, considering the first installation of the target item to the target terminal, if the compiled files of all the functional modules of the target item can be completely installed on the target terminal, the installation form needs to be determined to be full-quantity installation, and under the limit of full-quantity installation, the compiled file groups corresponding to all the functional modules in the file catalogue are equivalent to the files to be installed.

S2104, determining the installation form to be corresponding to the file to be installed according to the system version number of the operating system installed on the target terminal.

When the present alternative embodiment determines that the target item is not the first installation to the target terminal, the operation of S2104 may be performed, where the specific installation form of the target item to the target terminal needs to be determined according to the system version number of the operating system installed on the target terminal, and different files to be installed may be determined according to different installation forms.

Wherein, this step can be further embodied as: acquiring a system version number of an operating system installed on the target terminal; if the system version number is lower than a set version threshold, determining that the installation form is full installation, and taking compiled files corresponding to all the functional modules in the file catalogue as files to be installed; otherwise, determining that the installation form is the designated installation, and taking a compiling file formed by triggering the target compiling task item or the target upgrading compiling task item to execute the compiling operation as a file to be installed.

Specifically, when the system version number is lower than a set version threshold (for example, android 10), the target terminal is considered to have only the authority of full-mount installation, the installation mode can be considered to be full-mount installation at this time, and the corresponding compiled files corresponding to all the functional modules in the file directory are required to be used as files to be installed. When the system version number is higher than or equal to the set version threshold, the task target terminal can have independent installation capability, at this time, the installation form can be determined to be designated installation, and the file to be installed corresponding to the designated installation can be a compiling file formed by triggering the target compiling task item or the target upgrading compiling task item to execute compiling operation.

For example, the obtaining of the file to be installed may be determined by determining an apk path included in the apks list when the INSTALLPACKAGES method is called, where the apk path is equivalent to a cache path of the compiled file generated after the compiling operation is performed on the functional module corresponding to the target compiling task item or the target upgrading compiling task item.

S2105, executing the installation operation of the file to be installed on the target terminal and starting the operation of the target item.

In this embodiment, this step may further include specifying a packet name parameter configured under installOptions parameters: listOf ("-t", "-p", PACKAGENAME) to effect the installation of the file to be installed to the target terminal. And then, the display of the home page of the application software associated with the target project on the target terminal can be realized through corresponding instruction operation. It should be noted that, when the module is independently installed in the above manner, if an independent installation failure is detected, the installation of the target item to the target terminal may be implemented by adopting an installation mode of full installation through a formulated spam policy.

The above optional embodiment of the present embodiment specifically provides an implementation process of the independent installation of the functional module in the present embodiment, where the optional embodiment may implement the independent installation of the dynamic module on the terminal device with the system version number higher than the set version threshold through the identification of the system version number of the connected terminal device, so that the project installation time in the project development test process is effectively saved, and further, the improvement of the project development efficiency is also implemented.

Fig. 2e is an explanatory diagram of the effect of the functional module in the present alternative embodiment when installed on a terminal device with a different android system version number. As shown in fig. 2e, the effect of the installation time spent when installing a target item on each terminal device with different Android system version numbers in different installation forms is mainly shown in the figure.

The item of mobile phone model 27 shown in fig. 2e mainly comprises 5 kinds of mobile phone equipment with different models, and the item of Android version 28 mainly shows system version numbers of Android systems installed on the mobile phone equipment with 5 kinds of different models; the total installation time 29 mainly gives the time taken for 5 different types of mobile phone devices to install target items in a total form; the term of separately installing the dynamic module time 20 mainly gives the time taken for 5 different models of mobile phone devices to achieve the independent installation of the dynamic module in a specified form.

It can be seen that the mobile phone device with the system version number lower than Android10 does not support independent installation of the dynamic module, but the time spent for independent installation is obviously smaller than the time spent for full installation on the mobile phone device with independent installation of the dynamic module. The effect comparison chart provided in fig. 2e of the present embodiment further illustrates that when the method provided in the present embodiment is adopted to implement independent installation of modules, the project development efficiency is effectively improved.

Example III

Fig. 3 is a block diagram of a device for implementing module independence in project development, which is suitable for use in the case of performing a talking-singing music conversion on a voice recorded by a user, wherein the device may be implemented by software or hardware and may be generally integrated on a computer device. As shown in fig. 3, the apparatus includes: an information acquisition module 31, an information generation module 32, and a compiling execution module 33.

An information obtaining module 31, configured to traverse a currently associated target item to obtain each function module included in the target item;

the information generating module 32 is configured to determine an attribution division of each of the function modules in each of preset compiling requirement scenes, and generate a compiling task item corresponding to each of the compiling requirement scenes;

And the compiling execution module 33 is configured to perform a compiling operation on the target function module associated with the corresponding compiling requirement scene after detecting that the target compiling task item is triggered, where the target compiling task item is any compiling task item.

Compared with a conventional method for compiling developed projects, the device for realizing the independence of the modules in project development provided by the third embodiment of the invention can determine the function modules to be compiled in different compiling requirement scenes according to different compiling requirement scenes, and generate compiling task items corresponding to different compiling requirement scenes, so that when the task items are triggered, only the associated function modules in the compiling requirement scenes corresponding to the task items can be compiled. The method realizes the independence of compiling the functional modules in the developed project, effectively shortens the compiling time in the project development, and improves the project development efficiency.

Example IV

Fig. 4 shows a schematic hardware structure of a computer device according to a fourth embodiment of the present invention, and specifically, the computer device includes: a processor and a storage device. At least one instruction is stored in the storage device, and the instruction is executed by the processor, so that the computer device executes the method for realizing the independence of the modules in the project development according to the embodiment of the method.

Referring to fig. 4, the computer device may specifically include: a processor 40, a storage device 41, a display 42, an input device 43, an output device 44, and a communication device 45. The number of processors 40 in the computer device may be one or more, one processor 40 being illustrated in fig. 4. The number of storage means 41 in the computer device may be one or more, one storage means 41 being exemplified in fig. 4. The processor 40, the storage means 41, the display 42, the input means 43, the output means 44 and the communication means 45 of the computer device may be connected by a bus or by other means, in fig. 4 by way of example.

Specifically, in the embodiment, when the processor 40 executes one or more programs stored in the storage device 41, the following operations are specifically implemented: traversing the currently associated target item to obtain each functional module included in the target item; determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene; after the target compiling task item is triggered, compiling operation is carried out on the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

The embodiment of the invention also provides a computer readable storage medium, and a program in the storage medium is executed by a processor of a computer device, so that the computer device can execute the method for realizing the independence of the modules in the project development according to the embodiment. Exemplary, the method for implementing the independence of the modules in the project development according to the above embodiment includes: traversing the currently associated target item to obtain each functional module included in the target item; determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene; after the target compiling task item is triggered, compiling operation is carried out on the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

It should be noted that, for the apparatus, computer device, and storage medium embodiments, since they are substantially similar to the method embodiments, the description is relatively simple, and the relevant points refer to the part of the description of the method embodiments.

From the above description of embodiments, it will be clear to a person skilled in the art that the present invention may be implemented by means of software and necessary general purpose hardware, but of course also by means of hardware, although in many cases the former is a preferred embodiment. Based on such understanding, the technical solution of the present invention may be embodied essentially or in a part contributing to the prior art in the form of a software product, which may be stored in a computer readable storage medium, such as a floppy disk, a Read-Only Memory (ROM), a random access Memory (Random Access Memory, RAM), a FLASH Memory (FLASH), a hard disk, or an optical disk of a computer, where the instructions include a number of instructions for causing a computer device (which may be a robot, a personal computer, a server, or a network device, etc.) to execute the method for implementing the independence of the modules in the project development described in any embodiment of the present invention.

It should be noted that, in the above-mentioned independent implementation device of the module in the project development, each unit and module included are only divided according to the functional logic, but not limited to the above-mentioned division, as long as the corresponding function can be implemented; in addition, the specific names of the functional units are also only for distinguishing from each other, and are not used to limit the protection scope of the present invention.

It is to be understood that portions of the present invention may be implemented in hardware, software, firmware, or a combination thereof. In the above embodiments, the various steps or methods may be implemented in software or firmware stored in a memory and executed by a suitable instruction execution device. For example, if implemented in hardware, as in another embodiment, may be implemented using any one or combination of the following techniques, as is well known in the art: discrete logic circuits having logic gates for implementing logic functions on data signals, application specific integrated circuits having suitable combinational logic gates, programmable Gate Arrays (PGAs), field Programmable Gate Arrays (FPGAs), and the like.

Note that the above is only a preferred embodiment of the present invention and the technical principle applied. It will be understood by those skilled in the art that the present invention is not limited to the particular embodiments described herein, but is capable of various obvious changes, rearrangements and substitutions as will now become apparent to those skilled in the art without departing from the scope of the invention. Therefore, while the invention has been described in connection with the above embodiments, the invention is not limited to the embodiments, but may be embodied in many other equivalent forms without departing from the spirit or scope of the invention, which is set forth in the following claims.

Claims (12)

1. The method for realizing the independence of the modules in the project development is characterized by comprising the following steps of:

traversing the currently associated target item to obtain each functional module included in the target item;

Determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene;

After the target compiling task item is triggered, compiling the associated target functional module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item;

each functional module is provided with a corresponding module attribute, and the module attribute is basic or dynamic; the APP module is a basic functional module, and the dynamic module is a dynamic functional module;

The compiling requirement scene comprises:

Compiling and installing all the functional modules with module attributes as basic types, recompiling all the functional modules with module attributes as basic types and installing all the functional modules, recompiling any one of the functional modules with module attributes as dynamic types and installing all the functional modules, recompiling all the functional modules and installing;

In a demand scene that only any functional module with the dynamic module attribute is recompiled and all functional modules are installed, each functional module with the dynamic module attribute is correspondingly provided with a compiling task item;

determining attribution division of each functional module in each preset compiling requirement scene, and generating compiling task items corresponding to each compiling requirement scene, wherein the determining comprises the following steps:

analyzing and determining module attributes of the functional modules;

Aiming at each compiling requirement scene, determining a functional module belonging to the compiling requirement scene according to the module attribute and scene description information of the compiling requirement scene;

and generating compiling task items required by compiling the associated functional modules according to compiling generation rules corresponding to the compiling requirement scenes.

2. The method of claim 1, wherein each of the compilation task items is contained in a first compilation task list presented in a view region of a development platform upon which the target item depends;

the naming information of the compiling task item at least comprises:

And parameter names of the target items, a construction type buildType and requirement scene description information.

3. The method according to claim 1, further comprising, after obtaining each functional module included in the target item:

extracting each dynamic module with dynamic module attribute from each functional module;

generating upgrade compiling task items corresponding to the dynamic modules respectively according to a preset upgrade compiling generating rule;

wherein each of the upgraded compilation task items is contained in a second compilation task list presented within a view region of a development platform upon which the target item depends.

4. A method according to claim 3, further comprising:

after determining that the running condition of a target upgrading compiling task item is met currently, executing compiling operation on a target dynamic module corresponding to the target upgrading compiling task item, wherein the target upgrading compiling task item is any upgrading compiling task item.

5. The method of claim 4, wherein the operating conditions of the target upgrade compilation task item are:

and monitoring that the target upgrading compiling task item is triggered and started, and performing compiling operation on the target dynamic module associated with the target compiling task item based on the corresponding compiling task item.

6. The method of claim 4, wherein the performing a compiling operation for the target dynamic module corresponding to the target upgrade compiling task item comprises:

determining an associated module on which the compiling operation of the target dynamic module depends;

when the compiling of the target dynamic module is started to be executed, the compiling of each associated module is skipped, and the current compiling information of the target dynamic module is obtained;

and multiplexing the historical compiling information of each associated module and combining the current compiling information to form a compiling file of the compiling operation.

7. The method of any one of claims 1-6, further comprising:

after the compiling operation of the functional module to be compiled is completed, the correspondingly formed compiling file is cached into a set file directory, wherein the file directory is under the root directory of the target item;

and selecting a file to be installed from the file catalogue according to the determined installation form, and executing the installation operation of the file to be installed to a target terminal and the starting operation of the target item.

8. The method according to claim 7, wherein the selecting a file to be installed from the file directory according to the determined installation form, and performing an installation operation of the file to be installed to a target terminal and a start operation of the target item, includes:

determining a target terminal to be installed, and determining whether the target item is first installed to the target terminal;

If yes, determining that the installation form is full installation, and taking compiled files corresponding to all the functional modules in the file catalogue as files to be installed;

If not, determining the installation form to be a corresponding file to be installed according to the system version number of the operating system installed on the target terminal;

and executing the installation operation of the file to be installed to the target terminal and starting the operation of the target item.

9. The method according to claim 8, wherein the determining the installation form to correspond to the file to be installed according to the system version number of the operating system installed on the target terminal includes:

Acquiring a system version number of an operating system installed on the target terminal;

If the system version number is lower than a set version threshold, determining that the installation form is full installation, and taking compiled files corresponding to all the functional modules in the file catalogue as files to be installed; otherwise the first set of parameters is selected,

And determining the installation form as the designated installation, and taking a compiling file formed by triggering the target compiling task item or the target upgrading compiling task item to execute the compiling operation as the file to be installed.

10. An apparatus for realizing independence of modules in project development, comprising:

the information acquisition module is used for traversing the currently associated target item to acquire each functional module included in the target item;

The information generation module is used for determining attribution division of each functional module in each preset compiling requirement scene and generating compiling task items corresponding to each compiling requirement scene;

the compiling execution module is used for carrying out compiling operation on the associated target function module under the corresponding compiling requirement scene after the target compiling task item is triggered, wherein the target compiling task item is any compiling task item;

each functional module is provided with a corresponding module attribute, and the module attribute is basic or dynamic; the APP module is a basic functional module, and the dynamic module is a dynamic functional module;

The compiling requirement scene comprises:

Compiling and installing all the functional modules with module attributes as basic types, recompiling all the functional modules with module attributes as basic types and installing all the functional modules, recompiling any one of the functional modules with module attributes as dynamic types and installing all the functional modules, recompiling all the functional modules and installing;

In a demand scene that only any functional module with the dynamic module attribute is recompiled and all functional modules are installed, each functional module with the dynamic module attribute is correspondingly provided with a compiling task item;

the information generation module is specifically configured to: analyzing and determining module attributes of the functional modules; aiming at each compiling requirement scene, determining a functional module belonging to the compiling requirement scene according to the module attribute and scene description information of the compiling requirement scene; and generating compiling task items required by compiling the associated functional modules according to compiling generation rules corresponding to the compiling requirement scenes.

11. A computer device, comprising:

one or more processors; a storage means for storing one or more programs;

The one or more programs are executed by the one or more processors to cause the one or more processors to implement the method of independence of the modules in the project development of any one of claims 1-9.

12. A computer readable storage medium having stored thereon a computer program, which when executed by a processor, implements a method of independence of modules in a development of a project as claimed in any one of claims 1-9.