Martin Suchan – BloQ Random #WPdev stuff


UWP Quick tip – JumpLists

Have you heard about the new feature of iPhone 6S called 3D touch? It's basically reinvented context menu on steroids that looks cool and can be useful in many cases, like providing quick context actions for apps on your home screen:

In this article I'll show you, how to implement similar behavior in your Windows 10 UWP app using JumpList API.

First of all, this feature is not available in the Windows 10 RTM version. First you need to have the latest Windows 10 Insider preview build v10565 installed. Second you need to install the latest Windows beta SDK v10563 by following the guide here. Note you should not install this beta SDK on your production machine because you won't be able to publish Store apps built with this SDK!

Once you have all this set up, it's really straightforward, you just need to use the new JumpList API. This API allows you to place custom context menu items, that are shown when you right-click or tap-and-hold Tile of your Windows Store app.

Here's a really simple code for adding those same Camera app context menu items to your Windows Store app:

JumpList jumpList = await JumpList.LoadCurrentAsync();
JumpListItem item1 = JumpListItem.CreateWithArguments("selfie", "Take Selfie");
item1.Logo = new Uri("ms-appx:///Assets/selfie.png");
JumpListItem item2 = JumpListItem.CreateWithArguments("video", "Record Video");
item2.Logo = new Uri("ms-appx:///Assets/cam.png");
JumpListItem item3 = JumpListItem.CreateWithArguments("slomo", "Record Slo-mo");
item3.Logo = new Uri("ms-appx:///Assets/slomo.png");
JumpListItem item4 = JumpListItem.CreateWithArguments("photo", "Take Photo");
item4.Logo = new Uri("ms-appx:///Assets/cam.png");
await jumpList.SaveAsync();

Note that I've added four simple PNG images in Assets folder that are used for JumpListItems.
When you start your app and run this code, the context menu for your tile will look like this:

Screenshot (1)

And if you click one of those Tasks, the app launches with the provided argument in the e.Argument property, so it's really easy to open the right UI for the right task:


And that's all :)

I think the JumpList API is a really nice addition to the UWP ecosystem. It could be used not just for displaying list of recently opened document or projects, but also for quick tasks similar to context menus on iPhone 6S.

Note the JumpList sample should work on Windows 10 Mobile too, if you have the latest build v10549. You can test it on a phone as your homework :)

Filed under: Tips&Tricks, UWP 2 Comments

Displaying HTTPS page with invalid certificate in UWP WebView

If you want to display web page content inside your Windows 10 UWP app, you need to use the WebView class. In standard scenarios you just set the Source property or use the Navigate(Uri) method to the target page and if your Internet connection works, the page shows up just like in Microsoft Edge.

But there is a caveat when using the method. If the target page is available only on HTTPS protocol and the Domain certificate for the target web is not valid (expired, self-signed, invalid domain name...) then the page won't load, you only get the OnNavigationFailed event with WebErrorStatus.CertificateIsInvalid or similar indicator.

As you probably know, in standard browsers like IE, Chrome, Firefox or Edge there is always a semi-hidden option to override this certificate error and continue navigation to that page anyway, usually with a big warning that the connection won't be secure and possible attacker could be eavesdropping your connection or even modifying the transmitted data. Yes, that's the risk here, even though in 99.99% of cases no-one is actually eavesdropping you, only the server is just not properly configured.


If the target site uses self-signed HTTPS certificate and this self-signed certificate is otherwise valid for the target domain, there is a solution how to make the WebView work in this case - you just need to add the specific certificate inside Package.appxmanifest -> Declarations -> Certificates whitelist. Here you select the .cer file for your site with "TrustedPeople" as the Store name and all should just work. Another solution is to whitelist the Root certificate for this custom domain certificate and trust this self-signed Root. Unfortunately this solution only works for specific sites that you whitelist, not for any site with self-signed certificate.


