Multi-level dynamically scalable software processing method, system, chip and device

Abstract

The present invention discloses a multi-level dynamically expandable software processing method, system, chip and device, which divide an application program into multiple functional modules according to functions and effects, and each functional module is further subdivided, and the divided multi-level functional modules are in a tree structure; each functional module defines an interface according to its division standard, and is implemented in a plug-in manner to form a multi-level plug-in structure; the multi-level plug-ins are placed in the corresponding path of the application program and its installation platform; all plug-ins of the corresponding type are searched under the corresponding path, and are summarized into a tree data structure as a plug-in data source according to the hierarchical relationship of the plug-ins; the corresponding plug-in data source is updated when the plug-in is installed or uninstalled; the interface of the application program is dynamically displayed according to the changes of the plug-in data source, and the functional operation thereof searches for its dynamic library according to the corresponding plug-in name in the plug-in data source, loads the dynamic library and uses its function.

Description

Technical Field

[0001] The present invention belongs to the technical field of computer software processing, and in particular relates to a multi-level dynamically expandable software processing method, system, chip and device. Background Art

[0002] Software project development is a complex system engineering. High cohesion, low coupling, ensuring the independence of modules and the neatness of code are the key to the quality of software projects and are also conducive to the control of overall software risks. However, in the actual development process, due to the skill level of developers, the urgency of the project or the subjective attitude of developers, the project modules are often unclearly divided, coupled and have large code redundancy. In this way, although the progress of software development may be guaranteed in the early stage of the project, as the project becomes larger and larger in the later stage, it often makes the code difficult to modify, and a simple change in requirements may also bring a lot of workload, greatly increasing the maintenance cost of the project. At the same time, this may also affect the confidence and stability of the software development team, bringing great risks to the management of software projects. Although some companies adopt a code review system, this is often limited to local codes and often becomes a formality, thus wasting too much manpower and time costs.

[0003] In addition, since software processing systems usually need to be adapted to a variety of different platforms, if the code cannot be managed and reused well, it will cause a lot of duplicate development, greatly increasing the company's development and maintenance costs. Summary of the invention

[0004] The technical problem to be solved by the present invention is to provide a multi-level dynamically expandable software processing method, system, chip and device to address the deficiencies in the above-mentioned prior art, so as to solve the technical problems that the software project development process is difficult to manage, the code quality is low and the development cost of the enterprise is high.

[0005] The present invention adopts the following technical solutions:

[0006] The multi-level dynamically scalable software processing method comprises the following steps:

[0007] Divide the application into multiple functional modules according to their functions and roles, and form a tree structure with multiple functional modules; define the interface of each functional module according to the division standard, and implement it in a plug-in manner to form a multi-level plug-in structure;

[0008] Place multi-level plug-ins in the corresponding path of the application installation platform, search for all plug-ins of the corresponding type in the corresponding path, and summarize them into a tree data structure according to the hierarchical relationship of the plug-ins as the plug-in data source;

[0009] When installing or uninstalling a plug-in, the corresponding tree data structure is updated as the plug-in data source; the application interface is dynamically displayed according to the plug-in data source.

[0010] Specifically, a general plug-in interface with parameters and return values ​​of any data type is reserved in the application. The general plug-in interface has plug-in type parameters. When new functions are extended, new functions are dynamically added by adding a plug-in that implements the general plug-in interface.

[0011] Furthermore, the general plug-in interface uses an asynchronous callback method to return the processing result.

[0012] Specifically, the user operates a certain function in the interface as follows:

[0013] Find the corresponding plug-in name in the plug-in data source, then find the corresponding dynamic library according to the plug-in name, load the corresponding dynamic library and use the corresponding function.

[0014] Specifically, there is a dependency relationship between the parent and child plug-ins in a multi-level plug-in. The child plug-in follows the interface followed by the parent plug-in and the interface of a specific function. The child plug-ins at the same level implement the corresponding functions in a differentiated manner while following the same interface.

[0015] Specifically, when a function in the user operation interface enters the next level interface, the subtree corresponding to the current plug-in is searched from the plug-in data source, and then the plug-in corresponding to the lower level interface is searched from the subtree.

[0016] Specifically, the adaptation of applications to multiple platforms treats the platform type as a hierarchical division.

[0017] In a second aspect, the present invention provides a multi-level dynamically scalable software processing system, comprising:

[0018] Functional modules: divide the application into multiple functional modules according to their functions and roles, and the divided multi-level functional modules form a tree structure; define the interface of each functional module according to the division standard, and implement it in a plug-in manner to form a multi-level plug-in structure;

