JP5072844B2 - User interface service provision - Google Patents

Description

  Personal computers (used herein to consider an array of computing devices) continue to evolve into devices that are more suitable for the living room of the home as well as the office. For example, a common use of PCs is for use as a DVR (Digital Video Recorder) known as PVR (Personal Video Recorder). A PC used in this manner can record a media program such as a television program of interest for later playback or download to an external device. One of the evolutionary aspects related to computers that expands its usage is the evolution of its user interface (UI).

  Conventionally, computers have exchanged information with a UI referred to herein as a two-foot UI (length: about 61 cm), that is, a proximity UI. The 2 foot UI is designed to be used in connection with users who are about 2 feet (61 cm) away from the computer screen, or approximately the length of their arms. Almost all graphical user interfaces (GUIs) designed for computers are 2 foot UIs. However, in recent years, the idea of a 10-foot UI (about 3 meters in length) has been materialized. Using a 10-foot UI makes it easy to exchange information with a computer from a farther distance—about the distance to watch TV. Another descriptive term for this type of UI is “Distance User Interface” (DUI). Of course, the terms “10 feet UI” or “DUI” do not consider interacting with a computer that is exactly 10 feet (3 meters), but rather, the PC from about a TV viewing distance. Used herein to describe the concept of manipulating.

  One embodiment of such a DUI is described in co-pending application No. 10 / 174,619 with the name “User Interface for Operating a Computer From A Distance”. Another embodiment of such a system and its interaction are described in US Pat. No. 6,313,851 entitled “User Friendly Remote System Interface” and US in the name “User-Friendly Remote System Interface With Menu Highlighting”. This is described in US Pat. No. 6,898,765. Each of these references is expressly incorporated herein by reference.

  A user interface shell (UIS) is a type of environment that interacts with various applications (including computer operating systems) to control the presentation of data to the user. In general, a 10 foot UI application is not compatible with a system that presents a 10 foot UI. Just as an application needs to be configured to operate in conjunction with a 2 foot UI, the application must be configured to operate in conjunction with a 10 foot UI. Such a configuration can be particularly problematic for both software and UI developers.

  One reason why this is a problem is related to ensuring interoperability. In other words, the UI must be compatible with the desired application. Software vendors must make their applications compatible with the UI that is to be used to present the data associated with the application. The more shells that must interact with each other, the greater the burden that software vendors face when developing applications that can be used by many people.

  One possible solution to this challenge is to have only a single UI, as defined herein, a single 10 foot UI. This scenario is important for independent software vendors (ISVs). This is because they need to program their applications to interact with only a single 10 foot UI. However, this scenario has many regrets for other software vendors, especially those engaged in developing alternative UI shells (first shell, or alternative to the default shell). Certain software vendors may wish to have a customized 10 foot UI. However, the company wishing to develop a customized 10 foot UI ensures that without the present invention, the UI is compatible with various products offered by various other software vendors. Face a messy job.

  In addition, if a vendor attempts to independently develop an alternative UIS, such as an alternative 10-foot UIS, the shell may be customized with features, brands, etc., although UIS (other applications and hardware devices) Communicate with other tasks). Such attempts are not only resource intensive, but involve considerable uncertainties as to how well they are accepted by the market and how compatible with various hardware and software products. Current technology, among other things, by providing a method and system that allows a desired software vendor to achieve a customized 10 foot UI without the burden associated with developing a fully interoperable UI. It would be possible to improve.

  Embodiments of the present invention provide, among other things, a system and method that facilitates interaction with one or more computing devices by servicing a second UIS using a first UIS. This solves at least the above problems. The present invention extends the client / server type or relationship to the user interface. The present invention provides several methods in the art, including facilitating UI shell development and thereby reducing resources associated with making an alternative UI shell available to a running computing system. Have practical applications.

  In a first exemplary aspect, an application program interface (API) (from multiple component interfaces) that facilitates a method for presenting a presented UI (presented UI) in conjunction with a service providing user interface shell (UIS) Can be configured). The method includes receiving data indicating that the task is complete, coordinating the completion of the task, and returning control to the presentation UI.

  In a second exemplary aspect, one embodiment of the invention takes the form of a computer-implemented method that includes servicing a first graphical UIS with a second UIS. The first UIS can be a client UIS, the second UIS is a service providing UIS, and the first UIS is serviced by the second UIS.

  In a third exemplary aspect, an embodiment of the invention includes servicing a first UI environment with a second UI environment.

  In a fourth exemplary aspect, an embodiment of the invention provides a computer program for performing a method that facilitates interaction with one or more computing devices having at least two UI shells. It is a product. The method includes servicing a second UIS that is presented to the user using a first UIS that is not presented to the user.

  In one last exemplary aspect, one embodiment of the present invention is a displayable UIS embodied on one or more computer-readable media served by a hidden UIS.

  The present invention is described in detail below with reference to the accompanying drawings, which are incorporated herein by reference.

  As already mentioned, UI developers can use the 10-foot UI without the work associated with creating independent UIs compatible with various operating systems, third-party applications, hardware devices, etc. You may want to design your own look and feel and present such a look and feel to the user. The solution described herein causes a first user interface shell (UIS) to service a second UIS (alternate or customized UIS), so that the computer user has a customized UI. However, the customized UI will operate in conjunction with a service provisioning UI that performs the traditional “powerful work” associated with an independent UI. The UI shell is a kind of UI environment.

  In a sense, one aspect of one embodiment of the present invention could be described as a facade. The client UI is a kind of appearance presented to the user. Thus, although a client shell is presented, the service providing shell is not in one embodiment. In accordance with various embodiments of the present invention, a service providing UIS is a universal UI (display) that facilitates data exchange with a client UI at one end and data exchange between various applications and other components at the other end. But can be displayed if necessary).

