Category Archives: PC

Auto Added by WPeMatico

Developer platform updates at Microsoft Ignite 2019 – Windows Developer Blog

Earlier this year, we announced some awesome advancements in how developers can better connect with their customers and build people-centric experiences using the Microsoft 365 platform. Today, we’re continuing that story and sharing how you can use these enhancements to build more innovative applications and be more productive. We are focusing on three key areas:Enhancing your applications
Optimizing your end to end workflow
Providing seamless deployment solutions

As the gap between Win32 and the Universal Windows Platform (UWP) shrinks, you can adopt the features and tools that work best for you. A top request from developers is to use the modern UI framework down-level. Today you can start using WinUI 3 Alpha, an early preview of WinUI 3 that allows you to start writing apps that will work down to the Windows 10 April 2018 Update. You can also use the Uno platform to bring your WinUI code anywhere WebAssembly runs – including Windows 7. Learn more about our vision and see the roadmap for WinUI on GitHub.

Figure 1: Conceptual overview of WinUI 3
React Native for Windows v0.60 now matches React Native v0.60 and is available through the latest vnext npm package. Partners like HP, Citrix, epam, and axsy are incorporating React Native for Windows capabilities such as keyboard and transitions, focus handling, and Acrylic to name a few so their apps can shine on Windows devices. You can also access nearly 80% of React Native core APIs on Windows including support for native extensions. Use our Getting Started Guide and other docs to learn more.

Today, the final Beta of Microsoft Edge is available. You can install the browser here, select the appropriate channel, and add it to your test matrix now. That way your customers can have a great experience when they begin to upgrade. The new Microsoft Edge will include Internet Explorer mode for enterprise customers, and new privacy features like tracking prevention for end users. Microsoft Edge will be available to download on Windows and macOS in January 2020.
In addition to the web updates, you’ll notice significant improvements to Windows Subsystem for Linux 2 (WSL 2). You can now access your sites and services running in your Linux distros via localhost:port – allowing you to access a node site running in Windows Subsystem for Linux via http://localhost:3000 instead.

Figure 2: http://localhost:3000
WSL 2 distros will also release unused memory back to Windows so that as you run processes inside of your WSL 2 VM, it will grow and shrink to fit your memory needs. Once the Linux process is finished, it will free the memory in the instance and the memory footprint of the WSL 2 VM in Windows.

It’s great to see all of our MSIX tool partners provide additional tooling and support for MSIX scenarios and enhance the user experience in the application deployment space. Developers can use the MSIX Packaging Tool to improve signing apps and IT Pros can leverage Device Guard signing to sign their packages with their Azure AD tenant. You can also update your packaging workflows and edit your MSIX packages by using the right-click edit option to directly launch the package editor.
With the MSIX App Attach preview you can use a single package type across physical and virtual desktops. This preview provides on-demand app availability, reduces network traffic, and improves user logon times because the applications are now separated from the user profiles and the OS layer and attached to a VM at user login. This optimizes application and OS image management for virtual environments – no need to bloat the VM image with unused applications or manage app streaming infrastructure. A single VM image can be used across different user/app groups.
We know you have a lot of options when choosing which tools and features to use when updating or creating new apps and websites, and we are committed to supporting you with great tools, features, and frameworks. Please continue to share your feedback with us so we can build the best operating system for all your development tasks.

Getting your sites ready for the new Microsoft Edge – Microsoft Edge Blog

This morning, we released Microsoft Edge Beta version 79, which is the final Beta before the new Microsoft Edge is generally available, also known as the “Release Candidate.” On January 15th, we expect to release the “Stable” channel, at which point Microsoft Edge will be generally available to download on Windows and macOS.The new Microsoft Edge is built on the Chromium engine, providing best in class compatibility with extensions and web sites, with great support for the latest rendering capabilities, modern web applications, and powerful developer tools across all supported platforms.
For Enterprise customers, the new Microsoft Edge also includes Internet Explorer mode, providing a seamless experience across internal sites and LOB apps with legacy dependencies. And for end users, it includes new privacy-enhancing features like tracking prevention that’s on by default and a new InPrivate mode across your entire web experience, so your online searches and browsing are not attributed to you.
You can learn more about how the new Microsoft Edge and Bing work together to be the browser and search engine for business over on the Windows blog. In this post, we’ll share more about how you can add the new Microsoft Edge to your automated browser testing, so your customers have a great experience as they begin to upgrade. We’ll also share resources you can use to file bugs, get support, and see what’s next for the new Microsoft Edge.

Microsoft Edge has multiple channels that you can get started testing today: Canary, Developer, and Beta. Each of these channels has differing levels of support for experimental features, and therefore each has its own level of risk regarding stability.In general, we recommend testing on the Developer channel as a good balance between Canary (which is essentially untested bits that are built every night) and Beta, which contains six weeks’ worth of changes. The Developer channel may be less stable than Beta but allows developers to experiment and prototype against early bits.
For customers looking for a snapshot of what is coming in the next major version, the Beta channel represents an early preview of the next Stable release. For example, today’s Beta 79 is our “Release Candidate” build for our Stable release on January 15th. To install the browser, simply browse here and select the appropriate channel.

Because the new Microsoft Edge is built on Chromium, it is fully compatible with popular automated testing frameworks like Selenium WebDriver and Puppeteer. With general availability coming in January, we recommend incorporating the new Microsoft Edge into your existing automated tests now – testing the Beta channel will give you six weeks advance notice of any potential issues that may impact your site.
Selenium WebDriver
The most common framework for browser automation is Selenium WebDriver. To configure WebDriver with Microsoft Edge, you’ll need to download the corresponding version of our WebDriver, MSEdgeDriver. So, for example, if you downloaded the Developer channel for Microsoft Edge, you would want to click on the Settings and More link in the browser and then click on “Settings”. From there, you can click on “About Microsoft Edge” and see your Version. It will say something like “79.0.308.0”. Once you know that, you can download the matching version of MSEdgeDriver that is appropriate for your Operating System.
If you prefer to automate that process, you can check the following registry key for the version of Microsoft Edge that is installed:
HKEY_CURRENT_USERSoftwareMicrosoftEdge{ CHANNEL}BLBeacon (e.g., ComputerHKEY_CURRENT_USERSoftwareMicrosoftEdge DevBLBeacon)
And then you can download the driver by building a URL to the server that looks like this:
https://msedgedriver.azureedge.net/{VERSION}/edgedriver_{ARC}.zip (e.g., https://msedgedriver.azureedge.net/79.0.308.1/edgedriver_win32.zip)
Microsoft Edge should be fully compatible with existing tests written to run in Chrome or other Chromium-based browsers – simply modify the “binary_location” to point to Microsoft Edge, and modify the “executable_path” to point to msedgedriver.exe. MSEdgeDriver.exe currently supports Chrome options, but we do plan on updating the Selenium language bindings in Selenium 4 to account for our new browser. For the time being, the language bindings will default to creating the legacy Microsoft Edge connections, so you will pass in a parameter indicating that these tests should run against the new Microsoft Edge browser:
Here is an example for how you would do that in C#:

Puppeteer
Another popular automation framework is Puppeteer, a Node library which provides a high-level API to control Chromium-based Browsers over the DevTools Protocol. By default, Puppeteer will launch a version of Chromium (the core upon which Google Chrome, Microsoft Edge, Brave, Vivaldi, and others are built). However, you can also pass in the path to the browser exe you would like to run instead.
You would write something like this (in JavaScript):

Automating Internet Explorer mode
In addition to running tests written for Chrome on Microsoft Edge, we’ve also made it easy to migrate tests written for Internet Explorer 11. The new Microsoft Edge includes “Internet Explorer mode,” which allows a tab to render content using IE11 in certain Enterprise contexts (e.g., for Intranet sites or sites  specified by your Enterprise Mode Site List).
The new Microsoft Edge allows you to run IE11 validation for legacy sites in addition to your modern experiences. To run your IE11 tests in Microsoft Edge, download the IEDriverServer from Selenium. Then you must pass in a capability to put Microsoft Edge into IE Mode and then run your tests.
Because this capability puts the whole browser into IE11 Mode, you cannot simultaneously test content that should render in the modern Chromium engine, but you should be able to run all of your IE11 tests and validate the rendering in Microsoft Edge. Note that this code requires an update to IEDriverServer which should be included in the next release of Selenium.
After you download the new IEDriverServer from SeleniumHQ and follow the directions for the “Required Configuration” as documented here, you can run the following code to launch the new Microsoft Edge in IE11 mode and run some tests:

As you test your sites in Microsoft Edge, you may encounter issues that appear to be caused by a bug in the browser. For any issue, the quickest way to give feedback is simply to click the “Send feedback” button in the “Help and Feedback” menu (or Alt-Shift-I on Windows). You can describe your issue and share additional details such as screenshots, diagnostic details, or contact information here.
This is also the best place to provide general end-user feedback such as feature suggestions. To date, we’ve received over 230,000 pieces of feedback from users and developers – thank you, and we truly embrace your input!

Alongside today’s announcements, we’ve updated our Platform Status feature roadmap to reflect the new Microsoft Edge capabilities and an early look at what’s in development for future versions. If you have questions about whether we plan to implement an upcoming HTML/CSS/JS feature, you can search for the corresponding entry here. If you don’t see the feature you’re looking for, simply open an issue on GitHub to get it added.
We’re also continuing to innovate through new standards proposals and by implementing experimental features in Chromium. You can track our focus areas on GitHub in the MSEdgeExplainers repository, where we publish public explainers and “intent to implement” notices as our first step towards shipping new features. We are committed to contributing as a member of the open source community, and have published over 30 explainers to date – and more importantly, we hope to make the web better for everyone.
Get started today by downloading the Microsoft Edge Release Candidate build and adding it to your test matrix, and be sure to share any feedback or issues you might have. We’ll see you in January!
– Kyle Pflug, Senior PM Lead, Microsoft Edge– John Jansen, Principal Software Engineering Manager, Microsoft Edge

Join the Microsoft Edge team next week at Ignite 2019 – Microsoft Edge Blog

Next week, we will be travelling to Microsoft Ignite 2019 to share what’s new in Microsoft Edge for enterprises, IT professionals, and web developers. We’re very excited to share more about our journey with Chromium over the past year, what it means to your customers, and to hear your feedback.In this post, we’ve outlined all the breakout sessions and other activities our team will be presenting at Ignite next week, so you can easily track which sessions you want to attend or review later. This year, Ignite is also introducing Roundtable Topics, which are a great opportunity to share your experiences with the product team directly, provide feedback, and help us understand how we can empower you and your organization with Microsoft Edge.
The full list of sessions is provided below. We look forward to seeing you there! Don’t miss out—sign in using your attendee or tech community account to build your Ignite schedule today!

Monday, November 4th
2:00 – 2:45 PM ET: BRK012 – The Web: Where the rubber hits the road on security and manageability, and productivity
Join VP of Product for Microsoft Edge, Chuck Friedman, Group Product leader for Microsoft Edge Enterprise, Sean Lyndersay, and VP of Bing, Jordi Ribas to discuss how Microsoft Edge and Microsoft Search in Bing is the best browser and search for business. We can help you with a systematic approach to identity and security, high-performing intranet and internet searches, and how to think about web and app compatibility on the internet.
3:15 – 4:00 PM ET: BRK1019 – State of the browser: Microsoft Edge
Come learn about the history of Microsoft Edge and the decision to move to Chromium as well as the roadmap for enterprises and show you the 4 pillars of what the team focuses on: Rock solid fundamentals, Safety and Security, Flexible and efficient manageability and deployment, and end-user productivity.
Tuesday, November 5th
11:05 – 11:20 AM ET: MLS1020 – Microsoft Edge and Chromium: What’s new for web developers
In this Microsoft Ignite Live session, Burke Holland will interview Kyle Pflug, PM for Microsoft Edge Developer Experiences, about what the new Chromium foundation means for your web sites and web apps, and how the Microsoft Edge team is working with web standards and the Chromium community to build a better web for everyone.
1:50 – 2:10 PM ET: THR2279 – Mechanics Live: Microsoft Edge and Microsoft Search: Complete tour for IT admins and users
Join Chuck Friedman and Jeremy Chapman to get a comprehensive understanding of the enterprise-focused capabilities in the new Microsoft Edge browser. This is a 20-minute Theater session filmed in the Mechanics Live studio in the hub and you are a part of the experience.
3:05 – 3:25 PM ET: THR108 – Top 10 reasons why you’ll choose the next version of Microsoft Edge
We’re on a mission to create the best browser for the enterprise. We believe the next version of Microsoft Edge is that browser and in this session, we will share the top 10 reasons why.
Roundtable Topics
Wednesday, November 6th
 10:15 – 11:00 AM: BRK2230 – One browser for modern and legacy web apps: deploying Microsoft Edge and IE mode
