WO2024019755A1

WO2024019755A1 - Support remote application extensions or plugins

Info

Publication number: WO2024019755A1
Application number: PCT/US2022/073961
Authority: WO
Inventors: Zhan Yu; Xiaofeng Li; Yiwei ZHAO
Original assignee: Innopeak Technology, Inc.
Priority date: 2022-07-20
Filing date: 2022-07-20
Publication date: 2024-01-25

Abstract

A general and transparent plugin interface is provided for deployment both locally and remotely. In accordance with the present disclosure, the plugin interface in accordance with the present disclosure is an intermediary plugin layer that maps a super application interface proved a device A to a remote plugin implementation on a device B. The super application is referred to as an application that has one or more functionalities available to a user through an application interface. In various embodiments, the super application is enabled by the plugin interface to call a plugin implemented provided on a remote device without having to have knowledge that the plugin implementation is deployed remotely on a different device.

Description

SUPPORT REMOTE APPLICATION EXTENSIONS OR PLUGINS

BACKGROUND

[0001] A plug-in is typically a small piece of software with one or more specific functions serving a webpage, an application or an app. For example, plug-ins were developed for earlier browsers, such as Netscape Navigator, such that they can be downloaded and installed onto a computer where the browser is running. An example of such plug-ins is a piece of software enabling a user to view a document in a specific format that cannot be displayed using HTML. Another example is a piece of software enabling the user to exploit one or more hardware functions provided by the computer, which cannot be invoked from the web browser via HTML.

[0002] In later development of the plug-in technology, plug-in coding has evolved from small pieces of helper software mentioned above to small pieces of code or apps for a host app. For example, Android plug-in is a tech where a piece of plug-in developed for a host app allows the host app to communicate with the android platform on which the plug-in runs. The plug-in, in that example, typically has the knowledge on how to access device and platform functionality such that the host app is not inundated with this knowledge. In this way, functionalities of the host app can be distributed and localized to the plug-ins, which makes bug fixes, app updates and deployment much easier.

SUMMARY

[0003] A system of one or more computers can be configured to perform particular operations or actions by virtue of having software, firmware, hardware, or a combination of them installed on the system that in operation causes or cause the system to perform the actions. One or more computer programs can be configured to perform particular operations or actions by virtue of including instructions that, when executed by data processing apparatus, cause the apparatus to perform the actions. One general aspect includes a method implemented by an electronic processor configured to execute machine-readable instructions such that when the machine-readable instructions are executed by the processor. In various embodiments, the method includes receiving a function call from an application. In those embodiments, the method also includes detecting that the function call is for a plugin implementation on a remote device. In those embodiments, the method also includes generating a message based on the function call. The method also includes sending the message to the remote device. The method also includes receiving a return value from the remote device, the return value being in response to the function all. The method also includes forwarding the return value to the application. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods.

[0004] Implementations may include one or more of the following features. The method where the function call is a callback function call, and the message is a callback function message. The function call is a api function call, and the message is a api call message. The method may include: determining a preset time period has expired after the message is sent to the remote device and the return value has not been received; and in response to the determination that the preset time period has expired after the message is sent to the remote device and the return value has not been received, generating a default return value and forward the default return value as the return value to the application. The return value is received after the intermediate return value is received. Implementations of the described techniques may include hardware, a method or process, or computer software on a computer-accessible medium.

[0005] One general aspect includes a device may include an electronic processor configured to perform: receiving a function call from an application. The device is also configured to perform detecting that the function call is for a plugin implementation on a remote device. The device also includes generating a message based on the function call. The device is also configured to perform sending the message to the remote device. The device is also configured to perform receiving a return value from the remote device, the return value being in response to the function all. The device is also configured to perform forwarding the return value to the application. Other embodiments of this aspect include corresponding computer systems, apparatus, and computer programs recorded on one or more computer storage devices, each configured to perform the actions of the methods.

