Music is something we at VerySoftware love. Whether it’s music to work to, music to relax to, music to dance to or music to rock out to, we believe that there is a tune for every moment. Most importantly, we feel that music is something to be shared. This is the inspiration behind our latest creation – Tunee.

There are many services available to purchase or stream music over the internet, but while this has made getting access to music easier than ever, it’s made it hard to share music between people with preferences for different services. Tunee allows you to forget about all that and create a single link (or URL) to share a piece of music with friends who can then instantly access the music on the service of their choice.

How Does It Work

paste your long url or search for music	share the tunee link with your friends	your friends enjoy the music in any app they like

The best way to see how Tunee works is to give it a try, so head over to http://tun.ee and take a look. There are two ways to start using Tunee: either search for the artist/album/track you want to share from the Tunee homepage or paste in a ‘share’ link/URL from the music service of your choice (i.e. http://open.spotify.com/album/7Gu2d2XmbFFQQowcOEVYeA) and then hit “Go”.

Tunee will generate a short link for you (i.e. http://tun.ee/1o), which can then be Tweeted, Liked, G+’d or simply copy/pasted to your friends and followers. When your friends click the link they’re presented with a list of available services to access that piece of music on, so they can click their favourite and start listening. It’s as simple as that!

The Future

Tunee has only just been released in Alpha and we’re still hard at work on it. Over the next few weeks and months we are planning to support additional services (such as Last.FM, Pandora, Amazon MP3, Grooveshark, etc.) where possible as well as iron out any kinks that pop up along the way.

We’re also working out the best way to allow 3rd Parties to use Tunee via an API, so if you’re interested in that give us a shout. If you have any requests for additional services, features or just general comments please send us a mail to tunee@verysoftware.co.uk

Go forth and “share the music”, then let us know what you think.

So what’s the problem? Well when a user reinstalls your app they have to start from scratch, any settings/customisations they make to your app are lost and this barrier to re-entry can sometimes force users to simply go elsewhere. In an ideal world a user should be presented with the option to restore their settings/customisations to you app when they load it for the first time after the uninstall/on the new device. Obviously any settings stored in Isolated Storage are lost so if you want to provide this experience you will need to save these settings in the cloud.

The process is quite simple, when the app is running a ‘backup’ of the user’s settings are sent to the cloud along with the User ID. Whenever the application loads it checks the isolated storage for the settings, meaning that an app can have fast and offline loading, but if no settings are found locally then a request for the settings matching the current User ID is sent to the cloud. If settings for that user are found in the cloud then they are returned and the application should prompt the user to ask if they want these settings restored. A key point here is to ask the user at this point for 2 reasons, firstly the user may have intentionally uninstalled the application so that they can start from scratch, or the user’s settings may be causing the bug which forced them to uninstall it to start fresh. Thanks to the simplicity of these steps this code can easily be added to any existing application without any major refactors of code.

At this point many people will say that while this process sounds simple the ‘scary’ part is the use of the world ‘cloud’, as cloud services can be complex and expensive which often doesn’t make sense for a small phone application. However I will demonstrate below that implementing a simple WCF Web Service like this is very simple and is lightweight enough to run on the lowest cost Azure instance (or even share an instance with other cloud services you may be running). For more information on the cost of Azure hosting take a look here, or if you are a startup I’d highly recommend looking into Microsoft’s BizSpark scheme in which you can get lots of Azure usage (and may other benefits and Microsoft software) for free!

Implementation – Client Side

The implementation of this consists of 2 parts, the client side and the server/cloud side. All code snippets are taken from our TechDays Sample app and are available here, in this sample the only user settings we have is the list of ‘followed’ sessions, but you should be able to see how this can be extended to include whatever settings your app needs.

First, in the background function where we load our settings from Isolated Storage and then apply them, we need to add in the extra logic to fire off a simple Web Service call if no settings are loaded. Then once the Web Service call returns we need to respond appropriatley as explained above. The code to do this is shown below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

void BackgroundLoadFavouriteSessions(object sender, DoWorkEventArgs e)
{
    var favIDs = LoadFavouriteSessionsFromFile();
    if (favIDs == null)
    {
        // We failed when loading from file so check the cloud store
        CloudUserDataServiceClient client = new CloudUserDataServiceClient();
        client.GetStoredTechDaysUserDataCompleted += client_GetStoredTechDaysUserDataCompleted;
        client.GetStoredTechDaysUserDataAsync(HelperFuncs.UserID);
    }
    else
    {
        // Loaded from file successfully so use this data
        SetFavourites(GetSessionListFromIDs(favIDs));
    }
}
void client_GetStoredTechDaysUserDataCompleted(object sender, GetStoredTechDaysUserDataCompletedEventArgs e)
{
    if ((e.Error == null) && (e.Result != null) && (!String.IsNullOrEmpty(e.Result.FavouriteIDs)))
    {
        if (MessageBox.Show("Would you like to restore your settings for this app?", "No settings found", MessageBoxButton.OKCancel) == MessageBoxResult.OK)
        {
            var favouriteSessionList = GetSessionListFromIDString(e.Result.FavouriteIDs);
            SetFavourites(favouriteSessionList);
        }
    }
}

Also at some other point while the application is running we want to send the app’s current settings off to the Web Service, like so:

1
2
3
4
5
6
7
8
9
10

private void SaveFavouritesToCloud(string favIDString)
{
    TechDaysUserData saveData = new TechDaysUserData()
    {
        UserID = HelperFuncs.UserID,
        FavouriteIDs = favIDString
    };
    CloudUserDataServiceClient client = new CloudUserDataServiceClient();
    client.StoreTechDaysUserDataAsync(saveData);
}

Both these code blocks are fairly standard Web Service calls, the only potentially unknown thing here is how to retrieve the user’s ID. This is shown in the following block of code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

private static string cachedUserID = null;
public static string UserID
{
    get
    {
        if (cachedUserID == null)
        {
            string anid = UserExtendedProperties.GetValue("ANID") as string;
            if (anid != null)
            {
                cachedUserID = anid.Substring(2, 32);
            }
            else
            {
                cachedUserID = "EMULATOR_USER";
            }
        }
        return cachedUserID;
    }
}

This is just a wrapper around the Microsoft API to retrieve the User Extended Property but we add some caching here to improve performance, and strip away part of the string to provide an anonymous User ID. More information on this is available via the MSDN page. That is all the client side code that you will need to add into your existing application, now onto the server side.

Implementation – Cloud Side

If you have ever used Azure Table Storage before the following code should look very simple, if you haven’t then I’d suggest having a quick read up on it as I won’t go into great detail about it here. The same also applies here for WCF Web Services.

The first thing we want to do on the Azure/Cloud side is create the structures for holding our User Settings, the code below describes the Azure Table Storage Table and Entity that will be used to hold this data:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

public class TechDaysDataEntryContext : TableServiceContext
{
    public static string TableName = "TechDaysDataEntrys";
    public TechDaysDataEntryContext(CloudStorageAccount account)
        : base(account.TableEndpoint.ToString(), account.Credentials)
    {
    }
    public IQueryable<TechDaysDataEntry> TechDaysDataEntrys { get { return this.CreateQuery<TechDaysDataEntry>(TableName); } }
    public void AddTechDaysDataEntry(TechDaysDataEntry newEntry)
    {
        this.AddObject(TableName, newEntry);
        this.SaveChanges();
    }
}
public class TechDaysDataEntry : TableServiceEntity
{
    public string UserID
    {
        get { return PartitionKey; }
        set { RowKey = value; PartitionKey = value; }
    }
    public string FavouriteIDs { get; set; }
    public TechDaysDataEntry() { }
    public TechDaysDataEntry(string UserID, string inFavouriteIDs)
    {
        PartitionKey = UserID;
        RowKey = UserID;
        FavouriteIDs = inFavouriteIDs;
    }
}

That is the Azure Table Storage code out of the way, the next thing we need to do is write the WCF Web Service to provide access to/from the storage. The code for those two functions is below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

public TechDaysUserData GetStoredTechDaysUserData(string userID)
{
    var storageAccount = GetStorageAccount();
    var tddeContext = new TechDaysDataEntryContext(storageAccount);
    tddeContext.IgnoreResourceNotFoundException = true;
    var result = (from entry in tddeContext.TechDaysDataEntrys
                    where entry.PartitionKey == userID && entry.RowKey == userID
                    select entry).ToList();
    if (result.Count == 1)
    {
        var entry = result.First();
        var userData = new TechDaysUserData()
        {
            UserID = entry.UserID,
            FavouriteIDs = entry.FavouriteIDs
        };
        return userData;
    }
    return null;
}
 
public void StoreTechDaysUserData(TechDaysUserData userData)
{
    var storageAccount = GetStorageAccount();
    var tddeContext = new TechDaysDataEntryContext(storageAccount);
    tddeContext.IgnoreResourceNotFoundException = true;
    var result = (from entry in tddeContext.TechDaysDataEntrys
                    where entry.PartitionKey == userData.UserID && entry.RowKey == userData.UserID
                    select entry).ToList();
    if (result.Count == 0)
    {
        var entry = new TechDaysDataEntry(userData.UserID, userData.FavouriteIDs);
        tddeContext.AddTechDaysDataEntry(entry);
    }
    else
    {
        var entry = result.First();
        entry.FavouriteIDs = userData.FavouriteIDs;
        tddeContext.UpdateObject(entry);
        tddeContext.SaveChanges();
    }
}

Then the final bit of code is a very simple class used for passing data between our Application and the Web Service:

1
2
3
4
5
6
7
8

[DataContract]
public class TechDaysUserData
{
    [DataMember]
    public string UserID{ get; set; }
    [DataMember]
    public string FavouriteIDs { get; set; }
}

And that’s it, everything you need to implement this feature. You will likely want to expand the settings that are saved, as well as consider your privacy policy around storing User’s data, etc. but I’ll leave that as an exercise for you.

This post was originally published on Roy’s personal blog at http://roybott.com/blog/wp7-app-settings-persistence.html but we brought it here to share with you.

So what about having a context menu on Windows Phone 7? Currently the most common approach is to show an overlay containing a set of buttons. This is a good approach when you don’t access context menu too often. But when used frequently you might find the following issues:

• Holding an item is way slower compared to a tap
• Overlay covers a great portion of the screen
• When clicked on the border between two items there is no way to know which item context menu corresponds to

That is why I came up with a slightly different approach.

Note: All the screenshots and code snippets are from VerySoftware talk at TechDays UK 2011, where our team was Blending Delicious User Experiences for Windows Phone 7, including me talking about nested MVVM and context menu. Feel free to download our Tech.Days WP7 app source code.

Concept

This type of context menu will mainly be useful in the ListBoxes where tapping an item doesn’t involve any action.

The idea of the context menu we are going to create is to attach a set of items (buttons most of the time) to an item in the list. Those buttons will be hidden and shown only when the user selects an item. Showing a context menu shifts other elements in the ListBox so they don’t overlay any of the UI elements.

I will use a demo Tech.Days app from our presentation as an example. Our final app will have an inline context menu that will contain two buttons:

• Share by email – shares selected session via email
• Add to favourites – adds selected session into a different ListBox, which contains all favourite sessions

Screenshot below shows the final result:

So that’s it about the idea, now let’s start punching in some code.

Step 1: Set Up

We start by creating a new WP7 project in Visual Studio where we will add our MVVM stuff:

• View – this is where our ListBox with sessions will be placed
• Model – contains a list of sessions available at UK Tech.Days
• ParentViewModel – treat this as a standard view model for now

View:

1
2
3
4
5
6
7
8
9
10
11
12

<ListBox x:Name="SessionList"
      Style="{StaticResource CoreListBoxStyle}"
      ItemContainerStyle="{StaticResource SessionListBoxItemStyle}"
      Margin="0,12,0,60"
      ItemsSource="{Binding SessionsVMs}"
      SelectionChanged="SelectedSessionChanged">
  <ListBox.ItemTemplate>
    <DataTemplate>
      <!-- A beautiful data template to be placed here -->
    </DataTemplate>
  </ListBox.ItemTemplate>
</ListBox>

Model:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public class Session : INotifyPropertyChanged
{
  // Other properties…
  public string ImagePath { get; set; }
 
  private bool isInFavourites = false;
  public bool IsInFavourites
  {
    get
    {
      return isInFavourites;
    }
    set
    {
      isInFavourites = value;
      InvokePropertyChanged("IsInFavourites");
    }
  }
}

ViewModel:

1
2
3
4
5
6
7
8
9
10
11
12
13

// Our model is only going to be used internally in ViewModel
private ReadOnlyObservableCollection<Session> _sessions;
 
// Nested child view models (will be described later)
public ObservableCollection<SessionViewModel> SessionsVMs{ get; private set; }
 
public SessionsViewModel()
{    
  SessionsVMs = new ObservableCollection<SessionViewModel>();
 
  // Retrieve items from a service
  _sessions = _techDaysDataManager.Sessions;
}

What we have created now is a pretty standard MVVM, apart from list of child ViewModels inside the ParentViewModel which we will discuss later. Now we are ready to start adding the juicy bits.

Step 2: DataTemplate = UserControl

Next thing we are going to add is a DataTemplate for each session, which will also contain our XAML for DataContext menu.

If you remember our intention was to have a context menu which is set to collapse and will be shown when the user taps on an item which is associated with the context menu. Also when user taps Add to favourites buttons we have to execute some code.

Here comes the first challenge: data template doesn’t have any code behind, and we can’t handle things like button clicks. I like to think of data template as an inflatable rubber toy which is inflated with data. So our XAML-only data template defines how our item looks but not how it behaves.

To overcome that challenge we set our DataTemplate to be a user control, which isn’t pure XAML and contains code behind, so it can handle things like events. Below is the simplified version of how it would look like:

View:

1
2
3
4
5

<ListBox.ItemTemplate>
  <DataTemplate>
    <local:SessionItem />
  </DataTemplate>
</ListBox.ItemTemplate>

DataTemplate:

1
2
3
4
5
6
7
8

<UserControl>
<!--
Here goes:
- Data template itself
- Data Context menu
- Button click events on the button controls
-->
</UserControl>

DataTemplate, Code Behind:

1
2
3

private void ShareButtonClicked(object sender, RoutedEventArgs e)
{
}

At this point we have our DataTemplate and item context menu UI code written. Screenshot below shows how our app should look like:

Now we have all UI elements in place and now we will bring them into life, by adding the logic.

Step 3: Adding Logic and Selection Problem

So let’s write some logic to handle the tapping of Add to favourites and showing/hiding the context menu.

Here comes the second challenge: it’s only the ListBox that is aware which item is selected in the ListBox and when this selection has changed. So we have to notify our items that they were selected/unselected.

Let’s for a moment pretend that we a using standard MVVM and our ViewModel contains an ObservableCollection of Sessions rather that child ViewModels. This means that each item in the ListBox will get its DataContext set to Session.

In that case ViewModel (Parent ViewModel) will have two options how to notify items about the selection:

1. As we have a list of Sessions, we can notify an appropriate session (model) that it was selected and then model would notify the view
2. Navigate the logical tree and set a visibility of the right context menu to visible

Second solution sounds a lot like a nasty hack and the first one adds code which shouldn’t be in the model, and in fact code which handles the state of the view which should go into ViewModel.

That’s when the nested MVVM comes into the picture.

Step 4: Creating a nested MVVM

Now I want to go back to our ViewModel code. If you remember there was a collection of ViewModels (SessionVMs), where we started nesting our ViewModels. What we are doing is wrapping a session inside another ViewModel (child ViewModel) and hold a collection of those inside our parent ViewModel.

ViewModel:

1
2
3
4
5
6
7
8
9
10
11
12

// Our model is only going to be used internally in ViewModel
private ReadOnlyObservableCollection<Session> _sessions;
 
// Nested child view models. This will be a CollectionSource of our ListBox
public ObservableCollection<SessionViewModel> SessionsVMs{ get; private set; }
 
public SessionsViewModel()
{    
  SessionsVMs = new ObservableCollection<SessionViewModel>();
  // Retrieve items from a service
  _sessions = _techDaysDataManager.Sessions;
}

Child ViewModel

1
2
3
4
5
6

public Session Session { get; private set; }
public SessionViewModel(Session session, IParentViewModel parentViewModel)
{
  Session = session;
  _parentViewModel = parentViewModel;
}

Essentially we wrap our existing model inside a ViewModel. Optionally we could provide a link back to the parent so they can communicate both directions. Now communication between our items will happen in the following way:

1. ListBox notifies a Parent ViewModel about newly selected item. Now VM has two options
2. Parent ViewModel finds an appropriate Child ViewModel and notifies it about selection/de-selection
3. Child ViewModel notifies the View by exposing a property which indicates if View is selected or not
4. View updates its visual to show/hide context menu

Step 5: Extra Stuff (Optional)

As previously mentioned we can pass a parent ViewModel reference to our Child ViewModel. Here are just a couple of scenarios of usage:

• Use as proxy for communication with the rest of application
• Notify a Parent ViewModel about the state of one of its child (for example an error), so the parent (ListBox) can show an appropriate sate

This is an example of how you can use an existing MVVM pattern in a slightly different way to achieve an interesting result. I hope you have found this post useful. You are more than welcome to check out our Tech.Days WP7 app source code. Stay tuned, there are more posts to come…

]]> http://verysoftware.co.uk/blog/nested-mvvm-creating-an-inline-context-menu-for-wp7/feed/ 2 http://verysoftware.co.uk/blog/wp7-error-reporting-done-simply/ http://verysoftware.co.uk/blog/wp7-error-reporting-done-simply/#comments Sun, 10 Jul 2011 11:22:51 +0000 Roy Herrod http://verysoftware.co.uk/blog/?p=277 Continue reading →]]> Part 3 in my series of blog posts covering the quick code Tips & Tricks I shared at UK Tech.Days, is about enabling your users to provide you with some useful information if things go badly with your Windows Phone 7 app.

