WO2020248172A1

WO2020248172A1 - Functional module invoking method, device and computer readable storage medium

Info

Publication number: WO2020248172A1
Application number: PCT/CN2019/090985
Authority: WO
Inventors: 李小军
Original assignee: 深圳市大疆创新科技有限公司
Priority date: 2019-06-12
Filing date: 2019-06-12
Publication date: 2020-12-17
Also published as: CN111684420A

Abstract

Provided in the embodiments of the present invention are a functional module invoking method, a device and a computer readable storage medium. The method is applied to an electronic device. A cross-platform software development engine and a software development kit (SDK) are installed on the electronic device. The method comprises: the SDK receiving, by means of a preset event interface, an event transmitted from the engine, wherein the event is related to a target functional module to be invoked, and the event interface is an interface between the SDK and the engine; and the SDK invoking, according to the event, the target functional module from functional modules integrated by the SDK. The present invention avoids the problem that interface maintenance is difficult due to the introduction of a large number of interfaces invoking functional modules in the engine.

Description

Function module calling method, equipment, and computer readable storage medium

Technical field

The present invention relates to the field of software technology, and in particular to a method, equipment, and computer-readable storage medium for calling function modules.

Background technique

With the development of computer technology, the system platforms of various development languages continue to mature, such as operating system platforms such as windows, Mac, Android, and iOS. The local language of each system platform is different. For example, Android can be Java or kotlin, and iOS can be swift or objectc. Generally, when deploying and running developed application apps on various system platforms, it is necessary to develop apps in corresponding languages based on specific system platforms. Not only does it need to develop apps in multiple languages, but also code logic maintenance requires a lot of human resources.

Therefore, cross-platform technology emerged as the times require, and cross-platform software development engines such as Unity are used to implement APP development to achieve cross-platform APP. However, the functions that can be implemented in the cross-platform software development engine are limited. If you need to expand more functions, you need to call a third-party library or function modules in other libraries to implement it.

In the calling method of related function modules, the cross-platform software development engine needs to configure the interface corresponding to each library, and the cross-platform software development engine directly calls the function module through the interface corresponding to the library where the function module is located. Therefore, in order to be able to call the function modules of various libraries other than the cross-platform software development engine, a large number of interfaces for calling the function modules will be introduced into the engine, which leads to the problem of difficult interface maintenance.

Summary of the invention

The present invention provides a method, equipment and computer-readable storage medium for calling function modules, which can avoid the problem of difficult interface maintenance caused by the introduction of a large number of interfaces for calling function modules in the engine.

In the first aspect of the embodiments of the present invention, a method for invoking a function module is provided, which is applied to an electronic device on which a cross-platform software development engine and a software development kit SDK are installed;

The method includes:

The SDK receives an event transmitted from the engine through a preset event interface, the event is related to the target function module to be called, and the event interface is an interface between the SDK and the engine;

The SDK calls the target function module from the function modules integrated by the SDK according to the event.

In a second aspect of the embodiments of the present invention, a method for invoking a function module is provided, which is applied to an electronic device on which a cross-platform software development engine and a software development kit SDK are installed;

The method includes:

When a target function module needs to be called, the engine triggers an event, and the event is related to the target function module;

The engine transmits the event to the SDK through a preset event interface. The event interface is an interface between the SDK and the engine, so that the SDK receives the event from the SDK. The target function module is called in the function module integrated by the SDK.

In a third aspect of the embodiments of the present invention, an electronic device is provided, and a cross-platform software development engine and a software development kit SDK are installed on the electronic device;

The device includes: a memory and a processor;

The memory is used to store program code;

The processor is used to call the program code, and when the program code is executed, it is used to perform the following operations:

Use the SDK to receive an event transmitted from the engine through a preset event interface, the event is related to the target function module to be called, and the event interface is an interface between the SDK and the engine;

Use the SDK to call the target function module from the function modules integrated by the SDK according to the event.

In a fourth aspect of the embodiments of the present invention, an electronic device is provided, and a cross-platform software development engine and a software development kit SDK are installed on the electronic device;

The device includes: a memory and a processor;

The memory is used to store program code;

When a target function module needs to be called, use the engine to trigger an event, and the event is related to the target function module;

Use the engine to transmit the event to the SDK through a preset event interface. The event interface is the interface between the SDK and the engine, so that the SDK receives the event from the The target function module is called from the function module integrated by the SDK.

A fifth aspect of the embodiments of the present invention provides a computer-readable storage medium, which is characterized in that:

The computer-readable storage medium stores computer instructions, and when the computer instructions are executed, the method for invoking the functional modules described in the foregoing embodiments is implemented.

Based on the above technical solution, in the embodiments of the present invention, the engine can notify the SDK to call the function module through the event mechanism. When the engine needs to call the target function module, it can transmit events related to the target function module through the event interface between the engine and the SDK. For the SDK, the SDK calls the target function module from the function module integrated by the SDK according to the event. There is no need to configure the corresponding call interface for each library function module in the engine, which not only reduces the interface required in the engine, and avoids the introduction of the engine A large number of interfaces that call function modules lead to the problem of difficult interface maintenance, and the function modules are integrated in the SDK to avoid the problem of the engine needing to manage a large number of libraries.

Description of the drawings

In order to more clearly describe the technical solutions in the embodiments of the present invention, the following will briefly introduce the drawings needed in the embodiments of the present invention. Obviously, the drawings in the following description are only some implementations recorded in the present invention. For example, for those of ordinary skill in the art, other drawings can be obtained based on these drawings of the embodiments of the present invention.

FIG. 1 is a schematic flowchart of a method for calling a function module according to an embodiment of the present invention;

2 is a schematic diagram of interaction between an engine and SDK according to an embodiment of the present invention;

3 is a schematic flowchart of a method for invoking a function module according to another embodiment of the present invention;

Fig. 4 is a structural block diagram of an electronic device according to an embodiment of the present invention.

Detailed ways

The technical solutions in the embodiments of the present invention will be clearly and completely described below in conjunction with the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are only a part of the embodiments of the present invention, rather than all the embodiments. Based on the embodiments of the present invention, all other embodiments obtained by those of ordinary skill in the art without creative work shall fall within the protection scope of the present invention. In addition, if there is no conflict, the following embodiments and the features in the embodiments can be combined with each other.