[0006] Implementations may include one or more of the following features. In some embodiments, the function call is a callback function call, and the message is a callback function message. In some embodiments, the function call is an API function call, and the message is an API call message. In some embodiments, the device is further configured to perform: determining a preset time period has expired after the message is sent to the remote device and the return value has not been received; and in response to the determination that the preset time period has expired after the message is sent to the remote device and the return value has not been received, generating a default return value and forward the default return value as the return value to the application. In some embodiments, the device is further caused to perform: receiving an intermediate return value from the remote device after the message is sent; and, where the return value is received after the intermediate return value is received. Implementations of the described techniques may include hardware, a method or process, or computer software on a computer- accessible medium.

BRIEF DESCRIPTION OF THE DRAWINGS

[0007] A further understanding of the nature and advantages of various embodiments may be realized by reference to the following figures. In the appended figures, similar components or features may have the same reference label. Further, various components of the same type may be distinguished by following the reference label by a dash and a second label that distinguishes among the similar components. If only the first reference label is used in the specification, the description is applicable to any one of the similar components having the same first reference label irrespective of the second reference label.

[0008] FIG. 1 illustrates one example plugin interface in accordance with the present disclosure.

[0009] FIG. 2 illustrates another example of a plugin proxy interface in accordance with the present disclosure.

[0010] FIG. 3 illustrates yet another example of a plugin proxy interface in accordance with the present disclosure.

[0011] FIG. 4 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where synchronous callback mechanism is employed.

[0012] FIG. 5 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where synchronous API call mechanism is employed.

[0013] FIG. 6 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where asynchronous callback mechanism is employed.

[0014] FIG. 7 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where asynchronous API mechanism is employed.

[0015] FIG. 8 is an example flow chart showing a method for implementing a plugin proxy interface in accordance with the present disclosure.

[0016] FIG. 9 is an example flow chart showing a method for implementing a plugin proxy interface in accordance with the present disclosure.

[0017] FIG. 10 illustrates an example of a computer system configurable to implement various embodiments in accordance with the present disclosure. DETAILED DESCRIPTION

[0018] Having described several example configurations, various modifications, alternative constructions, and equivalents may be used without departing from the spirit of the disclosure. For example, the above elements may be components of a larger system, wherein other rules may take precedence over or otherwise modify the application of the invention. Also, a number of steps may be undertaken before, during, or after the above elements are considered.

[0019] As used herein, client and server are relative terms. In accordance with the present disclosure, whichever sends a message is a client and whichever receives the message is a server. For example, two processes A and B, they communicate with each other, A sends a message to B, at this time A is the client, and B is the server; and then B sends a message to A, at this time B is the client, and A is the binder server.

[0020] As used herein, a proxy is referred to as wrapper or an agent object that is called by a client to access the real serving object behind the scenes. For example, in this figure below:

the RealSubject and Proxy are each a subclass of the Subject - the client. In this example, when the Subject evokes the Request method, it calls the Proxy, which has a method called realSubject, which in turn evokes the RealSubject to perform functionalities coded with the RealSubject.

[0021] As used herein, a proxy is referred to as a local proxy when it is located on a same computing platform as serving application or app. For example, when a proxy is located on a same computer system as an application that provides voice recognition, this proxy is referred to as the local voice recognition proxy. As used herein, a proxy is referred to as a remote proxy when it is located separate and distinct from the local proxy. It should be understood, the remote proxy may be located on the same or different computing platform. For example, a remote proxy can be located on a user’s smartphone, such as an Android phone, and evoke functionalities provided by the local voice recognition proxy. In that example, the remote proxy can be referred to as the remote voice recognition proxy.

[0022] As used herein, a plug-in proxy is a piece of software that performs the proxy functionalities in accordance with the present disclosure for an application or app. For example, a voice recognition plugin proxy can be developed for Android platform such that it can be installed on an Android smartphone. The voice recognition plugin proxy can be exploited by an app such as an app installed on the Android smart phone. In that example, the voice recognition plug-in proxy is also a remote proxy configured to communicate with the local voice recognition plug-in proxy on the computing platform where the voice recognition application that can perform the actual voice recognition task is located.