[0019] The management module places multi-level plug-ins in the corresponding path of the application installation platform; searches for all plug-ins of the corresponding type in the corresponding path; summarizes the hierarchical relationship of the plug-ins into a tree data structure as the plug-in data source; when installing or uninstalling a plug-in, updates the corresponding tree data structure as the update plug-in data source; the application interface is dynamically displayed according to the plug-in data source; the operation interface function searches for the corresponding plug-in name in the plug-in data source, then finds the corresponding dynamic library according to the plug-in name, loads the corresponding dynamic library and uses the corresponding function.

[0020] In a third aspect, a chip comprises a memory, a processor, and a computer program stored in the memory and executable on the processor, wherein the processor implements the steps of the above-mentioned multi-level dynamically scalable software processing method when executing the computer program.

[0021] In a fourth aspect, an embodiment of the present invention provides an electronic device, including the chip, to implement the steps of the above-mentioned multi-level dynamically scalable software processing method.

[0022] Compared with the prior art, the present invention has at least the following beneficial effects:

[0023] The multi-level dynamically scalable software processing method creates a tree-structured multi-level module plug-in and establishes dependencies between plug-ins. Compared with single-function plug-ins, multi-level plug-ins have a wider range of applications. Larger functional modules and even the entire application can be plug-inized. The interface is dynamically displayed according to the plug-in data, and the interface jump can also be controlled according to the dependencies between plug-ins. This makes the software project structure clearer and more hierarchical. The plug-in method can standardize developers to ensure the independence of modules. Module plug-ins at each level can be dynamically added and uninstalled, ensuring the flexibility of the application.

[0024] Furthermore, a general plug-in interface is reserved, so that new functions that do not exist in the existing interface can be dynamically added, ensuring the independence of the new function module, complying with the open-closed principle, reducing the modification of the original code, and thus ensuring the continuous independence of each module in the project. And when upgrading new functions, only the new functions and the module plug-ins of the caller need to be updated, without updating the entire application, making application updates more efficient.

[0025] Furthermore, when running a plug-in program, there may be a situation where the process is waiting and the processing result cannot be returned directly. The asynchronous callback can return the processing result to the caller in a timely manner.

[0026] A multi-level dynamically expandable software processing system, in which each functional module can be implemented in a plug-in manner, greatly ensuring the independence and decoupling of the software system modules, thereby reducing the development and maintenance costs of the project; keeping the processing flow of the software system consistent on multiple platforms and limiting the differences to platform module plug-ins can make the code structure neat and the logic clear, which can reduce the error rate, improve the reusability of the code on various platforms, reduce redundant development, and thus improve development efficiency.

[0027] It can be understood that the beneficial effects of the second to fourth aspects mentioned above can be found in the relevant description of the first aspect mentioned above, and will not be repeated here.

[0028] In summary, the present invention makes the software project structure clear and well-organized, which is conducive to the independence and decoupling of each module and the newly added module in the project and the plug-in processing of the project module, improves the quality of the software project code, and its modular plug-in dynamic installation and uninstallation characteristics ensure the flexibility of application program updates and upgrades. In addition, the multi-platform approach reduces the complex logic of multi-platform differential processing, improves the reusability of the code, and thus improves the efficiency of enterprise software development.

[0029] The technical solution of the present invention is further described in detail below through the accompanying drawings and embodiments. BRIEF DESCRIPTION OF THE DRAWINGS

[0030] Figure 1 is a system structure diagram of the present invention;

[0031] Figure 2 is a schematic diagram of a common core module of the present invention;

[0032] Figure 3 It is a schematic diagram of the multi-level functional modules of the present invention;

[0033] Figure 4 Flowchart for plug-in data source operation;

[0034] Figure 5 Processing of platform modules under multiple platforms;

[0035] Figure 6 Added new module processing to the common plugin interface;

[0036] Figure 7 This is an example of a multi-level functional module class diagram;

[0037] Figure 8 The block diagram of a chip provided according to an embodiment of the present invention. DETAILED DESCRIPTION

[0038] The following will be combined with the drawings in the embodiments of the present invention to clearly and completely describe the technical solutions in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, not all of the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by ordinary technicians in this field without creative work are within the scope of protection of the present invention.

[0039] In the description of the present invention, it should be understood that the terms “include” and “comprises” indicate the presence of described features, wholes, steps, operations, elements and / or components, but do not exclude the presence or addition of one or more other features, wholes, steps, operations, elements, components and / or collections thereof.

[0040] It should also be understood that the terms used in the present specification are only for the purpose of describing specific embodiments and are not intended to limit the present invention. As used in the present specification and the appended claims, unless the context clearly indicates otherwise, the singular forms "a", "an" and "the" are intended to include plural forms.