We have worked with numerous companies – ranging from 1,000’s to 100,000’s of seats – to move from multiple browser environments to a single browser environment. We’ll share lessons learned and best practices for piloting and deploying the next version of Microsoft Edge by leveraging our investments in Internet Explorer mode, Configuration Manager, and Intune.
1:50 – 2:10 PM ET: THR1075 – Enterprise ready PDF solution in Microsoft Edge
Customers have communicated they want a PDF solution in the browser, so they don’t have to manage additional 3rd party software. The Microsoft Edge’s PDF solution will help you understand the investments we’re making so we can accomplish that specific feedback.
Roundtable Topics
Thursday, November 7th
12:45 – 1:30 PM ET: BRK3099 – Moving the web forward: Microsoft Edge for web developers
The next version of Microsoft Edge is built on a new foundation, powered by Chromium. This foundation will empower you with a consistent set of developer tools and enable you to deliver powerful standards-based and hybrid application experiences using web technologies. In this session, we’ll share how our upcoming release simplifies cross-browser testing and enables the latest capabilities for your sites and line of business (LOB) apps, plus our ongoing contributions to Chromium that improve the browser experience for everyone. Finally, we’ll reveal what’s next for web developers in the new Microsoft Edge.
3:40 – 4:00 PM ET: THR106 – Microsoft Edge on macOS
Microsoft Edge will be our first browser for macOS in 13 years. In this session, we share how Microsoft Edge feels at home on macOS, how you can be more productive and secure using it, and what you need to know about managing Microsoft Edge on macOS.
Roundtable Topics
Friday, November 8th
10:15 – 11:00 AM ET: BRK3253 – Protected, productive mobile browsing with Microsoft Edge and Intune
Microsoft Edge isn’t just a desktop browser. The mobile platform has been going strong for close to 2 years. This session will show you the investments we’re making to allow for a full range of experiences starting with management capabilities with Intune, customizing the end user experience, and how to migrate from the Microsoft Intune managed browser to Microsoft Edge.
11:30 AM – 12:15 PM ET: BRK2231 – Keep users productive and data secure in a cloud-first world: secure browsing with Microsoft Edge
Wrap up your Friday with a deep dive on all things security regarding Microsoft Edge. Features such as Application Guard, Conditional Access, and Microsoft Information Protection will be discussed along with other security measures to show you how Microsoft Edge is the most secure browser in the enterprise.
See you there! Don’t forget to sign in using your attendee or tech community account to build your Ignite schedule today!
– Colleen Williams, Senior Program Manager, Microsoft Edge

Identity, Registration and Activation of Non-packaged Win32 Apps – Windows Developer Blog

Many new and sought-after Windows APIs and features such as BackgroundTasks, Notifications, LiveTiles, Share and more, are either not available or not easily callable from non-packaged Win32 applications. This is due to the programming model for UWP APIs that integrate with the system and have a dependency on the following concepts:Identity – The need for package or application identity to identify the caller, and an identifier to scope data and resources.
Registration – The need for configuration of machine state during application deployment, which is required by the API and indexed by the package or application identity.
For packaged applications, Identity declared in the Appxmanifest.xml, and Registration is handled by the MSIX deployment pipeline based on the information in the AppxManifest.xml. This allows a simplified calling pattern for UWP APIs where the application code just uses an API. Compare this to a typical Win32 API that requires a register-use-unregister pattern for managing a callback.
We’ve heard your feedback, and in response we’re filling in the divide between Win32 apps and new Windows APIs & features so that you can take advantage of these new APIs & features and enhance your applications. As of Windows Build 10.0.19000.0 we’re introducing the following new AppModel concepts to provide your Win32 app with deeper integration into the OS:
Sparse Package registrationSigned MSIX packages can be installed on Windows today but all content referenced in the package’s Appxmanifest.xml must be present inside the package. A ‘Sparse’ Package contains an AppxManifest.xml but unlike a regular/full package, the manifest can reference files outside its package in a predetermined ‘external location’. This allows applications that are not yet able to adopt complete MSIX packaging to gain Identity, configure state (Registration) as required by UWP APIs and then take advantage of these APIs.
Package ‘External Location’ To support a Sparse Package, a package definition now has a new element. This is what allows your package AppxManifest.xml to reference content outside its package, in a specific location on disk. For example, if your existing Win32 app installs content in C:Program FilesMyWin32App , you can create a Sparse Package that declares the element and during app installation or first run of your app, you can register the Sparse Package and declare C:Program FilesMyWin32App as the external location your app will be using. This way you can continue deploying all your other app artifacts in the locations you do today while taking advantage of the Sparse Package.
Win32 type RuntimeBehaviorTo help with compatibility of your existing Win32 app when using a Sparse Package, the app can register to have its application process be run like a non-packaged Win32 app as much as possible. This differs from a fully packaged Win32 app in that it is not subject to filesystem + registry virtualization, lifetime management by the system and other runtime attributes of fully packaged applications. The main runtime similarity between such an app and a fully packaged app is the presence of app/package identity in the running process.
Activation via CreateProcessThe activation path for UWP applications today ensures the app has PackageIdentity in its process token. This is used by UWP APIs to identify the caller and refer to later – either to perform a callback or to look up state that was configured during deployment. Because of this requirement, calling CreateProcess() on a UWP exe will fail as the CreateProcess() pipeline was not enlightened about Identity. In order to support Sparse Packages with an External Location, we leverage the classic Win32 application.manifest to provide Identity in CreateProcess() scenarios.
At their core, these features are about providing a foundation for non-packaged Win32 processes to use our latest APIs and features.
*Please note that these are still new and somewhat advanced development features that do not yet have full Visual Studio integration i.e. there are still some gaps in the end to end authoring experience such as having to create a Sparse Package outside of Visual Studio.

We’ll be using a sample application making use of a Sparse Package to walk through the different aspects of Sparse Package authoring and usage. The demo app is located at https://aka.ms/sparsepkgsample
We have a non-packaged WPF application PhotoStoreDemo that stores and displays photos. In its purely non-packaged state, it can be challenging to take advantage of new Windows APIs and features. Our goal is to change this by creating a Sparse Package and continuing to use our previously existing Win32 app artifacts.
Anatomy of a Sparse Package
A Sparse Package must have an AppxManifest.xml and a minimal set of required visual assets in order to deploy.


Assetsstorelogo.png
true

Let’s use the AppxManifest.xml from our sample code above to look at the anatomy of a Sparse Package.
Package External Location
Firstly, the AppxManifest should declare the package property. This allows the manifest to reference content that is not located within the package. Any content referenced in the Sparse Package that isn’t located in the package directly should be in the ‘external’ location which is specified when the Sparse Package is registered. For example, if I declare my package’s external location to be C:Program FilesMyDesktopApp during installation or at first run, the image storelogo.png defined for the property should be installed at C:Program FilesMyDesktopAppAssetsstorelogo.png and the main application executable PhotoStoreDemo.exe should be installed at C:Program FilesMyDesktopAppPhotoStoreDemo.exe. In addition, the MinVersion should be OS Build 10.0.19000.0 or greater, Sparse packages are currently not supported on OS versions earlier than this.
It’s important to note that unlike a fully packaged application, an app using a Sparse Package + ‘External Location’ is not fully managed by the OS at deployment, runtime and uninstall. As is the case with Win32 apps today, your application is responsible for install and uninstall of all its artifacts including the Sparse Package and any content in the ‘external location’. This also means your app doesn’t receive lifetime management and tamper protection that fully packaged apps receive from being installed in a locked down location on the System.
Win32 Runtime Behavior
The newly introduced TrustLevel=mediumIL and RuntimeBehavior=Win32App attributes in the element are used to declare that the application associated with this Sparse Package will run like a Win32 app, with no registry + filesystem virtualisation and other runtime changes.
Sparse Package Authoring
The steps required in authoring Sparse Package are:
Create an AppxManifest.xml + Visual Assets and package them
Sign the Sparse Package
Create a classic Win32 application.manifest in your Win32 app
Register the Sparse Package
Creating and Packaging an AppxManifest.xml + Visual Assets
The first step in creating a Sparse Package is generating the AppxManifest.xml. The AppxManifest needs to contain the properties listed above, you can use this template as a starting point. In addition to the AppxManifest you need to include the visual assets referenced in the manifest file. You can use the “Visual Assets” node in the package.manifest editor of the Visual Studio Application Packaging Project to generate the visual assets.
Once you have your AppxManifest.xml and visual assets, you can use App Packager (MakeAppx.exe) to create a Sparse Package. Because the Sparse package doesn’t contain all the files referenced in the AppxManifest.xml, you need to specify the /nv command.
Here is an example command to create a Sparse Package containing just an AppxManifest.xml from a VS Developer Command Prompt:
MakeAppx.exe  pack  /d    /p  mypackage.msix  /nv
You can find more info on App packager (MakeAppx.exe) here.
Signing a Sparse package
To successfully install on a machine, your Sparse Package must be signed with a cert that is trusted on that machine. This is the case for regular MSIX packages today. You can create a new self-signed cert for development purposes and sign your Sparse Package using the SignTool available in the Windows SDK and MSIX Toolkit. You can also make use of the newly announced Device Guard Signing feature.Here’s an example of how to sign a Sparse Package from a VS Developer Command Prompt using the Sign Tool:
SignTool.exe sign /fd SHA256 /a /f mycert.pfx  /p   mypackage.msix
Creating a classic Win32 application.manifest
To support CreateProcess() scenarios that do not go through the UWP activation pipeline, your app must use the classic Win32-style application.manifest to declare the identity attributes of your application under the new element. The values defined in the manifest are used determine your application’s identity when its executable is launched and must match those declared in your Sparse Package’s AppxManifest.xml.

packageName (above) corresponds to Name and publisher corresponds to Publisher in the element of your Sparse package:
(Sparse Package)

applicationId corresponds to the Id attribute in the element for this app declared in the Sparse package:
(Sparse Package)

Applications>

To add a classic Win32 manifest to an existing project in Visual studio, from the application node right click | Add | New Item | Visual C# | Application Manifest File. The manifest file naming convention is that it must have the same name as your application’s .exe and have the .manifest extension, in this case I named it “PhotoStoreDemo.exe.manifest”.
Taking advantage of your app’s Sparse Package
As earlier mentioned, creating a Sparse Package for your application makes it easier for your Win32 app to deeply integrate with the OS and take advantage of features such as BackgroundTasks, Share, Notifications and Tiles. Let’s have a look at how our sample app runs and uses the Sparse Package to register as a Share Target and make use of UWP activation.
The workflow in our sample looks something like this:
Declare our app as a Share Target in the Sparse Package AppxManifest.xml
Register our app’s Sparse Package with the OS.
Relaunch the app and handle activation types.
Example usage – Declaring your app as a Share Target in the Sparse Package AppxManifest.xml
Our sample app is registered as a Share Target by declaring the windows.ShareTarget Application Extension in the Sparse Package AppxManifest.xml:

.jpg
.png
.gif

StorageItems
Bitmap