[0023] Traditionally, as mentioned above, a plugin is installed on a device where an application resides and enables the application to access one or more functionalities provided by the plugin and/or the device. Thus, implementation of the plugin for is typically application and device specific - for example, a specific plugin is typically developed for a PC and another specific plugin is typically developed for a Mac for a same application - e.g. a same drawing application on PC and Mac, where both plugins help the application achieve more or less the same functions.

[0024] In addition, traditional plugins developed for an application typically does not perform tasks on a device remote to the plugins. Techniques were developed to facilitate a local plugin to request a task to be performed on a remote device through specific remote support. Such remote support typically is plugin specific and/or device specific, and thus is not flexible and sharable for different plugins of a same application or different applications.

[0025] One insight provided by the present disclosure is to provide a general and transparent plugin interface deployed both locally and remotely. In accordance with the present disclosure, the plugin interface in accordance with the present disclosure is an intermediary plugin layer that maps a super application interface proved a device A to a remote plugin implementation on a device B. As used herein, a super application is referred to as an application that has one or more functionalities available to a user through an application interface. For example, a drawing application on a device can be considered as a super application because it has drawing functionalities (such as allowing user to draw digitally on the device) through the application interface provided by the drawing application. As used herein, a plugin implementation is referred to a piece of software on a device that makes one or more functionalities provided by that device accessible to other applications. For example, a plugin implementation can be developed for a tablet to make inputs and outputs in a touch-sensitive surface accessible to an application. [0026] By way example for illustration, a drawing app on device A is enabled to allow a user to us a drawing pad on device A to draw something in the drawing app. In that example, the drawing app is the super application. A plugin implementation is developed on device B that makes inputs/outputs in a touch-sensitive surface of device B accessible. In various embodiments, the novel plugin proxy interface in accordance with the present disclosure is developed as a standardized interface for super applications, such as the draw app, to access remote plugin implementations. This allows the plugin interface to be accessed and shared by any plugin that needs remote support on those applications. This also remotely extends functionalities provided by various other devices to an application on a device otherwise would not have those functionalities.

[0027] FIG. 1 illustrates one example plugin interface in accordance with the present disclosure. In this example, the application is located on device A, which may be a PC. In this example, device B may be a tablet computer, for example a tablet. For instance, the application may be a drawing application that allows a user to author a drawing on the PC. In this example, plugin implementation makes a set of one or more functionalities accessible to whichever application to use those functionalities. For instance, the plugin implementation exports inputs and outputs in a touch-sensitive surface of the tablet. In this example, the plugin implementation is developed specifically for the tablet and does not export such inputs and outputs remotely beyond the device where it is installed by itself. Thus, in this example, the plugin implementation does not export such input/outputs to device A by itself.

[0028] Traditionally, the plugin implementation shown in this example cannot be used by the application on a difference device because of the restraints mentioned above. That is, the PC drawing application would not be able to use the tablet touch sensitive surface even though there is the plugin implementation on the tablet. Traditionally, the plugin implementation is typically developed for access by an application or app on device B, e.g. a web browser installed on the tablet. As mentioned above, traditionally, the provider of the application could implement its own remote support for the application to access the plugin implementation on device B remotely, but such remote support is typically device and/or application specific, and thus not reusable or shareable to other applications.

