Unfortunately this is a much confused and misunderstood feature.

Fas App Resume (FAR) is a purely technical setting that controls what the OS should do with existing instances of the application when the user does something which would, traditionally, try and launch a new instance.

Enabling FAR tells the OS that it should load any exiting application instance before starting a new one.

FAR does not define what should happen with the existing instance is NOT universally defined. Each app should do what is best/most appropriate for that app if begin launched via FAR.

When implementing Fast Resume, you must decide what is the best user experience for you app when launched from the different launch points that are available on the phone.

Enabling FAR does not mean that every app should always maintain an existing back stack when an existing instance is resumed due to FAR.

Windows 8 has a recommendation that apps should hide whether they are being launched afresh or an existing instance is reloaded. Apps, when launched, should always display themselves as they were when last viewed, regardless of how long ago that was or if the devices has been turned off (or rebooted) in the meantime.

This recommendation does not exist historically in Windows Phone and has not been made now.

In Windows Phone (7.x) there was a recommendation that apps should be predictable and always do the same thing when launched.

I see no reason why that recommendation does not still stand. Windows Phone apps should provide a consistent, predictable experience when launched.

But what about the built in apps?
Looking at the built in applications is always a great guide for what your apps should do. There’s a problem here though. The built in applications can have multiple instances in the back stack.
The built in apps will launch a new instance in the same predictable way. The back stack maintains multiple instances in their different states.
There are also built in apps which remember where you were previously whenever the app is launched, regardless of other instances in the back stack.

It would be great if Microsoft had provided some information about why this feature (FAR) was added. I’d hope it’s driven from research about how users are trying to use apps on the phone. To see the data behind such research would be awesome.

I suspect this may have been added to try and drive Win8 parity…

So what about some guidelines*:

• Enable Fast App Resume so that load time will be faster if an instance of the app already exists in the back stack.
• Launching from the main tile or app list always opens the app on the main page.
• Launching from a deep link (secondary tile) or otherwise) should launch direct to the
• Adding a home button should always be very carefully considered and you need a very strong case for adding one.
• Regardless of whether an existing instance of an app was loaded or not, any back stack should be cleared when starting the app again.
• If your app will show the last page shown when previously opened, this behaviour should be implemented regardless of how the app was started.

An exception:

• If the user was performing a complicated or long process when they left the app and it would be frustrating to lose that context, data or state then it may be appropriate resume where the user left off. It may also be useful to provide a way to allow the user to return to the main page though.

*entirely my opinion and I reserve the right to change this opinion either wholesale or on a case by case basis

If you do implement FAR and you have page navigation animations that animates the PhoenApplicationFrame you may need to consider how you avoid spurious animations when FAR occurs. I’ve handled this by hiding the frame while navigation and back stack manipulation is performed as part of the resume process.

If you want an easy way to enable support in your project without having to manually edit the WMAppManifest.xml file, there’s a nuget package to help.

Below is a comparison of the controls available in the largest and most popular sets.

These collections are:

• The Windows Phone Toolkit
• RadControls for Windows Phone (Telerik)
• NetAdvantage for Windows Phone (Infragistics)
• Essential Studio for Windows Phone (SyncFusion)
• Studio for Windows Phone (ComponentOne)
• Phone Elements (MindScape)
• Metropolis for Windows Phone (Bee Mobile)
• MobileForms Toolkit for Windows Phone (Resco)
• Coding 4 Fun toolkit

There are also many other smaller collections and individual controls included in the Geek Champ Component Marketplace.

Obviously the above chart will no longer be correct when the control sets are updated but I believe it to be correct at the moment.

Obviously this isn’t an ideal way of working and recently I felt something needed to be done.

After exploring a few possibilities, I’ve created nine new NuGet packages which will allow you to modify the WMAppManifest.xml file to indicate supporting:

• New tile formats, via reflection, when a 7.X app is run on a 7.8 or 8.0 device.
• Background location tracking
• Fast-App-Resume
• Lock Screen background images
• Lock Screen notification text
• Lock Screen notification counts
• All Lock Screen items (rather than adding them individually)
• Lauching via a custom schema
• Custom file formats/extensions

