Live Framework Team Blog

Important Updates to Live Services: Live Framework CTP Unavailable As of Sept 8

2009-08-21T22:54:00Z

This morning, David Treadwell announced that the Live Framework CTP will be unavailable as of September 8. First, a very big thanks to all who tried out our CTP and provided invaluable feedback. All that we learned will be used in future offerings. As David says in his post:

"At the Professional Developer Conference 2008, we gave the developer community access to the technical preview of the Live Framework. The Live Framework is core to our vision of providing you with a consistent programming interface. Now we are working to integrate existing services, controls and the Live Framework into the next release of Windows Live. Your feedback continues to help us build the best possible offerings for Windows Live users, for you and for your customers. "

Read the full announcement here.

Thanks again for your participation,
The Live Framework Team

Notifications and Subscriptions

2009-04-16T21:29:24Z

In this post, we will explain how to make use of notifications in the Live Framework. When you subscribe to a specific resource, the Live Framework provides notifications when changes are made to that resource. This allows you to optimize interactions with the Live Operating Environment (both client and cloud) and only retrieve information when something has changed.

We will use JSON as the wire format for all the examples shown here. All the requests made are authenticated with a delegated auth header or user auth header and are in the context of a particular user.

Step 1

The first thing that the application needs to do is to create a notification queue to receive notifications from subscribed resources. A notification queue is in the context of a user and is bounded by a user’s mesh. The queue can only receive notifications for resources that are part of this user’s mesh. The following HTTP request creates the notification queue.

Request

HTTP POST	
https://user-ctp.windows.net/V0.1/Mesh/NotificationQueues

{
}

Response

{
 "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
 "Categories" : [
     {
         "Label" : "NotificationQueue",
         "Name" : "NotificationQueue",
         "Scheme" : "http:\/\/user.windows.net\/Resource"
     }
 ],
 "Id" : "uuid:3084e6c2-56ac-4563-b67c-af7a7fc019e7;id=18130",
 "LastUpdatedTime" : "\/Date(1237276680000)\/",
 "SelfLink" : "Mesh\/NotificationQueues\/[ID]",
 "Title" : "NotificationQueueResource",
 "ExpirationDuration" : 300,
 "NotificationsLink" : "Mesh\/NotificationQueues\/[ID]\/Notifications",
 "Watermark" : ""
}

The following properties from the preceding code examples are worth noting:

ExpirationDuration: This defaults to 300 seconds. If the client does not poll this notification queue (by executing an HTTP PUT request on the queue itself or HTTP GET on the Notifications feed associated with it) one time every 300 seconds, this queue is deleted. This is because notification queues are short-lived and are not persisted in the database.
NotificationsLink: This is the link to the feed that will contain notifications for all the subscribed resources. It should be cached by the client application.
Watermark: This is an opaque identifier that is used to acknowledge receipt of notifications. More on this property later.

It is important to note that the NotificationQueues feed only supports HTTP POST operations. Each entry within this feed (each NotificationQueue) only supports HTTP PUT operations.

Step 2

When the application has a notification queue in place, it now needs to create a subscription for a resource. For this, the application needs to execute an HTTP POST request on the Subscriptions feed for the resource from the notification queue that the application created.

The following code sample creates a subscription for a mesh object::

Request

HTTP POST	
https://user-ctp.windows.net/V0.1/Mesh/MeshObjects/[ID]/Subscriptions

{
"NotificationQueueLink" : "Mesh/NotificationQueues/[ID]"
}

Response

{
    "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
    "Categories" : [
        {
            "Label" : "Subscription",
            "Name" : "Subscription",
            "Scheme" : "http:\/\/user.windows.net\/Resource"
        }
    ],
    "Id" : "urn:uuid:33abe770-0d77-4aaa-a07d-7242b04958c5",
    "LastUpdatedTime" : "\/Date(1237276859000)\/",
    "SelfLink" : "Mesh\/MeshObjects\/[ID]\/Subscriptions\/[ID]",
    "Title" : "SubscriptionResource",
    "ETag" : "171184531853220",
    "NotificationQueueLink" : "Mesh\/NotificationQueues\/[ID]",
    "Timeout" : 3080
}

The following properties from the preceding code examples are of interest:–

Etag: It is possible that the mesh object (the subscribed resource in this example) is updated between the time period when the last GET was executed and the creation of this subscription. The client can make use of this Etag value to check if such an update has happened (for which it would not have received any notification) and to get the latest changes.
NotificationQueueLink: This is the link to the notification queue where notifications for this resource will be available. This value is the same as what the client application specified in the request body when creating a subscription.
Timeout: This is the value in seconds after which this subscription will be lost. In order to keep subscribing to this resource, the client application will have to execute a PUT request on this subscription (with the data in the response as the request body) before that time period. This value is not static, is determined by the server, and is read-only. This is so because notifications and subscriptions are not persisted in the database and the server needs to reclaim unused resources.

When polling for notifications, the client application should do an HTTP GET request on the Notifications feed under NotificationQueue (provided by the subscription resource as NotificationQueueLink). The Subscriptions feed only supports an HTTP POST operation and each subscription (entry within the subscriptions feed) only supports an HTTP PUT operation.

Step 3

Executing HTTP GET requests on notifications for the notification queue results in the following code example. You can see that this is an empty feed with no entries because no change has been made to the subscribed resource (i.e., the mesh object in this case).

Request

HTTP GET	
https://user-ctp.windows.net/V0.1/Mesh
/NotificationQueues/[ID]/Notifications

Response

{
    "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
    "Entries" : [
        
    ],
    "SelfLink" : "Mesh\/NotificationQueues\/[ID]\/Notifications",
    "Title" : "Notifications"
}

Step 4

In order to demonstrate how notifications are generated, we will make changes to the mesh object by updating its summary property. This change should generate a notification under notifications for the notification queue that is associated with this mesh object.

Request

HTTP PUT	
https://user-ctp.windows.net/V0.1/Mesh/MeshObjects/[ID]

{
    "Id" : "urn:uuid:8d9e425a-52ea-4645-be8f-cc20d5de7446",
    "Title" : "Images",
    "Summary" : "This is a test update"
}

Response

{
    "AuthorProfileLink" : "email-nguptadev@hotmail.com\/Profiles",
    "Authors" : [
        {
            "Name" : "Nishant Gupta",
            "Uri" : "email-nguptadev@hotmail.com\/Profiles",
            "Email" : "nguptadev@hotmail.com"
        }
    ],
    "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
    "Categories" : [
        {
            "Label" : "MeshObject",
            "Name" : "MeshObject",
            "Scheme" : "http:\/\/user.windows.net\/Resource"
        }
    ],
    "Id" : "urn:uuid:8d9e425a-52ea-4645-be8f-cc20d5de7446",
    "LastUpdatedTime" : "\/Date(1237277073000)\/",
    "PublishDate" : "\/Date(1233431971000)\/",
    "SelfLink" : "Mesh\/MeshObjects\/[ID]",
    "Summary" : "This is a test update",
    "Title" : "Images",
    "ActivitiesLink" : "Mesh\/MeshObjects\/[ID]\/Activities",
    "DataFeedsLink" : "Mesh\/MeshObjects\/[ID]\/DataFeeds",
    "MappingsLink" : "Mesh\/MeshObjects\/[ID]\/Mappings",
    "MembersLink" : "Mesh\/MeshObjects\/[ID]\/Members",
    "NewsFeedLink" : "Mesh\/MeshObjects\/[ID]\/News",
    "SubscriptionLink" : "Mesh\/MeshObjects\/[ID]\/Subscriptions"
}

Step 5

We will now do a GET request on notifications to look for any notifications that may have been generated for this change.

Request

HTTP GET	
https://user-ctp.windows.net/V0.1/Mesh
/NotificationQueues/[ID]/Notifications

Response

{
   "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
   "Entries" : [
     {
       "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
       "Categories" : [
           {
               "Label" : "Notification",
               "Name" : "Notification",
               "Scheme" : "http:\/\/user.windows.net\/Resource"
            }
       ],
       "Id" : "urn:uuid:4f9e630c-c9d0-49eb-9e40-519f0de29f81",
       "LastUpdatedTime" : "\/Date(1237278069000)\/",
       "PublishDate" : "\/Date(1237278061000)\/",
       "SelfLink" : "Mesh\/NotificationQueues\/[ID]\/Notifications\/1",
       "Title" : "Title",
       "ResourceLink" : "Mesh\/MeshObjects\/[ID]",
       "Type" : 0,
       "Watermark" : "1.823.0"
     }
    ],
    "SelfLink" : "Mesh\/NotificationQueues\/[ID]\/Notifications",
    "Title" : "Notifications"
}

As you can see, there is a single entry (notification) generated.

The properties of interest in this example:

ResourceLink – This specifies the resource for which this notification has been generated. The client application can then do a GET request on this resource with the last Etag received to get the changes.
Type – This specifies the type of notification that has been generated. The possible values are
- 0 – Resource changed. This is the most common value for type. This signifies that the resource (identified by resource link) has changed.
- 1 – All subscriptions lost. Subscriptions can be lost for various reasons, such as: notification queue timed out, notifications overflow for this notification queue, or service crash/restart (because notifications are not persisted in database). In this case, you need to renew the notification queue by generating a PUT request with a watermark value for this notification (see the following step for details) and then re-subscribe to all the resources. Please note that when you renew the notification queue, the self-link now received for the notification queue is different from the previous one (because the old queue was lost). You need to use this new link when subscribing to resources.
- 2 – Subscription lost for the resource identified by the resource link. The loss could be due to a service restart/crash. When this happens, the client needs to re-subscribe to the resource in order to receive further notifications for this resource.
Watermark – This is an opaque identifier associated with this notification. Because notifications and notification queues are not persisted in the database, the number of notifications that can be retained in memory for a given notification queue are limited. The clients are encouraged to acknowledge the receipt of notifications that they have read by doing a PUT request on Mesh/NotificationQueues/<ID> with the watermark value of the last notification in the feed. This will remove all the acknowledged notifications up to the notification with the watermark specified and will free up resources. Failure to do so will result in loss of notifications when the limit on the number of notifications allowed per queue is reached. In an ideal case, every non-empty GET on notifications should be followed by a PUT request on the notification queue with the last read watermark value.

Step 6

We will renew the notification queue and delete the stale notifications by doing a PUT request on the notification queue.

Request

HTTP PUT	
https://user-ctp.windows.net/V0.1/Mesh/NotificationQueues/[ID]
{
 "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
 "Categories" : [
     {
         "Label" : "NotificationQueue",
         "Name" : "NotificationQueue",
         "Scheme" : "http:\/\/user.windows.net\/Resource"
     }
 ],
 "Id" : "uuid:3084e6c2-56ac-4563-b67c-af7a7fc019e7;id=18130",
 "LastUpdatedTime" : "\/Date(1237276680000)\/",
 "SelfLink" : "Mesh\/NotificationQueues\/[ID]",
 "Title" : "NotificationQueueResource",
 "ExpirationDuration" : 300,
 "NotificationsLink" : "Mesh\/NotificationQueues\/[ID]\/Notifications",
 "Watermark" : "1.823.0"
}

A subsequent GET request on the notifications will appear as follows. Note that there are no more entries (notifications) because we deleted the stale entry by providing the watermark value in the PUT request on notification queue.

Request

HTTP GET	
https://user-ctp.windows.net/V0.1/Mesh/NotificationQueues/[ID]/Notifications

Response

{
    "BaseUri" : "https:\/\/user-ctp.windows.net\/V0.1\/",
    "Entries" : [
        
    ],
    "SelfLink" : "Mesh\/NotificationQueues\/[ID]\/Notifications",
    "Title" : "Notifications"
}

It is important to note that you can also renew the notification queue by doing an HTTP GET on notifications. This will, however, not remove the acknowledged notifications from the queue.

Take-away Points

Notifications and subscriptions allow for efficient polling to check for updates on the resource without actually doing a GET request on the resource itself.
The client application can create a single notification queue and use it for subscribing to multiple resources.
The default life span for notification queue is 300 seconds from the last PUT request. The client application should renew it by doing an HTTP PUT on the notification queue or HTTP GET on the notifications feed within that duration. If there are acknowledged notifications that need to be removed, the client should specify the watermark value corresponding to the last such notification. The polling interval chosen by the client should be determined based on the client’s need for responsiveness and the TTL of the queue.
Subscriptions to resources timeout after a period. In order for the client application to continue subscribing to the resource, it should renew it by doing a PUT request within the timeout duration.
Watermarks should be treated as opaque identifiers. No assumptions should be made on their format.

--Live Services Team

New Live Framework Samples

2009-03-21T00:01:14Z

We’ve created a code gallery for Live Framework samples, and posted six new samples not included in the SDK.

Here’s the list of the additional samples now available:

Sample Name	Description	Technologies Used
Livefx Office Addins	Demonstrates how to integrate Live Framework capabilities with Office products using the Live Framework .NET Toolkit.	C#, Visual Studio Tools for Office
ASP.NET DelAuth	Demonstrates how to set up and use Delegated Authentication from an ASP.NET Web site in order to access Live Framework resources.	ASP.NET; C#
Livefx PHP Helper Library	A sample PHP helper library for accessing Live Framework resources.	PHP
ProfileInfo	Demonstrates how retrieve a user’s Windows Live Profile information using IronPython and the Live Framework .NET Toolkit.	.NET, IronPython, LINQ
ProfileInfo	Demonstrates how retrieve a user’s Windows Live Profile information over HTTP, using POX and JSON.	HTTP, POX, JSON
Live Mesh Utilities	Demonstrates MeshObject operations using the .NET Toolkit, including creating a Live Folder and a MeshObject, mapping the MeshObject, and enumerating MeshObject properties.	C#

Keep up to date with our sample publishing via this RSS feed.

We hope these help! As usual, chat, ask questions, or give feedback in our Forum.

Thanks,

The Live Framework team

Live Framework Updated!

2009-03-11T23:15:00Z

We are pleased to announce the April CTP update of the Live Framework SDK and Tools. Below you will find details about what’s new with this release.

The Live Framework Team thanks its developer community for trying out Live Framework CTP and taking time to submit the feedback. Please keep it coming through the Live Framework Developer Connection and the Live Framework Forum.

DOWNLOAD THE TOOLS AND SDK
DOWNLOAD THE SDK ONLY

New to the Live Framework? Go to the Live Framework home page to see how to get started.

Version numbers

The latest version numbers for this release are as follows:

Live Framework Developer Sandbox: 0.9.3904.1
Live Framework Client: 0.9.3904.1
Live Framework SDK: 0.9.3904.1
Live Framework Tools: 1.0.20309.3

Installing the Updated Live Framework Client

Installing the Live Framework client will allow you to access resources locally (for example, in an offline scenario). If you want to run the Live Framework client side-by-side with the Live Mesh client, see instructions in this forum post.

Sign-in to Live Mesh Developer Sandbox
Navigate to Devices Tab.
Click on "Add Device". (Note: To update the Live Framework client, you need to re-add any pre-existing devices in our Mesh.).
Choose the correct operating system from drop down and Click "Install"
Download the LiveFrameworkClient.msi file to your desktop
Run LiveFrameworkClient.msi to install the latest client bits

What’s New in this Release

This update includes:

Support for side-by-side installation of the www.mesh.com local client and the developer.mesh-ctp.com local client. This means that you can use the production Mesh.com to sync data across all your devices, and develop applications for the Mesh Developer Sandbox that uses the local client—all on the same machine. For instructions on setting up side-by-side, please see this forum post.
Support for Windows 7 and Internet Explorer 8
Single installer for the Live Framework SDK and the Live Framework Tools for Microsoft Visual Studio.
Resource Scripts are now supported in Silverlight applications and with the local Live Operating Environment
Public availability of the SDK and Tools on the Microsoft.com Download Center.
Improved stability in the client and the cloud Live Operating Environment.
Design and performance improvements to the API toolkits
Simplified workflow for setting up an account and a Live Framework project on the Azure Developer Portal.

NOTE: There are some changes in the CTP toolkits that may require you to update your application code should you recompile with the new bits. See this document for more information.

See a list of known issues.

What’s New in the Tools

The Live Framework Tools April CTP release includes several updates:

Installation of the Silverlight Tools, Live Framework SDK, and Live Framework Tools is accessed through a single installer.
Error messages and diagnostics have been improved. In most error situations when the server returns a failure code more information can be located in the application event log.
A set of C# Code Snippets for accessing common Live Framework tasks are now accessible through the standard snippet mechanism. To see the available snippets right-click in a .cs file and select “insert snippet.”

This release also contains the cumulative updates from the January CTP:

Debugging or running a Mesh-enabled Web Application which contains no changes from previous versions immediately launches the application instead of re-uploading the files.
Mesh-enabled Web Applications created by the Live Framework Tools now have identical offers to those created through the Azure Services Developer Portal, which are generally less restrictive. This change removes the need for the workaround mentioned in this thread.
Projects created by the Live Framework Tools may now contain periods fixing the issue reported in this bug.
Changes to the application's logo.png file will now be reflected in the icon that appears on the Live Desktop fixing the issue reported in this thread.

What's Included in the April 2009 CTP

The Live Framework CTP April 2009 CTP includes everything you need in order to quickly build rich, connected, data-sharing applications using Live Services. This CTP includes both the Live Framework SDK and the Live Framework Tools for Microsoft Visual Studio.