[0029] As illustrated, in this example, local plugin proxy and remote plugin proxy are deployed on device A and device B, respectively. These plugin proxies are collectively referred to as the plugin proxy interface. A functionality of the plugin proxy interface is that it passes back and forth API calls and Callbacks between the plugin implementation and the application. In this way, the plugin implementation on device B is made accessible to one or more applications on device A. As mentioned, the plugin proxy interface in accordance with the present disclosure is differentiated from the traditional remote support for the plug-in implementation because the plugin proxy interface in accordance with the present disclosure is a standardized interface that can enable multiple applications on device A to access the plugin implementation on device B. In various implementations, the plugin proxy interface in accordance with the present disclosure enables the applications on device A to make API calls to the plugin implementation without knowledge that the plugin implementation is located remote on device B. In that sense, the plugin proxy interface allows a developer of a given application for device A to access one or more functionalities provided by the plugin implementation as if the plugin implementation is located on a same device as the given application. Behind the scene of the developer of the given application, the plugin proxy interface in accordance with the present disclosure handles “plumbing” and communication needed to facilitate the given application to make API calls to the plugin implementation and to obtain callbacks from the plugin implementation across the devices.

[0030] By way of example of illustration, the plugin implementation on device B sends an API call to application 1 on device A - not knowing that application 1 is remote from the plugin implementation. For instance, the API call may be a request for the application 1 to let the plugin implementation know if the plugin implementation may begin performing a functionality previously requested by application 1. In that example, the remote plugin proxy intercepts the API call from plugin implementation and detects that application 1 is on device A. The remote plugin proxy then generates an API message and sends the API message to the local plugin proxy.

[0031] The local plugin proxy on device A receives the API message and detects the API message is from plugin implementation for an API call to application. The local plugin proxy then generates the API call to application 1. After receiving the API call, application 1 generates a result in response to the API call - e.g., an acknowledgement that the plugin implementation may begin perform the previously requested functionality immediately. Application 1 then generates a callback function message containing the result to the plugin implementation.

[0032] Application 1 sends the callback function message to the plugin implementation as if the plugin implementation resides on a same device as application 1. The call back function message from application 1 is intercepted by the local plugin proxy, which is configured to detect that callback function message from application 1 is to the plugin implementation remote from device A. The local plugin proxy then sends the callback function message to device B, where the plugin implementation resides. The remote plugin proxy receives the callback function message and detects that the callback function message is from application 1 on device A to the plugin implementation. The remote plugin proxy then generates a callback function to the plugin implementation to pass the callback function message to the plugin implementation.

[0033] FIG. 2 illustrates another example of a plugin proxy interface in accordance with the present disclosure. In this example, compared with the example shown in FIG. 1, a single application on device A can exploit the plugin proxy interface having the local plugin proxy and remote plugin proxy as shown to access multiple plugin implementations on device B. In this example, after receiving an API call message or a callback function message, the remote plugin proxy on device B is configured to determine which plugin implementation(s) is(are) the recipient(s) of that message and generate one or more function calls to specific plugin implementation(s) on device B accordingly. In this way, the application on device A is made accessible to multiple functionalities provided by the multiple plugin implementations on device B. As mentioned, the local/remote plugin proxy is standardized such that the developers of the plugin implementations can plug in their respective plugin implementations to the plugin proxy interface making them available to the application without having to develop separate equivalent plugin implementations for device A.

[0034] FIG. 3 illustrates yet another example of a plugin proxy interface in accordance with the present disclosure. In this example, one or more applications on a given device, such as device A, B, or N, are facilitated, by the plugin proxy interface, to access one or more plugin implementations provided on another device, such as device D or device E. In this example, application(s) on device A is facilitated to access plugin implementations on device D but not on device E, and application(s) on device N is facilitated to access plugin implementations on device E but not on device D. Application(s) on device B is facilitated to access plugin implementations on device and on device D. In this example, the plugin proxy interface is configured to detect which plugin implementation on which device is accessible to which application for a specific device. In implementations, a registry may be developed to keep track of such information. In some implementations, such a registry may be implemented on both local/remote plugin proxy and synchronized from time to time.

