Fitbit arrives for Windows Phone 8.1! 28 Jul 2014, 2:29 pm

Fitbit is launching their native app for Windows Phone 8.1 today that brings direct mobile syncing (via Bluetooth 4.0). Devices running Windows Phone 8.1 will now have instant access to up-to-date stats from Fitbit’s wireless activity trackers like the Flex, One and Zip. Fitbit’s wireless activity trackers track health and fitness metrics like steps taken, distance traveled, calories burned, active minutes, floors climbed and sleep quality. With their wireless activity trackers, Fitbit wants to inspire people to lead healthier and more active lives. I am nearing my two-year mark as a Fitbit user so I’m pretty excited about their app!

The Fitbit app features a Live Tile when pinned to your Start screen giving you all the up-to-date information and notifications at a glance. You’ll see things like steps taken and how much more is needed to meet your daily goal for example. All without having to open the app. In addition to direct mobile syncing, you’ll be able to quickly log fitness and nutrition data and set or manage personal goals directly from the app. And you’ll also be able to see how you stack up against your friends on the leaderboard and cheer (or taunt) them by direct messaging them from the app.

Here is a list of what is included in the Fitbit app for Windows Phone 8.1 today:

• Real-time stats: Automatic and wireless syncing for all Fitbit activity and sleep trackers through Bluetooth 4.0
• Fitbit on your Start screen: Pin the Fitbit Live Tile to your Start screen and quickly view your step count
• Stay on track: Real-time and historical stats in easy-to-understand graphs, to help track progress and set goals
• Log more than activity: Recently enhanced food database of more than 350,000 foods with accurate nutritional data for faster, better food-logging and calorie coaching
• Get motivated: Fitbit's motivational social tools like notifications and badges, to help reach target goals
• Stay social: Ability to challenge friends and family with leaderboards, direct messages, cheers and taunts

You can download the Fitbit app today for free from the Windows Phone Store and start syncing your Fitbit wireless activity tracker. Click here to read on getting started with their app for Windows Phone 8.1.

Don’t have a Fitbit wireless activity tracker? You can pick one up from Fitbit.com or the Microsoft Store.

Please note: Fitbit currently supports Microsoft Nokia Lumia devices running Windows Phone 8.1 with the Lumia Cyan firmware. You can check their supported device page for the most up-to-date list of compatible devices as they expand compatibility to additional devices in the Windows Phone ecosystem.

Expanding Open Source technologies on Windows 28 Jul 2014, 1:27 pm

At //build/ 2014 earlier this year, Microsoft took a number of broad steps to embrace open source, from WinJS and .NET to the open cloud on Azure and investments and efforts to enable your favorite open-source technologies on Windows.

Continuing on that promise, and to celebrate our presence at OSCON 2014, we are delighted to announce support for another popular OSS technology - CMake.

CMake for Windows Store and Windows Phone apps

CMake is a cross-platform project files generator that enables re-use of shared C++ code across multiple IDEs or project systems. An early build of CMake that allows you to target Windows Store and Windows Phone apps is available on CodePlex here. We are working with Kitware and CMake community to incorporate feedback and integrate it soon in the public CMake repository.

To learn more on using CMake for Windows Store and Windows Phone apps, we’ve created a short quick-start exercise (with sample code and installer) that you can try out here. If you are interested, feel free to check out all the labs in the Code2Win Challenge.

Microsoft and Open Source at OSCON 2014

Teams at Microsoft such as Microsoft Open Technologies, Windows and the Developer Division have been working hard to bring you many additional OSS technologies. Here is a list of those we cover at OSCON 2014, which you can use today to build your Windows Store and Phone apps:

• WinJS
• jQuery
• CMake
• OpenCV
• Cocos2d-x
• ANGLE
• Cordova
• Xamarin
• Boost C++ Libraries
• openFrameworks
• Kinect SDK
• Box2d

Here are the announcements from Microsoft Open Technologies at OSCON 2014.

The VC++ team in Developer Division has just announced support for Boost C++ Libraries for Windows Store and Windows Phone.

And of course, our work with open source is just beginning, and we’d love to know how we can prioritize and improve our work.

Please take our OSS Survey to share your feedback and what OSS you want to see next on Windows.

Introduction to universal Windows apps in Windows 8.1 and Windows Phone 8.1 24 Jul 2014, 11:35 am

This post was written by Microsoft MVP Pavel Yosifovich.

-----

This week we're featuring guest blog posts from some of the members of our Microsoft developer MVP program. Microsoft MVPs are passionate, expert community leaders who share their real-world knowledge and experience building solutions with Microsoft platforms. 

Pavel Yosifovish, CTO at CodeValue; Can Bilgin, Senior Solutions Architect at CompuSight Corp.; and Rob Miles, a university lecturer, have all recently had experience implementing universal Windows apps, so we thought it would be especially useful to showcase the things they've learned and how they've been able to leverage much of the same code to deliver experiences across multiple device types.

One of the new features introduced during the Build conference is a converged Windows Runtime on Windows Phone 8.1, opening the way to “universal Windows apps.” In this post I’d like to share my first experience with universal Windows apps, their structure and possible future.

The before

Before universal apps came along, creating apps for Windows 8.x Store and Windows Phone 8 was mostly a two-app project. Sure, some logic code could be shared via Portable Class Libraries (PCL), but the common surface of PCLs was too small, leading to many #if/#endif statements. Also, sharing XAML was extremely difficult, and in my experience a futile exercise, so it had better be kept separate.

Other stuff, similar on the outside, such as Live Tiles and push notifications, had to be done differently, because it was a different API, built on different foundations. Windows Store was built on top of the Windows Runtime (sometimes dubbed WinRT) – a native, COM based API, while the Windows Phone API was mostly Silverlight-based – pure .NET mostly. Yes, with the 8.0 version of Windows Phone some WinRT APIs made it to the phone (sometimes referred to as “WinPRT”), common with WinRT, but that common API was relatively small.

The after

With Windows Phone 8.1 and Windows 8.1 Update, things are changing, or should I say – converging. The WinRT API has spread to the phone, replacing Silverlight based APIs. For example, the Windows.UI.Xaml.Controls.Button class from WinRT now exists as a Win(P)RT type in WP 8.1. The “old” button, System.Windows.Controls.Button is still there to support existing apps (and is probably a wrapper around the “new” button). New apps can still use the Silverlight model, but I suspect this will be discouraged in the future.

Another effect of this convergence is the “Universal PCLs”, which are now expanded to include a much larger surface area than non-universal PCLs. I use the term “Universal PCLs” but these are regular PCLs targeting Win8.1/WP8.1 that include more common surface to share, including XAML. “Non-universal” here really means PCLs that target more than Windows 8.1 and Windows Phone 8.1.

Universal Windows Apps

Universal Windows apps are there to allow the same app to be written for Windows 8.1 Store and Windows Phone 8.1 with little code changes. Note that it’s not the same as linking a Windows and Phone app in the Store – this can be done in the non-Universal model as well; here I’m referring to actual code sharing, whether the apps will be linked in the Store or not. Almost everything can be shared, and obviously some things will have to change, such as UI layout, or usage of special features of one platform or the other. But, as it turns out, most code, and even XAML can actually be shared; and that’s a real advantage we didn’t have before.

Let’s create a simple universal Windows app and examine its components. To get support for this, you’ll need Visual Studio 2013 (any SKU) with Update 2. This will install the proper project templates and other required support to get this working.

From Visual Studio, select File -> New Project and navigate to the new Store Apps subfolder:

It’s actually possible to start with a Windows 8.1 app or a Windows Phone 8.1 App and add its “twin” app using a context menu option on the project node in solution explorer.

With the universal app selection, we get two app projects, one for Win 8.1 and the other for Win Phone 8.1. The unusual part is the third, “Shared” project:

Notice the projects look very similar. The Silverlight manifest file WMAppManifest.xml has been transformed into Package.appxmanifest, essentially the same as its Windows 8.1 counterpart.

As we can see, the “Shared” project has App.xaml and App.xaml.cs shared by default. This means these files do not appear in the normal projects, but are “pulled” by each one when built.

The Shared project is a bit weird, as it has no output on its own – it’s not a DLL, EXE, XAP or whatever. It’s nothing; it just contains shared stuff that must be pulled by each of the “real” projects. It doesn’t even have a References node.

So what happens if we want to use some class library (it better be a Universal PCL)? We add it as a reference for each of the real projects, and then its contents is available for use in the Shared project. Get it?

Let’s do some experimentation. Drag the MainPage.xaml file from the Windows Phone project to the Shared project’s node:

Notice the file does not disappear from the original project. Trying to build now yields 2 errors, because there are 2 files with the same name (identity) for each project.

Let’s delete the MainPage.xaml file (along with its code behind) from the Win 8.1 and WP 8.1 projects, leaving it in the Shared project only:

Now the two projects build just fine, and they even run perfectly fine. In this case, the MainPage.xaml file was identical in the original two projects, so no harm, no foul. Let’s add a simple Button control to the Grid that exists in that (now single) MainPage.xaml:

The designer now has an option to switch to one of two views – Win 8.1 or Win Phone 8.1 so we can check out the results at design time:

Running each app shows the button as we expect, in the Grid’s center.

By the way, notice that the XAML has converged, so that Windows Phone and Windows 8 now recognize the same syntax, such as the way to map a XAML namespace to a CLR namespace using the “using” keyword rather than the “clr-namespace” keyword, as was done with the “Silverlight way”. This is just one aspect that makes sharing XAML possible.

Same same but sometimes different

Some aspects of the app would be different between Windows Phone and Windows. For this purpose, the project templates define the WINDOWS_PHONE_APP (for WP) and WINDOWS_APP (for Windows) symbols, so that C# code can use the standard #if/#else/#endif markers to distinguish between the platforms. This is particularly useful for a PCL and any other non-XAML code.

Sharing XAML is more difficult. Let’s say I want to have two pieces of XAML laid out differently in WP and Windows like the following simple example:

One way to achieve that is to use the same page XAML, but do the tweaks using View Model property bindings, such as for alignment, grid row/column, etc. Although that’s possible, it’s a maintenance nightmare for non-trivial views.

A better approach would be to factor out the important controls as user controls in the shared project and have different page XAML for each platform. In the above example, I created a DeviceList user control in the shared project that hosts a list of devices on the current platform. The XAML of the control is simple:

 

The code behind provides the Devices dependency property of type IReadOnlyList<DeviceInformation> which is mapped from the IVectorView<> WinRT interface.

The two XAML pages for the platforms simply use the control in the correct place. This keeps the page XAML simple and not require any support from the view model or value converters. Here’s the example for Windows:

The binding is set up in the code behind (would be in a PCL or shared code ViewModel in practice):

In this way, user controls can be shared and handle the heavy lifting, while the Page objects would not be shared, but handle the overall layout and common parts (such as images, status or whatever).

What about the Desktop?

From my perspective the only thing missing in this story is the Desktop. Microsoft realized, perhaps a year or a bit more ago that the desktop is not going away and is important as ever, if not more. Many apps run in the desktop (vs. Store), many apps rely on mouse and keyboard for their utilization, and touch is not the answer to everything.

I see no reason why the WinRT model, including the UI and XAML does not bleed into desktop apps as well. WinRT is just COM, after all, and in fact, many types can already be used in desktop apps. For some reason, XAML based UI still can’t but I personally believe it will. .NET developers have WPF, but native desktop developers have just MFC, which is outdated and primitive by comparison to either WPF or WinRT.