Live Framework SDK

The Live Framework SDK package provides you with Live Framework API Kits, sample code demonstrating usage of the API Kits and the Live Framework Resource Browser.

Live Framework API Kits

Live Framework .NET Kit – a programming library for use with .NET Framework. This includes object model, resource model and AtomPub client library.
Live Framework Silverlight Kit – a managed code programming library to use with Silverlight. This includes object model, resource model and AtomPub client library for Silverlight.
Live Framework JavaScript Kit – a programming library for use with JavaScript

Samples

Samples included in the Live Framework SDK demonstrate the usage of various aspects of API.

Resource Browser

The Live Framework Resource Browser is a handy tool to help you browse through Live Framework Resources.

Live Framework Tools for Microsoft Visual Studio

The Live Framework Tools significantly decrease the time it takes to develop Mesh-enabled Web Applications in Visual Studio 2008.

The Live Framework Tools include:

Project templates for creating DHTML Mesh-enabled Web Applications and C# or VB Silverlight Mesh-enabled Web Applications
Building and packaging of Mesh-enabled Web Applications for deployment
Launching and debugging Mesh-enabled Web Applications hosted in the Live Desktop
IntelliSense completion for Live Framework assemblies and JavaScript files

Getting started with the Live Framework Tools

This textual step-by-step walkthrough will guide you through using the Live Framework Tools to create, build, deploy and debug a simple DHTML and Silverlight Mesh-enabled Web Application.

Developer Resources

Please give us your feedback! Let us know what you like and what you don't like. Stop by and give us your feedback here on the Connect site.

Start Programming with the Live Framework in 5 Minutes

2009-03-03T02:02:45Z

Although accessing data using the Live Framework is as simple as making REST API calls, one thing that might take you more time to figure out is authentication. The Live Framework relies on the Delegated Authentication mechanism to authenticate the incoming request and check for authorization to access the data being requested. This is done by providing a ticket (Delegation Token) in an AppDelegationToken HTTP header. Delegated authentication allows a Windows Live ID user to grant consent to a 3^rd-party web application to access data on his/her behalf. Last December, we posted a great article on how to implement delegated authentication for your website using .NET. But we want to make it even easier for you to make your first API call to the Live Framework.

In this post, we give you a quick way to generate a temporary delegation token and show you how to use it to connect with the Live Framework cloud endpoint (https://user-ctp.windows.net/). Note that this method of generating a token is only for testing purposes. Since the goal of this exercise is to make it easy for you to make your first API call to the Live Framework, we do not cache the token on the server.

1. Go to the token generation utility at http://token.mslivelabs.com.

2. Click the link to grant access to your data.

3. Login with your Windows Live ID.

4. Click “Allow Access”.

5. Use the generated HTTP header to make an HTTP GET request on https://user-ctp.windows.net.

FYI: here's an example header, requesting data to be returned in the ATOMPub format:

  Accept: application/atom+xml
  Content-Type: application/atom+xml
  AppDelegationToken: "<insert a valid token here>"
  Host: user-ctp.windows.net
  Connection: Keep-Alive

To learn how to use this header to make requests for resources, see Interacting with the Live Operating Environment by Using HTTP.

Happy coding!

--Live Framework Team

Live Framework Tools January CTP

2009-02-02T23:01:31Z

The Live Framework Tools team has released an update to their Community Technical Preview (CTP). This release was focused on addressing top customer issues, so please be sure to keep the feedback coming!

From the team’s announcement:

The Live Framework Tools team is pleased to announce the January CTP update. This update contains a number of fixes. Please see below for details. And as always, thank you for using Live Framework.

New in this release

The Live Framework Tools January CTP includes a number of bug fixes. A few of the most notable fixes are listed below:

Debugging or running a Mesh-enabled Web Application which contains no changes from previous versions immediately launches the application instead of re-uploading the files.

Mesh-enabled Web Applications created by the Live Framework Tools now have identical offers to those created through the Azure Services Developer Portal, which are generally less restrictive. This change removes the need for the workaround mentioned in this thread.

Projects created by the Live Framework Tools may now contain periods fixing the issue reported in this bug.

Changes to the application's logo.png file will now be reflected in the icon that appears on the Live Desktop fixing the issue reported in this thread.

Error messages and diagnostics have been improved. In certain error situations additional information can now be located in the application event log.

In addition to the fixes listed above, the January CTP includes a feature that will offer to notify you of any future updates to the Live Framework Tools.

Delegated Authentication, Part II: Managing Tokens

2009-01-13T02:23:06Z

In our previous posting, we discussed the basics of setting up delegated authentication using a simple ASP.NET Web site. In this posting we will explore the code in greater detail, and expand the capabilities of the sample to include checking the expiry date of the token, and refreshing the token. This posting shows highlights of the code that is used to perform these tasks, but not the complete code. Refer to the sample code for the full source.

Click here to download the sample code

Note: The instructions for setting up prerequisites have been moved to the sample code project. See readme.htm to access the instructions. Pay particularly close attention if you plan to test the application locally, there are a couple of extra steps you need to take so that cookies will work properly in the local environment.

Creating the Hyperlink

The first order of business is displaying a hyperlink for the Windows Live sign-in page. This hyperlink contains an assortment of information, including:

The URL for the consent page.
A list of offers. These determine the types of permissions that should be granted.
The return URL. This should point to the response handler page (more about that later).
The URL for the privacy policy page (in this sample it is merely a placeholder).
The appid and appUrl values that were provided when you provisioned the application.

Altogether the URL looks like this, as it is generated by calling the GetConsentUrl method in the WindowsLiveLogin class when the page loads (line breaks added for clarity):

https://developer.mesh-ctp.com/web/apps/appconsent.aspx?
ps=LiveMeshFolder.Read%2cProfiles.Read%2cContacts.Read%2cNews.Read
&ru=http%3a%2f%2flivedocs3.com%2fLiveFX_DelAuth%2fdelauth-handler.aspx
&pl=http%3a%2f%2flivedocs3.com%2fLiveFX_DelAuth%2fPolicy.aspx
&app=appid%3d000000004800582F%26ts%3d1229629618%26sig%3d%
252bZRR4MStePHXezuSb3onuRDCOfvW0M28P7nLYq1re2c%253d
&appUrl=/Live/V0.1/Mesh/Applications/FAN5567B47NEXA5P2GWFSJRRAQ

The following code shows creating an instance of WindowsLiveLogin and calling GetConsentUrl.

// Create a new instance of WindowsLiveLogin and get a URL string.
WindowsLiveLogin wl_login = new WindowsLiveLogin(true);
string consentUrl = wl_login.GetConsentUrl(Offers);

On the default.aspx page, the hyperlink is presented as follows:

<span id="linkConsent" runat="server"><a href="<%=consentUrl%>">Click here</a> to grant consent for this application to access your Windows Live data.</span>

WindowsLiveLogin gets the values to use for the URL from the web.config file for the project. When you first open the web.config, look for the following section.

<!-- IMPORTANT: These values must be entered before running the sample. -->
<!--<appSettings>
    <add key="wll_appid" value="[Your appid.]"/>
    <add key="wll_secret" value="[Your secret key.]"/>
    <add key="wll_securityalgorithm" value="wsignin1.0"/>
    <add key="wll_returnurl" value="[The full URL for your delegated auth handler page.]"/>
    <add key="wll_policyurl" value="[The full URL for your site's privacy policy page.]"/>
    <add key="wll_consenturl" value="https://developer.mesh-ctp.com/web/apps/appconsent.aspx"/>
    <add key="wll_appurl" value="/Live/V0.1/Mesh/Applications/[The id provided by Azure Services Portal when you registered your app.]"/>
</appSettings>

IMPORTANT: The AppID and the final segment of the Application URL (self link) are two discrete values. Take care not to get these values mixed up. See readme.htm in the sample code for more detail about these settings.

Keep in mind that WindowsLiveLogin is also sample code, taken directly from the Windows Live ID Delegated Authentication SDK for Application Providers. Nothing here is set in stone, so feel free to make modifications, and extend the classes as you see fit.

Handling the Return

Once the user has granted consent to access the resources specified in the offers string, a request is sent back to the return URL. Code needs to be put into place to handle this request. This is done by delauth-handler.aspx and delauth-handler.aspx.cs. Since the return URL points directly to this page, the request is intercepted by using a standard HttpRequest object as shown in the following example.

protected void Page_Load(object sender, EventArgs e)
{
    HttpRequest Request = HttpContext.Current.Request;
    HttpResponse Response = HttpContext.Current.Response;
 
    if (Request["action"] == "delauth")
    {
        // Call ProcessConsent to create a new token.
        consentToken = wl_login.ProcessConsent(Request.Form);
     }
    // Redirect to the login page.
    Response.Redirect(LoginPage);
    } 
}

