Methods, apparatus, devices, and media for managing application components.

Abstract

A method, apparatus, device, and medium for managing components of an application are provided. The method receives a first description defining a first function of the component in a first application and a second description defining a second function of the component in a second application, the first and second functions respectively including page styles of the component in the first and second applications. Based on the first and second descriptions, general resources, first dedicated resources, and second dedicated resources are determined in the code framework implementing the component. The general resources implement the common functionality between the first and second functions, the first dedicated resources implement the first dedicated function within the first function, and the second dedicated resources implement the second dedicated function within the second function. Based on the general resources, the first dedicated resources, and the second dedicated resources, target resources for implementing the functionality of the component in the target applications are generated for the target applications in the first and second applications. This allows for unified management of component code and improves code reusability.

Description

Technical Field

[0001] The exemplary implementations of this disclosure generally relate to the field of software development, and in particular to methods, apparatus, devices, and computer-readable storage media for managing components of an application. Background Technology

[0002] With the development of internet technology, various applications running on terminal devices have been developed. For example, news applications provide users with news reports on trending events, and video applications provide users with various video content, and so on. News applications and video applications can each use their own components to implement specific functions. Generally speaking, the functions provided by different applications may overlap. Because multiple applications may be developed using different methods, it becomes necessary to develop separate components for each application. Therefore, how to manage the components of multiple applications in a unified and effective way has become a research hotspot and challenge in the field of software development. Summary of the Invention

[0003] Based on an exemplary implementation of this disclosure, a scheme for managing application components is provided.

[0004] In a first aspect of this disclosure, a method for managing components of an application is provided. In this method, a first description defining a first function of a component in a first application and a second description defining a second function of the component in a second application are received, the first function and the second function respectively including page styles of the component in the first and second applications. Based on the first and second descriptions, general resources, first dedicated resources, and second dedicated resources are determined in a code framework for implementing the component. The general resources implement a common function between the first and second functions, the first dedicated resources implement a first dedicated function within the first function, and the second dedicated resources implement a second dedicated function within the second function. Based on the general resources, the first dedicated resources, and the second dedicated resources, target resources for implementing the functions of the component in the target applications are generated for target applications in the first and second applications.

[0005] In a second aspect of this disclosure, an apparatus for managing components of an application is provided. The apparatus includes: a receiving module configured to receive a first description defining a first function of the component in a first application and a second description defining a second function of the component in a second application, the first function and the second function respectively including page styles of the component in the first application and the second application; a determining module configured to determine, based on the first and second descriptions, a general resource, a first dedicated resource, and a second dedicated resource in a code framework for implementing the component, the general resource implementing a general function between the first and second functions, the first dedicated resource implementing a first dedicated function within the first function, and the second dedicated resource implementing a second dedicated function within the second function; and a generating module configured to generate, based on the general resource, the first dedicated resource, and the second dedicated resource, a target resource for implementing the function of the component in the target application, for a target application in the first and second applications.

[0006] In a third aspect of this disclosure, an electronic device is provided. The electronic device includes: at least one processing unit; and at least one memory coupled to the at least one processing unit and storing instructions for execution by the at least one processing unit, the instructions causing the device to perform a method according to a first aspect of this disclosure when executed by the at least one processing unit.

[0007] In a fourth aspect of this disclosure, a computer-readable storage medium is provided having a computer program stored thereon, which, when executed by a processor, causes the processor to implement the method according to a first aspect of this disclosure.

[0008] It should be understood that the content described in the summary section of this invention is not intended to limit the key or essential features of the implementation of this disclosure, nor is it intended to limit the scope of this disclosure. Other features of this disclosure will become readily apparent from the following description. Attached Figure Description

[0009] In the following detailed description, in conjunction with the accompanying drawings, the above and other features, advantages, and aspects of the various implementations of this disclosure will become more apparent. In the accompanying drawings, the same or similar reference numerals denote the same or similar elements, wherein:

[0010] Figure 1 A block diagram of an example environment in which the implementation of this disclosure can be implemented is shown;

[0011] Figure 2 A block diagram illustrating a process for managing application components according to some implementations of this disclosure;

[0012] Figure 3A block diagram illustrates a process for determining general and special resources in a code framework based on multiple descriptions, respectively, for multiple applications, according to some implementations of this disclosure;

[0013] Figure 4 A block diagram of the code framework according to some implementations of this disclosure is shown;

[0014] Figure 5 A block diagram of target resources for different applications according to some implementations of this disclosure is shown;

[0015] Figure 6 A block diagram illustrating configuration parameters for managing components according to some implementations of this disclosure is shown;

[0016] Figure 7 A block diagram is shown for generating target resources based on an inheritance pattern according to some implementations of this disclosure;

[0017] Figure 8 A flowchart illustrating the process of modifying the code framework according to some implementations of this disclosure is shown;

[0018] Figure 9 A flowchart is shown illustrating a method for managing application components according to some implementations of this disclosure;

[0019] Figure 10 A block diagram of an apparatus for managing application components according to some implementations of this disclosure is shown; and

[0020] Figure 11 A block diagram of a device capable of implementing various implementations of the present disclosure is shown. Detailed Implementation

[0021] Implementations of this disclosure will now be described in more detail with reference to the accompanying drawings. While some implementations of this disclosure are shown in the drawings, it should be understood that this disclosure can be implemented in various forms and should not be construed as limited to the implementations set forth herein. Rather, these implementations are provided to provide a more thorough and complete understanding of this disclosure. It should be understood that the accompanying drawings and implementations of this disclosure are for illustrative purposes only and are not intended to limit the scope of protection of this disclosure.

[0022] In the description of the implementation methods disclosed herein, the term "comprising" and similar terms should be understood as open inclusion, i.e., "including but not limited to". The term "based on" should be understood as "at least partially based on". The term "one implementation" or "the implementation" should be understood as "at least one implementation". The term "some implementations" should be understood as "at least some implementations". Other explicit and implicit definitions may also be included below. As used herein, the term "model" can represent the relationships between various data. For example, the aforementioned relationships can be obtained based on various currently known and / or future-developed technical solutions.

[0023] It is understood that the data involved in this technical solution (including but not limited to the data itself, the acquisition or use of the data) shall comply with the requirements of relevant laws, regulations and related provisions.