Sure, there are other C++ UI non-Microsoft alternatives, such as Qt, wxWidegts and many more, but that’s not enough. Microsoft should provide its own framework, and indeed it’s already here – that’s WinRT. It just needs to be “allowed” to execute in desktop apps.

In fact, I sense that WinRT is not just about “apps”; instead, it’s the new Win32 API. Every developer that’s familiar to some extent with the Win32 API understands these words. This API is old, mostly thousands of C-style functions, is unwieldy, and difficult to learn given the alternative APIs. WinRT is for the most part well designed, object oriented, and is still native, so it has a lot going for it. It could very well be the new Windows API.

Let’s see a quick example of getting that same device list and using that in a WPF app.

WinRT metadata format is the same as .NET, so adding a reference should be possible. However, desktop projects are not configured by default to allow it. We need to edit the .csproj file to allow easy adding of the WinRT metadata information. To do that, unload the desktop project, right click the project node and select the edit option, which will open the file in the text XML editor. Add the following as another property group somewhere in the file:

Save the file and reload the project. Open the Add Reference dialog box and now notice the “Windows” node with the “Core” sub-node and the Windows WinMD file on the right:

Now that the reference is in, we can use the WinRT API. First, here’s a simple XAML for the WPF window:

I want to show columns for the properties Name, Id and IsEnabled of a DeviceInformation object. To get that info, we need some code behind, such as the following while handling the Loaded event:

Notice the async operation. If we try to compile this, it fails, telling us that the method GetAwaiter is not present on that IAsyncOperation<> that’s returned. That’s because the C# compiler has a pattern for methods that are awaitable (the “awaiter pattern”). The regular Task<T> class from .NET supports this, of course, but this is a WinRT type, not a .NET type – so there is no notion of an awaiter.

The solution is to reference another assembly, which provides that support for easier working with WinRT from .NET. We need to add a reference to the System.Runtime.WindowsRuntime.Dll assembly located at a folder like “C:\Program Files (x86)\Reference Assemblies\Microsoft\Framework\.NETCore\v4.5”. This provides not just await support but also other useful stuff such as the AsTask extension method that can turn IAsyncAction/Operation into a .NET Task (which has a rich API).

Running the app we get something like this:

What’s next?

Clearly, there’s still a way to go, but I believe this is a good direction. What is apparent to me is that WinRT is the present and future, but the Silverlight API is just here for compatibility and maintenance. So, if you’ve been avoiding or neglecting WinRT – don’t. New apps (even if they are not planned to be multi-platform) should be based on the WinRT API and not the Silverlight one.

The Windows Runtime is truly universal, in more than one sense. I expect a common Windows Runtime core to be present in all form factors – phone, tablet, desktop and XBOX.

Sheep for wheat, anyone? Internet Explorer releases preview of new social Catan web experience for free play 24 Jul 2014, 9:01 am

Today, we’re excited to release the preview of Catan Anytime – the entirely new social version of the beloved board game The Settlers of Catan. Play is completely free and available on any device with a modern browser. We hope Catan fans will appreciate its simplicity – Catan Anytime is fast, fluid and designed for touch making it easy to play the game from mobile to your big screen with IE on XBOX and everything in-between.

Catan Anytime is a partnership with creators of Catan, Mayfair Games and Bontom Games. This preview release features the latest HTML5 web standards and real-time in-game social interaction. As part of the ongoing collaboration, we will be releasing the complete Catan ruleset: Development cards, Achievements, and Ports at GamesCon in August. This brings Catan Anytime to full parity in game rules with the board game.  We hope that the parity in rules, combined with the unique capabilities of asynchronous gaming and auto trading will attract Catan fans old and new alike! This web experience joins our collection of Rethink experiences such as Assassin’s Creed Pirates and 22Tracks – helping push the limits of what’s possible on the modern, interoperable web.

The Teuber family and Arnd Beenen from the Catan team were wonderful partners and supporters of this project. In Guido Teuber and Benny Teuber’s words, “It’s exciting to reflect on how The Settlers of Catan started as a passion project for our father and we never could have imagined it would grow into the iconic board game that it is today. At the Catan team, we are always looking for new ways to inspire fans and we’re thrilled to be partnering with Internet Explorer to help us bring the next evolution of Catan to life.”

Wait, what’s Settlers of Catan?

The Settlers of Catan is a board game of barter trading – an instant pop-culture classic found in college dorms and family reunions alike. The original has sold 20 million copies and is now available in over 30 languages. Playing Catan with family and friends is tradition for some and conversations starters for others. No matter the reason, the game evokes laughter, exciting debates and endless dialogs.

Players play the part of settlers who gain resources to build roads and settlements that eventually become cities. Ore, wheat, wood, brick and sheep are your five resources. Players must strategically place their cities and trade their resources to earn the 10 victory points it takes to win. The real fascinating part about the game is that it’s so balanced – there are so many ways to win (or not).

Play Catan Anytime across any device, anywhere

Internet Explorer truly believes in the open and interoperable web, and therefore we focused on delivering a game that simply works on the web without bias of what device, OS or browser players’ choose to use. Together we created a game that is light and renders easily on devices ranging from smartphones to PCs and anything in between.

Catan Anytime is not meant to replace the board game experience.  We wanted to adapt the essence of Catan to the best of today’s mass market game mechanics.  The digital version is meant to plug the game seamlessly into our daily lives and grow the way people can experience it. 

What’s in this preview?

We hope the web version makes Catan even more accessible to all – it’s a great “gateway” game towards its genre. Whether you’re familiar with the game or not, Catan Anytime makes it fun and easy to jump right in:

1. Getting Started: Try a single turn before you register to check out gameplay. Once you are hooked, invite your friends to join the fun via Facebook or email. You just need three players to start playing.

2. Time Savers: Turn-based asynchronous gameplay is a great feature we introduced in this new version of Catan. Auto-trade and auto-roll features also help the players keep the game moving forward.

3. No Dice: We took away the need for dice and instead the player clicks a button to produce resources. The probability that duplicates a dice roll is built into the game!

4. Notifications: Opt in for notifications while you are away from the game. You can choose to stay connected to your game via email so you don’t miss a beat!

The social Catan: Stay connected with friends, family and fellow fans while you play

With in-built chat and access to Skype and Twitter, our goal is to help keep you connected to other players and the wider online Catan community. Using the in-game chat feature you can send messages, or start a group call on Skype as you play. You can also broadcast your thoughts to Twitter directly from the chat box. Stay connected to engage with other enthusiastic players and listen out for tips and tricks shared on the social sphere.

Now boldly go forth and conquer Catan Anytime anywhere! And stay tuned for more features coming to catananytime.com this August!

Justin Garrett

Group Product Manager, Internet Explorer

Uber now available on Windows Phone! 23 Jul 2014, 12:35 pm

Uber, the popular technology platform that connects users with safe, reliable and seamless transportation announced their official Windows Phone app earlier today. Uber for Windows Phone is a fast, full-featured native app that makes ordering your next ride super easy. The app works on all Windows Phone 8 and Windows Phone 8.1 devices, is free, and is available for immediate download in the Windows Phone Store.

We welcome Uber to our fast-growing Windows Phone ecosystem. Now with Uber on Windows Phone, our users will have a seamless ride at the touch of a button.

Meet the Lumia 530 – the most affordable Lumia yet 23 Jul 2014, 12:02 pm

Today, the Microsoft Devices Group has announced the very affordable Lumia 530. The Lumia 530 is the perfect entry to Windows Phone 8.1 which includes new features like Action Center, Word Flow, and Cortana - the world’s first personal digital assistant. The Lumia 530 comes with a 4-inch LCD display and a powerful 1.2GHz quad-core Qualcomm Snapdragon processor. It also has a 5-megapixel camera and expandable storage up to 128GB using a MicroSD memory card. The Lumia 530 will also come with dual-SIM capabilities too. For more details on the Lumia 530, see this post on the Conversations blog or watch the below video.

The Lumia 530 Single SIM and Lumia 530 Dual SIM are expected to be priced at €85 (before taxes and subsidies) and on the highstreet for under €100. The Lumia 530 will be available globally, with rollout beginning in select markets in August 2014.

Tips and tricks for using XAML controls in your universal Windows apps 22 Jul 2014, 9:46 am

This post was written by Rohan Thakkar, Program Manager 2 - Developer Ecosystem Platform on Operating Systems Group at Microsoft.

At //build 2014 we introduced the ability to build universal Windows apps, which are able to share a large amount of code between Windows 8.1 and Windows Phone 8.1 projects. In particular, three sessions at //build discussed the important features for developers working with XAML:

• What about XAML UI and Controls? by Shawn Oster
• Quality and Performance for XAML Apps by Stefan Wick
• Animations in Windows Phone XAML Apps by Kunal Deep Singh and Rohan Thakkar

To follow up from those talks, we wanted to share with you the golflink sample app used for our demos and use it as a basis to share a number of tips and tricks for working with XAML controls in universal apps. For more background on XAML basics, refer to Create your first Windows Runtime app using C# or Visual Basic, Creating a UI (XAML), and Developing apps (XAML) in the documentation.

Adaptive UI

Sharing common pages

When sharing a page across Windows and Windows Phone projects, the first thing you must tackle is to ensure Windows has a software back button for in-app navigation and Windows Phone has a hardware back button for in-app navigation. The sample demonstrates a CommonPage.XAML and how to tackle the back button problem. We have done this using a separate user control, PageTitleUserControl.xaml, for Windows and Windows Phone that will be instantiated from the CommonPage in the shared project. You need to pass in a reference to the NavigationHelper for the back navigation.

public CommonPage()
{
this.InitializeComponent();
this.navigationHelper = new NavigationHelper(this);
this.InsertPageTitleUserControl();

this.navigationHelper.LoadState += navigationHelper_LoadState;
this.navigationHelper.SaveState += navigationHelper_SaveState;
}
private void InsertPageTitleUserControl()

    PageTitleUserControl pageTitle = new PageTitleUserControl(this.navigationHelper);
    pageTitle.PageTitle = "Common page";
    pageTitle.AppName = "APP NAME";
    rootGrid.Children.Add(pageTitle);
    Grid.SetRow(pageTitle, 0);
}

Sharing UserControls

UserControls can be different, like in the above sample, but be used in a shared page. The best and most common use is to have bunch of shared UserControls (think fragmentsJ) for common parts of the UI and use them for respective XAML pages (views). In the golflink sample, we could have used them more heavily. However, to demonstrate their usefulness, check out the Shared\UserControls\ProfileControl.xaml and its usage in HubPage.XAML.

Sharing Styles

Sometimes you have unique styles for respective frameworks and share them. This is a nice trick that can be very handy.

In golflink sample, Windows\Styles\Styles.xaml has a resource dictionary with a set of unique styles that exist by default on Windows Phone 8.1’s generic.xaml. These styles (and maybe others) must be defined for Windows projects to be able to share the XAML with phone. Let us take a look at our example.

Windows\Styles\Styles.xaml

<ResourceDictionary
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:golflink.Styles">

<Style TargetType="TextBlock" x:Key="ListViewItemSubheaderTextBlockStyle">
<Setter Property="FontSize" Value="15"/>
<Setter Property="Margin" Value="0,6,0,0"/>
</Style>
<Style TargetType="TextBlock" x:Key="ListViewItemContentTextBlockStyle"/>
<Style TargetType="TextBlock" x:Key="ListViewItemTextBlockStyle"/> 
<SolidColorBrush Color="Blue" x:Key="PhoneAccentBrush"/>
<SolidColorBrush Color="White" x:Key="PhoneForegroundBrush"/>
<x:Double x:Key="ContentControlFontSize">20.26</x:Double>
</ResourceDictionary>