The terms used in the present invention are only for the purpose of describing specific embodiments, rather than limiting the present invention. The singular forms of "a", "said" and "the" used in the present invention and the claims are also intended to include plural forms, unless the context clearly indicates other meanings. It should be understood that the term "and/or" as used herein refers to any or all possible combinations of one or more associated listed items.

Although the terms first, second, third, etc. may be used in the present invention to describe various information, the information should not be limited to these terms. These terms are used to distinguish the same type of information from each other. For example, without departing from the scope of the present invention, the first information may also be referred to as second information, and similarly, the second information may also be referred to as first information. Depending on the context, in addition, the word "if" used can be interpreted as "when", or "when", or "in response to certainty."

The method for invoking functional modules of the embodiment of the present invention can be used in apps that need to be cross-platform. The apps are developed based on a cross-platform software development engine and can be used across platforms. There is no need to develop apps in corresponding platform local languages for different system platforms. It reduces the workload of APP development and also reduces the human resources required for code logic maintenance.

In the embodiment of the present invention, the function extension of the cross-platform software development engine can be realized. The corresponding function can be realized by calling the function modules of various libraries outside the engine by the SDK. It is only necessary to configure a unified interface between the engine and the SDK. Configure corresponding interfaces for different libraries in the engine to avoid the problem of difficult interface maintenance caused by the introduction of a large number of interfaces.

Cross-platform is an important concept in software development, that is, it does not depend on the operating system or the hardware environment. An APP developed under one operating system can still run under another operating system.

The cross-platform in the embodiment of the present invention may be across two system platforms or across more system platforms. The system platform can include popular operating system platforms such as windows, Mac, Android, iOS, Linux, etc., of course, can also include other system platforms, which will not be listed here.

The invoking method of the function module of the embodiment of the present invention will be explained below, but it should not be limited to this.

The first aspect of the embodiments of the present invention provides a method for invoking a function module, which is applied to an electronic device on which a cross-platform software development engine and a software development kit SDK are installed;

Referring to Fig. 1, in one embodiment, the calling method of the function module may include the following steps:

S100: The SDK receives an event transmitted from the engine through a preset event interface, the event is related to the target function module to be called, and the event interface is an interface between the SDK and the engine;

S200: The SDK calls the target function module from the function modules integrated by the SDK according to the event.

In this embodiment, the execution subject of the calling method of the function module may be an electronic device, and further may be a processor of the electronic device, where the processor may be one or more, and the processor may be a general-purpose processor. Or a dedicated processor. The specific type of electronic equipment is not limited, such as computer equipment, mobile equipment, etc.

A cross-platform software development engine and a software development kit SDK are installed on the electronic device. You can install an APP containing the engine and SDK on the electronic device to implement the installation of the engine and SDK. During the running of the APP, the function module can be called through the cooperation of the engine and the SDK to realize the required functions for the APP.

The cross-platform software development engine is a software development platform, and the developed software can be cross-platform. The engines mentioned in the embodiments of the present invention all refer to cross-platform software development engines. Cross-platform software development engines, such as Unity, Cocos2d-x, Qt, etc., are not limited.

Taking the cross-platform software development engine as Unity as an example, the Unity technology framework has continued to mature. Because it has cross-platform features and uses the easy-to-use C# development language, it has gradually been welcomed by developers, not only in game development, but also in game development. Common application software has also begun to be used gradually. After Unity is completed, it can be compiled into files that support various system platforms. Various file formats are different. For example, the file format that supports iOS is .framework, the file format that supports MacOS X is .bundle, and the file format that supports Windows The format is .dll, and the file format that supports Android is .so, etc. In this embodiment, Unity is installed on the corresponding system platform with a file that supports the file format of the electronic device.

The software development kit (abbreviated as SDK, and the full foreign language is called Software Development Kit) is generally a collection of development tools used by software engineers to build application software for specific software packages, software frameworks, hardware platforms, operating systems, etc.

In step S100, the SDK receives an event transmitted from the engine through a preset event interface, the event is related to the target function module to be called, and the event interface is between the SDK and the engine. interface.

When the engine needs to call the target function module, it will trigger an event related to the target function module, and notify the SDK in the form of an event that the target function module needs to be called. Events are transmitted through the event interface between the engine and the SDK. The event interface may include an event sending interface on the engine for sending events and an event receiving interface on the SDK for receiving events.

Referring to FIG. 2, the event interface may include an event sending interface 501 and an event receiving interface 601, and event transmission between the engine 50 and the SDK 60 can be realized through the event sending interface 501 and the event receiving interface 601. When the engine 50 triggers an event, it will send the event through the event sending interface 501, and the SDK 60 will receive the event through the event receiving interface 601.

The event interface can be configured in the engine and SDK in advance when developing the APP. All events related to the function module can be transmitted through the event interface between the engine and the SDK. In other words, whether it is a third-party library or a function module in a custom library, the SDK can be called through the same event interface. The engine is configured with a corresponding interface for each library function module, which greatly reduces the number of interfaces required in the engine.

In step S200, the SDK calls the target function module from the function modules integrated by the SDK according to the event.

Multiple different libraries can be integrated in the SDK, and each library can contain one or more than two functional modules. Of course, it is also possible to integrate only one library, which is not limited. SDK is a software toolkit, usually comes with some function module libraries.

In this embodiment, the function modules integrated by the SDK may include the function modules that the SDK comes with, or may include the function modules that are added to the SDK in advance (for example, during the APP development process). At present, it is not ruled out that if the APP needs more functions in the future, the possibility of adding new function modules to the SDK. The language of the SDK and its integrated functional modules can be a language suitable for underlying development and can support cross-platform use, for example, it can be a language such as C or C++.

When the SDK receives an event transmitted from the engine, since the event is related to the target function module, it can determine and call the target function module from all the function modules integrated by the SDK according to the event. The SDK can be configured with the calling interface of the function modules of each library, and the target function module can be called through the calling interface of the target function module.

The target function module is called to realize the corresponding function. For example, when the target object needs to be accelerated, the engine will trigger an event related to the acceleration function module and send the event to the SDK. After receiving the event, the SDK will call the acceleration function module according to the event to achieve the acceleration of the target object.