[0024] It is understood that before using the technical solutions disclosed in the various embodiments of this disclosure, users should be informed of the types, scope of use, and usage scenarios of the personal information involved in this disclosure through appropriate means in accordance with relevant laws and regulations, and user authorization should be obtained.

[0025] For example, upon receiving a user's active request, a prompt message is sent to the user to explicitly inform them that the requested operation will require the acquisition and use of the user's personal information. This allows the user to independently choose whether to provide personal information to the software or hardware, such as the electronic device, application, server, or storage medium performing the operations of this disclosed technical solution, based on the prompt message.

[0026] As an optional but non-restrictive implementation, in response to a user's active request, a prompt message can be sent to the user, such as a pop-up window, where the prompt message can be presented in text format. Furthermore, the pop-up window can also include a selection control allowing the user to choose "agree" or "disagree" to provide personal information to the electronic device.

[0027] It is understood that the above notification and user authorization process are merely illustrative and do not constitute a limitation on the implementation of this disclosure. Other methods that comply with relevant laws and regulations may also be applied to the implementation of this disclosure.

[0028] Example Environment

[0029] First see Figure 1 Describe the application environment of the components that manage the application. Figure 1 A block diagram of an example environment 100 in which the implementation of this disclosure can be implemented is shown. For example... Figure 1As shown, multiple applications 110 and 120 can be provided. Specifically, application 110 can be used to provide news services, and this application 110 may include a "Sports" component 116. Specifically, this component 116 can provide news about basketball games. For example, content area 112 may include live text coverage of the basketball final, score area 114 may include the scores of the two participating teams, and so on. Further, application 120 can be used to provide video services, and this application 120 may include a "Sports" component 126. Specifically, this component 126 can provide videos of basketball games. For example, content area 122 may include live video coverage of the basketball final, score area 124 may include the scores of the two participating teams, and so on.