ListViewItemSubHeaderTextBoxStyle does not currently exist on Windows 8.1 but it does on Phone 8.1. We define it here.

Similarly on the phone side we might require a style with a key shared with Windows to behave differently. We put it under Phone\Styles\Styles.xaml.

Now, as you might imagine, these were styles unique to each project. The styles that are common to both projects are in shared project’s app.xaml (Shared\App.xaml).

Here, you will also merge the Styles.xaml’s resource dictionary using the highlighted mark up:

<Application
x:Class="golflink.App"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:golflink"
xmlns:localData="using:Shared">

<Application.Resources>
<!-- Application-specific resources -->
<ResourceDictionary>
<ResourceDictionary.MergedDictionaries>
<ResourceDictionary Source="/Styles/Styles.xaml"/>
</ResourceDictionary.MergedDictionaries>
<x:Double x:Key="largeCellHeightPercent">0.392</x:Double>
<x:Double x:Key="largeCellWidthPercent">0.392</x:Double>


<x:Double x:Key="mediumCellHeightPercent">0.205</x:Double>
<x:Double x:Key="mediumCellWidthPercent">0.205</x:Double>

<x:Double x:Key="smallCellHeightPercent">0.138</x:Double>
<x:Double x:Key="smallCellWidthPercent">0.138</x:Double>
</ResourceDictionary>
</Application.Resources>
</Application>

The end result is a nice way to merge dictionaries and share styles where appropriate.

Window-based width adaption

Sometimes you want to set the width of certain controls to be relative to the window size (or dimensions of the device). For example, on phone, a HubSections width should ideally be 90% of window width. The percentage-based dimensions can be handy at many places, and here we describe simple steps on how to achieve the goal using behaviors. An important note here is that one might get carried away and use percentage-based width/height everywhere, but you should step back and realize the need for it. Existing layout primitives like Grid/StackPanel coupled with alignment properties provide a pretty powerful adaptive UI mechanism. So, the take away is use WindowDimensionBehavior for percentage-based widths only when you absolutely cannot use Grid/StackPanel. Here is how you would do it:

Step 1. Add Behaviors SDK. Right-click both projects Windows/Windows Phone individually and add reference. Select Extensions SDK -> Behaviors SDK.

Step 2. Create a shared Helper class, WindowDimensionBehavior.cs:

using Microsoft.XAML.Interactivity;
using Windows.UI.XAML;
using Windows.UI.XAML.Controls;

namespace golflink.Helpers
{

    [Microsoft.XAML.Interactivity.TypeConstraint(typeof(FrameworkElement))]
class WindowDimensionBehavior : DependencyObject, IBehavior
    {
public WindowDimensionBehavior()
        {
this.WidthMultiple = 1;
this.HeightMultiple = 1;
this.HeightPercentage = double.NaN;
this.WidthPercentage = double.NaN;
        }
public DependencyObject AssociatedObject { get; set; }            

public FrameworkElement TypedObject { get; set; }
public int WidthMultiple { get; set; }

public double WidthPercentage { get; set; }

public int HeightMultiple { get; set; }

public double HeightPercentage { get; set; }

public void Attach(DependencyObject associatedObject)
        {
this.AssociatedObject = this.TypedObject = associatedObject as FrameworkElement;

this.TypedObject.Loaded += TypedObject_Loaded;
            Window.Current.SizeChanged +=Current_SizeChanged;

        }

void TypedObject_Loaded(object sender, RoutedEventArgs e)
        {           
            Handle();
        }

void Current_SizeChanged(object sender, Windows.UI.Core.WindowSizeChangedEventArgs e)
        {
            Handle();
        }

private void Handle()
        {
            var frameWorkElement = (this.TypedObject as FrameworkElement);

//I base all the percentage calculations on shortest dimension, you can modify this depending on your layouts requirements.
double shortestDimension = (Window.Current.Bounds.Width <= Window.Current.Bounds.Height) ? 
                Window.Current.Bounds.Width : Window.Current.Bounds.Height;

if (frameWorkElement != null)
            {
if(this.WidthPercentage!=double.NaN)
                frameWorkElement.Width = shortestDimension * this.WidthPercentage * this.WidthMultiple;                
if(this.HeightPercentage!=double.NaN)
                frameWorkElement.Height = shortestDimension * this.HeightPercentage * this.HeightMultiple;
            }
        }

public void Detach()
        {
            Window.Current.SizeChanged -= Current_SizeChanged;
            (this.AssociatedObject as Control).Loaded -= TypedObject_Loaded;

        }
    }
}

Step 3. Use it in XAML

Don’t forget to add xmlns reference:

xmlns:Interactivity="using:Microsoft.XAML.Interactivity"

Then in the actual Hub section where you want to make the width twice of 90% of the window width:

<HubSection  x:Uid="Section2Header" Header="MY GAME" DataContext="{Binding Profile}">
<Interactivity:Interaction.Behaviors>
<helpers:WindowDimensionBehavior WidthMultiple="2" WidthPercentage="0.9"/>
</Interactivity:Interaction.Behaviors>
<DataTemplate>

And use it responsibly.

Revisiting the goodness of layout primitives (Grid/StackPanel)

The Windows\Players.xaml page makes almost no use of the WindowDimensionBehavior mentioned above. 99% of the layout is done using basic layout primitives like Grid, StackPanel, ListView and GridView. Make good use of the HorizontalAlignment/VerticalAlignment and HorizontalContentAlignment/VerticalContentAlignment properties coupled with the magic of Grid’s “star” capabilities.

On the other hand, on the Phone’s Players.xaml page, we have extensively used behaviors (not recommended, but left there for comparison).

Viewbox

This can be handy at times when you want the text font to scale with window dimension. We used it in a couple of places in the project (an exercise for you to search and learn why; let us know if you think of other ways to achieve the same desired scenario). Just knowing that this control exists for your layout magic is super useful.

VisualStateManager

Use it along with the Window_SizeChanged event to swap out item templates or show/hide different controls on your layout. Unfortunately, we haven’t used it in our demo app. However, there is nothing new or fancy here to demonstrate. XAML experts know the power of VSM. Folks who are not familiar with VSM can take a look at Quickstart: Designing apps for different window sizes.

Test test test…

Universal apps will have a massively diverse dimensional reach. It is very important to test your app’s layouts in different resolutions and dimensions. Remember, width is not the only thing that varies. Height also varies significantly. An easy way to test is using Simulator for Windows and Emulator for phone or the designer.

The Golflink app has bugs; we could not fix all of them. Curious readers can try and see which layouts have problems.

Specific common controls but different behaviors

Hub

Windows Store Apps using XAML Hub share the same API as Windows Hub, but it looks and feels like the Phone 8.0 Panorama. When authoring an app using Phone Hub here are a few things to note or do differently.

• HubSection’s width is by default set to 90% of window width. If the content of the section is wider than this, it will get clipped.
• If you want the HubSection to expand to match the width of the content, you need to set the width of HubSection to Auto

  <HubSection Width="Auto"/>

• The recommended way to have a wide HubSection is to make the section’s width equal to a multiple of 90% of the window width. There are different ways to achieve this. In the sample we have used behaviors (recommendation from Jerry Nixon, thanks!) and shared a behavior class to achieve this. Check the adaptive UI section for step-by-step instructions on how to use WindowDimensionBehavior.cs.
• Use the Hub.SectionsInViewChanged event to identify SectionsInView. This is a replacement for the 8.0 Panorama.SelectionChanged event and SelectedIndex. In the golflink sample we have used it to show/hide app bar for “recent” section.
• Hub is designed to be used with Orientation=”horizontal” ONLY. Do not use it in Orientation=”vertical”.
  

private void Hub_SectionsInViewChanged(object sender, SectionsInViewChangedEventArgs e)
{
if(Hub.SectionsInView!=null && Hub.SectionsInView.Count>0)
if(Hub.SectionsInView[0].Name=="recent")
    {
        appBar.ClosedDisplayMode = AppBarClosedDisplayMode.Compact;
        (appBar.PrimaryCommands[0] as AppBarButton).Visibility = Windows.UI.XAML.Visibility.Visible;
    }
else
    {
        appBar.ClosedDisplayMode = AppBarClosedDisplayMode.Minimal;
        (appBar.PrimaryCommands[0] as AppBarButton).Visibility = Windows.UI.XAML.Visibility.Collapsed;
    }
}

Tip: Two section Hubs don’t wrap. This is by design. Having a Hub with fewer than three sections is not recommended UX and supporting wrapping for two section Hubs was very expensive.

SemanticZoom

SemanticZoom is available on both platforms but the interaction model varies significantly.

Windows behavior

It is the same as you know on Windows 8.1. You pinch on the ListView/GridView within a SemanticZoom to get the zoomed out view. Our sample uses SemanticZoom in Players.XAML

After you pinch the contacts you get the ZoomedOut view:

Windows Phone behavior

In the phone world, this used to be referred to as a JumpList in LongListSelector, and you invoke it by tapping on the group headers. Interaction for it stays the same. When the user taps the group header, SemanticZoom.ZoomedOutView is invoked with an animation similar to native phone jumplists. Here is an image to remind you what we are talking about. A sample for this is available in golflink.Phone project’s Players.xaml “all” players pivot item. Justification for the divergent interaction model has been that tablets are two-handed devices where the device is held with one hand and the screen is pinched with the other whereas phones are one-handed devices, and to invoke the zoomed out view (jump list) you only need to tap on the group header.

Tip: For the Listview on Windows Phone 8.1 XAML, do not forget to add a width to the ListView item template to avoid a horizontal bouncing bug. Check the sample comments in Players.XAML

DatePicker/TimePicker

DatePicker and TimePicker APIs are both available on the Windows 8.1 and Windows Phone 8.1 XAML stack, but they look and interact differently. Settings.XAML includes a basic sample. Here are a few screenshots.

Windows behavior

Windows Phone behavior

ComboBox

Windows behavior

Windows Phone behavior

The Phone ComboBox item list expands in place when there are up to five items, but will turn into a picker flyout for more than five items.

MenuFlyout

Similar to DatePicker/TimePicker. The experience for MenuFlyout is unique to each OS. The sample is in Settings.XAML page.

Windows behavior

On Windows it’s a simple flyout with menu items.

Windows Phone behavior

Windows Phone has an “elevator/escalator” animation (similar to ContextMenu from WPToolkit).

Phone-only control APIs

There are a few controls that we added after Windows 8.1 shipped that are only a part of the Windows Phone 8.1 stack (for now, yes, we understand and feel the pain of divergence).

Listview/Gridview additional properties

Converters for zoomed out view (jumplist)

JumpListItemBackgroundConverter/JumpListItemForegroundConverter helps with setting the right colors for the Jumplist (zoomed out semantic zoom view). Used in Player.xaml’s “all” pivot item.

ReorderMode

It is very easy to invoke reorder mode now. All you need is a two-way binding with the collection on your ListView and then Enable/Disable this property on the ListView. You will see the usage on Windows Phone’s Players.xaml page (“favorites” pivot item).

However, there is no ReorderMode_changed event, so you need to use data binding to get the state changes of ReorderMode. Here is how we have done it in the app:

Players.xaml