Registering a Sparse Package
To take advantage of a Sparse package, your application needs to register the signed package with the system. You can register the package during first run, or you can also register the package during installation of your other Win32 artifacts, if you’re using an installer such as an MSI. To install the package using an MSI you’d need to use Custom Actions. In our sample app, we register the Sparse package during first run. When our application is launched, we check if it’s running with Identity (identity or the lack thereof is a signal of whether the Sparse package has been registered/installed) if the app is not running with identity we then register the Sparse Package and restart the app. This is expected to take place only once at first run. To see how we’re determining if the app is running with identity, have a look at the ExecutionMode class and this post if you’d like more background.
This is what the code in our app looks like:

//if app isn’t running with identity, register its sparse package
if (!ExecutionMode.IsRunningWithIdentity())
{
string externalLocation = @”C:\”;
string sparsePkgPath = @”C:\PhotoStoreDemo.msix”;

//Attempt registration
if (registerSparsePackage(externalLocation, sparsePkgPath))
{
//Registration succeded, restart the app to run with identity
System.Diagnostics.Process.Start(Application.ResourceAssembly.Location, arguments: cmdArgs?.ToString());
}
else //Registration failed, run without identity
{
Debug.WriteLine(“Package Registation failed, running WITHOUT Identity”);
SingleInstanceManager wrapper = new SingleInstanceManager();
wrapper.Run(cmdArgs);
}

}

And this is the registerSparsePackage method called above handling package registration:

Using Windows.Management.Deployment