[0041] It should be further understood that the term "and / or" used in the present specification and the appended claims refers to any combination of one or more of the associated listed items and all possible combinations, and includes these combinations. For example, A and / or B can represent: A exists alone, A and B exist at the same time, and B exists alone. In addition, the character " / " in the present invention generally indicates that the associated objects are in an "or" relationship.

[0042] It should be understood that, although the terms first, second, third, etc. may be used to describe preset ranges, etc. in the embodiments of the present invention, these preset ranges should not be limited to these terms. These terms are only used to distinguish preset ranges from each other. For example, without departing from the scope of the embodiments of the present invention, the first preset range may also be referred to as the second preset range, and similarly, the second preset range may also be referred to as the first preset range.

[0043] The word "if" as used herein may be interpreted as "at the time of" or "when" or "in response to determining" or "in response to detecting", depending on the context. Similarly, the phrases "if it is determined" or "if (stated condition or event) is detected" may be interpreted as "when it is determined" or "in response to determining" or "when detecting (stated condition or event)" or "in response to detecting (stated condition or event)", depending on the context.

[0044] Various structural schematic diagrams of the embodiments disclosed in the present invention are shown in the accompanying drawings. These figures are not drawn to scale, and some details are magnified and some details may be omitted for the purpose of clear expression. The shapes of various regions and layers shown in the figures and the relative sizes and positional relationships therebetween are only exemplary, and may deviate in practice due to manufacturing tolerances or technical limitations, and those skilled in the art may additionally design regions / layers with different shapes, sizes, and relative positions according to actual needs.

[0045] The present invention provides a multi-level dynamically extensible software processing method, which is composed of a multi-level tree structure module, and each module is plug-in processed in the form of a dynamic library. The modules on each level can be dynamically installed and uninstalled, and the corresponding interface is dynamically displayed according to the plug-in data; in this way, the software project structure is relatively clear, and the plug-in method can standardize the developer to ensure the independence of the module; the design of the interface and user operation using a similar multi-level structure also makes the interface logic clear, and the user is easy to understand and master, which also standardizes the work of UI designers to a certain extent, thereby ensuring the quality of the software processing system. Further, in view of the problem of dynamically adding plug-in interfaces that do not exist in the software processing system in the later stage, the present invention reserves a general plug-in interface, so that functions that do not exist in the existing interface can be dynamically added; finally, for the adaptation of the software processing system under multiple platforms, according to the maximum set of all possible operations under all target platforms, a unified architecture design process is adopted, public modules are shared, and differentiated functions are implemented by platform modules corresponding to each platform, thereby enhancing the reusability of code and architecture and improving development efficiency.

[0046] The present invention groups modules according to functions and roles to form a plurality of primary function modules, and further subdivides and groups each primary function module according to functions and roles to form a plurality of secondary sub-function modules under the primary function, and so on, so that the function modules divided in this way form an orderly tree structure. The interface of each module is defined according to the grouping standard, and the modules of the same level follow the same interface, and these modules implement their functions in a differentiated manner while following the same interface. For parent-child modules, in addition to following all interfaces followed by the parent module, the submodule also follows and implements the interface of its specific function. These modules are implemented as plug-ins according to the interfaces they follow, and these plug-in modules form a multi-level tree structure.

[0047] See also Figure 1 The present invention provides a multi-level dynamically scalable software processing system, which can be used to implement a multi-level dynamically scalable software processing method. Specifically, the multi-level dynamically scalable software processing system includes a host program 101, a common core module 102, various functional modules 103 and a platform module 104;

[0048] See also Figure 2 The common core module 102 includes a basic function module 201 , a plug-in management module 202 , and a custom component module 203 .

[0049] Basic function module 201, used for encapsulation of network request, data persistence and other functions;

[0050] The plug-in management module 202 is used to implement the loading and release management of plug-in dynamic libraries on different platforms;

[0051] The custom component module 203 is used to encapsulate some UI components commonly used in development, expand the basic SDK, facilitate reuse in later UI development, reduce duplicate code, and improve development efficiency.

[0052] The common core module 102 must exist in the application.

[0053] See also Figure 3 , the functional module 103 includes multiple first functional modules 301 and second functional modules 302, and each first functional module 301 can be divided into multiple first and second sub-functional modules 303 and second and second sub-functional modules 304 according to its function and role. Similarly, each secondary function can also be divided into multiple third-level sub-functional modules, and so on. For multi-level functions, each functional module needs to follow the interface defined at this level. If there is a parent, it needs to follow the parent functional module interface, the parent functional module interface of the parent, and so on, until the interface of the top layer. In this way, multiple sub-functional modules belonging to the same parent function follow the same interface, and each level and each branch has its own specific interface standard. This makes the multi-level function division clear, and also ensures the plug-in processing of multi-level functions. The corresponding data model can be organized using a tree data structure, which can meet the data source required by any form of multi-level view.