<Page
x:Class="golflink.Pages.Players"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:golflink.Pages"    
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:prim="using:Windows.UI.XAML.Controls.Primitives"
xmlns:Interactivity="using:Microsoft.XAML.Interactivity" 
xmlns:helpers="using:golflink.Helpers"
mc:Ignorable="d" Name="rootPage">
<ListView Name="favoritesListView" ItemsSource="{Binding RecentPlayers}" 
ReorderMode="{Binding ReorderMode, ElementName=rootPage, Mode=TwoWay}"
ItemTemplate="{StaticResource RecentListViewItemTemplate}">
</ListView>

Players.xaml.cs code behind

public sealed partial class Players : Page, INotifyPropertyChanged
{
//other usual methods

private void editAppBarButton_Click(object sender, RoutedEventArgs e)
    {
this.ReorderMode = ListViewReorderMode.Enabled;
        ReorderModeChanged();
    }

private void acceptAppBarButton_Click(object sender, RoutedEventArgs e)
    {
this.ReorderMode = ListViewReorderMode.Disabled;
        ReorderModeChanged();
    }

private void ReorderModeChanged()
    {
if(this.ReorderMode == ListViewReorderMode.Enabled)
        {
            playerPivot.IsLocked = true;//lock the pivot
            editAppBarButton.Visibility = Windows.UI.XAML.Visibility.Collapsed;
            acceptAppBarButton.Visibility = Windows.UI.XAML.Visibility.Visible;   
        }
else
        {
            playerPivot.IsLocked = false;
            editAppBarButton.Visibility = Windows.UI.XAML.Visibility.Visible;
            acceptAppBarButton.Visibility = Windows.UI.XAML.Visibility.Collapsed;
        }
    }

private ListViewReorderMode _reorderMode = ListViewReorderMode.Disabled;
public ListViewReorderMode ReorderMode
    {
        get
        {
return _reorderMode;
        }
        set
        {
if (_reorderMode != value)
            {
                _reorderMode = value;
                NotifyPropertyChanged();
this.ReorderModeChanged();
            }
        }
    }

public event PropertyChangedEventHandler PropertyChanged;
private void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
    {
        PropertyChangedEventHandler handler = PropertyChanged;
if (null != handler)
        {
            handler(this, new PropertyChangedEventArgs(propertyName));
        }
    }
}

Pivot

Pivot for Windows Phone 8.1 XAML shares the same behavior as Windows Phone 8.0, but the API is not available in Windows 8.1 XAML. This makes it tricky to share the page across the two projects in universal apps.

In our example, we have two separate XAML files. The Phone side uses the Pivot and the Windows side uses a custom design implementation that suits the app’s content.

The Pivot API in Windows Phone 8.1 XAML SDK is same as the Silverlight 8.0 Pivot API. One delightful feature that was included was Pivot.SlideInAnimationGroup="GroupOne". The intent of this property is to slide in FrameworkElements when the selected PivotItem changes. All the elements in a group slide in together and you can have three different levels (groups). Use it responsibly. Check out Phone’s Players.xaml for the usage example.

StatusBar, margins on pages and headers

StatusBar (System tray) is now always visible on Windows Phone 8.1 unless explicitly hidden. Its opacity is set to 0. To explain this part, let us define CoreWindowBounds as the screen window, the size of the phone window in logical pixels. VisibleBounds is the size of the visible region of the window (CoreWindowBounds minus size of StatusBar+AppBar).

By default, the page’s content takes the VisibleBounds, however the page background, when set, takes the CoreWindowBounds. If you set a background on the page, it goes all the way from top to bottom, behind the app bar and status bar. But the content of the page stays in the visible region.

To be clear, let’s look at the basic XAML below:

<Page
x:Class="App29.MainPage"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:local="using:App29"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
mc:Ignorable="d"
Background="Red">

<Grid Background="Yellow">

</Grid>
<Page.BottomAppBar>
<CommandBar Name="appBar" Visibility="Visible" Opacity="0.5">
<CommandBar.PrimaryCommands>
<AppBarButton Icon="Edit"
Label="edit" Name="editAppBarButton"/> 
</CommandBar.PrimaryCommands>
</CommandBar>
</Page.BottomAppBar>
</Page>

This is the result of the page:

This is good. Now you don’t need to worry about the content of the page being occluded by either StatusBar or AppBar.

Additionally, Pivot/Hub templates already offset their respective headers to account for a visible/hidden StatusBar, so you don’t need to worry about it.

Tip: You should be careful when toggling the state of the appbar’s ClosedDisplayMode as it resizes the content and could result in the page jumping. We recommend toggling the state of the appbar only when you have a ScrollViewer on that particular page (or HubSection or PivotItem).

Then, unfortunately, one of the scenarios was not caught earlier. It is better that we list the workaround here than to have you go through an ordeal trying to fix the issue.

If you have a Jumplist (SemanticZoom) as a child of a PivotItem/HubSection, the transition is not smooth from the ZoomedOut to ZoomedIn view because of this margin adjustment and because the Jumplist hides the StatusBar automatically. The workaround here is to disable the page resizing. It is important to note that this is a global, app-wide setting. So don’t forget to re-enable VisibleWindow when you leave the page.

protected override void OnNavigatedTo(NavigationEventArgs e)
{
    navigationHelper.OnNavigatedTo(e);
    (Windows.UI.ViewManagement.ApplicationView.GetForCurrentView()).
SetDesiredBoundsMode(Windows.UI.ViewManagement.ApplicationViewBoundsMode.UseCoreWindow);
}

protected override void OnNavigatedFrom(NavigationEventArgs e)
{
    (Windows.UI.ViewManagement.ApplicationView.GetForCurrentView()).
SetDesiredBoundsMode(Windows.UI.ViewManagement.ApplicationViewBoundsMode.UseVisible);
    navigationHelper.OnNavigatedFrom(e);
}

The PivotHeaders are fine and in place. All you need to do is ensure your content is not occluded by the AppBar (CommandBar). Add compensation padding at the end of the content to account for the app bar. In our case, we do it using the footer property on ListView:

<ListView.FooterTemplate>
<DataTemplate>
<Rectangle Fill="Transparent" Height="60"/>
</DataTemplate>
</ListView.FooterTemplate>

ContentDialog

This is a custom message dialog with phone dialog UX that is completely customizable. You can also cancel the closing of the dialog if the result of the dialog is not to your app’s liking (example terms and conditions are not accepted).

A basic sample can be found on settings.xaml page for phone project.

AutoSuggestBox

The Windows 8.1 functionality equivalent for this would be SearchBox, which allows you to do suggestions. AutoSuggestBox is lightweight, without Search integration, and suggestions in a list with ItemsControl. A sample can be found on Settings.xaml page for phone.

ListPickerFlyout

Unique to Windows Phone, you can now have ListPickerFlyouts to display a list of content in a pop-up-like fullscreen window. Sample usage in Settings.xaml of phone project

Animations

The talk on animation at //build pretty much covered everything. The sample demonstrates the usage from the talk. Here is a brief summary:

• All the animations existing on Windows also exist on Phone. Some might be modified for phone UX (for example, PointerDownThemeAnimation is more like the tilt effect on phone; refer to the Profile.xaml usercontrol sample).
• Phone has added a new concept of NavigationThemeTransitions on pages. There are three different types of navigation animations: CommonNavigationTransitionInfo (default turnstile animation), SlideInNavigationTransitionInfo and ContinuumNavigationTransitionInfo. These are all covered in the animations talk and used in the sample. This could be a differentiating factor between a four star and a five star app. For more details refer to Kunal’s talk from Build - Animations in Windows Phone XAML Apps
• Here is an example of how to define it:
  

  <Page.Transitions>
  <TransitionCollection>
  <NavigationThemeTransition>
  <NavigationThemeTransition.DefaultNavigationTransitionInfo>
  <CommonNavigationTransitionInfoSlideNavigationTransitionInfo/>
  </NavigationThemeTransition.DefaultNavigationTransitionInfo>
  </NavigationThemeTransition>
  </TransitionCollection>
  </Page.Transitions>
  

When going from page A to page B, the framework plays the animation as defined on page B. And then, when navigating back from page B to page A, the framework will play the right animation contextual to the navigation (example - in this case slide-out page B).

XAMLToolkit

Almost everything that was in WPToolkit is now part of the Universal XAML framework. What are you looking for in XAMLToolkit? We really want to know. Your feedback helps us prioritize the work we do.

Conclusion

Phew. . . that was a lot of content. We have worked really hard to provide this level of convergence in universal apps. We know it is not 100% perfect but it’s a step in the right direction. We hope this post helped you get past a few glitches you might have encountered when writing your universal app.

Thank you for reading this far and feel free to reach out with questions in comments or directly

Modern Combat 5: Blackout arriving soon for Windows and Windows Phone 21 Jul 2014, 12:19 pm

Modern Combat 5: Blackout is one of the most highly anticipated mobile games of the year. Many of you have been wondering when this first person shooter will be arriving on Windows and Windows Phone. Your wait will soon be over! Today, Gameloft has announced that Modern Combat 5: Blackout will be available for download on both Windows and Windows Phone on July 24th, just a few days away. The game looks pretty amazing.

Gameloft has created some great, highly rated games for Windows and Windows Phone including Asphalt 8: Airborne, Despicable Me: Minion Rush, and many more. Many more games are on the horizon as well. Gameloft also just announced that all of their Gameloft HD titles in 2014 will release immediately on the Windows Store and Windows Phone Store.

Marvel’s Guardians of the Galaxy comes to Windows and Windows Phone 17 Jul 2014, 11:20 am

I am so excited for Marvel’s Guardians of the Galaxy which hits theaters on August 1^st. The movie looks fantastic. As we wait for the movie, Marvel has released the game Guardians of the Galaxy: The Universal Weapon for us to get acquainted with this ragtag group of characters.

The Guardians of the Galaxy include Star-Lord, Rocket the gun-toting raccoon, the tree-like humanoid Groot, the mysterious and deadly assassin Gamora, and Drax the Destroyer. You play as the Guardians in the game on a brand new adventure to recover the five pieces of The Universal Weapon before it falls into the hands of the villainous Ronan the Accuser. As you play, you can unlock, upgrade and control 25 characters from the Guardians of the Galaxy universe. And you travel through the galaxy battling through more than 60 levels of real-time, gesture-based combat in Story Mode.

You can buy Guardians of the Galaxy: The Universal Weapon from the Windows Store for $7.99 (U.S.) or from the Windows Phone Store for $4.99 (U.S.).

New Opportunity: Kinect for Windows + Unified Windows developer portal and documentation and 21 additional payout markets 16 Jul 2014, 1:27 pm

Earlier this week Microsoft released the Kinect for Windows Public Preview which represents a new opportunity for Windows developers, as apps created with the new SDK may be published to the Window Store later this year. We’re making plans to prominently feature Kinect-enabled apps to provide customers with an exciting new Windows experience. I’d like to encourage you to download the preview today and be one of the first to publish a Windows app integrating the Kinect experience.

Today we are also taking the next step in the journey to a single unified Windows platform which began last November with unified developer registration, and continued at Build with universal Windows apps. With this release, we are bringing together Windows Phone and Windows Store online developer resources including education materials, guidance, code samples and reference documentation. We now have a single Windows Dev Center website – dev.windows.com – to aid those of you developing apps and games across phone, tablet and PC.

Finally, this week we’re also expanding the number of payout markets to include 21 new markets from which you can submit paid apps. This includes apps with in-app purchase, the fastest growing Store revenue model, representing nearly 50% of Windows Phone developer payout and over 30% of Windows payout – and growing.

New opportunity: Kinect for Windows