[0035] In some implementations, plugin implementations can be chained together for applications across devices. For instance, in this example, a first plugin implementation on device D can be facilitated to make API/Callback function calls to a second plugin implementation on device E. For example, an application on device B can make a API call to the first plugin implementation, which then makes another API call to the second plugin implementation on device E when fulfilling the API call from the application. In implementations, the remote plugin proxies on different devices can be configured to export functionalities provided by the plugin implementations on their respective devices to other plugin implementations residing on other devices.

[0036] FIG. 4 is a diagram that illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where synchronous callback mechanism is employed. In this example, a synchronous callback mechanism the application, intermediary plugin proxy, and a 3rd party plugin implementation is shown. As mentioned above, the plugin proxy interface, in this example, comprises a local plugin proxy and a remote plugin proxy. In some embodiments, the local plugin proxy and remote plugin proxy are located on two different device - for example- as shown in FIGS. 1-3.

[0037] In the callback mechanism shown in FIG. 4, the Application first initiates a callback function call to the 3rd party plugin implementation, which may or may not reside on a same device as the Application. In the case where the 3rd party plugin implementation is located on a different device from the Application, the Application does not necessarily have the knowledge that the 3rd party plugin implementation resides on a remote device. For instance, the Application does not have to have remote support to invoke 3rd party plugin implementation. In this example, the callback function call initiated by the Application is intercepted by the local plugin proxy. At the same time, the Application starts a timer waiting for a result from the 3rd party plugin implementation in response to the callback function call.

[0038] After receiving the callback function call request from the Application, the local plugin proxy, in this example, detects that the callback function call request from the Application is for a 3rd party plugin implementation on a remote device. In this case, the local plugin proxy determines which device the 3rd party plugin implementation, and generates a callback function message directed to that device. The local plugin proxy then sends the callback function message to that device.

[0039] The remote plugin proxy on the device where the 3rd party plugin implementation receives the callback function message from the local plugin proxy. The remote plugin proxy then detects that the callback function message is from the Application and is directed to the 3rd party plugin implementation. The remote plugin proxy then generates an equivalent callback function call to the 3rd party plugin implementation as if it were from an application local to the 3rd party plugin implementation.

[0040] The 3rd party plugin implementation receives the callback function call from the remote plugin proxy. It should be understood the 3rd party plugin implementation is referred as such in this example because it is developed and provided by an entity separate and distinct from the provider of the Application. However, this is not intended to be limiting. As shown in FIGS. 1-3, the plugin implementation in accordance with the present disclosure does not have to be provided by a 3rd party with respect to a provider of the Application. In some embodiments, the 3rd party plugin implementation is contemplated to be provided by a same provider of the Application. In this example, after receiving the callback function call, the 3rd party plugin implementation, executes accordingly to generate a function return value.

[0041] Because the callback function call is generated by the remote plugin proxy, the remote plugin proxy receives the function return value from the 3rd party plugin implementation. That is, the 3rd party plugin implementation may not necessarily have the knowledge of the remote plugin proxy. It may simply “think” that is sending the function return value to the Application.

[0042] After receiving the function return value, the remote plugin proxy sends the function return value back to the local plugin proxy, because the remote plugin proxy understands that the function return value is for the Application, which is handled by the local plugin proxy. After receiving the function return value from the remote plugin proxy, the local plugin proxy returns the function return value to the Application because it understands that the Application has made the callback function call to the 3rd party plugin implementation and is waiting on a result.

[0043] As shown, this mechanism is referred to as synchronous callback mainly because once the callback function call is initiated by the Application, it stops performing other tasks and starts the timer. This may also be referred to as blocking call mechanism. In the event, the Application does not receive the function return value from the 3rd party plugin implementation from the 3rd party plugin implementation and the timer times out after a preset period, the local plugin proxy returns a default return value to the Application so that the Application can continue performing other tasks.