You can find the packages by searching for “WMAppManifest“

Or, if like me, you’re super lazy (efficient), you can search for “WMAM” (the acronym) and you’ll find them that way too.

The package will make appropriate modifications to the WMAppManifesst.xml file and add a readme file to the project.
When you uninstall the package the readme file is removed but the modifications to the XML file remain.
This is deliberate. The NuGet package is just a means to an end. There is no expectation that you’ll need to update the package in the future so you can uninstall it immediately after it’s been installed. This will mean you have no unnecessary dependencies in your project.

If you are adding support for file extensions or a custom schema you’ll still need to modify the file manually to set the schema name and file extension. Everything else is set up though. You just need to alter the “ChangeMe” or “SetMe” values. This is documented in the readme file for each package so you may want to read that before removing the readme file and/or uninstalling the package.

You can find all the packages at nuget.org if you want to explore them in a bit more detail.

If you think these could be useful, you use them, find an issue or have any other feedback I’d love to hear it. Please do share your thoughts and experiences with this. It’s my attempt to help make Windows Phone development that little bit easier for everyone.

It’s a simple and common scenario. It’s also one where there are lots of ways of implementing the
behaviour. But which one should be used?

The navigation part is pretty straight forward but how to detect the “touch” and intent.

There are four options available:

1. Contain each item in a Button and use the `Click` event to detect the users action.
2. Use the `Tap` event on the containing UIElement to detect the users action.
3. Contain each item in a Button and bind to the `Command` to detect the users action.
4. If the items are in a  ListBox (or similar) use the SelectionChanged event to determine the users action.

Some may think there is no difference or they’re interchangeable but there are some important differences.

A Click event occurs when contact is made with the sceen and the same control is still under the touch point when contact is lost. This is regardless of how long the touch was made for or what happened in the mean time. This means you can move around the screen, move off of the control and back onto it, move the control within a scrollable area, and as long as there is no other control which will capture the gesture, swipe across the control and still trigger the click event. This may be more than you want or a user will expect to trigger the action/navigation.

A Tap event is intended to be used when you want to capture the users intention to interact with a screen element by tapping it. To trigger the tap event of a control contact must be made and released within a short period of time (about 300ms) and without the touchpoint moving more than a small amount.  This avoids the event being triggered by pressing on something for a long period of time or when moving a control on the screen. This is what you should be using instead of a `Click` event as it is designed and created to be used for finger based interaction while the click event was created for use with a mouse.

Using the SelectionChanged event for items in a ListBox (or similar) is a popular technique as it is used by the DataBound project template. There are a couple of issues with this though. The first is that you must clear the selection after it’s made to allow the selection of the same item again. The second, and bigger issue in my opinion, is that this is a misuse of what the ability to select an item is for. The ability to select an item (or items) is to enable it to be distinguished from the other items in the group. That’s why there’s a selected state. It allows you to see which items have been selected, so you can act on them. Thirdly, triggering a change in the selected item can also happen accidentally when scrolling a list.
If you have multiple items in a list and want to be able to perform an action when one of them is tuched, it would be better to use a Tap event on the individual item, rather than an event attacehd to the outer collection.
Like this:

    <ListBox ItemsSource="{Binding ListOptions}">
        <ListBox.ItemTemplate>
            <DataTemplate>
                <Grid Tap="ItemTapped">
                    <TextBlock Text="{Binding}" />
                </Grid>
            </DataTemplate>
        </ListBox.ItemTemplate>
    </ListBox>

But, I hear you say, what about MVVM? I don’t want to use coded behind, I want to bind the action to an ICommand on the ViewModel.

Yes, the ICommand is the solution here and the ButtonBase control has a Command property that you can bind your ICOmmand implementation to. But how is it triggered?
Disappointingly, from my perspective, it is triggered by either a Click or Tap event. This means that it can still be triggered in the same unexpected and undesired ways as a Click event.

Fortunately it’s easy to create a user control that has the ability to call an ICommand implementation when it is Tapped and not Clicked.

Here’s the incredibly simple XAML you need:

<UserControl
    x:Class="TapClickCommand.TapCommandControl"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Tap="ControlTapped" />