This week we released the Kinect for Windows SDK 2.0 Public Preview. Apps created with this release may be published to the Windows Store once the final, RTM version of the SDK is available (planned for later this year). And, to make it easy for you to leverage Kinect technology within your existing games, the SDK 2.0 release includes Unity support.

Key enhancements in the 2.0 release include improved skeletal, hand, and joint orientation support; advanced face tracking; simultaneous multi-app support; and enhanced recording and playback features so you can develop without having a Kinect sensor with you at all times.

You can expect to hear more about this new opportunity in the coming months. You’ll want to visit the Kinect for Windows site where you can download the Public Preview and purchase the v2 sensor.

dev.windows.com, the one place to learn about Windows app development

In the unified site you will find the content and guidance for both Windows Phone and Windows Dev Centers consolidated in to a single location. Learn about design, find the tools you need for development, and understand the steps to publish universal Windows apps. We’ve also combined code samples and forums into a single, convenient location.

Unified documentation: You will now see a comprehensive, combined documentation set to help you learn how to build apps for Windows devices (phone, tablet and PC), with API and feature distinctions clearly called out. Documentation is now available in 11 languages: German, English, Spanish, French, Italian, Japanese, Korean, Brazilian Portuguese, Russian, Simplified Chinese and Traditional Chinese.

Single location for code samples: The code samples for Windows Phone and Windows Store apps, as well as for universal Windows apps, continue to be published in the MSDN code gallery. The difference is that they are now easily accessible directly from one Dev Center page.

Single location for developer forums: The Windows Store apps and Windows Phone developer forums have been merged into one streamlined set of forums. The dashboard forums have been combined so that they appear together in one location, while the technical forums remain specialized for each form factor.

The dashboards will remain separate for Windows Phone and Windows. When you first click the Dashboard link in the Dev Center, you’ll be able to choose which one to start with. After that, switching between the two is simple. Just use the link in the left-hand navigation pane.

­

21 New Payout Markets

Beginning this week the number of markets in which registered developers can submit paid apps has been increased by 21 for both Windows Phone and Windows Store. The 21 new payout markets include: Albania, Antigua and Barbuda, Armenia, Azerbaijan, Belarus, Bosnia and Herzegovina, Botswana, Comoros, Dominica, Fiji Islands, Georgia, Iceland, Liechtenstein, Mauritius, Monaco, Mongolia, St. Vincent and the Grenadines, Tajikistan, Tonga, Turkmenistan, Uzbekistan.  This brings the count to 149 markets where Windows Phone and Windows developers can earn revenue through paid apps or through in-app purchase. 

Windows App Studio Beta site improvements

And for our novice developers we’ve recently refreshed the Windows App Studio Beta site, making it easier to use in addition to adding new ‘getting started’ training content. If you’ve got an idea for a great app, but little time or coding skills, I would encourage you to try this easy-to-use tool.

I’d like to encourage you to download the Kinect for Windows SDK 2.0 Public Preview and be one of the first to bring Kinect-enabled apps to the Windows platform. And visit the new unified Dev Center portal to start developer universal Windows apps. As always, your feedback is important to us, please continue to let us know what you think at Dev Center user voice.

Free group video calling now available with Skype for Windows 8.1 15 Jul 2014, 10:58 am

You can now bring family and friends together for free group video calling with Skype for Windows 8.1 on your Windows PCs and Tablets. Group video calling allows you to have group video calls with up to 9 people at the same time. This was previously available only as a premium feature with a paid subscription but now it’s free and really easy to do.

For all the details on how group video calling works with Skype for Windows 8.1, read their blog post here. Or watch the below video! You can download Skype for Windows 8.1 here from the Windows Store.

Viggle now available for Windows and Windows Phone 15 Jul 2014, 8:32 am

Who doesn’t like the idea of earning rewards for watching their favorite TV shows and listening to their favorite music? With Viggle, just hold up the app to check in to TV shows you’re watching or match music you’re listening to earn Viggle Points. You can then redeem the Viggle Points you earn for rewards like movie tickets and gift cards from BestBuy, Lowe's, Gap, Fandango and more. By checking into featured shows or songs, you can early 2X, 5X, 10X the points. With the app, you can also set custom reminders for your favorite shows and get access to exclusive celebrity content with Wetpaint original videos.

Download Viggle for free from the Windows Store and here from the Windows Phone Store.

Click here to read Viggle’s announcement of these apps and their collaboration with Microsoft.

Right now, you can install and register the Viggle app on a Windows device for a chance to win a Surface Pro 3 and other prizes. The first 2,000 users who invite five friends to join get a $5 Windows Store gift card.

Click here for the terms and conditions.

WPC 2014: Partnering to win in the mobile era 15 Jul 2014, 8:30 am

Today, we are at Microsoft’s Worldwide Partner Conference (WPC) in Washington, D.C. This is one of my favorite events of the year because it gives us an opportunity to connect with our partners and gather invaluable feedback on their experiences working with us, our platform and productivity scenarios. It’s also a unique opportunity for our partners to come together and share how they are using Microsoft technologies to create innovative solutions.

This year is an important one for WPC, following a lot of big changes across our company and across the industry. The conversations I have been having with partners lately have largely centered on mobility. The rise of mobility is presenting businesses, from small organizations to large enterprises, with a lot of new and innovative opportunities – and along with that, many complex challenges. Our partners are rising to the occasion; and to support them, enabling mobility and mobile scenarios has been a top priority for the company – and undoubtedly for the Windows and Windows Phone business specifically. This is why we are continuing to make investments in several key areas, including business-ready devices, mobile productivity services, line of business apps and enterprise-grade management systems, all which enable new mobile scenarios.

Interesting partner stories always surface at WPC and one that I am really excited about this year is iRiS Software Systems and InterKnowlogy (finalist for Windows 8 app developer partner of the year). Both are working together to help luxury hotel company, Mandarin Oriental Hotel Group reimagine the customer experience at its worldwide properties. Mandarin Oriental has piloted Microsoft Surface Pro tablets in four of its award-winning locations in London, Washington DC, Las Vegas and Tokyo. The in-room tablets feature a custom Windows 8.1 Start screen and immersive touch apps that allow guests to quickly and easily request hotel services such as housekeeping, laundry and in-room dining. They chose Windows for this solution for a few reasons, one being that they can quickly and easily wipe the tablet with our Remote Wipe functionality. For more information on Mandarin Oriental’s deployment of Windows on Surface tablets, read the Spotlight news story here.

Also at WPC, we’re working with our OEM partners to ensure that they have the knowledge and access to the right technology resources to support their customers’ business needs. With that in mind, I want to share with you a couple of exciting partner announcements:

• Partnering with HP and Intel, we announced the Best for Business Mobility Program. This effort combines HP’s ecosystem of business-optimized tablets and convertible PCs, powered by Intel processors for increased reliability and processing power, with Microsoft productivity solutions and vertical apps to help businesses redefine workflows, enhance productivity and deepen customer connections.
• To continue driving unique, end-to-end IT solutions, Fujitsu announced their new 8-inch tablet this week and shared how they are leveraging Project Siena, Microsoft’s new tool that allows business experts with Excel and PowerPoint skills to create powerful, custom mobile apps. Recognizing the opportunity to quickly deliver value to customers, Fujitsu has trained over 70 developers and 100 sales personnel to utilize the solution for simple integration into overall business mobility processes. This puts Fujitsu in an advanced position to meet customer expectations for a flexible and rapid development of commercial apps on a mobile device.

If you haven’t seen much about Project Siena, I encourage you to check it out. I spoke about it today at WPC and we demonstrated some of its functionality. It’s an impressive tool and very relevant in today’s business landscape. Nearly every customer we speak with has an idea for a mobile app that could transform their business processes or activities. Project Siena is a pure reflection of our mission to reinvent productivity, empowering people and organizations to bring app ideas and concepts to life. As we first shared with you at the end of last year, Project Siena helps easily translate those imagined ideas into full, functioning apps.

Yesterday, we released Beta 3 of Project Siena, a major addition that will make it even easier for business experts and business analysts to build powerful, service-connected apps. The Beta3 includes social and communication functionality, and integration with popular web services, all just a click away. Also new in Beta3, IT will have the ability to bring in an even greater spectrum of custom services. I encourage you to visit the Project Siena website to learn more about how it can help your company easily build Windows 8 apps, and download the beta version of Project Siena today.

In the last few months, we have seen some great examples of Project Siena in action. Notably:

• Toro, a leading provider of innovative turf, landscape, rental and construction equipment, saw Project Siena just four weeks before a NASCAR race at the Talladega Speedway. Within days, they were able to conceive and create an impactful app that allowed attendees to explore and understand the Toro product catalog, with content and features crafted specifically for the race event.
• Another example is Persistent Systems, a global company specializing in software products and technology services. Their business analysts and architects use Project Siena to impact app discovery conversations with customers. With Project Siena, they can convert ideas into highly-functional prototypes right as the customer conversation is happening, helping validate and refine the ideas to happen almost immediately.
• Aditi Technologies is a cloud led customer experience design partner, who uses Project Siena for its solution consulting efforts. Using Project Siena to quickly create apps in near-real time gives Aditi’s team the ability to build products and solutions for user demos and prototype walkthroughs. This has helped them shorten sales cycles and bring customer experiences to life faster.

Our partners are really doing some incredible things this year. Tomorrow, Tony Prophet – our new Windows marketing chief – will take the stage to talk more about the Windows and Windows Phone vision and opportunity. Satya Nadella will cap the conference, addressing partners for the first time as the CEO of Microsoft. Both are available for live streaming via Digital WPC.

Windows themes from dawn to dusk 14 Jul 2014, 12:06 pm

Do people still read the Iliad? I studied it in school, mumble years ago, and one of the few things I remember about it is that every single time sunrise is mentioned, it is described as “rosy-fingered dawn” or “dawn’s rosy fingers.” I don’t know about you, but I have never once looked at the brightening eastern sky and thought, “Yep, that looks like a pink hand.” But dawn certainly can be beautiful, so I’ve curated a luminous set of misty morning images that I hope will bring a touch of quiet serenity to your desktop. Now you don’t even have to get up early to enjoy the loveliness of sunrise!

Water is beautiful in all its forms, whether in an expansive lakeside view or in the smallest dewdrop. Photographer Shilpa Rao captures the gemlike clarity of water drops in her new Liquid Jewels theme, in which they gleam like amethysts, rubies, garnets, and topazes beading the petals of vibrantly colored flowers.

Photographer Sean Byrne’s new theme, celebrating the beauty of Britain, includes watery seaside views (at Devon, Brighton Pier, Brancaster, and along the English Channel) as well as notable inland sights including Stonehenge, Big Ben, and the Tower Bridge. His images vividly convey the glittering light and fast pace of the city as well as the peaceful quiet of more remote British landscapes.

Meanwhile, on the other side of the world, photographer Josh Robinson has been documenting the lush and varied landscapes of New Zealand, which you can now enjoy in his new theme. We’ve intermingled panoramic and standard proportion images for twice the immersive drama.

Photographer Rebecca Heigel takes a closer view at nature’s beauty in her new theme, Spring Blooms, which includes gorgeous flowers in all the warmest sunset shades, from brilliant flame orange through gold and rosy pink.

Flowers (and the pretty bugs who love them) appear in our next new theme, as well. Community Showcase: Insects 2 includes delicate dragonflies, spotted ladybugs, fuzzy bees, and one iridescent beetle. This big theme features photographs submitted by 21 contributors to the Open Call, including Alexandra Planet, Gerard Durnota, Ekaterina Kokushkina, and Aarti Bhardwaj. This shot of a ladybug on a thistle bloom is by Bobby Morrison.

