CN112527306A

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

Info

Publication number: CN112527306A
Application number: CN202011165177.9A
Authority: CN
Inventors: 施旺
Original assignee: Bigo Technology Singapore Pte Ltd
Current assignee: Bigo Technology Singapore Pte Ltd
Priority date: 2020-10-27
Filing date: 2020-10-27
Publication date: 2021-03-19

Abstract

The embodiment of the invention discloses a method, a device, equipment and a medium for realizing independence of a module in project development. Traversing the currently associated target project to obtain each functional module included in the target project; determining attribution division of each functional module in each preset compiling demand scene, and generating compiling task items corresponding to each compiling demand scene; and after the target compiling task item is triggered, compiling the associated target function module in the corresponding compiling demand scene. By the method, the functional module to be compiled under different compiling requirement scenes can be determined, and the compiling task item is generated corresponding to the different compiling requirement scenes, so that only the functional module related under the compiling requirement scene corresponding to the task item can be compiled when the task item is triggered. The method realizes the independence of compiling of 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 independence of modules in the project development.

Background

With the popularization of the Android App Bundle, AAB, which is a new generation of Android packaging/publishing technology, the development of application software projects based on AAB organizational structures is also increasingly popular. The function modules developed based on the AAB organizational structure comprise dynamic modules, and the dynamic modules have the characteristics that when a user installs the opened application software for the first time, the application software does not need to be installed together, and the function modules can be dynamically downloaded and installed when needed. Meanwhile, in the project development based on the AAB organization architecture, the architecture of the project can be clearer along with the introduction of the dynamic module, a user can download the dynamic module as required to reduce the size of an application package, and therefore, the independence of downloading and installing the functional module when the user uses the module is realized.

Generally, for application software project development for the android system, compiling of developed function modules and installing of the compiled function modules on terminal equipment are required in a development stage to view operation effects. The existing compiling and installing implementation of the function module is mainly based on a self-contained compiling function in a project development platform, however, through the compiling mode, when a compiling requirement (such as a certain function module is developed or a certain function module is modified) exists, all the function modules in the developed application software need to be compiled each time, and then all the compiled modules need to be installed during installation.

By adopting the existing compiling and installing mode, for the development of medium and large-sized projects, along with the iteration of the projects, the code scale of the projects is larger and larger, and the time spent on compiling and installing in the daily development process is longer. For example, the full-scale compilation and installation of some medium-large projects may take 10 minutes or more, which may seriously affect the project development efficiency of the application software.

Disclosure of Invention

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

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

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

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

and after triggering of a target compiling task item is monitored, compiling the associated target function 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 module independence in project development, including:

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

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

and the compiling execution module is used for compiling the associated target function module in the corresponding compiling demand scene after monitoring that 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 device, including:

one or more processors;

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 the independence of the modules in the 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, on which a computer program is stored, where the computer program, when executed by a processor, implements the method for implementing the independence of the modules in the project development provided in the embodiment of the first aspect of the present invention.

In the method, the apparatus, the device and the medium for realizing independence of modules in project development provided by the embodiment of the present invention, a currently associated target project is traversed to obtain each functional module included in the target project; then determining attribution division of each functional module in each preset compiling demand scene, and generating compiling task items corresponding to each compiling demand scene; and finally, after triggering of a target compiling task item is monitored, compiling the associated target function 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 functional module to be compiled under different compiling requirement scenes according to different compiling requirement scenes, and generates the compiling task item corresponding to the different compiling requirement scenes, so that only the functional module associated under the compiling requirement scene corresponding to the task item can be compiled when the task item is triggered. The method realizes the independence of compiling of 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 flowchart illustrating a method for implementing module independence in project development according to an embodiment of the present invention;

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

fig. 2 is a schematic flow chart illustrating 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 task item presentation in the method according to the second embodiment of the present invention;

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

FIG. 2c is a diagram showing a comparison of the compiling effect of the functional module by using several different compiling methods according to the embodiment of the present invention;

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

fig. 2e is a diagram showing an effect of the functional module in the optional embodiment when the functional module is installed on a terminal device with different android system version numbers;

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

fig. 4 is a schematic diagram of a 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, embodiments of the present invention will be described in detail with reference to the accompanying drawings. It should be understood that the described embodiments are only some embodiments of the invention, and not all embodiments. In addition, the embodiments and features of the embodiments in the present invention may be combined with each other without conflict.