[0030] In the context of this disclosure, a component can represent a software module that provides specific functionality within an application. Specifically, a component can present content obtained according to specific page logic in a specific page style (e.g., a presentation style related to the appearance of the application's user interface, including background color, text color, font, font size, size and layout of various elements on the page, etc.). Here, page logic refers to the processing procedures performed on the data to be processed. For example, in component 126 providing basketball game videos, the page logic could involve starting or pausing video playback based on user actions. Figure 1 As shown, although components 116 and 126 function similarly—that is, to provide information about the basketball finals—their functions may include both identical and different parts. For example, both components 116 and 126 are provided as tabs; however, the content presented in content areas 112 and 122 may differ, and the display styles of score areas 114 and 124 may differ, and so on.

[0031] Typically, software companies can develop multiple applications, and these applications may offer the same or similar functionalities. For example, as major sporting events unfold, both news apps and video apps can provide content related to the events. News apps can provide live scores, text, and images, while video apps can provide live scores and videos. In this case, development engineers have to develop dedicated component code for each application separately.

[0032] In the software development field, the concept of a "middle platform" has been proposed. A middle platform can integrate various resources of a software company to serve multiple applications, thereby meeting the rapid iteration needs of the front-end and the stability requirements of the back-end. When new requirements arise, the middle platform can respond quickly, thus improving development efficiency. However, different applications may use different design languages, and each application may have its own specific logic, etc., which leads to different middle platform management methods.

[0033] In a separate management approach, code can be developed and corresponding components generated for each application. Since the core logic of these components is often reusable, the basic core logic can be modified to meet the specific requirements of each application. Generating a dedicated component for each application leads to a large amount of duplicate code and is detrimental to code management. Furthermore, when the core logic needs modification, each component must be modified individually, significantly reducing software development efficiency. Conversely, in an integrated management approach, code applicable to all applications can be integrated into a single component for maintenance. While this approach facilitates global management, the component includes redundant code for multiple applications, resulting in bloated component size and poor performance.

[0034] Component management architecture

[0035] To address the shortcomings of the aforementioned technical solutions, a technical solution for managing application components is proposed based on an exemplary implementation of this disclosure. In summary, a code framework can be used to manage components used in multiple applications. For example, the descriptions of the component's functionality in different applications can be analyzed to determine common resources within the code framework that can be used in multiple applications (e.g., using tabs to display components in both applications 110 and 120, etc.) and dedicated resources specific to a particular application (e.g., using different background and text colors within tabs, displaying text and video in content areas 112 and 122 respectively, displaying scores in different formats in score areas 114 and 124, etc.).

[0036] It will be understood that a component's page style is its most intuitive visual representation and directly impacts user experience; therefore, special attention can be paid to page style-related functionalities. This approach allows for the differentiation between common and dedicated resources related to a component's page style across different applications, prioritizing the sharing of basic resources related to the component's visual presentation. Furthermore, page logic can be handled in a similar manner, enabling deeper resource sharing. This approach also allows for the unified management of components used in multiple applications, resulting in more convenient and efficient component management. Moreover, common and dedicated resources can isolate a component's functionality across multiple applications, further reducing the resource size for a specific target application.

[0037] See below. Figure 2 Further details describe an exemplary implementation according to this disclosure. Figure 2 A block diagram 200 illustrates a process for managing application components according to some implementations of this disclosure. For example... Figure 2As shown, the process of managing application components can be implemented using component generator 260. Both applications 110 and 120 can use component 240 (e.g., the "Sports" component described above). However, the specific details of the function of component 240 in applications 110 and 120 may differ. In this case, a description 210 defining the function of component 240 in application 110 and a description 220 defining the function of component 240 in application 120 can be received (for ease of distinction, applications 110 and 120 can be referred to as the first application and the second application, respectively, and descriptions 210 and 220 can be referred to as the first description and the second description, respectively).

[0038] like Figure 2 As shown, description 210 defines the function of component 240 in application 110: displaying the component in a tabbed manner, displaying text within the tabs with a white background and black text, displaying text in content area 112, etc. Description 220 defines the function of component 240 in application 120: displaying the component in a tabbed manner, displaying text within the tabs with a black background and white text, displaying video in content area 122, etc. By comparing descriptions 210 and 220, it can be found that the function of component 240 in applications 110 and 120 includes the general function: displaying the component in a tabbed manner. Furthermore, the function of component 240 in applications 110 and 120 differs: the format of the displayed text is different and the displayed content is different; these functions can be referred to as special functions.

[0039] According to an exemplary implementation of this disclosure, the code framework 230 for implementing component 240 can be determined based on comparison. Specifically, the code framework 230 can identify general resources 250 that can be shared (for implementing the functionality of displaying the component in tabs) and dedicated resources for implementing specific functions in applications 110 and 120 respectively (e.g., dedicated resources 252, 254 for implementing dedicated functions in application 110; and dedicated resources 256, ..., 258 for implementing dedicated functions in application 120). It will be understood that, in the context of this disclosure, resources may relate to page styles, page logic, and combinations thereof, and may include various types of resources that need to be invoked to implement various functions of the component, including but not limited to code (e.g., source code and / or executable code, etc.), documents, images, audio, video, configuration files, etc.

[0040] In this way, components 240 for implementing different functions in multiple applications can be maintained within a single code framework 230. Furthermore, based on general resources 250 and various dedicated resources, target resources for implementing the functions of component 240 in either application 110 or application 120 can be generated. Specifically, for application 110, target resource 212 may include general resource 250, dedicated resources 252, 254, etc.; for application 120, target resource 222 may include general resource 250, dedicated resources 256, 258, etc. Subsequently, application 110 can directly call target resource 212 generated by component generator 260, and application 120 can directly call target resource 222.

[0041] Using the exemplary implementation of this disclosure, a unified code framework 230 can be used to manage the code of component 240 during development and testing, and target resources for specific applications can be generated based on this code framework 230. This avoids the need to maintain separate code versions for each application, thereby reducing the complexity of code management. On the other hand, dedicated resources for different applications can be isolated; for example, dedicated resources 252 and 254 can be dedicated to application 110, and dedicated resources 256 and 258 can be dedicated to application 120. This reduces the coupling between code and allows the final target resources 212 and 222 to include only the code resources for their respective applications. This ensures that redundant resources are not included in the target resources, thus reducing code size and improving runtime efficiency.

[0042] Specific implementation of component management

[0043] The architecture of component management has been described above; further details regarding the component management process will be described below. According to an exemplary implementation of this disclosure, component generator 260 can receive descriptions 210 and 220 in various ways, such as by acquiring descriptions 210 and 220 from the development engineers of applications 110 and 120. Within the context of this disclosure, there is no limitation on the manner in which descriptions are received: for example, component generator 260 can receive description files defined by development engineers; or, for example, component generator 260 can provide a dialog box to development engineers to receive descriptions 210 and 220 defined by development engineers.

[0044] Upon receiving descriptions 210 and 220, component generator 260 can analyze descriptions 210 and 220 to determine the general resources 250 and various specialized resources included in code framework 230. See below for more details. Figure 3 The description identifies more details about general resource 250 and various special resources. Figure 3 A block diagram 300 illustrates a process for determining general and special resources in a code framework based on multiple descriptions, respectively, for multiple applications, according to some implementations of this disclosure. For example... Figure 3 As shown, the description can include page styles and page logic. Here, page styles refer to how the page is displayed, such as the page background color, the color, font, and font size of the text on the page, the size and layout of various elements on the page, and so on. Generally, page styles do not depend on the application's context. Page logic can include resources used to implement various functions of the page within components, such as resources for displaying content areas and score areas in different ways, and so on. Page logic typically depends on the application's context.

[0045] According to an exemplary implementation of this disclosure, the description can be divided into two cases: page style (i.e., context-independent) and page logic (i.e., context-dependent). In this way, various scenarios involved in component development can be handled, thereby managing the component development process in a universally applicable manner.

[0046] like Figure 3 As shown, the description can be split into page styles and page logic based on whether each part depends on the application's contextual functionality, so that they can be processed in different ways later. For example, description 210 can involve page logic 310, page style 312, and page logic 314; further, description 220 can involve page logic 320, page style 322, and page logic 324. By comparison, it is found that page logics 310 and 320 involve the same function, that is, displaying components in the form of tabs in applications 110 and 120 respectively. In this case, page logics 310 and 320 can share the same resources. That is, page logics 310 and 320 can be implemented using the common resource 250.

[0047] According to one exemplary implementation of this disclosure, the general resource 250 can be implemented in various ways that are currently known and / or will be developed in the future. For example, the general resource 250 can be implemented in a single code file or in multiple code files. In this case, the general resource 250 can be invoked by importing and calling the corresponding code file in the component.

[0048] Furthermore, since page styles 312 and 322 are displayed differently, dedicated resources 252 and 256 are needed to implement page styles 312 and 322 respectively. Generally, page styles do not depend on the application's context functionality, and therefore such dedicated resources can be determined based on independent resources separate from the target application. For example... Figure 3As shown, page style 312 can be implemented using dedicated resource 252, and page style 322 can be implemented using dedicated resource 256.

[0049] For context-independent page styles, which have no interaction or mutual references, the page styles can be determined directly at compile time and do not need to be determined at runtime. Therefore, the page style-related resources for each application can be directly split into independent files for maintenance. For example, separate files can be used to store page style-related resources. Specifically, a separate style file can be maintained for each application: page style 312 can be implemented using file app1.css, and page style 322 can be implemented using file app2.css. In this case, dedicated resource 252 in code framework 230 can include statements calling file app1.css to implement page style 312; and dedicated resource 256 can include statements calling file app1.css to implement page style 322.

[0050] Will understand, Figure 3 The illustration only shows the case where page styles 312 and 322 are different. Assuming that the two page styles render the page in the same way, the same file (e.g., app.css) can be used to implement the two identical page styles. In this case, code frame 230 will include a common resource (not shown) pointing to the page style file, and both applications can call the common resource to render background color, font, etc., in the same style in both applications.

[0051] According to an exemplary implementation of this disclosure, since the specific display content of page logics 314 and 324 is different, dedicated resources 254 and 258 are needed to implement page logics 314 and 324 respectively. Generally, page logic involves application context-dependent functions. In this case, dependent resources, including interfaces for receiving context parameters from the target application, can be used to determine dedicated resources. At this time, the page logic and the application have a contextual relationship; for example, the page logic involves internal mutual references and interactions. Specifically, when displaying content areas in a component, different content needs to be displayed for different applications. For example, when a user interacts with the application (e.g., clicking an area in a component), it is necessary to determine which application the interaction should be fed back to, and so on. In this case, it is necessary to determine which application the user is using at runtime. Therefore, it is necessary to determine the specific context parameters of the application.

[0052] According to one exemplary implementation of this disclosure, dedicated context parameters can be provided: for example, _APP1 can represent application 110 for providing news services, and _APP2 can represent application 120 for providing video services. See below for further details. Figure 4Describe more details about the dedicated resources related to implementing the page logic. Figure 4 A block diagram 400 illustrates a code framework based on some implementations of this disclosure. For example... Figure 4 As shown, the code framework 230 may include multiple parts: general resource 250 can implement the part shared between applications 110 and 120, that is, the function of displaying tabs. Further, the code framework 230 may include: dedicated resource 254 for implementing the function of displaying text content in application 110; and dedicated resource 258 for implementing the function of displaying video content in application 120.

[0053] It will be understood that the process of determining dedicated resources was described above using the examples of displaying text in content area 112 of application 110 and displaying video in content area 122 of application 120 as specific examples of dedicated functions. According to one exemplary implementation of this disclosure, dedicated functions may also include one or more other functions. For example, scores may be displayed in different formats in score area 114 of application 110 and score area 124 of application 120. In this case, dedicated resources for implementing the functions of each score area 114 and 124 can be determined based on the specific descriptions defining score areas 114 and 124.

[0054] Using the exemplary implementation of this disclosure, resources for components used in different applications can be managed uniformly within the code framework 230. Thus, for multiple applications 110 and 120, only a single version of the code framework 230 needs to be maintained. This reduces the complexity of managing component development and avoids the overhead of redundant development. Furthermore, using the context parameters "_APP1" and "_APP2", resources for different applications can be isolated within the code framework 230. This facilitates the generation of corresponding target resources for a specific target application later.

[0055] According to an exemplary implementation of this disclosure, the component generator 260 can be invoked at various stages of component development. For example, in the early stages of component development, the component generator 260 can be used to generate a code framework 230. The locations of general and special resources can be pre-specified in the code framework 230. At this time, the general and special resources in the code framework 230 can be reserved areas, and the development engineer can be prompted to write general and special resources in these reserved areas. Specifically, the development engineer can be prompted to import the corresponding code in a dialog box, or the code can be written directly in the dialog box.

[0056] Alternatively and / or additionally, component generator 260 can be invoked during component development. Assuming the developer of application 110 has already developed its own code framework 230, component generator 260 can receive description 220 from the developer of application 120 and compare it with description 210. Further, it can determine which general resources can be shared and which private resources cannot. At this point, component generator 260 can divide code framework 230 into general resources and private resources (at this point, code framework 230 only includes general resource 250 and private resources 252 and 254 for application 110, and the private resources for application 120 can point to reserved areas). At this point, applications 110 and 120 can share general resource 250, and can specify corresponding private resources 256 and 258 (e.g., pointing to reserved areas) for page styles 322 and page logic 324 of application 120. Further, it can prompt the developer of application 120 to supplement and improve the content of private resources 256 and 258.

[0057] Using the exemplary implementation of this disclosure, the component generator 260 can be invoked at multiple stages of component development, thereby facilitating developers to share component code when needed and improving code reusability.

[0058] Having distinguished between general resources and individual dedicated resources, these resources can be combined to generate target resources for implementing the functionality of component 240 in a target application across multiple applications. It will be understood that the target application here can be either application 110 or 120. See below for further details. Figure 5 Describe the target resources generated for different applications.

[0059] Figure 5 A block diagram 500 shows target resources for different applications according to some implementations of this disclosure. For example... Figure 5 As shown, the file APP1.js can be used to define the target resource 212 generated by application 110. This target resource 212 can include a dedicated resource 252 for importing page style 312, a general resource 250 for implementing page logic 310, and a dedicated resource 254 for implementing page logic 314. Furthermore, the file APP2.js can be used to define the target resource 222 generated by application 120. This target resource 222 can include a dedicated resource 256 for importing page style 322, a general resource 250 for implementing page logic 320, and a dedicated resource 258 for implementing page logic 324.

[0060] It will be understood that the above description is merely illustrative of the scenario where a common resource 250 is shared between applications 110 and 120. According to one exemplary implementation of this disclosure, applications 110 and 120 may share common resources for implementing other functionalities. For example, component 240 may provide the same "statistics" functionality for calculating the scoring status of individual players. In this case, common resources can be determined in a similar manner to implement the "statistics" functionality in each application.

[0061] According to one exemplary implementation of this disclosure, more configuration parameters can be provided to define how the target resource is generated. See also Figure 6 For more details regarding the configuration parameters, please refer to the following. Figure 6 A block diagram 600 illustrating configuration parameters for managing components according to some implementations of this disclosure is shown. According to an exemplary implementation of this disclosure, it is possible to utilize, as... Figure 6 The configuration parameter 610 shown (e.g., represented in JSON format) defines several parameters for generating the target resource. It will be understood that... Figure 6 The schematic data structure for implementing configuration parameter 610 is shown only. According to one exemplary implementation of this disclosure, configuration parameter 610 may be stored in tables, files, arrays and / or other formats.

[0062] Specifically, configuration parameter 610 may include the target application, for example, indicated by the keyword "output_client", in order to specify which application the target resource is generated for.

[0063] According to an exemplary implementation of this disclosure, target resources can be generated for either application 110 or 120; alternatively, target resources can also be generated for both applications 110 and 120. With "output_client": ["APP1"] set, resources such as... can be generated. Figure 5 The target resource 212 shown; with "output_client": ["APP2"] set, it can generate as follows: Figure 5 The target resource 222 shown; with "output_client": ["APP1", "APP2"] set, can generate as follows. Figure 5 The two target resources 212 and 222 are shown. Using the exemplary implementation of this disclosure, only the configuration parameter 610 needs to be modified to define which application generates the target resource in a simple and flexible way.

[0064] According to an exemplary implementation of this disclosure, configuration parameter 610 may further include a production mode. For example, it may be represented by the keyword "output_mode" to specify whether the generated target resource includes the functionality of the component in another application besides the target application. In this case, the specific method of generating the target resource can be determined based on the production mode.

[0065] According to an exemplary implementation of this disclosure, a splitting mode (e.g., denoted by the keyword "separate") can indicate that the generated target resources do not include the functionality of the component in another application besides the target application. When "output_mode": "seperate" is set, the target resource can be generated based on the general resources and the dedicated resources corresponding to the target application from the first and second dedicated resources. In this case, the target resource generated for application 110 may include general resource 250 and dedicated resources 252 and 254 used by application 110 itself, but not dedicated resources 256 and 258 used by another application 120. Using the exemplary implementation of this disclosure, the splitting mode can isolate dedicated resources of different applications, thereby ensuring that the target resource generated for the target application does not include redundant resources used by other applications. In this way, the size of the target resource can be reduced, thereby improving the performance of the target resource.

[0066] Alternatively and / or additionally, the merge mode (e.g., denoted by the keyword "mixed") can indicate that the generated target resource includes the functionality of the component in another application besides the target application. When "output_mode": "mixed" is set, the target resource can be generated based on a general resource, a first dedicated resource, and a second dedicated resource. In this case, generating target resource 212 for application 110 may include: a general resource 250, dedicated resources 252 and 254 for application 110's own use, and dedicated resources 256 and 258 for use by another application 120. It will be understood that there are currently many components developed based on existing technical solutions, whose code resources include redundant resources for multiple applications. Using the exemplary implementation of this disclosure, the merge mode can be compatible with existing technical solutions and can enable components generated using the merge mode to be directly called by existing applications.

[0067] According to an exemplary implementation of this disclosure, configuration parameter 610 may further include an inheritance pattern (e.g., indicated by the keyword "need_common") to indicate whether the target resource inherits the component's common page styles (hereinafter referred to as common styles). Typically, a component framework may include common styles (e.g., background, font, etc.) to describe the common display of the component. Additionally, the page logic in the component's description may specify certain special styles to override the component's common styles.

[0068] According to one exemplary implementation of this disclosure, the inheritance pattern can be used to specify whether to import the component's generic styles. Figure 7 A block diagram 700 is shown for generating a target resource based on an inheritance pattern, according to some implementations of this disclosure. For example, when "need_common": True is set, common styles will be further imported into the target resource. Specifically, as... Figure 7 As shown, the target resource 212 for application 110 may include a statement 710 for importing common styles. Alternatively, with "need_common": False set, the target resource 212 may not include statement 710 and may only include statements for importing the application 110's specific page style "app1.css".

[0069] Using the exemplary implementation of this disclosure, the inheritance mode allows setting whether common styles are inherited across target resources used in different applications. With inheritance mode enabled, developers are not required to copy the code for common styles, thus reducing their workload. Conversely, with inheritance mode disabled, developer-defined display styles become the active page styles. This provides greater flexibility for component management and allows developers to choose whether to enable or disable inheritance mode based on the specific application environment.

[0070] According to one exemplary implementation of this disclosure, component generator 260 can provide development engineers with an interface to modify configuration parameter 610. For example, configuration parameter 610 can be modified via a configuration file and / or a dedicated dialog box. Utilizing the exemplary implementation of this disclosure provides greater flexibility in managing the component development process, thereby enabling more efficient sharing of components across multiple applications.

[0071] According to one exemplary implementation of this disclosure, developers can further debug and release the target resource. During debugging, developers are allowed to make modifications. It will be understood that developers are allowed to directly modify general and specific resources within the code framework 230. At this point, new target resources can be generated based on the modified resources in the code framework 230, and then used for the next round of debugging. It will be understood that frequent modifications to the code framework 230 by a large number of developers from multiple applications may introduce instability into the code framework 230 and increase the difficulty of version management. In this case, developers can be allowed to modify the target resources for their own applications, and after completing the phase debugging and obtaining a relatively stable version (e.g., once a day, or at other time intervals), then feed that version back to the code framework 230.

[0072] Figure 8 A block diagram 800 illustrates the process of modifying the code framework according to some implementations of this disclosure. Figure 8 The illustration shows a scenario where a developer modifies target resource 212. Upon receiving a modification to the portion of target resource 212 corresponding to general resource 250 (e.g., code resource 810), the general resource 250 in code framework 230 can be updated based on this modification. It will be understood that since general resource 250 involves multiple applications, modifications to general resource 250 require coordination among the development engineers of multiple applications. For example, on the basis of consensus, code resource 810 in target resource 212 can be modified, and the modification can then be submitted to code framework 230. Alternatively and / or additionally, component generator 260 can determine whether to accept the modification. Alternatively and / or additionally, component generator 260 can allow the modified general resource 250 to be received directly at code framework 230.

[0073] According to an exemplary implementation of this disclosure, upon receiving a modification to a portion of target resource 212 corresponding to a dedicated resource 254 for a target application (e.g., code resource 820), the dedicated resource 254 for the target application in code framework 230 can be updated based on this modification. It will be understood that dedicated resource 254 is invoked only by application 110, thus eliminating the need for coordination among developers of multiple applications to update code framework 230 based on this modification. Utilizing the exemplary implementation of this disclosure, while providing a unified code framework 230, allows developers of multiple applications to perform their own debugging and release work. In this way, application-specific developers can be isolated from unrelated code resources, thereby improving development efficiency.

[0074] According to an exemplary implementation of this disclosure, the content of the code framework 230 can be continuously updated based on the process described above. Using this exemplary implementation, the code framework 230 can be managed in a unified manner, and it can be ensured that the code framework 230 can be updated iteratively and in a timely manner. Furthermore, target resources can be updated based on updated general resources and updated dedicated resources for the target application within the code framework 230. In this way, the component generator 260 can provide development engineers with a more convenient shared development environment, thereby facilitating the sharing of components among multiple applications.

[0075] According to an exemplary implementation of this disclosure, after the debugging of a component has been completed, the corresponding component can be published. For example, the final component from target resources 212 and 222 can be published. At this time, applications 110 and 120 can access the final component via a specified address, thereby enabling applications 110 and 120 to respectively provide components that perform the desired functions.

[0076] According to one exemplary implementation of this disclosure, multiple applications can be software applications that implement different functions, such as application 110 for providing news services and application 120 for providing video services described above. In the context of this disclosure, the operating system on which each application is based is not limited; for example, application 110 and application 120 can be applications developed based on the same or different operating systems. According to one exemplary implementation of this disclosure, multiple applications can be software applications developed based on different operating systems to implement the same function. For example, two applications can be applications developed based on different operating systems to provide video services.

[0077] It will be understood that although the process of sharing components between two applications, 110 and 120, has been described above as an example, according to one exemplary implementation of this disclosure, components can be shared between more applications. For example, in addition to the news-providing application 110 and video-providing application 120 described above, the "Sports" component described above can also be invoked in an application providing an instant messaging service. In this case, the "Sports" component can be displayed as a tab in the instant messaging service application. Based on the specific description of the application, the "Sports" component can have customized functionality within that application. For example, it can display text with a red background and black font, display content areas as text and images, and so on.

[0078] The exemplary implementation of this disclosure allows for the sharing of component development processes across multiple applications. In this way, components in multiple applications can share the same code framework. This eliminates the need to write only one set of code when writing component code, avoiding the need to modify each version individually, which would be required in scenarios where separate component versions are maintained for each application. Furthermore, the target resources generated for each application can isolate the specific functionalities of each application, ensuring a smaller final deployed component resource size and thus faster response times.

[0079] Using the exemplary implementation of this disclosure, the code framework 230 of component 240 can be managed with a more granular approach. In other words, the functionality of the code framework 230 of component 240 is further broken down into general resources and special resources, thereby allowing for more granular code sharing within the component.

[0080] Example process

[0081] Figure 9 A flowchart of a method 900 for managing application components according to some implementations of this disclosure is shown. Specifically, at block 910, a first description for defining a first function of the component in a first application and a second description for defining a second function of the component in a second application are received, the first function and the second function respectively including page styles of the component in the first application and the second application; at block 920, based on the first description and the second description, general resources, first dedicated resources and second dedicated resources are determined for implementing the component's code framework, the general resources implementing the general function between the first function and the second function, the first dedicated resources implementing the first dedicated function in the first function, and the second dedicated resources implementing the second dedicated function in the second function; and at block 930, based on the general resources, the first dedicated resources and the second dedicated resources, target resources for implementing the component's function in the target application are generated for the target application in the first application and the second application.

[0082] According to an exemplary implementation of this disclosure, determining the first dedicated resource includes: in response to determining that the first description involves context-independent functionality, determining the first dedicated resource based on an independent resource independent of the target application.

[0083] According to an exemplary implementation of this disclosure, the first function further includes page logic of the component in the first application, and determining the first dedicated resource includes: in response to determining that the first description involves context-dependent functionality, determining the first dedicated resource based on dependent resources that depend on the target application, the dependent resources including an interface for receiving context parameters of context-dependent functionality from the target application.

[0084] According to an exemplary implementation of this disclosure, generating a target resource for implementing the functionality of a component in a target application further includes: receiving a generation mode for a specified target resource, the generation mode indicating whether the target resource includes the functionality of the component in another application outside the target application; and generating the target resource based on the generation mode.

[0085] According to an exemplary implementation of this disclosure, generating a target resource based on a generation pattern includes: in response to determining that the generation pattern indicates that the target resource does not include functionality in another application, generating the target resource based on a general resource and a special resource corresponding to the target application from a first special resource and a second special resource.

[0086] According to an exemplary implementation of this disclosure, generating a target resource based on a generation pattern includes: in response to determining that the generation pattern indicates that the target resource includes functionality in another application, generating the target resource based on a general resource, a first dedicated resource, and a second dedicated resource.

[0087] According to an exemplary implementation of this disclosure, generating a target resource for implementing the functionality of a component in a target application further includes: receiving an inheritance pattern of a specified target resource, the inheritance pattern indicating whether the target resource inherits the component's generic page style; and generating the target resource based on the inheritance pattern.

[0088] According to an exemplary implementation of this disclosure, method 900 further includes at least one of the following: in response to receiving a modification to a portion of the target resource corresponding to a general resource, updating the general resource in the code framework based on the modification; and in response to receiving a modification to a portion of the target resource corresponding to a special resource for the target application, updating the special resource for the target application in the code framework based on the modification.

[0089] According to an exemplary implementation of this disclosure, method 900 further includes: updating the target resource based on updated general resources in the code framework and updated special resources for the target application.

[0090] According to one exemplary implementation of this disclosure, the first application and the second application are software applications used to implement different functions.

[0091] According to one exemplary implementation of this disclosure, the first application and the second application are software applications developed on different operating systems to achieve the same function.

[0092] Example devices and equipment

[0093] Figure 10A block diagram of an apparatus 1000 for managing application components according to some implementations of the present disclosure is shown. The apparatus 1000 includes: a receiving module 1010 configured to receive a first description defining a first function of a component in a first application and a second description defining a second function of the component in a second application, the first function and the second function respectively including page styles of the component in the first application and the second application; a determining module 1020 configured to determine, based on the first and second descriptions, general resources, first dedicated resources, and second dedicated resources in a code framework for implementing the component, the general resources implementing a general function between the first function and the second function, the first dedicated resources implementing a first dedicated function within the first function, and the second dedicated resources implementing a second dedicated function within the second function; and a generating module 1030 configured to generate target resources for implementing the functions of the component in the target applications, for a target application in the first application and the second application, based on the general resources, the first dedicated resources, and the second dedicated resources.

[0094] According to an exemplary implementation of this disclosure, the determining module 1020 includes: a style resource determining module configured to determine a first dedicated resource based on an independent resource independent of the target application in response to determining that the first description involves context-independent functionality.

[0095] According to an exemplary implementation of this disclosure, the first function further includes page logic of the component in the first application, and the determining module 1020 includes: a logic resource determining module configured to determine a first dedicated resource based on dependent resources that depend on the target application in response to determining that the first description involves context-related functions, the dependent resources including an interface for receiving context parameters of context-related functions from the target application.

[0096] According to an exemplary implementation of this disclosure, the generation module 1030 further includes: a generation mode receiving module, configured to receive a generation mode of a specified target resource, the generation mode indicating whether the target resource includes the functionality of a component in another application outside the target application; and a function generation module, configured to generate the target resource based on the generation mode.

[0097] According to an exemplary implementation of this disclosure, the feature generation module includes: a split pattern generation module configured to generate a target resource based on a general resource and a special resource corresponding to the target application from a first special resource and a second special resource, in response to determining that the generation pattern indicates that the target resource does not include features in another application.

[0098] According to an exemplary implementation of this disclosure, the feature generation module includes: a merge pattern generation module configured to generate the target resource based on a general resource, a first dedicated resource, and a second dedicated resource in response to determining that the generation pattern indicates that the target resource includes features in another application.

[0099] According to an exemplary implementation of this disclosure, the generation module 1030 further includes: an inheritance mode receiving module, configured to receive an inheritance mode of a specified target resource, wherein the inheritance mode indicates whether the target resource inherits the general page style of the component; and a style generation module, configured to generate the target resource based on the inheritance mode.

[0100] According to an exemplary implementation of this disclosure, the apparatus 1000 further includes at least one of the following: a general modification module configured to update a general resource in a code framework based on a modification received for a portion of a target resource corresponding to a general resource; and a special modification module configured to update a special resource in a code framework for a target application based on a modification received for a portion of a target resource corresponding to a special resource for a target application.

[0101] According to an exemplary implementation of this disclosure, the apparatus 1000 further includes: an update module configured to update target resources based on updated general resources in the code framework and updated special resources for the target application.

[0102] According to one exemplary implementation of this disclosure, the first application and the second application are software applications used to implement different functions.

[0103] According to one exemplary implementation of this disclosure, the first application and the second application are software applications developed on different operating systems to achieve the same function.

[0104] Figure 11 A block diagram of a device 1100 capable of implementing various implementations of the present disclosure is shown. It should be understood that... Figure 11 The computing device 1100 shown is merely exemplary and should not be construed as limiting the functionality and scope of the implementation described herein. Figure 11 The computing device 1100 shown can be used to implement the method described above.

[0105] like Figure 11As shown, computing device 1100 is in the form of a general-purpose computing device. Components of computing device 1100 may include, but are not limited to, one or more processors or processing units 1110, memory 1120, storage devices 1130, one or more communication units 1140, one or more input devices 1150, and one or more output devices 1160. Processing unit 1110 may be a physical or virtual processor and is capable of performing various processes according to programs stored in memory 1120. In a multiprocessor system, multiple processing units execute computer-executable instructions in parallel to improve the parallel processing capability of computing device 1100.

[0106] Computing device 1100 typically includes multiple computer storage media. Such media can be any available media accessible to computing device 1100, including but not limited to volatile and non-volatile media, removable and non-removable media. Memory 1120 can be volatile memory (e.g., registers, cache, random access memory (RAM)), non-volatile memory (e.g., read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), flash memory), or some combination thereof. Storage device 1130 can be removable or non-removable media and can include machine-readable media, such as flash drives, disks, or any other media that can be used to store information and / or data (e.g., training data for training) and can be accessed within computing device 1100.

