WO2016177341A1

WO2016177341A1 - Interface calling method and device, and terminal

Info

Publication number: WO2016177341A1
Application number: PCT/CN2016/081184
Authority: WO
Inventors: 王哲
Original assignee: 北京金山安全软件有限公司
Priority date: 2015-05-07
Filing date: 2016-05-05
Publication date: 2016-11-10
Also published as: CN104881318B; CN104881318A

Abstract

An interface calling method, an interface calling device and a terminal, which can improve the compatibility of a browser. The method comprises: receiving an interface calling instruction, the interface calling instruction carrying an interface identifier and parameters, corresponding to an interface which needs to be called for loading a client script (S101); when a browser kernel, which is currently operated in a browser, is not a target browser kernel corresponding to the client script, and a first interface function, which is provided by the currently operated browser kernel and corresponds to the interface identifier, is different from a second interface function, which is provided by the target browser kernel and corresponds to the interface identifier, acquiring a pre-set target interface function, which corresponds to the interface identifier, of the currently operated browser kernel (S102); and taking the parameters as input parameters of the target interface function, and calling the target interface function (S103).

Description

Interface calling method, device and terminal

Cross-reference to related applications

The present application is based on the Chinese Patent Application No. 20151022950

Technical field

The present invention relates to the field of computer technologies, and in particular, to an interface calling method, apparatus, and terminal.

Background technique

With the development of Internet technology, the browser has become one of the necessary application software on the mobile terminal. When browsing the webpage through the browser on the mobile terminal, the browser kernel interprets the webpage syntax and renders the webpage. Generally, the browser kernel provides a large number of interfaces, and the client script can call these interfaces. The browser interprets the client scripts loaded in the execution webpage, thereby realizing the dynamic display effect of the webpage and enhancing the interactivity of the webpage.

Currently, most browsers are multi-core browsers, that is, the browser includes at least two browser kernels. However, the interface functions provided between different browser kernels may differ. For example, different browser kernels have different parameters for the interface functions designed by interface A that implement the same function, and the order of parameters is different, or one browser kernel in the browser provides interface B, and another browser kernel. This interface B is not provided. At the same time, since extensions and web pages in existing browsers are developed based on a particular browser kernel, client-side scripts in web pages and extensions are also developed based on that particular browser kernel. Therefore, the client script can run normally on that particular browser kernel. However, if the currently running browser kernel in the browser is not a specific browser kernel corresponding to the client script, and the currently running browser kernel and the specific browser kernel have the above difference for the interface that the client script needs to invoke , webpages or extensions will run incorrectly, resulting in poor browser compatibility.

Summary of the invention

The embodiment of the invention provides an interface calling method, device and terminal, which can improve browser compatibility.

In a first aspect, an embodiment of the present invention provides an interface calling method, including:

Receiving an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script;

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browsing Kernel Obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier when the second interface function corresponding to the interface identifier is different, and the target interface function is according to the target The second interface function provided by the browser kernel performs a preset third interface function corresponding to the currently running browser kernel;

The target interface function is invoked by using the parameter as an input parameter of the target interface function.

In a first possible implementation manner of the first aspect, the client script is a script program included in an extension in the browser;

Before the receiving interface calls the instruction, the method further includes:

When the trigger event of opening the webpage is detected, the client script corresponding to the extension that needs to be loaded in the browser is inserted into the webpage to be opened.

In conjunction with the first possible implementation of the first aspect, in a second possible implementation of the first aspect, the extension further includes a main program loaded in a browser;

The receiving interface calls an instruction, where the interface calling instruction carries an interface identifier and a parameter corresponding to an interface that needs to be invoked by the client script, the method further includes:

Upon receiving the trigger instruction to load the extension, a new process is started to load the main program, and the target browser kernel is loaded in the new process.

In conjunction with the first aspect, in a third possible implementation manner of the first aspect, the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the currently running Obtaining, by the browser kernel, a first interface function corresponding to the interface identifier and a second interface function corresponding to the interface identifier provided by the target browser kernel, obtaining a preset corresponding to the interface identifier The target interface function of the currently running browser kernel includes:

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browsing When there is a difference between the second interface function corresponding to the interface identifier provided by the kernel, the interface identifier is queried from the preset information base according to the interface function of the currently running browser kernel;

Determine the interface function that is queried as the target interface function.

With reference to the first aspect or any one of the foregoing possible implementation manners of the first aspect, in a fourth possible implementation manner of the first aspect, the parameter is used as an input parameter of the target interface function, After the target interface function, the method further includes:

Returns the result of the call to the target interface function.

In a second aspect, an embodiment of the present invention provides an interface calling device, where the device is applied to a browser, including:

a receiving module, configured to receive an interface call instruction, where the interface call instruction carries a load client script that needs to be called Interface identifier and parameters corresponding to the interface;

a determining module, configured to: when the currently running browser kernel in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel Obtaining, by the target browser kernel, a second interface function corresponding to the interface identifier, acquiring a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the target The interface function is a third interface function corresponding to the currently running browser kernel according to the second interface function provided by the target browser kernel;

The calling module is configured to invoke the parameter as the input parameter of the target interface function, and invoke the target interface function.

In a first possible implementation of the second aspect, the client script is a script program included in the extension in the browser, and the device further includes:

The inserting module is configured to insert a client script corresponding to the extension that needs to be loaded in the browser into the webpage to be opened when the triggering event of opening the webpage is detected.

In conjunction with the first possible implementation of the second aspect, in a second possible implementation of the second aspect, the extension further includes a main program loaded in a browser, the device further comprising:

The startup module is configured to start a new process to load the main program when the trigger instruction for loading the extension is received, and the target browser kernel is loaded in the new process.

With reference to the second aspect, in a third possible implementation manner of the second aspect, the determining module is specifically configured to:

With reference to the second aspect, or any one of the foregoing possible implementation manners of the second aspect, in a fourth possible implementation manner of the second aspect, the device further includes:

A return module for returning a result of the call of the target interface function.

In a third aspect, an embodiment of the present invention provides a terminal, including any one of the interface calling devices described above.

The embodiment of the present invention receives an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script; when the currently running browser kernel in the browser is not the client script corresponding to a target browser kernel, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the second interface function provided by the target browser kernel corresponding to the interface identifier are different Obtaining, by the preset interface identifier, a target interface function of the currently running browser kernel; using the parameter as a The input parameter of the target interface function is called, and the target interface function is called. According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the interface with different parts, thereby avoiding the running error of the client script when calling the interface with the difference, and improving the browser. Compatibility.

In a fourth aspect, an embodiment of the present invention provides a terminal, including a processor and a memory that stores instructions executable by the processor. The processor is configured to: receive an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script; when the currently running browser kernel in the browser is not the target corresponding to the client script a browser kernel, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the second interface function provided by the target browser kernel corresponding to the interface identifier are different, Obtaining, by the preset interface identifier, a target interface function of the currently running browser kernel, where the target interface function is preset according to the second interface function provided by the target browser kernel Determining a third interface function corresponding to the currently running browser kernel; using the parameter as an input parameter of the target interface function, calling the target interface function.

In a fifth aspect, an embodiment of the present invention provides a computer readable storage medium having instructions stored therein, and when a processor of a terminal executes the instruction, the terminal executes an interface calling method as described above.

In a sixth aspect, an embodiment of the present invention provides a computer program that, when run on a processor, performs the interface calling method as described above.

DRAWINGS

In order to more clearly illustrate the technical solutions in the embodiments of the present invention, the drawings used in the description of the embodiments will be briefly described below. It is obvious that the drawings in the following description are some embodiments of the present invention, Those skilled in the art can also obtain other drawings based on these drawings without paying any creative work.

1 is a schematic flowchart of an interface calling method according to an embodiment of the present invention;

2 is another schematic flowchart of an interface calling method according to an embodiment of the present invention;

3 is a schematic structural diagram of an interface calling apparatus according to an embodiment of the present invention;

4 is another schematic structural diagram of an interface calling apparatus according to an embodiment of the present invention;

FIG. 5 is a schematic structural diagram of a terminal according to an embodiment of the present disclosure;

FIG. 6 is still another schematic structural diagram of an interface calling apparatus according to an embodiment of the present invention.

detailed description

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. It is apparent that the described embodiments are only a part of the embodiments of the invention, and not all of the embodiments. All other embodiments obtained by those skilled in the art based on the embodiments of the present invention without creative efforts are within the scope of the present invention.

The embodiment of the invention provides an interface calling method, device and terminal, and receives an interface calling instruction, where the interface calling instruction carries an interface identifier and a parameter corresponding to an interface that needs to be invoked by the client script; when the browser is currently running The browser kernel is not the target browser kernel corresponding to the client script, and the interface identifier is determined when the interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browser kernel respectively is different. Corresponding to the target interface function of the currently running browser kernel, the target interface function is a preset interface function; and the parameter is used as an input parameter of the target interface function, and the target interface function is called. According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the partial difference interface, thereby avoiding the running error of the client script when calling the part of the difference interface, and improving the compatibility of the browser. . The interface calling method, device and terminal provided by the embodiment of the present invention are respectively described in detail below with reference to FIG.

Referring to FIG. 1, FIG. 1 is a schematic flowchart of a method for invoking an interface according to an embodiment of the present invention. In the embodiment of the present invention, the method may include the following steps.

S101: Receive an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script.

In the embodiment of the present invention, the method may be used in a browser on a terminal or a browser-like product, and the terminal may be a terminal such as a computer, an IPAD, a mobile phone, or other smart device, specifically, the present invention. The embodiment of the invention is not limited at all.

Generally, in order to enrich the dynamic display effect of the webpage and enhance the interaction between the webpage and the user, the browser provides a large number of standard interfaces to the webpage for the client script to be loaded in the webpage, and the browser interprets and executes the client script. For example, when the browser receives the interface call instruction of the client script, the browser runs the interface function corresponding to the target interface specified by the information according to the information carried by the interface call instruction, thereby implementing the corresponding function. Currently, commonly used browser kernels include: Trident kernel, blink kernel, Gecko kernel, etc. However, interface functions provided between different browser kernels may be different. For convenience of description, this part of the embodiment of the present invention The interface corresponding to the interface function that has the difference is called the difference interface. For example, different browser kernels have different parameter parameters and parameter delivery order for interface function designed for interface A that implements the same function, or a browser kernel provides interface B, and another browser kernel does not provide the same. Interface B. Since extensions and web pages in existing browsers are developed based on a particular browser kernel, client-side scripts in web pages and extensions are also developed based on that particular browser kernel. Therefore, the client script can be normal Runs on that particular browser kernel, and when the browser kernel currently running in the browser is not the specific browser kernel, a runtime error may occur.

In order to improve the efficiency of webpages, browsers are mostly multi-core browsers, that is, browsers include at least two browser kernels. For convenience of description, the embodiment of the present invention takes a dual-core browser as an example. Of course, the present invention can be applied to any browser, such as a single-core browser, a multi-core browser, and specifically, the embodiment of the present invention is not limited. In the process of loading the webpage, the interface call instruction is received, and the interface call instruction carries an interface identifier and a parameter corresponding to the interface that the client script needs to invoke. The interface identifier may be an interface name or an identifier that is unique to the interface name. Specifically, the embodiment of the present invention does not limit the present invention.

S102: The browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the And obtaining, by the target browser, a second interface function corresponding to the interface identifier, acquiring a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the target interface function is Presetting a third interface function corresponding to the currently running browser kernel according to the second interface function provided by the target browser kernel.

In the embodiment of the present invention, according to the difference in interface functions provided by different browser kernels for some interfaces in the browser, an interface function for replacing the difference interface is preset. For convenience of explanation, it is assumed that the browser is a dual-core browser, which is a Trident kernel and a blink kernel respectively. It can be seen that in the interfaces provided by the Trident kernel and the blink kernel respectively, for the interface that implements the same function, if the Trident kernel and the blink kernel are directed to the interface, The calling interface of the provided interface function is the same, regardless of whether the currently running browser kernel is the target browser kernel corresponding to the client script, the browser can normally run the client script to call the interface request. If the interface provided by the Trident kernel and the blink kernel differs as follows: the Trident kernel and the blink kernel have different calling specifications for the interface functions provided by the same function (such as the interface name, the number of parameters, the order of delivery, etc.), or A kernel provides an interface to implement a function, and another core does not provide an interface to implement the function. In these cases, if the client script calls this part of the difference interface, a running error will occur.

The embodiment of the present invention provides an interface calling method for the defect in the existing method, even if the browser kernel currently running in the browser and the browser kernel corresponding to the client script respectively provide an interface for the interface to be called by the client script. There is a difference in the function, and the client script can still be loaded normally, thereby improving browser compatibility. For convenience of explanation, it is assumed that the browser is a dual-core browser, which is a Trident kernel and a blink kernel respectively. The target browser kernel corresponding to the client script is a blink kernel, and the currently running browser kernel is a Trident kernel, respectively, in the blink kernel and the Trident kernel. Among all the interfaces provided, there is one difference interface, which is represented by interface A.

As an example, assume that the interface function provided by the blink kernel for interface A is InterfaceA, within Trident. The interface function provided by the core for interface A is TridentInterfaceA, then the code for calling interface A (see InterfaceA in code 1) in the client script can be as shown in code 1, and the calling specification of the interface function provided by Trident kernel for interface A can be as Code 2 is shown.

Code 1:

//blink client script

Function blinkExtensionFunction()

{

....//function code

/ / Call the blink interface, function InterfaceA (count, url)

/ / This interface accepts two parameters, the first parameter is the number of times, the second parameter is the URL

chrome.InterfaceA(100,"http://www.liebao.cn");

....//function code

}

Code 2:

//The interface of the same function of the Trident kernel

/ / This interface accepts three parameters, the first parameter is the URL, the second parameter is the number of times, the third parameter is the current time

Function TridentInterfaceA(url,count,date);

It can be known in advance from code 1 and code 2 that there is a difference between the interface function provided by the blink kernel and the Trident kernel for interface A. The interface function InterfaceA provided by the blink kernel receives two parameters, the first parameter represents the number of times, and the second parameter represents The interface function TridentInterfaceA provided by the Trident kernel receives 3 parameters, the first parameter represents the URL, the second parameter represents the number of times, and the third parameter represents the current time. Therefore, if the target browser kernel calls the interface provided by the Trident kernel for the client script of the blink kernel in accordance with the call specification provided by the blink kernel, a runtime error will occur. In the embodiment of the present invention, for the same interface, when the calling specifications of the interface functions provided by different browser kernels are inconsistent, the interface function for replacement is preset. Specifically, according to the interface function provided by one of the browser kernels, a replacement function of another browser kernel is set. For example, for the interface function TridentInterfaceA provided by the Trident kernel, a replacement interface function FakeInterfaceA is preset, wherein the interface function FakeInterfaceA for replacement can be a rewritten interface function, or can be obtained by processing the existing interface function TridentInterfaceA. Interface function. Specifically, the embodiment of the present invention is not limited according to the actual needs. As an example, the interface function FakeInterfaceA can be as shown in code 3.

Code 3

/ / Script middle layer, the interface is converted

//chrome is a predefined global object

chrome.FakeInterfaceA=function(count,url)

{

...//Auxiliary code

//where Date() means to get the current time

/ / Here call the interface of the Trident kernel

Var result=TridentInterfaceA(url,count,Date());

...//Auxiliary code

Return result;

}

Therefore, when the browser loads the client script, if the client script needs to call interface A, the target browser kernel corresponding to the client script is the blink kernel, and the currently running browser kernel is the Trident kernel, then the preset interface is run. The function FakeInterfaceA.

As another example, assume that the interface function provided by the blink kernel for interface A is InterfaceA, and the Trident kernel does not provide interface A. That is, the Trident kernel does not provide an interface function that implements the function corresponding to interface A, and the client script calls interface A (see The code for InterfaceA in Code 1 can be as shown in Code 1. In the embodiment of the present invention, if a browser kernel provides the interface for an interface, that is, the kernel provides an interface function that implements the function corresponding to the interface; and another browser kernel does not provide the interface function, according to the above The kernel provides an interface function for realizing the function corresponding to the interface, and a target interface function is preset for another browser kernel, and the function required to be implemented by the target interface function and the interface function provided by the kernel to implement the function corresponding to the interface need to be implemented. The functions are the same and the calling specifications are the same. In a specific implementation, the target interface function may be a combination of existing interface functions (for example, as shown in code 4), or may be a rewritten interface function (for example, as shown in code 5), specifically, according to the actual The case is selected, and the embodiment of the present invention is not limited. As an example, suppose the target interface function FakeInterfaceB can realize the functions that the interface function InterfaceA needs to implement by combining the existing interface functions (TridentInterfaceB1, TridentInterfaceB2 and TridentInterfaceB3) in the Trident kernel. By combining these interfaces, you can implement and link The kernel provides the same functionality as interface A. For example: the target interface function FakeInterfaceB can be as shown in code 4.

Code 4:

//chrome is a predefined global object

chrome.FakeInterfaceB=function(count,url){

Var result;

...//Auxiliary code

/ / Combine the Trident interface to achieve the same function

/ / The following combination is only an example, the actual situation is changeable.

Result=TridentInterfaceB1(count);

...//Auxiliary code

Result=TridentInterfaceB2(url);

...//Auxiliary code

Result=TridentInterfaceB3();

...//Auxiliary code

Return result;

}

Therefore, when the browser loads the client script, if the client script needs to call interface A, the target browser kernel corresponding to the client script is the blink kernel, and the currently running browser kernel is the Trident kernel, then the preset interface is run. The function FakeInterfaceB.

As another example, if it is not possible to implement the functions that interface A needs to implement by combining the existing interface functions in the Trident kernel, an interface function TridentInterfaceC that implements this function is set in advance for the Trident kernel. Thus, the preset target interface function FakeInterfaceC can be as shown in code 5.

Code 5

//chrome is a predefined global object

chrome.FakeInterfaceC=function(count,url){

...//Auxiliary code

/ / Here to call the interface added by the invention for the Trident kernel

Var result=TridentInterfaceC(url,count);

...//Auxiliary code

Return result;

}

Therefore, when the browser loads the client script, if the client script needs to call interface A, the target browser kernel corresponding to the client script is the blink kernel, and the currently running browser kernel is the Trident kernel, then the preset target is run. The interface function FakeInterfaceC.

S103: Call the parameter as an input parameter of the target interface function, and invoke the target interface function.

After the target interface function is determined in step S102, the parameter carried in the interface call instruction is used as an input parameter of the target interface function, and the target interface function is called. In other words, the parameters carried in the interface call instruction are substituted into the target interface function, and the target interface function is executed or executed. Thus, the compatibility of the browser is improved by pre-normalizing the interfaces provided by different browser kernels.

In the interface calling method described in the embodiment of the present invention, an interface call instruction is received, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script; when the browser kernel currently running in the browser is not a target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the interface identifier corresponding to the interface identifier provided by the target browser kernel When the second interface function is different, obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier; using the parameter as an input parameter of the target interface function, calling the target interface function. According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the partial difference interface, thereby avoiding the running error of the client script when calling the part of the difference interface, and improving the compatibility of the browser. .

Referring to FIG. 2, FIG. 2 is another schematic flowchart of an interface calling method according to an embodiment of the present invention. In the embodiment of the present invention, the method may include the following steps.

S201: Upon receiving the trigger instruction for loading the extension, start a new process to load the main program, and the target browser kernel is loaded in the new process.

Because the browser kernel provides a powerful interface, developers can develop a variety of extensions based on these interfaces, such as: automatic proxy, password safe, ad filtering and other plug-ins, these extensions can not only achieve new features, but also You can also change how the current page is displayed. Typically, extensions include a main program loaded in a browser and/or a script loaded in a web page. In the implementation, the extension is associated with the browser kernel. For example, extensions developed based on the blink kernel can only run normally in the blink kernel. Extensions developed based on the Firefox kernel can only run normally in the Firefox kernel. Therefore, in a multi-core browser, if an extension based on the blink kernel is installed, the plugin can only run normally on web pages opened based on the blink kernel, but in web pages that are not opened based on the blink kernel (such as the Trident kernel). A runtime error may occur during runtime.

Generally, the browser includes at least the main process during the running process. Of course, the rendering process may also include a rendering process. If the rendering process is included, the rendering of the webpage content is performed in the rendering process. If the rendering process is not included, the rendering of the webpage content is performed. Work is done in the main process. In the embodiment of the present invention, if the extension plug-in includes a main program loaded in the browser, when receiving the trigger instruction for loading the extension, a new process is started to load the main program, and the new process is loaded with the Target browser kernel.

For example, suppose the browser is a dual-core browser, which is the Trident kernel and the blink kernel respectively. The target browser kernel corresponding to the extension is the Trident kernel, and the extension can be automatically loaded when the browser is started, or the browser can be successfully started. Manually load the extension. When the browser receives the trigger instruction to load the extension, it automatically creates a new page, launches a rendering process loaded with the Trident kernel for the page, and runs the main program corresponding to the extension in the rendering process. Thus, regardless of whether the browser kernel currently running by the browser is the target browser kernel corresponding to the main program in the extension, the main program can run normally in the browser.

S202: When detecting a trigger event of opening a webpage, insert a client script corresponding to the extension that needs to be loaded in the browser into the webpage to be opened.

If the extension includes a script loaded in a webpage, when the extension is loaded in the browser, the script corresponding to the extension needs to be inserted into the opened webpage, thereby loading the extension by loading the webpage. The corresponding script program. In the embodiment of the present invention, when a trigger event of opening a webpage is detected (for example, the triggering time may be a triggering event of starting a browser or creating a new tab, etc.), the client script corresponding to the extension that needs to be loaded in the browser is used. Insert the webpage to be opened.

For example: Suppose the extension is a plugin with translation capabilities, the plugin includes the main program loaded in the browser and the script loaded in the web page. Upon receiving the trigger instruction to load the extension, a new process is started to load the main program, wherein the target browser core corresponding to the extension is loaded in the new process. And when the trigger event of opening the webpage is detected, the client script corresponding to the extension is inserted into the webpage to be opened. Therefore, the text message that needs to be translated on the webpage is obtained by the client script loaded in the webpage, and the obtained text information is sent as an interface parameter to be called to the main program loaded in the browser, and the main program is transmitted through the network. The server obtains the translation information of the text information, and finally displays the obtained translation information to the webpage.

S203: Receive an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script.

In the process of loading the webpage, the interface call instruction is received, and the interface call instruction carries an interface identifier and a parameter corresponding to the interface that the client script needs to invoke. The interface identifier may be an interface name or an identifier that is unique to the interface name. Specifically, the embodiment of the present invention does not limit the present invention.

S204: The browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the When there is a difference between the second interface function corresponding to the interface identifier provided by the target browser kernel, the interface identifier corresponding to the interface function of the currently running browser kernel is queried from the preset information base according to the interface identifier.

In an implementation manner, according to different browser APIs in the browser, the interface functions provided by the interface are different, and an interface function for replacing the interfaces with different differences is preset, and the preset interface functions and pairs are set. The interface identifier should be saved in the preset information base. Therefore, according to the interface identifier carried by the interface call instruction, it can be known whether there is a difference in the interface function provided by the interface to be called in different browser kernels. When receiving the interface call instruction, obtain the type of the browser kernel currently running in the browser. For convenience of description, the browser kernel currently running in the browser is referred to as the first browser kernel; according to the target corresponding to the client script The type of the browser kernel, identifying whether the type of the first browser kernel is consistent with the type of the target browser kernel; if not, the interface identifier carried by the interface call instruction identifies that the interface to be called is provided in the first browser kernel Whether the interface function is different from the interface function provided in the target browser kernel; if yes, querying, according to the interface identifier, the interface identifier corresponding to the interface function of the currently running browser kernel from the preset information base.

S205: Determine the interface function that is queried as a target interface function.

S206: Call the parameter as an input parameter of the target interface function, and invoke the target interface function.

After the target interface function is determined in step S205, the parameter carried in the interface call instruction is used as an input parameter of the target interface function, and the target interface function is called. In other words, the parameters carried in the interface call instruction are substituted into the target interface function, and the target interface function is executed or executed. Thus, the compatibility of the browser is improved by pre-normalizing the interfaces provided by different browser kernels.

S207: Return a result of calling the target interface function.

Obtaining an output parameter after calling the target interface function, and using the output parameter as a result of the call, returning a result of the calling of the target interface function to the client script, so that the client script continues to perform the subsequent operation by using the calling result.

The following is an embodiment of the device of the present invention. The device embodiment of the present invention is the same as the method embodiment of the present invention, and is used to perform the method described in the method embodiment of the present invention. For ease of description, the device embodiment of the present invention only shows a part related to the device embodiment of the present invention. If the specific technical details are not disclosed, please refer to the description of the method embodiment of the present invention. One by one.

Referring to FIG. 3, FIG. 3 is a schematic structural diagram of an interface invoking device according to an embodiment of the present invention. In the embodiment of the present invention, the device may be applied to a browser, including: a receiving module 101, a determining module 102, and a call. Module 103.

The receiving module 101 is configured to receive an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script.

The determining module 102 is configured to: when the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface corresponding to the interface identifier provided by the currently running browser kernel And obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the function and the second interface function corresponding to the interface identifier provided by the target browser kernel are different, The target interface function is a third interface function corresponding to the currently running browser kernel according to the second interface function provided by the target browser kernel.

The calling module 103 is configured to invoke the parameter as the input parameter of the target interface function, and invoke the target interface function.

In the interface calling device described in the embodiment of the present invention, an interface call instruction is received, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script; when the browser kernel currently running in the browser is not Determining, according to the target browser kernel corresponding to the client script, the interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browser kernel respectively The target interface function of the currently running browser kernel, the target interface function is a preset interface function; the parameter is used as an input parameter of the target interface function, and the target interface function is called. According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the partial difference interface, thereby avoiding the running error of the client script when calling the part of the difference interface, and improving the compatibility of the browser. .

Referring to FIG. 4, FIG. 4 is another schematic structural diagram of an interface invoking device according to an embodiment of the present invention. In the embodiment of the present invention, the device may include: a receiving module 201, a determining module 202, a calling module 203, and an insertion. Module 204, startup module 205, and return module 206.

The receiving module 201 is configured to receive an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that needs to be invoked by the client script.

The determining module 202 is configured to: when the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface corresponding to the interface identifier provided by the currently running browser kernel Function and Obtaining, by the target browser kernel, a second interface function corresponding to the interface identifier, acquiring a target interface function of the currently running browser kernel corresponding to the preset interface identifier, the target interface function Presetting a third interface function corresponding to the currently running browser kernel according to the second interface function provided by the target browser kernel.

The calling module 203 is configured to invoke the parameter as an input parameter of the target interface function, and invoke the target interface function.

In an embodiment, the client script is a script program included in the extension in the browser, and the module 204 is configured to: when the trigger event of opening the webpage is detected, the browser needs to be loaded. The client script corresponding to the extension plugin is inserted into the webpage to be opened.

In an embodiment, the extension further includes a main program loaded in the browser, and the startup module 205 is configured to start a new process to load the main program when receiving a trigger instruction for loading the extension. The target browser kernel is loaded in the new process.

The returning module 206 is configured to return a result of the calling of the target interface function.

In an embodiment, the determining module 202 is specifically configured to:

In the interface calling device described in the embodiment of the present invention, an interface call instruction is received, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script; when the browser kernel currently running in the browser is not a target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the interface identifier corresponding to the interface identifier provided by the target browser kernel When the second interface function is different, obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier; using the parameter as an input parameter of the target interface function, calling the target interface function. According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the partial difference interface, thereby avoiding the running error of the client script when calling the part of the difference interface, and improving the compatibility of the browser. .

Referring to FIG. 5, FIG. 5 is a schematic structural diagram of a terminal according to an embodiment of the present invention. Terminal 10 includes an interface calling device as described above. In the embodiment of the present invention, the terminal may include: a smart phone, a computer, a tablet computer, a notebook computer, a palmtop computer, and a terminal device such as a mobile Internet device (MID) or a PAD. Specifically, the embodiment of the present invention is not limited.

It is to be noted that the terminal 10 includes any interface calling device as described above, and the terminal receives an interface calling instruction, where the interface calling instruction carries an interface identifier and a parameter corresponding to an interface that needs to be invoked by the client script; The browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier and the target browser kernel provided by the currently running browser kernel are provided. Obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier when the second interface function corresponding to the interface identifier is different; using the parameter as the target interface function The input parameter, the target interface function is called. According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the partial difference interface, thereby avoiding the running error of the client script when calling the part of the difference interface, and improving the compatibility of the browser. .

Referring to FIG. 6, FIG. 6 is another schematic structural diagram of an interface calling apparatus according to an embodiment of the present invention, for performing an interface calling method disclosed in an embodiment of the present invention, where the apparatus may include: at least one processor 301, for example, The CPU, at least one network interface 304 or other user interface 303, memory 305, at least one communication bus 302. Communication bus 302 is used to implement connection communication between these components. The user interface 303 can optionally include a USB interface and other standard interfaces and wired interfaces. Network interface 304 may optionally include a Wi-Fi interface as well as other wireless interfaces. The memory 305 may include a high speed RAM memory and may also include a non-volatile memory such as at least one disk memory. The memory 305 can optionally include at least one storage device located remotely from the aforementioned processor 301. As shown in FIG. 6, an operating system 3051 and an application 3052 may be included in the memory 305 as a computer storage medium.

In some implementations, the memory 305 stores the following elements, executable modules or data structures, or a subset thereof, or their extension set:

An operating system 3051, including various system programs for implementing various basic services and processing hardware-based tasks;

The application 3052 includes various setting programs of a data block parameter setting program of the target network data, a partitioning program of the target data block, a comparison program of the target data block and the data block in the database, and a deletion program of the target data block, and the like. To achieve a variety of application services.

Specifically, the processor 301 is configured to invoke a program stored in the memory 305 to perform the following operations:

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browsing Obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the second interface function corresponding to the interface identifier is different, and the target interface function is The second interface function provided by the target browser kernel performs a preset third interface function corresponding to the currently running browser kernel;

In another embodiment, the client script is a script program included in an extension in the browser, and the processor 301 executes the receiving interface call instruction, where the interface call instruction carries a load client script. Before performing the operation of the interface identifier and parameters corresponding to the interface to be invoked, the following operations are also performed:

In another embodiment, the extension further includes a main program loaded in a browser, and the processor 301 executes the receiving interface calling instruction, where the interface calling instruction carries an interface corresponding to the calling client script to be called. Before the operation of the interface identifier and parameters, the following operations are also performed:

In another embodiment, the processor 301 performs: when the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the currently running browser kernel provides the same When the first interface function corresponding to the interface identifier is different from the second interface function corresponding to the interface identifier provided by the target browser kernel, the currently running browser corresponding to the preset interface identifier is obtained. The operation of the kernel's target interface function, including the following:

In another embodiment, the processor 301 performs the input parameter that uses the parameter as the target interface function. After the operation of the target interface function is invoked, the method further includes:

Returns the result of the call to the target interface function.

In the technical solution described in the embodiment of the present invention, an interface call instruction is received, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script; when the browser kernel currently running in the browser is not a target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the first interface corresponding to the interface identifier provided by the target browser kernel When there is a difference between the two interface functions, obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier; using the parameter as an input parameter of the target interface function, calling the target interface function . According to the embodiment of the present invention, according to different browser kernels in the browser, the interface functions provided by some interfaces are different, and the interface functions that can be replaced are preset, so that whether the currently running browser kernel is a client or not The target browser kernel corresponding to the script, the browser can normally execute the client script to call the request of the partial difference interface, thereby avoiding the running error of the client script when calling the part of the difference interface, and improving the compatibility of the browser. .

In the description of the present specification, the description with reference to the terms "one embodiment", "some embodiments", "example", "specific example", or "some examples" and the like means a specific feature described in connection with the embodiment or example. A structure, material or feature is included in at least one embodiment or example of the invention. In the present specification, the schematic representation of the above terms does not necessarily have to be for the same embodiment or example. Furthermore, the particular features, structures, materials, or characteristics described may be combined in a suitable manner in any one or more embodiments or examples. In addition, various embodiments or examples described in the specification, as well as features of various embodiments or examples, may be combined and combined.

Those skilled in the art can combine and combine the different embodiments described in the specification and the features of the different embodiments. The modules or units in all the embodiments of the present invention may be implemented by a general-purpose integrated circuit, such as a CPU (Central Processing Unit) or an ASIC (Application Specific Integrated Circuit).

The steps in the method of all the embodiments of the present invention may be sequentially adjusted, combined, and deleted according to actual needs; the modules or units in all the embodiments of the present invention may be combined, divided, and deleted according to actual needs.

Any process or method description in the flowcharts or otherwise described herein may be understood to represent a module, segment or portion of code that includes one or more executable instructions for implementing the steps of a particular logical function or process. And the scope of the preferred embodiments of the invention includes additional implementations, in which the functions may be performed in a substantially simultaneous manner or in an opposite order depending on the functions involved, in the order shown or discussed. It will be understood by those skilled in the art to which the embodiments of the present invention pertain.

The logic and/or steps represented in the flowchart or otherwise described herein, for example, may be considered as an ordered list of executable instructions for implementing logical functions, and may be embodied in any computer readable medium, For instruction A system, apparatus, or device (such as a computer-based system, a system including a processor, or other system that can fetch instructions and execute instructions from an instruction execution system, apparatus, or device), or in conjunction with such instructions to execute a system, apparatus, or device. use. For the purposes of this specification, a "computer-readable medium" can be any apparatus that can contain, store, communicate, propagate, or transport a program for use in an instruction execution system, apparatus, or device, or in conjunction with the instruction execution system, apparatus, or device. More specific examples (non-exhaustive list) of computer readable media include the following: electrical connections (electronic devices) having one or more wires, portable computer disk cartridges (magnetic devices), random access memory (RAM), Read only memory (ROM), erasable editable read only memory (EPROM or flash memory), fiber optic devices, and portable compact disk read only memory (CDROM). In addition, the computer readable medium may even be a paper or other suitable medium on which the program can be printed, as it may be optically scanned, for example by paper or other medium, followed by editing, interpretation or, if appropriate, other suitable The method is processed to obtain the program electronically and then stored in computer memory.

One of ordinary skill in the art can understand that all or part of the steps carried by the method of implementing the above embodiments can be completed by a program to instruct related hardware, and the program can be stored in a computer readable storage medium. When executed, one or a combination of the steps of the method embodiments is included.

In addition, each functional unit in each embodiment of the present invention may be integrated into one processing module, or each unit may exist physically separately, or two or more units may be integrated into one module. The above integrated modules can be implemented in the form of hardware or in the form of software functional modules. The integrated modules, if implemented in the form of software functional modules and sold or used as stand-alone products, may also be stored in a computer readable storage medium.

The above mentioned storage medium may be a read only memory, a magnetic disk or an optical disk or the like. Although the embodiments of the present invention have been shown and described, it is understood that the above-described embodiments are illustrative and are not to be construed as limiting the scope of the invention. The embodiments are subject to variations, modifications, substitutions and variations.

The above is only the preferred embodiment of the present invention, and the scope of the present invention is not limited thereto, and those skilled in the art can understand all or part of the process of implementing the above embodiments, and according to the claims of the present invention. Equivalent changes made are still within the scope of the invention.

Claims

An interface calling method, comprising:

Receiving an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script;

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browsing Obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the second interface function corresponding to the interface identifier is different, and the target interface function is The second interface function provided by the target browser kernel performs a preset third interface function corresponding to the currently running browser kernel;

The target interface function is invoked by using the parameter as an input parameter of the target interface function.
The method of claim 1, wherein the client script is a script program included in an extension in the browser;

Before the receiving interface calls the instruction, the method further includes:

When the trigger event of opening the webpage is detected, the client script corresponding to the extension that needs to be loaded in the browser is inserted into the webpage to be opened.
The method of claim 2, wherein the extension further comprises a main program loaded in a browser;

Before the receiving interface calls the instruction, the method further includes:

Upon receiving the trigger instruction to load the extension, a new process is started to load the main program, and the target browser kernel is loaded in the new process.
The method according to any one of claims 1 to 3, wherein the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the currently running browser Obtaining, by the browser kernel, a first interface function corresponding to the interface identifier and a second interface function corresponding to the interface identifier provided by the target browser kernel, obtaining a preset corresponding to the interface identifier The target interface function of the currently running browser kernel includes:

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browsing Kernel When the second interface function corresponding to the interface identifier is different, querying, according to the interface identifier, the interface identifier corresponding to the interface function of the currently running browser kernel from the preset information base;

Determine the interface function that is queried as the target interface function.
The method according to any one of claims 1-4, wherein the method further comprises: after the parameter is used as an input parameter of the target interface function, after the target interface function is invoked, the method further comprises:

Returns the result of the call to the target interface function.
An interface calling device, the device being applied to a browser, comprising:

a receiving module, configured to receive an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script;

a determining module, configured to: when the currently running browser kernel in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel Obtaining, by the target browser kernel, a second interface function corresponding to the interface identifier, acquiring a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the target The interface function is a third interface function corresponding to the currently running browser kernel according to the second interface function provided by the target browser kernel;

The calling module is configured to invoke the parameter as the input parameter of the target interface function, and invoke the target interface function.
The device according to claim 6, wherein the client script is a script program included in the extension in the browser, the device further comprising:

The inserting module is configured to insert a client script corresponding to the extension that needs to be loaded in the browser into the webpage to be opened when the triggering event of opening the webpage is detected.
The device of claim 7, wherein the extension further comprises a main program loaded in a browser, the device further comprising:

The startup module is configured to start a new process to load the main program when the trigger instruction for loading the extension is received, and the target browser kernel is loaded in the new process.
The device according to any one of claims 6 to 8, wherein the determining module is specifically configured to:

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the When the first interface function corresponding to the interface identifier provided by the currently running browser kernel is different from the second interface function provided by the target browser kernel and corresponding to the interface identifier, according to the interface identifier, Querying, in the preset information base, the interface identifier corresponding to the interface function of the currently running browser kernel;

Determine the interface function that is queried as the target interface function.
The device of any of claims 6-9, wherein the device further comprises:

A return module for returning a result of the call of the target interface function.
A terminal characterized by comprising the interface calling device according to any one of claims 6-10.
A terminal comprising:

processor;

a memory for storing instructions executable by the processor;

The processor is used to:

Receiving an interface call instruction, where the interface call instruction carries an interface identifier and a parameter corresponding to an interface that is required to be loaded by the client script;

When the browser kernel currently running in the browser is not the target browser kernel corresponding to the client script, and the first interface function corresponding to the interface identifier provided by the currently running browser kernel and the target browsing Obtaining a target interface function of the currently running browser kernel corresponding to the preset interface identifier, where the second interface function corresponding to the interface identifier is different, and the target interface function is The second interface function provided by the target browser kernel performs a preset third interface function corresponding to the currently running browser kernel;

The target interface function is invoked by using the parameter as an input parameter of the target interface function.
A computer readable storage medium having instructions stored therein, the terminal executing the interface calling method of any one of claims 1-5 when the processor of the terminal executes the instructions.
A computer program that, when run on a processor, performs the interface invocation method of any one of claims 1-5.