In the embodiment of the present invention, the engine can notify the SDK to call the function module through the event mechanism. When the engine needs to call the target function module, the event related to the target function module can be transmitted to the SDK through the event interface between the engine and the SDK. This event calls the target function module from the function module integrated by the SDK. There is no need to configure the corresponding call interface for each library function module in the engine. This not only reduces the interface required in the engine, but also avoids the introduction of a large number of calling function modules in the engine. The interface causes the problem of difficulty in interface maintenance, and the function module is integrated in the SDK, which avoids the problem of the engine needing to manage a large number of libraries.

In an embodiment, the event has a type field that records type information to which the event belongs;

In step S200, the SDK calls the target function module from the function modules integrated by the SDK according to the event, including:

S201: The SDK parses the type field of the event;

S202: The SDK calls the target function module from the function modules integrated by the SDK according to the parsed type information.

When the engine triggers an event, it can write the type information of the event in the type field of the event. On the one hand, the type information indicates the type of the event, and on the other hand, it can be used to determine the target function module. After the SDK receives the event, it can determine and call the target function module according to the type information on the type field of the event.

There may be a direct or indirect correspondence between the target function module and the type information in the event. In this way, the SDK can determine the target function module corresponding to the type information according to the type information, and call the target function module. Of course, this is only an example, and the specific calling method is not limited, as long as the target function module can be called based on the type information.

The number of bits in the type field can be customized and can be determined according to the number of all event types, such as 32 bits, 64 bits, etc., and the specific number of bits is not limited. The event can only have the type field, of course, can also have other fields, which can be determined according to needs.

In an embodiment, the type field includes a first field and a second field;

The first field records the target total type information to which the event belongs, and the second field records the target subtype information to which the event belongs among all subtype information of the target total type information;

In step S202, the SDK calls the target function module from the function modules integrated by the SDK according to the parsed type information, including:

S2021: The SDK calls the target function module according to the target total type information and target subtype information.

The type field is divided into a first field and a second field. The first field and the second field are used to record the target total type information and target subtype information of the event, respectively. For example, the upper 32 bits of the type field can be used as the first field, and the lower 32 bits can be used as the second field. Of course, how to allocate the type field can be determined according to needs.

Divide all event types into major categories first, divide into several general categories, and then divide each general category into sub-categories, and further divide into several sub-types under the general category. According to the target general category information, the general category to which the event belongs can be determined. Type, according to the target subtype information, the subtype to which the event belongs to the total type can be determined. Of course, how to classify event types is not a limitation.

In this embodiment, all events are classified in a classification manner of total type and sub-type, and the event type can be determined hierarchically, which is convenient for determining the event type so as to quickly call the target function module.

In one embodiment, in step S2021, the SDK calling the target function module according to the target total type information and target subtype information includes:

The SDK invokes the target message processing object corresponding to the target total type information, so as to use the target message processing object to determine the target event processing object corresponding to the target subtype information;

The SDK invokes the target event processing object to use the target event processing object to determine the functional module corresponding to the target subtype information;

The SDK takes the determined function module as the target function module and calls the target function module.

The SDK can be pre-configured with a message processing object (Handler) corresponding to each total type information, and an event processing object (EventHandler) corresponding to the subtype information under each total type information, and the function module call is completed through these objects.

SDK management objects can be pre-created in the SDK for creating and managing various event processing objects. Event processing objects can be responsible for the processing of one or more types of events through event type registration. The user can easily extend the event processing object to handle a variety of different transactions.

After the SDK receives the event, it can call the target message processing object corresponding to the target total type information according to the target total type information in the event. The target message processing object can find the target event processing object according to the target subtype information, and set the target subtype Information is transmitted to the target event processing object, and the target event processing object can determine the target function module according to the target subtype information, and then call the target function module.

In this embodiment, the target message processing object is determined first, and then the target message processing object distributes the event to the target event processing object for processing. Different event processing objects can determine the function modules to be called according to the event subtype, and realize the event Distributed processing can improve the efficiency of event processing.

In an embodiment, before the SDK receives the event transmitted from the engine through the preset event interface, the method further includes the following steps:

S010: The SDK receives the creation message transmitted by the engine through the preset object management interface, the creation message is used to instruct the creation of the SDK management object, the SDK management object is used to manage the objects required to call the function module, so The object management interface is the interface between the SDK and the engine;

S020: The SDK creates an SDK management object according to the creation message.

There is an object management interface between the engine and the SDK, and the object management interface may include a first message sending interface on the engine for sending messages and a first message receiving interface on the SDK for receiving messages (not shown in FIG. 2). The engine can send a creation message to the SDK through the first message sending interface, and the SDK can receive the creation message from the engine through the first message receiving interface.

The creation message is used to instruct the creation of the SDK management object. After the SDK receives the creation message, it can create the SDK management object based on the creation message. The SDK management objects can be one or more than two, which are used to manage the objects required to call the function module, such as managing various event processing objects.

In this embodiment, the SDK management object manages the event processing object, which is actually the management function module. The creation message is transmitted through the object management interface to create the SDK management object, which facilitates the management of each event processing object and function module, and reduces the need for the engine Management work.

Of course, the object management interface can also be used to transmit other messages, such as the destruction message used to instruct the destruction of the SDK management object. The engine can send the destruction message to the SDK through the first message sending interface, and the SDK can receive the message from the engine through the first message receiving interface. Destroy the message and destroy the created SDK management object according to the destruction message.

S030: The SDK receives the initialization message transmitted by the engine through a preset object initialization interface, the initialization message is used to instruct to initialize the SDK management object, the SDK management object is used to manage the objects required to call the function module, so The object initialization interface is the interface between the SDK and the engine;

S040: The SDK initializes the SDK management object according to the initialization message.

Of course, steps S030 and S040 are executed after steps S010 and S020. The SDK object is created first, and then the SDK object is initialized.

There is an object initialization interface between the engine and the SDK, and the object initialization interface may include a second message sending interface on the engine for sending messages and a second message receiving interface on the SDK for receiving messages (not shown in FIG. 2). The engine can send an initialization message to the SDK through the second message sending interface, and the SDK can receive the initialization message from the engine through the second message receiving interface.

The initialization message is used to indicate the initialization of the SDK management object. After the SDK receives the initialization message, it can initialize the created SDK management object according to the initialization message. The initialization state of the SDK management object can be defined as required.

In this embodiment, the engine can notify the SDK to initialize the SDK management object through an initialization message, which makes the initialization operation more convenient.

In one embodiment, after the SDK invokes the target function module from the function module integrated by the SDK according to the event, the method further includes the following steps:

S300: The SDK obtains the target execution result obtained by calling the target function module;

S400: The SDK transmits the target execution result to the engine through a preset callback interface; the callback interface is an interface between the SDK and the engine, and is used to call the SDK into various functional modules The execution result obtained is transmitted to the engine.

There is a callback interface between the engine and the SDK. The callback interface can include a result sending interface on the SDK for sending execution results, and a result receiving interface on the engine for receiving execution results. After the SDK calls the target function module, it can send the target execution result obtained from the call to the engine through the result sending interface, and the engine receives the target execution result through the result receiving interface.

Continuing to refer to FIG. 2, the callback interface includes a result sending interface 602 and a result receiving interface 502. Through the result sending interface 602 and the result receiving interface 502, the transmission of the execution result between the SDK 60 and the engine 50 can be realized. The SDK 60 can obtain the execution result after calling a function module, and sends the execution result to the engine 50 through the result sending interface 602, and the engine 50 receives the execution result through the result receiving interface.

After the engine receives the target execution result, it can prompt for the target execution result, or perform the next transaction processing according to the target execution result to realize the required functions.

In one embodiment, the event is triggered when the engine receives a call instruction indicating the target function module to be called, and the event also carries an identifier for identifying the call instruction;

In step S400, the SDK transmits the target execution result to the engine through a preset callback interface, including:

S401: The SDK obtains an identifier from the event;

S402: The SDK carries the identifier in the target execution result and transmits it to the engine through the callback interface.

In this embodiment, the event may be triggered by a call instruction, which may be input by an external user, or may be generated during the execution of the electronic device, which is not specifically limited.

Operating the same button multiple times on an electronic device can trigger multiple call instructions. For example, operating the same accelerator key twice will accelerate twice, but the basic speed of the two accelerations is different, so even if the same function module is called, the result The results of the implementation may also be different. In order to enable the engine and SDK to distinguish each call instruction, an identifier is determined for each call instruction.

The event carries an identifier that identifies the call instruction, so that the SDK can distinguish the call instruction that triggered the event based on the identifier; the execution result returned by the SDK also carries the identifier, so that the engine can determine the corresponding execution result based on the identifier Call the instruction to correctly prompt or further process the execution result.

Based on the description in the foregoing embodiment, when the target message processing object passes the target subtype information to the corresponding target event processing object, it can also pass the identifier into the target event processing object, and when the target execution result is obtained, it will also The identifier is carried in the target execution result, and the SDK transmits the target execution result carrying the identifier to the engine.

In one embodiment, the event carries data related to the event;

In step S200, when the SDK calls the target function module from the function module integrated by the SDK according to the event, the method further includes:

S210: The SDK inputs the data into the target function module, so that the target function module performs processing according to the data.

The data carried in the event is the data required for the operation of the target function module. The specific data required by each function module is different and can be determined according to actual needs. The data may include data carried in the call instruction, data acquired on the electronic device, and so on.

After the SDK inputs the data carried by the event as a parameter to the target function module, the target function module performs corresponding processing according to the input data. Of course, it is not ruled out that some functional modules do not need to input data during operation. At this time, the event may not carry relevant data.

In one embodiment, the language of the SDK supports the operating system of the device, and the SDK supports an operating system different from the operating system of the device.

In other words, the language of the SDK can support more than two operating systems, of course, including the operating system of the electronic device that is the execution subject of the embodiment of the present invention. In this way, the SDK can be used across platforms.

The language of the SDK may include languages such as C, C++, etc., of course, it is not limited to this, and other languages that can support different operating systems are also possible.

In the embodiment of the present invention, the language of the interface on the SDK is preferably C language. Because C++ has the characteristics of overloading, it is easy to cause renaming problems. Using C language to write interfaces can avoid the problem of function renaming and ensure the uniqueness of interface names. To avoid calling errors.

In one embodiment, the language of the SDK is the same as the language of the functional module integrated by the SDK. The language of the SDK and the function module is the same, which makes the calling interface between the SDK and the function module easier to write, and the function module can be called more conveniently.

The language of the functional modules integrated by the SDK and SDK can be C or C++, etc. The languages of the SDK and functional modules support different operating systems to ensure that the entire APP is cross-platform.

In one embodiment, the SDK integrates multiple different functional modules. In this way, more functions can be extended for the engine.

These functional modules can be functional modules in the same library or functional modules in different libraries. Of course, it does not rule out that the SDK integrates only one functional module.

The second aspect of the embodiments of the present invention provides a method for invoking a function module, which is applied to an electronic device on which a cross-platform software development engine and a software development kit SDK are installed;

Referring to Figure 3, in one embodiment, the calling method of the function module includes the following steps:

T100: When a target function module needs to be called, the engine triggers an event, and the event is related to the target function module;

T200: The engine transmits the event to the SDK through a preset event interface. The event interface is the interface between the SDK and the engine, so that the SDK receives the event from The target function module is called from the function module integrated by the SDK.

In this embodiment, the execution subject of the calling method of the function module may be an electronic device, and further may be a processor of the electronic device, where the processor may be one or more, and the processor may be a general-purpose processor. Or a dedicated processor. The specific type of electronic equipment is not limited, such as computer equipment, mobile equipment, etc. A cross-platform software development engine and a software development kit SDK are installed on the electronic device.

In step T100, when the target function module needs to be called, the engine triggers an event, and the event is related to the target function module.

When the engine needs to call the target function module, it will trigger an event related to the target function module, and notify the SDK in the form of an event that the target function module needs to be called.

In step T200, the engine transmits the event to the SDK through a preset event interface. The event interface is an interface between the SDK and the engine, so that the SDK depends on the received The event calls the target function module from the function module integrated by the SDK.

Events are transmitted through the event interface between the engine and the SDK. The event interface may include an event sending interface on the engine for sending events and an event receiving interface on the SDK for receiving events.

Referring to FIG. 2, the event interface may include an event sending interface 501 and an event receiving interface 601. Event transmission between the engine 50 and the SDK 60 can be realized through the event sending interface 501 and the event receiving interface 601. When the engine 50 triggers an event, it will send the event through the event sending interface 501, and the SDK 60 will receive the event through the event receiving interface 601.