Larger creatures, whether feathered, furred, or scaled, take center stage in Community Showcase: Fauna 2. This theme features the best wildlife and pet photography from 20 photographers including Dan Porcupile, Olga Górka, Adrian Maraś, and Meera Sulaiman. This arresting shot of a golden-eyed kitten is by Carly Kaste.

If you have an older version of Windows that can’t use themes, or if you prefer to use a single image, we have new desktop décor for you, too. Here are just a few of our new wallpapers.

I’ve mentioned this before, but it bears repeating: You can also customize your Windows 8 or 8.1 lock screen – or your Windows Phone – with wallpapers from the Personalization Gallery. I explained how in this blog post.

That wraps up the latest overview of new themes and wallpapers. I hope you’ll keep checking back on the Personalization Gallery for more great new imagery to keep your Windows PC or Windows Phone looking fresh from sunrise to nightfall and all the hours in between.

Tips for submitting apps in markets that require an age rating 14 Jul 2014, 7:00 am

Windows and Windows Phone apps are available in hundreds of markets, as seen in my Windows Store trends blog. Many of these markets have organizations that help label apps for the age group for which they are most suitable. In some markets these ratings are optional, but in a few markets, apps require a rating to be able to be published in that market.

These age ratings are typically based on content and features, and their goal is to provide information for users in that market about the content of the app or game. To the left is an example of how a user in the United States would see an ESRB rating in the details of an app in the Windows Store.

Both Windows and Windows Phone support age ratings, and in this blog I will share guidance and ideas to facilitate publishing in the markets that have age ratings, with some more detail on how to submit your app to the Windows Store in those markets.

Age ratings overview

Both the Windows and Windows Phone stores support age ratings from market-specific ratings organizations, for example:

• United States uses the Entertainment Software Rating Board (ESRB) ratings
• Most of Europe uses the Pan-European Game Information (PEGI) ratings
• Japan uses the Computer Entertainment Rating Organization (CERO) ratings

All of these ratings bodies have established standards for each rating level within their system; individual app ratings are based on these guidelines. Most ratings bodies also provide a rating certificate (in PDF or similar format) to serve as record of your rating. In the majority of markets, to submit an app with an age rating from a third-party ratings organization, you will need both a rating value and a rating certificate.

It is always a good practice to obtain an age rating for your app, even if it is optional, as this will help users choose the content that is appropriate for them.

In addition to the market-specific age ratings, Windows Store additionally requires assigning an age rating for every single app that is submitted and distributed through the Windows Store. This post focuses only on the market-specific age ratings.

Age rating process overview

During app submission, you select the markets where your app will be published. If some of the markets require a game rating, you have to obtain a rating value and supporting documentation for each market, and then submit your app:

• Windows Phone Store: Submit your app, and in the metadata select the rating for each market (where applicable) and upload the rating certificates.
• Windows Store: Create a single GDF file with all the ratings for the app, submit the app, submit the single GDF file with all the ratings, and upload the rating certificates.

Below I’ll list all the markets that require an age rating, and detail the process to submit apps to both Windows and Windows Phone for markets that require an age rating.

Does your app need an age rating from a ratings organization?

Here are the ratings organization supported by Windows and Windows Phone.

* The rating process for Russia varies between Windows and Windows Phone. Windows Phone currently supports PEGI, and Windows supports PCBP.

Every rating organization has their own process for obtaining a rating.

For example, for ESRB, we offer a free online tool to obtain an ESRB rating (Windows or Windows Phone), and for PEGI we also offer a free online tool (Windows or Windows Phone). To obtain ratings and ratings certificates for optional ratings organizations other than ESRB and PEGI, please visit the respective rating organization’s website.

I’ll now walk you through the specific process for each market where a rating is required.

Game ratings in Brazil

Brazil requires content to be rated using the DJCTQ rating system. The DJCTQ rating is administered by the Brazilian Advisory Rating Coordination (Coordenação de Classificação Indicativa). There are three ways to obtain a DJCTQ rating for your app:

• Submit your app for review by the DJCTQ, and get a rating published in the official government publication, or
• Obtain a ESRB game rating using the online form (Windows or Windows Phone), and then you assign the equivalent rating using DJCTQ guidelines, or
• Obtain a PEGI game rating using the online form (Windows or Windows Phone), and then you assign the equivalent rating using DJCTQ guidelines

Add rating to Windows Phone app

In Windows Phone Dev Center, during app submission, in the App Info section, expand the More Options section, then select the DJCTQ rating from the pull-down and upload a certificate (either scanning the DJCTQ official government publication or adding the ESRB or PEGI certificates).

Add rating to Windows Store app

First create a GDF (Game Definition File), and include the DJCTQ rating.

Then during app submission, upload the GDF file in Windows Dev Center, in the Age Rating section:

And add the certificate file (either the DJCTQ, PEGI or ESRB certificate):

Game ratings in Russia

Russia requires a PCBP rating, which is assigned by you, based on the PEGI rating. So the first step is to get a PEGI rating (use the Windows or Windows Phone online form to get it), then self-rate your game using the guidelines published by PCBP.

Add rating to Windows Phone app

In Windows Phone Dev Center, during app submission, in the App Info section, expand the ‘More Options’ section, then select the PEGI rating from the pull-down, and upload the PEGI certificate.

Add rating to Windows Store app

First create a GDF (Game Definition File), and include the PCBP rating.

Then during app submission, upload the GDF file in Windows Dev Center, in the Age Rating section:

And add the PEGI certificate file:

Game ratings in South Korea

Korea requires all games to be rated using the GRAC system (formerly GRB). To obtain it, follow the process described in the GRB site. If you are not from Korea, you’ll require a local representative in Korea in order to request the rating.

Add rating to Windows Phone app

In Windows Phone Dev Center, during app submission, in the App Info section, expand the ‘More Options’ section, then select the GRB rating from the pull-down, and upload the GRB certificate.

Add rating to Windows Store app

First create a GDF (Game Definition File), and include the GRB rating.

Then during app submission, upload the GDF file in Windows Dev Center, in the Age Rating section:

And add the GRB certificate file:

Game ratings in Taiwan

Taiwan requires content to be rated using the CSRR rating system. The CSRR system is self-rated, so you assign the rating based on the CSRR guidelines (Chinese/English). You should also register as a developer with CSRR (typically takes a few days) and then register your game with CSRR through their website.

Add rating to Windows Phone app

In Windows Phone Dev Center, during app submission, in the App Info section, expand the ‘More Options’ section, then select the CSRR rating from the pull-down. No certificate is needed.

Add rating to Windows Store app

First create a GDF (Game Definition File), and include the CSRR rating.

Then during app submission, upload the GDF file in Windows Dev Center, in the Age Rating section:

Then add a screenshot of the CSRR website where you show the rating assigned by CSRR:

One last step

After you have the rating and certificate, and have added them to the app submission, I recommend double checking that the market is selected so that the app is actually being published in that market.

For Windows Phone, during submission, go to Market selection, then check that the market or markets you are publishing to are selected:

For Windows, during submission go to Selling details then check that the market or markets you are publishing to are selected:

Publishing your apps in all the markets that require age ratings can increase your downloads, so if you have not published your apps in all the markets, take the time to do it now.

For more information, take a look at the Windows game rating documentation, the Windows Phone game ratings documentation, and learn how to create a GDF file.

Please let me know if there are questions, as this is a constantly evolving topic, as countries and governments adjust to the rapid growth and increased use of apps.

Bing magic helps Cortana predict the winner in 15 out of 16 Soccer (Football) matches in Brazil 13 Jul 2014, 3:19 pm

A few weeks ago, we enabled the ability for Cortana to predict the outcomes of soccer matches from Brazil powered by prediction technology in Bing on devices running Windows Phone 8.1. Thanks to Bing, Cortana has accurately predicted the winner in 15 out of 16 games of those popular soccer matches (a near perfect bracket in the knockout rounds) which is pretty amazing.

As noted here in this Bing Blog post, the model in which Bing uses to predict sporting events like these soccer matches consists of a few things. It looks at the strength of each team through a variety of factors such as previous wins/losses/ties in qualification matches, other international competitions and margin of the victories in these competitions. Then other adjustments are made related to other factors that might give a team advantages over others like home field advantage (for Brazil), proximity (for South American teams like finalist Argentina), playing surface (hybrid grass), game-time weather conditions, and other factors. The data can also be tuned based on win/lose/tie probabilities captured by the people wagering on the outcomes. This model doesn’t rely more heavily on any one element but rather has the advantage of dynamically and continuously adapting up until game time in an innovative way to give users the best possible prediction. For more on how Bing makes predictions, read this blog post from Next at Microsoft.

It is also pretty amazing we were able to enable the prediction behavior in Cortana in just a week and have it light up on people’s Windows Phone 8.1 devices.

We’re excited to be able to do more of these types of things with Cortana in the future.

Rolling out the Windows Developer Program for IoT 11 Jul 2014, 2:43 pm

You’ve heard quite a bit recently about Microsoft’s strategy for bringing Windows to more devices, including IoT. Today I’d like to update you on the commitments we made during the recent O’Reilly Solid and Microsoft Build events to ship developer kits that allow people to run a version of Windows on the Intel Galileo board.

I’m pleased to share that we’ve begun rolling out a new Windows Developer Program for IoT. Through this program we are introducing a new Windows Developer for IoT Portal, with documentation and examples to support the developer kits we are starting to ship in small batches. These developer kits include a Galileo board and preview Windows image that supports the standard Arduino Wiring API set and a subset of Win32 API. This Windows image does not yet support Galileo boards outside of our program.

We are putting out the developer kit in preview to gather feedback. The Windows image we’ve used should be viewed as a proof of concept (read: don’t bet your business on it). We’re sharing this toolkit to find out what folks think, see what kinds of cool things you build with it and learn how to make Windows ever-better on this class of devices. To make things even easier, Microsoft Open Technologies has open sourced much of the toolkit, which will be available on Github in the coming days (more from them here). There you’ll find full access to toolkit components (Arduino Wiring Headers, Arduino Wiring Implementations and porting functions), documentation, sample projects and shield/library ports for Galileo running Windows.

We are rolling out this new program gradually to make sure that everything is working well and we’re able to provide the right level of support. We plan to ship a couple of hundred kits each week this summer and continue adding more templates and guidance to the Developer Portal. We’ve already seen an overwhelming amount of interest in Windows for IoT. As a result, we will not be able to ship this initial developer kit to everyone who signs up. We will, however, continue to share new resources and updates with all program participants. In the mean time we think you’ll find lots of great content to play with on the portal and Github. We’ll keep working to give people more ways to experiment with Windows for IoT, bringing more and smaller devices into the Internet of Your Things.

Microsoft launches new Windows Apportals 11 Jul 2014, 8:46 am

Today we launched Windows Apportals on Microsoft.com, at http://microsoft.com/enterprise/apportals.

WHAT ARE WINDOWS APPORTALS?

A Windows Apportal is a Windows 8.1 app that can integrate your entire Line of Business (LOB) stack into a single, modern, touch-based experience. The concept behind Apportals is simple – introduce the same nested folder structure common in a desktop OS to the modern mobile OS. The result is a UI experience that allows the user to drill from the Start screen (composed of Live Tiles) to another mini-Start screen (composed of Grid Tiles). And best of all, because an Apportal is built out of the OS, everything that runs on Windows runs in a Windows Apportal, including Desktop Windows 7 Applications; Modern Windows 8 Apps; and Web Applications.

WHY WINDOWS APPORTALS?