Often on the marketplace I have seen apps that have multiple reviews by different users just saying things like “Crashes on startup!” or “Doesn’t work on my device!”, and as a developer I know its frustrating to see things like this when the app is working perfectly fine on your phone. While it would be nice for users to provide detailed repro’ steps and associated data, that’s not really likely to happen, but in my opinion the main thing you want as a developer is the Exception and a Call Stack of whatever is causing the app to crash.

Luckily, the App.xaml.cs file included in the standard Windows Phone project template includes a function named “Application_UnhandledException” which is called when an unhandled exception occurs and is the last point of call before the app closes and returns the user to the homescreen. This function is primarily used to allow the debugger to break into the app when debugging so that the developer can try to investigate the unhandled exception, however by adding a little bit of code to it you can provide users in the wild the ability to email the exception information to you.

The following code shows this function with the added ‘else’ block which asks the user if they would like to send the error details to the developer. If they accept then a new email task is created which contains the exception object information (the exception message and call stack). Clearly if you want to include more information then you can just add it to the body of the email:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

private void Application_UnhandledException(object sender, ApplicationUnhandledExceptionEventArgs e)
{
	if (System.Diagnostics.Debugger.IsAttached)
	{
		// An unhandled exception has occurred; break into the debugger
		System.Diagnostics.Debugger.Break();
	}
	#region Error Reporting code
	else
	{
		var result = MessageBox.Show("Would you like to email the details of this error to the Developer?
(No personal information, other than your email address, will be sent to the Developer)",
			"An error has occurred!",
			MessageBoxButton.OKCancel);
 
		if (result == MessageBoxResult.OK)
		{
			var task = new EmailComposeTask();
			task.To = "contact@DeveloperEmailAddress.com";
			task.Subject = "Error Report: TechDays 2011 App";
			task.Body = String.Format("An unhandled exception occurred in TechDays 2011 App:
{0}", e.ExceptionObject.ToString());
			task.Show();
		}
	}
	#endregion
}

The great things about this approach is that it can very easily be dropped into any app, requires no infrastructure/web service and as this is done via email, the user gets to clearly see and approve all information being sent. This is a good thing from a user’s perspective as they can see that no personal information (other than their email) is being shared.

This post was originally published on Roy’s personal blog at http://roybott.com/blog/wp7-error-reporting-done-simply.html but we brought it here to share with you.

Anyone who has had a bad experience with your application is motivated to go and leave it a scathing review, whereas the hundreds of people who loved your app may never even consider leaving it a good review. One way to counter this is to simply ask those users who like your app to leave you a review, however you don’t want to bug people too often or before they’ve had a real chance to use your application. So what can you do?

Well one suggestion that I’ve heard a few times is to wait until a user has run your application a number of times (say 10) and then throw up a message box asking them to rate your app. By waiting until the user has run the app a number of times you can be more confident in receiving a positive review because at this point chances are they like the app or they wouldn’t keep returning to it. To avoid bugging users too often you should increase the number of runs between each time you display the message box so that the user doesn’t feel like they are having to constantly hit ‘no’ every time they open the app. Also giving the user the option to never be asked again is a good way to say on their good side.

The following block of code can be dropped into any existing application and helps provide the above functionality:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

private static bool PerformedRatingPromptCheck = false;
private void PhoneApplicationPage_Loaded(object sender, System.Windows.RoutedEventArgs e)
{
    if (!PerformedRatingPromptCheck)
    {
        PerformedRatingPromptCheck = true;
 
        int numAppLaunches = 0;
        IsolatedStorageSettings.ApplicationSettings.TryGetValue("Rating_numAppLaunches", out numAppLaunches);
 
        int numNextRatingPrompt = 0;
        if (!IsolatedStorageSettings.ApplicationSettings.TryGetValue("Rating_numNextRatingPrompt", out numNextRatingPrompt))
        {
            numNextRatingPrompt = 5;
        }
 
        if (numAppLaunches >= numNextRatingPrompt)
        {
            IsolatedStorageSettings.ApplicationSettings["Rating_numNextRatingPrompt"] = numNextRatingPrompt * 2;
 
            NotificationBox.ShowAgain("Enjoying the app?",
                    "Would you like to rate this app now?",
                    "Ask me later",
                    false,
                    Surpressed => { },
                    "Rating_MsgPrompt",
                    new NotificationBoxCommand("Yes", () => { new MarketplaceReviewTask().Show(); }),
                    new NotificationBoxCommand("No", () => { }));
        }
 
        IsolatedStorageSettings.ApplicationSettings["Rating_numAppLaunches"] = numAppLaunches + 1;
    }
}

This code simply pulls two values out of the IsolatedStorageSettings, one that tracks the number of times the application has been run and one that tracks when you’re next going to show the prompt, and then displays the prompt if needed. If the user clicks the ‘Yes’ button on the prompt then a “MarketplaceReviewTask” is created and shown so that the user can leave your app a review.

You may have noticed that the ‘prompt’ the code above shows is not a standard Windows Phone MessageBox but is instead a ‘NotificationBox’. Tomer Shamam has created an incredibly handy DLL that provides a prompt that looks like the Windows Phone MessageBox but also allows you to have a tick box which can be unticked to cause the prompt to never be shown again. The result will look something like this:

So by simply downloading the NotificationBox DLL, referencing it in your application and then including the code snippet above you can hopefully dramatically increase the number of positive ratings/reviews your app receives.

This post was originally published on Roy’s personal blog at http://roybott.com/blog/getting-ratings-for-your-wp7-app.html but we brought it here to share with you.

Capture

We use Screen Capture tool from Microsoft’s Expression Encoder 4. It’s a free, easy-to-use and offers numerous settings. It will help you to select the correct capture area inside phone’s frame.

Encode

After the video is captured, send it to Encoder where you can make the final changes before exporting it into variety of encoding formats.

Embed

Now it’s time to embed the exported video into your website or presentation. We use standard Windows Phone Emulator frame with transparent background.

Storyboards for our AppTracker promo video were created and exported as WMV simply in PowerPoint:

For use on the website we upload it on YouTube. Its latest code for embedding uses HTML5 which allows viewing your video on devices like iPhone which don’t support Flash. A bit of positioning and clipping tweaks using CSS and your video player fits nicely inside the phone frame image.

Showcase

As a result you get an effective demo of your app ready to impress your clients, users, friends and colleagues. As simple as that!

Trial Mode

Adding a trial mode to an existing paid application is very easy to do and highly recommended, even if you also have a ‘free’ version of you app available on the marketplace, because it lowers the hurdle between a user seeing your application and a user making the purchase. Also improvements to the on phone Marketplace rumoured to be coming with the relelase of Mango this Fall will mean that paid applications with trials are highlighted more than those without.

The first thing you need to do when implementing a trial mode is figure out whether the current user of your application is using the paid version or the trial. The following code snippet enables you to do this and also provides a few other useful features:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

  private static bool? cachedIsTrialMode = null;
 
  public static bool IsTrialMode()
  {
      return IsTrialMode(false);
  }
 
  public static bool IsTrialMode(bool forceFromCache)
  {
      // If this code is being run buy VS/Blend design tool, we don't want to MessageBox
      if (DesignerProperties.IsInDesignTool)
          return false;
 
      if ((forceFromCache) || (cachedIsTrialMode == null))
      {
  #if DEBUG
          MessageBoxResult result = MessageBox.Show("Click ok to simulate paid version",
"Simulate paid version?", MessageBoxButton.OKCancel);
 
          if (result == MessageBoxResult.OK)
          {
              cachedIsTrialMode = false;
          }
          else
          {
              cachedIsTrialMode = true;
          }
  #else
          LicenseInformation licenseInfo = new LicenseInformation();
          cachedIsTrialMode = licenseInfo.IsTrial();
  #endif
      }
 
      return cachedIsTrialMode.Value;
  }

This block of code provides a wrapper around Microsoft’s LicenseInformation API and adds 2 key features. Firstly the block of code surrounded by #if DEBUG provides you with a very simple way of testing how a user experiences your app in both Trial and Paid modes, by offering the option when the app is launched in Debug. Secondly the result of the API call is cached, it is important to do this (especially if you are making frequent calls to it) because a call into that API can have a performance hit of ~60ms or more.

As we are caching the result of the first call into the LicenseInformaiton API we need the following block of code. By making a call to the IsTrialMode function in the Application_Launching and Application_Activated functions in App.xaml.cs we are ensuring that we are always using a correct result. Imagine if the user left your application, purchased it and then returned by pressing the back button, in this case the app would be rehydrated so we would therefore want to ensure we are not using an old cached value.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

  // Code to execute when the application is launching (eg, from Start)
  // This code will not execute when the application is reactivated
  private void Application_Launching(object sender, LaunchingEventArgs e)
  {
      #region Trial Mode code
      // Force a recheck of the IsTrialMode Flag
      Utilities.HelperFuncs.IsTrialMode(true);
      #endregion
  }
 
  // Code to execute when the application is activated (brought to foreground)
  // This code will not execute when the application is first launched
  private void Application_Activated(object sender, ActivatedEventArgs e)
  {
      #region Trial Mode code
     // Force a recheck of the IsTrialMode Flag
      Utilities.HelperFuncs.IsTrialMode(true);
      #endregion
  }

Finally we need to use the result of the IsTrialMode function; I’ve seen some very complicated ways of preventing users from accessing content in an app but in this example we simple display a semi-transparent ‘overlay’ (UI element) which literally blocks the user from being able to touch/interact with the content behind it. The overlay contains some text selling the application/feature to the user and a button allowing them to purchase the app. The code behind this button simply creates and shows a “MarketplaceDetailTask”:

1
2
3
4

  private void BuyAppButton_Click(object sender, RoutedEventArgs e)
  {
      new MarketplaceDetailTask().Show();
  }

To show/hide the Trial overlay we simply check the result of the IsTrialMode call and set the overlay’s Visibility property to either Visible or collapsed, like so:

1
2
3
4
5
6
7
8
9
10
11

  void VideosView_Loaded(object sender, RoutedEventArgs e)
  {
      if (HelperFuncs.IsTrialMode())
      {
          VisualStateManager.GoToState(this, "TrialWelcome", true);
      }
      else
      {
          VisualStateManager.GoToState(this, "DialogBoxesHidden", true);
      }
  }

So that’s it, everything you need to do to include a Trial Mode in your application.

For details of our TechDays talk take a look here, and for further reference about trial mode check the MSDN documentation.

This post was originally published on Roy’s personal blog at http://roybott.com/blog/wp7-trial-mode-done-simply.html but we brought it here to share with you.

A few weeks ago our team was “Blending Delicious User Experiences for Windows Phone 7” at Microsoft Tech.Days in London. Thank you everyone for coming, we really hope you have enjoyed our talk!

Our talk

We wanted to share experience developing Windows Phone 7 apps and show tips and tricks for designers and developers to help take their app’s user experience to the next level.

For starter we have shared our experience designing for Windows Phone

• transition from developing for the iPhone to Windows Phone
• our love for Expression Blend and great developer-designer workflow
• showcase of our latest apps – Polyglot and Gifts

For main we have demonstrated our award-winning AppTracker – the ultimate app for developers to track their apps’ performance on the Marketplace.

For dessert we served a selection of tips & tricks for designers and developers on the example of building a sample Tech.Days app:

• design-time data
• dummy data in code
• nested MVVM
• designing graphics
• information architecture
• transitions: page navigation, animating screen rotation
• trial mode
• getting ratings
• error reporting
• user settings in the cloud

Tech.Days sample app

We have made the source code for our sample Tech.Days Windows Phone 7 app available for download. The app is not fully ready for release onto the Marketplace as it uses locally cached data, but it is a great template/starting point for anyone wanting to create a companion app for a conference or event.

Slides and video

Presentation slides available for download and on slideshare. You can watch the entire talk below or on Tech.Days website:

We plan to cover the contents of our talk bit by bit in our future blog posts. Watch this space!

If you have any feedback or questions, feel free to drop us a line: contact@verysoftware.co.uk

After investigating a couple of 3rd party Binary Serialization libraries for WP7 and having seen a couple of suggestions online of just writing your own, I decided to do just that.

There were 2 main places where I found information on how to potentially write you own Binary Serializer for WP7, the first I felt took a rather old school approach by adding a “Write” function to each class which accepted a BinaryWriter and simply wrote out each of its own properties. The clear problem with this approach is the maintenance involved with adding new properties or if you wanted to serialize a different class.

The second approach was explained by Eugene Chaikin on his site, where he attempted to replicate the DataContractSerializer’s interface and even make use of the ‘[DataMember]‘ attributes in the same way.

So based on the simple sample code I started to create my own and call it the VSBinarySerialiser (because this was for use on VerySoftware [VS] projects, and Serialise is spelt with an S in the UK). The goal was to be able to use code like the following directly in place of the equivalent DataContractSerializer code:

1
2
3
4
5
6
7

// Write
var serialiser = new VSBinarySerialiser(typeof(MyClass));
serialiser.WriteObject(fs, theData);
 
// Read
var serialiser = new VSBinarySerialiser(typeof(MyClass));
var result = (MyClass)serialiser.ReadObject(fs);

The first obvious change I needed to make was due to the fact that my classes contained other classes inside of them, so I needed a ReadObject/WriteObject function that I could use internally to recursively serialise objects that were encapsulated within each other. To do this I modified the public ReadObject/WriteObject functions to simply create the BinaryReader/BinaryWriter and then call into the internal function passing the type that was stored when the VSBinarySerialiser was created:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

public void WriteObject(Stream stream, object theData)
{
if (stream == null || theData == null)
	return;
 
BinaryWriter bw = new BinaryWriter(stream);
 
InternalWriteObject(bw, theData, serializableObjectType);
}
 
public object ReadObject(Stream stream)
{
if (stream == null)
	return null;
 
BinaryReader br = new BinaryReader(stream);
 
return InternalReadObject(br, serializableObjectType);
}

The Internal Read/Write Object functions I wrote were similar to those in Eugene’s example, except for 3 main changes. Firstly I gathered the list of Properties on the object marked with the attribute at this point rather than earlier, as this allows recursive use of the function. Secondly to support the writing out of null objects when calling this function recursively I write a boolean out at the start to indicate if the object is Null or not. Finally I extended the list of type checks to include the additional data types I needed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

private void InternalWriteObject(BinaryWriter bw, object obj, Type type)
{
    if (obj == null)
    {
        bw.Write(false);
        return;
    }
    else
    {
        bw.Write(true);
    }
    var serializableProperties = GetMarkedProperties(type);
 
    foreach (PropertyInfo pi in serializableProperties)
    {
        var value = pi.GetValue(obj, null);
 
        if (pi.PropertyType == typeof(string))
        {
            bw.Write(value as string ?? string.Empty);
        }
        else if (pi.PropertyType == typeof(double))
        {
            bw.Write((double)value);
        }
        else if (pi.PropertyType == typeof(bool))
        {
            bw.Write((bool)value);
        }
        else if (pi.PropertyType == typeof(DateTime))
        {
            bw.Write(((DateTime)value).ToUniversalTime().Ticks);
        }
 
        else if (pi.PropertyType == typeof(myEnum))
        {
            bw.Write((int)value);
        }
        else if (pi.PropertyType == typeof(MyOtherClass))
        {
            InternalWriteObject(bw, value as Language, typeof(MyOtherClass));
        }
        else if (pi.PropertyType == typeof(ObservableCollection))
        {
            WriteObsevableCollection(bw, value as ObservableCollection);
        }
        else
        {
            throw new NotImplementedException(String.Format(
"Attempted to WriteObject property of type '{0}' which is currently unsupported!", pi.PropertyType));
        }
    }
}
 
private object InternalReadObject(BinaryReader br, Type type)
{
    if (!br.ReadBoolean())
    {
        return null;
    }
 
    object deserializedObject = Activator.CreateInstance(type);
 
    var serializableProperties = GetMarkedProperties(type);
 
    foreach (PropertyInfo pi in serializableProperties)
    {
        Type propType = pi.PropertyType;
 
        if (pi.PropertyType == typeof(string))
        {
            pi.SetValue(deserializedObject, br.ReadString(), null);
        }
        else if (pi.PropertyType == typeof(double))
        {
            pi.SetValue(deserializedObject, br.ReadDouble(), null);
        }
        else if (pi.PropertyType == typeof(bool))
        {
            pi.SetValue(deserializedObject, br.ReadBoolean(), null);
        }
        else if (pi.PropertyType == typeof(DateTime))
        {
            pi.SetValue(deserializedObject, new DateTime(br.ReadInt64(), DateTimeKind.Utc), null);
        }
        else if (pi.PropertyType == typeof(myEnum))
        {
            pi.SetValue(deserializedObject, (AppStore)br.ReadInt32(), null);
        }
        else if (pi.PropertyType == typeof(MyOtherClass))
        {
            pi.SetValue(deserializedObject, InternalReadObject(br, typeof(MyOtherClass)) as MyOtherClass, null);
        }
        else if (pi.PropertyType == typeof(ObservableCollection))
        {
            pi.SetValue(deserializedObject, ReadObservableCollection(br), null);
        }
        else
        {
            throw new NotImplementedException(String.Format(
"Attempted to ReadObject property of type '{0}' which is currently unsupported!", pi.PropertyType));
        }
    }
    return deserializedObject;
}

I’ve changed the names of some of the classes here to protect the innocent :)

