The Brain Dump : Live Mesh

Important Updates to Live Services!

benwilli — Fri, 21 Aug 2009 19:58:46 GMT

from the Live Services blog : Important Updates to Live Services

Starting September 8th, 2009 the Live Framework CTP (services, SDK & Tools) will be unavailable.

The Live Framework will be integrated into the next release of Windows Live. Stay tuned to dev.live.com for more details in the future.

There are a few other items but the people I’ve worked with over the past year likely are most affected by the Live Framework change.

Please see the whole article for details. Make sure any data you need that is currently in the Live Framework CTP (not Mesh, Live Mesh will remain available to end users and is not affected) needs to be copied because “Microsoft will not retain any data and/or solutions that are a part of the Live Framework CTP offering.”

Thanks again to everyone for your participation and feedback!

Disowning a mesh folder

benwilli — Thu, 05 Feb 2009 01:54:22 GMT

Small tip: If you have a folder in your mesh that someone else shared to you before the permissions were updated to allow “read only” permissions, you are still an “owner” on the folder.

Today I was copying a 1.2GB folder around and accidentally dropped it onto someone else’s folder which I need read access to but I don't contribute to. After a minute I realized the problem and deleted the folder, but the news feed shows that I was an idiot and announced it to everyone on the folder.

Luckily this wasn’t personal data! Also, being an owner of the folder, I was able to manage the member’s list and kick myself off so now I’m just a reader.

Meshing in C++ (CLI)

benwilli — Mon, 08 Dec 2008 22:54:38 GMT

I recently was asked about accessing the Live Framework from C++. Taking this from the standpoint of “Hey, I have a regular old C++ application. How can I start putting my stuff into Live Services using Live fx?” there are a couple of options.

REST/XML
C++ CLI Interop

These are reasonable alternatives depending on your particular team and your business needs. And yes, there are a few other unreasonable options such as rewriting your whole app in managed code, using .NET/COM interop to talk to the .NET toolkit, or writing your own JSON parser while heavily using the __asm keyword just for fun, but I’ll just forget you mentioned that and move along.

REST/XML

If you have an application which is already doing XML manipulation, then you may already have the skills and libraries in place to just start using Live fx directly. This would be just the same as if you were using java, python, php or whatever language currently doesn’t have a toolkit available. You just grab an XML library you are comfortable with and starting PUTing and GETing your way into your user’s Mesh.

C++ CLI Interop

This is where I think I would end up – mainly because I’m an old C++ hack who lives in a C# world now. With C++ CLI available, you can easily take just a single file or your whole project and build it with the capability to interact natively with .NET assemblies. Since the Live Framework SDK comes with a .NET toolkit, your application can call into the managed Live fx classes directly from C++.

In C++ you could list all the meshObjects like this

LiveOperatingEnvironment^ loe = gcnew LiveOperatingEnvironment(); 
loe->ConnectLocal(); 
Mesh^ mesh = loe->Mesh; 
IQueryable<MeshObject^>^ meshObjects = mesh->CreateQuery<MeshObject^>(); 
for each (MeshObject ^ mo in meshObjects) 
{ 
  Console::WriteLine(mo->Resource->Title); 
}

There is fairly straightforward and not too much different than C#, right? Well now comes the fun part – LINQ queries.

LINQ queries are very useful in the Live fx toolkits, because the toolkit can examine the queries and potentially send it over the wire to run on the server instead of running locally. The problem is that C++ doesn’t natively support LINQ. It can of course call the underlying classes and interfaces that actually run LINQ under the covers but it becomes pretty ugly when trying to do it directly.

Lets add a “simple” LINQ query to just find all the Mesh Objects that are titled “Documents”. For those Lambda expression guys out there this is ‘mo => mo.Resource.Title == “Documents”’

LiveOperatingEnvironment^ loe = gcnew LiveOperatingEnvironment(); 
loe->ConnectLocal(); 
Mesh^ mesh = loe->Mesh; 
IQueryable<MeshObject^>^ baseQuery = mesh->CreateQuery<MeshObject ^>();

// Define the left side of the lambda expression
ParameterExpression^ meshObj = 
    Expression::Parameter(baseQuery->ElementType, "meshObj");

// Define the right side of the lambda expression
// Need to use the PropertyInfo because of ambiguous 
// reflection of derived types
System::Reflection::PropertyInfo^ propInfo = 
    baseQuery->ElementType->GetProperty(
        "Resource", 
        Microsoft::LiveFX::ResourceModel::MeshObjectResource::typeid
    );
MemberExpression^ resourceProp = 
    Expression::Property(meshObj, propInfo);

// retrieve Title property of Resource property
MemberExpression^ titleProp = 
    Expression::Property(resourceProp, "Title");

// do the compare
Expression^ leftSide = titleProp;
Expression^ rightSide = Expression::Constant("Documents");
Expression^ finalExpression = Expression::Equal(leftSide, rightSide);
Expression<Func<MeshObject^,bool>^>^ whereExpression = 
    Expression::Lambda<Func<MeshObject^,bool>^>(finalExpression, meshObj);

IQueryable<MeshObject^>^ whereQuery = 
    Queryable::Where<MeshObject^>(baseQuery, whereExpression);

for each (MeshObject ^ mo in whereQuery)
{
    Console::WriteLine(mo->Resource->Title);
}