[0054] See also Figure 4 In another embodiment of the present invention, a multi-level dynamically expandable software processing method is provided. The interface in the application system is usually operated in a multi-level tree structure. The interface can be dynamically displayed according to whether the corresponding multi-level module plug-in exists, and the method includes the following steps:

[0055] S401, when the user enters the interface;

[0056] S402, searching for a plug-in data source of a corresponding type;

[0057] S403: When the plug-in data source does not exist, all plug-ins of the same type are searched from the local path of the application, the plug-ins are loaded to obtain their information, and the information is summarized into a tree data structure according to the hierarchical relationship, which is the plug-in data source;

[0058] S404: A user installs or uninstalls a plug-in;

[0059] S405, updating the corresponding plug-in data source;

[0060] S406, when there is a plug-in data source, the content of the interface is displayed according to the plug-in data source, and the interface is dynamically displayed according to the installation status of the plug-in. When the user operates a certain function in the interface, the corresponding plug-in name is searched in the plug-in data source, and then the corresponding dynamic library name is obtained according to the plug-in name, and then the dynamic library is searched in the local path, and then the dynamic library can be loaded and its function can be used. When the user operates a certain function in the interface and enters the next level interface, the corresponding subtree is searched from the plug-in data source and processed according to the same logic.

[0061] Software processing systems usually need to meet the use of multiple platforms, such as Windows, Mac OS X, iOS, Android, Harmony OS, Linux, etc. In order to reduce development costs, cross-platform technologies are often used to implement them, such as Web-based cross-platform technologies, Qt, Flutter, etc. These cross-platform technologies can adapt most of the functions of the software processing system, so that the operation process on different platforms is consistent as a whole, but there are also some differentiated processing processes and differentiated implementations of the same operation steps, which require a variety of special processing and lead to a chaotic project structure. The present invention proposes a platform module plug-in, which can be implemented in a multi-level form. The first level is a platform type-related interface, and the remaining levels are divided according to functions and functions. In this way, the corresponding platform module plug-in is loaded on different platforms according to the platform type interface. In addition, when designing a software system, the maximum set of all possible processing flows under multiple platforms is considered. If there is an operation on platform 1 but not on platform 2, it is necessary to define the interface of the operation in the platform module, and include the operation in the processing flow of the software system. The interface is specifically implemented in the platform 1 module plug-in, and the default implementation is adopted in the platform 2 module plug-in. The processing flow is as follows:

[0062] On a certain platform, step 501 is executed to step 502, and step 504 is executed after step 502 is executed. Step 502 has different processing under multiple platforms. If step 502 does not need to be processed under the current platform, the platform module 503 adopts its default implementation; if step 502 needs to be processed on the current platform, it is necessary to develop a platform module to implement 503 of the subclass of the interface corresponding to step 502.

[0063] Specifically implement the processing method under the platform, and then put the platform module plug-in into the corresponding path to facilitate loading the platform module plug-in to execute 503.

[0064] When loading the platform module library, determine whether the platform type returned in the platform type interface of the platform module plug-in is consistent with the current platform. If they are consistent, execute the method in the plug-in.

[0065] A plug-in framework usually requires a host program that contains a header file that defines the interface specification. As long as the plug-in module implements the defined interface, the module can be loaded into the host program in the form of a dynamic library to implement the call. Since the interface file is located in the host program, it exists at the time of initial installation. When the developer wants to add a new interface later, the host program needs to be updated. In addition to the existing clearly defined interfaces in the host program, the present invention reserves a general plug-in interface with parameters and return values ​​of any data type. The interface uses an asynchronous callback method to return the processing result. The interface also has a plug-in type parameter to distinguish the type of plug-in that implements the interface. The specific use is as follows:

[0066] The plug-in module follows the general plug-in interface to implement its unique functions. The parameters in the interface are passed according to the needs of the plug-in, so the caller of the plug-in also needs to assign values ​​according to the type. The plug-in also needs to return a unique ID indicating the plug-in type. In this way, the plug-in caller can confirm the plug-in library based on this ID.

[0067] When new development requirements are encountered later and this function is not available in the current framework process, the above-mentioned new plug-in that implements the general plug-in interface is used to dynamically add new functions.

[0068] See also Figure 6 The original processing framework flow is from step 601 to step 602. To add a new function before step 602, a plug-in that complies with the general plug-in interface is developed, and the original operation flow is changed to step 601 calling step 603, and then step 603 calling step 602.