Throughout the description of the present invention, multiple acronyms and shorthand notations are used to facilitate understanding of some concepts related to related systems and services. These acronyms and shorthand notations are intended only to provide a convenient way of communicating the ideas disclosed herein, and are not intended to limit the scope of the invention in any way. A list of these acronyms is given below.
API: Application program interface service provision UIS: A user interface shell that services another user interface shell called a client UI shell.
Client UIS: A user interface shell that receives services from another user interface shell called a service providing UIS.
ISV: Independent software vendor 10 ft UI / DUI: 10 ft user interface / remote user interface (operates the computer from approximately the TV viewing distance).
2 feet UI / DUI: 2 feet (about 61 cm) user interface (operating a computer from a distance of about a television viewing distance).
UI: User interface UIS: User interface shell

  Returning to FIG. 1, an exemplary embodiment of the present invention is shown and is generally referred to by the number 110. API 112 is referenced. The API 112 can be composed of a collection of components that expose various functional aspects, such as in a method, but in this document it is singular to avoid obscuring the present invention and to make it easier to read. Mainly referenced. The use of API 112 facilitates communication between client UIS 114 that are serviced by service providing UIS 116 in one embodiment.

  The service providing UIS 116, as a kind of server component, seeks to service the request of the client UIS 114 that operates as a kind of client with respect to the UIS 116. Each UIS can host other applications either directly or indirectly according to some embodiments of the present invention.

  Various networks are not shown in FIG. 1 in order not to obscure the present invention, which is the case when such networks are considered well within the scope of the present invention. For example, the serving UIS 116 and the client UIS 114 can reside on different devices such as different PCs coupled to each other by one or more networks. As alluded to above, the shell can operate in a client-server arrangement on the network. For example, the client UIS 114 is serviced by a service providing UIS 116 that operates as a type of server to perform a relatively large number of resource intensive tasks as a type of client. The terms “client” and “server” (and variations such as “service provision”) are used herein, which are used to describe various functional aspects of the shell. They are not necessarily themselves “clients” or “servers” with respect to the historical meaning of the term. However, these terms convey concepts related to the present invention.

  In short, the client UIS 114 is a UI shell that submits requests fulfilled by other UI shells. A service-providing UI shell is a shell that services other UI shells (such as receiving a request, completing a task, etc., as described below). The client UIS 114 receives a service provided by the service providing UIS 116. However, since the user only sees components related to the client UIS 114 (such as UI components), the user may not even know that the serving UIS 116 exists. Similarly, some applications may not even know that the client UIS 114 is present. This is because, in one embodiment, the application interacts with the service providing UIS 116, and then the service providing UIS 116 passes the data or data modifications to the client UIS 114.

  Various visual elements or data components are presented on a display device in the presentation area 118, which may take the form of a computer monitor, a handheld device. The presentation area 118 is for user selection area 120 and the like, such as playing a video, displaying an image, or displaying a feed from a service providing UIS 116 that interacts with a collection of applications generally referenced by number 124. Several exemplary components are shown, such as inserts 122 that can be used. References suggested earlier describe in detail exemplary DUI components, navigation, and the like.

  The collection of applications 124 is exemplary and includes exemplary items such as media player 124A, software framework 124B, computer or software add-in 124C, other applications or even operating system 124D, or operating system itself 124E. . The operating system itself 124E is the opposite of communicating with the aforementioned application 124 via respective interfaces such as the first API 126A, the second API 126B, the third API 126C, and the fourth API 126D. In one embodiment, the service providing UIS 116 may operate directly.

  Some of the data is referenced by the numbers 128A-D, but is collectively referred to herein as the number 128, between the presentation area 118 and the client UIS 114, or between the client UIS 114 and the service provider 116. Can convey the concept that data generally moves. More specifically, however, the data portion 128A corresponds to the data that arrives from the presentation area 118 to the client UIS 114, and the reference number 128B refers to the data that is exchanged from the API 112 to the service providing UIS 116, Portion 128C points to data communicated from service providing UIS 116 to API 112, and data portion 128D points to data transmitted from client UIS 114 to presentation area 118. The data flow is shown in block diagram form for purposes of illustration. Although the actual data flow may differ from that shown due to the actual nature of the data flow, such is contemplated within the scope of the claims.

  The shapes and symbols used in FIG. 1 should not be construed as trying to conform to essentially any flow diagram where a particular shape means a particular thing. Rather, the figures illustrate various practical applications and some of the advantages of the technology realized by the present invention with pictures. For example, a method of exemplifying the concept of an application program interface using a puzzle piece is used. For example, FIG. 1 shows that the client UIS 114 is compatible with the API 112.

  The service providing UIS 116 is associated with a group of APIs 126A-126D that interact with various software applications 124. As used herein, the term “software application” is used in a broad sense and considers executable files, libraries, other software components, etc. used within a computing system. As shown, the first API 126A can facilitate interaction with the specific media player 124A. Although not shown in the figure, different APIs can be used to interact with different media players, or all media players can interact with the first API 126A. . Similarly, framework 124B may require API 126B to communicate. Exemplary frameworks include “.NET Framework” provided by Microsoft Corporation.

  Another example where a customized interface needs to communicate with the serving UIS 116 includes an add-in 124C interface that uses a third API 126C. Attempting to enumerate all of the various APIs associated with interacting with the many available software applications will defocus the present invention. Accordingly, ellipses are shown to indicate that more APIs than those shown in FIG. 1 are specifically contemplated herein. The last exemplary API, fourth API 126D, is shown as being used to interact with other applications or operating system 124D. Of course, the service providing UIS 116 can interact directly with the operating system 124E or directly with various other software programs.

  However, according to one embodiment of the present invention, the client UIS 114 does not need to recognize the first API 126A, the second API 126B, etc., or even recognizes a direct link with the operating system 124E. Although not required, it is sufficient to know how to interact with the service providing UIS 116 via the API 112 and can sufficiently interact with other components indirectly.

  The client UIS 114 can present a customized display 118 to the user. As input data is received from the user via the customized client UIS 114, the data can be passed to the serving UIS 116 via the API 112. The service providing UIS 116 coordinates the performance of various tasks sought by the client UIS 114. In this way, developers are given the opportunity to customize the display without dealing with compatibility issues associated with developing their own full-fledged shells, such as service offering UIS 116.

  In one embodiment of the invention, the serving UIS 116 does not display its own components in the presentation area 118 itself, but rather facilitates the display of such components by the client UIS 114 via the API 112. 10 feet UIS. In this embodiment, the client UIS 114 is an alternate 10 foot UI (an alternative to the UIS 116) customized with respect to the serving UIS 116. The API 112 has been referred to in the singular form for convenience and will continue to do so, but as previously described, the present invention believes that the API 112 can be comprised of multiple application program interfaces. In the present invention, among others, software vendors expose these APIs that can present what they want to present via an alternative shell, such as client UIS 114.

  In one embodiment, the service providing UIS 116 receives data, tasks, etc. received by the client UIS 114 and passed to the service providing UIS 116 so that those tasks can be easily performed, if applicable. The client UIS 114 is serviced so that the data can be returned to the client UIS 114 and used for applications including presenting the data in the presentation area 118.

  In one embodiment, the serving UIS 116 may be a modified version of the UIS that presents the data itself as is conventionally viewable by the user. In the modified state, rather than presenting the component itself, the serving UIS 116 facilitates the display of data sought by the client UIS 114 using strategies related to the graphical display. In one aspect, the serving UIS 116 operates in an invisible mode and services third party applications such as the client UIS 114.

  Thus, without the serving UIS 116, the client UIS 114 needs to know how to interact directly with the software application 124, but using one embodiment of the present invention, the client UIS 114 That is not necessary. The client UIS 114 needs to be configured to only interact with the serving UIS 116 through the API 112. Similarly, a software developer, such as the manufacturer of software application 124, can continue to develop products that operate in conjunction with a single API, such as one of APIs 126A-126D. Consider an illustrative example in which a first API 126A represents an API that allows a service providing UIS 114 to operate in conjunction with a media player. The media player developer does not need to provide the software 124A over and over again to cooperate with both the UIS 116 and the client UIS 114. Rather, the media player developer may cooperate with the service providing UIS 116.

  Returning briefly to FIG. 1A, the client UIS of the different vendor 140 is shown with the client UIS of the different vendor 142. Using one embodiment of the present invention, media player 124A (or any application) does not need to care about various client 10 foot UI shells such as client UIS 140 or 142. Note that UIS 140 and 142 are pictorially shown to have arms that are compatible with API 112 and designed to interact with each other. This is because API 112 is the only API that alternative UI developers need to be concerned about. If the UI developer can create a UI that uses the API 112 associated with the service provisioning UIS 116, the developer is free to use the service provisioning UIS 116 because of the nature of the service provisioning UIS 116. Use indirect control of the application. The service providing UIS 116 can operate as a standard execution environment so that the client UI shell (114, 140, 142, etc.) and the application 124 need only test against the service providing UIS 116.

  Returning now to FIG. 2, an exemplary method for facilitating interaction with a computing device is shown and is generally referred to by the number 200. The steps of process 200 are described in connection with the components described in FIG. 1A. The following steps are of only one embodiment, but are intended to be exemplary in nature and should not be construed as limiting in nature, rather, one embodiment of the present invention. The purpose is to illustrate various functional aspects.

  In one embodiment, user input is received by client UIS 114 at step 210. This user input selects an expression in the presentation area 118, a mouse click, a keyboard command received from the wireless keyboard, for example, a stimulus received from a remote control such as playing a song or video from the selection area 120, etc. It may be of a nature. User input is not limited to human input, but in some embodiments, input received from other machines or components of the same machine can be considered.

  In step 212, the data is communicated to the serving UIS 116 based on the user input received in step 210. In one embodiment, this data communicated may be data component 128A. Data 128A may be the raw data received via the user input in step 210, or may be a modified form or addition thereof. An example embodying this concept is shown below.

  The user may wish to navigate to a particular channel, and data 128A includes a specification of the desired channel and an instruction set associated with presenting a display area that displays the desired television program. Includes both. Accordingly, in step 214, the serving UIS coordinates the performance of the task associated with the data received in step 212. These tasks can take a variety of forms. In the following paragraphs, a limited and exemplary variety that may be required by or associated with the client UIS 114 and facilitated in connection with the serving UIS 116. A list of important tasks.

  The first exemplary task includes enumerating compatible applications. As already mentioned, applications that run on a 10 foot UI are generally configured differently than those that run on a 2 foot UI. For various reasons, it is convenient to know what software applications installed on a computer system are compatible with a particular UIS. Because the client UIS 114 is indirectly compatible with the application 124 thanks to the service providing UIS 116, the client UIS 114 may want to know what applications are available to interact with each other. This task can also include naming various compatible software applications, where they are located, features they have, icons and other attributes associated with the application including metadata, and so forth. Enumerating applications includes extracting any extractable attribute that is associated with any application that is available and compatible with client UIS 114.

  Other exemplary tasks include filtering the application based on the respective function and / or attribute. Here, the client UIS 114 may want to recognize or identify all applications that include a particular attribute, such as an application that requires a sound card (substantially anything). This task involves specifying resources and functions and then querying or otherwise determining a software application that meets the given criteria from a pool of available resources. Thus, the client UIS 114 can identify all applications that can be used, for example, to present an image, play a video, or record a recording.

  Other exemplary tasks include presenting data to the user. Client UIS 114 must present data in presentation area 118 according to a customized format. However, in order to interact with various hardware and / or software components, the service providing UIS 116 facilitates such presentation. Even though the client UIS 114 can ultimately control the various complex parts associated with presenting the components as shown in the presentation area 118, the serving UIS 116 works with the client UIS 114. And provides data used in connection with presenting various display components. One embodiment of the present invention includes the client UIS 114 following the client UIS when UI or other data is presented on one (or more) display devices. As such, the client UIS 114 can allow the service providing UIS 116 to present display data associated with an application, such as the application 124, in accordance with the service providing UIS 116.

  In another exemplary task, the client UIS 114 can instruct the serving UIS 116 to launch an application, such as one of the software applications 124A-E. Here, the client UIS 114 can specify and identify or refer to the desired application to be launched and use data such as data 128A passed to the service providing UIS 116 to The provided UIS 116 facilitates launching of the desired application. Environmental parameters such as screen size, window type, and position could also be passed as data 128A.

  In other tasks, the service providing UIS 116 retains a means to control the service providing UIS 116 while performing other tasks. For example, while the serving UIS 116 is performing a first task, the user may, for example, issue a command to the computer to move the icon or resize the window thanks to the client UIS 114. Such a command could be passed to the serving UIS 116, even if it facilitates the execution of other tasks at the same time.

  Other tasks include modifying a particular event that the serving UIS 116 should know or notifying the client UIS 114 of a particular event that the serving UIS 116 should know. For example, control can be returned to the client UIS 114 when the service providing UIS 116 completes the task. This event that ends the activity is something that the client UIS 114 must be aware of so that it can be prepared to take over control. The serving UIS 116 may also send feedback such as error conditions, UI component movement, resizing, etc.

  Other exemplary tasks include facilitating callbacks for additional APIs that are returned to the alternate shell, the client UIS 114. In other words, this task makes the client UIS 114 aware of what the serving UIS 116 considers to be recognized. The service UIS 116 notifies the client UIS 114 of any events or events that may be known to be recognized, for example. In some present embodiments, this task takes the form of transferring data to the client UIS 114. For example, consider an embodiment where the user indicates that he wants to record a particular television program. The input comes via the client UIS 114, which then communicates the request to the serving UIS 116. Although no information can be given except for the indication of the program to be recorded, the service UIS 116 also recognizes other functions that must be performed with respect to facilitating recording of the desired program. There is a case. Accordingly, the serving UIS 116 can return recording information to the client UIS 114 to use its own recording component or some other recording application. In many cases, the service providing UIS 116 has its own ability to perform events such as video recording. However, some of the client UIS 114 may include a video recording component (or image display component, audio presentation component, etc.). In this case, client UIS 114 presents a customized display associated with recording and / or playing a video program. And, for example, it may be configured to present a customized UI, although it needs to interact with a device such as a video capture card. As such, it initiates a request to the serving UIS 116 to facilitate the complex work associated with recording a program, and the client UIS 114 is consistent with its recording component or other recording components. Data can be returned that allows a program event to possibly be recorded. This task provides data related to requests from client UIS 114.

  Another exemplary task includes the client UIS 114 performing a method for adding additional functionality to the serving UIS 116. That is, the service providing UIS 116 can be configured to grow or evolve according to the data provided by the client UIS 114 to the service providing UIS 116. This task includes leaving an alternative shell, such as client UIS 114, to extend the API set associated with a serving UIS 116, such as API 112. An illustrative example of such a task can be something similar to the way a client UIS would like to present a certain display box in the presentation area 118 at some point, such as at startup. . Perhaps an image is displayed or text or a small video clip is displayed. Additional APIs that interact with the window can be published so that the client UIS 114 can display what it wants to display in the window. If the API 112 does not have an instruction set for facilitating such mutual exchange, this task has a function for supplementing the API 112 with a function for performing such mutual exchange.

  Other exemplary tasks relate to the ability to persist events in the background or foreground while other changes are occurring. An exemplary embodiment of such a task is described with reference to inset 122. The inset 122 is a region of the UI where events (displaying videos, presenting images, showing camera feeds, etc.) can be continuously executed while changes occur in the background. For example, inset 122 may play a particular video recording while the user is navigating music or video or images through selections made by selection area 120. Further details of such insets are described in the aforementioned copending application No. 10 / 174,619. In this pass, an alternative shell, such as client UIS 114, can pass information related to the event of inset 122 to serving UIS 116, which inset 122 has undergone a background example change. You can keep doing what you are doing in the meantime. In the absence of the client UIS 114, the service provision 116 is the only UIS and the service provision UIS 116 has access to various hardware or software components 124, so events are persisted to insets such as 122. Can be displayed or presented. In this task, the client UIS 114 can do something similar, i.e., continuously display what is displayed in the inset 122. Thanks to the API 112, the client UIS 114 can present an inset 122 or multiple instances of the inset (not shown in the figure for clarity).

  Other exemplary tasks include providing negotiation of the use of different system resources between the client UIS 144 and the serving UIS 116. Consider a situation where a user is watching a video being presented by client UIS 114, for example. The user then activates a command to change to a specific channel. However, such actions may not have been intentional, such as when a child is playing with a remote control while others are watching a video. In this case, perhaps confirmation is desired before the video is stopped and actually switched to the indicated channel. In this situation, an instantaneous task allows the client UIS 114 to ask the user as to whether he wants to match the desired channel, does nothing, etc. In this example, a negotiation between two different system resources, such as resources associated with playing a movie and resources associated with navigating to and / or playing a channel of a program. Was necessary. Rather than having the client UIS 114 have to know how to complete such negotiation, the serving UIS 116 can facilitate such negotiation.

  Another exemplary task that the service providing UIS 116 can facilitate is associated with initializing a device or service that requires initialization. For example, when a user unpacks a new PC and plugs it into an electrical outlet, a particular product offering may need to be configured first. For example, viewing a television program may require the PC to recognize the user's content provider, geographic location, time zone, and the like. Users may be asked to perform such initialization when there is no alternative shell, such as client UIS 114, but their presentation is suppressed by the serving UIS 116 in one embodiment. In one embodiment, such initialization can be delayed until the user requests a service that requires such initialization. This request is received via the client UIS 114 and communicates the data to the serving UIS 116 through the API 112, and then causes the client UIS 114 to present and collect the data that requires such initialization. Is supplied to the client UIS 114. In this way, the client UIS 114 can even customize the initialization of services that require initial configuration and the like.

  Although the number of example tasks is large, the above and last example tasks are listed to convey the spirit and broad scope of tasks that can be facilitated by the presence of API 112. The last exemplary task that can be performed thanks to the presence of the API 112 is a legacy remote control that may be designed to work with the serving UIS 116 along with the client UIS 114. Is to be able to use it.

  Thus, referring to FIG. 2, after completing at step 214, the next step in one embodiment of the present invention is to actually complete the task at step 216. Any data related to performing these tasks can be received at step 218. The foregoing refers to several cases where data can be returned from an application, such as application 124, or a hardware device in connection with performing the requested task. The data or changes can then be received at the serving UIS 116 at step 220. If this data needs to be formatted or supplemented or otherwise modified, things such as passed to UIS 114 at step 222 can be performed, which Embodiments can include returning control to the client UIS 114. This then allows the client UIS 114 to present the appropriate output to the user at step 224.

  Next, at a lower level, some exemplary embodiments are described. Additional examples and technical disclosure are provided for purposes of disclosure. The examples and exemplary API structures should not be construed as limiting the invention. The invention is defined by the appended claims. The following modules expose various functional aspects of API 112 in one or more embodiments. Furthermore, the following list of exemplary modules and syntax is by no means exhaustive and is intended to be exemplary.