In the description of the present application, it is to be understood that the terms "first," "second," "third," and the like are used solely to distinguish one from another and are not necessarily used to describe a particular order or sequence, nor are they to be construed as indicating or implying relative importance. The specific meaning of the above terms in the present application can be understood by those of ordinary skill in the art as appropriate.

Example one

Fig. 1 is a flowchart illustrating a method for implementing a module in project development independently according to an embodiment of the present invention, where the method is suitable for independent management of a functional module in a developed project, and the method can be executed by an apparatus for implementing a module in project development independently, where the apparatus can be implemented by software and/or hardware, and can be generally integrated as a plug-in on a computer device installed with software of a project development platform.

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. Various application software installed on the intelligent mobile terminal needs to be developed on the premise of compatibility of an Android operating system, when application software project development is carried out on an Android application software development platform Android Studio, when new function codes are added or existing codes are modified in the application software, a used function module in the application software needs to be compiled again through a compiling tool carried by the Android Studio, and then the compiled file is installed again (installation in a development stage) on the mobile terminal.

In order to better understand the process of compiling based on the self-contained compiling tool of the Android Studio platform, fig. 1a shows a current modular project architecture diagram based on an AAB dynamic module in the Android application software project development, and a description of an implementation process of compiling operation performed by the current authority is given in combination with the architecture diagram: first, the current AAB-based project architecture differs from the original traditional Android modular architecture in that Dynamic-feature modules, such as Dynamic module a and Dynamic module B in fig. 1a, are introduced, which are next to APP modules. Then, when performing compilation in the Android Studio, if the compilation mode is defaulted to compilation with a self-contained compilation tool and the version of the Android operating system on the connected terminal device is above a set version number (e.g., Android5.0), the existing compilation implementation needs all functional modules in the App module and all dynamic modules to participate in the execution of the compilation task, that is: and executing the operation of the app, associatedDebug, dynamic feature-a, associatedDebug, dynamic feature-b and associatedDebug. Three compiled files in apk format can then be obtained: apk, Dynamicfeature-a.apk and Dynamicfeature-b.apk; finally, the installation of the obtained compiled files to the terminal equipment is realized by running the installation instruction.

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

It should be noted that the method for implementing independence of modules in project development provided in this embodiment may be used as a plug-in, and before compiling or even installing and managing the functional modules in the target project, the formed plug-in needs to be introduced into the selected project to be subjected to independence management. Specifically, the plug-in executing the method provided by the embodiment may be incorporated into the project to be managed independently through the corresponding path configuration. For example, the path configuration may be: xxxx, yyyy, mobile, android, toolkit, plugin, 2.0.1, where xxxx and yyyy may be information items associated with an item, such as an item name, and may be filled differently according to different items. Then, it is necessary to perform a configuration operation of presenting the content of the introduced plug-in one step, such as: application plugin,' xxxx.

The configured project is equivalent to a function of independent management for compiling and even installing the functional module by using the method provided by the embodiment of the present invention, and specifically, as shown in fig. 1, a method for realizing independence of a module in project development provided by an embodiment of the present invention specifically includes 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 considered as an item on which the plug-in configuration operation is performed, and may be considered 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, and these modules are collectively referred to as functional modules in this embodiment.

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 the functional module is programmed may be preset according to a main use situation frequently encountered in the project development process, and it can be known that the functional modules that need to be compiled in different compiling requirement scenarios may be different, and in this step, the attribution division from the obtained functional module to different compiling requirement scenarios may be performed from among the obtained functional modules. And then generating related compiling task items corresponding to different compiling demand scenes respectively.

Specifically, in this step, it may be determined which functional modules are suitable for compilation in the compilation demand scenario through relevant scenario description information corresponding to different compilation demand scenarios, and then a compilation task item triggering compilation of the associated functional module is generated. Wherein the compilation task item can be presented in a view area of the project development tool for a developer to click to trigger when needed.

In this embodiment, the functional modules are further optimized, for example, each of the functional modules may be optimized to have a corresponding module attribute, and the module attribute is a basic type or a dynamic type.

It should be noted that, in the process of executing traversal of the function module in S101, each function module may be obtained, and meanwhile, a module attribute that the function module has may also be determined according to some prefix information of the function module, for example, an App module with prefix information of "com.android.

Meanwhile, the further optimizing the compilation requirement scenario in this embodiment may include: compiling and installing all function modules with module attributes as basic types only, recompiling and installing all function modules with any function module with module attributes as dynamic types only, and recompiling and installing all function modules with module attributes as dynamic types only; in a demand scenario where only any one of the functional modules with the dynamic module attribute is recompiled and all the functional modules are installed, one compiling task item is correspondingly present for each functional module with the dynamic module attribute.