[0044] FIG. 5 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where synchronous API call mechanism is employed. In this example, an API call is initiated from the plugin implementation as shown. Like the example shown in FIG. 4, the API call is intercepted by the remote plugin proxy and an API call message is generated by the remote plugin proxy accordingly. The API call message then is forwarded by the remote plugin proxy to the device where the Application resides. The API call message is then received by the local plugin proxy, which generates an API call request to the Application as if the request were from another local Application. The Application performs one or more task to answer the API call and returns an API return value. As shown, this API call mechanism for facilitating the remote plugin implementation is also blocking. As shown, the API call can be timed out after a preset period expires.

[0045] In example implementations, the synchronous callback or API function call mechanism is implemented using so-called soft blocking as compared to hard blocking. In hard blocking, the calling entity, e.g., the Application or the 3rd party plugin implementation, stops performing other tasks until the call is either timeout or a value in response to the call is obtained by the call entity. In soft blocking, after a call is initiated by the API or 3rd party plugin implementation, a second thread is started to send the request to the other side for the result. In this way, the calling entity is free to perform other tasks while the second thread is waiting for the result. In those implementations, the call can still be timed out and the second entity can still get a default value.

[0046] FIG. 6 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where asynchronous callback mechanism is employed. Compared with the example in FIG. 4, the callback mechanism shown in this example is asynchronous in a sense there is no timeout employed. As shown, after the callback function call is received by the 3rd party plugin implementation, an immediate return value is returned to the Application. This immediate return value can be an acknowledgement that the callback function call is received by the 3rd party plugin implementation. In this way, the Application is notified and thus may proceed to perform other tasks. The 3rd party plugin implementation then take its time to complete the callback function call request and sends the return value to the Application when finished. This may happen immediately after the immediate return value is returned to the Application by the 3rd party plugin implementation, or may take some time.

[0047] FIG. 7 is a diagram illustrates one example implementation of the plugin proxy interface in accordance with the present disclosure, where asynchronous API mechanism is employed.

[0048] FIG. 8 is an example flow chart showing a method 800 for implementing a plugin proxy interface in accordance with the present disclosure. The operations of method 800 presented below are intended to be illustrative. In some embodiments, method 800 may be accomplished with one or more additional operations not described and/or without one or more of the operations discussed. Additionally, the order in which the operations of method 800 are illustrated in FIG. 8 and described below is not intended to be limiting.

[0049] In some embodiments, method 800 may be implemented by a device including one or more of the processor, such as the ones shown in FIG. 8. The device may include a digital processor, an analog processor, a digital circuit designed to process information, an analog circuit designed to process information, a state machine, and/or other mechanisms for electronically processing information. The device may execute some or all of the operations of method xxx in response to instructions stored electronically on an electronic storage medium. The device may include one or more components configured through hardware, firmware, and/or software to be designed for execution of one or more of the operations of method 800. In some implementations, the method 800 is implemented by a local plugin proxy described and illustrated herein.

[0050] FIG. 9 is an example flow chart showing a method 900 for implementing a plugin proxy interface in accordance with the present disclosure. The operations of method 900 presented below are intended to be illustrative. In some embodiments, method 900 may be accomplished with one or more additional operations not described and/or without one or more of the operations discussed. Additionally, the order in which the operations of method 900 are illustrated in FIG. 9 and described below is not intended to be limiting.

[0051] In some embodiments, method 900 may be implemented by a device including one or more of the processor, such as the ones shown in FIG. 9. The device may include a digital processor, an analog processor, a digital circuit designed to process information, an analog circuit designed to process information, a state machine, and/or other mechanisms for electronically processing information. The device may execute some or all of the operations of method xxx in response to instructions stored electronically on an electronic storage medium. The device may include one or more components configured through hardware, firmware, and/or software to be designed for execution of one or more of the operations of method 900. In some implementations, the method 900 is implemented by a remote plugin proxy described and illustrated herein.

Example Computer System