[0107] The computing device 1100 may further include additional removable / non-removable, volatile / non-volatile storage media. Although not explicitly stated... Figure 11 As shown, disk drives for reading from or writing to removable, non-volatile disks (e.g., "floppy disks") and optical disk drives for reading from or writing to removable, non-volatile optical disks can be provided. In these cases, each drive can be connected to a bus (not shown) via one or more data media interfaces. Memory 1120 may include computer program product 1125 having one or more program modules configured to perform various methods or actions of various implementations of this disclosure.

[0108] The communication unit 1140 enables communication with other computing devices via a communication medium. Additionally, the components of the computing device 1100 can function as a single computing cluster or multiple computing machines capable of communicating via communication connections. Therefore, the computing device 1100 can operate in a networked environment using logical connections to one or more other servers, networked personal computers (PCs), or another network node.

[0109] Input device 1150 can be one or more input devices, such as a mouse, keyboard, trackball, etc. Output device 1160 can be one or more output devices, such as a monitor, speaker, printer, etc. Computing device 1100 can also communicate as needed with one or more external devices (not shown) via communication unit 1140. These external devices include storage devices, display devices, etc., and can communicate with one or more devices that enable user interaction with computing device 1100, or with any device that enables computing device 1100 to communicate with one or more other computing devices (e.g., network card, modem, etc.). Such communication can be performed via input / output (I / O) interfaces (not shown).

