WO2018001041A1 - Interface implementation method and device, set-top box, and storage medium - Google Patents

Abstract

Provided are an interface implementation method and device, a set-top box, and a storage medium. The method comprises: receiving a plugin invoking request for invoking a browser plugin; determining a target interface to be executed according to the plugin invoking request; executing the target interface and returning an execution result; and taking the execution result as a plugin invoking result, and displaying same. Provided is a new interface implementation method, according to the method, a JS interface is taken as a browser plugin, and the corresponding JS interface function is realized by invoking the browser plugin. Compared with the related technology, the invention makes great progress, achieves a relatively significant effect, saves the workload of developing a JS expansion interface and the memory taken up by running a browser running, improves the working efficiency of a developer and the browser running speed, etc., solves the problem that a browser extension JS interface needs to recompile the browser code, and enhances the usage experience of a user.

Description

Interface implementation method, device, set top box and storage medium Technical field

The present disclosure relates to the field of set top box applications, and in particular, to an interface implementation method, apparatus, set top box, and storage medium.

Background technique

In set-top boxes, operators have proposed more telecommunications interfaces, such as JS (JavaScript) expansion interfaces, to meet the actual business needs of set-top boxes, such as authentication, configuration file reading, and video playback.

There are two types of related browser extension JS interface implementation technologies:

1) Generate the code files required for the JS extension object according to the IDL interface language standard and the corresponding script file. Each time you add a new interface, you need to repeat the process and recompile the browser code;

2) Define the JS extension interface object file according to the specified format, and recompile the browser code;

When adding JS objects in the above two ways, the file format requirements are strict, the development process of implementing the JS interface is cumbersome, error-prone, and when the JS interface is added, the browser code needs to be recompiled, and the development cycle is long.

Summary of the invention

The embodiments of the present disclosure provide an interface implementation method, apparatus, set top box, and storage medium to solve the problem that the related browser extension JS interface needs to recompile the browser code.

In one aspect, an interface implementation method for a set top box is provided, including:

Receiving a plugin call request that invokes a browser plugin;

Determine the target interface to be executed according to the plugin call request;

Execute the target interface and return the execution result;

The result of the execution is called as a result of the plugin and is displayed.

In one aspect, an interface implementation apparatus for a set top box is provided, including:

a receiving module, configured to receive a plugin call request that invokes a browser plugin;

The execution module is configured to determine a target interface to be executed according to the plugin call request, execute the target interface, and return an execution result;

The presentation module is set to display the execution result as a result of the plugin call and display it.

In one aspect, a set top box is provided, including an interface implementing apparatus provided by an embodiment of the present disclosure.

In another aspect, a storage medium is provided having stored therein computer executable instructions for performing the aforementioned interface implementation method.

Advantageous effects of embodiments of the present disclosure:

An embodiment of the present disclosure provides an interface implementation method. When working, receiving a plug-in call request that invokes a browser plug-in, determining a target interface to be executed according to a plug-in call request, executing a target interface, returning an execution result, and using the execution result as a result The plug-in invokes the result and displays it; that is, the embodiment of the present disclosure provides a new interface implementation manner, which uses the JS interface as a browser plug-in, and implements a corresponding JS interface function by calling a browser plug-in, so that even if a new addition is made The JS interface does not need to recompile the browser. Compared with related technologies, it has achieved great progress and obvious effects, saving the development workload of the JS extension interface, and the browser running memory, which improves the developer's work efficiency. And the browser running speed, etc., solves the problem that the relevant browser extension JS interface needs to recompile the browser code, and enhances the user experience.

DRAWINGS

FIG. 1 is a flowchart of a method for implementing an interface according to a first embodiment of the present disclosure;

2 is a schematic structural diagram of an interface implementation apparatus according to a second embodiment of the present disclosure;

3 is a schematic structural diagram of an interface implementation apparatus according to a third embodiment of the present disclosure;

4 is a flowchart of an interface compiling method according to a third embodiment of the present disclosure;

FIG. 5 is a flowchart of an interface calling method according to a third embodiment of the present disclosure.

detailed description

The technical solutions in the embodiments of the present disclosure are clearly and completely described in the following with reference to the accompanying drawings in the embodiments of the present disclosure. It is obvious that the described embodiments are only a part of the embodiments of the present disclosure, and not all of the embodiments. All other embodiments obtained by a person of ordinary skill in the art based on the embodiments of the present disclosure without departing from the inventive scope are the scope of the disclosure.

The disclosure will now be explained by way of specific embodiments in conjunction with the accompanying drawings.

Embodiment 1:

1 is a flowchart of a method for implementing an interface according to a first embodiment of the present disclosure. As shown in FIG. 1, the interface implementation method provided in this embodiment includes:

S101: Receive a plug-in call request that invokes a browser plug-in;

S102: Determine, according to the plugin call request, a target interface that needs to be executed;

S103: execute a target interface, and return an execution result;

S104: The execution result is used as a plug-in call result and is displayed.

In some embodiments, the execution target interface in the above embodiment returns the execution result including:

Detect whether the current memory is the target interface according to the object name of the target interface;

If the target interface is already loaded in the memory, the related methods and attributes of the calling target interface are executed, and the execution result is returned.

In some embodiments, the execution target interface in the above embodiment returns the execution result further includes:

If the target interface is not loaded in the memory, the interface file of the target interface is searched according to the object name of the target interface;

Load the found interface file into memory;

Parsing the interface file into an executable file that can be recognized by the browser by parsing the syntax;

Execute the executable file and return the execution result.

In some embodiments, the interface implementation method in the foregoing embodiment further includes:

Set the rules file for the browser plugin;

According to the rule file, the interface to be plugged in converts the corresponding interface file.

In some embodiments, the rule file in the above embodiment includes an object name, an attribute name, a method name, a parameter name definition rule, and an access authority control of the attribute method of the interface.

Embodiment 2:

2 is a schematic structural diagram of an interface implementation apparatus according to a second embodiment of the present disclosure. As shown in FIG. 2, the interface implementation apparatus provided in this embodiment includes:

The receiving module 21 is configured to receive a plug-in call request that invokes a browser plug-in;

The execution module 22 is configured to determine, according to the plug-in call request, a target interface that needs to be executed, execute the target interface, and return an execution result;

The presentation module 23 is arranged to display the execution result as a result of the plugin call and display it.

In some embodiments, the execution module 22 in the above embodiment is configured to detect whether the current memory is a target interface according to the object name of the target interface, and if the memory has already loaded the target interface, execute the related method and attribute of calling the target interface, and return Results of the.

In some embodiments, the execution module 22 in the above embodiment is configured to: if the memory does not load the target interface, search for the interface file of the target interface according to the object name of the target interface, and load the found interface file into the memory, The parsing syntax parses the interface file into an executable file that can be recognized by the browser, executes the executable file, and returns the execution result.

In some embodiments, the interface implementation apparatus in the foregoing embodiment further includes a writing module 24 configured to set a rule file of the browser plug-in, and convert the corresponding interface file according to the rule file, the interface to be plugged.

In practical applications, the functional modules involved in the above embodiments may be burned by specific software. The program's editable logic device implementation can be implemented by the processor and memory.

Correspondingly, in some embodiments, a set top box is provided, which includes the interface implementing apparatus provided by the embodiment of the present disclosure.

The present disclosure will be explained in conjunction with specific application scenarios.

This embodiment describes the telecom specification interface as a calling object, and provides a problem and a defect for overcoming the long development cycle of the JS object extension in the related art, the large amount of development work, and the high coupling degree between the JS interface and the browser. Based on the Blink browser kernel, a method, device and storage medium for implementing a telecom specification interface as a browser plug-in are provided.

As shown in FIG. 3, the device for using the telecom specification interface as a browser plug-in in the Blink browser provided by the embodiment, that is, the telecommunication interface implementation device includes: a JS object plug-in execution module 31, a JS object plug-in calling module 32, JS The object plug-in definition module 33 and the JS object plug-in parsing module 34; the relationship between the four modules is: the JS object plug-in calling module 32 provides a development guide for the developer. The JS object plug-in calling module 32 is responsible for calling the JS module; after receiving the request transmitted by the JS object plug-in calling module 32, the JS object plug-in executing module 31 calls the JS object plug-in parsing module 34, and the JS object plug-in parsing module 34 first reads the JS. The interface file defined by the object plug-in definition module 33 is then parsed into an execution object recognizable by the browser, and the object is returned to the JS object plug-in execution module 31, and the JS object plug-in execution module 31 executes the code and returns the execution result. The module 32 is called to the JS object plug-in. The connection relationship between the four modules constitutes a complete plug-in implementation method of the JS extension object.

The method for using the telecom specification interface as a browser plug-in in the Blink browser provided in this embodiment includes the following steps:

The first step: the browser will define the template of the JS extension object implementation. The template mainly includes the object name, the object attribute type and name, the object method name, the parameter and the return value type. When the developer needs to extend the new JS object interface, implement the JS interface definition file according to the template file provided by the browser and save it to the development directory.

The second step: the JS object plug-in calling module 32 obtains the JS object name that needs to be called according to the user call requirement, and passes the object name to the JS object plug-in execution module 31.

The third step: the JS object plug-in execution module 31 obtains the JS object name transmitted by the JS object plug-in calling module 32, determines whether the current memory has loaded the JS object, and if loaded, executes the related method and attribute of calling the object, and The execution result is returned to the JS object plugin calling module 32. If not, the JS object name is passed to the JS object plugin parsing module 34.

The fourth step: the JS object plug-in parsing module 34 finds the JS file defined by the developer from the specified directory according to the JS object name, and then loads it into the memory, and parses the JS interface definition file into a browser-recognizable identifier through the parsing syntax. The file is executed and returned to the JS object plug-in execution module 31.

The fifth step: the JS object plug-in execution module 31 executes the executable file returned by the JS object plug-in parsing module 34, and returns the execution result to the JS object plug-in calling module 32.

Step 6: The JS object plugin calling module 32 returns the execution result to the user.

Compared with the related technology, the method and the device of the embodiment have achieved great progress, achieved obvious effects, saved the development workload of the JS extension interface, and occupied the memory of the browser operation, thereby improving the working efficiency of the developer. , and the browser running speed, etc.

In practical applications, the telecom interface implementation method is mainly divided into two parts:

1. Expand the JS object interface definition file generation.

As shown in Figure 4, the process of this part of the process is as follows:

S401: The browser provides a rule file of the JS extension interface. This rules file is used to guide developers in developing the writing rules for JS extension files. The rule file mainly includes JS object name, attribute name, method name, and parameter name definition rule. And access control of attribute methods, including Public, Protected, Private, etc.

S402-S406: The developer writes the extended interface file MediaPlayerInterface in strict accordance with the rules file, and the format specification facilitates the parsing of subsequent interface files. After the definition of the JS object interface file is completed, the interface file is stored in the specified directory.

2. Extend the JS object interface call flow.

As shown in Figure 5, the process of this part of the process is as follows:

S501: The HTML page calls the extended JS object through the JS statement. If the JS object name is Example, the method is called: var mediaPlayer=new MediaPlayer().

S502-S503: The browser JavaScript engine executes the page call statement, mediaPlayer.getNativePlayerInstanceID(), first parses the JS object MediaPlayer that needs to be called by the page, calls the method name getNativePlayerInstanceID, and parameter information (this method does not need to pass parameters).

S504-S512: The JavaScript engine searches from the currently registered JS object. If it can find the JS object MediaPlayer that needs to be called, obtain the JS object, execute the corresponding method, and execute the result (the constructed media player ID value). ) Return to the HTML page. If there is no JS object MediaPlayer to be called in the engine, you need to pass the JS object name to the parsing module.

After obtaining the JS object name MediaPlayer passed by the JS engine, the parsing module finds the JS interface definition file MediaPlayerInterface corresponding to the JS object name from the browser development directory, and directly returns NULL to the page if the file does not exist, otherwise the interface is defined. The file is loaded into memory. The parsing module parses the interface file into a JS object MediaPlayer that can be recognized by the JS engine according to the parsing rule. After the parsing is completed, the JS object mediaPlayer is passed to the JavaScript engine.

The JavaScript engine executes the corresponding method based on the JS object passed by the parsing module, and returns the execution result (the constructed media player ID value) to the HTML page.

In summary, through the implementation of the embodiments of the present disclosure, at least the following beneficial effects exist:

An embodiment of the present disclosure provides a method for implementing a telecommunication interface. When working, receiving a plug-in call request that invokes a browser plug-in, determining a target telecommunication interface to be executed according to a plug-in call request, executing a target telecommunication interface, and returning an execution result, The execution result is displayed as a result of the plug-in, and is displayed; that is, the embodiment of the present disclosure provides a new implementation of the telecommunication interface, which uses the JS interface as a browser plug-in, and implements a corresponding JS interface function by calling a browser plug-in. Compared with the related technology, it has made great progress, achieved obvious effects, saved the development workload of the JS extension interface, and occupied the memory occupied by the browser, improved the developer's work efficiency, and the browser running speed, etc. The relevant browser extension JS interface needs to be recompiled The problem with the browser code enhances the user experience.

Those skilled in the art will appreciate that embodiments of the present disclosure can be provided as a method, system, or computer program product. Accordingly, the present disclosure may take the form of a hardware embodiment, a software embodiment, or a combination of software and hardware aspects. Moreover, the present disclosure may take the form of a computer program product embodied on one or more computer-usable storage media (including but not limited to disk storage and optical storage, etc.) including computer usable program code.

The present disclosure is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the present disclosure. It will be understood that each flow and/or block of the flowchart illustrations and/or FIG. These computer program instructions can be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing device to produce a machine for the execution of instructions for execution by a processor of a computer or other programmable data processing device. Means for implementing the functions specified in one or more of the flow or in a block or blocks of the flow chart.

The computer program instructions can also be stored in a computer readable memory that can direct a computer or other programmable data processing device to operate in a particular manner, such that the instructions stored in the computer readable memory produce an article of manufacture comprising the instruction device. The apparatus implements the functions specified in one or more blocks of a flow or a flow and/or block diagram of the flowchart.

These computer program instructions can also be loaded onto a computer or other programmable data processing device such that a series of operational steps are performed on a computer or other programmable device to produce computer-implemented processing for execution on a computer or other programmable device. The instructions provide steps for implementing the functions specified in one or more of the flow or in a block or blocks of a flow diagram.

Embodiment 3

Embodiments of the present disclosure also provide a storage medium. Optionally, in the embodiment, the foregoing storage medium may be configured to store program code for performing the following steps:

S1, receiving a plugin call request that invokes a browser plugin;

S2, determining, according to the plugin call request, a target interface that needs to be executed;

S3, executing the target interface, and returning an execution result;

S4, the execution result is used as a plug-in call result, and is displayed.

Optionally, the storage medium is further arranged to store program code for performing the following steps:

S1. Detect, according to an object name of the target interface, whether the current memory is the target interface.

S2. If the target interface is already loaded in the memory, execute related methods and attributes of the target interface, and return an execution result.

Optionally, the storage medium is further arranged to store program code for performing the following steps:

S1. If the target interface is not loaded, the interface file of the target interface is searched according to the object name of the target interface.

S2, loading the found interface file into the memory;

S3, parsing the interface file into an executable file that can be recognized by a browser by parsing a grammar;

S4, executing the execution file and returning an execution result.

Optionally, the storage medium is further arranged to store program code for performing the following steps:

S1, setting a rule file of the browser plugin;

S2: Convert the corresponding interface file according to the rule file, the interface to be plugged in.

Optionally, in this embodiment, the foregoing storage medium may include, but not limited to, a USB flash drive, a Read-Only Memory (ROM), a Random Access Memory (RAM), a mobile hard disk, and a magnetic memory. A variety of media that can store program code, such as a disc or a disc.

Optionally, in this embodiment, the processor executes the method steps described in the foregoing embodiments according to the stored program code in the storage medium.

For example, the examples in this embodiment may refer to the examples described in the foregoing embodiments and the optional embodiments, and details are not described herein again.

The above is only an alternative embodiment of the present disclosure, and is not intended to be in any form for the present disclosure. Any simple modifications, equivalent changes, combinations or modifications of the above embodiments in accordance with the technical spirit of the present disclosure are still within the scope of the technical solutions of the present disclosure.

Industrial applicability

In the embodiment of the present disclosure, when working, receiving a plug-in call request that invokes a browser plug-in, determining a target interface to be executed according to the plug-in call request, executing a target interface, returning an execution result, and executing the result as a plug-in call result, and performing The embodiment of the present disclosure provides a new interface implementation manner, which uses a JS interface as a browser plug-in, and implements a corresponding JS interface function by calling a browser plug-in, so that even if a new JS interface is added, it is not required. Recompiling the browser, compared with the related technology, has achieved great progress and obvious effects, saving the development workload of the JS extension interface, and the browser running memory, improving the developer's work efficiency, and the browser running speed, etc. It solves the problem that the relevant browser extension JS interface needs to recompile the browser code, and enhances the user experience.

Claims (11)

An interface implementation method for a set top box, comprising: Receiving a plugin call request that invokes a browser plugin; Determining a target interface to be executed according to the plugin call request; Executing the target interface, and returning an execution result; The execution result is called as a plugin result and displayed. The interface implementation method of claim 1, wherein the executing the target interface and returning the execution result comprises: Detecting whether the current memory is the target interface according to the object name of the target interface; If the target interface is already loaded in the memory, the related method and attribute of calling the target interface are executed, and the execution result is returned. The interface implementation method of claim 2, wherein the executing the target interface and returning the execution result further comprises: If the target interface is not loaded, the interface file of the target interface is searched according to the object name of the target interface; Load the found interface file into memory; Parsing the interface file into an executable file recognizable by a browser by parsing a grammar; Execute the execution file and return the execution result. The interface implementation method according to any one of claims 1 to 3, further comprising: Set the rules file for the browser plugin; According to the rule file, the interface to be plugged in converts the corresponding interface file. The interface implementation method according to claim 4, wherein the rule file includes an object name, an attribute name, a method name, a parameter name definition rule, and an access authority control of the attribute method of the interface. An interface implementation device for a set top box, comprising: a receiving module, configured to receive a plugin call request that invokes a browser plugin; An execution module, configured to determine, according to the plug-in call request, a target interface that needs to be executed, execute the target interface, and return an execution result; The presentation module is configured to display the execution result as a plugin result and display it. The interface implementation apparatus according to claim 6, wherein the execution module is configured to detect whether the current memory is the target interface according to an object name of the target interface, and if the target interface is loaded in the memory, execute the call center. The related methods and attributes of the target interface, and return the execution result. The interface implementation device of claim 7, wherein the execution module is configured to search for an interface file of the target interface according to an object name of the target interface, if the target interface is not loaded in the memory, The interface file is loaded into the memory, the interface file is parsed into an executable file recognizable by the browser by parsing syntax, the execution file is executed, and the execution result is returned. The interface implementation apparatus according to any one of claims 6 to 8, further comprising a writing module configured to set a rule file of the browser plug-in, and to convert the corresponding interface file according to the rule file, the interface to be plug-inized . A set top box comprising the interface implementation according to any one of claims 6 to 9. Device. A storage medium comprising a stored program, wherein the program is executed to perform the method of any of the preceding claims 1 to 5.

Images