Tag Archives: BUILD 2017

Windows Store: video trailers, improved Store listings, advanced sales, and other new capabilities

At Build 2017, the Windows Store announced the initial availability of several features. Today, I want to share with you that all accounts have access to these features:

  • More ways to promote your apps and drive user acquisition
  • More ways to manage schedules, prices and sales
  • Debug your apps more effectively by using CAB files
  • Use Dev Center through a modern and efficient dashboard experience

Important: If you have a submission in progress, publish it (or delete it) and your next submission will show these new pricing, sales and store listing options. Also, if you use the Windows Store submission API, be sure to read the info at the bottom of this post.

More ways to promote your apps and drive user acquisition

Many of you told us that video trailers are one of the best ways to attract customers. You can now upload up to 15 trailers to use in your Store listing. When using trailers, make sure to also include the 1920 x 1080 pixel image (16:9) in the promotional images section, which shows up after the video stops playing. Feedback from other developers using videos has been very positive, try them out!

Video trailer as shown in the Store – see it in action here on a Windows 10 PC

Creating and updating Store listings used to take many steps per language and could take hours for a submission with listings in many languages. You can now update all Store listing content (description, images, keywords, etc.), by importing and exporting your listings, reducing the update time to just a few minutes.

Export and import of store listings – Submission overview page

More ways to manage prices and sales

 When a customer makes their first purchase, we’ve found that they typically continue to purchase more add-ons in that initial app or game, as well as in other products in the Store. The new pricing and availability page gives you additional options to drive users to that first purchase:

Schedule when your app or game will be visible (as long as the submission happens with enough time to process—we recommend at least three days in advance). You have the option to specify the schedule when your app should become available and discoverable in the Store, as well as a date when it should no longer be available for new acquisitions.

 Schedule availability – pricing and availability page

Schedule price changes in advance. For example, change the base price a month after the app has been published.

Schedule price changes – pricing and availability page

There are many more options to configure sales, including using percentage values (such as “30% off”), viewing sales options in the currency that makes sense to you, configuring sales globally or for specific markets, offering discounts to customers that own one of your other apps (for example “50% off if you own this other game”) and the ability to target a discount to a segment of customers (such as those that have not made any Store purchases so far).

Sales drive purchases, so try them out!

Configure sales – Pricing and availability page

How sales show up in the Store

We also heard that you wanted a more efficient way to understand all prices, for all markets. You can now view all possible price tiers in Excel. Go to the Pricing and availability page, select view table, and you can view and export the table to CSV.

Viewing all price tiers – Pricing and availability page

Use Dev Center through a modern and efficient dashboard experience

The Dev Center dashboard has been redesigned based on your feedback to help you be more productive. It has a clean new interface, beautiful analytics, new account-level pages, integrated app picker and streamlined program switching. These are a few of the things that make the new dashboard more useful, particularly for accounts with multiple apps, games or programs.

Dev Center redesign

Debug your apps more effectively by using CAB files

 We heard a lot of feedback on having access to CAB files to help debugging apps, and improve the quality and performance of your apps and games. The Health report lets you pinpoint which OS and app version configurations generate the most crashes, and provides links to failure details with individual CAB files. These CAB files are only available for customers running any of the Windows Insider flights of Windows 10 (slow or fast), so not all failures will include the CAB download option. 

Access to failure downloads – health analytics page

Implications of these changes if you are using the Windows Store submission API

If you use the Windows Store submission API to manage your apps and games, please be aware of the following:

  • If you manage prices using the Submission API, you’ll have to use new price tiers. To do that, manually update your app or game once, so you can view the new price tiers, accept them, and then update your Submission API code to use these new price tier values, which can be found in the price table on the pricing and availability page in Dev Center, as described above.
  • The Windows Store submission API does not support all the new Store listing capabilities You can add the new assets using the Dev Center dashboard, and the submission API will be updated later in July to let you manage these new assets through the API. More details about the upcoming API capabilities, including trailers and game options, can be found.
  • If you use the StoreBroker PowerShell module to simplify using the Windows Store submission API, you can keep using it to manage the same listing asset types you are managing today. However, you won’t be able to upload the new asset types using StoreBroker until the StoreBroker team publishes an update in a few more weeks, and you pick up that update.

Read this previous blog post to learn about all the recently added Store features, and try all the features that are live today. If you have any issues finding or using these features, please let us know using the feedback link in Dev Center (upper right of the dashboard).

UWP App Diagnostics

At Build this year, we gave a sneak preview of a set of new APIs designed to provide diagnostic information about running apps. You can see the videos here and here – but note that these were based on a pre-release implementation. So, while the Build videos are still correct on broad functionality, the final API names are almost all slightly different. Plus, we added a couple of extra features after Build.

The final versions for the upcoming release are available in the Insider builds from Build 16226, along with the corresponding SDK.

At a high level, these APIs allow an app to:

  • Enumerate a list of running apps, including UWP apps, Win32 apps, system services and so on.
  • For each app, get process-specific metrics on:
    • Memory usage (private commit and working set).
    • CPU usage.
    • Disk reads and writes.
  • For each UWP app, get additional metrics on:
    • Memory usage (including shared commit) equivalent to the Windows.System.MemoryManager report previously available to an app for its own usage.
    • State info: running, suspending, suspended, not running.
    • Energy quota info: under or over.
    • Enumerate a list of any background tasks that are active for the app, including name, trigger type and entry point.
    • Enumerate all the processes for the app (using an enhancement to the existing Windows.System.Diagnostics.ProcessDiagnosticInfo class that was previously restricted to an app for its own usage).

The API has a simple hierarchical structure:

  • The AppDiagnosticInfo type represents a single app. Callers would normally request either a single AppDiagnosticInfo for the app you’re interested in or a list of AppDiagnosticInfos if you’re interested in multiple apps.

  • Once you’ve gotten hold of an AppDiagnosticInfo for an app you’re interested in, you’d call GetResourceGroups to get a list of AppResourceGroupInfo objects. Each AppResourceGroupInfo corresponds to a resource group. An app can define resource groups in its manifest as a way to organize its components (foreground app, background tasks) into groups for resource management purposes. If you don’t define any explicit resource groups, the system will provide at least one (for the foreground app) plus potentially more (if you have out-of-proc background tasks, for example).

  • From there, you’d call any of the AppResourceGroupInfo methods to get snapshot reports of memory usage, execution and energy quota state, and the app’s running background tasks (if any) via the AppResourceGroupMemoryReport, AppResourceGroupStateReport and AppResourceGroupBackgroundTaskReport classes.

  • And finally, each group exposes a list of ProcessDiagnosticInfo objects.

As you can see from the class diagrams, the AppDiagnosticInfo and ProcessDiagnosticInfo each have a link to the other. This means you can get all the rich process-specific info for any running process and get the UWP-specific info for any process related to a UWP app (including Desktop Bridge apps).

These APIs are intended to support app developers who either need more diagnostic support during their own app development and testing, or who want to build a general-purpose diagnostic app and publish it in the Windows Store. Exposing information about other apps raises potential privacy concerns, so if your app uses these APIs, you’ll need to declare the appDiagnostics capability in your manifest, along with the corresponding namespace declaration:


<Package
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/ windows10/restrictedcapabilities"
  IgnorableNamespaces="uap mp rescap">
  ...

  <Capabilities>
    <rescap:Capability Name="appDiagnostics" />
  </Capabilities>
</Package>

This is a restricted capability: If you submit an app with this capability to the Windows Store, this will trigger closer scrutiny. The app must be in the Developer Tools category, and we will examine your app to make sure that it is indeed a developer tool before approving the submission.

At run time, the capability also triggers a user-consent prompt the first time any of the diagnostic APIs are called:

The user is always in control: If permission is denied, then the APIs will only return information about the current app. The prompt is only shown on first use, but the user can change his or her mind any time via the privacy pages in Settings. All apps that use the APIs will be listed here, and the user can toggle permission either globally or on a per-app basis:

Given the richness of the APIs, it’s not too much of a stretch to envisage creating a UWP version of Task Manager. There are a few features that we can’t implement just yet (terminating apps and controlling system services, for example), but certainly most of the data reporting is perfectly possible with the new APIs:

The first thing to do is to request permission to access diagnostics for other apps using AppDiagnosticInfo.RequestAccessAsync. The result could be Denied, Limited (which means you can only get information for the current app package) or Allowed.


DiagnosticAccessStatus diagnosticAccessStatus = 
    await AppDiagnosticInfo.RequestAccessAsync();
switch (diagnosticAccessStatus)
{
    case DiagnosticAccessStatus.Allowed:
        Debug.WriteLine("We can get diagnostics for all apps.");
        break;
    case DiagnosticAccessStatus.Limited:
        Debug.WriteLine("We can only get diagnostics for this app package.");
        break;
}

Then, to emulate Task Manager, you’d start with a list of the ProcessDiagnosticInfo objects for all running processes.


IReadOnlyList<ProcessDiagnosticInfo> processes = ProcessDiagnosticInfo.GetForProcesses();

For each running process, you can extract the top-level process-specific information such as the ExecutableFileName and the ProcessId. You can also get the more detailed process information from each of the three reports for CpuUsage, MemoryUsage and DiskUsage.


if (processes != null)
{
    foreach (ProcessDiagnosticInfo process in processes)
    {
        string exeName = process.ExecutableFileName;
        string pid = process.ProcessId.ToString();

        ProcessCpuUsageReport cpuReport = process.CpuUsage.GetReport();
        TimeSpan userCpu = cpuReport.UserTime;
        TimeSpan kernelCpu = cpuReport.KernelTime;

        ProcessMemoryUsageReport memReport = process.MemoryUsage.GetReport();
        ulong npp = memReport.NonPagedPoolSizeInBytes;
        ulong pp = memReport.PagedPoolSizeInBytes;
        ulong peakNpp = memReport.PeakNonPagedPoolSizeInBytes;
        //...etc

        ProcessDiskUsageReport diskReport = process.DiskUsage.GetReport();
        long bytesRead = diskReport.BytesReadCount;
        long bytesWritten = diskReport.BytesWrittenCount;
        //...etc
    }
}

For any process associated with a UWP app, the IsPackaged property is true. So, for each of these, you can get from the ProcessDiagnosticInfo to the AppDiagnosticInfo. It might seem strange that we can get AppDiagnosticInfos (plural) from a process – but this is to allow for the possibility that a single process is associated with more than one app. That’s an extremely uncommon scenario, but it is possible in the case of VoIP apps where two or more apps in the same package can share a component running in a separate process at run time. In almost all cases, though, there will only be one AppDiagnosticInfo per process.


