# Patent

## Title
Updating data-consuming entities

## Abstract

This document describes tools capable of updating data-consuming entities. These tools allow a developer of an application to use data binding to update data-consuming entities without the need to write custom code.

## Background
BACKGROUND
Many conventional computer programs use data-consuming entities that access data from one or more data locations. Data binding is one common approach by which entities access this data. Data binding is achieved, in part, through custom code created for and located on the computer program having the data-consuming entities.
This custom code, however, may require updates for each computer program or other time-consuming management. For example, some custom code may rely on management by a software developer that does not have sufficient skill to easily manage the custom code, such as when the custom code is written by one developer and managed by another. Further, even the most skilled developer may inadvertently or maliciously cause problems for a provider of data. Because of this, some data providers do not want to enable developers to alter or otherwise manage the custom code.
SUMMARY
This document describes tools capable of updating data-consuming entities. These tools allow a developer of an application to use data binding to update data-consuming entities without the need to write custom code.
This Summary is provided to introduce a selection of concepts in a simplified form that are further described below in the Detailed Description. This Summary is not intended to identify key or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter. The term “tools,” for instance, may refer to system(s), method(s), computer-readable instructions, and/or technique(s) as permitted by the context above and throughout the document.



BRIEF DESCRIPTION OF THE DRAWINGS
The detailed description is described with reference to the accompanying figures. In the figures, the left-most digit of a reference number identifies the figure in which the reference number first appears. The use of the same reference number in different instances in the description and the figures may indicate similar or identical items.
FIG. 1 is an illustration of an environment in which data binding may be used in an application without the need for custom code.
FIG. 2 is a flow diagram depicting an example process for indirectly binding data through an external entity.
FIG. 3 is a more-detailed illustration of an example of indirect data-source module 116 of FIG. 1.
FIG. 4 is an illustration of an example web application and user interface.
FIG. 5 is a flow diagram depicting an example process in which the tools provide indirect data binding for an application.
FIG. 6 is a more-detailed illustration of an example of external data-management module 108 of FIG. 1.



DETAILED DESCRIPTION
Overview
This document describes tools capable of allowing a developer of an application to use data binding without the need to write custom code. The tools may be distributed in a software development kit provided to the developer. Full control of the custom code needed to do the data binding remains in the hands of the makers of the software development kit. This may provide increased reliability of developed applications and save development time and money.
In one embodiment, the tools use an external entity that manages data at data locations. This external entity is deployed on the computing device running the application but is external to the application. The tools may also contain a module to be embedded within the application. This internal module communicates with the external entity and enables a developer to declare a data path for one or more data-consuming entities relative to the internal module. The developer may then assign the internal module a data-location path, which the internal module may register with the external entity. The external entity then monitors the data-location path for appropriate data updates. When the external entity detects a change to the data it passes the data on to the internal entity. The internal entity updates the data-consuming entities with the changed data to which they are bound.
By so doing the tools not only enable a developer to update the data-consuming entities without the need to write custom data-binding code, the tools may also enable a change to the data location, such as moving the data from one server to another, to be easily handled by a simple change to the data-location path within the application.
Example Environment
FIG. 1 is an illustration of an example environment 100 in which the tools may enable an application to bind to data without the need for custom code within the application. Environment 100 includes a first computing device 102. Examples of computing device 102 include a set-top box, a personal computer, a media player, and a smart phone to name a few. Computing device 102 includes one or more processors 104 and computer-readable media 106. Computer-readable media 106 contains or has access to an external data-management module 108, one or more applications 110, and one or more optional device-local data locations 112.
External data-management module 108 is external to applications 110 and configured to manage data located at data locations, such as data location 112. In this environment, device-local data locations 112 are local to computing device 102 but not located within applications 110. External data-management module 108 enables developers of applications 110 to manage data from a variety of data locations. External data-management module 108 may filter the data from data locations 112, such as based on a current state of computing device 102, user preferences, or other information. In another embodiment, external data-management module 108 is located on a different computing device and has remote access to information on computing device 102.
Each of applications 110 can be of varying different types, such as a web application, a web service, a word processor, or an executable. Applications 110 may contain one or more data-consuming objects 114, indirect data-source modules 116, and/or application-local data locations 118. Each or either of these data locations 112 and 118 contains data that one or more data-consuming objects 114 may consume. A device-local data location (e.g., 112) may be located on a permanent or removable computer-readable storage medium, such as a DVD, compact disk, USB flash drive, or USB hard drive.
Data-consuming objects 114 are objects that use and/or display data. Some examples include an audio/video recording object, an audio/video/image displaying object, a text box, a button, or a combo box. Each of data-consuming objects 114 is configured to reference data indirectly through indirect data-source modules 116. Indirect data-source modules 116 are configured to communicate with external data-management module 108. Indirect data-source modules 116 inform external data-management module 108 of a data location that external data-management module 108 will manage. Indirect data-source modules 116 may receive data updates from external data-management module 108. Indirect data-source modules 116 may also communicate data updates to those data-consuming objects 114 that want to consume the data.
Data-consuming objects 114 may also or instead reference data directly through external data-management module 108. In this case each of data-consuming objects 114 has code embedded to carry out the duties of indirect data-source module 116. Application-local data locations 118 are data locations within the application that may be directly or indirectly bound to. An example of data at such a location is an application's version information, to which a data-consuming object 114 may bind in order to display such information to the user.
Computing device 102 is optionally configured to communicate with one or more remote computing devices 120, such as a server computer, a personal computer, a media player, or an external storage device. Remote computing device 120 includes one or more processors 122 and computer-readable media 124. Computer-readable media 124 contains or has access to one or more remote data locations 126. Remote data locations 126 contain data that one or more data-consuming objects 114 may consume. Computing device 102 may communicate through a communication network 128 with computing device 120. Communication network 128 may be any network enabling communication between any two or more of the computing devices, such as the Internet, a local-area network, a wide-area network, a wireless network, a USB hub, or a combination of these.
A few examples of data locations 112, 118, and 126 include a computer file/folder, a database, a data variable, a web page, or a web service. Data contained at such data locations 112, 118, or 126 may be of any type, such as one or more family photos, recorded movies, television shows, songs, streaming movies, television show times, media channel lists, pictures, prices and descriptions of goods for sale, application data fields, hyperlinks, or text characters to be displayed. These are not meant to be exhaustive lists of examples. The tools are intended to be used with any sort of data to which any sort of data-consuming object 114 may be bound.
Generally, any of the functions described herein can be implemented using software, firmware, hardware (e.g., fixed-logic circuitry), manual processing, or a combination of these implementations. The terms “tool” and “module,” as used herein generally represent software, firmware, hardware, whole devices or networks, or a combination thereof. In the case of a software implementation, for instance, a module may represent program code that performs specified tasks when executed on a processor (e.g., CPU or CPUs). The program code can be stored in one or more computer-readable memory devices, such as computer-readable media 106 and/or 124. The features and techniques of the tools are platform-independent, meaning that they may be implemented on a variety of commercial computing platforms having a variety of processors.
Example Process for Indirectly Binding Data Through an External Entity
The following discussion describes ways in which the tools may operate to enable an application to bind to data without its developer needing to write data-binding code. Aspects of this and other processes described herein may be implemented in hardware, firmware, software, or a combination thereof. These processes are shown as sets of blocks that specify operations performed by the tools, such as through one or more modules or devices and are not necessarily limited to the order shown for performing the operations by the respective blocks. In portions of the following discussion reference may be made to environment 100 of FIG. 1 as well as to FIGS. 3, 4, and 6.
FIG. 2 is a flow diagram depicting an example process 200 for binding to data by registering with an external entity that handles the data-binding functionality. An example user interface and system layout is described as part of this example process, though other user interfaces and system layouts are also contemplated.
Block 202 registers a data-location path with an external entity. The data-location path is first defined by the developer within the application. The data-location path is a path to a data location that contains data to which one or more data-consuming entities in the application may wish to bind. Registering the data-location path with the external entity may involve communicating the data-location path to the external entity. The external entity may then monitor the data location specified by the data-location path. In another embodiment, both the external entity and the application are provided with a pre-defined data-location path and block 202 may be skipped.
By way of example, consider FIGS. 3 and 4. FIG. 3 illustrates a detailed example of indirect data-source module 116 of FIG. 1. Indirect data-source module 116 includes data-location path 300, data buffer 302, and data-provider module 304. The information stored in data-location path 300 is assigned (e.g., by a developer) to an application, such as the web application depicted in FIG. 4 at 400. The labels of FIG. 4 correlate to the proper names used in the example markup shown in Table I below.








TABLE I







1
<Page>


2
<Video1 DataSource=”{Binding Source=IndirectDataSourceA,



path=myTuneUrl[1]}” />


3
<Text1 DataSource=”{Binding Source=IndirectDataSourceA,



Path=myValues[1]}” />


4
<Button1 DataSource=”{Binding Source=IndirectDataSourceA,



Path=myButtonHRef[1]}” />


5
<DataSource id=”IndirectDataSourceA”



Url=”http://www.contoso.com/webservice.aspx” />


6
</Page>









Web application 400 includes a user interface 402. User interface 402 includes a video-playing object 404 named Video1, a text-box object 406 named Text1, and a button object 408 named Button1. These objects are all examples of data-consuming objects 114 of FIG. 1 and the data-consuming entities of this method. Web application 400 also includes an example of indirect data-source module 116, here named IndirectDataSourceA 410. IndirectDataSourceA 410, while not displayed to the user of the application, performs a role in the example embodiment. As shown in lines 2-4 of the example markup in Table I, each object references IndirectDataSourceA 410 as its data-binding source. On the fifth line of the example markup, IndirectDataSourceA 410 is assigned a Uniform Resource Locator (URL) to a web service. The URL is provided as an example, though a Uniform Resource Identifier (URI), which may include a URL or a Uniform Resource Name (URN), as well as arbitrary user-defined names may be used. This example URL is stored as data-location path 300 of FIG. 3 and is an example of a data-location path registered in block 202 of FIG. 2. The path values in lines 2-4 of the example markup (Table I) reference specific data values at a data location specified by data-location path 300.
Block 204 receives a notification of changed data from an external entity. This notification may be responsive to the data being checked by the external entity for the first time or because the data has changed since last checked. Block 206 communicates a request for the changed data to the external entity. Block 208 receives the changed data from the external entity. Block 210 updates any bound data-consuming entities with the changed data. In some embodiments, the external entity is configured to automatically communicate the changed data. In such an embodiment, blocks 204 and/or 206 may be skipped.
Continuing the ongoing example, indirect data-source module 116 receives a notification from the external entity as in block 204. The notification informs indirect data-source module 116 that data at the data location specified by data-location path 300 has changed. Indirect data-source module 116 then communicates a request for the changed data to the external entity as in block 206. Upon receiving the changed data (block 208), indirect data-source module 116 stores the changed data in data buffer 302. Indirect data-source module 116 then updates Video1 404, Text1 406, and Button1 408 with the changed data as in block 210 of FIG. 2. This updating is performed by data-provider module 304, which informs the objects of the changed data. The objects then retrieve the changed data from data buffer 302.
For example, the data updated can be a URL of video content for Video1 404 to play. Video1 404 retrieves this data from data buffer 302 via path mytuneUrl[1] of Table I. The data updated can be a text description of the video content for Text1 406 to display. Text1 406 retrieves this data from data buffer 302 via path myValues[1] of Table I. The data updated can be a link to a button to display as Button1 408. Button1 408 retrieves this data from data buffer 302 via path myButtonHRef[1] of Table I. Alternatively, in some embodiments data-provider module 304 actively updates a data field within the objects with the changed data. In those embodiments the paths described above are a data variable within each object but accessible by data-provider module 304. Data-provider module 304 actively sets those variables to the new data value in those embodiments.
Example Device
Applications, such as application 400, may be used in various devices. Consider, by way of example, a set-top box connected to a television. Application 400 may run on such a set-top box and with it a user can preview channels to find something to watch. A user can preview a video in Video1 404 and read the description of what is playing in Text1 406 to decide if he wants to watch it. When a desired channel is found the user may press Button1 408. In the background, the external entity downloads a list of channels from “webservice.aspx” (Table I, line 5). It then changes the data periodically (e.g., to proceed to the next channel preview). Indirect data-source module 116 is informed of the changed data and communicates a request for the changed data. Responsive to receiving the changed data, indirect data-source module 116 updates Video1 404 and Text1 406 objects. These objects then show the updated channel-preview information. Application 400 may forgo code capable of knowing that this is occurring. Application 400 may simply display whatever data the external entity tells it to display. Once Button1 408 is selected, the external entity stops changing the data and application 400 remains on the chosen channel.
Example Process for Providing Indirect Data Binding for an Application
FIG. 5 depicts a process 500 in which the tools provide indirect data binding for an application. An example user interface and system layout is described as part of this example process, though other user interfaces and system layouts are also contemplated.
Block 502 receives a registration containing a data-location path, such as data-location path 300 of FIG. 3. The registration can be received from a module located within an application running on the same computing device as this process. The data-location path specifies a data location at which data is located. The internal module registers the data-location path on behalf of one or more data-consuming entities that wish to bind to the data.
By way of example, consider FIG. 6. FIG. 6 illustrates a detailed view of an example of external data-management module 108 of FIG. 1. For purposes of this example, external data-management module 108 performs this process. External data-management module 108 includes one or more data-location-management modules 602. Each data-location-management module 602 manages one data location and includes data-location path 604, data-binding module 606, and data buffer 608. In block 502 data-location path 604 is populated with the data-location path contained within the registration.
Block 504 detects a change to data at the data location. Continuing the ongoing example, data-binding module 606 connects with and understands data at the data location. Data-binding module 606 monitors the data for changes. It detects changes and downloads relevant data into data buffer 608. Block 506 communicates a notification to the internal module informing it that data at the data location has changed. Continuing the example, if the data has any changes, or if this is the first time checking the data, data-binding module 606 informs internal data-source module 116 of the changed state. Block 508 receives a request for the data that has changed. Continuing the example, data-binding module 606 receives a request for the data from indirect data-source module 116. Block 510 communicates (e.g., sends) the data that has changed to the internal module. In another embodiment the changed data is automatically sent to the internal module. In this other embodiment blocks 506 and/or 508 may be skipped. Continuing the example, data-binding module 606 communicates the changed data to indirect data-source module 116.
In the specific example of a set-top box above, data-binding module 606 can be configured to be aware of a user's selection to preview channels based on information located in the set-top box. From the data location, data-binding module 606 may fetch a list of channels, the descriptions for what are currently on each of those channels, and a view-channel button. Data-binding module 606 stores this information in data buffer 608. Data-binding module 606 then selects the first channel, its text description, and the button link. Data-binding module 606 communicates the data to indirect data-source module 116 for the application to display as described previously. After some time has passed, data-binding module 606 sets the channel and text to the next value and again communicates the changed data to indirect data-source module 116 for the application to display. This continues until the user presses the button, which in this specific example is set to perform a view-button function. The user selects the view button to inform the set-top box that this is the channel he wishes to view.
CONCLUSION
This document describes tools capable of updating data-consuming entities. These tools allow a developer of an application to use data binding to update data-consuming entities without the need to write custom code. Although the invention has been described in language specific to structural features and/or methodological acts, it is to be understood that the invention defined in the appended claims is not necessarily limited to the specific features or acts described. Rather, the specific features and acts are disclosed as example forms of implementing the claimed invention.

## Claims

1. A method comprising:
deploying an application and an external entity on a computing device, the application comprising one or more data-consuming entities and an indirect data-source module;
declaring a data-location path to a data location on a web service that contains data the one or more data-consuming entities may consume and recording the data-location path in the indirect data-source module;
binding the one or more data-consuming entities to the indirect data-source module using a markup language;
registering the data-location path with the external entity, the external entity being external to the application, located on the same computing device on which the application is deployed, and capable of managing data from one or more data locations on the web service;
monitoring, by the external entity, the data at the data location specified by the data-location path and the data consumed by the one or more data-consuming entities;
notifying the application, by the external entity, that the data at the data location specified by the data-location path has changed relative to the data consumed by the one or more data-consuming entities; and
updating the one or more data-consuming entities with the data from the data location.

2. The method as recited in claim 1, wherein the data-location path is an internal property of the indirect data-source module.

3. The method as recited in claim 1, further comprising communicating a request from the application to the external entity for the data that was changed.

4. The method as recited in claim 1, further comprising receiving the data that was changed from the external entity.

5. The method as recited in claim 1, wherein the data-location path is a Uniform Resource Identifier.

6. The method as recited in claim 1, wherein the notification by the external entity indicates that the data location has changed, and wherein the method further comprises updating the data-location path recorded in the indirect data-source module and registered with the external entity when updating the one or more data-consuming entities with the data that was changed.

7. The method as recited in claim 1, wherein the data-consuming entity is a video display object and the data is video content.

8. The method as recited in claim 1, further comprising communicating a request from the indirect data-source module to the external entity for the data that was changed.

9. The method as recited in claim 1, wherein the data location is remote from the computing device.

10. The method as recited in claim 1, wherein updating the one or more data-consuming entities further comprises updating the data-location path recorded in the indirect data-source module and registering the updated data-location path with the external entity.

11. The method as recited in claim 1, wherein the data-location path is pre-defined by a developer of the application.

12. The method as recited in claim 1, the indirect data-source module further comprising a data buffer, the data buffer configured to receive the changed data.

13. The method as recited in claim 1, the indirect data-source module further comprising a data-provider module, the data-provider module configured to inform the data-consuming entities of the changed data and to update the data-consuming entities.

14. A system comprising:
one or more processors; and
one or more tangible computer-readable media having stored thereon computer-executable instructions that are executable by the one or more processors to perform operations including:
deploying an application and an external entity on a computing device, the application comprising one or more data-consuming entities and an indirect data-source module;
declaring a data-location path to a data location on a web service that contains data the one or more data-consuming entities may consume and recording the data-location path in the indirect data-source module;
binding the one or more data-consuming entities to the indirect data-source module using a markup language;
registering the data-location path with the external entity, the external entity being external to the application, located on the same computing device on which the application is deployed, and capable of managing data from one or more data locations on the web service;
monitoring, by the external entity, the data at the data location specified by the data-location path and the data consumed by the one or more data-consuming entities;
notifying the application, by the external entity, that the data at the data location specified by the data-location path has changed relative to the data consumed by the one or more data-consuming entities; and
updating the one or more data-consuming entities with the data from the data location.

15. The system as recited in claim 14, wherein the application is a web application, the one or more data-consuming entities are audio or visual display objects, and the changed data is audio or video content.

16. The system as recited in claim 14, wherein the data-location path is a URL.

17. The system as recited in claim 14, wherein the data-location path is pre-defined by a developer of the application.

18. The system as recited in claim 14, the operations further comprising receiving, by the indirect data-source module, the data that has changed into a data buffer.

19. The system as recited in claim 14, the indirect data-source module further comprising a data-provider module, the data-provider module configured to inform the data-consuming entities of the changed data and update the data-consuming entities.