In this embodiment, 5 compiling requirement scenarios with different requirement conditions are given above, through the operation in this step, the functional modules whose attribution is divided to the compiling requirement scenarios can be determined respectively, and for the compiling requirement scenarios in which only compiling and installing all the functional modules whose module attributes are basic types are performed, for example, in this step, all the functional module attributions whose module attributes are basic types can be divided to the scenario.

For another example, in a compiling demand scenario in which only any one functional module with a dynamic module attribute is recompiled and all functional modules are installed, the functional modules with the dynamic module attribute can be respectively regarded as an independent individual attribute and divided into the scenarios, and meanwhile, in the demand scenario, a compiling task item can be respectively generated corresponding to each functional module, that is, in the demand scenario, the same number of compiling task items as the dynamic functional modules exist.

It can be seen that each compilation requirement scenario is also accompanied by a compiled installation requirement, and this embodiment further provides implementation of installation of the functional module, which can implement installation of the functional module to the terminal device according to the installation requirement in the compilation requirement scenario at the installation stage of the provided method.

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

In addition, the present embodiment may further perform optimization limitation on the compiling task item. Specifically, the compiling task item generated in this step may be included as a subtask in a first compiling task list, and the first compiling task list may be displayed in a development platform on which the target item depends, and is mainly displayed in a view area of the development platform.

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

Meanwhile, the embodiment also defines naming information of the compiling task items, and for each compiling task item, the naming of the task item first includes a parameter name navigator and a construction type buildType of the target item, and then includes description information of a compiling demand scene corresponding to the compiling task item, such as a compiling task item named GpEngDebug _ runOnlyBase, where GpEngDebug is the navigator + buildType in the target item, and runOnlyBase is description information for compiling only a basic functional module.

S103, after the fact that a target compiling task item is triggered is monitored, compiling operation is conducted on a target function module associated in a corresponding compiling demand scene, wherein the target compiling task item is any compiling task item.

The steps specifically realize the monitoring of the compiling task item and the compiling and executing of the target function module associated with the compiling task item.

Specifically, each generated compiling task item may be triggered by an operation of a developer (e.g., double-clicking a compiling task item), and in this step, it may be monitored whether the developer performs a triggering operation on each compiling task item, and the compiling task item on which the triggering operation is monitored is regarded as a target compiling task item. The target compiling task item corresponds to one of the compiling requirement scenarios, the corresponding compiling requirement scenario has a related functional module, which is recorded as a target functional module in this embodiment, and the compiling operation on the target functional module can be started after the target functional module is determined.

Compared with the conventional method for compiling the developed project, the method for realizing independence of the modules in the project development provided by the embodiment of the invention can determine the functional modules to be compiled under different compiling requirement scenes according to different compiling requirement scenes, and generates the compiling task items corresponding to the different compiling requirement scenes, so that only the related functional modules under the compiling requirement scenes corresponding to the task items can be compiled when the task items are triggered. The method realizes the independence of compiling of 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 flowchart illustrating a method for implementing module independence in project development according to a second embodiment of the present invention, where this embodiment is optimized based on the foregoing embodiment, and in this embodiment, determining attribution division of each functional module in each preset compiling requirement scenario, and generating a compiling task item corresponding to each compiling requirement scenario is further embodied as: analyzing and determining the module attribute of each functional module; determining a function module which belongs to each compiling demand scene according to each module attribute and scene description information of the compiling demand scene; and generating compiling task items required by compiling the associated functional modules according to the compiling generation rule corresponding to the compiling demand scene.

In addition, in this embodiment, after obtaining each function module included in the target item, the optimization includes extracting each dynamic module whose module attribute is dynamic from each function module; and respectively generating upgrading and compiling task items corresponding to the dynamic modules according to a preset upgrading and compiling generation rule.

Meanwhile, on the basis of the optimization, the present embodiment further includes executing a compiling operation on the target dynamic module corresponding to the target upgrade compiling task item after determining that the running condition of the target upgrade compiling task item is currently satisfied, where the target upgrade compiling task item is any upgrade compiling task item.

As shown in fig. 2, a method for implementing module independence in project development provided by 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 including the method provided by the embodiment is introduced into the developed project, which is equivalent to the currently associated target project, and then the functional modules with different module attributes can be obtained through the step.

The following S202 to S204 of this embodiment give specific implementations of generating the compiling task item.