In some valid scenarios you might need to display web content of HTTPS page with invalid certificate inside your Windows Store app, but how to do it? There is no property or method in WebView to override this behavior and enable navigation to a page with invalid certificate, but luckily I found a solution!

WebView in Windows Store apps has a method called NavigateToLocalStreamUri(Uri source, IUriToStreamResolver streamResolver) which is designed for loading local HTTP page with external resources, like HTML pages with extern CSS styles or images, that cannot be loaded just by using NavigateToString(Uri). How to use that method for loading local pages is shown in this short article.

In short you create special object implementing the IUriToStreamResolver interface, that has method IAsyncOperation<IInputStream> UriToStreamAsync(Uri uri). In this method you can handle all HTTP requests from the WebView and load your page resources from any source you want!

The solution

Even though the method is called NavigateToLocalStreamUri, it works just fine even when I manually download the requested resources from the Internet in the IUriToStreamResolver object using the HttpClient class. And with the fact, that HttpClient class allows us to ignore specific certificate errors when connecting to HTTPS web sites, we have a solution for our problem!

Here's a quick and ugly proof of concept for the problem:

public sealed partial class MainPage
    public MainPage()
    protected override void OnNavigatedTo(NavigationEventArgs e)
        Uri uri = new Uri("");
        Uri localStreamUri = Web.BuildLocalStreamUri("MyTag", "/");
        BadHttpsStreamResolver resolver = new BadHttpsStreamResolver(uri, localStreamUri);
        Web.NavigateToLocalStreamUri(localStreamUri, resolver);
public sealed class BadHttpsStreamResolver : IUriToStreamResolver
    private readonly string baseUri;
    private readonly string localStreamUri;
    private readonly HttpClient hc;
    public BadHttpsStreamResolver(Uri baseUri, Uri localStreamUri)
        this.baseUri = baseUri.ToString();
        this.localStreamUri = localStreamUri.ToString();
        HttpBaseProtocolFilter filter = new HttpBaseProtocolFilter();
        // specify here which certificate errors should we ignore
        hc = new HttpClient(filter);
    public IAsyncOperation<IInputStream> UriToStreamAsync(Uri uri)
        // TODO better uri validation and conversion
        Uri targetUri = new Uri(uri.ToString().Replace(localStreamUri, baseUri));
        return GetInputStream(targetUri).AsAsyncOperation();
    public async Task<IInputStream> GetInputStream(Uri targetUri)
            HttpRequestMessage request = new HttpRequestMessage(HttpMethod.Get, targetUri);
            HttpResponseMessage response = await hc.SendRequestAsync(request);
            IInputStream stream = await response.Content.ReadAsInputStreamAsync();
            return stream;
        catch (Exception ex)
            Debug.WriteLine("Exception {0}", ex);
            return null;

How this works? We have a WebView named "Web" in the MainPage XAML. We have a sample page with expired domain certificate. First we create local stream Uri using the Web.BuildLocalStreamUri("MyTag", "/") method. Then we create the instance of our online IUriToStreamResolver. In our stream resolver we just transform every local Uri to the proper online Uri and use the HttpClient class instance with HttpBaseProtocolFilter ignoring ChainValidationResult.Expired errors for downloading all resources that the page needs.

Here you can see, how the sample page is displayed just fine in my UWP Store app. Note this page uses external CSS file and three external images, all these resources were loaded using my BadHttpsStreamResolver class.


Possible problems with this solution

Sadly this solution is not almighty. It works fine for reasonably simple web sites, but not for highly dynamic sites using AJAX XMLHttpRequest, WebSockets or other advanced stuff. This method also won't work for POST and other non-GET request on that page.

There is a project called Web Application Template that tries to solve some of these advanced scenarios, I've not tried it but it looks quite promising especially for solving the XMLHttpRequest problem by using injected proxy class that redirects all XMLHttpRequest calls into the C# code.