The event interface can be configured in the engine and SDK in advance when developing the APP. All events related to the function module can be transmitted through the event interface between the engine and the SDK. In other words, whether it is a third-party library or a function module in a custom library, the SDK can be notified through the same event interface. The engine is configured with a corresponding interface for each library function module, which greatly reduces the number of interfaces required in the engine.

In one embodiment, the event has a type field that records type information to which the event belongs.

In an embodiment, the type field includes a first field and a second field;

The first field records the target total type information to which the event belongs, and the second field records the target subtype information to which the event belongs among all subtype information of the target total type information.

In an embodiment, before the engine triggers an event, the method further includes:

When the SDK management object needs to be created, the engine transmits a creation message to the SDK through the preset object management interface. The creation message is used to instruct the creation of the SDK management object, and the SDK management object is used to manage the call to the function module. The object management interface is an interface between the SDK and the engine, so that the SDK creates an SDK management object according to the received creation message.

When the SDK management object needs to be initialized, the engine transmits an initialization message to the SDK through the preset object initialization interface. The initialization message is used to instruct to initialize the SDK management object, and the SDK management object is used to manage the call function module. The object initialization interface is an interface between the SDK and the engine, so that the SDK initializes the SDK management object according to the received initialization message.

There is an object initialization interface between the engine and the SDK. The object initialization interface can include a second message sending interface on the engine for sending messages and a second message receiving interface on the SDK for receiving messages (not shown in Figure 2). The engine can send an initialization message to the SDK through the second message sending interface, and the SDK can receive the initialization message from the engine through the second message receiving interface.

In an embodiment, after the engine transmits the event to the SDK through a preset event interface, the method further includes:

The engine receives the target execution result transmitted from the SDK through a preset callback interface. The target execution result is the execution result obtained by invoking the target function module; the callback interface is the one between the SDK and the engine. The inter-interface is used to transmit the execution result obtained by the SDK invoking each function module to the engine.

The engine receives instructions;

When a call instruction is received, the call instruction is used to indicate the target function module to be called, and the engine determines that the target function module needs to be called.

In this embodiment, the event may be triggered by a call instruction, which may be input by an external user, or may be generated during the execution of the electronic device, which is not specifically limited. As long as the call instruction indicating the target function module to be called is received, it can be determined that the target function module needs to be called, and step T100 is executed.

In one embodiment, the engine transmits the event to the SDK through a preset event interface, including:

Determining, by the engine, an identifier for identifying the calling instruction according to the calling instruction;

The engine carries the identifier in the event and transmits it to the SDK through the event interface, so that the SDK carries the identifier in the target execution result and transmits it to the target through the callback interface The engine.

In one embodiment, the instruction carries data related to the event;

The engine transmits the event to the SDK through a preset event interface, including:

The engine obtains the data from the call instruction;

The engine carries the data in the event and transmits it to the SDK through the event interface, so that the SDK inputs the data into the target function module.

The call instruction will carry the data required for the operation of the target function module. After the data is obtained from it, the obtained data is carried in the event, and the event carrying the data is transmitted to the SDK through the event interface.

The data carried in the event is the data required for the operation of the target function module. The specific data required by each function module is different and can be determined according to actual needs.

A third aspect of the embodiments of the present invention provides an electronic device, on which a cross-platform software development engine and a software development kit SDK are installed.

Referring to FIG. 4, in one embodiment, the electronic device 100 includes: a memory 101 and a processor 102. The memory 101 is used to store program codes. The processor 102 is used to call the program code, and when the program code is executed, it is used to perform the following operations:

When the processor uses the SDK to call the target function module from the function module integrated by the SDK according to the event, it is specifically used to:

Parse the type field of the event by using the SDK;

The SDK is used to call the target function module from the function module integrated by the SDK according to the parsed type information.

In an embodiment, the type field includes a first field and a second field;

When the processor uses the SDK to call the target function module from the function module integrated with the SDK according to the type information parsed by the SDK, it is specifically used to:

Using the SDK to call the target function module according to the target total type information and target subtype information.

In one embodiment,

When the processor uses the SDK to call the target function module according to the target total type information and target subtype information, it is specifically configured to:

Calling the target message processing object corresponding to the target total type information by using the SDK, so as to use the target message processing object to determine the target event processing object corresponding to the target subtype information;

Using the SDK to call the target event processing object, so as to use the target event processing object to determine the functional module corresponding to the target subtype information;

Use the SDK to take the determined function module as the target function module and call the target function module.

In an embodiment, before the processor receives an event transmitted from the engine through a preset event interface using the SDK, it is further used to:

Use the SDK to receive a creation message transmitted by the engine through a preset object management interface, the creation message is used to instruct the creation of an SDK management object, and the SDK management object is used to manage objects required for invoking a function module. The object management interface is the interface between the SDK and the engine;

Use the SDK to create an SDK management object according to the creation message.

In one embodiment, before the processor uses the SDK to receive the event transmitted from the engine through a preset event interface, it is further configured to:

The SDK is used to receive the initialization message transmitted by the engine through a preset object initialization interface. The initialization message is used to instruct to initialize the SDK management object. The SDK management object is used to manage the objects required to call the function module. The object initialization interface is the interface between the SDK and the engine;

Use the SDK to initialize the SDK management object according to the initialization message.

In an embodiment, after the processor uses the SDK to call the target function module from the function module integrated by the SDK according to the event, it is further configured to:

Using the SDK to obtain the target execution result obtained by invoking the target function module;

Use the SDK to transmit the target execution result to the engine through a preset callback interface; the callback interface is the interface between the SDK and the engine, and is used to call the SDK into various functional modules. The execution result of is transmitted to the engine.

In one embodiment,

The event is triggered when the engine receives a call instruction indicating the target function module to be called, and the event also carries an identifier for identifying the call instruction;

When the processor uses the SDK to transmit the target execution result to the engine through a preset callback interface, it is specifically used to:

Use the SDK to obtain an identifier from the event;

The SDK is used to carry the identifier in the target execution result and is transmitted to the engine through the callback interface.

In one embodiment,

The event carries data related to the event;

When the processor uses the SDK to call the target function module from the function module integrated by the SDK according to the event, it is also used to:

Use the SDK to input the data into the target function module, so that the target function module executes processing according to the data.

In one embodiment, the language of the SDK is the same as the language of the functional module integrated by the SDK.

In one embodiment, the SDK integrates multiple different functional modules.