Yes, it’s just an empty control with a Tap event handler wired up.

Then we just need the code to make it work:

namespace TapClickCommand
{
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Input;
 
    public partial class TapCommandControl : UserControl
    {
        public readonly DependencyProperty TapCommandProperty =
            DependencyProperty.Register(
                "TapCommand",
                typeof(ICommand),
                typeof(TapCommandControl),
                new PropertyMetadata(null));
 
        public readonly DependencyProperty TapCommandParameterProperty =
            DependencyProperty.Register(
                "TapCommandParameter",
                typeof(object),
                typeof(TapCommandControl),
                new PropertyMetadata(null));
 
        public TapCommandControl()
        {
            InitializeComponent();
        }
 
        public ICommand TapCommand
        {
            get { return (ICommand)GetValue(TapCommandProperty); }
            set { this.SetValue(TapCommandProperty, value); }
        }
 
        public object TapCommandParameter
        {
            get { return GetValue(TapCommandParameterProperty); }
            set { this.SetValue(TapCommandParameterProperty, value); }
        }
 
        public void ControlTapped(object sender, GestureEventArgs e)
        {
            if (this.TapCommand != null)
            {
                this.TapCommand.Execute(this.TapCommandParameter);
            }
        }
    }
}

You use it just like the Command property in ButtonBase.
e.g.

    <local:TapCommandControl TapCommand="{Binding TheTapCommand}"
                             TapCommandParameter="{Binding Id}">
        <TextBlock Style="{StaticResource PhoneTextLargeStyle}"
                    Text="{Binding Name}" />
    </local:TapCommandControl>

Voila!

So, to summarize:
Use a Tap event, rather than Click or SelectionChanged if using code behind.
Bind commands to be triggered by a Tap event rather than a Click event if using commanding.

This article explains how to create a custom “discrete” colour picker page for Windows Phone.

See Featured Articles for other great articles from the community.

The Nokia Notifications API (introduced with the Nokia Asha software platform 1.0) provides a mechanism to deliver app-specific push messages from a remote server to a Java app. Notifications bring several advantages over alternative approaches (for instance, periodical server polling) including the following:

• Message delivery when the app is not running
• Fast message delivery
• Reduced battery consumption

This article shows how to implement a complete system that allows the setup and delivery of Nokia notifications. Read more…

See Featured Articles for other great articles from the community.

This project/app allows you to easily test availability/non-availability of hardware features of a device. The project basically consists of a Pivot control which has two views integrated, one named as ‘Availability’ displays the status of hardware features (like accelerometer, gyroscope, FM radio etc) in the form of list, while the second view ‘Characteristics’ displays the resolution of the device along with the memory info for the application itself.

The project is useful for those who have an application dependent on some hardware feature that may not be present on a particular device as they can review the source code to work out how to test if the feature is present (e.g. Front Camera).

We are always looking for such cool and usable projects, so if you have one such in mind then don’t delay to share/host it with Nokia Developer Projects.

- Vineet Jain (on behalf, Projects Moderation team)

In the phone dev centre there was a nice link prompting me to renew. On that renewal page there was an option to pay for renewal or enter a code. Obviously I wanted the “enter a code” option but where to get that code from? Unfortunately it wasn’t as easy to find as I would have liked so I thought I’d share it here.

It’s actually quite simple (once you know how)

• Log into your account on msdn.microsoft.com.
• Got to https://msdn.microsoft.com/en-us/subscriptions/manage/
• Under the Subsccription Benefits find “Windows Phone developer account”
• Click on the “get code” link to reveal your code – it is a GUID
• Enter that code (GUID) in to the phone dev center renewal page.
• Done!

Hope this helps.

This is with code like:

    foreach (var tile in ShellTile.ActiveTiles)
    {
        // update the tile.
    }

At the moment I only have anecdotal evidence of this behaviour but wondered if anyone else could shed any knowledge or experience of this while I continue to investigate.

Deleting and repinning the tile in question seems to make the problem go away but this isn’t a real solution.
Additionally it doesn’t seem like it’s the first or last created pin but I can’t be sure of this.

Has anyone else seen this?