[0069] In another embodiment of the present invention, a terminal device is provided, the terminal device includes a processor and a memory, the memory is used to store a computer program, the computer program includes program instructions, and the processor is used to execute the program instructions stored in the computer storage medium. The processor may be a central processing unit (CPU), or other general-purpose processors, digital signal processors (DSP), application-specific integrated circuits (ASIC), field-programmable gate arrays (FPGA) or other programmable logic devices, discrete gates or transistor logic devices, discrete hardware components, etc., which are the computing core and control core of the terminal, which are suitable for implementing one or more instructions, and are specifically suitable for loading and executing one or more instructions to implement corresponding method processes or corresponding functions; the processor described in the embodiment of the present invention can be used for the operation of a multi-level dynamically scalable software processing method, including:

[0070] The application is divided into multiple functional modules according to functions and roles, and the divided multi-level functional modules form a tree structure; the interface of each functional module is defined according to the division standard, and implemented in a plug-in manner to form a multi-level plug-in structure; the multi-level plug-in structure is placed under the corresponding path of the application; after the application is started, the corresponding type of plug-in is searched under the corresponding path; according to the hierarchical relationship of the plug-in, it is summarized into a tree data structure as the plug-in data source; when installing or uninstalling the plug-in, the corresponding tree data structure is updated as the update plug-in data source; the application interface is dynamically displayed according to the plug-in data source.

[0071] See also Figure 8 , the terminal device is a chip, and the chip 800 of this embodiment includes a processor 822, which may be one or more, and a memory 832 for storing a computer program executable by the processor 822. The computer program stored in the memory 832 may include one or more modules, each corresponding to a set of instructions. In addition, the processor 822 may be configured to execute the computer program to execute the above-mentioned multi-level dynamically scalable software processing method.

[0072] In addition, the chip 800 may further include a power supply component 826 and a communication component 850, wherein the power supply component 826 may be configured to perform power management of the chip 800, and the communication component 850 may be configured to implement communication, for example, wired or wireless communication, of the chip 800. In addition, the chip 800 may further include an input / output (I / O) interface 858. The chip 800 may operate based on an operating system stored in the memory 832.

[0073] In another embodiment of the present invention, the present invention further provides a storage medium, specifically a computer-readable storage medium (Memory), which is a memory device in a terminal device for storing programs and data. It can be understood that the computer-readable storage medium here can include both the built-in storage medium in the terminal device and the extended storage medium supported by the terminal device. The computer-readable storage medium provides a storage space, which stores the operating system of the terminal. In addition, one or more instructions suitable for being loaded and executed by the processor are also stored in the storage space, and these instructions can be one or more computer programs (including program codes). It should be noted that the computer-readable storage medium here can be a high-speed RAM memory, or a non-volatile memory (Non-Volatile Memory), such as at least one disk memory.

[0074] The processor may load and execute one or more instructions stored in the computer-readable storage medium to implement the corresponding steps of the multi-level dynamically scalable software processing method in the above embodiment; the processor may load and execute the following steps:

[0075] The application is divided into multiple functional modules according to functions and roles, and the divided multi-level functional modules form a tree structure; the interface of each functional module is defined according to the division standard, and implemented in a plug-in manner to form a multi-level plug-in structure; the multi-level plug-in structure is placed under the corresponding path of the application; after the application is started, the corresponding type of plug-in is searched under the corresponding path; according to the hierarchical relationship of the plug-in, it is summarized into a tree data structure as the plug-in data source; when installing or uninstalling the plug-in, the corresponding tree data structure is updated as the update plug-in data source; the application interface is dynamically displayed according to the plug-in data source.

[0076] In order to make the purpose, technical solutions and advantages of the embodiments of the present invention clearer, the technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the drawings in the embodiments of the present invention. Obviously, the described embodiments are part of the embodiments of the present invention, rather than all of the embodiments. The components of the embodiments of the present invention described and shown in the drawings here can usually be arranged and designed in various different configurations. Therefore, the following detailed description of the embodiments of the present invention provided in the drawings is not intended to limit the scope of the claimed invention, but merely represents selected embodiments of the present invention. Based on the embodiments in the present invention, all other embodiments obtained by ordinary technicians in this field without making creative work are within the scope of protection of the present invention.

[0077] Application Examples