[0110] According to exemplary implementations of this disclosure, a computer-readable storage medium is provided that stores computer-executable instructions thereon, wherein the computer-executable instructions are executed by a processor to implement the methods described above. According to exemplary implementations of this disclosure, a computer program product is also provided, which is tangibly stored on a non-transitory computer-readable medium and includes computer-executable instructions, which are executed by a processor to implement the methods described above. According to exemplary implementations of this disclosure, a computer program product is provided that stores a computer program thereon, which, when executed by a processor, implements the methods described above.

[0111] Various aspects of this disclosure are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatuses, devices, and computer program products implemented according to this disclosure. It should be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer-readable program instructions.

[0112] These computer-readable program instructions can be provided to a processing unit of a general-purpose computer, a special-purpose computer, or other programmable data processing apparatus to produce a machine such that, when executed by the processing unit of the computer or other programmable data processing apparatus, they create means for implementing the functions / actions specified in one or more blocks of the flowchart and / or block diagram. These computer-readable program instructions can also be stored in a computer-readable storage medium that causes a computer, programmable data processing apparatus, and / or other device to operate in a particular manner. Thus, the computer-readable medium storing the instructions comprises an article of manufacture that includes instructions for implementing aspects of the functions / actions specified in one or more blocks of the flowchart and / or block diagram.