I have shown in this article that it's possible to display simple HTTPS pages with invalid certificate inside WebView in UWP Windows Store apps. For sites with valid self-signed certificate it's possible to use whitelisted certificate or certificate root in app manifest, for pages with other certificate validation errors it's possible to handle all HTTP request with custom IUriToStreamResolver class.

In my opinion the fact, that WebView does not support opt-in for displaying HTTPS pages with invalid certificates is a problem that should be fixed. If you agree with me, please vote for these two UserVoice issues, thanks!

Did you like this article, have you found it helpful, or do you know other methods for displaying HTTPS page with invalid certificate in UWP WebView? Please let me know either here in the discussion or on my Twitter, thanks!


Building Windows Store .appxupload packages using PowerShell

In this article I'll show you how you can easily build Windows Store apps using PowerShell, without launching Visual Studio. Specifically how to build signed .appxupload packages that can be uploaded to Dev Dashboard straight away.

First some summary, by Windows Store apps I mean Windows 8, Windows 8.1, Windows Phone 8.1 (XAML) or Windows 10 (UWP) apps. All these apps use .appx package format when building in Debug mode in Visual Studio.
When creating Windows Store package for your app, you typically use these steps:

1. First, if not done previously, you need to Associate App with the Store. Before you can do that you need to login to Visual Studio with your Windows Store Microsoft Account using two factor authentication, typically using verification code on phone or sent to you by email. After that in the first step unique app name is reserved, app name, publisher name and publishers' signing .pfx certificate is downloaded to you solution and these data are set in your Package.appxmanifest file.



2. Then you need to build the package for Store, this is typically done using the Create App Packages command. In the wizard that shows up it's possible to select target version, bundle option, architecture and solution configuration and option to include debug symbols. After then the solution is built and packaged.


As you can see this is not exactly easy to do and definitely not suitable for automatic builds on your VSO or TeamCity Continuous Integration server.


Since Visual Studio 2013 I was trying to replicate the process that Visual Studio is doing when building app to Store using the Create App Packages Wizard. From what I found this process consist of several steps:

  • msbuild.exe builds the solution in Release mode.
  • makeappx.exe creates .appx package based on a map file containing list of all required files.
  • signtool.exe signs the appx with my private pfx certificate.
  • pdbcopy.exe copies all PDB files related to all dll, exe or winmd libraries without private symbols.
  • These PDB symbols are zipped into .appxsym file.
  • Signed .appx file together with .appxsym is zipped into .appxupload final file.

Details about these steps are described in this nice article: Create a Windows Store AppX package and sign it

I spent about two days packing all these steps into single PowerShell script file but then I made huge discovery - that when building Windows Store app in Release mode using Visual Studio 2015 msbuild, it automatically builds signed .appxupload file for the Store as well!

I was testing the same commands about year or two ago with Visual Studio 2013 and I am almost sure that VS2013 does not create .appxupload packages just like that.

To sum it all up, what to do to build Windows Store packages using PowerShell? First associate your app with Store using Visual Studio, select your preferred Store package configuration and build the packages at least once using the wizard. After that make sure to save all your changes to the solution and project file. These project settings will be then automatically used when building the solution using PowerShell. Then just grab this script, enter you solution name, run it in the folder with your solution and you are done :)

# tools
$msbuild = "C:\Program Files (x86)\MSBuild\14.0\bin\MSBuild.exe"
set-alias msbuild $msbuild
# solution settings
$sln_name = "TestSolution.sln"
$vs_config = "Release" 
$vs_platfom = "x86"
# call the rebuild method
Write-Host "Building solution`n" -foregroundcolor Green
msbuild $sln_name /t:Build /p:Configuration=$vs_config /p:Platform=$vs_platfom /v:q /nologo

What is even better about this - you can build Store packages without entering your Microsoft Account credentials every time. Note in my case I'm not using appx bundle settings and I need to repeat these steps for ARM and x64 Configuration.