The other change you might notice in the above code is the support for ObservableCollections, as we use a number of these for storing lists of data I created generic functions called WriteObsevableCollection<T> and ReadObservableCollection<T> to handle these:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

private void WriteObsevableCollection(BinaryWriter bw, ObservableCollection collection)
{
    if (collection == null || collection.Count == 0)
    {
        bw.Write(0);
    }
    else
    {
        bw.Write(collection.Count);
 
        foreach (var item in collection)
        {
            InternalWriteObject(bw, item, typeof(T));
        }
    }
}
 
private ObservableCollection ReadObservableCollection(BinaryReader br)
{
    var result = new ObservableCollection();
    int count = br.ReadInt32();
    for (int i = count; i > 0; --i)
    {
        result.Add((T)InternalReadObject(br, typeof(T)));
    }
 
    return result;
}

And that’s it, we now have our own Binary Serialiser that works on WP7; but how does it compare performance wise? Below is a table showing the data for our VSBinarySerialiser against the DataContractSerializer (averages are based on 5 runs of each):

Not too bad, the time to write/serialize the data is slightly slower than the DataContractSerializer but the read/deserialize takes just 60% of the original time. I expect the slower write time is possibly down to something relating to how I’m reflecting over the classes to get the properties each time, rather than caching them for each Type I come across. That optimisation however can wait for another time.