[0078] Functional modules, such as digital painting material management software, often include menu bars, which provide the main functions of the material management software, such as material mall, material courses, etc. Each functional module may contain multiple sub-functional modules, such as the material course module contains graphic material courses, video material courses, etc. When designing a program, all menu items in the menu bar belong to the first level. All menu options in this level follow a common interface, MenuInterface, that is, Figure 7701. When traversing the plugins, the plugin that inherits this interface is a menu bar plugin. The MenuInterface interface contains the type of menu, such as a mall or a course; the serial number of the tool, serialNumber, which can be used to sort when displaying the interface based on the plugin data source; the name of the tool, menuName, and some image resources contained in the tool, such as the icon iconName; the different types of course plugins under the course module can follow the second interface or protocol (different languages ​​have different implementation methods, such as C++ can use multiple inheritance, and Java implements multiple interfaces), that is, the course class plugin 703 not only follows the first interface MenuInterface, indicating that it is a menu item, but also needs to follow the second interface CourseInterface (702), indicating that it is a course. In this way, when the plug-in functions are digitized, all plug-ins based on the first-level interface are classified into one category. If the plug-ins follow the first-level interface, the plug-ins that follow the same second-level interface are classified into one category. If there are third-level interfaces, the same applies. In this way, a tree data structure about menu plug-ins will be formed, which is the plug-in data source of the menu class. For the content that needs to be displayed in the menu bar, it is only necessary to obtain the first-level child nodes of the tree, so as to dynamically display the content of the menu bar according to the data of the first-level child nodes. If there is a course in the first-level child node, that is, there is a plug-in named course in the MenuInterface of the plug-in, the tool list will obtain the Icon icon from the value of iconName in MenuInterface, so as to display the course icon in the tool list. When the user clicks on the course icon in the menu bar, the subtree whose parent node is CourseInterface will be searched in the tree data in an in-order traversal manner, so as to dynamically display the course types available to the user according to the data, so that the user can select the course type and display all courses of this type. CourseIterface can be specifically divided into graphic tutorials and video tutorials. If a tool does not have multiple forms of sub-functions and has only one form, it only needs to follow the MenuInterface interface and then implement its own functions on this basis. For example, the mall menu 704 usually has only one form. It only needs to inherit MenuInterface to indicate that it is a menu item, and its own specific functions are implemented by adding corresponding methods. If "online real-time courses" are added later, it is only necessary to implement a plug-in class that follows both MenuInterface and CourseInterface, and implement the operation of real-time video stream pulling for rendering in its load(id, userId) method. Then put the plug-in in the corresponding position under the software processing system, and the course types on the interface can be dynamically displayed as graphics, videos, and online items. Users can click on the options to obtain the corresponding course resources.

[0079] A certain software processing system currently supports both Mac and Windows platforms. In the user login interface, due to Apple's new audit requirements, the Mac platform needs to provide the user with a "privacy agreement" confirmation function, while the Windows platform does not need to implement this function. However, the software processing system that has been launched does not include the processing of this function. At this time, we can dynamically add a privacy protocol processing plug-in that follows the general plug-in interface. During development, all relevant privacy protocol functions are encapsulated into a module and plug-in, including a clickable "privacy agreement" prompt and a check box to check whether it has been read, the specific privacy agreement content loaded by clicking the privacy agreement, and the asynchronously returned module interface value is "whether it has been read". In addition, the plug-in needs to return a unique id value. When processing on the Mac side, a plug-in that implements the general plug-in interface, has the same id value, and a platform type interface return value of Mac is searched. If found, the UI provided in the plug-in is displayed on the login interface. When the user checks the read option, the return value provided in the plug-in becomes YES, otherwise it is NO. In this way, when the user fills in other login information and clicks, the module directly obtains whether the privacy agreement has been read, and then performs related login operations. When processing on the Windows platform, the plugin interface returns the default value of "read or not" of YES, so the next step can be processed directly. According to the platform type interface, it is not a Mac, so there is no privacy agreement display on the login interface. According to this method, adding the privacy agreement function only involves the modification of the new privacy agreement plug-in and the login module plug-in, and there is no need to upgrade the application and affect other modules. Although the relevant processing logic can be added directly to the login module, this is not conducive to the independence of the module and the reuse of the code. For example, the setting module may also involve the privacy agreement function; at the same time, if you want to change the relevant judgment method of the privacy agreement later, such as whether it has been read is based on whether the time for reading the specific content of the privacy agreement is sufficient. In this way, the corresponding modifications are completed completely in the plug-in content of the privacy agreement, without affecting other modules, and updates and upgrades do not require upgrading the entire application.

[0080] In summary, the multi-level dynamically expandable software processing method, system, chip and device of the present invention make the software project structure clear and well-organized, which is conducive to the independence and decoupling of each module and the newly added module in the project and the plug-in processing of the project module, improves the quality of the software project code, and its modular plug-in dynamic installation and uninstallation characteristics ensure the flexibility of application program updates and upgrades. In addition, the multi-platform approach reduces the complex logic of multi-platform differentiated processing, improves the reusability of the code, and thus improves the efficiency of enterprise software development.