And S202, analyzing and determining the module attribute of each functional module.

In this embodiment, the module attributes of the functional modules may be obtained by analyzing the obtained functional modules.

S203, aiming at each compiling demand scene, determining the function module which belongs to the compiling demand scene according to the module attributes and the scene description information of the compiling demand scene.

In this embodiment, the compilation requirement scenario preset according to the main usage scenario that may occur in the development process is mainly expressed by the corresponding scenario description information, and this step and the following S204 may be equivalent to an operation performed on each compilation requirement scenario.

Specifically, for each compiling requirement scenario, the corresponding scenario description information includes the relevant description of the functional module that is expected to be compiled in the compiling requirement scenario, so that after the module attributes of each functional module are known, which functional modules are associated in the compiling requirement scenario corresponding to the scenario can be determined by analyzing the scenario description information.

For example, assuming that a compiling demand scenario is only recompiling all the functional modules with the module attribute being dynamic and installing all the functional modules, it can be analyzed from the corresponding scenario description information that the functional modules that the compiling demand scenario desires to be compiled are all the functional modules with the module attribute being dynamic, and therefore all the functional modules with the module attribute being dynamic can be determined as the functional modules belonging to the compiling demand scenario.

And S204, generating compiling task items required by compiling the associated functional modules according to the compiling generation rule corresponding to the compiling demand scene.

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

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

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

And S205, extracting each dynamic module with dynamic module attributes from each functional module.

This step can be regarded as a parallel step of S202, and also needs to be executed after S201, so it can be understood that, in the method flow steps provided in this embodiment, the sequence number of each step is not limited to the specific execution sequence of the relevant step, 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 obtaining each functional module in S201, all functional modules with dynamic module attributes are further extracted from each functional module, and these functional modules are recorded as dynamic modules. It can be seen that the compiling task item in another form generated by this step and the following step S206 is only for the functional module whose module attribute is dynamic, and each compiling task item generated in this form corresponds to a dynamic module.

And S206, respectively generating upgrading and compiling task items corresponding to the dynamic modules according to a preset upgrading and compiling generation rule.

It should be noted that, in this embodiment, each compiling task item generated by this step is actually equivalent to a second upgrade of each dynamic module on the basis of the corresponding compiling task item, and this embodiment records the generation rule used for generating these compiling task items as an upgrading compiling generation rule, and correspondingly records the finally generated compiling task item as an upgrading compiling task item. Meanwhile, when the upgrade compiling task item is generated through the step, the upgrade compiling task item is only specific to each dynamic module, and the compiling requirement scenario is not limited.

Specifically, the upgrade compilation generation rule in this step may be mainly used to limit the code information extraction of the corresponding dynamic module when different upgrade compilation task items are generated, and by extracting the code information of different dynamic modules, upgrade compilation task items associated with different dynamic modules are correspondingly generated.

In addition, the present embodiment further defines the upgrade compilation task item, for example, the present embodiment optimizes that each of the generated upgrade compilation task items is included in the second compilation 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 compilation task list and the first compilation task item may correspond to two parallel task lists, which may be simultaneously presented in the view area of the development platform on which the target project depends.

The embodiment may use naming information similar to the compiling task item described above to perform related naming of the task item. Because the upgrading and compiling task item only aims at the dynamic module, the corresponding compiling demand scene can be defaulted to be any functional module only with the attribute of the recompiling module being dynamic type, and all the functional modules are installed. Therefore, the upgrade compilation task item naming may include, in addition to the related information of the viewer + buildType, the related expression of the functional description information corresponding to the task item, for example, the functional line description information is the fast recompilation of the dynamic module 1, and the related expression of the functional line description information in the upgrade compilation task item naming may be runAll _ update _ dynamic 1.

For example, fig. 2a shows an effect presentation diagram of the presentation of the compiling task item in the method provided by the second embodiment of the invention. As shown in fig. 2a, a graph view area under the Android Studio of the development platform is mainly provided, and the graph view area includes a first compiling task list 21 named rundynamic and a second compiling task list 22 named rundynamiclite. It can be seen that the rundynamic list includes a compiling task item 211 corresponding to a 5-type compiling demand scene, wherein only any functional module with dynamic module attributes is recompiled and a compiling task item is respectively presented for each functional module with dynamic module attributes in the demand scene of all the functional modules; the rundynamiclite list mainly includes an upgrade compiling task item 221 corresponding to each dynamic module.