[0052] Any of the computer systems and embodiments mentioned herein may be implemented by or utilize any suitable number of subsystems. Examples of such subsystems are shown in FIG. 10 in computer system 10, which can be configured to implement various features and/or functions described herein. In some embodiments, a computer system includes a single computer apparatus, where the subsystems can be the components of the computer apparatus. In other embodiments, a computer system can include multiple computer apparatuses, each being a subsystem, with internal components.

[0053] The subsystems shown in FIG. 5 are interconnected via a system bus 75. Additional subsystems such as a printer 74, keyboard 78, storage device(s) 79, monitor 76, which is coupled to display adapter 82, and others are shown. Peripherals and input/output (I/O) devices, which couple to I/O controller 71, can be connected to the computer system by any number of means known in the art such as input/output (I/O) port 77 (e.g., USB, FireWire®). For example, I/O port 77 or external interface 81 (e.g. Ethernet, Wi-Fi, etc.) can be used to connect computer system 10 to a wide area network such as the Internet, a mouse input device, or a scanner. The interconnection via system bus 75 allows the central processor 73 to communicate with each subsystem and to control the execution of instructions from system memory 72 or the storage device(s) 79 (e.g., a fixed disk, such as a hard drive or optical disk), as well as the exchange of information between subsystems. The system memory 72 and/or the storage device(s) 79 may embody a computer readable medium. Any of the data mentioned herein can be output from one component to another component and can be output to the user.

[0054] A computer system can include a plurality of the same components or subsystems, e.g., connected together by external interface 81 or by an internal interface. In some embodiments, computer systems, subsystem, or apparatuses can communicate over a network. In such instances, one computer can be considered a client and another computer a server, where each can be part of a same computer system. A client and a server can each include multiple systems, subsystems, or components.

[0055] It should be understood that any of the embodiments of the present invention can be implemented in the form of control logic using hardware (e.g. an application specific integrated circuit or field programmable gate array) and/or using computer software with a generally programmable processor in a modular or integrated manner. As used herein, a processor includes a single-core processor, multi-core processor on a same integrated chip, or multiple processing units on a single circuit board or networked. Based on the disclosure and teachings provided herein, a person of ordinary skill in the art will know and appreciate other ways and/or methods to implement embodiments of the present invention using hardware and a combination of hardware and software.

[0056] Any of the software components or functions described in this application may be implemented as software code to be executed by a processor using any suitable computer language such as, for example, Java, C, C++, C#, Objective-C, Swift, or scripting language such as Perl or Python using, for example, conventional or object-oriented techniques. The software code may be stored as a series of instructions or commands on a computer readable medium for storage and/or transmission, suitable media include random access memory (RAM), a read only memory (ROM), a magnetic medium such as a hard-drive or a floppy disk, or an optical medium such as a compact disk (CD) or DVD (digital versatile disk), flash memory, and the like. The computer readable medium may be any combination of such storage or transmission devices. [0057] Such programs may also be encoded and transmited using carrier signals adapted for transmission via wired, optical, and/or wireless networks conforming to a variety of protocols, including the Internet. As such, a computer readable medium according to an embodiment of the present invention may be created using a data signal encoded with such programs. Computer readable media encoded with the program code may be packaged with a compatible device or provided separately from other devices (e.g., via Internet download). Any such computer readable medium may reside on or within a single computer product (e.g. a hard drive, a CD, or an entire computer system), and may be present on or within different computer products within a system or network. A computer system may include a monitor, printer, or other suitable display for providing any of the results mentioned herein to a user.

[0058] Any of the methods described herein may be totally or partially performed with a computer system including one or more processors, which can be configured to perform the steps. Thus, embodiments can be directed to computer systems configured to perform the steps of any of the methods described herein, potentially with different components performing respective steps or a respective group of steps. Although presented as numbered steps, steps of methods herein can be performed at a same time or in a different order. Additionally, portions of these steps may be used with portions of other steps from other methods. Also, all or portions of a step may be optional. Additionally, any of the steps of any of the methods can be performed with modules, circuits, or other means for performing these steps.