This post was originally published on Roy’s personal blog at http://roybott.com/blog/serializing-to-binary-on-wp7-part-2.html but we brought it here to share with you.

1
2
3
4
5
6
7
8
9
10
11
12
13
14

// Save
MyClass theData = new MyClass();
using (IsolatedStorageFileStream fs = isoStore.OpenFile("MyClass.xml", FileMode.Create))
{
	DataContractSerializer ser = new DataContractSerializer(typeof(MyClass));
	ser.WriteObject(fs, theData);
}
 
// Load
using (IsolatedStorageFileStream fs = isoStore.OpenFile("MyClass.xml", FileMode.Open))
{
	DataContractSerializer ser = new DataContractSerializer(typeof(MyClass));
	MyClass result = (MyClass)ser.ReadObject(fs);
}

This is all well and good for getting something up and running quickly, but once you start having more complex classes and/or more data, performance starts to become an issue. A quick test of how long AppTracker currently takes to deserialize the cache file when following just 3 apps (Polyglot, Gifts and AppTracker – consisting of a total of about 544 reviews) resulted in the following timings:

As you will generally be loading up your data when the app loads (in a background thread and using a loading indicator I’d hope) the time it takes to load the data from file is noticeable to the user because it is the time between them launching the app and being able to actually use it.