After that only two unsolved tasks remain:

  • How to run Windows App Certification Kit from PowerShell and display the results in TeamCity/VSO?
  • How to upload the .appxupload package to Store automatically and release it as a new beta version of my app?

The first task might be possible, I'll try to dig into this soon and post my findings in another article.
The second feature is still not available since there is no public Windows Store REST API for gathering data about apps from Store/Dashboard or publishing new beta builds automatically. If you think just like me that this should be implemented, please vote here in WPdev UserVoice web for this idea, thanks!

Filed under: Tips&Tricks, UWP, WPdev 1 Comment

UWP quick tip – getting device, OS and app info

In this article I'll show you few useful tips when developing any Windows 10 UWP app - how to get basic data about current device, operating system and application. You might need all that info for logging or custom app analytics or maybe in a footer of a support mail generated in the app.

The goal - I want to know in my application:

  • current OS family - phone/desktop/...
  • current OS build number - 10.0.10240.16413
  • current OS architecture - x86/x64/ARM
  • current App Display Name - Battery Tile for instance
  • current App Version -
  • current Device manufacturer - Nokia
  • current Device model - Lumia 1520

Since Windows Phone 8 basically all APIs we used to gather these data have changed, but I've done the work for you, here's a helper class with all these properties:

using Windows.ApplicationModel;
using Windows.Security.ExchangeActiveSyncProvisioning;
using Windows.System.Profile;
public static class Info
    public static string SystemFamily { get; }
    public static string SystemVersion { get; }
    public static string SystemArchitecture { get; }
    public static string ApplicationName { get; }
    public static string ApplicationVersion { get; }
    public static string DeviceManufacturer { get; }
    public static string DeviceModel { get; }
    static Info()
        // get the system family name
        AnalyticsVersionInfo ai = AnalyticsInfo.VersionInfo;
        SystemFamily = ai.DeviceFamily;
        // get the system version number
        string sv = AnalyticsInfo.VersionInfo.DeviceFamilyVersion;
        ulong v = ulong.Parse(sv);
        ulong v1 = (v & 0xFFFF000000000000L) >> 48;
        ulong v2 = (v & 0x0000FFFF00000000L) >> 32;
        ulong v3 = (v & 0x00000000FFFF0000L) >> 16;
        ulong v4 = (v & 0x000000000000FFFFL);
        SystemVersion = $"{v1}.{v2}.{v3}.{v4}";
        // get the package architecure
        Package package = Package.Current;
        SystemArchitecture = package.Id.Architecture.ToString();
        // get the user friendly app name
        ApplicationName = package.DisplayName;
        // get the app version
        PackageVersion pv = package.Id.Version;
        ApplicationVersion = $"{pv.Major}.{pv.Minor}.{pv.Build}.{pv.Revision}";
        // get the device manufacturer and model name
        EasClientDeviceInformation eas = new EasClientDeviceInformation();
        DeviceManufacturer = eas.SystemManufacturer;
        DeviceModel = eas.SystemProductName;

Some comments:

The property DeviceFamilyVersion contains plain string with a long value containing the OS version. All we need to do is convert it back from string to long and convert each short number back to readable format.

The object Package contains lot of useful data including Package Family Name. You might need this property for some future advanced application contracts, so keep this in mind.

The SystemArchitecture property actually tells you the type of the installed package, not the OS architecture, but if you publish all three platform packages for x86, x64 and ARM, it will match the OS architecture.

DeviceManufacturer and DeviceModel might not be defined on custom built PCs. Also on phones the SystemProductName contains the phone name in non-readable format like RM-940_nam_att_200. To convert this name to readable format Lumia 1520 you can use the Phone Name Resolver library.

Here's a sample of properties gathered on my notebook:

Info Test
ASUSTeK Computer Inc.

and here on my dev phone:

Info Test


And that's all :) If you know any other useful system properties, just let me know.

Filed under: Tips&Tricks, UWP, WPdev No Comments

New API for changing Start screen background image in Windows 10 v10166