And S207, after monitoring that a target compiling task item is triggered, compiling the associated target function module in the corresponding compiling demand scene, wherein the target compiling task item is any compiling task item.

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

And S208, after the current running condition of the target upgrading compiling task item is determined to be met, executing the compiling operation of the target dynamic module corresponding to the target upgrading compiling task item, wherein the target upgrading compiling task item is any upgrading compiling task item.

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

In this embodiment, the running condition for triggering the compiling operation of the target dynamic module to be executed may be specifically set according to an incidence relation between the upgrade compiling task item and the compiling task item, and considering that the upgrade compiling task item is an upgrade of the compiling task item in the compiling operation process, it is necessary to consider an influence of whether the compiling task item is executed on the upgrade compiling task item when the running condition is set.

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

Specifically, the running condition includes two stages of determination, one stage is to monitor that the target upgrade compilation task item displayed in the view area is triggered by a trigger operation by a developer, and the second stage is to determine that the dynamic module corresponding to the triggered target upgrade compilation task item has been compiled based on the compilation task item corresponding to the triggered target upgrade compilation task item.

It can be understood that the compiling operation performed on the target dynamic module by this step may be regarded as an optimized upgrade when the compiling operation is performed based on the corresponding compiling task item, and the compiling operation of the target dynamic module achieved by this step takes shorter compiling time than that when the compiling operation is performed based on the compiling task item. In addition, when it is monitored that the developer triggers 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 which cannot realize dynamic module compiling through the task item can be carried out on the current interface of the development platform on which the target project depends.

It should be noted that, in this embodiment, a core idea of upgrading a compiling task item is further provided relative to a compiling task item of a dynamic module, and the core idea can be described as follows: for the functional module a with dynamic module attributes, when the above-mentioned compiling task item associated with the functional module a is used to implement independent compiling of the functional module, the compiling instruction to be executed may be expressed as a dynamic feature-a: an assembly debug, and analyzing the compiling process of this compiling task item can find that it also depends on each functional module with module attributes as a base type and many subtasks in the library module in the project architecture shown in fig. 1a, and when compiling these subtasks, some time-consuming tasks (such as java and kotlinc, etc.) are executed, especially some variables in the target project and need to be updated in real time, but they are executed again each time of compiling is performed, and such compiling dependency makes unnecessary time-consuming compiling even if only each dynamic module is independently compiled. In this embodiment, when only the code of the dynamic module changes, a compiling mode is designed, and in the compiling stage, only the compiling of the subtasks related to the dynamic module can be realized, and other internal unchanged associated modules can directly reuse the information that has been compiled before.

Specifically, fig. 2b is a flowchart illustrating implementation of compiling a target dynamic module in an independent implementation of a module in project development according to a second embodiment of the present invention. As shown in fig. 2b, this embodiment further embodies the following steps of executing the compiling operation on the target dynamic module corresponding to the target upgrade compiling task item:

s2081, determining the related module which the target dynamic module compiling operation depends on.

Based on the above description of the core idea of designing the upgrade compilation task item, it can be known that, when the compilation operation of the target dynamic module is implemented by the target upgrade compilation task item, each associated module on which the compilation operation of the target dynamic module depends can be determined by the present step.

S2082, when the compiling of the target dynamic module is started and executed, the compiling of each related 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 to false or a command line for skipping the execution of the associated module is directly generated, so that the compiling execution of the associated module is skipped, and therefore only some subtasks of the target dynamic module can be compiled and current compiling information related to the target dynamic module is generated.

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

In this step, the historical compiling information for the association module may be acquired from a pre-cache directory and multiplexed, and the historical compiling information and the current compiling information determined in the above step are combined to form a compiling file corresponding to the compiling operation performed on the target dynamic module.

The method for realizing the independence of the modules in the project development, which is provided by the embodiment of the invention, embodies the generation operation of the compiling task item, and increases the generation operation of another form of upgrading and compiling task item required by compiling the functional modules 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 demand scene, so that the time spent by compiling the functional module is saved, and the independent compiling operation aiming at the dynamic module is further upgraded and compiled again. Therefore, the time spent by independent compiling of the dynamic module is saved to the maximum extent, the development efficiency of the project is effectively improved, and the development period of the project is shortened.