Windows Apportals address a long-missed insight in enterprise sales: customers use software from many vendors. Windows Apportals were built in response to numerous requests to create an “on-the-glass” integration for the wide variety of heterogeneous LOB apps that exist in organizations today, including legacy Windows 7 Desktop Applications; newer Modern Windows 8 apps; and Web Applications. IT Pros within enterprises  know that the wide variety of apps, applications, and services which exist in an organization require a loosely-coupled structure – and in today’s diverse organizational environments it is not realistic or desirable to build a single, monolithic application. Instead, organizations want to use the flexibility of the Windows 8.1 OS to create a UI-based virtual integration, and continue to gain value from existing legacy technology investments. Windows Apportals are the solution to this need.

USER CUSTOMIZATION WITH ACTIVE DIRECTORY

Active Directory (AD) plays an important role in Windows Apportals by providing role-based access to both the Grid Tiles and the back-end data sources. Specifically, AD is a directory service that Microsoft developed for Windows domain networks and which is included in Azure and Windows Server. With AD, a domain controller authenticates and authorizes all users and computers in a Windows domain type network – assigning and enforcing security policies for all computers and installing or updating software. For example, when a user logs into a computer that is part of a Windows domain, Active Directory checks the submitted password and determines whether the user is a system administrator or normal user. With a Windows Apportal, the AD settings determine the specific data and Grid Tiles to which a user is entitled. This provides a high-level of customization, and is particularly helpful in environments where there is a high-level of data customization required by user – such as sales organizations, healthcare organizations, and distributed enterprises. As a result, a single Windows Apportal app can filter, share, and display data and functionality based on job role, organization, industry, and even geography – thereby enabling users to stay focused on the specific tools and information they need to do their job.

“Customers get excited when they see Windows Apportals, they say it’s the future”, said Martin Wolfram, President, Inviso. “As a Microsoft partner, we are very customer focused. This new innovation has given us the opportunity to work with our customers to understand a broader set of their business needs, and then customize and deliver end-to-end services that meet those needs. The design and architecture lend themselves to easy re-use of code, which makes Windows Apportals an incredibly profitable line of business for us. Customers  see a lot of value in Apportals, so for us, Windows Apportals are game changer.”

For partners attending WPC 2014, register to attend the Windows Apportal session for a Windows Apportal demo.

Grad Conn, CMO Lead, Microsoft U.S.

Which app should I build? Exploring opportunities in the market 11 Jul 2014, 7:32 am

This blog post is the first in a guest series of articles from the creators of AppFeds.com which walk developers through some of the business aspects of app development. In this post, we will cover the process of identifying your goals, doing initial market analysis, and brainstorming to set yourself up for greater success before you even get started.

So you’re thinking about developing an app for the Windows Store—that’s awesome! The Store is constantly growing and is a hot space to develop for right now. To compete with tens of thousands of apps in the Windows Store, use real data to make good decisions to help your app succeed.

Note: This post specifically discusses how to look at data for the Windows Store. Similar data for the Windows Phone Store can be found on AppAnnie (who recently acquired Distimo). Also refer to the Windows and Windows Phone Store trends update on this blog for recent data and analysis.

Identify your goal

You may already have an idea of which app to build, or maybe even a whole list. Before you jump in, you should pause and determine why you are building the app to begin with. App developers build apps for a variety of reasons, most commonly money and passion, but let’s also consider fame and philanthropy.

Note: Microsoft’s Kraig Brockschmidt covered some additional business questions and goal breakdowns in his blog: Instrumenting Your App for Telemetry and Analytics.

Money

The majority of app developers want to make money with their apps. Whether you are building apps as a side project or as a full time job, if you’re building for money, it’s recommended you incorporate business strategies into your plans from the beginning. You need to think like a businessperson, even if your core skillset is more closely related to a developer. One key is to not get attached to a particular idea, but rather look for gaps and seek out market opportunities where there is good potential for profit. That is, instead of thinking about that one app you dream about, if you want to make money, focus more on download numbers, ad and in-app-purchase strategies, and more.

Passion

Some developers build for fun, often to work on improving their coding and design skills and to build a work portfolio. These developers can also be passionate about a certain area and build apps to better improve that area (think specific apps like dog grooming apps, yoga exercise instruction apps, news about popular entertainment, and so forth).

Fame

Fame is typically an outcome of a developer building for either money or passion. While this outcome is rare, an app’s fame can also raise visibility of the developer’s other apps. This results in increased downloads, significantly more money, and the ability to build a brand around your developer franchise, opening doors to even greater.

Fame may not be a desired outcome, however. In one recent case of an extremely popular app, the developer didn’t anticipate the fame that the app would bring him or its effect on customers. He ended up removing the app from both Apple’s App Store and Google Play because of the game’s frustrating and addictive style. In this case, fame was actually detrimental to the app and the developer.

Philanthropy

Lastly, there are some who build for charity, promote a message, or simply to help out a business that they believe in. Philanthropy developers don’t seek any reward for their efforts except for the benefit that their apps will bring (that is, as a benefit to a favorite charity).

Market Analysis

Regardless of your development goal, all apps have one very important thing in common: they all need users! Whether a user decides to download your app or not can be attributed to a large number of factors, but the first and most obvious factor is app discoverability – does the user even know your app exists?

This is where it’s important--once you’ve identified your goal—to spend some time looking into what the current market landscape looks like for the idea. Who are your competitors? How popular are they? What’s their value-add? Conducting a market analysis before you build an app can greatly increase the discoverability of your app and, as a result, lead to an increased number of downloads and users.

There are a number of resources available to help in analyzing the current landscape of the market. Choosing a category with less competition or adding features a competitor may not have will help make your app stand out more.

Windows Store

It’s good to understand the breakdown by category to see where people are building the most apps. To better interpret the data, look at the number of apps as well as the number of ratings and reviews. You can use a service such as AppFeds to get some overall data and get some insights from blog posts such as Windows and Windows Phone Store trends update. Let’s look at a recent snapshot from AppFeds.

Category breakdown (June 24, 2014 – AppFeds)

Ratings/reviews breakdown (June 24, 2014 – AppFeds)

As you can see from the first pie chart, Games is by far the most popular category (and the second chart shows that Puzzle and Arcade games account for half of all games). After games, developers have built a roughly equal number of apps in the Entertainment, Education, Books and Reference, and Music and Videos categories.

Now look at the bar chart for ratings and reviews, and you can see that Games wins by a huge margin, disproportionate to its category share. Similarly, the Social category is a relatively small slice of the whole apps catalog, but garners a relatively high number of ratings.

What does all this mean? Here are some thoughts:

• If you’re looking for areas with fewer competitors—where it might be easier to find opportunities—you might focus on the smallest categories such as Finance, Security, Photos, Government, and Health and Fitness.
• If you’re planning to build a puzzle or arcade game, you’ll be joining a plethora of similar games. Therefore you really need to think about making an app that’s unique enough to get noticed, or make sure you invest heavily in promotion.
• f you’re looking to learn how to make a great app that’s responsive to user feedback, Games are a good category to explore for that reason alone, as is Social and Entertainment.
• Even though Games as a whole is the largest category, some of the sub-categories have relatively little competition—and thus greater opportunities—than others. For example, if you hover over the Games pie chart on AppFeds.com, you’ll see the actual number of apps in that subcategory. Doing this you’ll see that subcategories like Racing, Simulation, Role Playing, Casino, and Music only have a few hundred apps apiece, compared with the thousands in other categories.

While the category breakdown is just one data point, it gives you insight into what types of apps have been developed. A second data point is to understand which apps are actually most popular right now. A good place to do that is on the Windows Store itself or services such as Distimo and AppFeds. What you start to notice is that some categories are disproportionately represented in the top app charts relative to their overall app count, again indicating potential opportunities. Social and Tools are good examples.

Apple’s App Store and Google Play

Similar to the analyzing of apps in the Windows Store, you will want to take a look at the other main platforms to find gaps. You can use a service like AppAnnie to help here.

Take a look at the top charts for the other platforms. Do you notice any app trends in the top that are missing from the top on Windows? A good example here was Flappy Bird. After seeing Flappy Bird at the top of the charts on the other platforms, clones and similar games started to show up on Windows as developers saw the gap and jumped on the opportunity.

Brainstorming

Looking at the market data, you may notice a particular category where there is relatively little competition. You may have also found a few missing apps or app types that seem to be currently popular on other platforms. Use this information to augment and better prioritize your ideas list. Once you have this, you can start looking at the competition in that space.

Quick Search

Take your top ideas and brainstorm a few keywords. For example, if you wanted to make a Solitaire game, you might have keywords such as: Solitaire, Spider Solitaire, Cards, Casino, etc. Take these keywords and look at the Top Charts. Do you already see one or more extremely popular apps of this type? Is there something that these apps are missing? What do users mostly criticize the app for? All of these pieces of information are opportunities that will result in a much more competitive app.

Resources

For your convenience, here’s a list of resources you can use while you research:

• AppFeds – A comprehensive site with statistics about categories and apps in the Windows Store. Also has tools such as Search Keyword Monitor.
• App Annie – A site with lots of analytics for all major app stores including the Windows Store. App Annie also has an SDK you can download and put in your app for in-app tracking and tools for app store listing optimizations.
• Distimo (recently acquired by App Annie but still separate)– A site with some analytics about all major app stores. It also has a powerful dashboard that lets you track downloads, revenues, conversions, and other important metrics.

What’s coming next

In the next article of the series, we’ll dig further into competitor analysis. This includes digging deep into competitor’s apps and figuring out how to position your app so that it can compete efficiently. By doing so, you can land on Top Charts and New and Rising, which can have a significant impact on your overall user base.

Subway Surfers now available on low-memory Windows Phone 8 devices 10 Jul 2014, 8:53 am

In an update today to their popular (and really fun!) game Subway Surfers, Kiloo is making Subway Surfers available to low-memory Windows Phone 8 devices (devices with only 512MB of memory). You can download Subway Surfers for free here from the Windows Phone Store. This update also brings new colorful outfits for Coco (who is returning to the game) and Prince K characters, a new special Sci-Fi board called the Teleporter, and new “I Got the Power” awards which you get by picking up powerups whenever possible.

5 tips for using Cortana reminders 9 Jul 2014, 3:39 pm

You might think you’re “forgetful” or “scatterbrained” or “have a mind like a sieve.” But how many times have you remembered that you’re supposed to collect your kid from the bus stop right up until it’s time to go—and then gotten distracted by some shiny object? Leaving your innocent child standing alone under a broken streetlamp with tumbleweeds blowing all around? For me, the answer is a number between 1 and 50.

Lately, I’ve been relying on Cortana—the new digital assistant in Windows Phone 8.1—to prevent such unfortunate events. I press and hold the Search button, and Cortana pops up, ready for my commands. “Remind me to pick up Louie at 3:20,” I say to her, or “Remind me to take my memory-boosting herbal supplement every morning at 8.” She can even give me reminders based on location (“Remind me to call Suze when I leave work”) or person (“Remind me to ask about summer vacation next time I talk to Mom”).

These reminder basics are awesome enough. To get even more out of reminders, try the following power tips:

1. Say “Any” thing – If you tell Cortana, “Remind me to get eggs next time I’m at the supermarket,” she’ll show you a list of nearby stores to choose from. Tap Any and she’ll remind you the next time you’re at any supermarket.

2. Lose the snooze – Sometimes you need more than a five-minute snooze delay. When a reminder pops up at an inconvenient time, tap the reminder’s title and you’ll be able to set a new time.