if (process.IsPackaged)
{
    IList<AppDiagnosticInfo> diagnosticInfos = process.GetAppDiagnosticInfos();
    if (diagnosticInfos != null && diagnosticInfos.Count > 0)
    {
        AppDiagnosticInfo diagnosticInfo = diagnosticInfos.FirstOrDefault();
        if (diagnosticInfo != null)
        {
            IList<AppResourceGroupInfo> groups = diagnosticInfo.GetResourceGroups();
            if (groups != null && groups.Count > 0)
            {

From the AppDiagnosticInfo, you can walk down the hierarchy and get a collection of AppResourceGroupInfos. Then, for each AppResourceGroupInfo, you can get the UWP-specific state and memory information:


AppResourceGroupInfo group = groups.FirstOrDefault();
if (group != null)
{
    string name = diagnosticInfo.AppInfo.DisplayInfo.DisplayName;
    string description = diagnosticInfo.AppInfo.DisplayInfo.Description;
    BitmapImage bitmapImage = await GetLogoAsync(diagnosticInfo);

    AppResourceGroupStateReport stateReport= group.GetStateReport();
    if (stateReport != null)
    {
        string executionStatus = stateReport.ExecutionState.ToString();
        string energyStatus = stateReport.EnergyQuotaState.ToString();
    }

    AppResourceGroupMemoryReport memoryReport = group.GetMemoryReport();
    if (memoryReport != null)
    {
        AppMemoryUsageLevel level = memoryReport.CommitUsageLevel;
        ulong limit = memoryReport.CommitUsageLimit;
        ulong totalCommit = memoryReport.TotalCommitUsage;
        ulong privateCommit = memoryReport.PrivateCommitUsage;
        ulong sharedCommit = totalCommit - privateCommit;
    }
}

Note: to get the packaged logo from the app, there’s a little extra work. You call GetLogo from the AppDisplayInfo to return the data as a stream; if there are multiple logos available, this will return the largest one that is within the specified size.


private async Task<BitmapImage> GetLogoAsync(AppDiagnosticInfo app)
{
    RandomAccessStreamReference stream = 
        app.AppInfo.DisplayInfo.GetLogo(new Size(64, 64));
    IRandomAccessStreamWithContentType content = await stream.OpenReadAsync();
    BitmapImage bitmapImage = new BitmapImage();
    await bitmapImage.SetSourceAsync(content);
    return bitmapImage;
}

Once you’ve collected all the various detailed metrics you’re interested in, it’s a simple matter to populate your viewmodel for data-binding purposes, to perform data analytics or to do whatever other processing you might want.

In a later post, we’ll look at how you can integrate the diagnostic APIs with existing developer tools such as Visual Studio and Appium.

See What’s New with Windows Ink in the Windows 10 Creators Update

Windows Ink is about transforming the way we think about computers, from a tool that is great at getting things done, to one that harnesses your personality and your emotions into the things you create. It’s about bringing back the human aspects that a mouse and keyboard (and even touch) cannot express fully, it’s about making personal computers more personal, and an extension of yourself, not just a tool. We want you to feel empowered to create from the moment you pick up the pen, and have the confidence that Windows understands you, knows what you want to do – by understanding your handwriting, your words and your expression. This is the journey we’re on.

With the Creators Update, Windows Ink is now better than ever! When used with the Surface Dial, it allows you to discover new ways to work and interact with Windows. With Windows Ink, we continue to make it possible for you to do more than with pen and paper. Applications like Photos and Maps have added incredible inking functionality in the last year, and continue to evolve and expand. With Paint 3D in the Creators Update, Windows Ink can now create 3D objects! As we evolve what Ink means to users, we’re also introducing new Smart Ink capabilities to Windows Ink. These capabilities allows developers to understand the ink that is being laid down by the user, using AI to help create, connect and complete user actions on ink. We’ve also improved and added features to the building blocks for Windows Ink, introducing new stencils and adding tilt support to create a richer drawing experience.

Devices that support the Pen on Windows have also doubled in the last year, and is on track to double again in the next year! We’re seeing high demand not just for devices, but also for applications that support ink. To make it easier to find compatible pens, Wacom has partnered with us to develop the Bamboo Ink Pen. This pen will be in market in summer and supports almost all Windows PCs that are pen-capable. It features the Microsoft Pen Protocol (MPP), which is based on Surface Pen technology. In addition, we are also excited that the Surface Dial is now available in more countries, like Australia, Canada and New Zealand, giving more people an opportunity to try this incredible new input device. In addition, new hardware from our OEM partners, like the Dell Canvas 27, are shipping soon and takes advantage of the same RadialController APIs that are used for the dial. As a developer building for the Surface Dial today, it means that you are ready for all the new hardware that our OEM partners will bring to the ecosystem.

The progress we’ve made with Windows Ink would not have been possible without the feedback and passion you developers bring to us. With over a thousand inking applications in the store and growing everyday, with well over half of the top 10 paid store apps being ink apps, there is incredible enthusiasm and interest in this space. This is an incredible opportunity that you have embraced with us, and it inspires us to do more in each Windows release.

What’s new with Windows Ink platform?

Ink is the ultimate way humans can express themselves, it opens up new opportunities for application developers to differentiate, and helps make their applications stand out. From the latest fads like adult coloring books to simple games like tic-tac-toe, to applications that help you organize your life, there is just so much opportunity to build the next big thing in the inking space. We also know that people who use Windows Ink are more satisfied with their experience, what they look for, and buy more inking applications. From the platform perspective, we have 2 ways that we help developers:

  • Make it as easy and quick for a developer to add inking into their application by providing controls that can be dropped in quickly into any application and get Windows Ink support.
  • Provide the most flexible platform building blocks for developers to innovate upon. This gives you the flexibility to choose where to start developing for Windows Ink.

Introducing Smart Ink

Let’s start with a new building block that developers have access to in the Creators Update. Introducing Ink Analysis, this is the first of our family of Smart Ink capabilities that we are bringing to the platform. Smart Ink brings AI technology to not just understand what you write, but also helps connect the dots to what you may want to do. With Ink Analysis, it starts simple, with recognizing shapes and making that square you drew more perfect, but it can also do much more, like understanding you wrote words in squares and making it into an org chart using understanding about your organization. Our goal is to understand user intent and empower developers to turn it into rich digital constructs, as well as to leverage understanding from all parts of the system. Ink Analysis allows any developer to understand the ink they capture, whether it is handwriting, shapes, phone numbers, stock symbols, lists, document structure and more.  This is the same technology we debuted in Sticky Notes in the Window 10 Anniversary Update, and now it’s available for you to use! We can’t wait to see what you can do with this technology.

Here is an example of how to use Ink Analysis to recognize shapes.  For this snippet, we’ll use DirectInk to handle rendering the ink strokes.  Start by initializing an InkAnalyzer and connecting it with InkPresenter:


private void Initialize()
{
    inkAnalyzer = new InkAnalyzer();
    inkCanvas.InkPresenter.StrokesCollected += InkPresenter_StrokesCollected;
    inkCanvas.InkPresenter.StrokesErased += InkPresenter_StrokesErased;
}

// Whenever the user draws a new stroke, you copy the stroke into Ink Analyzer’s stroke collection
private void InkPresenter_StrokesCollected(InkPresenter sender, InkStrokesCollectedEventArgs args)
{
    inkAnalyzer.AddDataForStrokes(args.Strokes);
}

// When a stroke is erased in InkCanvas, remove the same stroke from Ink Analyzer's collection.
private void InkPresenter_StrokesErased(InkPresenter sender, InkStrokesErasedEventArgs args)
{
    foreach (var stroke in args.Strokes)
    {
        inkAnalyzer.RemoveDataForStroke(stroke.Id);
    }
}

Next you want to feed strokes to the analyzer. Commonly this is done via explicit user action (e.g. the user clicks a button) or after the user has been idle for a while.


inkAnalyzer.AnalyzeAsync();

The result is a tree representation of the whole document with different kinds of nodes, such as paragraph, line, list, word, and drawing. If for instance you want to find all the shapes in the ink, you can with the code below:


IReadOnlyList<IInkAnalysisNode> drawings = inkAnalyzer.AnalysisRoot.FindNodes(InkAnalysisNodeKind.InkDrawing);
foreach (IInkAnalysisNode drawing in drawings)
{
    var shape = (InkAnalysisInkDrawing)drawing;
    switch (shape.DrawingKind)
    {
        case InkAnalysisDrawingKind.Circle:
            // The user drew a circle. You can replace it with a perfect circle that goes through shape.Points.
            break;
        case InkAnalysisDrawingKind.Rectangle:
            // The user drew a rectangle. 
            // You can find the full list of supported shapes here.
            break;
    }
} 

If you want to learn more about Ink Analysis, you can watch the BUILD 2017 recorded video Enable Natural Pen Interaction by Using Ink Analysis to Better Understand Users’ Ink, download the Ink Analysis sample on GitHub or check out the Ink Analysis API Reference.

An improved Ink Toolbar

In the Anniversary Update we created a customizable set of inking tools, Ink Toolbar and Ink Canvas, that any developer can add to their own application with only two lines of markup.


<InkCanvas x:Name=“myInkCanvas”/>
<InkToolbar TargetInkCanvas=“{x:Bind myInkCanvas}”/>

Many of Microsoft’s first party applications have incorporated the inking tools to create engaging user experiences. For example, Photos added a calligraphy pen and the ability to draw on any photo in the gallery. Maps added a feature that lets you measure the distance of a route drawn on the map. Edge browser added inking on webpages. It has never been easier to add Windows Ink to your applications.

In the Creators Update, we continue our commitment to improving these controls! If you already use them in your applications, these improvements will benefit you with no additional work!

In response to users, the Creators Update introduces a new stencil, the protractor. This new stencil makes it easy for you to draw circles and arcs of any size. When drawing an arc, the protractor displays a readout that tells you the precise angle of the arc. You can also resize the stencil with just a pinch/zoom gesture with your fingers.

We’ve also made the ruler stencil better! Like the protractor, it now provides an angle readout that shows the ruler’s angle with the horizontal line. The ruler also snaps to 0, 45 and 90 degrees for easy access to the most common angles being used by our users.

You asked for an improve stroke preview in the Ink Toolbar, and in the Creators Update, we have it! We’re also make changes in the Ink Toolbar to work better with High Contrast themes, by automatically showing only colors that meet visibility requirements for the current user profile.

New Exciting Inking Capabilities


Today we announced the new Surface Pro and the new Surface Pen. Together they enable the next generation of inking capabilities that truly make writing digitally as natural as pen on paper. Here are some of the highlights:

  • Low latency Ink that virtually eliminates lag when you write
  • Tilt support to capture an additional dimension in digital inking
  • Ink that captures the entire spectrum of your expression with 4,096 levels of pressure sensitivity
  • Effortless inking with half the activation force required to being inking

Our customers have asked us for these capabilities, and they are finally here! From a developer perspective, if you already use the Windows Ink platform, all these capabilities show up in your application automatically! There are no changes required, and you are ready for the new Surface Pro, with the new Surface Pen.

Low latency Inking is a unique addition to Windows Ink. It is the result of a close partnership between hardware and software. The Pixelsense Accelerator chip in the new Surface Pro, is the first device to run Windows Ink acceleration code natively on hardware. This is how we achieve a new milestone in inking, virtually eliminating lag between the pen tip and the ink that flows out of it, creating the most natural writing experience with Windows Ink.

Tilt is another great addition to the Inking experience. The great news is, in addition to the new Surface Pro/Pen supporting this new capability, Wacom Pens that feature tilt will also “just work”! Tilt allows Windows Ink to model natural pencil sketching that response to the tilt of the pen. This support is now built into the pencil brush on the Ink Toolbar. In the above diagrams, we demonstrate how the pencil brush can be used to shade lines (on the left) and to draw arcs of varying thickness depending on the degree of tilt (on the right).

As mentioned above, tilt integration happens automatically if you use the Ink Toolbar. However, if you are not using the Windows Ink platform to render ink, and want to build your own brush that responds to tilt, you still can! There are two properties, TiltX and TiltY (respective angle of tilt against each axis of the screen plane) which are included with pointer input messages. You can access the tilt values from the PointerPointProperties included with Pointer input events, or the POINTER_PEN_INFO struct from WM_POINTER input.

These improvements automatically show up on any application that uses the Windows Ink controls, and you can be confident that we’ll continue to evolve and improve them in each release of Windows.

What’s new with Surface Dial and RadialController?

The Surface Dial introduces a new input paradigm to computing. It was designed alongside the Windows Ink experience, allowing it to truly shine when used together with a Pen. We’ve seen many experiences built to harness the new capabilities the Surface Dial brings, and are also seeing new hardware emerging, and adopting the RadialController standard. In response to your feedback, we’ve added more capabilities to the RadialController experience in the Creators Update.

First off, are some new button events for RadialControllers. These new events, Pressed and Released, combined with existing events for rotation and screen contact, will allow you to track complex interactions such as press-and-rotate or press-and-move. The example below illustrates a simple way to capture a press-and-rotate action.


_radialController.ButtonPressed += OnButtonPressed;
_radialController.ButtonReleased += OnButtonReleased;

private void OnRotationChanged(RadialController sender,
                               RadialControllerRotationChangedEventArgs args)
{
    if (args.IsButtonPressed)
    {
        /* When button is pressed, you can do modal interactions, fine-grained changes */
    }
    else
    {
        /* Otherwise, do the normal rotation behavior */
    }
}
private void SendHaptics(SimpleHapticsController hapticController)
{
    var feedbacks = hapticController.SupportedFeedback;
    foreach (SimpleHapticsControllerFeedback feedback in feedbacks)
    {
        if (feedback.Waveform ==
                    KnownSimpleHapticsControllerWaveforms.Click)
        {
            hapticController.SendHapticFeedback(feedback);
            return;
        }
    }
}

You also now have access to the Haptics engine in the Surface Dial hardware. Using SimpleHapticsController—a new object that uses the HID Simple Haptics specification—you have the power to directly send feedback to the user. You can use this to customize the feel of your menu, adding a new dimension to the experience. This object is available in the arguments of all radial controller input events.

In cases where you may want to suppress the radial menu to prevent it from blocking UI, we now have new properties ActiveControllerWhenMenuIsSuppressed and IsMenuSuppressed to let you configure when the menu is available or suppressed. When a menu is suppressed, it will not appear on press-and-hold interactions for the foreground app. Your app can listen to a new event during menu suppression to give the user an indication the menu is blocked, or build an alternate experience. Here is a code sample for this functionality:


RadialControllerConfiguration config = RadialControllerConfiguration.GetForCurrentView();
config.ActiveControllerWhenMenuIsSuppressed = myController;
config.IsMenuSuppressed = true;
  
myController.ButtonHolding += MyController_ButtonHolding;

User input running on a UI thread can sometimes lead to performance bottlenecks. With the Creator’s Update, radial controller interactions can now be handled on an off-UI thread using RadialControllerIndependentInputSource. Below is an example on how to get additional performance using this method.


RadialController controller;
Windows.UI.Input.Core.RadialControllerIndependentInputSource independentInput;
CoreApplicationView view;
            
view = CoreApplication.GetCurrentView();

var workItemHandler = new WorkItemHandler((IAsyncAction) =>
{
    independentInput = Windows.UI.Input.Core.RadialControllerIndependentInputSource.CreateForView(view);

    controller = independentInput.Controller;

    controller.RotationResolutionInDegrees = 5;

    controller.RotationChanged += Controller_RotationChanged;
    controller.ScreenContactStarted += Controller_ScreenContactStarted;
    controller.ScreenContactContinued += Controller_ScreenContactContinued;
    controller.ScreenContactEnded += Controller_ScreenContactEnded;
    controller.ControlLost += Controller_ControlLost;
    controller.ButtonClicked += Controller_ButtonClicked;
    controller.ButtonPressed += Controller_ButtonPressed;
    controller.ButtonReleased += Controller_ButtonReleased;
    controller.ButtonHolding += Controller_ButtonHolding;
    controller.ControlAcquired += Controller_ControlAcquired;

    // Begin processing input messages as they're delivered.      
    independentInput.Dispatcher.ProcessEvents(CoreProcessEventsOption.ProcessUntilQuit);
});
action = ThreadPool.RunAsync(workItemHandler, WorkItemPriority.High, WorkItemOptions.TimeSliced);

In addition to all the API additions above, you can now customize and easily add new menu items on the Radial Menu. Under “Wheel Settings” in the settings app, you can add application specific menu items that trigger keyboard combinations. Imagine customizing the controller to send your favorite shortcuts in Visual Studio, Photoshop or even when browsing the web!

The Surface Dial continues to excite users and developers alike, with these new enhancements, both developers and users have more control and flexibility in their experience. We invite you to join the numerous applications that have already delivered a great Surface Dial experience, like CorelDRAW, Autodesk’s SketchBook, Silicon Bender’s Sketchable and Algoriddim’s djay Pro. We can’t wait to see what you can do with this unique new form of input on Windows.

Join us in making Windows Ink better!

With Windows Ink and the Surface Dial additions in the Creators Update, we believe we’re just scratching the surface of what Windows Ink can do in people’s lives. Our commitment is to invest in areas that can help you innovate and remove all the barriers to our users using, loving and needing Windows Ink. This involves a spectrum of efforts, from the hardware we build by ourselves and with our partners, to the next SDK additions we make to power you app. As we continue this journey, we invite you to lend us your voice, your ideas and your feedback. Help us help you make the next great application and help us help you change the world. Tweet your ideas using #WindowsInk, email us at WindowsInk@Microsoft.com or tweet us at @WindowsInk. We would love to hear from all of you.

Thank you!

Introducing XAML Standard and .NET Standard 2.0

XAML Standard

We are pleased to announce XAML Standard, which is a standards-based effort to unify XAML dialects across XAML based technologies such as UWP and Xamarin.Forms.

XAML Standard is a specification that defines a standard XAML vocabulary. With that vocabulary, frameworks that support XAML Standard can share common XAML-based UI definitions. The goal is for the first version, XAML Standard 1.0, to be available later this year.

Post-specification plans include support of XAML standard in Xamarin.Forms and UWP. You can continue developing your UWP and Xamarin.Forms apps as you do today. When XAML Standard support is enabled, you will be able to reuse and share between the frameworks and expand into more platforms.

To visualize what this support would look like, here’s a side-by-side comparison between today’s XAML in Xamarin.Forms and in UWP:

In the above example – once XAML Standard is supported by Xamarin.Forms, you can use <TextBlock /> and have it supported in a Xamarin.Forms app targeting iOS and Android instead of needing to know and use <Label /> as shown above. In addition to a TextBlock, here are some of the currently proposed items for standardization.

We are at the beginning of a journey that makes it easy for you to reuse your XAML source files between some simple Xamarin.Forms and UWP views. For example – a Settings.xaml page, where you typically have some text, toggle switches and some buttons. You’d only need to design and create one XAML file to describe this UI and that can be used everywhere.

Nothing changes for existing developers – you can continue to use the same APIs you have always used in both frameworks. XAML Standard will help you reuse/share any common UI code that you wish to share between end points.

The XAML Standard v1 draft spec is being defined in the open, we encourage you to start a discussion or give us direct feedback in the GitHub repo here.

.NET Standard 2.0

We are also happy to announce .NET Standard 2.0! .NET Standard is the set of APIs which work in all .NET implementations. A good way to think about it is how HTML5 is today. There are many different browsers which implement HTML parsing and rendering, but the HTML standard is the common glue that holds the web together and allows for interoperability.

.NET Standard was introduced in June of 2016 to bring consistency to the .NET ecosystem. With the .NET Framework, Xamarin & Mono, .NET Core and then UWP, there were many different implementations of .NET and it was very difficult to write code or a library that could work across all of them. Using .NET Standard, and the tooling in Visual Studio, makes it possible to build libraries and NuGet packages that work literally everywhere .NET runs.

The feedback we received on after .NET Standard’s introduction last year was generally phrased as “We like the direction you’re going in, but the set of APIs isn’t large enough to be useful.” The goal with .NET Standard 2.0 is to respond to that feedback and add a large set of .NET’s “greatest hits” into .NET Standard. To do this, we looked at the intersection of APIs between the .NET Framework and Mono. This lead to the 2.0 definition including over 20,000 new APIs and those APIs enable the top 70% of existing NuGet packages to work.

With the addition of .NET Standard 2.0 support for UWP with the Fall Creators Update, .NET developers will be able to share code across all Windows 10 devices, in the cloud and through the rest of the .NET ecosystem. This will also make it easier to reuse existing WinForms and WPF code as many of the most frequently used APIs like DataSet/DataTable, and popularly requested APIs like SqlClient, are now part of .NET Standard 2.0.

You can learn more about .NET Standard here.

Forming the shape of the future

We invite you, the .NET community, to join the discussion and help shape the future of XAML Standard and .NET Standard. You can provide your feedback, both suggestions and issues, at the following locations; .NET Standard on Github and XAML Standard on Github.

Resources:

This Week on Windows: Build 2017 and more

We hope you enjoyed this week’s special episode of This Week on Windows! You can catch up on all our news from Build 2017 in the blog post below.

Build 2017: Sparking the next wave of creativity with the Windows 10 Fall Creators Update

In case you missed our Windows 10 tip from this week you can find it right here:

<!–
!function(a,b){“use strict”;function c(){if(!e){e=!0;var a,c,d,f,g=-1!==navigator.appVersion.indexOf(“MSIE 10”),h=!!navigator.userAgent.match(/Trident.*rv:11./),i=b.querySelectorAll(“iframe.wp-embedded-content”);for(c=0;c<i.length;c++){if(d=i[c],!d.getAttribute(“data-secret”))f=Math.random().toString(36).substr(2,10),d.src+=”#?secret=”+f,d.setAttribute(“data-secret”,f);if(g||h)a=d.cloneNode(!0),a.removeAttribute(“security”),d.parentNode.replaceChild(a,d)}}}var d=!1,e=!1;if(b.querySelector)if(a.addEventListener)d=!0;if(a.wp=a.wp||{},!a.wp.receiveEmbedMessage)if(a.wp.receiveEmbedMessage=function(c){var d=c.data;if(d.secret||d.message||d.value)if(!/[^a-zA-Z0-9]/.test(d.secret)){var e,f,g,h,i,j=b.querySelectorAll(‘iframe[data-secret=”‘+d.secret+'”]’),k=b.querySelectorAll(‘blockquote[data-secret=”‘+d.secret+'”]’);for(e=0;e<k.length;e++)k[e].style.display=”none”;for(e=0;e1e3)g=1e3;else if(~~g<!]]>

Here’s what’s new in the Windows Store:

Logan (Buy for $14.99)

Logan movie poster

In the near future, Logan attempts to hide from the world as he cares for an ailing Professor X. But everything will change when a young mutant shows up, on the run from sinister forces. Logan is available now to purchase for $14.99 in the Movies & TV section of the Windows Store. Watch the gripping superhero movie everyone is talking about one week before it comes to Blu-ray and DVD!

Phantom Dust (Free with IAP options)

Phantom Dust, the classic Xbox game blending third-person arena combat with card collecting, returns in re-release for Xbox One and Windows 10 PC with full Xbox LIVE support and a host of enhancements. Collect 300 unique skills and build your arsenal of powers, taking them into battle online with up to three other players in a variety of match types. Compete in highly destructible arenas and unleash an array of powers and tactics to defeat your enemies, including orbital particle cannons, flaming swords, barriers of ice, flight, cloaking, attack reflection and other abilities. All the while, get Xbox Play Anywhere, cross-device multiplayer, achievements and 16×9 presentation. Phantom Dust features more than 15 hours of solo player content in a story that explores isolation and faith – and it’s ready for you now in the Windows Store.

Netflix – Master of None (Free, subscription required for content)

From the Netflix show, Master of None, two men riding scooters down a road.

This week, Netflix brings the comedic talents of Aziz Ansari back for another season of the hilarious Master of None. Follow the personal and professional exploits of Dev, a 30-year-old actor in New York City who has trouble deciding what he wants to eat – much less, deciding the path he’ll follow in life. As sharp and funny as the actor who leads the cast, it’s must-see viewing this spring.

Minecraft Greek Mythology Mash-Up Pack now available (Buy for $5.99)

Behold and bow before the mighty Greek Mythology Mash-Up pack!

Your favorite historical figures from ancient Greek mythology are now available for Minecraft on Windows 10 for $5.99 USD. By the beard of Zeus! Complete with 39 skins and a bespoke texture set, the pack also has an original orchestral soundtrack composed by Gareth Coker. Build a pantheon fit for the gods, trap the Minotaur in an elaborate maze, or set sail for adventures across the sea – the options are endless! To learn more visit Minecraft’s blog post.

ForzaRC Season 3: The Porsche Cup to Make History at the 24 Hours of Le Mans

It seems like just yesterday that we kicked off the Forza Racing Championship (ForzaRC) Season 3: The Porsche Cup, which is currently in full swing through May 28. Today, we’re excited to share that the Elite finals will take place in France during the most prestigious endurance race in the world, the 24 Hours of Le Mans, from June 17-18 – making it the largest racing esports event ever hosted at Le Mans. To mark this historic occasion bridging real-world motorsport and racing esports, the Automobile Club de l’Ouest (ACO), creator and organizer of the 24 Hours of Le Mans, made an entirely new category for esports competition: the Official Endurance Esports Category. After the esports race, the winner of the ForzaRC finals will accept a trophy on the same 24 Hours of Le Mans podium as the winning Le Mans drivers. Visit Xbox Wire to learn more about this exciting news!

Have a great weekend!

Announcing Microsoft Build Tour 2017

Figure 1 Sign-up at http://buildtour.microsoft.com

On the heels of the Build conferences these last few years, we have had the pleasure of meeting thousands of developers around the world. Their feedback and technical insight has helped us to continue the tradition and explore more technical depth.

Today, I’m excited to announce the Microsoft Build Tour 2017, coming to cities around the globe this June! The Microsoft Build Tour is an excellent way to experience Microsoft Build news first-hand, and also work directly with Microsoft teams from Redmond and your local area.

This year, we’re bringing the Microsoft Build Tour to these locations:

Dates

City

June 5-6 Shanghai, China
June 8-9 Beijing, China
June 12 Munich, Germany *
June 13-14 Seoul, Republic of Korea
June 14-15 Helsinki, Finland
June 19-20 Warsaw, Poland
June 21-22 Hyderabad, India
June 29-30 Sydney, Australia

The Microsoft Build Tour is for all developers using Microsoft platform and tools. We will cover a breadth of topics across Windows, Cloud, AI, and cross-platform development. We will look at the latest news around .NET, web apps, the Universal Windows Platform, Win32 apps, Mixed Reality, Visual Studio, Xamarin, Microsoft Azure, Cognitive services, and much more.

We also want to go deeper into code, so this year we’re bringing the tour as a two-day* event. You can decide to attend just the sessions on the first day, or sign-up for a deep (and fun!) hands-on experience on the second day.

  • Day 1: Full day of fast-paced, demo-driven sessions, focusing primarily on new technology that you can start using immediately in your projects, with a bit of forward-looking awesomeness for inspiration.
  • Day 2: Full day hackathon where you’ll use the latest technologies to build a fun client, cloud and mobile solution that meet the requirements of a business case given at the beginning of the day. Seating is limited for Day 2, so be sure to register soon!

In most locations, on both days, we’ll also have a Mixed Reality experience booth where you’ll be able to sign up for scheduled hands-on time with Microsoft HoloLens and our latest Windows Mixed Reality devices.

To learn more and register, visit http://buildtour.microsoft.com. Can’t make it in person? Select cities will be live-streamed regionally to give you a chance to view the sessions and participate in the Q&A.

We can’t wait to see you on the tour!

*Munich is a single day, session-focused event.

Announcing Windows Template Studio

Today, we are pleased to announce the next evolution in your File New Universal Windows Platform app in Visual Studio – Windows Template Studio. Windows Template Studio addresses a top community ask in our developer survey to make it easier and provide guidance to create new projects that target the Universal Windows Platform. In this post, we’d like to spend a few minutes introducing Windows Template Studio and show you how it works.

Windows Template Studio uses a dev-friendly wizard to get your UWP apps to F5 in no time, bringing together the pages, frameworks and features that you want. Our wizard walks developers through four steps to quickly scaffold a new UWP app:

  1. Project Type: Select between standard layouts and predefined controls.
  2. Framework selection: Select the structure of your UWP app with in-house and third-party support.
  3. App pages: Select which pages that make sense for the app, that you are trying to create.
  4. App features: Easily add features such as background tasks with one click.

Furthermore, we’re open-sourcing Windows Template Studio, welcoming UWP devs to take the generation engine further – adding additional capabilities and app pages, improving the implemented best practices and patterns – and encouraging UWP devs to make the engine their own – tailoring it to their company’s specific needs.

Windows Template Studio is the evolution of Windows App Studio. App Studio was a free, online app creation tool that allowed developers and enthusiasts to quickly build Windows Universal Apps. We are taking our learnings from the code generation engine and the existing wizard to provide a strong foundation for our code generation and developer experience in Windows Template Studio.

A Lap Around Windows Template Studio

We kick off Windows Template Studio by creating a new UWP app project. In the Visual Studio 2017 ‘New Project’ dialog, select the Visual C# Windows Universal node.

Here you’ll see the Windows Template Studio project. Select the project type, enter in your new UWP app’s name and click ‘OK’. Windows Template Studio will now fire up and walk you through the UWP app creation wizard, step by step.

Step 1: Project Type

You begin by selecting a project type. We’ve started you with the most common types such as: blank, navigation pane and pivot and tabs.

Step 2: Framework

Once you have selected a project type, you need to select a framework. You can select from Code behind, MVVM Basic or the very popular MVVM Light.

Step 3: Pages and app lifecycle features

Once you have selected a project and framework, then it is time to add in pages and features. We’ve already added the most common pages such as Master/Detail, Settings and Web view. You can also easily add in Application Lifecycle features such as Suspend and Resume as well as Background Work and User Interaction.

Best practices and patterns

To wrap all of this up, with a couple of simple clicks, you can wire up an app that uses the Navigation Pane, MVVM Light framework, a Master Detail page and a couple of features such as suspend and resume and Azure hub notifications. You save time, your app is adhering to our design guidance and industry standard patterns and practices come free.

Below is an example of an app generated with Windows Template Studio. Again, we provide the foundation of a great UWP app and get you to F5 in a couple of clicks.

Get Started Today

Windows Template Studio v1.0 is available now and you can expect updates every 6 weeks. We have extremely easy to use instructions for installing the VS extension on our GitHub page as well. A public roadmap is currently available and we’d encourage you to check out The Tips and Tricks for UWP Developer session that was shown at Build to learn more. You can get started creating your own app in three simple steps:

  1. Download Visual Studio 2017 and select Universal Windows Platform development under Workloads.
  2. Install the Visual Studio Extension for Windows Template Studio by downloading the VSIX from the Visual Studio Gallery.
  3. Once installed, open Visual Studio 2017 and select FileNew Project→ C# → Windows Universal and you should see the new template that was just added.

And Best of All…Windows Template Studio is Open Source

Windows Template Studio is completely open-source and available now on GitHub. This project is community led and we’re very excited to already have contributions from the following community members: Matt Lacey and James Croft. We would love for you to contribute to the project and would encourage you to read our contribution guidelines for next steps.

In the spirit of being transparent, the roadmap for the next release is always available. If you have a bug that you would like to report or share a feature request, then please add it to our issue tracker.

We would love to hear how your experiences are using it and the helpfulness of the project. You can reach Clint at @clintrutkas and Michael at @mbcrump.  What are you waiting for? Go and try it out for yourself now!

Windows Store: more options to manage, monetize and promote apps

At Build 2017 last week, the Windows Store announced new capabilities to reach more customers, improve your productivity and promote and monetize your apps and games, including:

  • Offering your games to Xbox One users
  • Updating your Store listings faster via import/export
  • Releasing new games or apps using private beta, targeting a limited audience
  • Navigating Dev Center faster through an updated dashboard experience
  • Enabling more users to acquire apps via one-click download with no Microsoft account login
  • Offering more engaging Store listings with video trailers
  • Monetizing via recurring billing using in-app purchase subscriptions
  • Offering discounts only to some user segments, or only to users of your other apps or games
  • Analyzing your app performance more effectively, through funnel analysis and crash analytics
  • Earning more revenue from ads through more advertising formats

To learn more, I recommend viewing the Build session Windows Store: manage and promote apps your way (B8098), and reading this blog post.

More opportunity for your apps and games

Your UWP apps and games can run on any Windows 10 device, so you can reach out to hundreds of millions of users with a single app. The Store helps you grow that opportunity, reach more customers, acquire new users and increase the revenue for those users with several new capabilities. View the Build 2017 session Tips and Tricks for Successful Store Apps (B8102) to learn how to best use these new capabilities.

Increase your revenue through in-app advertising (New). Advertising is one of the primary monetization models for many publishers, and the Store now offers several new ad experiences that bring better yield and higher fill rates for ads in UWP apps: interstitial banner ads, playable ads and native ads (beta), in addition to the existing banner and video ads. To learn more, view Build session A quick lap around Microsoft Monetization Platform (P4112).

Example of a playable ad running in a UWP game

Promote your apps, and drive re-engagement using ad campaigns (New). Dev Center offers the ability to acquire new users in several ways: promotional codes, targeted offers and ad campaigns. Creating an ad campaign requires few clicks, and now supports interstitial banner, native and playable ads (beta). These ad campaigns are shown to users on other apps, as well as on Microsoft properties such as MSN.com, Skype and Outlook. To learn more, view the Build session User acquisition through Ads (session P4154).

Acquire more customers through one-click download, and buy Xbox games on PC (New). The Store has enabled faster and simpler app acquisition by letting customers acquire free apps or games (with age rating 13-year old or lower) with one click, without requiring the user to sign in with their Microsoft account. In addition to this change, customers can now purchase Xbox games directly from the PC Store. These new options help grow the number of users that download your app or game.

Distribute UWP games on Xbox One, engaging with hundreds of millions of Xbox One users and more than 50 million Xbox Live accounts (Coming soon). Dev Center already allows any developer to publish apps not categorized as games to Xbox One. Developers can now join the new Xbox Live Creators Program to submit games to Xbox One, with fast certification, no cost and no friction. You can start developing and testing your Xbox Live enabled games today, and you’ll be able to publish games for Xbox One in summer. View the Xbox Live Creators Program build session (P4159) to learn more.

Offer in-app purchase subscriptions (Coming soon). Apps can be configured to include in-app subscriptions, i.e. selling services in-app that charge periodically (1/3/6/12/24-month renewal periods), with or without a free trial. In-app subscription capability is currently in preview, being tested by a few publishers and will be available to all developers this summer. Follow the Building apps for Windows blog for more announcements.

In addition to these features, remember that you can offer your app or game to businesses or education institutions through the Microsoft Store for Business that offers a redesigned private Store experience for companies. You can also take your existing Win32 app or game and offer it through the Windows Store using the Desktop Bridge.

Dev Center experience redesign

More modern and efficient dashboard experience (Dev Center Insiders). The Dev Center dashboard has been redesigned based on your feedback to help you be more productive. The new dashboard integrates with Office, Cortana and Groove programs. It has a clean new interface, beautiful analytics, new account-level pages, integrated app picker and streamlined program switching.  These are a few of the things that make the new dashboard more useful, particularly for accounts with multiple apps, games or programs. Try it out today by joining the Dev Center Insider Program.

Startup guide for the new dashboard experience

Invite users outside of your organization to collaborate on your apps and games (New). We now support inviting users outside your company to contribute to the projects in your account. This makes collaboration and partnerships across companies and users easier than ever. Your account users are governed by the same roles and permissions that you apply to users in your AAD tenant, ensuring that you remain in full control.


Reaching more customers

To help customers find your app or game, and then increase the probability they will download it, the Store has added new search filters, and ways to make your store listing more engaging, and ways to update your Store listings in bulk, streamlining the update in multiple languages.

Help customers find your apps or games with new search capabilities (Rollout starting). Starting today, we’re rolling out the option to indicate if your app uses Cortana, Ink or Continuum, or if your games offer mixed reality, 4K, HDR, multi-player, co-op, or shared split screen. Indicate in the Properties page of your submission if it supports these capabilities, and this summer customers will be able to filter their searches to show only apps or games that support the capabilities they are looking for.

Search filters that will show up in the Store later in the summer

Create more engaging Store listings with video trailers (Rollout starting). Many of you have told us that video trailers are one of the best ways to attract customers. After piloting the feature earlier this year, today we’re beginning to roll out the ability to upload trailers to use in your Store listing, and all accounts should have access within a few months. We’ve made a few other updates to the types of images you can provide for a great Store listing, including 4K high-resolution assets.

Create and update Store listings faster with Import/Export (Coming soon). Creating and updating Store listings takes many clicks per language and can take hours for a submission with listings in many languages. Dev Center allows you to import and export your listings, so you can make changes offline in bulk and then upload all your listing details at once, rather than having to manually input each string and image for each language. We’ll be rolling this feature out to all accounts over the next few months.

Submission page showing progress using import/export Store listings

Planning your release

Once you have created your app submission and designed an engaging Store listing, you’ll have to plan the release. The Store supports several visibility options, including a release only accessible through promotional codes, a public but not searchable release (hidden), public release or flighting different packages of your published app to specific groups of people. Flighting is widely used, with more than 30,000 package flights created so far. We’re adding additional options to let you release private betas, and to schedule a release very precisely.

Release a submission at a precise date and time (Rollout starting). Dev Center previously let you define when a submission would start to be published, but didn’t let you know exactly when the submission would be live. You can now specific a precise date and time, in UTC or local time, during your submission. We are beginning to roll out the new Schedule options today, and all accounts should have access within a few months.

Offer a private beta (Coming soon). Soon you’ll be able to publish a new app or game that is only visible to people in a specific group that you define; anyone who’s not in your beta group won’t be able to see the Store listing page or download the product. This feature is being used by selected preview apps, and we will be releasing this feature to all developers within the next few months.

Remember that you can also use the Store service APIs to streamline your app management. There are APIs to submit and release apps, games and add-ons, manage package flights, access analytics information, read and respond to reviews and run ad campaigns.

Optimizing pricing and configuring deals and sales

Once your apps and games are published to the Store, you may want to adjust your app or add-on price, grow your customer engagement or offer sales to attract more customers.

Create new types of customer segments (New). Several features in Dev Center support segments, including sales, targeted offers, notifications and analytics. You can now create segments by market breakdown, purchase amount and if a user has rated the app or not. Coming soon, you’ll be able to use a predictive churn model to create segments of users who are predicted to stop using your app (churn), so you can take a preventive approach.

Show content or pricing targeted to a specific segment (New). The new targeted offers feature lets you target specific segments of your customers with attractive, personalized content inside the app to increase engagement, retention and monetization. An example is discounting certain in-app products for customers who are first time payers. For more info and a demo of how to use this feature, view the Build session Maximizing user engagement with customized app content (P4116), or read more.

Control your price more precisely and schedule changes (Rollout starting). You can precisely schedule price changes for customers on Windows 10 over time, using the currency that makes sense to you, to occur globally or for specific markets. Rollout of this feature starts today and will finish within a few months.

Increase customer acquisition and engagement with more flexible sale pricing (Rollout starting). We’ve added more options to sale pricing to let you configure discounts by percentage (e.g. 40% off), offer discounts to customers that own one of your other apps (such as “50% off if you own this other game”), target a discount to a segment of users (e.g. offer discount to users that have not rated the game) and even use a new segment of customers that have never purchased anything in the Store. When a customer makes their first purchase, we’ve found that they typically continue to purchase more items in that initial app or game, as well as in other products in the Store. Rollout of advanced sale pricing starts today, and all accounts should have access to these features by summer. Note that when you offer a discount to a segment of your customers, you can also use our targeted notifications feature to alert those customers about the discount. Watch the Build 2017 session Maximizing revenue through advanced pricing, sales and scheduling (P4116) to learn more.

Dev Center configuration 

How sale pricing appears in the Store

View all possible price tiers in Excel (Rollout starting). While adjusting prices, many of you have asked to be able to have an easier way to view the price tiers in all the currencies. The Pricing and availability page now offers the option to download the price table in .csv (editable in Excel). Rollout starts today, and all accounts should have access to download the price table in a few months.

Improving analysis

Once your app is published and live, you’ll want to analyze its performance, to help adjust your listing or app to improve acquisitions, satisfaction or engagement. Our new analytics capabilities let you analyze multiple apps more effectively, identify areas of improvement in the conversion funnel, improve debugging and in general find patterns and trends to improve your app.

View analytics for multiple apps, using a modern design (Dev Center Insiders). Along with the release of the new dashboard experience, we have refreshed and enhanced our analytics features to bring you better insights. The new Analytics Overview quickly summarizes key reports like Acquisitions, Usage, Installs and Health, and you can select up to 5 apps to view at one time. You can get an early look at this new design by joining the Dev Center Insider Program.

Analyze your customer conversion funnel (Dev Center Insiders). The acquisition funnel shows the total number of customers that complete each stage of the funnel—from viewing the Store page to using the app, along with conversion rate. You can filter by customer demographics and custom campaigns to compare campaign effectiveness. The report is for Windows 10 customers over the last 90 days, and Page views also includes views from people who are not signed in with a Microsoft account. Try it out now by joining the Dev Center Insider Program.

Automatically receive alerts when there are anomalies in acquisition trends (Dev Center Insiders). It’s often easy to miss significant changes. To help you monitor data changes, you’ll get an email alerting you when we detect a significant trend change with your acquisitions. We’ll also include your app’s average rating for the last 10 days so you can see if they’ve been impacted. You can then use the Health and other reports to identify urgent fixes to address, or you can respond to reviews to help drive your ratings back up. To receive these emails now, join the Dev Center Insider Program.

Debug your apps more effectively Analyzing crashes and debugging apps is critical for improving the performance and quality of your apps and games. Today, the Health report lets you pinpoint which OS and app version configurations generate the most crashes, and link to failure details with individual stack traces.  This summer we’ll roll out the ability to download CAB files for crashes that occur on devices that participate in the Windows Insider program.

Understand usage and analyze by cohorts (Coming soon). The Usage report helps you understand how often and how long users are using an app, and measures interactive engagement time across active users and active devices, using industry-standard DAU/MAU metrics and retention. The report will soon include cohort analytics to help you understand usage drop-off over time. Join the Dev Center Insider program to be ready to use this analysis when it rolls out to all accounts within the next few months.

What comes next?

We hope you’ll take advantage of these resources and learn more about the capabilities described in this blog by doing the following:

Keep giving us feedback to help us prioritize features and updates. Use the feedback link in Dev Center, which you’ll now find in the upper right of the dashboard (if you’re using the new dashboard experience as part of the Dev Center Insider Program).

Introducing Microsoft’s new Ad Monetization Platform

Earlier this week, we kicked off our annual developer conference Microsoft Build in front of over 5,000 developers at Washington state convention center with viewers watching the event live around the world. During the keynote and other live sessions, we had several announcements that featured tools and services for PC, Tablet & Web developers to monetize and acquire through the Microsoft’s new ad monetization platform.

Microsoft’s new ad monetization platform brings together innovative consumer ad experiences, federated cloud based smart mediation service, and best-in-class universal user acquisition and engagement service in a single platform, so you can maximize your ad revenue and grow your app business by deeply engaging with your users.

Let’s take a closer look at the major announcement.

Maximize your ad revenue

Ad monetize your app with the new Microsoft’s ad mediation platform

Microsoft ad mediation platform

In-app advertising continues to represent more than one-third of the revenue that developers make from writing apps for the Microsoft Windows platform. As part of our continuous commitment to maximize developer monetization through ads, we are excited to announce Microsoft’s ad mediation service, a federated cloud-based ad mediation service designed to help app developers maximize their ad revenue. The ad mediation service along with the Microsoft Advertising SDK are the two key components of Microsoft’s new ad monetization platform that dynamically optimizes ad network configurations to drive the highest yield for the developers and deliver innovative ad experiences for consumers.

Microsoft’s ad mediation service is now available to all developers through the Dev Center. Read more about this announcement here.

Choose the right ad experiences

Drive app advertising revenue by seamlessly integrating the right ad treatments into your app by our rich set of ad formats. Wide variety of formats means you have lots of choices to provide the best user experience.

Interstitial ads

We are also excited to announce the launch of interstitial banner ads support in the Microsoft Advertising SDK. Interstitial banner ads have been one of the top Windows Dev Center feature requests since we introduced support for interstitial video ads. Read more about this announcement here.

Native ads

Microsoft Advertising SDK now supports native ads. Native ads allow developers to create and implement highly immersive ads that fit their app experiences. Developers can now stitch beautiful ad experience completely native to their apps using the new capability provided by the SDK. This feature is currently available as a limited preview to participating developers/publishers.

Please contact aiacare@microsoft.com to get started.

Empowering app growth for Windows developers

Ad campaign to acquire & re-engage with users

Microsoft Universal User Acquisition Platform offers unparalleled self-served tools from Windows Dev Center & REST APIs to help developers promote & re-engage with users. Dev Center App Install Ad Campaigns underwent a major usability improvement. The new workflow helps developers automate campaign targeting, and creative generation to find your most valuable users based on your in app conversions. These innovative experiences are currently available for Insider users and will be generally available to everyone along with the overall Dev Center changes. Developers who haven’t used ad campaigns can read about the full suite of capabilities here.

Auto designed interstitial, native and playable ads

We have enabled adding banner interstitial ads to the creative mix without the developer having to create the artwork. Just click on one check box in the creative section and the banner interstitial that can scale across different device resolutions gets created. The best part of this capability is that you can also use the same ad for your house and community campaigns, which are completely free of cost. Just use the latest SDK to enable interstitial ads in your app, and then opt in to house and/or community ad campaigns.

You can promote your app through native ad experiences now. All the elements that are used to create an auto-generated ad like app title, logo, tagline and price etc. will now be sent as assets to the app developer showing the ads so that they can be stitched in an experience native to the app. All new ad campaigns will have these ads automatically created in the backend using the same elements that the user selects for creating ads in the campaign.

Developers can create a three-minute interactive version of the app as an ad using this capability. This feature is in developer preview and developers can sign-up for getting their apps streamed at aiacare@microsoft.com. Read more about this capability here.

What’s next

We look forward to helping many more developers build and grow successful businesses. At Microsoft //Build 2017, we have shared essential insights and best practices on how to drive growth with Microsoft’s new ad monetization platform. You can take part too by viewing the live streamed and pre-recorded sessions ad monetization and user acquisition.

Check out the new website for more details, then give the features a try! If you’ve got suggestions to make these features even more useful, please let us know at Windows Developer Feedback.

Windows 10 IoT is ready for Microsoft Build 2017

Building an engaging and informative customer experience

Building an engaging and informative customer experience

Windows 10 IoT provides a secure, cutting-edge IoT platform that will transform the way developers bring devices and solutions to market.  With the release of the Windows 10 Creators Update, we’ve made huge improvements in Windows 10 IoT Core, including improved developer tools, additional APIs, new code samples, and more.  We are launching a newly designed Windows IoT website, growing our partner base, and supporting more silicon options than ever before.

I’m excited and honored to be at Build 2017 this week, showing partner and customer solutions that are innovative, secure, and intelligent.  New partners like Innowi, Kodisoft, and XOGO are building innovative solutions using Windows 10 IoT Core and Windows 10 IoT Enterprise, such as next-generation point-of-sale devices, interactive tables, and intelligent digital signage.

As announced today in the Windows 10 IoT session at Build 2017, we are partnering with Intel to bring more choice to our customers and offer more computing power for their designs.  Working alongside our partners at Intel, we are pleased to announce that in addition to the Baytrail, Apollo Lake, and Joule platforms supported today, Windows 10 IoT Core will also be supported on Cherrytrail and Braswell platforms in the near future.  That’s great, but that’s not all.  I’m even more excited to announce today that Windows 10 IoT Core will be supported across Intel’s full range of processors moving forward, including the Core, Pentium, Celeron and Atom lines. This is a great expansion of our existing SoC support, which will now range from a Qualcomm Snapdragon 212 all the way to the top-end Intel Core i7.  See our full list of Windows IoT enabled SoCs and devices on our developer website.

As you will see at Build 2017, Windows 10 IoT and Azure complement each other and offer developers an opportunity to build secure and scalable solutions from the device to the cloud. We are excited about enabling the future of edge computing scenarios across multiple industries. We believe the integration between Windows 10 IoT and Azure IoT will help developers be even more productive in the IoT space and we’ve taken a big step towards that goal with the Windows 10 Creators Update. Some highlights include:

  • Windows 10 IoT Core support for Azure IoT Device Management, which provides highly scalable remote device management features.
  • Turn-key connectivity to the Azure IoT Hub that offers reliable and secure device-to-cloud and cloud-to-device messaging, scaling to millions of devices.
  • Support for the upcoming Azure IoT Hub Device Provisioning Service, which makes it easier to provision a connected device via Azure IoT services, leveraging Windows IoT TPM based security.

In addition to this Azure-connected functionality, we’ve also added new features to Windows IoT Core to help keep devices safe and enable developers to do more, including:

  • Support for Project “Rome” that allows a user to launch an app or communicate with an app service on a remote device, enabling cross-device experiences using the Microsoft Graph.
  • Support for Device Guard for IoT, which improves threat resistance by allowing only OS components and code signed by the OEM to load. This adds to the robust set of security features in Windows 10 IoT such as BitLocker and Secure Boot.
  • Cortana*, your personal digital assistant, is now available for you to integrate into your devices. Cortana will help you get things done by completing tasks and interacting with you using natural language in a consistent, contextual way.

You can also check out the redesigned website for developers, which will help you get started with Windows 10 IoT. If you’re not able to attend Build 2017 in person, you can find all the latest content on Channel 9.

*Cortana available in select markets.