[0081] The technicians in the relevant field can clearly understand that for the convenience and simplicity of description, only the division of the above-mentioned functional units and modules is used as an example for illustration. In practical applications, the above-mentioned function allocation can be completed by different functional units and modules as needed, that is, the internal structure of the device can be divided into different functional units or modules to complete all or part of the functions described above. The functional units and modules in the embodiment can be integrated in a processing unit, or each unit can exist physically separately, or two or more units can be integrated in one unit. The above-mentioned integrated unit can be implemented in the form of hardware or in the form of software functional units. In addition, the specific names of the functional units and modules are only for the convenience of distinguishing each other, and are not used to limit the scope of protection of this application. The specific working process of the units and modules in the above-mentioned system can refer to the corresponding process in the aforementioned method embodiment, which will not be repeated here.

[0082] In the above embodiments, the description of each embodiment has its own emphasis. For parts that are not described or recorded in detail in a certain embodiment, reference can be made to the relevant descriptions of other embodiments.

[0083] Those skilled in the art will appreciate that the units and algorithm steps of each example described in conjunction with the embodiments disclosed in the present invention can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are performed in hardware or software depends on the specific application and design constraints of the technical solution. Professional and technical personnel can use different methods to implement the described functions for each specific application, but such implementation should not be considered to be beyond the scope of the present invention.

[0084] In the embodiments provided by the present invention, it should be understood that the disclosed devices / terminals and methods can be implemented in other ways. For example, the device / terminal embodiments described above are only schematic. For example, the division of the modules or units is only a logical function division. There may be other division methods in actual implementation, such as multiple units or components can be combined or integrated into another system, or some features can be ignored or not executed. Another point is that the mutual coupling or direct coupling or communication connection shown or discussed can be through some interfaces, indirect coupling or communication connection of devices or units, which can be electrical, mechanical or other forms.

[0085] The units described as separate components may or may not be physically separated, and the components shown as units may or may not be physical units, that is, they may be located in one place or distributed on multiple network units. Some or all of the units may be selected according to actual needs to achieve the purpose of the solution of this embodiment.

[0086] In addition, each functional unit in each embodiment of the present invention may be integrated into one processing unit, or each unit may exist physically separately, or two or more units may be integrated into one unit. The above-mentioned integrated unit may be implemented in the form of hardware or in the form of software functional units.

[0087] If the integrated module / unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the present invention implements all or part of the processes in the above-mentioned embodiment method, and can also be completed by instructing the relevant hardware through a computer program. The computer program can be stored in a computer-readable storage medium, and the computer program can implement the steps of the above-mentioned various method embodiments when executed by the processor. Among them, the computer program includes computer program code, and the computer program code can be in source code form, object code form, executable file or some intermediate form. The computer-readable medium may include: any entity or device capable of carrying the computer program code, recording medium, U disk, mobile hard disk, disk, optical disk, computer memory, read-only memory (ROM), random access memory (RAM), electric carrier signal, telecommunication signal and software distribution medium, etc. It should be noted that the content contained in the computer-readable medium can be appropriately increased or decreased according to the requirements of legislation and patent practice in the jurisdiction. For example, in some jurisdictions, according to legislation and patent practice, computer-readable media do not include electric carrier signals and telecommunication signals.

[0088] The present application is described with reference to the flowcharts and / or block diagrams of the methods, devices (systems), and computer program products according to the embodiments of the present application. It should be understood that each process and / or box in the flowchart and / or block diagram, as well as the combination of the processes and / or boxes in the flowchart and / or block diagram, can be implemented by computer program instructions. These computer program instructions can be provided to a processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing device to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing device generate instructions for implementing the processes in the flowchart and / or block diagram. Figure 1 A process or multiple processes and / or boxes Figure 1 A device that provides the functions specified in a block or multiple blocks.

[0089] These computer program instructions may also be stored in a computer-readable memory capable of directing a computer or other programmable data processing device to operate in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture comprising an instruction device, which implements the process Figure 1A process or multiple processes and / or boxes Figure 1 A function specified in one or more boxes.

[0090] These computer program instructions can also be loaded onto a computer or other programmable data processing device so that a series of operating steps are executed on the computer or other programmable device to produce a computer-implemented process, thereby providing instructions for implementing the process in the computer or other programmable device. Figure 1 A process or multiple processes and / or boxes Figure 1 The steps for the functions specified in one or more boxes.

[0091] The above contents are only for explaining the technical idea of ​​the present invention and cannot be used to limit the protection scope of the present invention. Any changes made on the basis of the technical solution in accordance with the technical idea proposed by the present invention shall fall within the protection scope of the claims of the present invention.

Claims