For example, fig. 2c is a comparison graph of the effect of compiling the functional module by using several different compiling methods in the embodiment of the present invention. AS shown in fig. 2c, an effect of compiling time spent on compiling a certain dynamic module in a different compiling manner in a target item is mainly shown, where the module 23 shown in fig. 2c mainly includes 4 different dynamic modules, an item of a run button 24 of the AS is equivalent to the compiling time spent on adopting the existing compiling manner, an item of a run dynamic 25 is equivalent to the compiling time spent on realizing compiling based on a compiling task item in a first compiling task list in the compiling method provided by the embodiment, and an item of a run dynamic lite 26 is equivalent to the compiling time spent on realizing compiling based on an upgrading compiling task item in a second compiling task list in the compiling method provided by the embodiment.

It can be seen that the compiling time for compiling each dynamic module by using the run button 24 of the AS is longest, the compiling time for compiling each dynamic module by using the run dynamic 25 is obviously shortened compared with the prior art, and the compiling time for compiling each dynamic module by using the run dynamic lite 26 is shortest. The comparison of the effect provided by fig. 2c in this embodiment further illustrates that the efficiency of project development is effectively improved when the method provided by this embodiment is used to implement module-independent compilation.

Meanwhile, as an optional embodiment of the second embodiment of the present invention, on the basis of the method for implementing independence of the module in the project development provided in the above-mentioned embodiment, the optional embodiment further optimizes and increases the relevant operations of implementing independence of the functional module on installation, and as shown in fig. 2 provided in the second embodiment, the optional embodiment further includes the following operations with respect to the specific implementation of independence of the functional module on installation operation:

it is to be understood that the following steps in this alternative embodiment may be specifically executed after executing S103 in the first embodiment, or may be executed after executing S207 or S208 in this embodiment, and are specifically configured to implement installation and operation of a compiled file formed after compiling the function module onto the terminal device, and implement self-starting of the target item on the terminal device after completing installation.

And S209, after the compiling operation of the functional module to be compiled is completed, caching the correspondingly formed compiled file into a set file directory.

In this embodiment, the functional module to be compiled in this step may specifically refer to a target functional module corresponding to a triggered target compiling task item, or may refer to a target dynamic module corresponding to a target upgrading compiling task item meeting an operating condition.

Wherein the file directory is under a 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 functional module to be compiled completes the compiling operation may be placed in the file directory of the root directory, where rundynamic may be regarded as a file name of the file directory of the cache compiled file, and the file name may be set correspondingly according to a name of a task list including the compiling task item.

In this embodiment, the file directory caches compiled files of each currently compiled function module, and also caches apk compiled files of other currently uncompiled function modules, where the compiled files may be historical compiled files that have been previously stored in the file directory, and may be directly reused during installation operation, and if compiled files of some function modules are not stored in the file directory, the compiling operation of the function modules is automatically triggered, so as to generate and store related compiled files in the file directory.

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

After the functional module to be compiled is compiled, the present embodiment can automatically execute the installation operation from the functional module to the terminal device. It should be understood that, as can be seen from the above description of the compiling requirement scenario in this embodiment, different compiling requirement scenarios include relevant limitations for installing the functional module, and installation of all functional modules in the target item needs to be implemented in each compiling requirement scenario.

Therefore, the embodiment is basically equivalent to the realization of automatic installation of all functional modules in a target project, but on the basis of independent compilation of the functional modules by the method in the embodiment, the embodiment can also flexibly determine the installation form corresponding to the installation operation, and by the difference of the installation forms, when the installation of all the functional modules to the terminal equipment is realized, compiled files to be installed may be different substantially, and compared with the conventional installation form at present, the independent installation of the modules provided by the 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 that is to perform target project installation, and an android operating system is installed on the target terminal.

Specifically, this step may be automatically executed after implementing the above-mentioned S209, and to implement the complete installation of the function module in the target item 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 a File to be installed from the compiled File of the File directory according to the installation form, finally install the File to be installed to the target terminal in a form of calling an installation instruction (e.g., List < File > apps, bolt relation, List < String > install operations), and then may execute the Shell command monkey-p package name 1 to open a top page of the application software formed by the target item on the target terminal, so as to implement the start operation of the target item on the target terminal.

Further, fig. 2d shows a flowchart for implementing function module installation determination in the second optional embodiment of the present invention, and as shown in fig. 2d, this optional embodiment specifically implements:

s2101, a target terminal to be installed is determined.

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

S2102, determining whether the target item is installed to the target terminal for the first time, 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 to the target terminal for the first time or not is determined. And performs different operations under different determination results, e.g., S2103 may be performed when it is determined as first-time installation, and S2104 may be performed when it is determined as non-first-time installation.

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