Windows 10 Insider Preview v10166 was just recently released for PCs and Phones, together with related SDK.

In this short article I'll show you how to use new API for changing Desktop/Start screen background image, that is first available in this version.


The API is located in new class UserProfilePersonalizationSettings in the Windows.SystemUserProfile namespace. It has currently only few members:

public sealed class UserProfilePersonalizationSettings : IUserProfilePersonalizationSettings
    public IAsyncOperation<bool> IUserProfilePersonalizationSettings.TrySetLockScreenImageAsync(StorageFile imageFile);
    public IAsyncOperation<bool> IUserProfilePersonalizationSettings.TrySetWallpaperImageAsync(StorageFile imageFile);
    public static bool IsSupported();
    public static UserProfilePersonalizationSettings Current { get; }

For changing the background image you just need to get StorageFile of your image and call TrySetWallpaperImageAsync and that's all. Complete code sample could look like this. Note I have placed newbg.jpg image in the root folder of my project and set the compile option to Content:

private static async Task ChangeStartWallpaper()
    if (UserProfilePersonalizationSettings.IsSupported())
        StorageFile newBg = await StorageFile.GetFileFromApplicationUriAsync(new Uri("ms-appx:///newbg.jpg"));
        UserProfilePersonalizationSettings ups = UserProfilePersonalizationSettings.Current;
        await ups.TrySetWallpaperImageAsync(newBg);

I've tested this API just now and it works both on phone and PC. Strangely it works immediately, no question asked. There should probably be some kind of dialog or settings that only selected app can change these image. I can imagine two apps fighting to change the background images in background tasks.

That's all for now. I really like this simple new API that will make a great addition to my Windows and Windows Phone apps Astronomy Image of the Day that already can change the lockscreen image with daily astro photo.


Application Insights in Windows Phone 8.1 Silverlight app, first steps

Application Insights (AI) is a new Azure-based analytics service available for variety of platforms like ASP.NET, J2EE, Android, iOS and Windows/Phone, and because I started having recently problems with my current analytics service Flurry I decided to replace in one of my Windows Phone 8.1 Silverlight apps Flurry with AI, for the start.

In this article I'll cover the basic setup of Application Insights in Windows Phone app and also cover few specific problems that I ran into and I had to solve myself.

First steps

tl;dr for adding Application Insights to WP app follow Application Insights for Windows Phone and Store apps :)

Or these steps, first on Azure:

  1. For using AI you need to have Microsoft Azure account, if you don't have one, you can start Free one-month trial.
  2. On Azure Portal create new AI instance using Create -> Developer Services -> Application Insights.
  3. Here choose a name for the AI instance, application type (ASP.NET, Windows Phone, iOS, etc.), resource group and subscription. Note AI is available in Free Tier as well for small apps so you don't need to pay a single cent for using itVisual Studio Application Insights Pricing.
  4. Once you create your AI instance, click on Settings and here on Properties. Here copy your INSTRUMENTATION KEY which serves as unique ID of your AI instance in your app.

Now lets open Visual Studio to connect your new AI instance with your Windows Phone app.

  1. Open your Windows Phone 8.1 Silverlight app solution either in VS2013 or VS2015. Note VS2015 has built-in support for managing AI. In VS2013 you can install AddIn to get similar features, but from what I experienced this AddIn in VS2013 did not worked at all, it was throwing strange exceptions when creating new projects with AI or adding AI to existing project, so I highly recommend using VS2015 RC.
  2. In your project open NuGet and search for Microsoft.ApplicationInsights.WindowsApps and install it. Current stable version of AI for WP in NuGet is 0.17.
  3. Now open the new config file ApplicationInsights.config and here add here add your instrumentation key into this tag:
  4. The last step is adding reference to the TelemetryClient into your app so the AI is actually started somewhere, and here comes the first problem - I had no idea how and where to initialize the telemetry client. It's not mentioned anywhere in the Application Insights for Windows Phone and Store apps, maybe it's in subsequent articles, but I haven't searched any further.