[0113] Computer-readable program instructions can be loaded onto a computer, other programmable data processing apparatus, or other device to cause a series of operational steps to be performed on the computer, other programmable data processing apparatus, or other device to produce a computer-implemented process, thereby causing the instructions that execute on the computer, other programmable data processing apparatus, or other device to perform the functions / actions specified in one or more boxes of a flowchart and / or block diagram.

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

[0115] Various implementations of this disclosure have been described above. These descriptions are exemplary and not exhaustive, nor are they limited to the disclosed implementations. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described implementations. The terminology used herein is chosen to best explain the principles, practical applications, or improvements to technology in the market, or to enable others skilled in the art to understand the various implementations disclosed herein.

Claims

1. A method for managing components of an application, comprising: Receive a first description for defining a first function of a component in a first application and a second description for defining a second function of the component in a second application, wherein the first function and the second function respectively include the page style of the component in the first application and the second application; Based on a comparison of the first description and the second description, a code framework for implementing the component is determined. The code framework maintains the component for implementing different functions in the first application and the second application, respectively. The code framework includes general resources, a first dedicated resource and a second dedicated resource of the component. The general resource implements a general function between the first function and the second function. The first dedicated resource implements a first dedicated function in the first function, and the second dedicated resource implements a second dedicated function in the second function. as well as Based on the general resource, the first dedicated resource, and the second dedicated resource, for the target application in the first application and the second application, target resources are generated to implement the functions of the component in the target application, including: Configuration parameters are used to define multiple parameters for generating the target resource. These parameters include: parameters specifying the target application and parameters specifying the generation mode of the target resource. The generation mode indicates whether the target resource includes the functionality of the component in another application besides the target application. The target resources of the target application are generated based on the generation mode.