For the specific content of the electronic device provided in the third aspect of the embodiment of the present invention, please refer to the description content in the method for invoking a function module provided in the first aspect of the embodiment of the present invention, which is not repeated here.

A fourth aspect of the embodiments of the present invention provides an electronic device, on which a cross-platform software development engine and a software development kit SDK are installed.

In an embodiment, the type field includes a first field and a second field;

In an embodiment, before the processor uses the engine to trigger an event, it is also used to:

When an SDK management object needs to be created, the engine is used to transmit a creation message to the SDK through a preset object management interface. The creation message is used to instruct the creation of the SDK management object, and the SDK management object is used to manage and call function modules. A required object, the object management interface is an interface between the SDK and the engine, so that the SDK creates an SDK management object according to the received creation message.

When the SDK management object needs to be initialized, the engine is used to transmit an initialization message to the SDK through the preset object initialization interface. The initialization message is used to instruct to initialize the SDK management object, and the SDK management object is used to manage and call function modules. The required object, the object initialization interface is an interface between the SDK and the engine, so that the SDK initializes the SDK management object according to the received initialization message.

In an embodiment, after the processor uses the engine to transmit the event to the SDK through a preset event interface, it is further used to:

Use the engine to receive the target execution result transmitted from the SDK through the preset callback interface, the target execution result is the execution result obtained by calling the target function module; the callback interface is the SDK and the engine The interface between is used to transmit the execution result obtained by the SDK invoking each function module to the engine.

Use the engine to receive instructions;

When a call instruction is received, the call instruction is used to indicate the target function module to be called, and the engine is used to determine the target function module to be called.

In one embodiment, when the processor uses the engine to transmit the event to the SDK through a preset event interface, it is specifically used to:

Using the engine to determine an identifier for identifying the calling instruction according to the calling instruction;

Use the engine to carry the identifier in the event and transmit it to the SDK through the event interface, so that the SDK carries the identifier in the target execution result and transmits it through the callback interface To the engine.

In one embodiment, the instruction carries data related to the event;

When the processor uses the engine to transmit the event to the SDK through a preset event interface, it is specifically used to:

Obtain the data from the call instruction by using the engine;

The engine is used to carry the data in the event and is transmitted to the SDK through the event interface, so that the SDK inputs the data into the target function module.

In one embodiment, the SDK integrates multiple different functional modules.

For the specific content of the electronic device provided in the fourth aspect of the embodiment of the present invention, please refer to the description content in the method for invoking a function module provided in the second aspect of the embodiment of the present invention, which is not repeated here.

Based on the same inventive concept as the above method, an embodiment of the present invention also provides a computer-readable storage medium storing computer instructions, which can be implemented when the computer instructions are executed (for example, the computer instructions are executed by a processor) The calling method of the function module described in the foregoing embodiment.

The systems, devices, modules or units explained in the above embodiments may be implemented by computer chips or entities, or implemented by products with certain functions. A typical implementation device is a computer. The specific form of the computer can be a personal computer, a laptop computer, a cellular phone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email receiving and sending device, and a game control A console, a tablet computer, a wearable device, or a combination of any of these devices.

For the convenience of description, when describing the above device, the functions are divided into various units and described separately. Of course, when implementing the present invention, the functions of each unit can be implemented in the same one or more software and/or hardware.

Those skilled in the art should understand that the embodiments of the present invention may be provided as methods, systems, or computer program products. Therefore, the present invention may adopt the form of a complete hardware embodiment, a complete software embodiment, or an embodiment combining software and hardware. Moreover, the embodiments of the present invention may adopt the form of a computer program product implemented on one or more computer-usable storage media (including but not limited to disk storage, CD-ROM, optical storage, etc.) containing computer-usable program codes.

The present invention is described with reference to flowcharts and/or block diagrams of methods, devices (systems), and computer program products according to embodiments of the present invention. It should be understood that each process and/or block in the flowchart and/or block diagram, and the combination of processes and/or blocks in the flowchart and/or block diagram can be implemented by computer program instructions. These computer program instructions can be provided to the processor of a general-purpose computer, a special-purpose computer, an embedded processor, or other programmable data processing equipment to generate a machine, so that the instructions executed by the processor of the computer or other programmable data processing equipment are generated It is a device that realizes the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

Moreover, these computer program instructions can also be stored in a computer-readable memory that can guide a computer or other programmable data processing equipment to work in a specific manner, so that the instructions stored in the computer-readable memory produce an article of manufacture including the instruction device, The instruction device realizes the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

These computer program instructions can also be loaded into a computer or other programmable data processing equipment, so that a series of operation steps are executed on the computer or other programmable equipment to produce computer-implemented processing, thereby executing instructions on the computer or other programmable equipment Provides steps for realizing the functions specified in one process or multiple processes in the flowchart and/or one block or multiple blocks in the block diagram.

The above descriptions are only embodiments of the present invention and are not used to limit the present invention. For those skilled in the art, the present invention can have various modifications and changes. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the scope of the claims of the present invention.

Claims

A method for invoking a functional module, which is characterized in that it is applied to an electronic device on which a cross-platform software development engine and a software development kit SDK are installed;

The method includes:

The SDK receives an event transmitted from the engine through a preset event interface, the event is related to the target function module to be called, and the event interface is an interface between the SDK and the engine;

The SDK calls the target function module from the function modules integrated by the SDK according to the event.
The method for invoking a function module according to claim 1, wherein the event has a type field that records type information to which the event belongs;

The SDK calling the target function module from the function module integrated by the SDK according to the event includes:

The SDK parses the type field of the event;

The SDK calls the target function module from the function modules integrated by the SDK according to the parsed type information.
The method for invoking a function module according to claim 2, wherein the type field includes a first field and a second field;

The first field records the target total type information to which the event belongs, and the second field records the target subtype information to which the event belongs among all subtype information of the target total type information;

The SDK calls the target function module from the function modules integrated by the SDK according to the parsed type information, including:

The SDK calls the target function module according to the target total type information and target subtype information.
The calling method of the function module according to claim 3, characterized in that,

The SDK calling the target function module according to the target total type information and target subtype information includes:

The SDK invokes the target message processing object corresponding to the target total type information, so as to use the target message processing object to determine the target event processing object corresponding to the target subtype information;

The SDK invokes the target event processing object to use the target event processing object to determine the functional module corresponding to the target subtype information;