In the step, the first installation of the target project to the target terminal is considered, if the compiled files of all the functional modules of the target project can be completely installed on the target terminal, the installation form needs to be determined as full installation, and under the limitation of full installation, the compiled file groups corresponding to all the functional modules in the file directory are all regarded as files to be installed.

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

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

Wherein, the 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 the compiled files corresponding to all the functional modules in the file directory as files to be installed; otherwise, determining that the installation form is the specified installation, and taking a compiled 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 (such as Android 10), it is considered that the target terminal only has the permission of full installation, at this time, the installation form may be considered as full installation, and correspondingly, the compiled files corresponding to all the functional modules in the file directory need 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 the independent installation capability, the installation form can be determined as the specified installation, and the corresponding file to be installed under the specified installation can be a compiled file formed by triggering the target compiling task item or the target upgrading compiling task item to execute the compiling operation.

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

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

In this embodiment, in this step, the packet name specifying parameter configured under the instruction options parameter may be further used: listOf ("-t", "-p", packageName) to enable the installation of the file to be installed to the target terminal. And then, displaying the home page of the application software associated with the target project on the target terminal through corresponding instruction operation. It should be noted that, in the embodiment, when the module is independently installed in the above manner, if it is monitored that the independent installation fails, the installation of the target item to the target terminal may be implemented by using a full-installation mode through a formulated bottom-pocket policy.

The optional embodiment of this embodiment specifically provides a process for implementing independent installation of the function module in this embodiment, and this optional embodiment may implement independent installation of the dynamic module on a terminal device whose system version number is higher than a set version threshold value by identifying the system version number of the connected terminal device, thereby effectively saving project installation time in a project development test process, and further implementing improvement of project development efficiency.

For example, fig. 2e is a diagram showing an effect of the functional module in the optional embodiment when the functional module is installed on a terminal device with different android system version numbers. As shown in fig. 2e, an effect showing an installation time spent when one target item is installed on each terminal device with different Android system version numbers in different installation forms is mainly shown.

The mobile phone model 27 shown in fig. 2e mainly includes 5 mobile phone devices of different models, and the Android version 28 mainly shows system version numbers of Android systems installed on the mobile phone devices of 5 different models; the total installation time 29 mainly gives the time spent by the mobile phone devices of 5 different models for installing the target project in a total form; the term of the dynamic module independent installation time 20 mainly gives the time taken by 5 mobile phone devices of different models to realize 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 that of the Android10 does not support independent installation of the dynamic module, and the time spent on adopting independent installation of the dynamic module is obviously less than that spent on full installation. The comparison of the effects provided in fig. 2e of this embodiment further illustrates that the efficiency of project development is effectively improved when the method provided in this embodiment is used to implement module-independent installation.

EXAMPLE III

Fig. 3 is a block diagram of an apparatus for implementing independent modules in project development according to a third embodiment of the present invention, where the apparatus is suitable for use in converting rap music from a user recorded voice, and the apparatus 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 compilation execution module 33.

The information acquisition module 31 is configured to traverse a currently associated target item to acquire each function module included in the target item;

the information generating module 32 is configured to determine attribution division of each functional module in each preset compiling demand scenario, and generate a compiling task item corresponding to each compiling demand scenario;

and the compiling execution module 33 is configured to, after monitoring that a target compiling task item is triggered, perform compiling operation on a target function module associated in a corresponding compiling demand scenario, where the target compiling task item is any compiling task item.

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

Example four

Fig. 4 is a schematic diagram of a hardware structure of a computer device according to a fourth embodiment of the present invention, 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 independent implementation method of the module 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, and one processor 40 is taken as an example in fig. 4. The number of the storage devices 41 in the computer apparatus may be one or more, and one storage device 41 is taken as an example 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 in another way, as exemplified by the bus connection in fig. 4.

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 project to obtain each functional module included in the target project; determining attribution division of each functional module in each preset compiling demand scene, and generating compiling task items corresponding to each compiling demand scene; and after triggering of a target compiling task item is monitored, compiling the associated target function module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

An embodiment of the present invention further provides a computer-readable storage medium, where when a program in the storage medium is executed by a processor of a computer device, the computer device is enabled to execute the method for implementing module independence in project development according to the embodiment. Illustratively, the method for realizing the independence of the modules in the project development according to the above embodiments includes: traversing the currently associated target project to obtain each functional module included in the target project; determining attribution division of each functional module in each preset compiling demand scene, and generating compiling task items corresponding to each compiling demand scene; and after triggering of a target compiling task item is monitored, compiling the associated target function module under the corresponding compiling requirement scene, wherein the target compiling task item is any compiling task item.