Getting the Token Data

At this point let's say a user has visited the application, clicked the link, and granted consent to allow the application to view their Windows Live data. The response handler page has redirected us back to the login page, where we now have a delegated authentication token that we'll use to make Live Framework requests on the user's behalf. But there is an issue we have not yet addressed, and that is how to get the delegated authentication token across from the handler page to the default page (and to other pages on the site that may need to use the token). The answer to this is cookies. In the previous version of this sample session cookies were used. This version of the sample offers a more robust system for managing token data, so standard cookies are used instead. This necessitates some changes. First, default.aspx.cs needs some code to check for the existence of a cookie, refresh the cookie if it is expired, and extract delegated authentication data from the cookie. In the following code, the UI that is presented on the default page is toggled based on whether the cookie can be located.

protected void Page_Load(object sender, EventArgs e)
{
    // Generate the consent URL by calling GetConsentUrl
    // from the WindowsLiveLogin class.
    consentUrl = wl_login.GetConsentUrl(Offers);
 
    // Toggle the UI elements that are displayed.
    // This depends upon whether a token can be found in the site cookie.
    if (Request.Cookies["consentToken"] == null)
    {
        lblConsent.Text = "";
        linkConsent.Visible = true;
        manageConsent.Visible = false;
        connectPrompt.Visible = false;
    }
    else
    {
        // If there is a cookie, check the expiry value to determine whether refresh is required.
        if (DateTime.UtcNow.AddSeconds(-300) > (DateTime.Parse(Request.Cookies["consentToken"]["expiry"])))
        {
            WindowsLiveLogin.ConsentToken consentToken = authHelpers.getNewTokenwithRefreshToken(Request.Cookies["consentToken"]["offersString"], Request.Cookies["consentToken"]["refreshToken"]);
            authHelpers.CreateTokenCookie(consentToken);
        }
 
        lblConsent.Text = "Consent acquired: " + Request.Cookies["consentToken"]["delToken"];
        linkConsent.Visible = false;
        manageConsent.Visible = true;
        connectPrompt.Visible = true;
    }
}

The following code shows delauth-handler.aspx.cs, now expanded with some basic cookie management code.

protected void Page_Load(object sender, EventArgs e)
{
    // Create a new instance of the AuthenticationHelpers class.
    AuthenticationHelperClass authHelpers = new AuthenticationHelperClass();
 
    // Create a consent token
    WindowsLiveLogin.ConsentToken consentToken = null;
    HttpRequest Request = HttpContext.Current.Request;
    HttpResponse Response = HttpContext.Current.Response;
 
    if (Request["action"] == "delauth")
    {
        // Check if a cookie exists.
        if (Request.Cookies["consentToken"] != null)
        {
            // If the cookie exists, check the expiry and refresh if it is expired.
            if (DateTime.UtcNow.AddSeconds(-300) > (DateTime.Parse(Request.Cookies["consentToken"]["expiry"])))
            {
                consentToken = authHelpers.getNewTokenwithRefreshToken(Request.Cookies["consentToken"]["offersString"], Request.Cookies["consentToken"]["refreshToken"]);
                authHelpers.CreateTokenCookie(consentToken);
            }
        }
 
        else
        {
            // Call ProcessConsent to create a new token.
            consentToken = wl_login.ProcessConsent(Request.Form);
            authHelpers.CreateTokenCookie(consentToken);
        }
 
        // Redirect to the login page.
        Response.Redirect(LoginPage);
    } 
}

This is where the AuthenticationHelperClass class comes into play. When the handler page loads, it now checks for the existence of the consentToken cookie. If such a cookie is found it checks the value of the expiry key. If the token is expired, a call is made to getNewTokenwithRefreshToken. If no token exists, consent is processed, and the resulting token data is added to the site cookie. The cookie creation code in AuthenticationHelperClass looks like this.

// Create a cookie and assign keys to each piece of token data.
public void CreateTokenCookie(WindowsLiveLogin.ConsentToken consentToken)
{
    HttpCookie tokenCookie = new HttpCookie("consentToken");
    HttpResponse Response = HttpContext.Current.Response;
    tokenCookie["delToken"] = consentToken.DelegationToken;
    tokenCookie["refreshToken"] = consentToken.RefreshToken;
    tokenCookie["sessionKey"] = consentToken.SessionKey.ToString();
    tokenCookie["expiry"] = consentToken.Expiry.ToString();
    tokenCookie["offersString"] = consentToken.OffersString;
    tokenCookie["locationId"] = consentToken.LocationID;
    tokenCookie["context"] = consentToken.Context;
    tokenCookie["decodedtoken"] = consentToken.DecodedToken;
    tokenCookie["token"] = consentToken.Token;
    tokenCookie.Expires = DateTime.Now.AddDays(30d);
    Response.Cookies.Add(tokenCookie);
}

This code creates a new cookie named consentToken, then adds each piece of token data to the cookie as a key, and assigns an expiry date of 30 days from the current day. Although some of the data is not used in the sample, it is a good idea to save all of it for maximum flexibility in the future. For example, you could use the cookie data to completely re-create a new ConsentToken with updated offers. Back to the cookie expiry date, this example sets it for 30 days for the sake of simplicity. You can incorporate a more sophisticated scheme for managing the expiry dates of the token, and align the cookie expiry date accordingly. For example, you could set it up so that the cookie and the token expire at the same time. Since the ConsentToken.Expiry property is a DateTime value, you could set the cookie expiry date based on that. For example:

tokenCookie.Expires = consentToken.Expiry.AddDays(30d);

The refresh code uses an HttpWebRequest object and System.Net.WebRequest to generate a refresh token URL, StreamReader to read the response, and JavaScriptSerializer to deserialize the response. The following code snippet shows the code that is used to do this.

//Get Renewed ConsentToken Object with RefreshToken
public WindowsLiveLogin.ConsentToken getNewTokenwithRefreshToken(string offerString, string refreshToken)
{
    //WindowsLiveLogin wll = new WindowsLiveLogin(true);
    string refreshTokenURL = wl_login.GetRefreshConsentTokenUrl(offerString, refreshToken);
 
    HttpWebRequest request = (HttpWebRequest)WebRequest.Create(refreshTokenURL);
    request.Method = "GET";
    request.ContentType = "application/json";
 
    HttpWebResponse response = (HttpWebResponse)request.GetResponse();
 
    StreamReader streamReader = new StreamReader(response.GetResponseStream());
    string jsonResult = streamReader.ReadToEnd();
 
    JavaScriptSerializer jsonSerializer = new JavaScriptSerializer();
 
    string renewedRawTokenString = jsonSerializer.Deserialize<refreshTokenObj>(jsonResult).ConsentToken;
    return wl_login.ProcessConsentToken(renewedRawTokenString);
}
 
//ConsentToken Info Object to be Deserialized
class refreshTokenObj
{
    public string ConsentToken { get; set; }
}

Doing Stuff with the Live Framework

Now that consent has been granted, and a cookie has been saved to store all of the delegated authentication token data, we can begin working with the Live Framework. This sample illustrates getting the names of each folder, and displaying them. The sample has two methods, one to connect to the Live Operating Environment (LOE), and one to page through and display the names of associated Mesh objects. The code for creating an instance of the LOE looks like this:

// Create a new instance of the Live Operating Environment (loe).
LiveOperatingEnvironment loe = new LiveOperatingEnvironment();

The code for connecting to the LOE is as follows.

protected void  ConnectToLOE(object sender, EventArgs e)
{
    // Connect to the Live Operating Environment.
    loe.Connect(Request.Cookies["consentToken"]["delToken"], AuthenticationTokenType.DelegatedAuthToken, LiveFxUri, accessOptions);
 
    // Create a new Mesh object from the loe.
    // This is the object your program will use for the majority of interactions.
    Mesh mesh = loe.Mesh;
 
    // Show some text to indicate that the user is connected.
    userName.InnerText = mesh.ProvisionedUser.Name + " is now connected.";
 
    // Call the method to display a list of Mesh objects.
    DisplayMeshItems(mesh);
}

The ConnectToLOE method calls the LiveOperatingEnvironment.Connect method using the delegation token key that was saved with the current cookie, indicating an AuthenticationTokenType of DelegatedAuthToken, and passing the accessOptions that have been defined (not shown in this example). Next, a Mesh object is obtained from the LOE instance. This is used to display the user's name in a confirmation message, and to call the DisplayMeshItems method (shown in the following snippet).

private void DisplayMeshItems(Mesh mesh)
{
    // Display all Mesh Objects (in this case, all Mesh Folders).
    StringBuilder meshObjectList = new StringBuilder("");
    mesh.MeshObjects.Load();
 
    var meshObjects = (from meshObject in mesh.CreateQuery<MeshObject>() select meshObject);
 
    foreach (MeshObject meshObject in meshObjects)
    {
        meshObjectList.Append(meshObject.Resource.Title + ", ");
    }
    connected.InnerText = "Mesh Folders for " + mesh.ProvisionedUser.Name + ": " + meshObjectList;
}

At this point, depending on the offers and corresponding consent granted by the user, the application can be empowered to do everything from read the user's data, to creating, updating, and deleting items in the user's Mesh.

--Live Framework team

Connecting Your Web Site to the Live Framework (i.e. Using Delegated Auth)

2008-12-16T03:24:00Z

Click here to download the sample code

Ever wondered if there was a programmatic way to connect your web site with Live Mesh and other Live Services? Your Web site can request permission from your users to access their Live Mesh data such as photos, videos files or application data or Windows Live data such as Contacts and Profile information. Live ID Delegated Authentication serves to enable a Web site to connect to the Live Framework and provide access to a user’s data. The sample code featured in this posting uses a a simple ASP.NET Web application to demonstrate the basic tasks involved with using delegated authentication in conjunction with the Live Framework. This posting contains instructions for deploying and running the sample.

Before You Start

You need to have a provisioned to the Live Framework Developer CTP account to run this sample. Visit https://lx.azure.microsoft.com to sign in using your token. If you don't have a token, please register your interest here http://www.microsoft.com/azure/register.mspx. The rest of this document assumes you are already provisioned to the Live Framework CTP.
Download and install the Live Framework SDK here: http://dev.live.com/liveframework/sdk/.
Visit your Live Desktop and create some content for this application to access. A couple of Live Mesh folders is a good start.

To Create a new Web site using the Developer Portal

Before you add Delegated Authentication to your Live Framework-enabled Web site you first need to visit the Azure Services Developer Portal (https://lx.azure.microsoft.com/Cloud/Provisioning/Default.aspx) to register the Website. Take the following steps to register:

Go to the Azure Services Developer Portal.
Click New Project.
Under Azure Services Platform, click Live Services: Live Framework Community Technology Preview.
Enter a label and optional description for your project, then click Next.
Select the Create a Live Framework-enabled Website option, and click Create.
Click the Summary tab to view a summary for the newly created project.
Click Edit next to Delegated Authentication to add your domain and return URL to the configuration settings. For example:
MyDomain.com
http://www.MyDomain.com/MyWebsite/delauth-handler.aspx
If you are testing your Website locally, you need to locate your hosts file (for example C:\WINDOWS\system32\drivers\etc\hosts), and add an entry to redirect the domain to localhost, as shown here:
127.0.0.1 MyDomain.com
This does not have to be an actual domain, but it does have to be unique for the Website you're registering. The hosts entry causes your local web server to redirect the response from the authentication server to localhost. If you are behind a proxy server, you will need to add the domain you chose to the exclusion list.
Copy the following items from the summary page, and paste them into a text file for later use, along with the domain name and return URL you specified.

Application Self Link
Application ID
Secret Key
Domain name
Return URL

Click Update to add the configuration settings.

To Add the Live Framework References

Prior to running the sample, you will need to open the project in Visual Studio and add the appropriate references for the Live Framework assemblies. Here's how to do it:

Open the project in Visual Studio.
Right-click the project name and select Add Reference.
Click the Browse tab and navigate to the installed location for the Live Framework .NET assemblies (for example C:\Program Files\Microsoft SDKs\Live Framework SDK\v0.9\Libraries\.Net Library).
Select the following files:

Microsoft.LiveFX.Client.dll
Microsoft.LiveFX.ResourceModel.dll
Microsoft.Web.dll

Click OK to add the references to the project.

To Run the Sample

There are two options here, you can either deploy the sample site on a live Web server, or test it on your local computer. If you plan to deploy the site on a live Web server, you should do so before proceeding any further. Deploy the sample to your web server as you would do so for any ASP.NET Website.

If you want to run it locally, create a folder at C:\InetPub\wwwroot\LiveFX_DelAuth, and unzip the contents of the archive to that folder. The next section contains instructions for setting up your domain and return URL so that it will work in a testing environment. This example assumes that you are using Internet Information Server.

Deploy and Register the Sample Site

Update the web.config File

The WindowsLiveLogin class requires updating the configuration settings to the web.config file for the project. Add the appSettings tag, and add the following key-value pairs:

Key	Value
wll_appid	The application ID provided by Azure Services.
wll_secret	The secret key provided by Azure services.
wll_securityalgorithm	The security algorithm should be set to "wsignin1.0".
wll_returnurl	The full return URL for the authentication handler page. In this sample, the name of the page is "delauth-handler.aspx".
wll_consenturl	The URL for the consent page. In this sample, " developer.mesh-ctp.com/web/apps/appconsent.aspx " is used.
wll_policyurl	The URL for the Website's privacy policy page. In this example the page can be a blank placeholder, but in a live deployment this page must contain an actual privacy statement.
wll_appurl	This is the relative self-link that is used by Live Framework to reference your application. This value is provided for you by the Azure Services Developer Portal when you register your Mesh Application. If you are not using a Mesh Application, this key is not required. This value should be a relative URL, starting with Mesh/Applications. If the Azure Services Developer Portal lists a longer URL, then remove the beginning portion. In this example, it is "/Mesh/Applications/[value for ID]".

This is the relative self-link that is used by Live Framework to reference your application. This value is provided for you by the Azure Services Developer Portal when you register your Mesh Application. If you are not using a Mesh Application, this key is not required. This value should be a relative URL, starting with Mesh/Applications. If the Azure Services Developer Portal lists a longer URL, then remove the beginning portion. In this example, it is "/Mesh/Applications/[value for ID]".

For example:

<appSettings>

   <add key="wll_appid" value="000000004863583G"/>
   <add key="wll_secret" value="KfMbFMkVx95G4prAxF64gW78A3bK65HT"/>
   <add key="wll_securityalgorithm" value="wsignin1.0"/>
   <add key="wll_returnurl" 
        value="http://MyDomain.com/MyWebsite/delauth-handler.aspx"/>
   <add key="wll_policyurl" 
        value="http://MyDomain.com/MyWebsite/Policy.aspx"/>
   <add key="wll_consenturl" 
        value="developer.mesh-ctp.com/web/apps/appconsent.aspx"/>
   <add key="wll_appurl" 
        value="/Mesh/Applications/FAQ1234B47ZENA5P2GWFSJRLUV"/>
</appSettings>

Summary of Sample Website Features

Default.aspx/Default.aspx.cs

This page, and its accompanying code-behind page, contain code that checks for a session cookie with a delegated authentication token. If a token is not found, a link to the consent page is provided. This sample uses session cookies for the sake of brevity; you can substitute standard site cookies instead. If a token exists (which will be the case immediately after requesting consent), the token itself is displayed on the page, and a link is displayed to connect to the Live Operating Environment.

delauth-handler.aspx.cs

This is the page that handles the return request from the server. If the request is of type "delauth" it calls WindowsLiveLogin.ProcessConsent, passes the results of the form, and returns a consent token. The delegation token is then extracted from the consent token and added to the Session cookie.

WindowsLiveLogin.cs

This class is taken directly from the Windows Live ID Delegated Authentication SDK, and added to the App_Code folder for this sample. It provides the basic functionality for managing authentication data.

Running the app

Click the link to request consent. Enter your Windows Live credentials if prompted.
In the Access Permission section, scroll down to where it says Read access to the following MeshObject, click Change, and select the Mesh objects of your choice.
Click OK, then click Allow Access.
You will be returned to your Web site. The page now displays the delegated authentication token and a link.
Click the link to connect to the Live Operating Environment. This initiates a request to display the names of your Mesh objects.

For More Information, see:

Accessing Existing Resources by Using Delegated Authentication (http://msdn.microsoft.com/en-us/library/dd217567.aspx)

Windows Live ID Delegated Authentication SDK for Application Providers (http://msdn.microsoft.com/en-us/library/cc287637.aspx)

Live Framework Resource Model--Part 1

2008-12-12T02:55:57Z

In upcoming posts we will talk about the resources that are exposed by the Live Framework. The following diagram provides a complete picture of the various resources that are currently available.

We will take a bottom up approach to explain the various resources. The Live Framework Resource Model describes various resources and their relationships to other resources. It is based on a simple Property, Entity, Collection based information model. Each resource is an entity which contains various properties and a set of entities make up a collection. Every collection and entity is uniquely addressable and is identified by a URL. The relationships between entries are represented through hyperlinks. This allows for navigation from one resource to the related resource (entity) or collection of resources (collection). Note that such an entity/collection based model can be transformed trivially to an item/feed based information model of that of RSS or an entry/feed based model of that of ATOM.

At the heart of the resource model is Data Entry. Data Entry is the representation of a single unit of data such as photo, a document, a blog post etc. Each data entry contains textual information which describes the data and the link to the binary information, the media (if any, such as in case of a photo). Here is an example of a data entry in JSON format –

{
    "AuthorProfileLink" : "email-brian.perry@live.com/Profiles",
    "Authors" : [
        {
            "Name" : "Brian Perry",
            "Uri" : "email-brian.perry@live.com/Profiles",
            "Email" : "brian.perry@live.com"
        }
    ],
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Categories" : [
        {
            "Label" : "DataEntry",
            "Name" : "DataEntry",
            "Scheme" : "http://user.windows.net/Resource"
        }
    ],
    "Id" : "urn:uuid:29c29a60-6bc0-6888-72fc-5719596cf4c6",
    "LastUpdatedTime" : "/Date(1225235053000)/",
    "PublishDate" : "/Date(1225235053000)/",
    "SelfLink" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries/MCNMEKOANOEGQ4X4K4MVS3HUYY",
    "Summary" : " ",
    "Title" : "Amanda.wma",
    "EditMediaLink" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/MediaResources/MCNMEKOANOEGQ4X4K4MVS3HUYY-QLSVIDRQUCZLSAGEUVKWYJIPQA",
    "MediaResource" : {
        "Hash" : "guVUDjCgsrkAxKVVbCUPgA==",
        "Id" : "d73533c0-271b-4879-b5c8-021b94e874e2",
        "IsUploaded" : true,
        "LastUpdatedTime" : "/Date(1225235053495)/",
        "Length" : 4990823,
        "MediaType" : "audio/x-ms-wma",
        "Name" : "Amanda.wma",
        "PublishDate" : "/Date(1225235053495)/"
    },
    "ParentId" : "urn:uuid:00000000-0000-0000-0000-000000000000",
    "Type" : "File"
}

The same data entry in ATOM format is represented as follows –

<entry xml:base="https://user-ctp.windows.net/V0.1/">
 <id>urn:uuid:29c29a60-6bc0-6888-72fc-5719596cf4c6</id>
 <title type="text">Amanda.wma</title>
 <summary type="text"/>
 <published>2008-10-28T23:04:13Z</published>
 <updated>2008-10-28T23:04:13Z</updated>
 <author>
 <name>Brian Perry</name>
 <uri>email-brian.perry@live.com/Profiles</uri>
 <email>brian.perry@live.com</email>
 </author>
 <link rel="edit-media"title="Amanda.wma"href="Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/MediaResources/MCNMEKOANOEGQ4X4K4MVS3HUYY-QLSVIDRQUCZLSAGEUVKWYJIPQA"/>
 <link rel="self"title="self"href="Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries/MCNMEKOANOEGQ4X4K4MVS3HUYY"/>
 <link rel="edit"title="edit"href="Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries/MCNMEKOANOEGQ4X4K4MVS3HUYY"/>
 <link rel="LiveFX/AuthorProfile"title="LiveFX/AuthorProfile"href="email-brian.perry@live.com/Profiles"/>
 <category term="File"label="File"scheme="http://user.windows.net/DataEntry"/>
 <category term="DataEntry"label="DataEntry"scheme="http://user.windows.net/Resource"/>
 <content type="audio/x-ms-wma"src="https://user-ctp.windows.net/V0.1/Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/MediaResources/MCNMEKOANOEGQ4X4K4MVS3HUYY-QLSVIDRQUCZLSAGEUVKWYJIPQA"/>
 <Properties>
 <MediaResource>
 <Hash>guVUDjCgsrkAxKVVbCUPgA==</Hash>
 <Id>d73533c0-271b-4879-b5c8-021b94e874e2</Id>
 <IsUploaded>true</IsUploaded>
 <LastUpdatedTime>2008-10-28T23:04:13.4950863Z</LastUpdatedTime>
 <Length>4990823</Length>
 <MediaType>audio/x-ms-wma</MediaType>
 <Name>Amanda.wma</Name>
 <PublishDate>2008-10-28T23:04:13.4950863Z</PublishDate>
 </MediaResource>
 <ParentId>urn:uuid:00000000-0000-0000-0000-000000000000</ParentId>
 </Properties>
 </entry>

And the same data entry in POX is represented as follows –

<DataEntry>
 <AuthorProfileLink>email-brian.perry@live.com/Profiles</AuthorProfileLink>
 <Authors>
 <Person>
 <Name>Brian Perry</Name>
 <Uri>email-brian.perry@live.com/Profiles</Uri>
 <Email>brian.perry@live.com</Email>
 </Person>
 </Authors>
 <BaseUri>https://user-ctp.windows.net/V0.1/</BaseUri>
 <Categories>
 <Category>
 <Label>DataEntry</Label>
 <Name>DataEntry</Name>
 <Scheme>http://user.windows.net/Resource</Scheme>
 </Category>
 </Categories>
 <Id>urn:uuid:29c29a60-6bc0-6888-72fc-5719596cf4c6</Id>
 <LastUpdatedTime>2008-10-28T23:04:13Z</LastUpdatedTime>
 <PublishDate>2008-10-28T23:04:13Z</PublishDate>
 <SelfLink>Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries/MCNMEKOANOEGQ4X4K4MVS3HUYY</SelfLink>
 <Summary/>
 <Title>Amanda.wma</Title>
 <EditMediaLink>Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/MediaResources/MCNMEKOANOEGQ4X4K4MVS3HUYY-QLSVIDRQUCZLSAGEUVKWYJIPQA</EditMediaLink>
 <MediaResource>
 <Hash>guVUDjCgsrkAxKVVbCUPgA==</Hash>
 <Id>d73533c0-271b-4879-b5c8-021b94e874e2</Id>
 <IsUploaded>true</IsUploaded>
 <LastUpdatedTime>2008-10-28T23:04:13.4950863Z</LastUpdatedTime>
 <Length>4990823</Length>
 <MediaType>audio/x-ms-wma</MediaType>
 <Name>Amanda.wma</Name>
 <PublishDate>2008-10-28T23:04:13.4950863Z</PublishDate>
 </MediaResource>
 <ParentId>urn:uuid:00000000-0000-0000-0000-000000000000</ParentId>
 <Type>File</Type>
 </DataEntry>

More information on various properties of a data entry is available here. Media related to the data entry is linked via the “EditMediaLink” property and is stored under Media Resources. Sync Entries and Media Staging Area provide information that allows for synchronization of data entries. We will discuss more about synchronization in a separate post.

Let us assume that the data entry in this context represents a photo. A collection of all such photos can be represented as a Data Feed. A data feed is a collection of data entries. In most cases a data feed will be a logical collection of similar / related data entries, however, the content and type of data entries present as part of a data feed is whatever you want it to be. Here is an example of a data feed with single data entry –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Entries" : [
        {
            "AuthorProfileLink" : "email-brian.perry@live.com/Profiles",
            "Authors" : [
                {
                    "Name" : "Brian Perry",
                    "Uri" : "email-brian.perry@live.com/Profiles",
                    "Email" : "brian.perry@live.com"
                }
            ],
            "BaseUri" : "https://user-ctp.windows.net/V0.1/",
            "Categories" : [
                {
                    "Label" : "DataEntry",
                    "Name" : "DataEntry",
                    "Scheme" : "http://user.windows.net/Resource"
                }
            ],
            "Id" : "urn:uuid:29c29a60-6bc0-6888-72fc-5719596cf4c6",
            "LastUpdatedTime" : "/Date(1225235053000)/",
            "PublishDate" : "/Date(1225235053000)/",
            "SelfLink" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries/MCNMEKOANOEGQ4X4K4MVS3HUYY",
            "Summary" : " ",
            "Title" : "Amanda.wma",
            "EditMediaLink" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/MediaResources/MCNMEKOANOEGQ4X4K4MVS3HUYY-QLSVIDRQUCZLSAGEUVKWYJIPQA",
            "MediaResource" : {
                "Hash" : "guVUDjCgsrkAxKVVbCUPgA==",
                "Id" : "d73533c0-271b-4879-b5c8-021b94e874e2",
                "IsUploaded" : true,
                "LastUpdatedTime" : "/Date(1225235053495)/",
                "Length" : 4990823,
                "MediaType" : "audio/x-ms-wma",
                "Name" : "Amanda.wma",
                "PublishDate" : "/Date(1225235053495)/"
            },
            "ParentId" : "urn:uuid:00000000-0000-0000-0000-000000000000",
            "Type" : "File"
        }
    ],
    "Links" : [
        {
            "RelationshipType" : "LiveFX/MediaResources",
            "Title" : "LiveFX/MediaResources",
            "Uri" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/MediaResources"
        }
    ],
    "SelfLink" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries",
    "SubscriptionLink" : "Mesh/MeshObjects/4YMLEZWFU7QUFFAJTATIX5DYE4/DataFeeds/V5EGUCYSYL7ULE6IEYZR4P2IOY/Entries/Subscriptions",
    "Title" : "DataEntries"
}

More information on the various properties of data feeds can be found here.

Similarly, a collection of data feeds can be represented by a container which we call as a Mesh Object. Again, in most cases, the data feeds that are clubbed together under a single container (Mesh Object) will be logically related to each other but there is no such binding. Mesh objects are the basic unit of extensibility, data synchronization and sharing in the Live Framework Resource Model. Information on various properties of mesh objects is available here. All of a user’s data is represented by a collection of such mesh objects and they can be referenced via the user’s Mesh. Each mesh object not only exposes the collection of data feeds which contains user data but also some other important collections –

1. Mappings – Every mesh object can be synchronized to multiple devices in a user’s mesh. Information on devices on which a given mesh object is synchronized is available via the mappings feed where each entry provides information on a single device where this mesh object is present. More information on various properties is available here. JSON representation of Mappings feed with a single entry is as follows –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Entries" : [
        {
            "AuthorProfileLink" : "email-brian.perry@live.com/Profiles",
            "Authors" : [
                {
                    "Name" : "Brian Perry",
                    "Uri" : "email-brian.perry@live.com/Profiles",
                    "Email" : "brian.perry@live.com"
                }
            ],
            "BaseUri" : "https://user-ctp.windows.net/V0.1/",
            "Categories" : [
                {
                    "Label" : "Mapping",
                    "Name" : "Mapping",
                    "Scheme" : "http://user.windows.net/Resource"
                }
            ],
            "Id" : "urn:uuid:00000000-0000-0000-0000-000000000000",
            "LastUpdatedTime" : "/Date(1228413012000)/",
            "PublishDate" : "/Date(1228413012000)/",
            "SelfLink" : "Mesh/MeshObjects/WA6OMIZL7IGEFNJCCBFQG47V3U/Mappings/AAAAAAAAAAAAAAAAAAAAAAAAAA",
            "Title" : "",
            "GhostingPolicy" : 0,
            "MappingType" : 1,
            "MeshObjectLink" : "Mesh/MeshObjects/WA6OMIZL7IGEFNJCCBFQG47V3U"
        }
    ],
    "SelfLink" : "Mesh/MeshObjects/WA6OMIZL7IGEFNJCCBFQG47V3U/Mappings",
    "SubscriptionLink" : "Mesh/MeshObjects/WA6OMIZL7IGEFNJCCBFQG47V3U/Mappings/Subscriptions",
    "Title" : "Mappings"
}

2. Members – Every mesh object can be shared with multiple people in various capacities. E.g., I can share a mesh object that contains all my photos with my spouse (another Windows Live ID user) such that she can edit / delete / add more photos in that mesh object and with my friends such that they can only read them. Every entry in the members feed provide information on every user who has access to the given mesh object and the type of access they have (e.g. RO or RW). More information on various properties is available here. JSON representation of Members feed with a single entry is as follows –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Entries" : [
        {
            "AuthorProfileLink" : "email-brian.perry@live.com/Profiles",
            "Authors" : [
                {
                    "Name" : "Brian Perry",
                    "Uri" : "email-brian.perry@live.com/Profiles",
                    "Email" : "brian.perry@live.com"
                }
            ],
            "BaseUri" : "https://user-ctp.windows.net/V0.1/",
            "Categories" : [
                {
                    "Label" : "Member",
                    "Name" : "Member",
                    "Scheme" : "http://user.windows.net/Resource"
                }
            ],
            "Id" : "urn:uuid:00eb8df1-16ff-4c95-93a7-9ea3199b05b1",
            "LastUpdatedTime" : "/Date(1227561909000)/",
            "PublishDate" : "/Date(1227561909000)/",
            "SelfLink" : "Mesh/MeshObjects/U5CVWTZDBTRE7GKU623MLYZCOA/Members/6GG6WAH7C2KUZE5HT2RRTGYFWE",
            "Title" : "Brian Perry",
            "Email" : "brian.perry@live.com",
            "IsOwner" : true,
            "ProfilesLink" : "cid--4392929366419723837/Profiles",
            "Role" : 1
        }
    ],
    "SelfLink" : "Mesh/MeshObjects/U5CVWTZDBTRE7GKU623MLYZCOA/Members",
    "SubscriptionLink" : "Mesh/MeshObjects/U5CVWTZDBTRE7GKU623MLYZCOA/Members/Subscriptions",
    "Title" : "Members"
}

3. News – Whenever a data entry is added, updated or deleted under a given mesh object, the system automatically generates news events. These are also generated whenever there is an addition / deletion to the members feed or mappings feed for the mesh object. Each such news event forms an entry in the news feed for the given mesh object. More information on various properties is available here. JSON representation of a news feed with a single entry is as follows –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Entries" : [
        {
            "AuthorProfileLink" : "email-brian.perry@live.com/Profiles",
            "Authors" : [
                {
                    "Name" : "Brian Perry",
                    "Uri" : "email-brian.perry@live.com/Profiles",
                    "Email" : "brian.perry@live.com"
                }
            ],
            "BaseUri" : "https://user-ctp.windows.net/V0.1/",
            "Categories" : [
                {
                    "Label" : "NewsItem",
                    "Name" : "NewsItem",
                    "Scheme" : "http://user.windows.net/Resource"
                }
            ],
            "Id" : "urn:uuid:96777b22-65d2-0782-e4ec-2f85d7831f26",
            "LastUpdatedTime" : "/Date(1225297814000)/",
            "PublishDate" : "/Date(1225297814000)/",
            "SelfLink" : "Mesh/MeshObjects/S35IOSATGIMU3L5K2Y5HBLSW3M/News/ULXR63FDIIHU3LNMZZNYGW6RRI-EJ5XPFWSMWBAPZHMF6C5PAY7EY",
            "Title" : "LiveMesh.MemberAdd",
            "CoalesceCount" : 1,
            "Contexts" : [
                {
                    "Kind" : "Scope",
                    "Relationship" : "LiveFX/MeshObject",
                    "TargetLink" : "Mesh/MeshObjects/S35IOSATGIMU3L5K2Y5HBLSW3M",
                    "Text" : "Documents",
                    "Type" : "LiveFX/MeshObject"
                }
            ]
        }
    ],
    "SelfLink" : "Mesh/MeshObjects/S35IOSATGIMU3L5K2Y5HBLSW3M/News",
    "SubscriptionLink" : "Mesh/MeshObjects/S35IOSATGIMU3L5K2Y5HBLSW3M/News/Subscriptions",
    "Title" : "NewsFeed"
}

4. Subscription – Users can subscribe to changes to mesh objects such that they can be notified and can potentially take appropriate actions. We will discuss more about this when we talk about notifications and subscriptions in another post.

Other important resources exposed via Mesh in addition to Mesh Objects are

1. Devices – Information on all the devices on which all or some of the mesh objects are synchronized is available via the devices feed where each entry in the feed provides information on a single device. More information on the various properties exposed via devices entry is available here. JSON representation of Devices feed is as follows –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Entries" : [
        {
            "BaseUri" : "https://user-ctp.windows.net/V0.1/",
            "Categories" : [
                {
                    "Label" : "Device",
                    "Name" : "Device",
                    "Scheme" : "http://user.windows.net/Resource"
                }
            ],
            "Id" : "d61585ef-1d67-4d48-9b44-e0047ab93adf",
            "LastUpdatedTime" : "/Date(1226685229000)/",
            "PublishDate" : "/Date(1226685229000)/",
            "SelfLink" : "Mesh/Devices/7O5BXLSH2O7UDDAM7VG5SNBJSM-56CRLVTHDVEE3G2E4ACHVOJ234",
            "Title" : "MESHDEMO1",
            "SubscriptionLink" : "Mesh/Devices/7O5BXLSH2O7UDDAM7VG5SNBJSM-56CRLVTHDVEE3G2E4ACHVOJ234/Subscriptions",
            "Type" : "Computer"
        }
    ],
    "SelfLink" : "Mesh/Devices",
    "SubscriptionLink" : "Mesh/Devices/Subscriptions",
    "Title" : "Devices"
}

2. News – Collective information on all the news entries for all the mesh objects and global news related to the user is available via the news feed where every entry represents a single news event.

Mesh and all the resources underneath it can be accessed via the service endpoint. The service endpoint in the cloud is https://user.window-ctp.net and on the client is http://localhost:2048. In addition to Mesh, you can also access Windows Live Profiles and Windows Live Contacts via the cloud service endpoint. They are represented as Profile and Contact resource. More information on Contact resource is available here. JSON representation of a contact is as follows –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Categories" : [
        {
            "Label" : "Contact",
            "Name" : "Contact",
            "Scheme" : "http://user.windows.net/Resource"
        }
    ],
    "Id" : "8129b749-ebe2-4257-854e-bd2c4eb0094c",
    "LastUpdatedTime" : "/Date(1225296671853)/",
    "SelfLink" : "cid--4392929366419723837/Contacts/8129b749-ebe2-4257-854e-bd2c4eb0094c",
    "Title" : "Brian Perry",
    "Birthday" : "/Date(-62135568000000)/",
    "Cid" : -1415099226309944575,
    "ContactId" : "8129b749-ebe2-4257-854e-bd2c4eb0094c",
    "DisplayName" : "Brian Perry",
    "Emails" : [
        {
            "Primary" : true,
            "Type" : 1,
            "Value" : "brian.perry@live.com"
        }
    ],
    "FamilyName" : "Perry",
    "FormattedName" : "Brian Perry",
    "GivenName" : "Brian",
    "NickName" : "Brian",
    "PreferredUserName" : "brianperry",
    "Profession" : "Photographer",
    "ProfilesLink" : "cid--1415099226309944575/Profiles",
    "WindowsLiveId" : "brian.perry@live.com"
}

There are 5 profiles that are available for every user – About You Profile, Contact Profile, Work Profile, General Profile and Interests Profile. You can get more information on these profiles here. JSON representation of About You Profile is as follows –

{
    "BaseUri" : "https://user-ctp.windows.net/V0.1/",
    "Categories" : [
        {
            "Label" : "Profile",
            "Name" : "Profile",
            "Scheme" : "http://user.windows.net/Resource"
        },
        {
            "Label" : "AboutYouProfile",
            "Name" : "Profile",
            "Scheme" : "http://user.windows.net/Resource"
        }
    ],
    "Id" : "480u7Y0U",
    "SelfLink" : "cid--4392929366419723837/Profiles/480u7Y0U",
    "Title" : "AboutYouProfile",
    "ProfileBase" : {
        "__type" : "AboutYouProfile:http://user.windows.net",
        "Age" : 31,
        "Gender" : 2,
        "Interests" : "Coding\u000aReading books\u000aHiking\u000aXBOX!",
        "Location" : "Redmond, WA",
        "MoreAboutMe" : "I like to write code!",
        "Occupation" : "Engineer"
    },
    "ProfileType" : 2
}

To learn how to do basic operations on these resources, see the SDK documentation topics:

In upcoming posts we'll talk about Applications, Subscriptions and Notifications, and Synchronization of resources.

--The Live Framework Team

What Problems Are We Trying to Solve?

2008-12-03T03:34:00Z

As we hear from more and more developers who have started using the Live Framework or who are trying to understand it, it’s clear that some of you would like us to expand more on what the Live Framework is, the problems we are trying to solve, and why developers should care about it. So, we have put together this whitepaper to help answer some of these questions. All the ideas in this paper will eventually make their way into our core documentation and Web site.

Your feedback is, as always, welcome.

--The Live Framework Team

Live Web Cast Coming Dec 8th! Please Join Us.

2008-12-02T01:43:00Z

The Live Framework team would like to invite you to join the first webcast and chat event for the Live Framework. During the session, you will have a chance to hear from the Microsoft engineering team that architected and developed the Live Framework. The session will be held from 8am PST to 10am PST on Dec 8th, 2008.

The agenda for the session:

8:00am – 8:30am: Introduction to tne Live Framework, Overview of support resources

8:30am – 8:45am: Live demonstration of sample application development.

8:45am-10:00am: Open Q&A.

If there are any questions in-depth technical/coding questions that you would like us to cover as part of Q&A, you can post them in advance on this forum thread. We will try to cover as many as we can.

Joining and viewing online Webcast

You can join the online webcast using any standard browser here: https://www.livemeeting.com/cc/microsoft/join?id=LiveFx_Dec8&role=attend

Alternatively, you can dial-in to listen to audio using these numbers and participant pass-code.

Toll Number :

BELGIUM	+32-3-400-2811
DENMARK	+45-7014-0278
FRANCE	+33-1-70-70-62-75
GERMANY	+49-69-2222-7227
HONG KONG	+852-2286-5645
IRELAND	+353-1-247-5443
JAPAN	+81-3-5539-5167
SWITZERLAND	+41-44-580-6291
USA	+1-203-480-8000

Toll Free / Freephone :

AUSTRALIA	1-800-202-713
BRAZIL	0800-8911983
NEW ZEALAND	0800-448-997
USA	866-500-6738

Participant Passcode:

1957172

Thank you very much for your participation. We look forward to hearing from you.

Live Framework Team

Live Framework CTP Updated

2008-11-21T23:09:30Z

We are pleased to announce that we deployed an update to the Live Framework CTP. This update contains a number of fixes. Please see below for details.

Thank you to the developer community for trying out the Live Framework CTP and taking time to submit your feedback. Many fixes made in this update were a result of the issues reported by the community via the Live Framework Developer Connection and the Live Framework Forum.

Version numbers for this release

Live Framework Developer Sandbox: 0.9.3519.1
Live Framework Client: 0.9.3519.1
Live Framework SDK: 0.9.3519.1

Installing the Updated Live Framework Client

To install the updated Live Framework Client:

Sign-in to the Live Framework CTP Developer Sandbox.
Navigate to the Devices Tab.
Click "Add Device." (Note: To update the Live Framework client, you need to re-add any pre-existing devices in your Mesh.).
Choose the correct pperating system for your client from drop down and click "Install."
Download the LiveFrameworkClient.msi file to your desktop.
Run LiveFrameworkClient.msi to install the latest client bits.

Updating Mesh-enabled Web Applications from the Application Catalog

We have improved the application synchronization experience with this update. To ensure you have the latest updates for your Mesh-enable Web applications synchronized to your client devices, you should do the following (note that the four apps in the Application Catalog have all been updated with this latest release):

Close running instances of the applications on both the Live Desktop and all your devices.
Launch these applications in the Live Desktop. This will initiate the application synchronization to your devices.
On the device, wait while the application is synchronized, then launch the application.

For installing Mesh-enabled Web Applications for the first time, please refer to “Installing and Running a Mesh-enabled Web Application”

Fixes

Some of the fixes in this update are listed below.

The Live Framework client has number of fixes related to Mesh-enabled Web Application synchronization and performance.
The Profile resource is now accessible through Mesh-enabled Web Applications.
Mesh-enabled Web Applications can now access their Offers on the client.
Mesh-enabled Web Applications can be successfully updated and synced to devices using Live Framework Tools for Visual Studio.
ScriptUrl is fixed for the RunAtServer method to refer to http://user-ctp.windows.net/V0.1/Script.

Feedback

Thanks for being one of the first to use Live Framework. We would appreciate any feedback you have. You can submit (and view others’) feedback and bugs here on the Microsoft Connect Web site or ask questions from our public forum.

Thank you,
The Live Framework team

Live Framework Team Blog

Hello from the Live Framework Team

2008-11-14T02:01:00Z

We're proud of the recent Live Framework CTP release, and we are excited to share our thoughts, tips, and insights with you. In this initial post to our new team blog, we want to provide you with some key links and info and let you know some of the subjects we’ll be addressing in the near future.

What is the Live Framework?

The Live Framework is the uniform way for programming Live Services from a variety of platforms, programming languages, applications and devices.

How do I find out more about the Live Framework?

Besides keeping an eye on this blog, you should start with the Live Framework home at http://dev.live.com/liveframework and visit the SDK docs on MSDN.

Also, see this post from David Treadwell, introducing the Live Framework, this Channel 9 video going deep on how the framework is architected, or these PDC sessions drilling into different aspects of new technology.

How do I join the Community Technical Preview (CTP)?

Space is currently limited, but we are working on expanding the number of devs in the program. You can request access through our Microsoft Connect site. As we are in still in early development of the Live Framework, the CTP environment is isolated from the main end-user environment of www.mesh.com. Consider this a sandbox for you to test out the technology and provide us feedback in our engineering efforts.

So, what are you going to do here, on this blog?

Over the next couple of weeks, members of the Live Framework team will be digging into various aspects of the Live Framework, providing background on the architecture, offering tips, tricks and code, and letting you know how our ongoing engineering efforts are progressing.

Here is just a sample of some of the topics we’ll be discussing in the coming weeks and months:

Our motivation in developing the Live Framework
Principles guiding our design
Using the addressing model to access resources
Using resource scripts
Querying across Live Framework resources
Building custom types and objects using the extensibility model
Synchronizing data in Live Framework
The Live Framework application model

Please use the comments to let us know what you think and what you’d like to see discussed here. We’re looking forward to sharing with, and hearing from, you.

Technical issues or questions? See our forum.

Thanks,

The Live Framework Team