The SDK takes the determined function module as the target function module and calls the target function module.
The method for invoking a function module according to claim 1, wherein before the SDK receives the event transmitted from the engine through a preset event interface, the method further comprises:

The SDK receives a creation message transmitted by the engine through a preset object management interface, the creation message is used to instruct the creation of an SDK management object, the SDK management object is used to manage objects required to call a function module, the object The management interface is the interface between the SDK and the engine;

The SDK creates an SDK management object according to the creation message.
The method for invoking a function module according to claim 1, wherein before the SDK receives the event transmitted from the engine through a preset event interface, the method further comprises:

The SDK receives the initialization message transmitted by the engine through a preset object initialization interface, the initialization message is used to instruct to initialize the SDK management object, the SDK management object is used to manage the objects required to call the function module, the object The initialization interface is the interface between the SDK and the engine;

The SDK initializes the SDK management object according to the initialization message.
The method for invoking a function module according to claim 1, wherein after the SDK invokes the target function module from the function module integrated by the SDK according to the event, the method further comprises:

Acquiring, by the SDK, a target execution result obtained by invoking the target function module;

The SDK transmits the target execution result to the engine through a preset callback interface; the callback interface is an interface between the SDK and the engine, and is used to call each function module of the SDK. The execution result is transmitted to the engine.
The calling method of the function module according to claim 7, wherein:

The event is triggered when the engine receives a call instruction indicating the target function module to be called, and the event also carries an identifier for identifying the call instruction;

The SDK transmits the target execution result to the engine through a preset callback interface, including:

The SDK obtains an identifier from the event;

The SDK carries the identifier in the target execution result and transmits it to the engine through the callback interface.
The calling method of the function module according to claim 1, wherein:

The event carries data related to the event;

When the SDK calls the target function module from the function module integrated by the SDK according to the event, the method further includes:

The SDK inputs the data into the target function module, so that the target function module performs processing according to the data.
The method for calling a function module according to any one of claims 1-9, wherein the language of the SDK supports the operating system of the device, and the SDK supports an operating system different from the operating system of the device .
The method for invoking a function module according to any one of claims 1-9, wherein the language of the SDK is the same as the language of the function module integrated by the SDK.
The method for invoking a function module according to any one of claims 1-9, wherein the SDK integrates a plurality of different function modules.
A method for invoking a functional module, which is characterized in that it is applied to an electronic device on which a cross-platform software development engine and a software development kit SDK are installed;

The method includes:

When a target function module needs to be called, the engine triggers an event, and the event is related to the target function module;

The engine transmits the event to the SDK through a preset event interface. The event interface is an interface between the SDK and the engine, so that the SDK receives the event from the SDK. The target function module is called in the function module integrated by the SDK.
The method for invoking a function module according to claim 13, wherein the event has a type field that records type information to which the event belongs.
The method for invoking a function module according to claim 14, wherein the type field includes a first field and a second field;

The first field records the target total type information to which the event belongs, and the second field records the target subtype information to which the event belongs among all subtype information of the target total type information.
The method for invoking a function module according to claim 13, wherein before the engine triggers an event, the method further comprises:

When the SDK management object needs to be created, the engine transmits a creation message to the SDK through the preset object management interface. The creation message is used to instruct the creation of the SDK management object, and the SDK management object is used to manage the call to the function module. The object management interface is an interface between the SDK and the engine, so that the SDK creates an SDK management object according to the received creation message.
The method for invoking a function module according to claim 13, wherein before the engine triggers an event, the method further comprises:

When the SDK management object needs to be initialized, the engine transmits an initialization message to the SDK through the preset object initialization interface. The initialization message is used to instruct to initialize the SDK management object, and the SDK management object is used to manage the call function module. The object initialization interface is an interface between the SDK and the engine, so that the SDK initializes the SDK management object according to the received initialization message.
The method for invoking a function module according to claim 13, wherein after the engine transmits the event to the SDK through a preset event interface, the method further comprises:

The engine receives the target execution result transmitted from the SDK through a preset callback interface, and the target execution result is the execution result obtained by calling the target function module; the callback interface is the one between the SDK and the engine The inter-interface is used to transmit the execution result obtained by the SDK invoking each function module to the engine.
The method for invoking a function module according to claim 18, wherein before the engine triggers an event, the method further comprises:

The engine receives instructions;

When a call instruction is received, the call instruction is used to indicate the target function module to be called, and the engine determines that the target function module needs to be called.
The method for invoking a function module according to claim 19, wherein the engine transmits the event to the SDK through a preset event interface, comprising:

Determining, by the engine, an identifier for identifying the calling instruction according to the calling instruction;

The engine carries the identifier in the event and transmits it to the SDK through the event interface, so that the SDK carries the identifier in the target execution result and transmits it to the target through the callback interface The engine.
The method for invoking a function module according to claim 19, wherein the instruction carries data related to the event;

The engine transmits the event to the SDK through a preset event interface, including:

The engine obtains the data from the call instruction;

The engine carries the data in the event and transmits it to the SDK through the event interface, so that the SDK inputs the data into the target function module.
The method for invoking a function module according to any one of claims 13-21, wherein the language of the SDK supports the operating system of the device, and the SDK supports an operating system different from the operating system of the device .
The method for invoking a function module according to any one of claims 13-21, wherein the language of the SDK is the same as the language of the function module integrated by the SDK.
The method for invoking a function module according to any one of claims 13-21, wherein the SDK integrates a plurality of different function modules.
An electronic device, characterized in that a cross-platform software development engine and a software development kit SDK are installed on the electronic device;

The device includes: a memory and a processor;

The memory is used to store program code;

The processor is used to call the program code, and when the program code is executed, it is used to perform the following operations:

Use the SDK to receive an event transmitted from the engine through a preset event interface, the event is related to the target function module to be called, and the event interface is an interface between the SDK and the engine;

Use the SDK to call the target function module from the function modules integrated by the SDK according to the event.
The device according to claim 25, wherein the event has a type field for recording type information to which the event belongs;

When the processor uses the SDK to call the target function module from the function module integrated by the SDK according to the event, it is specifically used to:

Parse the type field of the event by using the SDK;

The SDK is used to call the target function module from the function module integrated by the SDK according to the parsed type information.
The device of claim 26, wherein the type field includes a first field and a second field;

The first field records the target total type information to which the event belongs, and the second field records the target subtype information to which the event belongs among all subtype information of the target total type information;