1. A multi-level dynamically scalable software processing method, characterized in that: The following steps are involved: The application is divided into multiple functional modules according to functions and roles. The divided multi-level functional modules form a tree structure. A general plug-in interface with any data type as parameter and return value is reserved in the application. The general plug-in interface has a plug-in type parameter. When expanding new functions, a new plug-in that implements the general plug-in interface is used to dynamically add new functions; the interface of each functional module is defined according to the division standard and implemented in a plug-in manner to form a multi-level plug-in structure. There is a dependency relationship between the parent and child plug-ins in the multi-level plug-ins. The child plug-ins follow the interface followed by the parent plug-in and the interface of the specific function. The child plug-ins at the same level implement the corresponding functions in a differentiated manner while following the same interface. The adaptation of the application to multiple platforms treats the platform type as a hierarchical division. The first level is the platform type-related interface, and the remaining levels are divided according to functions and roles. When designing the software system, the maximum set of all possible processing flows under multiple platforms is considered; Place multi-level plug-ins in the corresponding path of the application installation platform, search for all plug-ins of the corresponding type in the corresponding path, summarize them into a tree data structure according to the hierarchical relationship of the plug-ins, and use it as the plug-in data source. When a function in the user operation interface enters the next level interface, search the subtree corresponding to the current plug-in from the plug-in data source, and then search for the plug-in corresponding to the lower level interface from the subtree; When installing or uninstalling a plug-in, the corresponding tree data structure is updated as the data source for updating the plug-in; The application interface is dynamically displayed based on the plug-in data source.

2. The multi-level dynamically scalable software processing method according to claim 1, characterized in that: The general plug-in interface uses asynchronous callback to return processing results.

3. The multi-level dynamically scalable software processing method according to claim 1, characterized in that: The user operates a certain function in the interface as follows: Find the corresponding plug-in name in the plug-in data source, then find the corresponding dynamic library according to the plug-in name, load the corresponding dynamic library and use the corresponding function.

4. A multi-level dynamically scalable software processing system, characterized in that: include: Functional modules, divide the application into multiple functional modules according to functions and roles, and the divided multi-level functional modules form a tree structure. A general plug-in interface with any data type is reserved in the application. The general plug-in interface has a plug-in type parameter. When expanding new functions, a new plug-in that implements the general plug-in interface is used to dynamically add new functions; define the interface of each functional module according to the division standard, and implement it in a plug-in manner to form a multi-level plug-in structure. There is a dependency relationship between the parent and child plug-ins in the multi-level plug-ins. The child plug-in follows the interface followed by the parent plug-in and the interface of the specific function. The child plug-ins at the same level implement the corresponding functions in a differentiated manner while following the same interface. The adaptation of the application to multiple platforms treats the platform type as a hierarchical division. The first level is the platform type-related interface, and the remaining levels are divided according to functions and roles. When designing the software system, consider the maximum set of all possible processing flows under multiple platforms; Management module, placing multi-level plug-ins to the corresponding path of the application installation platform; Search for all plugins of the corresponding type in the corresponding path; According to the hierarchical relationship of the plug-ins, they are aggregated into a tree data structure as the plug-in data source; When installing or uninstalling a plug-in, the corresponding tree data structure is updated as the plug-in data source. When a function in the user operation interface enters the next level interface, the subtree corresponding to the current plug-in is found from the plug-in data source, and then the plug-in corresponding to the lower interface is found from the subtree; the application interface is dynamically displayed according to the plug-in data source; the operation interface function searches for the corresponding plug-in name in the plug-in data source, and then finds the corresponding dynamic library according to the plug-in name, loads the corresponding dynamic library and uses the corresponding function.

5. The multi-level dynamically scalable software processing system according to claim 4, characterized in that: The general plug-in interface uses asynchronous callback to return processing results.

6. The multi-level dynamically scalable software processing system according to claim 4, characterized in that: The user operates a certain function in the interface as follows: Find the corresponding plug-in name in the plug-in data source, then find the corresponding dynamic library according to the plug-in name, load the corresponding dynamic library and use the corresponding function.

7. A chip, characterized in that: a memory having a computer program stored thereon; A processor, configured to execute the computer program in the memory to implement the steps of the method according to any one of claims 1 to 3.

8. An electronic device, characterized in that: Comprising the chip as claimed in claim 7.

9. A computer-readable storage medium storing one or more programs, characterized in that: The one or more programs include instructions, which, when executed by a computing device, cause the computing device to perform the method of any one of claims 1 to 3.

10. A computing device, characterized in that include: One or more processors, a memory and one or more programs, wherein the one or more programs are stored in the memory and configured to be executed by the one or more processors, and the one or more programs include steps for executing the method described in any one of claims 1 to 3.

Images