3. So many memories – To see (and reactivate) completed reminders from your past, press the Search button, tap Cortana’s Notebook > Remind me, and then tap More > Reminder history. Tap a reminder to reuse it. This is great when you accidentally tap Complete on a reminder you still need—something I seem to do on a daily basis.

4. Pin the Tile – I generally like to use voice commands to order up my reminders, but my husband doesn’t much appreciate that when I wake up at 3 A.M. stressing about something I need to do. So I use my Remind me Tile from my Start screen to (silently) add a reminder in Cortana’s Notebook. To pin the Tile to Start, press the Search button, tap Cortana’s Notebook > Remind me, and then tap Pin.

5. Set some nicknames – Use nicknames when you set up your inner circle (Mom, Louie, Pookie) and favorite places (gym, school, bakery). Then you can use the nicknames when you set reminders (and when you call and text people, too).

DEVELOPER SPEAK: Jani Tietäväinen aims to increase user base and engagement through continuous app experience 8 Jul 2014, 11:09 pm

Jani Tietäväinen, CEO and lead producer of Finland-based Seepia Games, received funding from AppCampus to build a strategy game called Permia Duels. Since he released the app to Windows Phone six months ago, it has been hugely successful, accruing 540,000 downloads. Tietäväinen built his game to scale across multiple platforms, but now, he will be able to access over one billion Windows users via Windows 8.1—with minimal effort on his part. As he prepares to launch his game for laptop and PC users, Tietäväinen agreed to talk with me about how he plans to make the most out of his upcoming release.

What excites you the most about Windows Phone 8.1?

“We’re creating a continuous experience across different form factors, thereby increasing user engagement.”

The universal Windows app is huge. I love that you can build one app and publish it to both the Windows and Windows Phone stores without having to re-code. By publishing the app to Windows Phone 8.1, we know we’re opening the door—so to speak—to Windows users worldwide. The size of that market potential is exciting to think about. Using a common code base means we can be more efficient in managing and updating our code, and it also simplifies support scenarios.

Permia Duels

Customers change their behavior and make different decisions based on the device they’re using, so if we want them to play our game, they need to be able to find it easily on their device. We can’t expect them to come looking for us. That’s why creating a compelling cross-platform experience matters so much. Fortunately, Windows now makes that easy. We envision our customers starting a game on their PC and then leaving and picking up where they left off on their phone or tablet. We’re using 8.1 to create a continuous experience across different form factors, thereby increasing user engagement.

What Windows Phone 8.1 features do you intend to leverage to make your game even more successful?

“[We can now] focus on building the best game we can and engaging our users rather than having to write extra code to make a feature work.”

I am particularly excited about the enhanced HTML5 support for native apps in Internet Explorer 11. Our users tend to access our game from within the browser, so I’m pleased I’ll be able to create the rich app experience with enhanced graphic support on Windows Phone 8.1. It’s great to see Microsoft innovate in this area. Google is just now starting to create native app support with Chrome, and Apple isn’t attempting anything of the sort.

I also intend to take advantage of the powerful combination that is Live Tiles and Action Center. I can use the new live tile templates to create a more visual connection with our users and then combine that with notifications through the Action Center to keep users updated and engaged.

From the perspective of a games developer, the people hub extensibility for social apps is very important because we are able to amplify our presence and invest more in connecting with users where they are likely to spend their time.

Our game is multi-player, so we run the game entirely in our backend. With background execution built into the platform, we can now be more efficient by moving some of that processing to the client side without compromising performance.

Also, we use Windows Azure quite a lot. We hope to start using Windows Azure Mobile Services as well to integrate the app with the cloud service directly.

In summary, the fact that all these features are built into the platform makes it easy for us to focus on building the best game we can and engaging our users, rather than having to write extra code to make a feature work. It’s a time-saver, and it helps us to optimize our resources.

Permia Duels

Do you have any advice for developers?

“I encourage developers to take advantage of the 8.1 release.”

The most important thing a developer can do is to build a high-quality app. Customers will have a good experience, and strong ratings will propel more to try it.

Create a strong leadership team. Seepia Games has six founders; each of us leads a different part of the development process – from game design to backend architecture to marketing.

Finally, I encourage developers to take advantage of the 8.1 release to expand the reach of their games across Windows and Windows Phone.

Seepia Games Founders include: Jani Tietäväinen (CEO and Producer), Jani Rönkkönen (Game designer), Pasi Hirvonen (Graphic designer), Juha Hyttinen (Technology architect), Antti Villanen (Advisor and Chairman of the board), and the software service company OCTO3 Ltd.

Twitter app update brings enhancements for sharing and uploading photos 8 Jul 2014, 1:13 pm

I thought I would pass along that the official Twitter app has received a nice little update today for Windows Phone (version 3.2.0.0). This update includes enhancements for sharing and uploading photos. For example, you can now upload multiple photos to a single Tweet. You can also tag your friends in the photos you’re uploading in a Tweet to start a conversation. And you can also add photos to Direct Messages. With this update, you can also now reply, retweet, favorite, or follow straight from a Tweet on your home timeline. Tweets with Twitter photos, Vine videos, and other (select) content will also now show a preview in your home timeline too!

If you don’t have Twitter installed, you can download it here from the Windows Phone Store.

Watch your favorite TV shows on your Windows PC, Tablet or Phone this summer 3 Jul 2014, 9:27 am

After celebrating the Fourth of July this year, recover on the couch and enjoy all the great new TV apps in the Windows and Windows Phone Stores. Or break out of the house and watch your favorite television shows and movies on-the-go. Either way, there’s several great apps to keep you entertained wherever you go this summer so long as you bring along your Windows PC, Tablet or Phone!

New TV favorites in the Windows and Windows Phone Stores:

1. A&E, Lifetime & History

Enjoy great shows whenever you want with 3 new apps for cable TV favorites A&E, Lifetime, and History. Login with your TV provider credentials, and A&E hits like Duck Dynasty, Bates Motel and Storage Wars are available to stream right to your device – along with behind-the-scenes interviews. The Lifetime app delivers full access to more than 25 original full-length movies, plus hit dramas and reality shows like Dance Moms, Project Runway and Devious Maids. And Pawn Stars, Swamp People, American Pickers, Ax Men and more await on the new History channel app. Get the apps free for Windows: A&E, Lifetime, and History. Also available free for Windows Phone: A&E, Lifetime, and History.

2. Bravo Now

Watch episodes of your favorite Bravo shows like Southern Charm, Million Dollar Listing, and Real Housewives with the Bravo Now app for Windows and Windows Phone. Login with your TV provider credentials and enjoy full episodes. And enjoy select episodes and clips even without a subscription. Get Bravo Now for free from the Windows Store. Also available in the Windows Phone Store.

3. Comedy Central

Looking for laughs? Then don’t miss the Comedy Central app! Watch the latest episodes of The Daily Show with Jon Stewart, The Colbert Report, South Park, Tosh.0, and more without a TV provider login. Or login and enjoy older, archived content and stand-up specials. Get Comedy Central for free from the Windows Store. Also available in the Windows Phone Store.

4. MTV Shows and VH1

Watch the latest content from MTV Networks with the MTV Shows and VH1 apps. Enjoy a sampling of free content, or login with your TV provider credentials to unlock the full MTV Shows experience including full episodes of shows like Awkward, Teen Wolf, Real World, and more. Enjoy coverage of the MTV Video Music Awards, MTV Movie Awards, and summer music festivals, too. And with the VH1 app, get the latest in pop culture news and info, fashion updates from VH1 Celebrity, and musician interviews from VH1 Tuner. Get the apps free for Windows: MTV Shows and VH1. Also available free for Windows Phone: MTV Shows and VH1.

5. UVideos

Get the best in Hispanic TV content from Univision with the UVideos app for Windows. Login with your TV provider credentials and stream full-length popular telenovelas and dramas, plus clips from shows like El Gordo y La Flaca and República Deportiva. Catch up on your celebrity gossip, sports, music, Univision special events, and breaking news from Noticiero Univision and Primer Impacto, too. Get UVideos for free from the Windows Store.

6. Roku

Roku set-top boxes are a popular way to stream content to your TV from popular providers like Netflix, Hulu Plus, HBO Go and others. Now, the new Roku app for Windows and Windows Phone lets you control your Roku box right from your Windows PC, Tablet or Phone. You can view installed Roku channels and launch them with the app, too. Get the Roku app for free from the Windows Store. Also available in the Windows Phone Store.

7. Simple.TV

Simple.TV is a cloud-connected DVR (available separately) you hook up to your HDTV antenna and home network: It lets you watch live TV remotely or record and playback shows on-demand. With the new Simple.TV app, you can watch live TV right on your Windows PC, Tablet or Phone! Or record and playback your favorites shows on your device anytime you like. Get the Simple.TV app for free from the Windows Store. Also available in the Windows Phone Store.

You’ll find all these great TV apps and more gathered in our TV app Collections – look under “Collections” in the Windows Store, and in the TV on Your Windows Phone Collection.

New games from Gameloft heat up the Windows and Windows Phone Stores 2 Jul 2014, 10:05 am

Summer is on, and so is great gaming on your Windows PC, Tablet and Phone. Award-winning game developer Gameloft is helping to heat things up with multiple top quality new releases now available for your gaming pleasure:

1. Blitz Brigade

Are you ready for the gun show? Axis or Allies, victory or defeat – all will be decided in this multi-player, first-person-shooter! Become one of five highly-skilled classes; team up with other players to pound your enemies into the dirt and call them mean names. Lock 'n' load! Get Blitz Brigade Free from the Windows and Windows Phone Stores.

2. Rival Knights

Will you be the last night standing? Amor up – it’s time to joust to victory, challenging thousands of players online in games of glory. It’s an action-packed combat game set in medieval times. Your rivals await! Get Rival Knights Free from the Windows and Windows Phone Stores.

3. Order & Chaos Duels

Rediscover the Order & Chaos universe in this fantasy-based collectible trading card game. Duel evil forces on quests and adventures, or go head-to-head with other players for leaderboard supremacy. There’s almost 300 gorgeous cards to collect – can you acquire them all, stacking the deck in your favor? Get Order & Chaos Duels for Free from the Windows Phone Store.

4. GT Racing 2: The Real Car Experience

Get behind the wheel and race over 60 cars on 13 super-realistic tracks in GT Racing 2: The Real Car Experience. Drive everything from Nissans to Ferraris, and test your driving skills in more than 1,000 different events—Classic Races, Duels, Knockouts and Overtakes. Or race in multi-player mode with players from around the world. Get GT Racing 2: The Real Car Experience Free from the Windows and Windows Phone Stores.

5. My Little Pony: Friendship Is Magic

After being locked away in the moon for centuries, Nightmare Moon is set free and spreading night across Ponyville. Only Twilight Sparkle and her friends can bring light and friendship back to the land. You can help her and Rainbow Dash, Fluttershy, Applejack, Rarity, and Pinkie Pie rebuild the town and reach their dreams in fun, magical quests. Get My Little Pony: Friendship Is Magic for Free from the Windows and Windows Phone Stores.

6. Heroes of Order & Chaos

Enter the battle arena in this exceptionally rich and addictive Multiplayer Online Battle Arena (MOBA) game. Play as one of more than 40 heroes in your own solo campaign, or even better, recruit your friends for fast-paced multi-player action. Who’s got the skills and strategies to rule the mysterious world of Haradon? Get Heroes of Order & Chaos for Free from the Windows and Windows Phone Stores.

Find all these great new games and more in our Gameloft Collection.