2. The method of claim 1, wherein determining the first dedicated resource comprises: In response to determining that the first description relates to a context-independent function, the first dedicated resource is determined based on an independent resource independent of the target application.

3. The method of claim 1, wherein the first function further includes the page logic of the component in the first application, and determining the first dedicated resource includes: In response to determining that the first description involves context-dependent functionality, the first dedicated resource is determined based on dependent resources that depend on the target application, the dependent resources including an interface for receiving context parameters of the context-dependent functionality from the target application.

4. The method of claim 3, wherein generating the target resource based on the generation mode comprises: In response to determining that the generation mode indicates that the target resource does not include the functionality in the other application, the target resource is generated based on the general resource and the dedicated resource corresponding to the target application from the first dedicated resource and the second dedicated resource.

5. The method of claim 1, wherein generating the target resource based on the generation mode comprises: In response to determining that the generation mode indicates that the target resource includes the functionality in the other application, the target resource is generated based on the general resource, the first dedicated resource, and the second dedicated resource.

6. The method of claim 1, wherein generating the target resource for implementing the function of the component in the target application further comprises: Receive the inheritance mode of the target resource, whereby the inheritance mode indicates whether the target resource inherits the general page style of the component; as well as The target resource is generated based on the inheritance pattern.

7. The method of claim 1, further comprising at least one of the following: In response to receiving a modification to the portion of the target resource corresponding to the general resource, the general resource in the code framework is updated based on the modification; and In response to receiving a modification to a portion of the target resource corresponding to a dedicated resource for the target application, the dedicated resource for the target application in the code framework is updated based on the modification.

8. The method of claim 7, further comprising: The target resources are updated based on the updated general resources and the updated special resources for the target application within the code framework.

9. The method of claim 1, wherein the first application and the second application satisfy at least one of the following: The first application and the second application are software applications used to implement different functions; and The first application and the second application are software applications developed based on different operating systems to achieve the same function.

10. An apparatus for managing components of an application, comprising: The receiving module is configured to receive a first description for defining a first function of a component in a first application and a second description for defining a second function of the component in a second application, wherein the first function and the second function respectively include the page style of the component in the first application and the second application; A determining module is configured to determine a code framework for implementing the component based on a comparison of the first description and the second description. The code framework maintains the component for implementing different functions in the first application and the second application, respectively. The code framework includes general resources, a first dedicated resource and a second dedicated resource of the component. The general resource implements a general function between the first function and the second function. The first dedicated resource implements a first dedicated function in the first function, and the second dedicated resource implements a second dedicated function in the second function. as well as A generation module is configured to, based on the general resource, the first dedicated resource, and the second dedicated resource, generate target resources for implementing the functionality of the component in the target application within the first application and the second application, including: Configuration parameters are used to define multiple parameters for generating the target resource. These parameters include: parameters specifying the target application and parameters specifying the generation mode of the target resource. The generation mode indicates whether the target resource includes the functionality of the component in another application besides the target application. The feature generation module is configured to generate the target resources of the target application based on the generation mode.

11. The apparatus of claim 10, wherein the determining module comprises: A style resource determination module is configured to determine the first dedicated resource based on an independent resource independent of the target application in response to determining that the first description involves a context-independent function.

12. The apparatus of claim 10, wherein the first function further includes page logic of the component in the first application, and the determining module includes: A logical resource determination module is configured to determine the first dedicated resource based on dependent resources that depend on the target application in response to determining that the first description involves context-related functionality, the dependent resources including an interface for receiving context parameters of the context-related functionality from the target application.

13. The apparatus of claim 10, wherein the function generation module comprises: A splitting pattern generation module is configured to generate the target resource based on the general resource and the dedicated resource corresponding to the target application from the first dedicated resource and the second dedicated resource in response to determining that the generation pattern indicates that the target resource does not include the functionality in the other application.

14. The apparatus of claim 10, wherein the function generation module comprises: A merge pattern generation module is configured to generate the target resource based on the general resource, the first dedicated resource, and the second dedicated resource in response to determining that the generation pattern indicates that the target resource includes the functionality in the other application.

15. The apparatus of claim 10, wherein the generating module further comprises: An inheritance mode receiving module is configured to receive an inheritance mode for the specified target resource, wherein the inheritance mode indicates whether the target resource inherits the general page style of the component; as well as The style generation module is configured to generate the target resource based on the inheritance pattern.

16. The apparatus of claim 10, further comprising: A general modification module is configured to update the general resource in the code framework based on the modification received for a portion of the target resource corresponding to the general resource; as well as A dedicated modification module is configured to update the dedicated resource for the target application in the code framework based on the modification received for a portion of the target resource corresponding to a dedicated resource for the target application. as well as An update module is configured to update the target resource based on updated general resources in the code framework and updated dedicated resources for the target application.

17. An electronic device comprising: At least one processing unit; as well as At least one memory, coupled to the at least one processing unit and storing instructions for execution by the at least one processing unit, which, when executed by the at least one processing unit, cause the electronic device to perform the method according to any one of claims 1 to 9.

18. A computer-readable storage medium having a computer program stored thereon, the computer program causing the processor to implement the method according to any one of claims 1 to 9 when executed by a processor.

Images