[0059] The specific details of particular embodiments may be combined in any suitable manner without departing from the spirit and scope of embodiments of the invention. However, other embodiments of the invention may be directed to specific embodiments relating to each individual aspect, or specific combinations of these individual aspects.

[0060] The above description of exemplary embodiments of the invention has been presented for the purposes of illustration and description. It is not intended to be exhaustive or to limit the invention to the precise form described, and many modifications and variations are possible in light of the teaching above. The embodiments were chosen and described in order to best explain the principles of the invention and its practical applications to thereby enable others skilled in the art to best utilize the invention in various embodiments and with various modifications as are suited to the particular use contemplated.

[0061] A recitation of "a", "an" or "the" is intended to mean "one or more" unless specifically indicated to the contrary. The use of “or” is intended to mean an “inclusive or,” and not an “exclusive or” unless specifically indicated to the contrary. [0062] All patents, patent applications, publications, and descriptions mentioned herein are incorporated by reference in their entirety for all purposes. None is admitted to be prior art.

Claims

WHAT IS CLAIMED IS:

1. A method implemented by an electronic processor configured to execute machine-readable instructions such that when the machine-readable instructions are executed by the processor, the processor is caused to perform the method, the method comprising: receiving a function call from an application; detecting that the function call is for a plugin implementation on a remote device; generating a message based on the function call; sending the message to the remote device; receiving a return value from the remote device, the return value being in response to the function all; and forwarding the return value to the application.

2. The method of claim 1, wherein the function call is a callback function call, and the message is a callback function message.

3. The method of claim 1, wherein the function call is a API function call, and the message is a API call message.

4. The method of claim 1, further comprising: determining a preset time period has expired after the message is sent to the remote device and the return value has not been received; and in response to the determination that the preset time period has expired after the message is sent to the remote device and the return value has not been received, generating a default return value and forward the default return value as the return value to the Application.

5. The method of claim 1, further comprising: receiving an intermediate return value from the remote device after the message is sent; and, wherein the return value is received after the intermediate return value is received.

6 . The method of claim 1, wherein the message is a first message, and the method further comprises: receiving a second message from the remote device; determining the second message comprising a request of a function call from the plugin implementation to the application; generating a function call to the application according to the second message.

7. The method of claim 6, wherein the function call is a callback function call from the plugin implementation.

8 . The method of claim 6, wherein the function call is an API function call from the plugin implementation.

9. The method of claim 6, further comprising: receiving a return value from the application in response to the function call; and forwarding the return value to the remote device.

10. A device comprising an electronic processor configured to perform: receiving a function call from an application; detecting that the function call is for a plugin implementation on a remote device; generating a message based on the function call; sending the message to the remote device; receiving a return value from the remote device, the return value being in response to the function all; and forwarding the return value to the application.

11. The device of claim 10, wherein the function call is a callback function call, and the message is a callback function message.

12. The device of claim 10, wherein the function call is a API function call, and the message is a API call message.

13. The device of claim 10, wherein the electronic processor is further caused to perform: determining a preset time period has expired after the message is sent to the remote device and the return value has not been received; and in response to the determination that the preset time period has expired after the message is sent to the remote device and the return value has not been received, generating a default return value and forward the default return value as the return value to the Application.

14. The device of claim 10, wherein the electronic processor is further caused to perform: receiving an intermediate return value from the remote device after the message is sent; and, wherein the return value is received after the intermediate return value is received.

15 . The device of claim 10, wherein the message is a first message, and the electronic processor is further caused to perform: receiving a second message from the remote device; determining the second message comprising a request of a function call from the plugin implementation to the application; generating a function call to the application according to the second message.

16. The device of claim 15, wherein the function call is a callback function call from the plugin implementation.

17 . The device of claim 15, wherein the function call is an API function call from the plugin implementation.

18. The device of claim 15, wherein the electronic processor is further caused to perform: receiving a return value from the application in response to the function call; and forwarding the return value to the remote device.