<Low level explanation>
An external or alternative shell, such as client UIS 114, can receive a list of DUI applications installed on the system and their entry points using a component referred to herein as “IExtensibilityApplications :: GetFilteredEntryPoints”. The client UIS 114 can then instruct the serving UIS 116 to launch the installed application 124 by using a component referred to herein as “IExtensibilityApplications :: LaunchEntryPoint”. The client UIS 114 can also launch the application 124 with a URL that is not associated with an installed application by using a component called “IExtensibilityApplications :: LaunchUrl” herein. The functions of these three components are important functions compared to the specific embodiment. However, some exemplary embodiments are summarized in the following table as only one means of implementing the above functionality. These should not be construed as limiting the invention, but are defined in the appended claims. After the hosted application is launched, it can control and command the serving UIS 116 using a component referred to herein as “IextensibilityHostControl”. Exemplary functions include exposing a control that closes the window, maximizes the window, minimizes the window, sets the size and position of the window, or blocks execution until the window is closed.

  What is shown in Table 1 is just one illustrative example of a syntax for instantiating the occurrence of “IExtensibilityApplications :: GetFilteredEntryPoints”. Those skilled in the art will appreciate that there are many ways to perform the same function using different syntaxes, and that are considered within the scope of the appended claims.

  What is shown in Table 2 is just one illustrative example of a syntax for instantiating the occurrence of “IExtensibilityApplications :: LaunchEntryPoint”. Those skilled in the art will appreciate that there are many ways to perform the same function using different syntaxes, and that are considered within the scope of the appended claims.

  What is shown in Table 3 is just one illustrative example of a syntax for instantiating the occurrence of “IExtensibilityApplications :: LaunchUrl”. Those skilled in the art will appreciate that there are many ways to perform the same function using different syntaxes, and that are considered within the scope of the appended claims.

  Four exemplary interfaces that consist of or are exposed to API 112 with respect to serving UIS 116 are shown in Table 4.

  Next, the low level details of each of the methods in Table 4 are described. In one embodiment, the IExtensibilityApplications interface exposes methods as described in Table 5.

  The second method shown in Table 4 is referred to herein as the “IExtensibilityEntryPoint” interface and consists of an API 112 or an API so that an alternative shell, such as the client UIS 114, can find the entry point attribute. This is the name given to the component published by 112. Table 6 shows some exemplary methods exposed by IExtensibilityEntryPoint.

  The third method shown in Table 4 is referred to herein as “IExtensibilityHostControl” and consists of or exposed by API 112 to control the window that is opened when the application is launched. Is the name given to the component to be created. Table 7 shows some example methods exposed by IExtensibilityHostControl.

  The fourth and last exemplary method shown in Table 4 is referred to herein as “IExtensibilityHostEvents” and consists of or is exposed by API 112 to represent service window events. The name given to the component. Table 8 shows some example methods exposed by IExtensibilityHostEvents.

  Again, the essence of programming is often individualistic as there are many ways for a programmer to skin a cat. This is not a copyright application, but a patent application. While this disclosure supports the appended claims, it is the claims that define the invention.