When the processor uses the SDK to call the target function module from the function module integrated with the SDK according to the type information parsed by the SDK, it is specifically used to:

Using the SDK to call the target function module according to the target total type information and target subtype information.
The device of claim 27, wherein:

When the processor uses the SDK to call the target function module according to the target total type information and target subtype information, it is specifically configured to:

Calling the target message processing object corresponding to the target total type information by using the SDK, so as to use the target message processing object to determine the target event processing object corresponding to the target subtype information;

Using the SDK to call the target event processing object, so as to use the target event processing object to determine the functional module corresponding to the target subtype information;

Use the SDK to take the determined function module as the target function module and call the target function module.
The device according to claim 25, wherein, before the processor receives the event transmitted from the engine through the preset event interface by using the SDK, it is further configured to:

Use the SDK to receive a creation message transmitted by the engine through a preset object management interface, the creation message is used to instruct the creation of an SDK management object, and the SDK management object is used to manage objects required for invoking a function module. The object management interface is the interface between the SDK and the engine;

Use the SDK to create an SDK management object according to the creation message.
The device according to claim 25, wherein before the processor uses the SDK to receive the event transmitted from the engine through a preset event interface, it is further configured to:

The SDK is used to receive the initialization message transmitted by the engine through a preset object initialization interface. The initialization message is used to instruct to initialize the SDK management object. The SDK management object is used to manage the objects required to call the function module. The object initialization interface is the interface between the SDK and the engine;

Use the SDK to initialize the SDK management object according to the initialization message.
The device according to claim 25, wherein after the processor uses the SDK to call the target function module from the function module integrated by the SDK according to the event, it is further configured to:

Using the SDK to obtain the target execution result obtained by invoking the target function module;

Use the SDK to transmit the target execution result to the engine through a preset callback interface; the callback interface is the interface between the SDK and the engine, and is used to call the SDK into various functional modules. The execution result of is transmitted to the engine.
The device of claim 31, wherein:

The event is triggered when the engine receives a call instruction indicating the target function module to be called, and the event also carries an identifier for identifying the call instruction;

When the processor uses the SDK to transmit the target execution result to the engine through a preset callback interface, it is specifically used to:

Use the SDK to obtain an identifier from the event;

The SDK is used to carry the identifier in the target execution result and is transmitted to the engine through the callback interface.
The device of claim 25, wherein:

The event carries data related to the event;

When the processor uses the SDK to call the target function module from the function module integrated by the SDK according to the event, it is also used to:

Use the SDK to input the data into the target function module, so that the target function module executes processing according to the data.
The device according to any one of claims 25-33, wherein the language of the SDK supports the operating system of the device, and the SDK supports an operating system different from the operating system of the device.
The device according to any one of claims 25-33, wherein the language of the SDK is the same as the language of the functional module integrated with the SDK.
The device according to any one of claims 25-33, wherein the SDK integrates multiple different functional modules.
An electronic device, characterized in that a cross-platform software development engine and a software development kit SDK are installed on the electronic device;

The device includes: a memory and a processor;

The memory is used to store program code;

The processor is used to call the program code, and when the program code is executed, it is used to perform the following operations:

When a target function module needs to be called, use the engine to trigger an event, and the event is related to the target function module;

Use the engine to transmit the event to the SDK through a preset event interface. The event interface is the interface between the SDK and the engine, so that the SDK receives the event from the The target function module is called from the function module integrated by the SDK.
The device according to claim 37, wherein the event has a type field for recording type information to which the event belongs.
The device of claim 38, wherein the type field includes a first field and a second field;

The first field records the target total type information to which the event belongs, and the second field records the target subtype information to which the event belongs among all subtype information of the target total type information.
The device of claim 37, wherein before the processor uses the engine to trigger an event, it is further configured to:

When an SDK management object needs to be created, the engine is used to transmit a creation message to the SDK through a preset object management interface. The creation message is used to instruct the creation of the SDK management object, and the SDK management object is used to manage and call function modules. A required object, the object management interface is an interface between the SDK and the engine, so that the SDK creates an SDK management object according to the received creation message.
The device of claim 37, wherein before the processor uses the engine to trigger an event, it is further configured to:

When the SDK management object needs to be initialized, the engine is used to transmit an initialization message to the SDK through a preset object initialization interface. The initialization message is used to instruct to initialize the SDK management object, and the SDK management object is used to manage and call function modules. The required object, the object initialization interface is an interface between the SDK and the engine, so that the SDK initializes the SDK management object according to the received initialization message.
The device of claim 37, wherein after the processor uses the engine to transmit the event to the SDK through a preset event interface, it is further used for:

Use the engine to receive the target execution result transmitted from the SDK through the preset callback interface, the target execution result is the execution result obtained by calling the target function module; the callback interface is the SDK and the engine The interface between is used to transmit the execution result obtained by the SDK invoking each function module to the engine.
The device according to claim 42, wherein before the processor uses the engine to trigger an event, it is further configured to:

Use the engine to receive instructions;

When a call instruction is received, the call instruction is used to indicate the target function module to be called, and the engine is used to determine the target function module to be called.
The device according to claim 43, wherein when the processor uses the engine to transmit the event to the SDK through a preset event interface, it is specifically configured to:

Using the engine to determine an identifier for identifying the calling instruction according to the calling instruction;

Use the engine to carry the identifier in the event and transmit it to the SDK through the event interface, so that the SDK carries the identifier in the target execution result and transmits it through the callback interface To the engine.
The device according to claim 43, wherein the instruction carries data related to the event;

When the processor uses the engine to transmit the event to the SDK through a preset event interface, it is specifically used to:

Obtain the data from the call instruction by using the engine;

The engine is used to carry the data in the event and is transmitted to the SDK through the event interface, so that the SDK inputs the data into the target function module.
The device according to any one of claims 37-45, wherein the language of the SDK supports the operating system of the device, and the SDK supports an operating system different from the operating system of the device.
The device according to any one of claims 37-45, wherein the language of the SDK is the same as the language of the functional module integrated with the SDK.
The device according to any one of claims 37-45, wherein the SDK integrates multiple different functional modules.
A computer-readable storage medium, characterized in that:

The computer-readable storage medium stores computer instructions, and when the computer instructions are executed, the method for invoking the functional module of any one of claims 1-24 is realized.