That little query just added a whole lot of complexity because we have to build the expression tree by hand. Again, C++ doesn’t support LINQ syntax – but the queries are extremely useful and you are probably going to end up using them quite a bit. So how do we simplify this? We interop to our own C# assembly instead. In C# this same code collapses to

LiveOperatingEnvironment^ loe = gcnew LiveOperatingEnvironment(); 
loe->ConnectLocal(); 
Mesh^ mesh = loe->Mesh; 

var meshObjects = from mo in mesh.CreateQuery<MeshObject>()
    where mo.Resource.Title == "Documents"
    select mo;

foreach (MeshObject mo in meshObjects)
{
    Console.WriteLine(mo.Resource.Title);
}

Using C++ CLI, you can continue to work your main application logic in C++ if you want, and then just call into a separate DLL which talks to the Mesh in C# (or VB) to greatly simplify your development effort.

The point is, C++ is not left out in the cold; but for any LINQish query filtering/ordering you do, I would do it in a separate .NET assembly to handle it in a language that handles the LINQ syntax naturally. Unless of course you enjoy building your own expression trees.

Navigating LiveFX with .NET

benwilli — Tue, 18 Nov 2008 20:37:52 GMT

When first given a new SDK, what I do is immediately try to figure out the object model. This is how I try to understand what the SDK developer’s intent was and how he thinks I will or should use the new tools provided. Since documentation on the object model for the Live Framework toolkits is still in development today, I’d like to take a quick look of some pieces of the object model from a consumer’s perspective.

Here is the Resource Model from the SDK (http://msdn.microsoft.com/en-us/library/dd137022.aspx)

Everything in this hierarchy is either derived LiveItem or is a collection of those items. The LiveItem provides all the top level functionality needed to navigate the resource model and identify which nodes a developer is trying to find or modify. If you look at the methods provided by the LiveItem base class, they fit that model. For instance, there are methods to Load the data into the local object from the Live Framework, update it, and a Resource property to get to the actual data itself. The classes derived from LiveItem (e.g. MeshObject, Profile or DataFeed) provide additional members that are specific to their place in the resource hierarchy. For instance, the MeshObject contains a collection of the DataFeeds and the device Mappings.

Each LiveItem derived class is actually derived from LiveItem<TResouce> as seen in the following diagram.

The TResource property is a generic type that is defined by the derived type. The generic type provided to LiveItem as TResouce also must be derived from Resource. This is where the tight coupling between the LiveItems and the Resource items is created. For each LiveItem derived class, there is a corresponding Resource derived class.

So the definition of the MeshObject looks like this in C#

public class MeshObject : LiveItem<MeshObjectResource>

The Resource derived classes provide the actual data found at each node in the resource model, and is retrieved by accessing the Resource property of the LiveItem in question. For example, in order to inspect a DataFeeds properties such as Title or Type, you need to first navigate to the DataFeed in question through the resource model (e.g. Mesh->MeshObjects[0]->DataFeeds[0]) and then access the Resource property of the resulting DataFeed object. This property will be of type DataFeedResource and will have all the instance data for that data feed as well as any user defined data that was stored there.

So, to sum up, the resource model for the Live Framework Toolkit is primarily made up of two object types: LiveItem and Resource. Both these types are used as base classes for all the various node types within the resource model. And each one is paired with a corresponding derived type of the other. The LiveItem objects are used for resource model navigation and hierarchy updates. The Resource classes are used to store the data within the resource model nodes.

But what can I do with it?

benwilli — Fri, 14 Nov 2008 18:24:07 GMT

If you have expressed confusion about what the Live Framework is about, who can use it, or just plain “What can I do with it?!” then check out Danny Thorpe’s article How Do I Mesh Thee? Let Me Count The Ways. He breaks it down clearly and concisely and you may just be a bit surprised at what you can do!

Wallpaper your desktop with Mesh

benwilli — Wed, 12 Nov 2008 18:44:40 GMT

Due to popular demand, yesterday Vikas posted a zip file with a bunch of the various Live Mesh desktop backgrounds.

http://dev.live.com/downloads/resources/LiveServicesBackgrounds.zip

Mesh continues to expand availability

benwilli — Mon, 18 Aug 2008 22:06:55 GMT

In order to expand testing of the underlying technology, the Mesh team continues to expand the availability of the platform experience preview. You can now sign-up without a wait list in Canada, India and Ireland also (although you still need to run with an English locale for now.)

Angus Logan put together a map of all the countries where it is available for quick reference.

Live Mesh is now openly available to anyone in the U.S.!

benwilli — Wed, 16 Jul 2008 18:20:16 GMT

As announced in the Live Mesh Forum, anyone in the U.S. can now use Live Mesh. Just sign in to www.mesh.com with a valid Windows Live ID.

This is great news as the limited invites available earlier made me think a lot harder about using this to share data. No more "Hmmm, are you Mesh Invite worthy?" :)

Live Mesh update

benwilli — Fri, 11 Jul 2008 22:55:12 GMT

I love that even though its a Tech Preview, they keep rolling out updates with new features. Especially the ones that people keep asking about.

My favorite for this release - Sync Live Mesh folders peer-to-peer only, excluding your Live Desktop. This means if you don't want your files stored in the cloud they won't be. They will just sync from device to device.

Technorati tags: Live Mesh