AddOn vs Manual Steps

When adding the Microsoft.ApplicationInsights.WindowsApps NuGet package to your project it tries to modify your App.xaml.cs file with the initialization calls. The thing is it somehow does not work even when I tested it with new clean project. Not sure, where's the problem, really.

Since the manual guide failed in the last step, I tried the other way for initializing my project with AI - the automated way. In VS2015 it's possible to just right click your project and click on Add Application Insights Telemetry... which adds all required NuGet packages and initialization calls automatically. This added all packages in WP8.1 Silverlight project but not the initialization calls.

I've tried it again this time on WP8.1 XAML project and it worked adding this code the the App.xaml.cs file:

/// <summary>
/// Allows tracking page views, exceptions and other telemetry through the Microsoft Application Insights service.
/// </summary>
public static Microsoft.ApplicationInsights.TelemetryClient TelemetryClient;
public App()
TelemetryClient = new Microsoft.ApplicationInsights.TelemetryClient();

And when launched it works, as expected!

WP8.1 Silverlight App Initialization

So I figured out I'll do the same in WP8.1 Silverlight project, and here comes the other tricky part. When I added the same calls to App.xaml.cs to the top of the constructor, the app crashes on NullReferenceException when calling the TelemetryClient constructor.


I tried to search some insight regarding this issue on Google and StackOverflow, but with no success. I was actually surprised there were no tutorials yet from WPdevs solving this problem, or maybe I am having problem no one else had?

So the solution was simple, I started JetBrains dotPeek disassembler and checked the Stack Trace where this crash happened and discovered in about 5 minutes the root cause:


PhoneApplicationService is here used before it's initialized in App.xaml.cs, rookie mistake :)
PhoneApplicationService is defined as a service object in App.xaml and it's available only after the InitializeComponent(); call. When I placed the TelemetryClient constructor before it, then PhoneApplicationService.Current is null. When placing it after InitializeComponent();, it works.

The summary

First create your Application Insights instance on Azure, then add the Microsoft.ApplicationInsights.WindowsApps NuGet package to your app, configure instrumentation key in ApplicationInsights.config and last create instance of TelemetryClient in your app.

If you are Windows Phone developer - in WP Silverlight app you need to place the TelemetryClient constructor after the InitializeComponent(); call, otherwise it will crash right after start.

If you are Windows developer targeting new Universal Apps platform, you can place the TelemetryClient constructor right in the top of App constructor with no problems. That's because PhoneApplicationService is not used here.

And if you are by any chance Application Insights developer:

  • Make sure all tutorials contain required steps regarding TelemetryClient constructor placement.
  • Place the critical sections throwing NullReferenceException into try-catch, or just check if it's null, and tell the user in Exception message where should the TelemetryClient constructor be placed
  • Revise all NuGet packages so that they place TelemetryClient constructor on proper places and if it's not possible to place it, notify user.

At the end Application Insights now work in my Windows Phone 8.1 Silverlight app, maybe I'll publish another blogpost later after I gather some useful analytics data :)


Using ResW File Code Generator in Visual Studio 2015

When developing apps for Windows 8.1, Windows Phone 8.1 or Universal Windows apps, the recommended approach for app localization is to use .resw resource files located in Strings/[culture code]/Resources.resw path. This approach is quite similar to the previous .resx localization system used in .NET/Silverlight apps with one big difference - there is no generated code-behind file now that you can use for compiletime-safe access of localized strings. If you want to get the string named "ListHeader", you need to access it like this:

var loader = new Windows.ApplicationModel.Resources.ResourceLoader();
var str = loader.GetString("ListHeader");

As you can see this is not exactly convenient.

Simple solution for this problem is to use the ResW File Code Generator extension for Visual Studio. All you need is download the ReswCodeGen.VSPackage.vsix file and install it.