private static bool registerSparsePackage(string externalLocation, string sparsePkgPath)
{
bool registration = false;
try
{
Uri externalUri = new Uri(externalLocation);
Uri packageUri = new Uri(sparsePkgPath);
PackageManager packageManager = new PackageManager();
//Set the externalLocation where your Win32 artifacts will be installed
//Anything not in the package but referenced by your AppxManifest.xml needs to to be under this location
var options = new AddPackageOptions();
options.ExternalLocationUri = externalUri;

Windows.Foundation.IAsyncOperationWithProgress deploymentOperation = packageManager.AddPackageByUriAsync(packageUri, options)

To register the Sparse packages, you need to make use of the PackageManager AddPackageByUriAsync(packageUri, addPackageOptions) API. The API takes in the location of your signed Sparse Package as a URI and an AddPackageOptions object. You need to create an AddpackageOptions object and set the ExternalLocationUri property to the URI of the location where your Win32 artifacts (e.g. app executable) being referenced in the Sparse Package will be installed.
Handling App Activation
When our app is running, we check whether it was launched under UWP type activation e.g. a Share Event or Notification Event. If it was, we handle the activation event accordingly, otherwise, we handle the launch as a regular .exe launch such as double clicking the app .exe. Here’s a look at the code:

public static void Main(string[] cmdArgs)
{

//Handle Sparse Package based activation e.g Share target activation or clicking on a Tile
// Launching the .exe directly will have activationArgs == null
var activationArgs = AppInstance.GetActivatedEventArgs();
if (activationArgs != null)
{
switch (activationArgs.Kind)
{
case ActivationKind.Launch:
HandleLaunch(activationArgs as LaunchActivatedEventArgs);
break;
case ActivationKind.ToastNotification:
HandleToastNotification(activationArgs as ToastNotificationActivatedEventArgs);
break;
case ActivationKind.ShareTarget:
HandleShareAsync(activationArgs as ShareTargetActivatedEventArgs);
break;
default:
HandleLaunch(null);
break;
}

}
//This is a direct exe based launch e.g. double click.exe or desktop shortcut
else
{
SingleInstanceManager singleInstanceManager = new SingleInstanceManager();
singleInstanceManager.Run(cmdArgs);
}
}
}

Running the Sample
To run the sample app at https://aka.ms/sparsepkgsample:
Make sure your machine has Developer Mode turned on, and both your Windows Build and SDK versions are 10.0.19000.0 or later.
Retarget the solution to the SDK version on your machine – Right click -> Retarget solution.
Add a project reference to the Windows.winmd file at “C:Program Files (x86)Windows Kits10UnionMetadata\Windows.winmd”(Right click PhotoStoreDemo project | Add | Reference| Browse | All files | Windows.winmd)
Make sure the Sparse Package is signed by a trusted cert on your machine.
You can sign using an existing cert or you can create a self-signed cert and trust it on your machine by double clicking | Install certificate | Local Machine | Place all certificates in the following store | Browse | Trusted People | Next | Finish
Update, package and sign the unpackaged files in PhotoStoreDemoPkg. Open the AppxManifest.xml and update the Publisher value in the package element to match the publisher value in your cert. *You will also need to make sure the Publisher value is updated in the classic Win32 app.manifest (PhotoStoreDemo.exe.manifest) to match the new value in the AppxManifest.xml.
Follow the steps under “Creating and Packaging an AppxManifest.xml” and “Signing a Sparse Package” sections to package the files with App Packager (MakeAppx) and then sign them with the SignTool or Device Guard Signing.

Once the Sparse Package is signed, in the main method (in Startup.cs) update the externalLocation value to match the output location of your VS Build binaries and the sparsePkgPath value to match the path to your signed Sparse Package.
When you run the package, you should see the PhotoStoreDemo app launch with a “Running with Identity” tag in the top left corner. If registration of the package failed the tag will read “Desktop App” instead. If the package registration was successful and the app still launches without identity, try double checking to make sure the values in the element of the classic Win32 app.manifest (PhotoStoreDemo.exe.manifest) match the values in the and element of your Sparse Package’s AppxManifest.xml.
Launching the app with identity:

Checking the Details tab in Task Manager shows the app running with a Package Name PhotoStoreDemo which is an indicator that the app is running with our Sparse Package’s declared identity:

After my app has successfully registered the Sparse package, it shows up as a Share target when I right click on a .jpg/.png/.gif file:

Selecting our app activates the app and adds the new image to the image store.

As a bonus, our sample handles toast notification activation in the HandleToastNotification() method in Startup.cs. Clicking the “Add Via Toast” button in the bottom left quadrant of the running app launches a toast message from the app.

If you enter a full path to an image file, it should add the image file to the app’s photo store. If you close the app before responding to the toast, it will relaunch the app with the new image you specified in the path.

Unlike a fully packaged application that is uninstalled by the System when a user chooses to uninstall the app, a Sparse Package must be uninstalled by the application that registers it. The uninstall workflow of a Sparse Package points the user to the uninstaller of the application that registered the package and while uninstalling the Win32 artifacts of the app, the uninstaller must also remove the Sparse Package. This can be done using the PackageManager.RemovePackage..() APIs, you can find an example of an app using the APIs here.
Adding a Sparse Package to your existing Win32 app is a great way to give your application identity and add deeper integration with Windows APIs and features such as Notifications, BackgroundTasks, Live Tiles, Share and more. The main caveats are that unlike for fully packaged applications, your application does not receive tamper protection and installation in a locked down location. In addition, your app is not fully managed by the OS at deployment, runtime and uninstall – your application is responsible for install, lifetime management and uninstall of your Sparse Package, in the same way you are responsible for installing and managing your Win32 app artifacts.

Announcing Windows 10 Insider Preview Build 19013 | Windows Experience Blog

UPDATE 11/1: We have released Build 19013.1000 (KB4528332) to Windows Insiders. This update does not include any changes or fixes.NOTE: If you try to install a Feature On Demand (FOD) while this update is pending and you restart your PC, it will not trigger this update to successfully install. As a workaround, you can pause updates, un-pause updates, and then scan for updates to get out of this state if this happens to you.
Hello Windows Insiders, today we’re releasing Windows 10 Insider Preview Build 19013 (20H1) to Windows Insiders in the Fast ring.
IMPORTANT: As is normal with pre-release builds, these builds may contain bugs that might be painful for some. If you take this flight, you won’t be able to switch Slow or Release Preview rings without doing a clean-install on your PC.
If you want a complete look at what build is in which Insider ring, head over to Flight Hub. You can also check out the rest of our documentation here including a complete list of new features and updates that have gone out as part of Insider flights for the current development cycle.
Not seeing any of the features in this build? Check your Windows Insider Settings to make sure you’re on the Fast ring. Submit feedback here to let us know if things weren’t working the way you expected.

More kaomoji
As some of you may know, with Windows 10 version 1903, we updated our WIN+(Period) / WIN+(Semicolon) keyboard shortcut to not only include emoji, but to also now contain kaomoji and special characters. What are kaomoji? Basically, they’re faces with expressions you can make by combining various characters–for example, you might be familiar with the shruggie:
¯_(ツ)_/¯

In any case, based on your feedback, in this build we’re updating our kaomoji list with a few more favorites, including:
ヾ(⌐■_■)ノ♪
ლ(╹◡╹ლ)
(⊙_◎)
( ͡~ ͜ʖ ͡°)
ಠ_ರೃ
(∩^o^)⊃━☆
/ᐠ。ꞈ。ᐟ
And more! Enjoy (❁´◡`❁)
Windows Subsystem for Linux (WSL) 2 will now release unused Linux memory back to your Windows machine
Previously, your WSL 2 Virtual Machine’s (VM) memory would grow to meet the needs of your workflow, but would not shrink back down when the memory was no longer needed.  With this change, as memory is no longer in use in the Linux VM, it will be freed back to Windows, which will shrink in memory size accordingly.

PowerToys v0.12 now available!
We’ve just released our 0.12 release of PowerToys on GitHub. We’ve gotten tons of great feedback and suggestions from the community and want to directly say thank you to everyone.
New features include a great new utility called PowerRename, which makes it easy to batch rename a bunch of files, improvements to FancyZones, and support for Dark Mode.

Check out our latest article for all the details.
Your Phone app–Elevating the Phone screen feature by removing its dependency on Bluetooth connection
Windows Insiders, we heard your feedback about the Phone screen feature’s dependency on Bluetooth Low Energy connectivity. To address your feedback, we partnered closely with Samsung to bring you a more streamlined experience across all Windows 10 PCs by removing the peripheral role dependency for Phone screen, which will expand the overall reach of this feature.
Samsung Galaxy Note 10 was the first device to introduce this feature in August. After a positive response, we’ve recently enabled this feature across Samsung Galaxy Fold, S10, S10+, and S10e smartphones. You’ll need to update your supported Samsung devices with the recent software update that enables the ‘Link to Windows’ feature. To continue offering this experience to other smartphones, we’re expanding this feature support to Samsung Galaxy A30s, A50s, and A90 smartphones, and we’ll continue to add additional devices in the coming months.
With the new experience rolling out, we’ll be removing the Bluetooth connectivity option, effective immediately. If you were previously enjoying Phone screen over Bluetooth and you have a phone model that doesn’t yet support Link to Windows, the Phone screen node will disappear automatically within the Your Phone app. We recommend that you unpair your devices by going to the Bluetooth settings on both your PC and your Android phone, so that you don’t have a connection that is no longer in use.
Thank you for helping us refine the Phone screen experience so far!
Phone screen requirements:
Select Android phones running Android 9.0 or greater
PC running Windows 10 October 2018 Update or later
Android phone must be on and connected to the same network as the PC
You will need a supported device to use this feature:
Samsung Galaxy Fold
Samsung Galaxy Note 10/ Note 10+
Samsung Galaxy S10/S10+/S10e
Samsung Galaxy A30s/A50s/A90

Refer to the Your Phone FAQs for additional information.
Preview new DirectX 12 features
In the latest 20H1 builds, you can preview new DirectX 12 features, including DirectX Raytracing tier 1.1, Mesh Shader, and Sampler Feedback. In this blog post, the DirectX Team explains what each of these features are and how they will improve the gaming experience in Windows 10!

We fixed an issue resulting in frames being skipped, starting with Build 19002, when running games and videos fullscreen.
We fixed an issue where initiating “Reset this PC” with the cloud download option wasn’t working when started from Windows RE.
We fixed an issue resulting in preinstalled apps (like Calculator) and other UWP apps being missing from the Apps & Features page in Settings.
We appreciate your patience while we worked on our sync engine. As of this build, wallpaper and theme syncing is now up and running again.
We fixed an issue resulting in Wi-Fi unexpectedly resetting (turning off and back on) frequently in recent flights.
We fixed an issue where Wi-Fi Settings might get stuck saying Connecting, even though the network flyout (correctly) indicated that you were Connected.
We fixed an issue where an update being temporarily suspended would result in an 0xc19001e1 error being displayed in Windows Update history.
We fixed an issue resulting in the “Open location” search result option not working if the search result was a folder.
We fixed an issue where if you moved Cortana’s window to certain places on your screen, and then closed the window, the minimize animation wouldn’t go towards Cortana’s icon on the taskbar.
We fixed an issue resulting in File Explorer not rendering correctly sometimes when using multiple monitors with different DPIs on the previous flight.
We fixed an issue where you could get into a state where it wasn’t possible to set focus to File Explorer’s search box in order to type your query.
We fixed an issue that could result in the app thumbnail disappearing when you right clicked it in Task View.
We fixed an issue that could result in the Send Message button in certain notifications not being visible when using High Contrast White.
We fixed an issue where the notification following WIN+Shift+S might have a blank space for the screenshot (rather than actually displaying the screenshot).
We fixed an issue resulting in Resource Manager unexpectedly not showing any disk activity.
We fixed an issue where, if you called SUBST with a path ending with a it would give a Path not found error.
We fixed a memory leak with running apps that repeatedly sent calls to adjust gamma.
Some of you have reached out about when trying to shutdown, seeing a message saying that an app named “G” was preventing shutdown. We investigated and found an issue where windows related to GDI+were only referenced as “G.” We’ve fixed this, so going forward, these will now have the name “GDI+ Window ()”, where will show the .exe name of the app using GDI+.
We fixed an issue resulting in speechruntime.exe using an unexpectedly high amount of CPU on the previous flight.
We fixed an issue resulting in Bluetooth devices potentially not reconnecting as expected after closing then reopening the device lid for certain devices.
We fixed an issue resulting in the Surface Dial not scrolling in recent builds if you switched to something like zoom and then back to scrolling.
Thank you Insiders who shared feedback about the 2-in-1 convertible tablet experience improvements we discussed here. For the time being, we’re returning to the current experience in retail.
We fixed an issue where Narrator would sometime report focus as the page instead of reporting the actual focused control within Chrome.
We fixed an issue where Narrator would not automatically start reading the Narrator user guide webpage and the YouTube webpage.
We corrected Narrator’s “Next Table” command so that it would work in Excel.
We fixed an issue where the text cursor indicator was visible on top of the lock screen background picture.
We fixed an issue where the text cursor indicator preview wasn’t displaying correctly in Settings when using dark theme.
We fixed an issue where when using dark theme, the hardware keyboard text prediction candidate window was unreadable due to black text on a dark grey background.
We fixed an issue that could result in the touch keyboard flickering when inputting emoji.
We fixed an issue where English punctuations were outputted when using the Chinese Pinyin and Wubi IMEs, even if input mode was set to Chinese under the default IME settings. Thanks for your feedback.
We’ve fixed an issue where the character width of alphanumeric characters when using the Traditional Chinese Bopomofo IME would change from half width to full width unexpectedly in some input fields. Thanks for reporting it! If you feel this issue hasn’t been fully addressed in the new version of Bopomofo IME, please let us know your feedback.
We’ve fixed an issue where after successfully updating to a new build, the Windows Update Settings page may have shown the same build needed to be installed.
We’ve fixed an issue where Optional drivers were failing to install.

BattlEye and Microsoft have found incompatibility issues due to changes in the operating system between some Insider Preview builds and certain versions of BattlEye anti-cheat software. To safeguard Insiders who might have these versions installed on their PC, we have applied a compatibility hold on these devices from being offered affected builds of Windows Insider Preview. See this article for details.
We’ve heard that Settings still isn’t available outside of launching via the URI (ms-settings:) for some Insiders and are investigating.
If you use remote desktop connection and the target PC is on this build, within about an hour (if not sooner), DWM may start crashing, and the session window will either go totally black, experience black flashes, or you may get signed out of the remote desktop session altogether. We appreciate your patience.
[ADDED] A small subset of Insiders are reporting the Settings app hangs or crashes when accessing the System or Ease of Access sections. We’ve identified the cause, which is related to display settings, and are working on a fix for a future flight. As a workaround, launch Settings and then search for the setting you’d like to adjust. Any display-related setting can’t be adjusted until a fix is made available. Thank you to the Insiders who reported this.

Halloween is right around the corner and we challenge you to take our Bing Halloween Quiz! Learn the history behind jack-o’-lanterns, werewolves, trick-or-treating, and more. Test your knowledge here and become a Halloween expert with Bing.
If you want to be among the first to learn about these Bing features, join our Bing Insiders Program.
Thanks,BLB

Windows 10 SDK Preview Build 19008 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 19008 or greater). The Preview SDK Build 19008 contains bug fixes and under development changes to the API surface area.The Preview SDK can be downloaded from developer section on Windows Insider.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

This build works in conjunction with previously released SDKs and Visual Studio 2017 and 2019. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1903 or earlier to the Microsoft Store.
The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2019 here.
This build of the Windows SDK will install on only on Windows 10 Insider Preview builds.
In order to assist with script access to the SDK, the ISO will also be able to be accessed through the following static URL: https://software-download.microsoft.com/download/sg/Windows_InsiderPreview_SDK_en-us_19008_1.iso.

Message Compiler (mc.exe)
Now detects the Unicode byte order mark (BOM) in .mc files. If the If the .mc file starts with a UTF-8 BOM, it will be read as a UTF-8 file. Otherwise, if it starts with a UTF-16LE BOM, it will be read as a UTF-16LE file. If the -u parameter was specified, it will be read as a UTF-16LE file. Otherwise, it will be read using the current code page (CP_ACP).
Now avoids one-definition-rule (ODR) problems in MC-generated C/C++ ETW helpers caused by conflicting configuration macros (e.g. when two .cpp files with conflicting definitions of MCGEN_EVENTWRITETRANSFER are linked into the same binary, the MC-generated ETW helpers will now respect the definition of MCGEN_EVENTWRITETRANSFER in each .cpp file instead of arbitrarily picking one or the other).
Windows Trace Preprocessor (tracewpp.exe)
Now supports Unicode input (.ini, .tpl, and source code) files. Input files starting with a UTF-8 or UTF-16 byte order mark (BOM) will be read as Unicode. Input files that do not start with a BOM will be read using the current code page (CP_ACP). For backwards-compatibility, if the -UnicodeIgnore command-line parameter is specified, files starting with a UTF-16 BOM will be treated as empty.
Now supports Unicode output (.tmh) files. By default, output files will be encoded using the current code page (CP_ACP). Use command-line parameters -cp:UTF-8 or -cp:UTF-16 to generate Unicode output files.
Behavior change: tracewpp now converts all input text to Unicode, performs processing in Unicode, and converts output text to the specified output encoding. Earlier versions of tracewpp avoided Unicode conversions and performed text processing assuming a single-byte character set. This may lead to behavior changes in cases where the input files do not conform to the current code page. In cases where this is a problem, consider converting the input files to UTF-8 (with BOM) and/or using the -cp:UTF-8 command-line parameter to avoid encoding ambiguity.
TraceLoggingProvider.h
Now avoids one-definition-rule (ODR) problems caused by conflicting configuration macros (e.g. when two .cpp files with conflicting definitions of TLG_EVENT_WRITE_TRANSFER are linked into the same binary, the TraceLoggingProvider.h helpers will now respect the definition of TLG_EVENT_WRITE_TRANSFER in each .cpp file instead of arbitrarily picking one or the other).
In C++ code, the TraceLoggingWrite macro has been updated to enable better code sharing between similar events using variadic templates.
Signing your apps with Device Guard Signing
We are making it easier for you to sign your app. Device Guard signing is a Device Guard feature that is available in Microsoft Store for Business and Education. Signing allows enterprises to guarantee every app comes from a trusted source. Our goal is to make signing your MSIX package easier. Documentation on Device Guard Signing can be found here: https://docs.microsoft.com/windows/msix/package/signing-package-device-guard-signing

We have stood up a NuGet feed for the flighted builds of the SDK. You can now test preliminary builds of the Windows 10 WinRT API Pack, as well as a microsoft.windows.sdk.headless.contracts NuGet package.
We use the following feed to flight our NuGet packages.
Microsoft.Windows.SDK.Contracts which can be used with to add the latest Windows Runtime APIs support to your .NET Framework 4.5+ and .NET Core 3.0+ libraries and apps.
The Windows 10 WinRT API Pack enables you to add the latest Windows Runtime APIs support to your .NET Framework 4.5+ and .NET Core 3.0+ libraries and apps.
Microsoft.Windows.SDK.Headless.Contracts provides a subset of the Windows Runtime APIs for console apps excludes the APIs associated with a graphical user interface. This NuGet is used in conjunction with Windows ML container development. Check out the Getting Started guide for more information.

Removal of api-ms-win-net-isolation-l1-1-0.lib
In this release api-ms-win-net-isolation-l1-1-0.lib has been removed from the Windows SDK. Apps that were linking against api-ms-win-net-isolation-l1-1-0.lib can switch to OneCoreUAP.lib as a replacement.
Removal of IRPROPS.LIB
In this release, irprops.lib has been removed from the Windows SDK. Apps that were linking against irprops.lib can switch to bthprops.lib as a drop-in replacement.
Removal of WUAPICommon.H and WUAPICommon.IDL
In this release we have moved ENUM tagServerSelection from WUAPICommon.H to wupai.h and removed the header. If you would like to use the ENUM tagServerSelection, you will need to include wuapi.h or wuapi.idl.

The following APIs have been added to the platform since the release of Windows 10 SDK, version 1903, build 18362.
Additions:

namespace Windows.AI.MachineLearning {
public sealed class LearningModelSessionOptions {
bool CloseModelOnSessionCreation { get; set; }
}
}
namespace Windows.ApplicationModel {
public sealed class AppInfo {
public static AppInfo Current { get; }
Package Package { get; }
public static AppInfo GetFromAppUserModelId(string appUserModelId);
public static AppInfo GetFromAppUserModelIdForUser(User user, string appUserModelId);
}
public interface IAppInfoStatics
public sealed class Package {
StorageFolder EffectiveExternalLocation { get; }
string EffectiveExternalPath { get; }
string EffectivePath { get; }
string InstalledPath { get; }
bool IsStub { get; }
StorageFolder MachineExternalLocation { get; }
string MachineExternalPath { get; }
string MutablePath { get; }
StorageFolder UserExternalLocation { get; }
string UserExternalPath { get; }
IVectorView GetAppListEntries();
RandomAccessStreamReference GetLogoAsRandomAccessStreamReference(Size size);
}
}
namespace Windows.ApplicationModel.AppService {
public enum AppServiceConnectionStatus {
AuthenticationError = 8,
DisabledByPolicy = 10,
NetworkNotAvailable = 9,
WebServiceUnavailable = 11,
}
public enum AppServiceResponseStatus {
AppUnavailable = 6,
AuthenticationError = 7,
DisabledByPolicy = 9,
NetworkNotAvailable = 8,
WebServiceUnavailable = 10,
}
public enum StatelessAppServiceResponseStatus {
AuthenticationError = 11,
DisabledByPolicy = 13,
NetworkNotAvailable = 12,
WebServiceUnavailable = 14,
}
}
namespace Windows.ApplicationModel.Background {
public sealed class BackgroundTaskBuilder {
void SetTaskEntryPointClsid(Guid TaskEntryPoint);
}
public sealed class BluetoothLEAdvertisementPublisherTrigger : IBackgroundTrigger {
bool IncludeTransmitPowerLevel { get; set; }
bool IsAnonymous { get; set; }
IReference PreferredTransmitPowerLevelInDBm { get; set; }
bool UseExtendedFormat { get; set; }
}
public sealed class BluetoothLEAdvertisementWatcherTrigger : IBackgroundTrigger {
bool AllowExtendedAdvertisements { get; set; }
}
}
namespace Windows.ApplicationModel.ConversationalAgent {
public sealed class ActivationSignalDetectionConfiguration
public enum ActivationSignalDetectionTrainingDataFormat
public sealed class ActivationSignalDetector
public enum ActivationSignalDetectorKind
public enum ActivationSignalDetectorPowerState
public sealed class ConversationalAgentDetectorManager
public sealed class DetectionConfigurationAvailabilityChangedEventArgs
public enum DetectionConfigurationAvailabilityChangeKind
public sealed class DetectionConfigurationAvailabilityInfo
public enum DetectionConfigurationTrainingStatus
}
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataPackage {
event TypedEventHandler ShareCanceled;
}
}
namespace Windows.Devices.Bluetooth {
public sealed class BluetoothAdapter {
bool IsExtendedAdvertisingSupported { get; }
uint MaxAdvertisementDataLength { get; }
}
}
namespace Windows.Devices.Bluetooth.Advertisement {
public sealed class BluetoothLEAdvertisementPublisher {
bool IncludeTransmitPowerLevel { get; set; }
bool IsAnonymous { get; set; }
IReference PreferredTransmitPowerLevelInDBm { get; set; }
bool UseExtendedAdvertisement { get; set; }
}
public sealed class BluetoothLEAdvertisementPublisherStatusChangedEventArgs {
IReference SelectedTransmitPowerLevelInDBm { get; }
}
public sealed class BluetoothLEAdvertisementReceivedEventArgs {
BluetoothAddressType BluetoothAddressType { get; }
bool IsAnonymous { get; }
bool IsConnectable { get; }
bool IsDirected { get; }
bool IsScannable { get; }
bool IsScanResponse { get; }
IReference TransmitPowerLevelInDBm { get; }
}
public enum BluetoothLEAdvertisementType {
Extended = 5,
}
public sealed class BluetoothLEAdvertisementWatcher {
bool AllowExtendedAdvertisements { get; set; }
}
public enum BluetoothLEScanningMode {
None = 2,
}
}
namespace Windows.Devices.Bluetooth.Background {
public sealed class BluetoothLEAdvertisementPublisherTriggerDetails {
IReference SelectedTransmitPowerLevelInDBm { get; }
}
}
namespace Windows.Devices.Display {
public sealed class DisplayMonitor {
bool IsDolbyVisionSupportedInHdrMode { get; }
}
}
namespace Windows.Devices.Input {
public sealed class PenButtonListener
public sealed class PenDockedEventArgs
public sealed class PenDockListener
public sealed class PenTailButtonClickedEventArgs
public sealed class PenTailButtonDoubleClickedEventArgs
public sealed class PenTailButtonLongPressedEventArgs
public sealed class PenUndockedEventArgs
}
namespace Windows.Devices.Sensors {
public sealed class Accelerometer {
AccelerometerDataThreshold ReportThreshold { get; }
}
public sealed class AccelerometerDataThreshold
public sealed class Barometer {
BarometerDataThreshold ReportThreshold { get; }
}
public sealed class BarometerDataThreshold
public sealed class Compass {
CompassDataThreshold ReportThreshold { get; }
}
public sealed class CompassDataThreshold
public sealed class Gyrometer {
GyrometerDataThreshold ReportThreshold { get; }
}
public sealed class GyrometerDataThreshold
public sealed class Inclinometer {
InclinometerDataThreshold ReportThreshold { get; }
}
public sealed class InclinometerDataThreshold
public sealed class LightSensor {
LightSensorDataThreshold ReportThreshold { get; }
}
public sealed class LightSensorDataThreshold
public sealed class Magnetometer {
MagnetometerDataThreshold ReportThreshold { get; }
}
public sealed class MagnetometerDataThreshold
}
namespace Windows.Foundation.Metadata {
public sealed class AttributeNameAttribute : Attribute
public sealed class FastAbiAttribute : Attribute
public sealed class NoExceptionAttribute : Attribute
}
namespace Windows.Globalization {
public sealed class Language {
string AbbreviatedName { get; }
public static IVector GetMuiCompatibleLanguageListFromLanguageTags(IIterable languageTags);
}
}
namespace Windows.Graphics.Capture {
public sealed class GraphicsCaptureSession : IClosable {
bool IsCursorCaptureEnabled { get; set; }
}
}
namespace Windows.Graphics.DirectX {
public enum DirectXPixelFormat {
SamplerFeedbackMinMipOpaque = 189,
SamplerFeedbackMipRegionUsedOpaque = 190,
}
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicFrame {
HolographicFrameId Id { get; }
}
public struct HolographicFrameId
public sealed class HolographicFrameRenderingReport
public sealed class HolographicFrameScanoutMonitor : IClosable
public sealed class HolographicFrameScanoutReport
public sealed class HolographicSpace {
HolographicFrameScanoutMonitor CreateFrameScanoutMonitor(uint maxQueuedReports);
}
}
namespace Windows.Management.Deployment {
public sealed class AddPackageOptions
public enum DeploymentOptions : uint {
StageInPlace = (uint)4194304,
}
public sealed class PackageManager {
IAsyncOperationWithProgress AddPackageByUriAsync(Uri packageUri, AddPackageOptions options);
IVector FindProvisionedPackages();
PackageStubPreference GetPackageStubPreference(string packageFamilyName);
IAsyncOperationWithProgress RegisterPackageByUriAsync(Uri manifestUri, RegisterPackageOptions options);
IAsyncOperationWithProgress RegisterPackagesByFullNameAsync(IIterable packageFullNames, RegisterPackageOptions options);
void SetPackageStubPreference(string packageFamilyName, PackageStubPreference useStub);
IAsyncOperationWithProgress StagePackageByUriAsync(Uri packageUri, StagePackageOptions options);
}
public enum PackageStubPreference
public enum PackageTypes : uint {
All = (uint)4294967295,
}
public sealed class RegisterPackageOptions
public enum RemovalOptions : uint {
PreserveRoamableApplicationData = (uint)128,
}
public sealed class StagePackageOptions
public enum StubPackageOption
}
namespace Windows.Media.Audio {
public sealed class AudioPlaybackConnection : IClosable
public sealed class AudioPlaybackConnectionOpenResult
public enum AudioPlaybackConnectionOpenResultStatus
public enum AudioPlaybackConnectionState
}
namespace Windows.Media.Capture {
public sealed class MediaCapture : IClosable {
MediaCaptureRelativePanelWatcher CreateRelativePanelWatcher(StreamingCaptureMode captureMode, DisplayRegion displayRegion);
}
public sealed class MediaCaptureInitializationSettings {
Uri DeviceUri { get; set; }
PasswordCredential DeviceUriPasswordCredential { get; set; }
}
public sealed class MediaCaptureRelativePanelWatcher : IClosable
}
namespace Windows.Media.Capture.Frames {
public sealed class MediaFrameSourceInfo {
Panel GetRelativePanel(DisplayRegion displayRegion);
}
}
namespace Windows.Media.Devices {
public sealed class PanelBasedOptimizationControl
}
namespace Windows.Media.MediaProperties {
public static class MediaEncodingSubtypes {
public static string Pgs { get; }
public static string Srt { get; }
public static string Ssa { get; }
public static string VobSub { get; }
}
public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties {
public static TimedMetadataEncodingProperties CreatePgs();
public static TimedMetadataEncodingProperties CreateSrt();
public static TimedMetadataEncodingProperties CreateSsa(byte[] formatUserData);
public static TimedMetadataEncodingProperties CreateVobSub(byte[] formatUserData);
}
}
namespace Windows.Networking.BackgroundTransfer {
public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void RemoveRequestHeader(string headerName);
void SetRequestHeader(string headerName, string headerValue);
}
public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void RemoveRequestHeader(string headerName);
void SetRequestHeader(string headerName, string headerValue);
}
}
namespace Windows.Networking.Connectivity {
public enum NetworkAuthenticationType {
Owe = 12,
}
}
namespace Windows.Networking.NetworkOperators {
public sealed class NetworkOperatorTetheringAccessPointConfiguration {
TetheringWiFiBand Band { get; set; }
bool IsBandSupported(TetheringWiFiBand band);
IAsyncOperation IsBandSupportedAsync(TetheringWiFiBand band);
}
public sealed class NetworkOperatorTetheringManager {
public static void DisableNoConnectionsTimeout();
public static IAsyncAction DisableNoConnectionsTimeoutAsync();
public static void EnableNoConnectionsTimeout();
public static IAsyncAction EnableNoConnectionsTimeoutAsync();
public static bool IsNoConnectionsTimeoutEnabled();
}
public enum TetheringWiFiBand
}
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static event EventHandler ChannelsRevoked;
}
public sealed class PushNotificationChannelsRevokedEventArgs
public sealed class RawNotification {
IBuffer ContentBytes { get; }
}
}
namespace Windows.Security.Authentication.Web.Core {
public sealed class WebAccountMonitor {
event TypedEventHandler AccountPictureUpdated;
}
}
namespace Windows.Security.Isolation {
public sealed class IsolatedWindowsEnvironment
public enum IsolatedWindowsEnvironmentActivator
public enum IsolatedWindowsEnvironmentAllowedClipboardFormats : uint
public enum IsolatedWindowsEnvironmentAvailablePrinters : uint
public enum IsolatedWindowsEnvironmentClipboardCopyPasteDirections : uint
public struct IsolatedWindowsEnvironmentContract
public struct IsolatedWindowsEnvironmentCreateProgress
public sealed class IsolatedWindowsEnvironmentCreateResult
public enum IsolatedWindowsEnvironmentCreateStatus
public sealed class IsolatedWindowsEnvironmentFile
public static class IsolatedWindowsEnvironmentHost
public enum IsolatedWindowsEnvironmentHostError
public sealed class IsolatedWindowsEnvironmentLaunchFileResult
public enum IsolatedWindowsEnvironmentLaunchFileStatus
public sealed class IsolatedWindowsEnvironmentOptions
public static class IsolatedWindowsEnvironmentOwnerRegistration
public sealed class IsolatedWindowsEnvironmentOwnerRegistrationData
public sealed class IsolatedWindowsEnvironmentOwnerRegistrationResult
public enum IsolatedWindowsEnvironmentOwnerRegistrationStatus
public sealed class IsolatedWindowsEnvironmentProcess
public enum IsolatedWindowsEnvironmentProcessState
public enum IsolatedWindowsEnvironmentProgressState
public sealed class IsolatedWindowsEnvironmentShareFolderRequestOptions
public sealed class IsolatedWindowsEnvironmentShareFolderResult
public enum IsolatedWindowsEnvironmentShareFolderStatus
public sealed class IsolatedWindowsEnvironmentStartProcessResult
public enum IsolatedWindowsEnvironmentStartProcessStatus
public sealed class IsolatedWindowsEnvironmentTelemetryParameters
public static class IsolatedWindowsHostMessenger
public delegate void MessageReceivedCallback(Guid receiverId, IVectorView message);
}
namespace Windows.Storage {
public static class KnownFolders {
public static IAsyncOperation GetFolderAsync(KnownFolderId folderId);
public static IAsyncOperation RequestAccessAsync(KnownFolderId folderId);
public static IAsyncOperation RequestAccessForUserAsync(User user, KnownFolderId folderId);
}
public enum KnownFoldersAccessStatus
public sealed class StorageFile : IInputStreamReference, IRandomAccessStreamReference, IStorageFile, IStorageFile2, IStorageFilePropertiesWithAvailability, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
public static IAsyncOperation GetFileFromPathForUserAsync(User user, string path);
}
public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
public static IAsyncOperation GetFolderFromPathForUserAsync(User user, string path);
}
}
namespace Windows.Storage.Provider {
public sealed class StorageProviderFileTypeInfo
public sealed class StorageProviderSyncRootInfo {
IVector FallbackFileTypeInfo { get; }
}
public static class StorageProviderSyncRootManager {
public static bool IsSupported();
}
}
namespace Windows.System {
public sealed class UserChangedEventArgs {
IVectorView ChangedPropertyKinds { get; }
}
public enum UserWatcherUpdateKind
}
namespace Windows.UI.Composition.Interactions {
public sealed class InteractionTracker : CompositionObject {
int TryUpdatePosition(Vector3 value, InteractionTrackerClampingOption option, InteractionTrackerPositionUpdateOption posUpdateOption);
}
public enum InteractionTrackerPositionUpdateOption
}
namespace Windows.UI.Input {
public sealed class CrossSlidingEventArgs {
uint ContactCount { get; }
}
public sealed class DraggingEventArgs {
uint ContactCount { get; }
}
public sealed class GestureRecognizer {
uint HoldMaxContactCount { get; set; }
uint HoldMinContactCount { get; set; }
float HoldRadius { get; set; }
TimeSpan HoldStartDelay { get; set; }
uint TapMaxContactCount { get; set; }
uint TapMinContactCount { get; set; }
uint TranslationMaxContactCount { get; set; }
uint TranslationMinContactCount { get; set; }
}
public sealed class HoldingEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
}
public sealed class ManipulationCompletedEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
}
public sealed class ManipulationInertiaStartingEventArgs {
uint ContactCount { get; }
}
public sealed class ManipulationStartedEventArgs {
uint ContactCount { get; }
}
public sealed class ManipulationUpdatedEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
}
public sealed class RightTappedEventArgs {
uint ContactCount { get; }
}
public sealed class SystemButtonEventController : AttachableInputObject
public sealed class SystemFunctionButtonEventArgs
public sealed class SystemFunctionLockChangedEventArgs
public sealed class SystemFunctionLockIndicatorChangedEventArgs
public sealed class TappedEventArgs {
uint ContactCount { get; }
}
}
namespace Windows.UI.Input.Inking {
public sealed class InkModelerAttributes {
bool UseVelocityBasedPressure { get; set; }
}
}
namespace Windows.UI.Text {
public enum RichEditMathMode
public sealed class RichEditTextDocument : ITextDocument {
void GetMath(out string value);
void SetMath(string value);
void SetMathMode(RichEditMathMode mode);
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
bool CriticalInputMismatch { get; set; }
bool TemporaryInputMismatch { get; set; }
void ApplyApplicationUserModelID(string value);
}
public sealed class UISettings {
event TypedEventHandler AnimationsEnabledChanged;
event TypedEventHandler MessageDurationChanged;
}
public sealed class UISettingsAnimationsEnabledChangedEventArgs
public sealed class UISettingsMessageDurationChangedEventArgs
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
event TypedEventHandler PrimaryViewHiding;
event TypedEventHandler PrimaryViewShowing;
}
public sealed class CoreInputViewHidingEventArgs
public enum CoreInputViewKind {
Symbols = 4,
}
public sealed class CoreInputViewShowingEventArgs
public sealed class UISettingsController
}

Outer Worlds now available on Windows PC and Xbox One | Windows Experience Blog

The Outer Worlds, which won the best original game at E3 2019, is now available across the Xbox One family of devices, including Xbox One X and Windows PC.
In this game, you awake from hibernation after drifting in space for 70 years on a lost colonist ship, the Hope. Here at the edge of the galaxy, corporations control all aspects of life in Halcyon, and they are hiding a dark secret that could destroy the colony. As you explore multiple locations in the game’s world, you will encounter various factions, and meet a host of multi-faceted characters who may offer assistance in your missions. But choose carefully, as the actions and choices you make will determine how this player-driven story unfolds.
The Outer Worlds is available now for $59.99 for Xbox One and Windows PC through the Epic Games Store and Microsoft Store. It’s also available with Xbox Game Pass for Console and PC.
Find out more on Xbox Wire.

Announcing Windows 10 Insider Preview Build 19008 | Windows Experience Blog

UPDATE 10/24: We have released Build 19008.1000 which is a Cumulative Update with no major changes. We are trying out our servicing pipeline on 20H1 builds.Hello Windows Insiders, today we’re releasing Windows 10 Insider Preview Build 19008 (20H1) to Windows Insiders in the Fast ring.
IMPORTANT: As is normal with pre-release builds, these builds may contain bugs that might be painful for some. If you take this flight, you won’t be able to switch Slow or Release Preview rings without doing a clean-install on your PC.
If you want a complete look at what build is in which Insider ring, head over to Flight Hub. You can also check out the rest of our documentation here including a complete list of new features and updates that have gone out as part of Insider flights for the current development cycle.
Not seeing any of the features in this build? Check your Windows Insider Settings to make sure you’re on the Fast ring. Submit feedback here to let us know if things weren’t working the way you expected.

For Insiders that were experiencing their PCs getting stuck on restart and shutdown on Builds 18999-19002: A fix for this was included with the update to Build 19002.1002, but in case you didn’t see it, including a note here too. If you didn’t install Build 19002.1002, you may need to use the workaround in order to upgrade to this build.
We fixed an issue where, when optional updates were available, Insiders with the Settings header might see the Windows Update indicator in a warning state, although the main page of Windows Update Settings showed that everything is up to date.
We fixed an issue resulting in sometimes not being able to bring Settings back up after minimizing the window.
We’ve done some work to improve the launch speed of the taskbar jump lists.

We fixed an issue resulting in the Program Compatibility Assistant popping up with null entries for some Insiders after upgrade.

We fixed an issue resulting in Windows Hello unexpectedly showing an error message periodically saying “Can’t turn camera on” on recent builds.
We cleaned up some UI in the Mouse pointer settings in Ease of Access.
We fixed a bug in Narrator where Narrator was not reading link text in the proper language in the Chrome Browser.

[ADDED] We fixed an issue with the main page of Windows Security where if you hovered over the categories, the background color of the square around the icon didn’t match the background color of the rest of the category.

BattlEye and Microsoft have found incompatibility issues due to changes in the operating system between some Insider Preview builds and certain versions of BattlEye anti-cheat software. To safeguard Insiders who might have these versions installed on their PC, we have applied a compatibility hold on these devices from being offered affected builds of Windows Insider Preview. See this article for details.
We’re investigating an issue where initiating “Reset this PC” with the cloud download option isn’t working on this build or the previous one when started from Windows RE.
We’ve heard that Settings still isn’t available outside of launching via the URI (ms-settings:) for some Insiders and are investigating.
When using dark theme, the hardware keyboard text prediction candidate window is unreadable due to black text on a dark grey background.
Bluetooth devices may not reconnect as expected after closing the device lid for certain devices. We’re working on a fix, but in the meantime, you can toggle Bluetooth off and back on in the Settings app or reboot the device and that should resolve the issue.
Some Insiders are still reporting that after successfully updating to a new build, the Windows Update Settings page may show the same build needs to install. You can verify the build was successfully installed by checking the build number in the corner of the screen or going to Win + R, typing winver, and confirming the build number. We’re investigating this issue.
Some Insiders are still reporting that when viewing Optional drivers in the new section on the Windows Update page, there may be older drivers showing as available for download. If accepted, they will attempt to install and fail to do so. We’re investigating this issue.
[ADDED] We’re investigating reports of frames being skipped, starting with Build 19002, when running games and videos fullscreen.
[ADDED] Preinstalled apps (like Calculator) are missing from the Apps & Features page in Settings.
[ADDED] If you use remote desktop connection and the target PC is on this build, within about an hour (if not sooner), DWM may start crashing, and the session window will either go totally black, experience black flashes, or you may get signed out of the remote desktop session altogether.

Another Windows Insider Program 5th Anniversary surprise is coming soon for our Windows Insiders, but you have to be flighting to receive it. Start flighting by October 31st to earn your next badge!

Are you ready to get spooky? Our Halloween feature provides you with the best costumes, recipes, crafts, movies, and so much more. Whether it’s throwing a Halloween party or winning the best costume, you can do it all with Bing!
If you want to be among the first to learn about these Bing features, join our Bing Insiders Program.
Thanks,BLB

Windows 10 SDK Preview Build 19002 available now! – Windows Developer Blog

Today, we released a new Windows 10 Preview Build of the SDK to be used in conjunction with Windows 10 Insider Preview (Build 19002 or greater). The Preview SDK Build 19002 contains bug fixes and under development changes to the API surface area.The Preview SDK can be downloaded from developer section on Windows Insider.
For feedback and updates to the known issues, please see the developer forum. For new developer feature requests, head over to our Windows Platform UserVoice.

This build works in conjunction with previously released SDKs and Visual Studio 2017 and 2019. You can install this SDK and still also continue to submit your apps that target Windows 10 build 1903 or earlier to the Microsoft Store.
The Windows SDK will now formally only be supported by Visual Studio 2017 and greater. You can download the Visual Studio 2019 here.
This build of the Windows SDK will install on only on Windows 10 Insider Preview builds.
In order to assist with script access to the SDK, the ISO will also be able to be accessed through the following static URL: https://software-download.microsoft.com/download/sg/Windows_InsiderPreview_SDK_en-us_19002_1.iso.

Message Compiler (mc.exe)
Now detects the Unicode byte order mark (BOM) in .mc files. If the If the .mc file starts with a UTF-8 BOM, it will be read as a UTF-8 file. Otherwise, if it starts with a UTF-16LE BOM, it will be read as a UTF-16LE file. If the -u parameter was specified, it will be read as a UTF-16LE file. Otherwise, it will be read using the current code page (CP_ACP).
Now avoids one-definition-rule (ODR) problems in MC-generated C/C++ ETW helpers caused by conflicting configuration macros (e.g. when two .cpp files with conflicting definitions of MCGEN_EVENTWRITETRANSFER are linked into the same binary, the MC-generated ETW helpers will now respect the definition of MCGEN_EVENTWRITETRANSFER in each .cpp file instead of arbitrarily picking one or the other).
Windows Trace Preprocessor (tracewpp.exe)
Now supports Unicode input (.ini, .tpl, and source code) files. Input files starting with a UTF-8 or UTF-16 byte order mark (BOM) will be read as Unicode. Input files that do not start with a BOM will be read using the current code page (CP_ACP). For backwards-compatibility, if the -UnicodeIgnore command-line parameter is specified, files starting with a UTF-16 BOM will be treated as empty.
Now supports Unicode output (.tmh) files. By default, output files will be encoded using the current code page (CP_ACP). Use command-line parameters -cp:UTF-8 or -cp:UTF-16 to generate Unicode output files.
Behavior change: tracewpp now converts all input text to Unicode, performs processing in Unicode, and converts output text to the specified output encoding. Earlier versions of tracewpp avoided Unicode conversions and performed text processing assuming a single-byte character set. This may lead to behavior changes in cases where the input files do not conform to the current code page. In cases where this is a problem, consider converting the input files to UTF-8 (with BOM) and/or using the -cp:UTF-8 command-line parameter to avoid encoding ambiguity.
TraceLoggingProvider.h
Now avoids one-definition-rule (ODR) problems caused by conflicting configuration macros (e.g. when two .cpp files with conflicting definitions of TLG_EVENT_WRITE_TRANSFER are linked into the same binary, the TraceLoggingProvider.h helpers will now respect the definition of TLG_EVENT_WRITE_TRANSFER in each .cpp file instead of arbitrarily picking one or the other).
In C++ code, the TraceLoggingWrite macro has been updated to enable better code sharing between similar events using variadic templates.
Signing your apps with Device Guard Signing

We have stood up a NuGet feed for the flighted builds of the SDK. You can now test preliminary builds of the Windows 10 WinRT API Pack, as well as a microsoft.windows.sdk.headless.contracts NuGet package.
We use the following feed to flight our NuGet packages.
Microsoft.Windows.SDK.Contracts which can be used with to add the latest Windows Runtime APIs support to your .NET Framework 4.5+ and .NET Core 3.0+ libraries and apps.
The Windows 10 WinRT API Pack enables you to add the latest Windows Runtime APIs support to your .NET Framework 4.5+ and .NET Core 3.0+ libraries and apps.
Microsoft.Windows.SDK.Headless.Contracts provides a subset of the Windows Runtime APIs for console apps excludes the APIs associated with a graphical user interface. This NuGet is used in conjunction with
Windows ML container development. Check out the Getting Started guide for more information.

Removal of api-ms-win-net-isolation-l1-1-0.lib
In this release api-ms-win-net-isolation-l1-1-0.lib has been removed from the Windows SDK. Apps that were linking against api-ms-win-net-isolation-l1-1-0.lib can switch to OneCoreUAP.lib as a replacement.
Removal of IRPROPS.LIB
In this release irprops.lib has been removed from the Windows SDK. Apps that were linking against irprops.lib can switch to bthprops.lib as a drop-in replacement.
Removal of WUAPICommon.H and WUAPICommon.IDL
In this release we have moved ENUM tagServerSelection from WUAPICommon.H to wupai.h and removed the header. If you would like to use the ENUM tagServerSelection, you will need to include wuapi.h or wuapi.idl.

The following APIs have been added to the platform since the release of Windows 10 SDK, version 1903, build 18362.
Additions:

namespace Windows.AI.MachineLearning {
public sealed class LearningModelSessionOptions {
bool CloseModelOnSessionCreation { get; set; }
}
}
namespace Windows.ApplicationModel {
public sealed class AppInfo {
public static AppInfo Current { get; }
Package Package { get; }
public static AppInfo GetFromAppUserModelId(string appUserModelId);
public static AppInfo GetFromAppUserModelIdForUser(User user, string appUserModelId);
}
public interface IAppInfoStatics
public sealed class Package {
StorageFolder EffectiveExternalLocation { get; }
string EffectiveExternalPath { get; }
string EffectivePath { get; }
string InstalledPath { get; }
bool IsStub { get; }
StorageFolder MachineExternalLocation { get; }
string MachineExternalPath { get; }
string MutablePath { get; }
StorageFolder UserExternalLocation { get; }
string UserExternalPath { get; }
IVectorView GetAppListEntries();
RandomAccessStreamReference GetLogoAsRandomAccessStreamReference(Size size);
}
}
namespace Windows.ApplicationModel.AppService {
public enum AppServiceConnectionStatus {
AuthenticationError = 8,
DisabledByPolicy = 10,
NetworkNotAvailable = 9,
WebServiceUnavailable = 11,
}
public enum AppServiceResponseStatus {
AppUnavailable = 6,
AuthenticationError = 7,
DisabledByPolicy = 9,
NetworkNotAvailable = 8,
WebServiceUnavailable = 10,
}
public enum StatelessAppServiceResponseStatus {
AuthenticationError = 11,
DisabledByPolicy = 13,
NetworkNotAvailable = 12,
WebServiceUnavailable = 14,
}
}
namespace Windows.ApplicationModel.Background {
public sealed class BackgroundTaskBuilder {
void SetTaskEntryPointClsid(Guid TaskEntryPoint);
}
public sealed class BluetoothLEAdvertisementPublisherTrigger : IBackgroundTrigger {
bool IncludeTransmitPowerLevel { get; set; }
bool IsAnonymous { get; set; }
IReference PreferredTransmitPowerLevelInDBm { get; set; }
bool UseExtendedFormat { get; set; }
}
public sealed class BluetoothLEAdvertisementWatcherTrigger : IBackgroundTrigger {
bool AllowExtendedAdvertisements { get; set; }
}
}
namespace Windows.ApplicationModel.ConversationalAgent {
public sealed class ActivationSignalDetectionConfiguration
public enum ActivationSignalDetectionTrainingDataFormat
public sealed class ActivationSignalDetector
public enum ActivationSignalDetectorKind
public enum ActivationSignalDetectorPowerState
public sealed class ConversationalAgentDetectorManager
public sealed class DetectionConfigurationAvailabilityChangedEventArgs
public enum DetectionConfigurationAvailabilityChangeKind
public sealed class DetectionConfigurationAvailabilityInfo
public enum DetectionConfigurationTrainingStatus
}
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataPackage {
event TypedEventHandler ShareCanceled;
}
}
namespace Windows.Devices.Bluetooth {
public sealed class BluetoothAdapter {
bool IsExtendedAdvertisingSupported { get; }
uint MaxAdvertisementDataLength { get; }
}
}
namespace Windows.Devices.Bluetooth.Advertisement {
public sealed class BluetoothLEAdvertisementPublisher {
bool IncludeTransmitPowerLevel { get; set; }
bool IsAnonymous { get; set; }
IReference PreferredTransmitPowerLevelInDBm { get; set; }
bool UseExtendedAdvertisement { get; set; }
}
public sealed class BluetoothLEAdvertisementPublisherStatusChangedEventArgs {
IReference SelectedTransmitPowerLevelInDBm { get; }
}
public sealed class BluetoothLEAdvertisementReceivedEventArgs {
BluetoothAddressType BluetoothAddressType { get; }
bool IsAnonymous { get; }
bool IsConnectable { get; }
bool IsDirected { get; }
bool IsScannable { get; }
bool IsScanResponse { get; }
IReference TransmitPowerLevelInDBm { get; }
}
public enum BluetoothLEAdvertisementType {
Extended = 5,
}
public sealed class BluetoothLEAdvertisementWatcher {
bool AllowExtendedAdvertisements { get; set; }
}
public enum BluetoothLEScanningMode {
None = 2,
}
}
namespace Windows.Devices.Bluetooth.Background {
public sealed class BluetoothLEAdvertisementPublisherTriggerDetails {
IReference SelectedTransmitPowerLevelInDBm { get; }
}
}
namespace Windows.Devices.Display {
public sealed class DisplayMonitor {
bool IsDolbyVisionSupportedInHdrMode { get; }
}
}
namespace Windows.Devices.Input {
public sealed class PenButtonListener
public sealed class PenDockedEventArgs
public sealed class PenDockListener
public sealed class PenTailButtonClickedEventArgs
public sealed class PenTailButtonDoubleClickedEventArgs
public sealed class PenTailButtonLongPressedEventArgs
public sealed class PenUndockedEventArgs
}
namespace Windows.Devices.Sensors {
public sealed class Accelerometer {
AccelerometerDataThreshold ReportThreshold { get; }
}
public sealed class AccelerometerDataThreshold
public sealed class Barometer {
BarometerDataThreshold ReportThreshold { get; }
}
public sealed class BarometerDataThreshold
public sealed class Compass {
CompassDataThreshold ReportThreshold { get; }
}
public sealed class CompassDataThreshold
public sealed class Gyrometer {
GyrometerDataThreshold ReportThreshold { get; }
}
public sealed class GyrometerDataThreshold
public sealed class Inclinometer {
InclinometerDataThreshold ReportThreshold { get; }
}
public sealed class InclinometerDataThreshold
public sealed class LightSensor {
LightSensorDataThreshold ReportThreshold { get; }
}
public sealed class LightSensorDataThreshold
public sealed class Magnetometer {
MagnetometerDataThreshold ReportThreshold { get; }
}
public sealed class MagnetometerDataThreshold
}
namespace Windows.Foundation.Metadata {
public sealed class AttributeNameAttribute : Attribute
public sealed class FastAbiAttribute : Attribute
public sealed class NoExceptionAttribute : Attribute
}
namespace Windows.Globalization {
public sealed class Language {
string AbbreviatedName { get; }
public static IVector GetMuiCompatibleLanguageListFromLanguageTags(IIterable languageTags);
}
}
namespace Windows.Graphics.Capture {
public sealed class GraphicsCaptureSession : IClosable {
bool IsCursorCaptureEnabled { get; set; }
}
}
namespace Windows.Graphics.DirectX {
public enum DirectXPixelFormat {
SamplerFeedbackMinMipOpaque = 189,
SamplerFeedbackMipRegionUsedOpaque = 190,
}
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicFrame {
HolographicFrameId Id { get; }
}
public struct HolographicFrameId
public sealed class HolographicFrameRenderingReport
public sealed class HolographicFrameScanoutMonitor : IClosable
public sealed class HolographicFrameScanoutReport
public sealed class HolographicSpace {
HolographicFrameScanoutMonitor CreateFrameScanoutMonitor(uint maxQueuedReports);
}
}
namespace Windows.Management.Deployment {
public sealed class AddPackageOptions
public enum DeploymentOptions : uint {
StageInPlace = (uint)4194304,
}
public sealed class PackageManager {
IAsyncOperationWithProgress AddPackageByUriAsync(Uri packageUri, AddPackageOptions options);
IVector FindProvisionedPackages();
PackageStubPreference GetPackageStubPreference(string packageFamilyName);
IAsyncOperationWithProgress RegisterPackageByUriAsync(Uri manifestUri, RegisterPackageOptions options);
IAsyncOperationWithProgress RegisterPackagesByFullNameAsync(IIterable packageFullNames, RegisterPackageOptions options);
void SetPackageStubPreference(string packageFamilyName, PackageStubPreference useStub);
IAsyncOperationWithProgress StagePackageByUriAsync(Uri packageUri, StagePackageOptions options);
}
public enum PackageStubPreference
public enum PackageTypes : uint {
All = (uint)4294967295,
}
public sealed class RegisterPackageOptions
public enum RemovalOptions : uint {
PreserveRoamableApplicationData = (uint)128,
}
public sealed class StagePackageOptions
public enum StubPackageOption
}
namespace Windows.Media.Audio {
public sealed class AudioPlaybackConnection : IClosable
public sealed class AudioPlaybackConnectionOpenResult
public enum AudioPlaybackConnectionOpenResultStatus
public enum AudioPlaybackConnectionState
}
namespace Windows.Media.Capture {
public sealed class MediaCapture : IClosable {
MediaCaptureRelativePanelWatcher CreateRelativePanelWatcher(StreamingCaptureMode captureMode, DisplayRegion displayRegion);
}
public sealed class MediaCaptureInitializationSettings {
Uri DeviceUri { get; set; }
PasswordCredential DeviceUriPasswordCredential { get; set; }
}
public sealed class MediaCaptureRelativePanelWatcher : IClosable
}
namespace Windows.Media.Capture.Frames {
public sealed class MediaFrameSourceInfo {
Panel GetRelativePanel(DisplayRegion displayRegion);
}
}
namespace Windows.Media.Devices {
public sealed class PanelBasedOptimizationControl
}
namespace Windows.Media.MediaProperties {
public static class MediaEncodingSubtypes {
public static string Pgs { get; }
public static string Srt { get; }
public static string Ssa { get; }
public static string VobSub { get; }
}
public sealed class TimedMetadataEncodingProperties : IMediaEncodingProperties {
public static TimedMetadataEncodingProperties CreatePgs();
public static TimedMetadataEncodingProperties CreateSrt();
public static TimedMetadataEncodingProperties CreateSsa(byte[] formatUserData);
public static TimedMetadataEncodingProperties CreateVobSub(byte[] formatUserData);
}
}
namespace Windows.Networking.BackgroundTransfer {
public sealed class DownloadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void RemoveRequestHeader(string headerName);
void SetRequestHeader(string headerName, string headerValue);
}
public sealed class UploadOperation : IBackgroundTransferOperation, IBackgroundTransferOperationPriority {
void RemoveRequestHeader(string headerName);
void SetRequestHeader(string headerName, string headerValue);
}
}
namespace Windows.Networking.Connectivity {
public enum NetworkAuthenticationType {
Owe = 12,
}
}
namespace Windows.Networking.NetworkOperators {
public sealed class NetworkOperatorTetheringAccessPointConfiguration {
TetheringWiFiBand Band { get; set; }
bool IsBandSupported(TetheringWiFiBand band);
IAsyncOperation IsBandSupportedAsync(TetheringWiFiBand band);
}
public sealed class NetworkOperatorTetheringManager {
public static void DisableNoConnectionsTimeout();
public static IAsyncAction DisableNoConnectionsTimeoutAsync();
public static void EnableNoConnectionsTimeout();
public static IAsyncAction EnableNoConnectionsTimeoutAsync();
public static bool IsNoConnectionsTimeoutEnabled();
}
public enum TetheringWiFiBand
}
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static event EventHandler ChannelsRevoked;
}
public sealed class PushNotificationChannelsRevokedEventArgs
public sealed class RawNotification {
IBuffer ContentBytes { get; }
}
}
namespace Windows.Security.Authentication.Web.Core {
public sealed class WebAccountMonitor {
event TypedEventHandler AccountPictureUpdated;
}
}
namespace Windows.Security.Isolation {
public sealed class IsolatedWindowsEnvironment
public enum IsolatedWindowsEnvironmentActivator
public enum IsolatedWindowsEnvironmentAllowedClipboardFormats : uint
public enum IsolatedWindowsEnvironmentAvailablePrinters : uint
public enum IsolatedWindowsEnvironmentClipboardCopyPasteDirections : uint
public struct IsolatedWindowsEnvironmentContract
public struct IsolatedWindowsEnvironmentCreateProgress
public sealed class IsolatedWindowsEnvironmentCreateResult
public enum IsolatedWindowsEnvironmentCreateStatus
public sealed class IsolatedWindowsEnvironmentFile
public static class IsolatedWindowsEnvironmentHost
public enum IsolatedWindowsEnvironmentHostError
public sealed class IsolatedWindowsEnvironmentLaunchFileResult
public enum IsolatedWindowsEnvironmentLaunchFileStatus
public sealed class IsolatedWindowsEnvironmentOptions
public static class IsolatedWindowsEnvironmentOwnerRegistration
public sealed class IsolatedWindowsEnvironmentOwnerRegistrationData
public sealed class IsolatedWindowsEnvironmentOwnerRegistrationResult
public enum IsolatedWindowsEnvironmentOwnerRegistrationStatus
public sealed class IsolatedWindowsEnvironmentProcess
public enum IsolatedWindowsEnvironmentProcessState
public enum IsolatedWindowsEnvironmentProgressState
public sealed class IsolatedWindowsEnvironmentShareFolderRequestOptions
public sealed class IsolatedWindowsEnvironmentShareFolderResult
public enum IsolatedWindowsEnvironmentShareFolderStatus
public sealed class IsolatedWindowsEnvironmentStartProcessResult
public enum IsolatedWindowsEnvironmentStartProcessStatus
public sealed class IsolatedWindowsEnvironmentTelemetryParameters
public static class IsolatedWindowsHostMessenger
public delegate void MessageReceivedCallback(Guid receiverId, IVectorView message);
}
namespace Windows.Storage {
public static class KnownFolders {
public static IAsyncOperation GetFolderAsync(KnownFolderId folderId);
public static IAsyncOperation RequestAccessAsync(KnownFolderId folderId);
public static IAsyncOperation RequestAccessForUserAsync(User user, KnownFolderId folderId);
}
public enum KnownFoldersAccessStatus
public sealed class StorageFile : IInputStreamReference, IRandomAccessStreamReference, IStorageFile, IStorageFile2, IStorageFilePropertiesWithAvailability, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
public static IAsyncOperation GetFileFromPathForUserAsync(User user, string path);
}
public sealed class StorageFolder : IStorageFolder, IStorageFolder2, IStorageFolderQueryOperations, IStorageItem, IStorageItem2, IStorageItemProperties, IStorageItemProperties2, IStorageItemPropertiesWithProvider {
public static IAsyncOperation GetFolderFromPathForUserAsync(User user, string path);
}
}
namespace Windows.Storage.Provider {
public sealed class StorageProviderFileTypeInfo
public sealed class StorageProviderSyncRootInfo {
IVector FallbackFileTypeInfo { get; }
}
public static class StorageProviderSyncRootManager {
public static bool IsSupported();
}
}
namespace Windows.System {
public sealed class UserChangedEventArgs {
IVectorView ChangedPropertyKinds { get; }
}
public enum UserWatcherUpdateKind
}
namespace Windows.UI.Composition.Interactions {
public sealed class InteractionTracker : CompositionObject {
int TryUpdatePosition(Vector3 value, InteractionTrackerClampingOption option, InteractionTrackerPositionUpdateOption posUpdateOption);
}
public enum InteractionTrackerPositionUpdateOption
}
namespace Windows.UI.Input {
public sealed class CrossSlidingEventArgs {
uint ContactCount { get; }
}
public sealed class DraggingEventArgs {
uint ContactCount { get; }
}
public sealed class GestureRecognizer {
uint HoldMaxContactCount { get; set; }
uint HoldMinContactCount { get; set; }
float HoldRadius { get; set; }
TimeSpan HoldStartDelay { get; set; }
uint TapMaxContactCount { get; set; }
uint TapMinContactCount { get; set; }
uint TranslationMaxContactCount { get; set; }
uint TranslationMinContactCount { get; set; }
}
public sealed class HoldingEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
}
public sealed class ManipulationCompletedEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
}
public sealed class ManipulationInertiaStartingEventArgs {
uint ContactCount { get; }
}
public sealed class ManipulationStartedEventArgs {
uint ContactCount { get; }
}
public sealed class ManipulationUpdatedEventArgs {
uint ContactCount { get; }
uint CurrentContactCount { get; }
}
public sealed class RightTappedEventArgs {
uint ContactCount { get; }
}
public sealed class SystemButtonEventController : AttachableInputObject
public sealed class SystemFunctionButtonEventArgs
public sealed class SystemFunctionLockChangedEventArgs
public sealed class SystemFunctionLockIndicatorChangedEventArgs
public sealed class TappedEventArgs {
uint ContactCount { get; }
}
}
namespace Windows.UI.Input.Inking {
public sealed class InkModelerAttributes {
bool UseVelocityBasedPressure { get; set; }
}
}
namespace Windows.UI.Text {
public enum RichEditMathMode
public sealed class RichEditTextDocument : ITextDocument {
void GetMath(out string value);
void SetMath(string value);
void SetMathMode(RichEditMathMode mode);
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
bool CriticalInputMismatch { get; set; }
bool TemporaryInputMismatch { get; set; }
void ApplyApplicationUserModelID(string value);
}
public sealed class UISettings {
event TypedEventHandler AnimationsEnabledChanged;
event TypedEventHandler MessageDurationChanged;
}
public sealed class UISettingsAnimationsEnabledChangedEventArgs
public sealed class UISettingsMessageDurationChangedEventArgs
}
namespace Windows.UI.ViewManagement.Core {
public sealed class CoreInputView {
event TypedEventHandler PrimaryViewHiding;
event TypedEventHandler PrimaryViewShowing;
}
public sealed class CoreInputViewHidingEventArgs
public enum CoreInputViewKind {
Symbols = 4,
}
public sealed class CoreInputViewShowingEventArgs
public sealed class UISettingsController
}

Announcing Windows 10 Insider Preview Build 19002 | Windows Experience Blog

UPDATE 10/18: We have released 20H1 Build 19002.1002, which includes a fix for the issue causing some devices to get stuck during shutdown or restart.Hello Windows Insiders, today we’re releasing Windows 10 Insider Preview Build 19002 (20H1) to Windows Insiders in the Fast ring.
IMPORTANT: As is normal with pre-release builds, these builds may contain bugs that might be painful for some. If you take this flight, you won’t be able to switch Slow or Release Preview rings without doing a clean-install on your PC.
If you want a complete look at what build is in which Insider ring, head over to Flight Hub. You can also check out the rest of our documentation here including a complete list of new features and updates that have gone out as part of Insider flights for the current development cycle.
Not seeing any of the features in this build? Check your Windows Insider Settings to make sure you’re on the Fast ring. Submit feedback here to let us know if things weren’t working the way you expected.

Update on improving your Bluetooth Experience
With Build 18985 we announced we were working on improving our streamlined workflow for pairing your Bluetooth devices. We’re happy to share that this change is now rolling out to 100% of Insiders–thank you to those that have already tried it and shared feedback!

We also wanted to add two new peripherals to our supported device list:

We fixed an issue that could result in upgrades failing with error 0x8007042b.
We fixed an issue resulting in the acrylic effect in the Action Center only appearing after the Action Center opening animation had finished.
We fixed an issue where with multiple monitors and different DPIs, the File Explorer search box could become enlarged and offset.
We fixed an issue with the search indexer resulting in unexpected files being returned as search results when searching using French (France).
We fixed an issue for Japanese users where the user name in the Settings header wasn’t displayed in the correct order.
We fixed an issue resulting in clipboard history, WIN+(Period), and the touch keyboard displaying English text when being used with non-English display languages.
We fixed a rare condition that could result in devices not reconnecting after toggling Bluetooth off and back on.
We fixed an issue resulting in the VPN sometimes not automatically connecting after waking your device from sleep.
We fixed an issue that could result in the brightness getting stuck at 0 or 100% and requiring a reboot before it could be changed.
Text cursor indicator works better in more experiences (e.g. Word, Run dialog, Outlook) now.
The Magnifier centered text cursor option should now work correctly when switching Magnifier modes.
We fixed the mouse pointer visual when using the Magnifier docked mode.
We fixed a bug where Narrator was not saying the state of Scan mode when Edge was opened or closed.
We fixed a bug in Narrator where Narrator sometimes say password twice when focus was in a password edit field.
We fixed a bug in Narrator where scan mode was getting stuck in edit fields in Firefox.
We’ve made some general improvements and bug fixes for the Windows Subsystem for Linux (WSL), please see the WSL release notes for details.
If you were one of the Insiders experiencing frequent explorer.exe crashes recently, please go to the Microsoft Store and check for Xbox game bar app updates (specifically version 3.34.4xx should have the fix). If you’re on this app version and still seeing explorer.exe crashes, please file feedback and we will investigate.
Just a heads up that we’re expanding the rollout of the Settings header to more Insiders, so it may now appear for you when it hadn’t before. As always, we welcome feedback about Settings – in the Feedback Hub you can share it under Desktop Environment > Settings.
[ADDED] For devices that were affected by the Dual Scan issue fixed in Build 18999, you will need to disable WSUS on the device or update from an ISO of Build 18999 or higher, which will be released in the coming weeks.

We’re working on a fix for an issue that started with the previous flight where some devices are getting stuck during shutdown or restart and appreciate your patience. If you’re impacted by this issue, please see this forum post for workaround options.
There has been an issue with older versions of anti-cheat software used with games where after updating to the latest 19H1 Insider Preview builds may cause PCs to experience crashes. We are working with partners on getting their software updated with a fix, and most games have released patches to prevent PCs from experiencing this issue. To minimize the chance of running into this issue, please make sure you are running the latest version of your games before attempting to update the operating system. We are also working with anti-cheat and game developers to resolve similar issues that may arise with the 20H1 Insider Preview builds and will work to minimize the likelihood of these issues in the future.
We’re investigating an issue where initiating “Reset this PC” with the cloud download option isn’t working on this build or the previous one when started from Windows RE.
We’ve heard that Settings still isn’t available outside of launching via the URI (ms-settings:) for some Insiders and are investigating.
When using dark theme, the hardware keyboard text prediction candidate window is unreadable due to black text on a dark grey background.
When optional updates are available, Insiders with the Settings header may see the Windows Update indicator in a warning state, although the main page of Windows Update Settings shows that everything is up to date.
Bluetooth devices may not reconnect as expected after closing the device lid for certain devices. We’re working on a fix, but in the meantime, you can toggle Bluetooth off and back on in the Settings app or reboot the device and that should resolve the issue.

See if you topped our lists on the new September 2019 Windows Insider Leaderboard, and try to make next month’s by giving us feedback for new builds, getting upvotes on your feedback, and completing quests through the Feedback Hub!
Learn more about how you can be on the Leaderboard.

Are you keeping up with the US 2020 Candidates? Bing makes this easy. Learn more about these individuals through Bing’s carousel feature for both Democratic Candidates and  Republican Candidates. Through the carousel, Bing provides you with news articles, opinions, special dates, and videos related to your selected candidate. Stay informed with Bing!
If you want to be among the first to learn about these Bing features, join our Bing Insiders Program. 

Shout out to the Windows Insider Cadenzza on Twitter who is lucky we released Build 19002 today instead of Build 19001, so he doesn’t have to delete his computer. We’re not sure how one deletes an entire computer, but we’re happy he doesn’t have to do this.

If you do that I’ll delete my computer pic.twitter.com/GG3sUbUAQU
— Cadenzza (@cadenzza_) October 8, 2019

Thanks,BLB