<Example operating environment>
With particular reference to FIG. 3, an exemplary operating environment for implementing the invention is shown and generally designated as computing device 300. The computing device 300 is only one example of a suitable computing environment and is not intended to suggest any limitation as to the scope of use or functionality of the invention. Neither should the computing environment 300 be interpreted as having any dependency or requirement relating to one illustrated component or combination thereof.

  The present invention is described in the general context of computer code or machine-usable instructions, including computer-executable instructions, such as program modules, executed by a computer or other machine, such as a personal data assistant or other handheld device. be able to. In general, a program module that includes routines, programs, objects, components, data structures, and the like refers to code that performs a particular task or implements a particular abstract data type. The present invention can be implemented in various system configurations including handheld devices, consumer electronics, general purpose computers, and more specifically computing devices. The invention may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network.

  With reference to FIG. 3, the computing device 300 includes a memory 312, one or more processors 314, one or more presentation components 316, input / output ports 318, input / output components 320, and an exemplary power source 322. A bus 310 is provided that couples the devices directly or indirectly. Bus 310 may be one or more buses (such as an address bus, a data bus, or a combination thereof). The various blocks in FIG. 3 are shown as lines for clarity, but in practice it is not so obvious to draw the various components, and these lines are metaphorically, more precisely gray. It becomes ambiguous. For example, a presentation component such as a display device can be regarded as an I / O component. The processor includes a memory. We understand that this is the nature of the technology, and to reiterate, FIG. 3 illustrates exemplary computing that can be used in connection with one or more embodiments of the invention. It merely illustrates the device. No distinction is made between categories such as “workstation”, “server”, “laptop”, “handheld device”, etc., all within the scope of FIG. 3, and references to “computing devices”.

  Computing device 300 typically includes a variety of computer readable media. For example, without limitation, computer readable media may include random access memory (RAM), read only memory (ROM), electronically erasable programmable read only memory (EEPROM), flash memory or other memory technology, CDROM, digital To encode and access by a computing device 300 a multipurpose disc (DVD) or other optical or holographic media, magnetic cassette, magnetic tape, magnetic disc storage device or other magnetic storage device, carrier wave, or desired information Other media that can be used in

  The memory 312 includes computer storage media in the form of volatile and / or nonvolatile memory. The memory can be removable, non-removable, or a combination thereof. Exemplary hardware devices include solid state memory, hard drives, optical disk drives, and the like. Computing device 300 includes one or more processors that read data from various elements, such as memory 312 or I / O component 320. The presentation component (s) 316 sends a data indication to the user or other device. Exemplary presentation components include display devices, speakers, printing components, vibration components, and the like. Using the I / O port 318, the computing device 300 can be logically coupled to other devices including the I / O component 320, and some can be embedded. Exemplary components include a microphone, joystick, game pad, satellite dish, scanner, printer, wireless device, and the like.

  Many different arrangements of the various components shown, as well as those not shown in the figures, are possible without departing from the spirit and scope of the present invention. The embodiments of the present invention have been described by way of example and not limitation. Other embodiments that do not depart from the scope will be apparent to those skilled in the art. One skilled in the art can develop alternative means of implementing the above improvements without departing from the scope of the present invention.

  Some features and subcombinations are useful, can be used without reference to other features and subcombinations, and are considered to be within the scope of the claims. All steps shown in the various figures need not be performed in the specific order described.