Now when you open properties of any .resw file in your app and enter ReswFileCodeGenerator in the Custom Tool field, the code behind file will be created automatically. It's also possible to define the namespace of the generated class using the Custom Tool Namespace field.



Now it's possible to access the string ListHeader like this:

var str = Vlak.Resources.AppResources.ListHeader;

Not just this is much shorter to use, it's also safer. If you now rename the property to ListTitle or delete the string from resources, the app won't compile, which is good, because you know immediately that the string is not in resources anymore. With the original approach using loader.GetString the app would launch but throw an exception when accessing the no longer present string.


ResW File Code Generator in Visual Studio 2015

Installing the addon to Visual Studio 2012 or Visual Studio 2013 is supported out of the box. The problem, is when you want to install this addon to Visual Studio 2015 - it won't work using the available installer. Update, new version of ResW File Code Generator for Visual Studio 2015 was released just day after my article, strange coincidence :)

Luckily there is a simple fix for this:

  1. Download the ReswCodeGen.VSPackage.vsix addon, rename it to and extract it as a zip file.
  2. Open the extension.vsixmanifest file in any text editor.11 
  3. Change the line
    InstallationTarget Version="[11.0,12.0]"
    InstallationTarget Version="[14.0]"
    and save the file.
  4. Pack again the content of the folder as a zip archive and name it ReswCodeGen.VSPackage.vsix22 
  5. Now if you double click the new ReswCodeGen.VSPackage.vsix installer, it will install as expected into Visual Studio 2015 just like the original installer in Visual Studio 2013.

That's all, simple solution for better productivity when developing localized Windows Store apps that you can start using right now even in Visual Studio 2105!

Filed under: Tips&Tricks, WPdev No Comments

New API in Windows Phone 8.1 Update 2

Windows Phone 8.1 Update 2 v 8.10.15127 finally arrived as the default OS version on new Microsoft Lumia 640 and 640 XL, and again, there is a new hidden API in it, so let's take a look, if there is anything interesting that we, developers, can use in our apps.

tl;dr The API diff between WP8.1 Update 1 and WP8.1 Update 2 is here on GitHub. Only added/updated Windows.Phone.Notification.Management API - nothing we can use in our apps without special Accessory extension SDK, + new property in PhoneApplicationPage,


How to fix missing Extension SDKs in Windows 10 Universal Apps

When tools for developing Windows 10 Universal Apps were released couple of days ago I started porting one of my apps to find out, what are the changes and possible issues.
First issue I ran into was that I was unable to add Behaviors SDK to my project - the list of Extension SDKs was almost empty:

In Windows/Phone 8.1 project:


In Windows 10 UAP project:


Luckily, there is a workaround, according to Release Notes for the first version of Windows 10 Tools it's necessary to copy the extension SDKs from the Windows 8.1 Extension SDK location to the universal apps location—that is:

C:\Program Files (x86)\Microsoft SDKs\Windows\v8.1\ExtensionSDKs
C:\Program Files (x86)\Microsoft SDKs\UAP\v0.8.0.0\ExtensionSDKs

After restarting Visual Studio 2015 the copied SDKs are then available in the list and you can add it just like before. Done.


#WPdev Quick tip – API for accessing Windows Store from your app

Following the previous WPdev quick tip how to initiate Email Compose from your app, here is another API that developer often need:

  • Navigate to Rate and Review dialog for the current app - if you want to initiate app rating from the current user
  • Navigate to Windows/Phone Store to the currently running app - if you want the user to purchase full version of current app or upgrade to a new version
  • Navigate to Windows/Phone Store to all apps published by the current developer - if you want to encourage the user to download other of your apps

Unfortunately all these tasks require different type of API in Windows Phone 7.5/8/8.1 Silverlight apps, in Windows 8.1 apps and another one in Windows Phone 8.1 WinRT apps and since I needed all these methods in my recent Windows Universal App NASA TV Live, I decided to put it all into short article for future use, so here it is: