CN116974555A

CN116974555A - Method, device, equipment and storage medium for assembling software development kit

Info

Publication number: CN116974555A
Application number: CN202310774682.0A
Authority: CN
Inventors: 龚正; 郭彪; 李伟
Original assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Current assignee: Beijing Baidu Netcom Science and Technology Co Ltd
Priority date: 2023-06-28
Filing date: 2023-06-28
Publication date: 2023-10-31

Abstract

The disclosure provides an assembly method, an assembly device and a storage medium of a software development kit, relates to the technical field of computers, and particularly relates to the technical field of software development. The specific implementation scheme is as follows: determining a first functional module running in a static component mode from a plurality of target functional modules selected according to functional requirements; compiling the first functional module into a component file by utilizing the component adapter; and obtaining a software development kit based on the kernel file and the component file. The method and the device can improve the development efficiency of the software development kit and reduce repeated development.

Description

Method, device, equipment and storage medium for assembling software development kit

Technical Field

The present disclosure relates to the field of computer technology, and in particular, to the field of software development technology.

Background

The software development kit (Software Development Kit, SDK) may provide one or more capabilities for software, applications. The plug-in is an extension mechanism of the SDK, which can be dynamically loaded into the host application to provide additional functionality or enhance existing functionality.

The use of plug-in technology based on dynamic loading is not allowed in some business requirements, so that SDK products need to be developed as different projects according to whether plug-ins can be used or not.

Disclosure of Invention

The present disclosure provides an assembly method, apparatus, device and storage medium for a software development kit.

According to an aspect of the present disclosure, there is provided an assembling method of a software development kit, including:

determining a first functional module running in a static component mode from a plurality of target functional modules selected according to functional requirements;

compiling the first functional module into a component file by using a component adapter;

and obtaining a software development kit based on the kernel file and the component file.

According to another aspect of the present disclosure, there is provided an assembling apparatus of a software development kit, including:

the component determining module is used for determining a first functional module running in a static component mode from a plurality of target functional modules selected according to functional requirements;

the component compiling module is used for compiling the first functional module into a component file by utilizing the component adapter;

and the assembly module is used for obtaining a software development kit based on the kernel file and the component file.

According to another aspect of the present disclosure, there is provided an electronic device including:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein,,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of the embodiments of the present disclosure.

According to another aspect of the present disclosure, there is provided a non-transitory computer-readable storage medium storing computer instructions for causing the computer to perform a method according to any one of the embodiments of the present disclosure.

According to another aspect of the present disclosure, there is provided a computer program product comprising a computer program which, when executed by a processor, implements a method according to any of the embodiments of the present disclosure.

The method and the device can improve the development efficiency of the software development kit and reduce repeated development.

It should be understood that the description in this section is not intended to identify key or critical features of the embodiments of the disclosure, nor is it intended to be used to limit the scope of the disclosure. Other features of the present disclosure will become apparent from the following specification.

Drawings

The drawings are for a better understanding of the present solution and are not to be construed as limiting the present disclosure. Wherein:

FIG. 1 is a flow diagram of a method of assembling a software development kit according to one embodiment of the present disclosure;

FIG. 2 is a schematic diagram of the structure of a modular SDK provided by an embodiment of the present disclosure;

FIG. 3 is a schematic diagram of the structure of a modular SDK provided by an embodiment of the present disclosure;

FIG. 4 is a schematic diagram of an assembly device of a software development kit according to an embodiment of the disclosure;

fig. 5 is a block diagram of an electronic device used to implement an embodiment of the present disclosure.

Detailed Description

Exemplary embodiments of the present disclosure are described below in conjunction with the accompanying drawings, which include various details of the embodiments of the present disclosure to facilitate understanding, and should be considered as merely exemplary. Accordingly, one of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope of the present disclosure. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.

Fig. 1 is a flow chart illustrating an assembling method of a software development kit according to an embodiment of the disclosure. As shown in fig. 1, the method at least comprises the following steps:

s101, determining a first functional module running in a static component mode from a plurality of target functional modules selected according to functional requirements.

In the embodiment of the disclosure, the plurality of target function modules may be selected from a preset function module library according to a function requirement. The function module library comprises a plurality of developed function modules which can realize different functions. Functional modules can be generally divided into support modules and business modules. In one example, the support module may include a network module, a plug-in management module, a data reporting module, a privacy control module, an encryption and decryption module, and the like. The service module can comprise a security module, a pushing module, a face acquisition module, a virus scanning module and the like.

The function module library has the function that when one SDK product is developed, whether the function of the SDK product can be realized by the existing function modules through permutation and combination is firstly determined, if so, the development of the SDK product only needs to select a needed target function module for combination, and codes for realizing the function of the product do not need to be written, so that the development quantity is reduced.

S102, compiling the first functional module into a component file by using the component adapter.

After determining a plurality of target function modules for realizing the product function requirements, determining a first function module running in a static component mode according to service scenes or service requirements. Specifically, if the application program APP of the service party needs to be used in a scenario that dynamic loading is not allowed, the selected target function module is directly compiled to obtain a component file through a compiling system and a component adapter. And compiling the component file and the kernel file into a static SDK product.

S103, obtaining a software development kit based on the kernel file and the component file.

The kernel file, i.e., the kernel of the SDK, may be understood as a single special module that provides several basic tools, class libraries, interfaces and algorithms for handling the underlying logic and runtime environment of the SDK, and provides support and basic functions for other components, plug-ins, or functional modules.

Component files, i.e., components of an SDK, may be understood as several individual modules or functional units in the SDK, typically having specific functions or tasks. Components may be reusable, stand-alone software units that can interact with or be combined with other components to build a more complex system. The design of the components aims to promote multiplexing, modularization and maintainability of the code, so that developers can more easily construct and expand software applications.

A component can be thought of as a higher level module built on top of a kernel. The components may interact with the kernel, use the basic functions and interfaces provided by the kernel, and provide specific functions or services according to specific needs. Thus, the kernel provides the underlying operating environment for the SDK, while the components provide more specific and specific functionality on top of the kernel, which in cooperation can constitute the complete SDK.

According to the scheme of the embodiment of the disclosure, the developed functional modules can be reused, so that repeated development is reduced; the functional module can be rapidly modularized through the assembly adapter, so that the development efficiency of the software development kit is improved.

In one possible implementation, step S103: based on the kernel file and the component file, a software development kit is obtained, which comprises the following steps:

s1031, determining a second functional module running in a dynamic loading mode from a plurality of target functional modules under the condition that the functional requirements allow dynamic loading.

S1032, compiling the second functional module into a plug-in file by using the plug-in adapter.

S1033, obtaining the software development kit based on the metadata of the kernel file, the component file and the plug-in file. The metadata of the plug-in file at least comprises a unique identifier of the plug-in file and a download address for acquiring the plug-in file.

In the embodiment of the disclosure, if the service party APP is allowed to use in a dynamically loaded scenario, the selected second functional module is compiled into a plug-in through a compiling system and a plug-in adapter. And the SDK can only comprise a kernel, a plurality of basic supporting modules and an interface panel (UI) for the APP to call when being released, thereby simplifying the SDK. In one example, the underlying support module includes: the system comprises a network module, a plug-in management module and an encryption and decryption module. After the service side APP integrates the SDK, the SDK provides corresponding functions by downloading plug-ins from the cloud server.

In one example, the kernel provides an external interface, a call bridge between components and plug-ins, and a complete initialization flow. The external interface may bridge function calls provided by the APP to a plug-in or component of the SDK. The initialization flow can ensure that after the SDK is started, required plug-ins are downloaded from the cloud and organized into a complete structure with the static component. Call bridges between components and plug-ins may provide call capability across components/plug-ins.

It should be noted that, the second functional module generally does not include a network module and a plug-in management module, that is, the network module and the plug-in management module cannot be used as a dynamic plug-in, and when these modules are not included, the dynamic plug-in cannot be downloaded and loaded.

According to the scheme of the embodiment of the disclosure, the functional module can be compiled into a dynamic plug-in or a static component according to service requirements. And the same functional module can be freely switched among the plug-ins or the components through the adapter, so that the problem of developing the component SDK and the plug-in SDK respectively for adapting to service limitation is avoided.

In one possible implementation, step S102: compiling the first functional module into a component file using the component adapter, comprising the steps of:

s1021, compiling the first functional module independently by using the assembly adapter to obtain an archive file with an assembly structure.

S1022, generating a first configuration file according to the first functional module. The first configuration file contains a module list of the first functional module.

S1023, merging and packaging the archive files corresponding to the first functional module in the module list to obtain the component file.

In the embodiment of the disclosure, the component adapter may be understood as an Android Zhuo Daima Library (Android Library) project, which is used for assembling one or more first functional modules into a binary Archive (aar) file with a component structure. The component adapter has a first configuration file containing a first list of functional modules contained by the component. The component adapter first triggers the compiling system to compile each first functional module individually when compiling, and the compiling product of each first functional module is a aar file. And then merging and packaging the files of each functional module aar to obtain a component file.

In one example, the component adapter compiles one or more already developed functional modules into a component, typically requiring the following steps:

designing an assembly interface: and defining an externally exposed interface of the component, and determining input and output parameters, methods, events and the like of the component.

Component code is written: integrating codes of the functional modules, creating an independent component item, and writing codes of the components.

Configuration construction script: depending on the build tool used (e.g., gradle, maven, etc.), the build script is configured, including dependency management, compilation options, packaging, etc.

And (3) constructing a component: and executing the construction script, and compiling the functional module into a component. The build process compiles the code of the functional module into an executable binary file or library and generates an output file of the component.

Export component: the component files generated by compilation are exported to a designated directory or repository so that other projects or developers may reference and use the component.

The assembly adapter can take the process of realizing the steps as a standard flow, so that any functional module can be assembled into a aar file with a preset assembly structure. It should be noted that the specific compilation process and steps may vary depending on the development environment, construction tools, and programming language. The above steps are general examples, and specific implementations require adjustment and configuration according to project requirements and development tools.

According to the scheme of the embodiment of the disclosure, the function module is modularized by using the assembly adapter, so that the modularized rewriting of the function module is not needed manually, and the development efficiency of the SDK is improved.

In one possible implementation, the first configuration file includes a function entry for the first function module.

The component adapter is used for determining the function entry of the first function module corresponding to the function name from the first configuration file according to the function name to be called so as to realize bridge call of the first function module.

In the embodiment of the disclosure, the component adapter provides a bridge calling method, the function name to be called can be input through the SDK shell, and the component adapter determines the function entry of the first function module corresponding to the function name from the first configuration file, so as to bridge the corresponding function.

The SDK shell is also referred to as an external interface or external layer of the SDK. The SDK is a public interface and a function set provided externally by the SDK and is used for interacting and integrating with external application programs or systems. It should be noted that, the basic operation environment provided by the SDK kernel may also include an external interface for interacting with an external application, so that the SDK kernel may also be regarded as a shell for each component and plug-in.

According to the scheme of the embodiment of the disclosure, a bridge calling method is provided for the component through the component adapter.

In one possible implementation, the assembly method of the embodiments of the present disclosure further includes the steps of:

and writing an external interface method of the first functional module into the panel class by using the component adapter so as to realize direct calling of the first functional module through the panel class.

In the embodiment of the disclosure, a Panel Class (Panel Class) refers to a Class including an external interface method of each functional module. The panel class is used as a set, and the interface methods of the functional modules are extracted and combined together so as to be directly called by the SDK shell. The panel class may also be referred to as an external interface class (External Interface Class), a functional interface class (Function Interface Class), or similar names.

The panel class is used for providing a place for centralized management of the interface methods of the functional modules, so that the shell can more conveniently access and call the functions of the functional modules. By incorporating the external interface methods of the functional modules into the panel class, the shell program can invoke the interface methods of the functional modules by accessing an instance or static method of the panel class without directly accessing the interfaces of the individual functional modules.

According to the scheme of the embodiment of the disclosure, the component adapter extracts and merges the external interface methods of each module into one panel class in the compiling process, so that the SDK shell can be directly called.

In one possible implementation, step S1032: compiling the second functional module into a plug-in file by using a plug-in adapter, further comprising the steps of:

and compiling the second functional module independently by using the plug-in adapter to obtain the application program package file with the plug-in structure.

And generating a second configuration file according to the second functional module. The second configuration file contains a module list of the second functional module.

And merging and packaging the application program package files corresponding to the second functional module in the module list to obtain plug-in files.

In the embodiment of the disclosure, a plug-in adapter may be understood as an application program (Android Application) project, which is used to assemble one or more second functional modules into an android package (apk) file with a plug-in structure. The plug-in adapter is provided with a second configuration file, wherein the second configuration file comprises a module list of second function modules contained in the plug-in, and the function inlets of the second function modules are respectively arranged in the module list. Similarly to the component adapter, the plug-in adapter firstly triggers the independent compiling of each second functional module when compiling, and combines and packages the apk files of each functional module to obtain plug-in files.

According to the scheme of the embodiment of the disclosure, the function module is plugged by using the plug-in adapter, so that the plug-in rewriting of the function module is not needed manually, and the development efficiency of the SDK is improved.

In one possible implementation, the second configuration file includes a function entry for the second function module.

The plug-in adapter is used for determining the function entry of the second function module corresponding to the function name from the second configuration file according to the function name to be called so as to realize bridge call of the second function module.

In the embodiment of the disclosure, the plug-in adapter provides a bridge calling method, the function name to be called can be transmitted through the SDK shell, and the plug-in adapter determines the function entry of the second function module corresponding to the function name from the second configuration file, so as to bridge the corresponding function.

According to the scheme of the embodiment of the disclosure, a bridge calling method is provided for the plug-in through the plug-in adapter.

in case of a functional association of at least two target functional modules, a first federated module is provided in the component adapter. The first joint module is used for calling at least two target function modules according to a predefined flow.

In the embodiment of the disclosure, when the component adapter compiles, if the product includes a joint function (for example, the device environment security data is collected and packaged together in the face collection process), the component adapter is additionally incorporated into a first joint module, and the face module and the security module are respectively called according to a predefined process and combined into a complete product capability. The predefined flow is determined according to the business flow and the calling relation between the functional modules which are called respectively.

According to the scheme of the embodiment of the disclosure, the new capability which is richer and more complete can be obtained based on the original capability combination of a plurality of components.

in case of a functional association of at least two target functional modules, a second federated module is provided in the plug-in adapter. The second combined module is used for calling at least two target functional modules according to a predefined flow.

In the embodiment of the disclosure, when the plug-in adapter compiles, if the product contains a joint function, the plug-in adapter is additionally combined into a second joint module, at least two target function modules are respectively called according to a predefined flow, and the target function modules are combined into complete product capability.

According to the scheme of the embodiment of the disclosure, the new capability which is richer and more complete can be obtained based on the original capability combination of a plurality of plug-ins.

In one possible implementation, when the SDK product is developed, a desired target function module may be selected from a function module library formed by the service module library and the base module library according to the function requirement of the SDK product. And then, according to the scene requirement of the SDK product on the service, determining a first functional module needing to be modularized and/or a second functional module needing to be plugin in each target functional module. The first functional module is componentized with a component adapter. Or plug-in the second functional module by using a plug-in adapter. And assembling the obtained multiple components and/or plug-ins with the basic SDK kernel to obtain a complete SDK product.

In one example, as shown in fig. 2, the service module library includes an air control module, an equipment fingerprint module, a virus scanning module, a pushing module and a face collection module. The basic module library comprises a network module, a plug-in management module, an encryption and decryption module and a privacy control module. In the example shown in fig. 2, the network module, the plug-in management module, and the encryption/decryption module are modularized, so as to obtain a base component. The face acquisition module is componentized to obtain a face acquisition component for providing face acquisition capability which is not subjected to safety reinforcement. The pushing module is componentized to obtain a pushing component for providing pushing capability. The wind control module, the virus scanning module and the privacy control module are assembled to obtain a safety assembly for providing safety-related capability. The security component, the base component, and the base SDK kernel may be assembled together to obtain a secure SDK with secure wind control capability. The push component, the base component, and the base SDK kernel may be assembled together to obtain a push SDK with push capabilities. The security component, the face collection component, the base component and the base SDK kernel can be assembled together to obtain the security face collection SDK with reinforced face collection capability. I.e. the capabilities provided by the functional modules required by the SDK are already encapsulated in the SDK by the corresponding components without dynamic loading.

In another example, shown in FIG. 3, the SDK product differs from the example of FIG. 2 in that it allows the use of dynamically loaded plug-ins. Therefore, the face acquisition module can be subjected to plugin to obtain a face acquisition plugin. The push module can obtain push plug-ins through plug-in. The wind control module, the virus scanning module and the privacy control module can be plugged to obtain a safety plug-in. The face collection plug-in, the pushing plug-in and the security plug-in are encrypted and then distributed on the cloud server. The secure SDK needs to be assembled by the base component and the base SDK kernel and then dynamically loads the secure plug-in. Similarly, push SDKs need to be assembled by the base component and the base SDK kernel before the push plug-ins are dynamically loaded. The security face collection SDK is assembled by the basic component and the basic SDK kernel, and then the security plug-in and the face collection plug-in are dynamically loaded.

The component adapter and the plug-in adapter are used for respectively modularizing and plug-in the function module. The component adapter and the plug-in adapter need to provide bridging of basic operation environments for the operation of the functional modules, and the basic environments are actually realized by an SDK kernel (shell) or realized by the SDK kernel through basic components, including contexts (the contexts used by the components are the same as those used by the SDK kernel, and the plug-ins use independent contexts to realize resource isolation), resource file paths, data reporting, broadcast receiving capability, encryption and decryption capability, data persistence capability and the like.

The SDK kernel is an Android Library project and is responsible for final output of the capabilities of each module. And the support module is used for providing support for external interfaces and operation environments for the components and the plug-ins. The support of the external interface comprises:

and initializing an interface, wherein the assembly is started in the initializing process, and the plug-in is pulled from the cloud and loaded, so that the integrity of the plug-in is finally ensured.

And the call bridge is used for calling the independent capability provided by each module or the joint capability organized through the adapter.

And presetting an Android component pile, wherein the Android component pile is used for preregistering with a system in a Service party APP so as to support the Android component (Activity, service, receiver) operation in a module in a component/plug-in.

Support for the operating environment includes:

context object; general data reporting capability; privacy item acquisition management and control capability; inter-component/inter-plug-in capability, including multi-process call support; an ability to register and receive broadcasts with the system; unique Id generation capability; the basic function library comprises a thread pool, network requests, persistence, encryption and decryption and other basic functions.

According to the scheme of the embodiment of the disclosure, a compiling system based on an android platform is provided, and a supporting module and a service module can be compiled into a plug-in or a component. When the method is used, a certain number of modules are selected according to the requirement, compiled into plug-ins, and then a certain number of modules are selected and compiled into SDK products together with an SDK kernel.

After the SDK products are assembled, the SDK products are released to a business side APP for integration, and plug-in parts are encrypted and then released to a cloud server. Therefore, when the SDK product containing the plugin is initialized for the first time, the encrypted plugin file package (dex file+so file) is downloaded from the cloud server, decrypted and loaded after integrity check. And then the service party can call specific functions through an external bridging UI provided by the SDK kernel.

When a certain APP needs to be supplemented with capability, dynamic release can be performed by releasing a new plug-in or adjusting the existing plug-in function, and the APP is not required to be re-integrated with the SDK. On the other hand, each functional module only needs to pay attention to the logic and realization of the service function, so that the reusability of the functional module is improved.

Fig. 4 is a schematic structural diagram of an assembling device of a software development kit according to an embodiment of the present disclosure. As shown in fig. 4, the apparatus includes at least:

the component determining module 401 is configured to determine, from a plurality of target function modules selected according to a function requirement, a first function module that operates in a static component manner.

The component compiling module 402 is configured to compile the first functional module into a component file by using the component adapter.

An assembling module 403, configured to obtain a software development kit based on the kernel file and the component file.

In one possible implementation, the assembly module 403 includes:

and the plug-in determining sub-module is used for determining a second functional module running in a dynamic loading mode from a plurality of target functional modules under the condition that the functional requirements allow dynamic loading.

And the plug-in compiling sub-module is used for compiling the second functional module into plug-in files by utilizing the plug-in adapter.

And the assembly sub-module is used for obtaining a software development kit based on metadata of the kernel file, the component file and the plug-in file. The metadata of the plug-in file at least comprises a unique identifier of the plug-in file and a download address for acquiring the plug-in file.

In one possible implementation, the component compilation module 402 includes:

and the compiling sub-module is used for compiling the first functional module independently by utilizing the assembly adapter to obtain an archive file with an assembly structure.

And the generating sub-module is used for generating a first configuration file according to the first functional module. The first configuration file contains a module list of the first functional module.

And the packing sub-module is used for merging and packing the archive files corresponding to the first functional module in the module list to obtain the component files.

In one possible implementation, the first configuration file contains a function entry for the first function module.

In one possible embodiment, the apparatus further comprises:

and the direct calling module is used for assembling and writing the external interface of the first functional module into the panel class by utilizing the assembly adapter so as to realize the direct calling of the first functional module through the panel class.

In one possible implementation, the plug-in compiling sub-module is configured to:

In one possible implementation, the second configuration file contains a function entry for the second function module.

In one possible embodiment, the apparatus further comprises:

and the first setting module is used for setting a first joint module in the component adapter under the condition that the functions of at least two target function modules are associated. The first joint module is used for calling at least two target function modules according to a predefined flow.

In one possible embodiment, the apparatus further comprises:

and the second setting module is used for setting a second joint module in the plug-in adapter under the condition that the functions of at least two target function modules are associated. The second combined module is used for calling at least two target functional modules according to a predefined flow.

For descriptions of specific functions and examples of each module and sub-module of the apparatus in the embodiments of the present disclosure, reference may be made to the related descriptions of corresponding steps in the foregoing method embodiments, which are not repeated herein.

In the technical scheme of the disclosure, the acquisition, storage, application and the like of the related user personal information all conform to the regulations of related laws and regulations, and the public sequence is not violated.

According to embodiments of the present disclosure, the present disclosure also provides an electronic device, a readable storage medium and a computer program product.

Fig. 5 illustrates a schematic block diagram of an example electronic device 500 that may be used to implement embodiments of the present disclosure. Electronic devices are intended to represent various forms of digital computers, such as laptops, desktops, workstations, personal digital assistants, servers, blade servers, mainframes, and other appropriate computers. The electronic device may also represent various forms of mobile apparatuses, such as personal digital assistants, cellular telephones, smartphones, wearable devices, and other similar computing apparatuses. The components shown herein, their connections and relationships, and their functions, are meant to be exemplary only, and are not meant to limit implementations of the disclosure described and/or claimed herein.

As shown in fig. 5, the apparatus 500 includes a computing unit 501 that can perform various suitable actions and processes according to a computer program stored in a Read Only Memory (ROM) 502 or a computer program loaded from a storage unit 508 into a Random Access Memory (RAM) 503. In the RAM 503, various programs and data required for the operation of the device 500 can also be stored. The computing unit 501, ROM 502, and RAM 503 are connected to each other by a bus 504. An input/output (I/O) interface 505 is also connected to bus 504.

Various components in the device 500 are connected to the I/O interface 505, including: an input unit 506 such as a keyboard, a mouse, etc.; an output unit 507 such as various types of displays, speakers, and the like; a storage unit 508 such as a magnetic disk, an optical disk, or the like; and a communication unit 509 such as a network card, modem, wireless communication transceiver, etc. The communication unit 509 allows the device 500 to exchange information/data with other devices via a computer network such as the internet and/or various telecommunication networks.

The computing unit 501 may be a variety of general and/or special purpose processing components having processing and computing capabilities. Some examples of computing unit 501 include, but are not limited to, a Central Processing Unit (CPU), a Graphics Processing Unit (GPU), various specialized Artificial Intelligence (AI) computing chips, various computing units running machine learning model algorithms, a Digital Signal Processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 501 performs the various methods and processes described above, such as the assembly method of the method software development kit. For example, in some embodiments, the method of assembling a software development kit may be implemented as a computer software program tangibly embodied on a machine-readable medium, such as storage unit 508. In some embodiments, part or all of the computer program may be loaded and/or installed onto the device 500 via the ROM 502 and/or the communication unit 509. When the computer program is loaded into RAM 503 and executed by computing unit 501, one or more steps of the method of assembling a software development kit described above may be performed. Alternatively, in other embodiments, the computing unit 501 may be configured to perform the method of assembly of the software development kit in any other suitable manner (e.g., by means of firmware).

Various implementations of the systems and techniques described here above may be implemented in digital electronic circuitry, integrated circuit systems, field Programmable Gate Arrays (FPGAs), application Specific Integrated Circuits (ASICs), application Specific Standard Products (ASSPs), systems On Chip (SOCs), load programmable logic devices (CPLDs), computer hardware, firmware, software, and/or combinations thereof. These various embodiments may include: implemented in one or more computer programs, the one or more computer programs may be executed and/or interpreted on a programmable system including at least one programmable processor, which may be a special purpose or general-purpose programmable processor, that may receive data and instructions from, and transmit data and instructions to, a storage system, at least one input device, and at least one output device.

Program code for carrying out methods of the present disclosure may be written in any combination of one or more programming languages. These program code may be provided to a processor or controller of a general purpose computer, special purpose computer, or other programmable data processing apparatus such that the program code, when executed by the processor or controller, causes the functions/operations specified in the flowchart and/or block diagram to be implemented. The program code may execute entirely on the machine, partly on the machine, as a stand-alone software package, partly on the machine and partly on a remote machine or entirely on the remote machine or server.

In the context of this disclosure, a machine-readable medium may be a tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. The machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. The machine-readable medium may include, but is not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing.

To provide for interaction with a user, the systems and techniques described here can be implemented on a computer having: a display device (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor) for displaying information to a user; and a keyboard and pointing device (e.g., a mouse or trackball) by which a user can provide input to the computer. Other kinds of devices may also be used to provide for interaction with a user; for example, feedback provided to the user may be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user may be received in any form, including acoustic input, speech input, or tactile input.

The systems and techniques described here can be implemented in a computing system that includes a background component (e.g., as a data server), or that includes a middleware component (e.g., an application server), or that includes a front-end component (e.g., a user computer having a graphical user interface or a web browser through which a user can interact with an implementation of the systems and techniques described here), or any combination of such background, middleware, or front-end components. The components of the system can be interconnected by any form or medium of digital data communication (e.g., a communication network). Examples of communication networks include: local Area Networks (LANs), wide Area Networks (WANs), and the internet.

The computer system may include a client and a server. The client and server are typically remote from each other and typically interact through a communication network. The relationship of client and server arises by virtue of computer programs running on the respective computers and having a client-server relationship to each other. The server may be a cloud server, a server of a distributed system, or a server incorporating a blockchain.

It should be appreciated that various forms of the flows shown above may be used to reorder, add, or delete steps. For example, the steps recited in the present disclosure may be performed in parallel, sequentially, or in a different order, provided that the desired results of the disclosed aspects are achieved, and are not limited herein.

The above detailed description should not be taken as limiting the scope of the present disclosure. It will be apparent to those skilled in the art that various modifications, combinations, sub-combinations and alternatives are possible, depending on design requirements and other factors. Any modifications, equivalent substitutions, improvements, etc. that are within the principles of the present disclosure are intended to be included within the scope of the present disclosure.

Claims

1. A method of assembling a software development kit, comprising:

2. The method of claim 1, wherein deriving a software development kit based on a kernel file and the component file comprises:

determining a second functional module running in a dynamic loading mode from the target functional modules under the condition that the functional requirements allow dynamic loading;

compiling the second functional module into a plug-in file by using a plug-in adapter;

obtaining a software development kit based on metadata of the kernel file, the component file and the plug-in file; the metadata of the plug-in file at least comprises a unique identifier of the plug-in file and a download address for acquiring the plug-in file.

3. The method of claim 1, wherein compiling the first functional module into a component file with a component adapter comprises:

compiling the first functional module independently by utilizing a component adapter to obtain an archive file with a componentized structure;

generating a first configuration file according to the first functional module; wherein the first configuration file comprises a module list of the first functional module;

and merging and packaging the archive files corresponding to the first functional module in the module list to obtain a component file.

4. A method according to claim 3, wherein the first profile contains a function entry of the first function module;

the component adapter is used for determining a function entry of the first function module corresponding to the function name from the first configuration file according to the function name to be called so as to realize bridge call of the first function module.

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

and writing an external interface method of the first functional module into a panel class by using the assembly adapter so as to realize direct calling of the first functional module through the panel class.

6. The method of claim 2, wherein compiling the second functional module into a plug-in file with a plug-in adapter comprises:

compiling the second functional module independently by using a plug-in adapter to obtain an application program package file with a plug-in structure;

generating a second configuration file according to the second functional module; wherein the second configuration file comprises a module list of the second functional module;

7. The method of claim 6, wherein the second profile includes a function entry for the second function module;

and the plug-in adapter is used for determining a function entry of the second function module corresponding to the function name from the second configuration file according to the function name required to be called so as to realize bridge call of the second function module.

8. The method of any of claims 1 to 7, further comprising:

setting a first joint module in the component adapter in case of functional association of at least two target functional modules; the first joint module is used for calling the at least two target function modules according to a predefined flow.

9. The method of any of claims 2 to 7, further comprising:

setting a second joint module in the plug-in adapter in the case that functions of at least two target function modules are associated; the second combined module is used for calling the at least two target functional modules according to a predefined flow.

10. An assembly device of a software development kit, comprising:

11. The apparatus of claim 10, wherein the assembly module comprises:

a plug-in determining sub-module, configured to determine, from the plurality of target functional modules, a second functional module that operates in a dynamic loading manner, in a case where the functional requirement allows dynamic loading;

the plug-in compiling sub-module is used for compiling the second functional module into plug-in files by utilizing a plug-in adapter;

the assembly sub-module is used for obtaining a software development kit based on metadata of the kernel file, the component file and the plug-in file; the metadata of the plug-in file at least comprises a unique identifier of the plug-in file and a download address for acquiring the plug-in file.

12. The apparatus of claim 10, wherein the component compilation module comprises:

the compiling sub-module is used for compiling the first functional module independently by utilizing the assembly adapter to obtain an archive file with an assembly structure;

the generating sub-module is used for generating a first configuration file according to the first functional module; wherein the first configuration file comprises a module list of the first functional module;

13. The apparatus of claim 12, wherein the first profile includes a function entry for the first function module;

14. The apparatus of claim 12, further comprising:

and the direct calling module is used for assembling and writing the external interface of the first functional module into a panel class by utilizing the assembly adapter so as to realize the direct calling of the first functional module through the panel class.

15. The apparatus of claim 11, wherein the plug-in compiling sub-module is to:

16. The apparatus of claim 15, wherein the second profile includes a function entry for the second function module;

17. The apparatus of any of claims 10 to 16, further comprising:

a first setting module for setting a first joint module in the component adapter in the case that functions of at least two target function modules are associated; the first joint module is used for calling the at least two target function modules according to a predefined flow.

18. The apparatus of any of claims 11 to 16, further comprising:

a second setting module, configured to set a second joint module in the plug-in adapter in a case where functions of at least two target function modules are associated; the second combined module is used for calling the at least two target functional modules according to a predefined flow.

19. An electronic device, comprising:

at least one processor; and

a memory communicatively coupled to the at least one processor; wherein,,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1-9.

20. A non-transitory computer readable storage medium storing computer instructions for causing the computer to perform the method of any one of claims 1-9.

21. A computer program product comprising a computer program which, when executed by a processor, implements the method according to any of claims 1-9.