1 is a block diagram illustrating an exemplary embodiment of the present invention. FIG. 4 illustrates an example alternative client UI shell according to an example embodiment of the invention. 4 is a flow diagram illustrating the steps of an exemplary embodiment of the invention. FIG. 2 is an exemplary operating environment suitable for implementing an embodiment of the present invention.

Claims (7)

A method of presenting a component of a presentation UIS that is a second displayable interface that works in conjunction with a service providing user interface shell ( UIS ) that is a first displayable interface, the method comprising:
The service providing UIS receives data from the presentation UIS indicating one or more tasks to be completed;
Using one or more applications that are coupled to the service providing UIS, the one or the completion of a plurality of tasks comprising the steps of the service providing UIS is adjusted, the serving UIS said one or more Interacting directly with the application and adjusting is as follows:
Issuing a set of commands to the one or more applications coupled to the serving UIS;
Receiving return data from the one or more applications in connection with issuing the set of commands;
Including steps , and
Method characterized by comprising the steps of the service providing UIS to return control to the presentation UIS. The one or more tasks are:
Processing return data returned from the one or more applications and rendering a presentation to the user based on the return data;
Allowing the presenting UIS to instruct the service providing UIS to launch an application;
Allowing the presentation UIS to specify a reference to an application;
Allowing the presentation UIS to specify environmental parameters;
Controlling aspects of the service providing UIS;
Calling back to the presentation UIS for additional APIs ;
Enumerating applications compatible with the service providing UIS;
Filtering the compatible application based on one or more attributes associated with the compatible application;
Providing the method by which the presenting UIS supplements the functional aspects of the service providing UIS;
Negotiating the use of one or more system resources between the serving UIS and the presenting UIS;
Providing a persistent presentation of a media experience when a presentation change of the presentation UIS occurs;
Initializing the media programming guide;
Configure resource devices and
The method of claim 1 , comprising at least one of: Allowing the presenting UIS to specify a reference to an application includes specifying a location of the application;
The environmental parameters include: a window mode attribute that includes whether the window is minimized, maximized, modal, resizable, or given size, the screen location presenting the object, The method of claim 1, comprising one or more. Controlling the manner of the service providing UIS is claims, characterized in that it comprises resizing the items, altering the visual attributes of an item, and / or to specify an alternate reference including the URL The method according to 1 . Filtering the compatible application based on one or more attributes includes filtering the compatible application based on dependencies on other resources, wherein the other resource is a peripheral device. The method of claim 1, comprising one or more of a device or other application. The steps to provide a persistent presentation of the media experience are:
Presenting a slideshow,
Video presentation including camera feed presentation;
Audio presentation,
The method of claim 1, comprising providing one or more persistences of presentation of data.   A computer-readable recording medium storing computer-executable instructions for causing a computer to execute the method according to claim 1.

Images