Binary Serialization (Serialisation)

The DataContractSerializer stores data in the file in XML form which is one cause of the performance issues on larger/more complex datasets. Therefore it makes sense to use binary serialization instead, however WP7 doesn’t have support for a Binary Serializer so you are left with two choices – Use a 3rd party library for Binary serialisation or Role your own!

This first post is going to cover 3rd Party solutions, and then later I will blog about creating your own.

After digging around on the net for a while I came across less information than I was hoping to find. A few places suggested using custom ‘database’ solutions but with SQL CE support coming for WP7 in the Mango update I decided to avoid that option. So in the end I was left with 2 possible solutions:

SharpSerializer

On it’s website SharpSerializer is described as “an open source XML and binary serializer for .NET Framework, .NET Compact Framework and Silverlight” which sounds pretty good. It also offers a very simple interface making serializing just as easy as the DataContractSerializer, and can be dropped in place with little effort.

Unfortunately when I tried to just drop SharpSerializer into place I hit an exception and ultimately had to download the source and step through it to discover that if you have a class that implements the IEnumerable interface it must also implement the ICollection interface or you get an InvalidCastException. After fixing that issue I did the same timing tests as with the DataContractSerializer and got the following results:

As you can see the timings were in fact slightly slower, now this isn’t to say that SharpSerializer is slow as I have seen a fair few sites show test data with results very different to these. What this test does show is that in my case SharpSerializer performs less well than DataContractSerializer, I’m not sure on the exact cause of that as I haven’t yet ran it through a profiler to see if the issue is with the library or the objects I’m saving out (there’s a good chance the issue could be on my side).

Silverlight Serializer

The other library that I found a few references to is called ‘Silverlight Serializer‘ which is described on it’s website as “a binary serializer that works in .NET and Silverlight, allowing you to move your objects between the two instances or store and retrieve them locally in either” and is created by Mike Talbot. This library also offers a simple interface allowing it to again be dropped into place with minimal effort. Unfortunately I once again hit some exceptions (this time a MissingMethodException and another one I’ve forgotten now), again potentially not the fault of the library and probably something I could have fixed with a bit of investigation.

However, at this point however I decided to give up and take a look at writing my own.

This post was originally published on Roy’s personal blog at http://roybott.com/blog/serializing-to-binary-on-wp7-part-1.html but we brought it here to share with you.