It should be noted that, as for the embodiments of the apparatus, the computer device, and the storage medium, since they are basically similar to the embodiments of the method, the description is relatively simple, and in the relevant places, reference may be made to the partial description of the embodiments of the method.

From the above description of the embodiments, it is obvious for those skilled in the art that the present invention can be implemented by software and necessary general hardware, and certainly, can also be implemented by hardware, but the former is a better embodiment in many cases. Based on such understanding, the technical solutions of the present invention may be embodied 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 (RAM), a FLASH Memory (FLASH), a hard disk or an optical disk of a computer, and includes several instructions to enable a computer device (which may be a robot, a personal computer, a server, or a network device) to execute the method for implementing the modules in the project development according to any embodiment of the present invention.

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

It should 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 memory and executed by suitable instruction execution devices. For example, if implemented in hardware, as in another embodiment, any one or combination of the following techniques, which are known in the art, may be used: a discrete logic circuit having a logic gate circuit for implementing a logic function on a data signal, an application specific integrated circuit having an appropriate combinational logic gate circuit, a Programmable Gate Array (PGA), a Field Programmable Gate Array (FPGA), or the like.

It is to be noted that the foregoing is only illustrative of the preferred embodiments of the present invention and the technical principles employed. 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, although the present invention has been described in greater detail by the above embodiments, the present invention is not limited to the above embodiments, and may include other equivalent embodiments without departing from the spirit of the present invention, and the scope of the present invention is determined by the scope of the appended claims.

Claims

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

2. The method of claim 1, wherein each of the functional modules has a corresponding module attribute, and the module attribute is a basic type or a dynamic type;

the compilation requirement scenario includes:

compiling and installing all function modules with module attributes as basic types only, recompiling and installing all function modules with any function module with module attributes as dynamic types only, recompiling and installing all function modules with module attributes as dynamic types only, and recompiling and installing all function modules;

in a demand scenario where only any one of the functional modules with the dynamic module attribute is recompiled and all the functional modules are installed, one compiling task item is correspondingly present for each functional module with the dynamic module attribute.

3. The method of claim 1, wherein each of the compilation task items is included in a first compilation task list that is presented in a view area of a development platform upon which the target project depends;

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

the parameter name navigator, the building type buildType and the requirement scene description information of the target project.

4. The method according to claim 1, wherein the determining attribution division of each of the functional modules in each of the preset compilation demand scenarios and generating a compilation task item corresponding to each of the compilation demand scenarios comprises:

analyzing and determining the module attribute of each functional module;

determining a function module which belongs to each compiling demand scene according to each module attribute and scene description information of the compiling demand scene;

and generating compiling task items required by compiling the associated functional modules according to the compiling generation rule corresponding to the compiling demand scene.

5. The method of claim 1, further comprising, after obtaining each functional module included in the target item:

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

according to a preset upgrading and compiling generation rule, respectively generating upgrading and compiling task items corresponding to the dynamic modules;

and each upgrading and compiling task item is contained in a second compiling task list and is presented in a view area of a development platform depended by the target item.

6. The method of claim 5, further comprising:

and 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.

7. The method of claim 6, wherein the running condition of the target upgrade compiling task item is:

and monitoring that the target upgrading compiling task item is triggered and started, and compiling operation of a target dynamic module associated with the target compiling task item is performed on the basis of the corresponding compiling task item.

8. The method of claim 6, wherein the performing the compiling operation on the target dynamic module corresponding to the target upgrade compiling task item includes:

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

when the compiling of the target dynamic module is started to be executed, skipping the compiling of each associated module to obtain the current compiling information of the target dynamic module;

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.

9. The method according to any one of claims 1-8, further comprising:

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

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

10. The method according to claim 9, 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, comprises:

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

if so, determining that the installation form is full installation, and taking the compiled files corresponding to all the functional modules in the file directory as files to be installed;

if not, determining the installation form and the 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 a target terminal and starting and running the target project.

11. The method according to claim 10, wherein the determining the installation form as the corresponding file to be installed according to the system version number of the operating system installed on the target terminal comprises:

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 the compiled files corresponding to all the functional modules in the file directory as files to be installed; if not, then,

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

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

13. A computer device, comprising:

one or more processors; 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 the modules in the development of a project as set forth in any one of claims 1-11.

14. A computer-readable storage medium on which a computer program is stored, the program, when being executed by a processor, implementing a method for implementing a module in project development according to any one of claims 1 to 11 independently.