Tag Archives: windows sdk

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

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

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

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

More opportunity for your apps and games

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

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

Example of a playable ad running in a UWP game

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

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

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

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

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

Dev Center experience redesign

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

Startup guide for the new dashboard experience

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


Reaching more customers

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

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

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

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

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

Submission page showing progress using import/export Store listings

Planning your release

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

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

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

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

Optimizing pricing and configuring deals and sales

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

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

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

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

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

Dev Center configuration 

How sale pricing appears in the Store

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

Improving analysis

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

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

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

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

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

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

What comes next?

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

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

How the UWP Community Toolkit helps Windows developers easily create well-designed and user-friendly apps

In August 2016, we introduced the open-source UWP Community Toolkit. It simplifies app development and enables developers to collaborate and contribute new capabilities on top of the Windows SDK for Windows 10. Developers can leverage the UWP Community Toolkit to build UWP apps for any Windows 10 device, including PC, mobile, Xbox, the Internet of Things and Hololens.

We recently caught up with two developers who have used the toolkit to help create their apps. Hermit Dave developed the Daily Mail Online app for Windows. It’s the official Windows app for the Daily Mail, a British newspaper. David Bottiau is a member of the Github organization, UWP Squad. He developed a Windows 10 app for TVShow Time, a site that helps you track your favorite TV shows.

We asked them how the UWP Community Toolkit helped them. Here’s what they had to say:

Tell us about the app you built with the help of the UWP toolkit.

Hermit Dave: I joined MailOnline in November 2015 to expand their mobile offering to Windows. After initial talks on Phone + Xbox offering, I suggested the UWP as a means to target all the platforms. After the initial release, Windows was deemed a suitable platform to try out UI + UX tweaks and the current version of the app kicked off in April 2016.

David Bottiau: I really needed a service that offers me a way to track my favorite TV series and animated shows, and I recently discovered the TVShow Time service. I use the beautiful TVShow Time web app really often and I wanted access to the information even faster and closer. So, I decided to bring the service to Windows 10 and Windows 10 Mobile using the existing API provided by TVShow Time team.

Why did you use the UWP Toolkit to help you create your app?

HD: Offline reading and availability is a major requirement for news apps and MailOnline strives to be among the best in news applications. News content often contains images and the toolkit’s ImageEx control proved itself very handy. In addition to offline images, the ability to control cache size is important. I previously created an offline image control and a cache mechanism and the toolkit provided a simple yet very elegant solution for both.

In addition to ImageEx and ImageCache, I have used the toolkit’s CacheBase to create VideoCache (offline animated previews) and ConfigurationCache to ensure they are kept up to date. The toolkit also contains helpers like HttpHelper which makes it easy to talk to Http data sources. I use this to make API calls as needed.

 DB: I started to use it to have access to a larger list of UI controls. Moreover, by simplifying/removing code for repetitive tasks, it helps me focus on the main part of app development. Either it is C# or XAML, I can work quickly and add new features faster.

Was the UWP Toolkit simple to use?

HD: Yes — image control can be replaced by ImageEx and can provide offline capability in one line of XAML code. Others, like creating custom cache helpers, reduces the effort to create similar functionality by a very huge margin.

DB: The UWP Toolkit is really simple to use because the different items (Controls, Helpers) are really well written. Moreover, the documentation goes straight to the point: You can read the markdown files (in GitHub) or as a website (http://docs.uwpcommunitytoolkit.com/).

And if it isn’t clear enough, you can try the sample app that gives a visual of what you can achieve with the code, a simple example that you can copy/paste in your app and a view of the documentation in case you want more explanation and you do not want to switch between the app and the website.

How was the UWP Toolkit helpful to you?

HD: The toolkit helped me to create offline images, custom cache, images, videos, configuration and trending data. Also, HttpHelper to make API calls. In one instance, I needed a card layout with drop shadow, and there’s a control for that, too.

DB: The UWP Toolkit gives me the ability to create beautiful apps in a short period of time and with the minimum effort (minimum code). The HamburgerMenu control allowed me to create the entry point of my application where users can navigate easily between the different pages. The AdaptativeGridView control is perfect for displaying a collection of items, like the collection of TV shows I am currently watching. The control is also useful because the item’s size will be adapted to the screen size; it has never been easier to create an app that looks great on a mobile, a tablet, a PC or even a TV.

The DropShadowPanel control can add some effects to the page/items of the page. I used it to highlight important elements like my TV show collection. Another effect is Blur; to make the app even more beautiful, I added a Blur background image for each show episode so users can get visuals along with the description of the episode. And the Helpers can reduce the amount of code needed to read/save data in the application, to register background tasks or even to push notifications.

To simplify, it is the combination of the current Windows 10 SDK and the added elements in UWP Community Toolkit that helped me to achieved a really beautiful app with the least effort.

Did you run into any glitches or issues in creating your app? If so, what were they?

HD: There are always glitches in code. I often refer to them as features. I contributed to the toolkit in places I thought it could do better.

Hermit Dave 

DB: I remember that there was a bug with the HamburgerMenu in v1.1. The property SelectedIndex could not be changed in code-behind. I really wanted to the ability to change the value and I did not understand why it wasn’t possible. So, I checked in the GitHub repository to see if they can fix that. The fact is that it was already fixed, and the update HamburgerMenu was then published in v1.2.

Did the UWP Toolkit make it easier for you to develop your apps and push them onto the app store? Why or why not?

HD: If I was hand-crafting the functionality in the toolkit — the bits I use — my effort would have increased significantly. The toolkit helps by offering building blocks that help you go from 0 to 60 in seconds.

DB: Whatever Windows 10 application you are doing, you’ll find at least one great thing in the toolkit. It could be a UI control, an animation/effect behavior, a simple method to access the LocalStorage, or a rich structure to create notifications.

Dave Bottiau

Do you have any suggestions on how the Toolkit could be improved?

HD: It’s a community toolkit. If there are things you think it can do better, do not hesitate to say so. Raise an issue, push a PR to make it better. Raise user voice for items you think the toolkit should add.

DB: I think developers still have go through a lot of effort to understand and create great animations. The Composition API is a really nice improvement to the Windows SDK and it will continue to grow and offer more features — but it should be also simple to make animations. The Toolkit added some great stuff like the Blur effect and the reorder grid animation. These are good enhancement but at the same time can be better. I heard that the Windows/XAML team is working on the simplification of the animation system and I am happy to hear it. I hope the Toolkit will be improved as well with this future evolution.

What advice would you give to other developers who want to develop UWP apps?

HD: The UWP SDK, the toolkit and Visual Studio make app development a joy. The toolkit allows you to re-use helpers, converters, extension methods, and components not in the SDK.

DB: If you want to develop a great UWP app and need some inspiration for User Interface, you can download the sample app of the UWP Community Toolkit and check UI Controls and Animations. Let the magic happen!

Are there any tips about the UWP toolkit that you can share with other devs? If so, what are they?

HD: The toolkit is much more than controls. There are tons of services, helpers, converters, extensions. There’s a library just for animations, which simplifies the use of Composition API.

DB: I’ll give only one tip: Please visit the GitHub repository and share with the other contributors.

Using SQLite databases in UWP apps

For many developers, SQLite has become the preferred client-side technology for data storage. It is a server-less, embedded, open-source database engine that satisfies most local data access scenarios. There are numerous advantages that come with its use, many of which are explained in the SQLite about page.

Since the Windows 10 Anniversary Update (Build 14393), SQLite has also shipped as part of the Windows SDK. This means that when you are building your Universal Windows Platform (UWP) app that runs across the different Windows device form factors, you can take advantage of the SDK version of SQLite for local data storage. This comes with some advantages:

  • Your application size reduces since you don’t download your own SQLite binary and package it as part of your application
    • Note: Microsoft.Data.SQLite (used in the example below) currently has an issue where both SQLite3.dll and WinSQLite.dll are loaded in memory whenever a .NET Native version of your application is run. This is a tracked issue that will be addressed in subsequent updates of the library.
  • You can depend on the Windows team to update the version of SQLite running on the operating system with every release of Windows.
  • Application load time has the potential to be faster since the SDK version of SQLite will likely already be loaded in memory.

Below, we provided a quick coding example on how to consume the SDK version of SQLite in your C# application.

Note: Since the Windows SDK version of SQLite has only been available since the Windows 10 Anniversary Update, it can only be used for UWP apps targeting Build 14393 or higher.

C# Example

In this example, we will build a UWP application that will allow users to input text into an app local database. The goal is to provide developers with concise guidance on how to use the SQLite binary that’s shipped as part of the Windows SDK. Therefore this code sample is meant to be as simple as possible, so as to provide a foundation that can be further built upon.

An example of the end product is shown below:

SQLite C# API Wrappers

As mentioned in the SQLite documentation, the API provided by SQLite is fairly low-level and can add an additional level of complexity for the developer. Because of this, many open-source libraries have been produced to act as wrappers around the core SQLite API. These libraries abstract away a lot of the core details behind SQLite, allowing developers to more directly deal with executing SQL statements and parsing the results.

For SQLite consumption across Windows, we recommend the open-source Microsoft.Data.Sqlite library built by the ASP.NET team. It is actively being maintained and provides an intuitive wrapper around the SQLite API. The rest of the example assumes use of the Microsoft.Data.Sqlite library.

Alternative SQLite wrappers are also linked in the “Additional Resources” section below.

Visual Studio set-up

The packages used in this sample have a dependency on NuGet version 3.5 or greater. You can check your version of NuGet by going to HelpAbout Microsoft Visual Studio and looking through the Installed Products for NuGet Package Manager. You can go to the NuGet download page and grab the version 3.5 VSIX update if you have a lower version.

Note: Visual Studio 2015 Update 3 is pre-installed with NuGet version 3.4, and will likely require an upgrade. Visual Studio 2017 RC is installed with NuGet version 4.0, which works fine for this sample.

Adding Microsoft.Data.Sqlite and upgrading the .NET Core template

The Microsoft.Data.Sqlite package relies on at least the 5.2.2 version of .NET Core for UWP, so we’ll begin by upgrading this:

  • Right click on ReferencesManage NuGet Packages
  • Under the Installed tab, look for the Microsoft.NETCore.UniversalWindowsPlatform package and check the version number on the right-hand side. If it’s not up to date, you’ll be able to update to version 5.2.2 or higher.

Note: Version 5.2.2 is the default for VS 2017 RC. Therefore, this step is not required if you are using this newest version of Visual Studio.

To add the Microsoft.Data.Sqlite NuGet package to your application, follow a similar pattern:

  • Right-click on ReferencesManage NuGet Packages
  • Under the Browse tab, search for the Microsoft.Data.Sqlite package and install it.

Code

Application User Interface

We’ll start off by making a simple UI for our application so we can see how to add and retrieve entries from our SQLite database.


<Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
    <StackPanel>
        <TextBox Name="Input_Box"></TextBox>
        <Button Click="Add_Text">Add</Button>
        <ListView Name="Output">
            <ListView.ItemTemplate>
                <DataTemplate>
                    <TextBlock Text="{Binding}"/>
                </DataTemplate>
            </ListView.ItemTemplate>
        </ListView>
    </StackPanel>
</Grid>

There are three important parts to our application’s interface:

  1. A text box that allows us to take text from the user.
  2. A button linked to an event for pulling the text and placing it in the SQLite database.
  3. An ItemTemplate to show previous entries in the database.

Code Behind for Application

In the App.xaml.cs and MainPage.xaml.cs files generated by Visual Studio, we’ll start by importing the Microsoft.Data.Sqlite namespaces that we’ll be using.


using Microsoft.Data.Sqlite;
using Microsoft.Data.Sqlite.Internal;

Then as part of the app constructor, we’ll run a “CREATE TABLE IF NOT EXISTS” command to guarantee that the SQLite .db file and table are created the first time the application is launched.


public App()
{
    this.InitializeComponent();
    this.Suspending += OnSuspending;
    SqliteEngine.UseWinSqlite3(); //Configuring library to use SDK version of SQLite
    using (SqliteConnection db = new SqliteConnection("Filename=sqliteSample.db"))
    {
        db.Open();
        String tableCommand = "CREATE TABLE IF NOT EXISTS MyTable (Primary_Key INTEGER PRIMARY KEY AUTOINCREMENT, Text_Entry NVARCHAR(2048) NULL)";
        SqliteCommand createTable = new SqliteCommand(tableCommand, db);
        try
        {
        createTable.ExecuteReader();
        }
        catch (SqliteException e)
        {
            //Do nothing
        }
    }
} 

There are couple of points worth noting with this code:

  1. We make a call to SqliteEngine.UseWinSqlite3() before making any other SQL calls, which guarantees that the Microsoft.Data.Sqlite framework will use the SDK version of SQLite as opposed to a local version.
  2. We then open a connection to a SQLite .db file. The name of the file passed as a String is your choice, but should be consistent across all SqliteConnection objects. This file is created on the fly the first time it’s called, and is stored in the application’s local data store.
  3. After establishing the connection to the database, we instantiate a SqliteCommand object passing in a String representing the specific command and the SqliteConnection instance, and call execute.
  4. We place the ExecuteReader() call inside a try-catch block. This is because SQLite will always throw a SqliteException whenever it can’t execute the SQL command. Not getting the error confirms that the command went through correctly.

Next, we’ll add code in the View’s code-behind file to handle the button-clicked event. This will take text from the text box and put it into our SQLite database.


private void Add_Text(object sender, RoutedEventArgs e)
{
    using (SqliteConnection db = new SqliteConnection("Filename=sqliteSample.db"))
    {
        db.Open();

        SqliteCommand insertCommand = new SqliteCommand();
        insertCommand.Connection = db;
                
        //Use parameterized query to prevent SQL injection attacks
        insertCommand.CommandText = "INSERT INTO MyTable VALUES (NULL, @Entry);";
        insertCommand.Parameters.AddWithValue("@Entry", Input_Box.Text);        

try
        {
            insertCommand.ExecuteReader();
        }
        catch (SqliteException error)
        {
            //Handle error
            return;
        }
        db.Close();
    }
    Output.ItemsSource = Grab_Entries();
}

As you can see, this isn’t drastically different than the SQLite code explained in the app’s constructor above. The only major deviation is the use of parameters in the query so as to prevent SQL injection attacks. You will find that commands that make changes to the database (i.e. creating tables, or inserting entries) will mostly follow the same logic.

Finally, we go to the implementation of the Grab_Entries() method, where we grab all the entries from the Text_Entry column and fill in the XAML template with this information.


private List<String> Grab_Entries()
{
    List<String> entries = new List<string>();
    using (SqliteConnection db = new SqliteConnection("Filename=sqliteSample.db"))
    {
        db.Open();
        SqliteCommand selectCommand = new SqliteCommand("SELECT Text_Entry from MyTable", db);
        SqliteDataReader query;
        try
        {
            query = selectCommand.ExecuteReader();
        }
        catch(SqliteException error)
        {
            //Handle error
            return entries;
        }
        while(query.Read())
        {
            entries.Add(query.GetString(0));
        }
        db.Close();
    }
    return entries;
}

Here, we take advantage of the SqliteDataReader object returned from the ExecuteReader() method to run through the results and add them to the List we eventually return. There are two methods worth pointing out:

  1. The Read() method advances through the rows returned back from the executed SQLite command, and returns a boolean based on whether you’ve reached the end of the query or not (True if there are more rows left, and False if you’ve reached the end).
  2. The GetString() method returns the value of the specified column as a String. It takes in one parameter, an int that represents the zero-based column ordinal. There are similar methods like GetDataTime() and GetBoolean() that you can use based on the data type of the column that you are dealing with.
    1. The ordinal parameter isn’t as relevant in this example since we are selecting all the entries in a single column. However, in the case where multiple columns are part of the query, the ordinal represents the column you are pulling from. So if we selected both Primary_Key and Text_Entry, then GetString(0) would return the value of Primary_Key String and GetString(1) would return the value of Text_Entry as a String.

And that’s it! You can now build your application and add any text you like into your SQLite database. You can even close and open your application to see that the data persists.

A link to the full code can be found at: https://github.com/Microsoft/windows-developer-blog-samples/tree/master/Samples/SQLiteSample

Moving Forward

There are plenty of additions that you can make to tailor this sample to your needs:

  • Adding more tables and more complicated queries.
  • Providing more sanitation over the text entries to prevent faulty user input.
  • Communicating with your database in the cloud to propagate information across devices.
  • And so much more!

What about Entity Framework?

For those developers looking to abstract away particular database details, Microsoft’s Entity Framework provides a great model that lets you work at the “Object” layer as opposed to the database access layer. You can create models for your database using code, or visually define your model in the EF designer. Then Entity Framework makes it super-easy to generate a database from your defined object model. It’s also possible to map your models to existing databases you may have already created.

SQLite is one of many database back-ends that Entity Framework is configured to work with. This documentation provides an example to work from.

Conclusion

From embedded applications for Windows 10 IoT Core to a cache for enterprise relations database server (RDBS) data, SQLite is the premier choice for any application that needs local storage support. SQLite’s server-less and self-contained architecture makes it compact and easy to manage, while its tried and tested API surface coupled with its massive community support provides additional ease of use. And since it ships as part of Windows 10, you can have peace of mind, knowing that you’re always using an up-to-date version of the binary.

As always, please leave any questions in the comments section, and we’ll try our best to answer them. Additional resources are also linked below.

Additional Resources

Windows 10 SDK Preview Build 15021 Released

Today, we released a new Windows 10 Creators Update SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 15021 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 15021 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Things to note:

What’s New

Known Issues Windows SDK

  • There are no known issues with the SDK and emulator

API Updates and Additions

The following API changes are under development and new, or updated for this release of the SDK.

namespace Windows.ApplicationModel.Preview.Notes {
public sealed class NotesWindowManagerPreview {
void SetFocusToPreviousView();
IAsyncAction SetThumbnailImageForTaskSwitcherAsync(SoftwareBitmap bitmap);
void ShowNoteRelativeTo(int noteViewId, int anchorNoteViewId, NotesWindowManagerPreviewShowNoteOptions options);
void ShowNoteWithPlacement(int noteViewId, IBuffer data, NotesWindowManagerPreviewShowNoteOptions options);
}
public sealed class NotesWindowManagerPreviewShowNoteOptions
}
namespace Windows.Devices.Gpio {
public struct GpioChangeCount
public sealed class GpioChangeCounter : IClosable
public enum GpioChangePolarity
public sealed class GpioChangeReader : IClosable
public struct GpioChangeRecord
public enum GpioOpenStatus {
MuxingConflict = 3,
UnknownError = 4,
}
}
namespace Windows.Devices.I2c {
public enum I2cTransferStatus {
ClockStretchTimeout = 3,
UnknownError = 4,
}
}
namespace Windows.Devices.Pwm {
public sealed class PwmController {
public static IAsyncOperation<PwmController> FromIdAsync(string deviceId);
public static string GetDeviceSelector();
public static string GetDeviceSelector(string friendlyName);
}
}
namespace Windows.Devices.SmartCards {
public sealed class SmartCardTriggerDetails {
SmartCard SmartCard { get; }
}
}
namespace Windows.Devices.SmartCards {
public enum SmartCardCryptogramAlgorithm {
Sha256Hmac = 8,
}
public sealed class SmartCardCryptogramGenerator {
IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult> GetAllCryptogramMaterialCharacteristicsAsync(SmartCardUnlockPromptingBehavior promptingBehavior, string materialPackageName);
IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync();
IAsyncOperation<SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult> GetAllCryptogramMaterialPackageCharacteristicsAsync(string storageKeyName);
IAsyncOperation<SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult> GetAllCryptogramStorageKeyCharacteristicsAsync();
IAsyncOperation<SmartCardCryptogramGeneratorOperationStatus> ValidateRequestApduAsync(SmartCardUnlockPromptingBehavior promptingBehavior, IBuffer apduToValidate, IIterable<SmartCardCryptogramPlacementStep> cryptogramPlacementSteps);
}
public enum SmartCardCryptogramGeneratorOperationStatus {
ValidationFailed = 12,
}
public sealed class SmartCardCryptogramGetAllCryptogramMaterialCharacteristicsResult
public sealed class SmartCardCryptogramGetAllCryptogramMaterialPackageCharacteristicsResult
public sealed class SmartCardCryptogramGetAllCryptogramStorageKeyCharacteristicsResult
public sealed class SmartCardCryptogramMaterialCharacteristics
public sealed class SmartCardCryptogramMaterialPackageCharacteristics
public enum SmartCardCryptogramMaterialProtectionMethod
public sealed class SmartCardCryptogramStorageKeyCharacteristics
}
namespace Windows.Foundation.Metadata {
public sealed class FeatureAttribute : Attribute
public enum FeatureStage
}
namespace Windows.ApplicationModel {
public sealed class Package {
IAsyncOperation<PackageContentGroup> GetContentGroupAsync(string name);
IAsyncOperation<IVector<PackageContentGroup>> GetContentGroupsAsync();
IAsyncOperation<bool> SetInUseAsync(bool inUse);
IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names);
IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names, bool moveToHeadOfQueue);
}
public sealed class PackageCatalog {
event TypedEventHandler<PackageCatalog, PackageContentGroupStagingEventArgs> PackageContentGroupStaging;
IAsyncOperation<PackageCatalogAddOptionalPackageResult> AddOptionalPackageAsync(string optionalPackageFamilyName);
}
public sealed class PackageCatalogAddOptionalPackageResult
public sealed class PackageContentGroup
public sealed class PackageContentGroupStagingEventArgs
public enum PackageContentGroupState
public sealed class PackageStatus {
bool IsPartiallyStaged { get; }
}
}
namespace Windows.ApplicationModel.Activation {
public enum ActivationKind {
ContactPanel = 1017,
LockScreenComponent = 1016,
PrintWorkflowForegroundTask = 1018,
}
public sealed class ContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
public interface IContactPanelActivatedEventArgs
public sealed class LockScreenComponentActivatedEventArgs : IActivatedEventArgs
public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IToastNotificationActivatedEventArgs {
int CurrentlyShownApplicationViewId { get; }
}
}
namespace Windows.ApplicationModel.Background {
public sealed class BackgroundTaskBuilder {
BackgroundTaskRegistrationGroup TaskGroup { get; set; }
}
public sealed class BackgroundTaskRegistration : IBackgroundTaskRegistration, IBackgroundTaskRegistration2, IBackgroundTaskRegistration3 {
public static IMapView<string, BackgroundTaskRegistrationGroup> AllTaskGroups { get; }
BackgroundTaskRegistrationGroup TaskGroup { get; }
public static BackgroundTaskRegistrationGroup GetTaskGroup(string groupId);
}
public sealed class BackgroundTaskRegistrationGroup
public sealed class GattCharacteristicNotificationTrigger : IBackgroundTrigger {
public GattCharacteristicNotificationTrigger(GattCharacteristic characteristic, BluetoothEventTriggeringMode eventTriggeringMode);
BluetoothEventTriggeringMode EventTriggeringMode { get; }
}
public sealed class GattServiceProviderTrigger : IBackgroundTrigger
public sealed class GattServiceProviderTriggerResult
public interface IBackgroundTaskRegistration3 : IBackgroundTaskRegistration
}
namespace Windows.ApplicationModel.Contacts {
public sealed class ContactAnnotation {
string ContactListId { get; set; }
}
public enum ContactAnnotationOperations : uint {
Share = (uint)32,
}
public sealed class ContactAnnotationStore {
IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactListAsync(string contactListId);
}
public sealed class ContactGroup
public static class ContactManager {
public static bool IncludeMiddleNameInSystemDisplayAndSort { get; set; }
public static IAsyncOperation<bool> IsShowFullContactCardSupportedAsync();
}
public sealed class ContactManagerForUser {
void ShowFullContactCard(Contact contact, FullContactCardOptions fullContactCardOptions);
}
public sealed class ContactPanel
public sealed class ContactPanelClosingEventArgs
public sealed class ContactPanelLaunchFullAppRequestedEventArgs
public sealed class ContactPicker {
User User { get; }
public static ContactPicker CreateForUser(User user);
public static IAsyncOperation<bool> IsSupportedAsync();
}
public sealed class PinnedContactIdsQueryResult
public sealed class PinnedContactManager
public enum PinnedContactSurface
}
namespace Windows.ApplicationModel.Core {
public sealed class CoreApplicationView {
IPropertySet Properties { get; }
}
}
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataPackage {
event TypedEventHandler<DataPackage, ShareCompletedEventArgs> ShareCompleted;
}
public sealed class DataTransferManager {
event TypedEventHandler<DataTransferManager, ShareProvidersRequestedEventArgs> ShareProvidersRequested;
}
public sealed class ShareCompletedEventArgs
public sealed class ShareProvider
public delegate void ShareProviderHandler(ShareProviderOperation operation);
public sealed class ShareProviderOperation
public sealed class ShareProvidersRequestedEventArgs
public sealed class ShareTargetInfo
}
namespace Windows.ApplicationModel.Email {
public sealed class EmailMessage {
IVector<EmailRecipient> ReplyTo { get; }
EmailRecipient SentRepresenting { get; set; }
}
}
namespace Windows.ApplicationModel.Payments {
public sealed class PaymentAddress
public sealed class PaymentCurrencyAmount
public sealed class PaymentDetails
public sealed class PaymentDetailsModifier
public sealed class PaymentItem
public sealed class PaymentMediator
public sealed class PaymentMerchantInfo
public sealed class PaymentMethodData
public enum PaymentOptionPresence
public sealed class PaymentOptions
public sealed class PaymentRequest
public sealed class PaymentRequestChangedArgs
public delegate void PaymentRequestChangedHandler(PaymentRequest paymentRequest, PaymentRequestChangedArgs args);
public sealed class PaymentRequestChangedResult
public enum PaymentRequestChangeKind
public enum PaymentRequestCompletionStatus
public enum PaymentRequestStatus
public sealed class PaymentRequestSubmitResult
public sealed class PaymentResponse
public sealed class PaymentShippingOption
public enum PaymentShippingType
public sealed class PaymentToken
}
namespace Windows.ApplicationModel.Payments.Provider {
public sealed class PaymentAppManager
public sealed class PaymentTransaction
public sealed class PaymentTransactionAcceptResult
}
namespace Windows.ApplicationModel.Preview.Holographic {
public static class HolographicApplicationPreview
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
public static class LicenseManager {
public static IAsyncAction RefreshLicensesAsync(LicenseRefreshOption refreshOption);
}
public enum LicenseRefreshOption
}
namespace Windows.ApplicationModel.Store.Preview {
public static class StoreConfiguration {
public static string GetEnterpriseStoreWebAccountId();
public static string GetEnterpriseStoreWebAccountIdForUser(User user);
public static string GetStoreWebAccountId();
public static string GetStoreWebAccountIdForUser(User user);
public static void SetEnterpriseStoreWebAccountId(string webAccountId);
public static void SetEnterpriseStoreWebAccountIdForUser(User user, string webAccountId);
public static bool ShouldRestrictToEnterpriseStoreOnly();
public static bool ShouldRestrictToEnterpriseStoreOnlyForUser(User user);
}
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
public sealed class AppInstallItem {
IVectorView<AppInstallItem> Children { get; }
bool ItemOperationsMightAffectOtherItems { get; }
}
public sealed class AppInstallManager {
IVectorView<AppInstallItem> AppInstallItemsWithGroupSupport { get; }
IAsyncOperation<GetEntitlementResult> GetFreeDeviceEntitlementAsync(string storeId, string campaignId, string correlationVector);
IAsyncOperation<GetEntitlementResult> GetFreeUserEntitlementAsync(string storeId, string campaignId, string correlationVector);
IAsyncOperation<GetEntitlementResult> GetFreeUserEntitlementForUserAsync(User user, string storeId, string campaignId, string correlationVector);
}
public sealed class GetEntitlementResult
public enum GetEntitlementStatus
}
namespace Windows.ApplicationModel.UserActivities {
public sealed class UserActivity
public sealed class UserActivityChannel
public sealed class UserActivitySession : IClosable
public enum UserActivityState
public sealed class UserActivityVisualElements
}
namespace Windows.ApplicationModel.UserActivities.Core {
public static class CoreUserActivityManager
}
namespace Windows.ApplicationModel.UserDataAccounts {
public sealed class UserDataAccount {
bool CanShowCreateContactGroup { get; set; }
IRandomAccessStreamReference Icon { get; set; }
bool IsProtectedUnderLock { get; set; }
IPropertySet ProviderProperties { get; }
IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
IAsyncOperation<IVectorView<UserDataTaskList>> FindUserDataTaskListsAsync();
IAsyncOperation<string> TryShowCreateContactGroupAsync();
}
public sealed class UserDataAccountStore {
IAsyncOperation<UserDataAccount> CreateAccountAsync(string userDisplayName, string packageRelativeAppId, string enterpriseId);
}
}
namespace Windows.ApplicationModel.UserDataTasks {
public sealed class UserDataTask
public sealed class UserDataTaskBatch
public enum UserDataTaskDaysOfWeek : uint
public enum UserDataTaskDetailsKind
public enum UserDataTaskKind
public sealed class UserDataTaskList
public sealed class UserDataTaskListLimitedWriteOperations
public enum UserDataTaskListOtherAppReadAccess
public enum UserDataTaskListOtherAppWriteAccess
public sealed class UserDataTaskListSyncManager
public enum UserDataTaskListSyncStatus
public sealed class UserDataTaskManager
public enum UserDataTaskPriority
public enum UserDataTaskQueryKind
public sealed class UserDataTaskQueryOptions
public enum UserDataTaskQuerySortProperty
public sealed class UserDataTaskReader
public sealed class UserDataTaskRecurrenceProperties
public enum UserDataTaskRecurrenceUnit
public sealed class UserDataTaskRegenerationProperties
public enum UserDataTaskRegenerationUnit
public enum UserDataTaskSensitivity
public sealed class UserDataTaskStore
public enum UserDataTaskStoreAccessType
public enum UserDataTaskWeekOfMonth
}
namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
public sealed class UserDataTaskDataProviderConnection
public sealed class UserDataTaskDataProviderTriggerDetails
public sealed class UserDataTaskListCompleteTaskRequest
public sealed class UserDataTaskListCompleteTaskRequestEventArgs
public sealed class UserDataTaskListCreateOrUpdateTaskRequest
public sealed class UserDataTaskListCreateOrUpdateTaskRequestEventArgs
public sealed class UserDataTaskListDeleteTaskRequest
public sealed class UserDataTaskListDeleteTaskRequestEventArgs
public sealed class UserDataTaskListSkipOccurrenceRequest
public sealed class UserDataTaskListSkipOccurrenceRequestEventArgs
public sealed class UserDataTaskListSyncManagerSyncRequest
public sealed class UserDataTaskListSyncManagerSyncRequestEventArgs
}
namespace Windows.Devices.Bluetooth {
public sealed class BluetoothAdapter
public enum BluetoothAddressType {
Unspecified = 2,
}
public sealed class BluetoothDeviceId
public enum BluetoothError {
TransportNotSupported = 9,
}
public sealed class BluetoothLEDevice : IClosable {
DeviceAccessInformation DeviceAccessInformation { get; }
IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync();
IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(Guid serviceUuid);
IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(Guid serviceUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
}
public static class BluetoothUuidHelper
}
namespace Windows.Devices.Bluetooth.Background {
public enum BluetoothEventTriggeringMode
public sealed class GattCharacteristicNotificationTriggerDetails {
BluetoothError Error { get; }
BluetoothEventTriggeringMode EventTriggeringMode { get; }
IVectorView<GattValueChangedEventArgs> ValueChangedEvents { get; }
}
public sealed class GattServiceProviderConnection
public sealed class GattServiceProviderTriggerDetails
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
public sealed class GattCharacteristic {
IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync();
IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(Guid descriptorUuid);
IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(Guid descriptorUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<GattWriteResult> WriteClientCharacteristicConfigurationDescriptorWithResultAsync(GattClientCharacteristicConfigurationDescriptorValue clientCharacteristicConfigurationDescriptorValue);
IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value, GattWriteOption writeOption);
}
public sealed class GattCharacteristicsResult
public sealed class GattClientNotificationResult
public enum GattCommunicationStatus {
AccessDenied = 3,
ProtocolError = 2,
}
public sealed class GattDescriptor {
IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
}
public sealed class GattDescriptorsResult
public sealed class GattDeviceService : IClosable {
DeviceAccessInformation DeviceAccessInformation { get; }
GattSession Session { get; }
GattSharingMode SharingMode { get; }
public static IAsyncOperation<GattDeviceService> FromIdAsync(string deviceId, GattSharingMode sharingMode);
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync();
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(Guid characteristicUuid);
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(Guid characteristicUuid, BluetoothCacheMode cacheMode);
public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
public static string GetDeviceSelectorForBluetoothDeviceIdAndUuid(BluetoothDeviceId bluetoothDeviceId, Guid serviceUuid);
public static string GetDeviceSelectorForBluetoothDeviceIdAndUuid(BluetoothDeviceId bluetoothDeviceId, Guid serviceUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync();
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(Guid serviceUuid);
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(Guid serviceUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<GattOpenStatus> OpenAsync(GattSharingMode sharingMode);
IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
}
public sealed class GattDeviceServicesResult
public sealed class GattLocalCharacteristic
public sealed class GattLocalCharacteristicParameters
public sealed class GattLocalCharacteristicResult
public sealed class GattLocalDescriptor
public sealed class GattLocalDescriptorParameters
public sealed class GattLocalDescriptorResult
public sealed class GattLocalService
public enum GattOpenStatus
public sealed class GattPresentationFormat {
public static GattPresentationFormat FromParts(byte formatType, int exponent, ushort unit, byte namespaceId, ushort description);
}
public static class GattProtocolError
public sealed class GattReadClientCharacteristicConfigurationDescriptorResult {
IReference<byte> ProtocolError { get; }
}
public sealed class GattReadRequest
public sealed class GattReadRequestedEventArgs
public sealed class GattReadResult {
IReference<byte> ProtocolError { get; }
}
public sealed class GattReliableWriteTransaction {
IAsyncOperation<GattWriteResult> CommitWithResultAsync();
}
public enum GattRequestState
public sealed class GattRequestStateChangedEventArgs
public sealed class GattServiceProvider
public enum GattServiceProviderAdvertisementStatus
public sealed class GattServiceProviderAdvertisementStatusChangedEventArgs
public sealed class GattServiceProviderAdvertisingParameters
public sealed class GattServiceProviderResult
public sealed class GattSession : IClosable
public enum GattSessionStatus
public sealed class GattSessionStatusChangedEventArgs
public enum GattSharingMode
public sealed class GattSubscribedClient
public sealed class GattWriteRequest
public sealed class GattWriteRequestedEventArgs
public sealed class GattWriteResult
}
namespace Windows.Devices.Haptics {
public static class KnownSimpleHapticsControllerWaveforms
public sealed class SimpleHapticsController
public sealed class SimpleHapticsControllerFeedback
public enum VibrationAccessStatus
public sealed class VibrationDevice
}
namespace Windows.Devices.PointOfService {
public sealed class BarcodeScanner : IClosable {
void Close();
public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
}
public static class BarcodeSymbologies {
public static uint Gs1DWCode { get; }
}
public sealed class BarcodeSymbologyAttributes
public enum BarcodeSymbologyDecodeLengthKind
public sealed class CashDrawer : IClosable {
void Close();
public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
}
public sealed class ClaimedBarcodeScanner : IClosable {
IAsyncOperation<BarcodeSymbologyAttributes> GetSymbologyAttributesAsync(uint barcodeSymbology);
IAsyncOperation<bool> SetSymbologyAttributesAsync(uint barcodeSymbology, BarcodeSymbologyAttributes attributes);
}
public sealed class ClaimedLineDisplay : IClosable
public sealed class LineDisplay : IClosable
public sealed class LineDisplayCapabilities
public enum LineDisplayScrollDirection
public enum LineDisplayTextAttribute
public enum LineDisplayTextAttributeGranularity
public sealed class LineDisplayWindow : IClosable
public sealed class MagneticStripeReader : IClosable {
void Close();
public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
}
public enum PosConnectionTypes : uint
public sealed class PosPrinter : IClosable {
void Close();
public static string GetDeviceSelector(PosConnectionTypes connectionTypes);
}
}
namespace Windows.Gaming.Input {
public sealed class ArcadeStick : IGameController, IGameControllerBatteryInfo {
public static ArcadeStick FromGameController(IGameController gameController);
BatteryReport TryGetBatteryReport();
}
public sealed class FlightStick : IGameController, IGameControllerBatteryInfo
public enum FlightStickButtons : uint
public struct FlightStickReading
public enum GameControllerSwitchKind
public enum GameControllerSwitchPosition
public sealed class Gamepad : IGameController, IGameControllerBatteryInfo {
public static Gamepad FromGameController(IGameController gameController);
BatteryReport TryGetBatteryReport();
}
public sealed class Headset : IGameControllerBatteryInfo {
BatteryReport TryGetBatteryReport();
}
public interface IGameControllerBatteryInfo
public sealed class RacingWheel : IGameController, IGameControllerBatteryInfo {
public static RacingWheel FromGameController(IGameController gameController);
BatteryReport TryGetBatteryReport();
}
public sealed class RawGameController : IGameController, IGameControllerBatteryInfo
public sealed class UINavigationController : IGameController, IGameControllerBatteryInfo {
public static UINavigationController FromGameController(IGameController gameController);
BatteryReport TryGetBatteryReport();
}
}
namespace Windows.Gaming.Input.Custom {
public static class GameControllerFactoryManager {
public static IGameController TryGetFactoryControllerFromGameController(ICustomGameControllerFactory factory, IGameController gameController);
}
public sealed class HidGameControllerProvider : IGameControllerProvider
public interface IHidGameControllerInputSink : IGameControllerInputSink
}
namespace Windows.Gaming.UI {
public enum GameChatMessageOrigin
public sealed class GameChatOverlay
public enum GameChatOverlayPosition
}
namespace Windows.Globalization {
public static class CurrencyIdentifiers {
public static string BYN { get; }
}
}
namespace Windows.Globalization.Collation {
public sealed class CharacterGroupings : IIterable<CharacterGrouping>, IVectorView<CharacterGrouping> {
public CharacterGroupings(string language);
}
}
namespace Windows.Graphics {
public struct PointInt32
public struct RectInt32
public struct SizeInt32
}
namespace Windows.Graphics.Display {
public sealed class BrightnessOverride
public enum DisplayBrightnessOverrideOptions : uint
public enum DisplayBrightnessScenario
}
namespace Windows.Graphics.Display.Core {
public enum HdmiDisplayColorSpace
public struct HdmiDisplayHdr2086Metadata
public enum HdmiDisplayHdrOption
public sealed class HdmiDisplayInformation
public sealed class HdmiDisplayMode
public enum HdmiDisplayPixelEncoding
}
namespace Windows.Graphics.Holographic {
public sealed class HolographicCamera {
HolographicDisplay Display { get; }
HolographicCameraViewportParameters LeftViewportParameters { get; }
HolographicCameraViewportParameters RightViewportParameters { get; }
}
public sealed class HolographicCameraRenderingParameters {
HolographicReprojectionMode ReprojectionMode { get; set; }
void CommitDirect3D11DepthBuffer(IDirect3DSurface value);
}
public sealed class HolographicCameraViewportParameters
public sealed class HolographicDisplay
public enum HolographicReprojectionMode
public sealed class HolographicSpace {
public static bool IsAvailable { get; }
public static bool IsSupported { get; }
public static event EventHandler<object> IsAvailableChanged;
}
}
namespace Windows.Management {
public sealed class MdmAlert
public enum MdmAlertDataType
public enum MdmAlertMark
public sealed class MdmSession
public static class MdmSessionManager
public enum MdmSessionState
}
namespace Windows.Management.Deployment {
public enum DeploymentOptions : uint {
RequiredContentGroupOnly = (uint)256,
}
public sealed class DeploymentResult {
bool IsRegistered { get; }
}
public sealed class PackageManager {
PackageManagerDebugSettings DebugSettings { get; }
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RegisterPackageByFamilyNameAsync(string mainPackageFamilyName, IIterable<string> dependencyPackageFamilyNames, DeploymentOptions deploymentOptions, PackageVolume appDataVolume, IIterable<string> optionalPackageFamilyNames);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
}
public sealed class PackageManagerDebugSettings
}
namespace Windows.Management.Policies {
public static class NamedPolicy
public sealed class NamedPolicyData
public enum NamedPolicyKind
}
namespace Windows.Media {
public sealed class MediaExtensionManager {
void RegisterMediaExtensionForAppService(IMediaExtension extension, AppServiceConnection connection);
}
public sealed class MediaTimelineController {
IReference<TimeSpan> Duration { get; set; }
bool IsLoopingEnabled { get; set; }
event TypedEventHandler<MediaTimelineController, object> Ended;
event TypedEventHandler<MediaTimelineController, MediaTimelineControllerFailedEventArgs> Failed;
}
public sealed class MediaTimelineControllerFailedEventArgs
public enum MediaTimelineControllerState {
Error = 3,
Stalled = 2,
}
public struct MediaTimeRange
}
namespace Windows.Media.Capture {
public sealed class MediaCapture : IClosable {
event TypedEventHandler<MediaCapture, MediaCaptureDeviceExclusiveControlStatusChangedEventArgs> CaptureDeviceExclusiveControlStatusChanged;
IAsyncOperation<MultiSourceMediaFrameReader> CreateMultiSourceFrameReaderAsync(IIterable<MediaFrameSource> inputSources);
}
public enum MediaCaptureDeviceExclusiveControlStatus
public sealed class MediaCaptureDeviceExclusiveControlStatusChangedEventArgs
public sealed class MediaCaptureInitializationSettings {
bool AlwaysPlaySystemShutterSound { get; set; }
}
}
namespace Windows.Media.Capture.Frames {
public sealed class DepthMediaFrame {
uint MaxReliableDepth { get; }
uint MinReliableDepth { get; }
}
public enum MediaFrameReaderStartStatus {
ExclusiveControlNotAvailable = 4,
}
public sealed class MediaFrameSourceController {
IAsyncOperation<MediaFrameSourceGetPropertyResult> GetPropertyByExtendedIdAsync(byte[] extendedPropertyId, IReference<uint> maxPropertyValueSize);
IAsyncOperation<MediaFrameSourceSetPropertyStatus> SetPropertyByExtendedIdAsync(byte[] extendedPropertyId, byte[] propertyValue);
}
public enum MediaFrameSourceGetPropertyStatus {
MaxPropertyValueSizeRequired = 5,
MaxPropertyValueSizeTooSmall = 4,
}
public sealed class MultiSourceMediaFrameArrivedEventArgs
public sealed class MultiSourceMediaFrameReader : IClosable
public enum MultiSourceMediaFrameReaderStartStatus
public sealed class MultiSourceMediaFrameReference : IClosable
}
namespace Windows.Media.Core {
public enum AudioDecoderDegradationReason {
SpatialAudioNotSupported = 2,
}
public sealed class ChapterCue : IMediaCue
public enum CodecCategory
public sealed class CodecInfo
public enum CodecKind
public sealed class CodecQuery
public static class CodecSubtypes
public sealed class DataCue : IMediaCue {
PropertySet Properties { get; }
}
public sealed class ImageCue : IMediaCue
public interface ITimedMetadataTrackProvider
public sealed class MediaBindingEventArgs {
void SetAdaptiveMediaSource(AdaptiveMediaSource mediaSource);
void SetStorageFile(IStorageFile file);
}
public sealed class MediaSource : IClosable, IMediaPlaybackSource {
AdaptiveMediaSource AdaptiveMediaSource { get; }
MediaStreamSource MediaStreamSource { get; }
MseStreamSource MseStreamSource { get; }
Uri Uri { get; }
IAsyncAction OpenAsync();
}
public sealed class MediaStreamSource : IMediaSource {
IReference<double> MaxSupportedPlaybackRate { get; set; }
}
public sealed class SpeechCue : IMediaCue
public enum TimedMetadataKind {
ImageSubtitle = 6,
Speech = 7,
}
public enum TimedTextFontStyle
public sealed class TimedTextSource {
public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream);
public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream, string defaultLanguage);
public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri);
public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri, string defaultLanguage);
}
public sealed class TimedTextStyle {
TimedTextFontStyle FontStyle { get; set; }
bool IsLineThroughEnabled { get; set; }
bool IsOverlineEnabled { get; set; }
bool IsUnderlineEnabled { get; set; }
}
}
namespace Windows.Media.Core.Preview {
public static class SoundLevelBroker
}
namespace Windows.Media.Devices {
public sealed class AudioDeviceModule
public sealed class AudioDeviceModuleNotificationEventArgs
public sealed class AudioDeviceModulesManager
public sealed class ModuleCommandResult
public enum SendCommandStatus
public sealed class VideoDeviceController : IMediaDeviceController {
string Id { get; }
VideoDeviceControllerGetDevicePropertyResult GetDevicePropertyByExtendedId(byte[] extendedPropertyId, IReference<uint> maxPropertyValueSize);
VideoDeviceControllerGetDevicePropertyResult GetDevicePropertyById(string propertyId, IReference<uint> maxPropertyValueSize);
VideoDeviceControllerSetDevicePropertyStatus SetDevicePropertyByExtendedId(byte[] extendedPropertyId, byte[] propertyValue);
VideoDeviceControllerSetDevicePropertyStatus SetDevicePropertyById(string propertyId, object propertyValue);
}
public sealed class VideoDeviceControllerGetDevicePropertyResult
public enum VideoDeviceControllerGetDevicePropertyStatus
public enum VideoDeviceControllerSetDevicePropertyStatus
}
namespace Windows.Media.MediaProperties {
public sealed class AudioEncodingProperties : IMediaEncodingProperties {
bool IsSpatial { get; }
public static AudioEncodingProperties CreateAlac(uint sampleRate, uint channelCount, uint bitsPerSample);
public static AudioEncodingProperties CreateFlac(uint sampleRate, uint channelCount, uint bitsPerSample);
}
public sealed class MediaEncodingProfile {
public static MediaEncodingProfile CreateAlac(AudioEncodingQuality quality);
public static MediaEncodingProfile CreateFlac(AudioEncodingQuality quality);
public static MediaEncodingProfile CreateHevc(VideoEncodingQuality quality);
}
public static class MediaEncodingSubtypes {
public static string Alac { get; }
public static string D16 { get; }
public static string Flac { get; }
public static string L16 { get; }
public static string L8 { get; }
public static string Vp9 { get; }
}
public enum SphericalVideoFrameFormat
public sealed class VideoEncodingProperties : IMediaEncodingProperties {
SphericalVideoFrameFormat SphericalVideoFrameFormat { get; }
public static VideoEncodingProperties CreateHevc();
}
public enum VideoEncodingQuality {
Uhd2160p = 8,
Uhd4320p = 9,
}
}
namespace Windows.Media.Playback {
public enum AutoLoadedDisplayPropertyKind
public sealed class CurrentMediaPlaybackItemChangedEventArgs {
MediaPlaybackItemChangedReason Reason { get; }
}
public sealed class MediaPlaybackItem : IMediaPlaybackSource {
AutoLoadedDisplayPropertyKind AutoLoadedDisplayProperties { get; set; }
bool IsDisabledInPlaybackList { get; set; }
double TotalDownloadProgress { get; }
}
public enum MediaPlaybackItemChangedReason
public sealed class MediaPlaybackList : IMediaPlaybackSource {
IReference<uint> MaxPlayedItemsToKeepOpen { get; set; }
}
public sealed class MediaPlaybackSession {
bool IsMirroring { get; set; }
MediaPlaybackSphericalVideoProjection SphericalVideoProjection { get; }
event TypedEventHandler<MediaPlaybackSession, object> BufferedRangesChanged;
event TypedEventHandler<MediaPlaybackSession, object> PlayedRangesChanged;
event TypedEventHandler<MediaPlaybackSession, object> SeekableRangesChanged;
event TypedEventHandler<MediaPlaybackSession, object> SupportedPlaybackRatesChanged;
IVectorView<MediaTimeRange> GetBufferedRanges();
IVectorView<MediaTimeRange> GetPlayedRanges();
IVectorView<MediaTimeRange> GetSeekableRanges();
bool IsSupportedPlaybackRateRange(double rate1, double rate2);
}
public sealed class MediaPlaybackSphericalVideoProjection
public sealed class MediaPlayer : IClosable {
bool IsVideoFrameServerEnabled { get; set; }
event TypedEventHandler<MediaPlayer, object> VideoFrameAvailable;
void CopyFrameToStereoscopicVideoSurfaces(IDirect3DSurface destinationLeftEye, IDirect3DSurface destinationRightEye);
void CopyFrameToVideoSurface(IDirect3DSurface destination);
void CopyFrameToVideoSurface(IDirect3DSurface destination, Rect targetRectangle);
}
public enum SphericalVideoProjectionMode
}
namespace Windows.Media.Protection.PlayReady {
public interface IPlayReadyLicenseSession2 : IPlayReadyLicenseSession
public sealed class PlayReadyLicense : IPlayReadyLicense {
bool ExpiresInRealTime { get; }
bool InMemoryOnly { get; }
Guid SecureStopId { get; }
uint SecurityLevel { get; }
}
public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
}
public sealed class PlayReadyLicenseSession : IPlayReadyLicenseSession, IPlayReadyLicenseSession2 {
PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
}
}
namespace Windows.Media.SpeechSynthesis {
public sealed class SpeechSynthesisStream : IClosable, IContentTypeProvider, IInputStream, IOutputStream, IRandomAccessStream, IRandomAccessStreamWithContentType, ITimedMetadataTrackProvider {
IVectorView<TimedMetadataTrack> TimedMetadataTracks { get; }
}
public sealed class SpeechSynthesizer : IClosable {
SpeechSynthesizerOptions Options { get; }
}
public sealed class SpeechSynthesizerOptions
}
namespace Windows.Media.Streaming.Adaptive {
public sealed class AdaptiveMediaSource : IClosable, IMediaSource {
IReference<TimeSpan> DesiredSeekableWindowSize { get; set; }
AdaptiveMediaSourceDiagnostics Diagnostics { get; }
IReference<TimeSpan> MaxSeekableWindowSize { get; }
IReference<TimeSpan> MinLiveOffset { get; }
void Close();
AdaptiveMediaSourceCorrelatedTimes GetCorrelatedTimes();
}
public sealed class AdaptiveMediaSourceCorrelatedTimes
public sealed class AdaptiveMediaSourceCreationResult {
HResult ExtendedError { get; }
}
public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs
public sealed class AdaptiveMediaSourceDiagnostics
public enum AdaptiveMediaSourceDiagnosticType
public sealed class AdaptiveMediaSourceDownloadBitrateChangedEventArgs {
AdaptiveMediaSourceDownloadBitrateChangedReason Reason { get; }
}
public enum AdaptiveMediaSourceDownloadBitrateChangedReason
public sealed class AdaptiveMediaSourceDownloadCompletedEventArgs {
IReference<TimeSpan> Position { get; }
int RequestId { get; }
AdaptiveMediaSourceDownloadStatistics Statistics { get; }
}
public sealed class AdaptiveMediaSourceDownloadFailedEventArgs {
HResult ExtendedError { get; }
IReference<TimeSpan> Position { get; }
int RequestId { get; }
AdaptiveMediaSourceDownloadStatistics Statistics { get; }
}
public sealed class AdaptiveMediaSourceDownloadRequestedEventArgs {
IReference<TimeSpan> Position { get; }
int RequestId { get; }
}
public sealed class AdaptiveMediaSourceDownloadStatistics
}
namespace Windows.Networking.NetworkOperators {
public sealed class MobileBroadbandAccount {
Uri AccountExperienceUrl { get; }
}
public sealed class MobileBroadbandDeviceInformation {
string SimGid1 { get; }
string SimPnn { get; }
string SimSpn { get; }
}
}
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static PushNotificationChannelManagerForUser GetDefault();
}
public sealed class PushNotificationChannelManagerForUser {
IAsyncOperation<PushNotificationChannel> CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(IBuffer appServerKey, string channelId);
IAsyncOperation<PushNotificationChannel> CreateRawPushNotificationChannelWithAlternateKeyForApplicationAsync(IBuffer appServerKey, string channelId, string appId);
}
public sealed class RawNotification {
string ChannelId { get; }
IMapView<string, string> Headers { get; }
}
}
namespace Windows.Perception.Spatial {
public sealed class SpatialEntity
public sealed class SpatialEntityAddedEventArgs
public sealed class SpatialEntityRemovedEventArgs
public sealed class SpatialEntityStore
public sealed class SpatialEntityUpdatedEventArgs
public sealed class SpatialEntityWatcher
public enum SpatialEntityWatcherStatus
public enum SpatialLookDirectionRange
public enum SpatialMovementRange
public sealed class SpatialStageFrameOfReference
}
namespace Windows.Perception.Spatial.Surfaces {
public sealed class SpatialSurfaceObserver {
public static bool IsSupported();
}
}
namespace Windows.Security.Authentication.Identity.Provider {
public enum SecondaryAuthenticationFactorAuthenticationStage {
CheckingDevicePresence = 8,
}
public enum SecondaryAuthenticationFactorDeviceCapabilities : uint {
CloseRangeDataTransmission = (uint)64,
}
public enum SecondaryAuthenticationFactorDevicePresence
public enum SecondaryAuthenticationFactorDevicePresenceMonitoringMode
public enum SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus
public sealed class SecondaryAuthenticationFactorInfo {
bool IsAuthenticationSupported { get; }
SecondaryAuthenticationFactorDevicePresenceMonitoringMode PresenceMonitoringMode { get; }
IAsyncAction UpdateDevicePresenceAsync(SecondaryAuthenticationFactorDevicePresence presenceState);
}
public sealed class SecondaryAuthenticationFactorRegistration {
public static bool IsDevicePresenceMonitoringSupported();
public static IAsyncOperation<SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus> RegisterDevicePresenceMonitoringAsync(string deviceId, string deviceInstancePath, SecondaryAuthenticationFactorDevicePresenceMonitoringMode monitoringMode);
public static IAsyncOperation<SecondaryAuthenticationFactorDevicePresenceMonitoringRegistrationStatus> RegisterDevicePresenceMonitoringAsync(string deviceId, string deviceInstancePath, SecondaryAuthenticationFactorDevicePresenceMonitoringMode monitoringMode, string deviceFriendlyName, string deviceModelNumber, IBuffer deviceConfigurationData);
public static IAsyncAction UnregisterDevicePresenceMonitoringAsync(string deviceId);
}
}
namespace Windows.Security.Authentication.OnlineId {
public static class OnlineIdSystemAuthenticator
public sealed class OnlineIdSystemAuthenticatorForUser
public sealed class OnlineIdSystemIdentity
public sealed class OnlineIdSystemTicketResult
public enum OnlineIdSystemTicketStatus
}
namespace Windows.Security.Authentication.Web.Core {
public sealed class WebTokenRequest {
string CorrelationId { get; set; }
}
}
namespace Windows.Security.Authentication.Web.Provider {
public interface IWebAccountProviderTokenObjects2 : IWebAccountProviderTokenObjects
public static class WebAccountManager {
public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props);
public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props, WebAccountScope scope);
public static IAsyncOperation<WebAccount> AddWebAccountForUserAsync(User user, string webAccountId, string webAccountUserName, IMapView<string, string> props, WebAccountScope scope, string perUserWebAccountId);
public static IAsyncOperation<IVectorView<WebAccount>> FindAllProviderWebAccountsForUserAsync(User user);
}
public sealed class WebAccountProviderTriggerDetails : IWebAccountProviderTokenObjects, IWebAccountProviderTokenObjects2 {
User User { get; }
}
}
namespace Windows.Security.Cryptography.Certificates {
public sealed class CertificateExtension
public sealed class CertificateRequestProperties {
IVector<CertificateExtension> Extensions { get; }
SubjectAlternativeNameInfo SubjectAlternativeName { get; }
IVector<string> SuppressedDefaults { get; }
}
public sealed class SubjectAlternativeNameInfo {
IVector<string> DistinguishedNames { get; }
IVector<string> DnsNames { get; }
IVector<string> EmailNames { get; }
CertificateExtension Extension { get; }
IVector<string> IPAddresses { get; }
IVector<string> PrincipalNames { get; }
IVector<string> Urls { get; }
}
}
namespace Windows.Services.Cortana {
public enum CortanaPermission
public enum CortanaPermissionsChangeResult
public sealed class CortanaPermissionsManager
}
namespace Windows.Services.Maps {
public sealed class EnhancedWaypoint
public sealed class ManeuverWarning
public enum ManeuverWarningKind
public enum ManeuverWarningSeverity
public sealed class MapRoute {
TimeSpan DurationWithoutTraffic { get; }
TrafficCongestion TrafficCongestion { get; }
}
public static class MapRouteFinder {
public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints);
public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints, MapRouteDrivingOptions options);
}
public sealed class MapRouteLeg {
TimeSpan DurationWithoutTraffic { get; }
TrafficCongestion TrafficCongestion { get; }
}
public sealed class MapRouteManeuver {
IVectorView<ManeuverWarning> Warnings { get; }
}
public static class MapService {
public static MapServiceDataUsagePreference DataUsagePreference { get; set; }
}
public enum MapServiceDataUsagePreference
public enum TrafficCongestion
public enum WaypointKind
}
namespace Windows.Services.Maps.OfflineMaps {
public sealed class OfflineMapPackage
public sealed class OfflineMapPackageQueryResult
public enum OfflineMapPackageQueryStatus
public sealed class OfflineMapPackageStartDownloadResult
public enum OfflineMapPackageStartDownloadStatus
public enum OfflineMapPackageStatus
}
namespace Windows.Storage {
public enum KnownFolderId {
AllAppMods = 14,
CurrentAppMods = 15,
}
public sealed class StorageLibrary {
IAsyncOperation<bool> AreFolderSuggestionsAvailableAsync();
}
public enum StorageOpenOptions : uint {
AllowReadersAndWriters = (uint)2,
}
}
namespace Windows.System {
public sealed class AppDiagnosticInfo
public sealed class LauncherOptions : ILauncherViewOptions {
bool LimitPickerToCurrentAppAndAppUriHandlers { get; set; }
}
}
namespace Windows.System.Diagnostics {
public sealed class SystemCpuUsage
public sealed class SystemCpuUsageReport
public sealed class SystemDiagnosticInfo
public sealed class SystemMemoryUsage
public sealed class SystemMemoryUsageReport
}
namespace Windows.System.Diagnostics.DevicePortal {
public sealed class DevicePortalConnection
public sealed class DevicePortalConnectionClosedEventArgs
public enum DevicePortalConnectionClosedReason
public sealed class DevicePortalConnectionRequestReceivedEventArgs
}
namespace Windows.System.Diagnostics.Telemetry {
public static class PlatformTelemetryClient
public sealed class PlatformTelemetryRegistrationResult
public sealed class PlatformTelemetryRegistrationSettings
public enum PlatformTelemetryRegistrationStatus
}
namespace Windows.System.Diagnostics.TraceReporting {
public static class PlatformDiagnosticActions
public enum PlatformDiagnosticActionState
public enum PlatformDiagnosticEscalationType
public enum PlatformDiagnosticEventBufferLatencies : uint
public sealed class PlatformDiagnosticTraceInfo
public enum PlatformDiagnosticTracePriority
public sealed class PlatformDiagnosticTraceRuntimeInfo
public enum PlatformDiagnosticTraceSlotState
public enum PlatformDiagnosticTraceSlotType
}
namespace Windows.System.Profile {
public static class EducationSettings
}
namespace Windows.System.RemoteSystems {
public static class KnownRemoteSystemCapabilities
public sealed class RemoteSystem {
bool IsAvailableBySpatialProximity { get; }
IAsyncOperation<bool> GetCapabilitySupportedAsync(string capabilityName);
public static bool IsAuthorizationKindEnabled(RemoteSystemAuthorizationKind kind);
}
public enum RemoteSystemAuthorizationKind
public sealed class RemoteSystemAuthorizationKindFilter : IRemoteSystemFilter
public enum RemoteSystemDiscoveryType {
SpatiallyProximal = 3,
}
public sealed class RemoteSystemSession : IClosable
public sealed class RemoteSystemSessionAddedEventArgs
public sealed class RemoteSystemSessionController
public sealed class RemoteSystemSessionCreationResult
public enum RemoteSystemSessionCreationStatus
public sealed class RemoteSystemSessionDisconnectedEventArgs
public enum RemoteSystemSessionDisconnectedReason
public sealed class RemoteSystemSessionInfo
public sealed class RemoteSystemSessionInvitation
public sealed class RemoteSystemSessionInvitationListener
public sealed class RemoteSystemSessionInvitationReceivedEventArgs
public sealed class RemoteSystemSessionJoinRequest
public sealed class RemoteSystemSessionJoinRequestedEventArgs
public sealed class RemoteSystemSessionJoinResult
public enum RemoteSystemSessionJoinStatus
public sealed class RemoteSystemSessionMessageChannel
public enum RemoteSystemSessionMessageChannelReliability
public sealed class RemoteSystemSessionOptions
public sealed class RemoteSystemSessionParticipant
public sealed class RemoteSystemSessionParticipantAddedEventArgs
public sealed class RemoteSystemSessionParticipantRemovedEventArgs
public sealed class RemoteSystemSessionParticipantWatcher
public enum RemoteSystemSessionParticipantWatcherStatus
public sealed class RemoteSystemSessionRemovedEventArgs
public sealed class RemoteSystemSessionUpdatedEventArgs
public sealed class RemoteSystemSessionValueSetReceivedEventArgs
public sealed class RemoteSystemSessionWatcher
public enum RemoteSystemSessionWatcherStatus
}
namespace Windows.System.UserProfile {
public sealed class FeedbackAndDiagnosticsSettings
}
namespace Windows.UI {
public sealed class ColorHelper {
public static string ToDisplayName(Color color);
}
}
namespace Windows.UI.Composition {
public enum AnimationDelayBehavior
public sealed class CompositionCapabilities
public class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
SizeInt32 SizeInt32 { get; }
void Resize(SizeInt32 sizePixels);
void Scroll(PointInt32 offset);
void Scroll(PointInt32 offset, RectInt32 scrollRect);
void ScrollWithClip(PointInt32 offset, RectInt32 clipRect);
void ScrollWithClip(PointInt32 offset, RectInt32 clipRect, RectInt32 scrollRect);
}
public sealed class CompositionGraphicsDevice : CompositionObject {
CompositionDrawingSurface CreateDrawingSurface2(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
CompositionVirtualDrawingSurface CreateVirtualDrawingSurface(SizeInt32 sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
}
public class CompositionVirtualDrawingSurface : CompositionDrawingSurface
public sealed class Compositor : IClosable {
CompositionBackdropBrush CreateHostBackdropBrush();
}
public class KeyFrameAnimation : CompositionAnimation {
AnimationDelayBehavior DelayBehavior { get; set; }
}
public class Visual : CompositionObject {
Visual ParentForTransform { get; set; }
Vector3 RelativeOffsetAdjustment { get; set; }
Vector2 RelativeSizeAdjustment { get; set; }
}
}
namespace Windows.UI.Composition.Interactions {
public sealed class CompositionConditionalValue : CompositionObject
public sealed class InteractionTracker : CompositionObject {
void ConfigureCenterPointXInertiaModifiers(IIterable<CompositionConditionalValue> conditionalValues);
void ConfigureCenterPointYInertiaModifiers(IIterable<CompositionConditionalValue> conditionalValues);
}
public class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
Vector3 DeltaPosition { get; }
float DeltaScale { get; }
Vector3 Position { get; }
Vector3 PositionVelocity { get; }
float Scale { get; }
float ScaleVelocity { get; }
void ConfigureCenterPointXModifiers(IIterable<CompositionConditionalValue> conditionalValues);
void ConfigureCenterPointYModifiers(IIterable<CompositionConditionalValue> conditionalValues);
void ConfigureDeltaPositionXModifiers(IIterable<CompositionConditionalValue> conditionalValues);
void ConfigureDeltaPositionYModifiers(IIterable<CompositionConditionalValue> conditionalValues);
void ConfigureDeltaScaleModifiers(IIterable<CompositionConditionalValue> conditionalValues);
}
}
namespace Windows.UI.Core {
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
event TypedEventHandler<CoreWindow, object> ResizeCompleted;
event TypedEventHandler<CoreWindow, object> ResizeStarted;
}
public sealed class SystemNavigationCloseRequestedEventArgs
public sealed class SystemNavigationManager {
event TypedEventHandler<SystemNavigationManager, SystemNavigationCloseRequestedEventArgs> CloseRequested;
}
}
namespace Windows.UI.Input {
public sealed class RadialController {
event TypedEventHandler<RadialController, RadialControllerButtonHoldingEventArgs> ButtonHolding;
event TypedEventHandler<RadialController, RadialControllerButtonPressedEventArgs> ButtonPressed;
event TypedEventHandler<RadialController, RadialControllerButtonReleasedEventArgs> ButtonReleased;
}
public sealed class RadialControllerButtonClickedEventArgs {
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerButtonHoldingEventArgs
public sealed class RadialControllerButtonPressedEventArgs
public sealed class RadialControllerButtonReleasedEventArgs
public sealed class RadialControllerConfiguration {
RadialController ActiveControllerWhenMenuIsSuppressed { get; set; }
bool IsMenuSuppressed { get; set; }
}
public sealed class RadialControllerControlAcquiredEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerMenuItem {
public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily);
public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily, Uri fontUri);
}
public sealed class RadialControllerRotationChangedEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerScreenContactContinuedEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerScreenContactEndedEventArgs
public sealed class RadialControllerScreenContactStartedEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
}
namespace Windows.UI.Input.Core {
public sealed class RadialControllerIndependentInputSource
}
namespace Windows.UI.Input.Inking {
public sealed class InkDrawingAttributes {
bool IgnoreTilt { get; set; }
}
public enum InkHighContrastAdjustment
public enum InkPersistenceFormat
public sealed class InkPoint {
public InkPoint(Point position, float pressure, float tiltX, float tiltY, ulong timestamp);
float TiltX { get; }
float TiltY { get; }
ulong Timestamp { get; }
}
public sealed class InkPresenter {
InkHighContrastAdjustment HighContrastAdjustment { get; set; }
}
public sealed class InkPresenterProtractor : IInkPresenterStencil
public sealed class InkPresenterRuler : IInkPresenterStencil {
bool AreTickMarksVisible { get; set; }
bool IsCompassVisible { get; set; }
}
public enum InkPresenterStencilKind {
Protractor = 2,
}
public sealed class InkStroke {
uint Id { get; }
IReference<TimeSpan> StrokeDuration { get; set; }
IReference<DateTime> StrokeStartedTime { get; set; }
}
public sealed class InkStrokeBuilder {
InkStroke CreateStrokeFromInkPoints(IIterable<InkPoint> inkPoints, Matrix3x2 transform, IReference<DateTime> strokeStartedTime, IReference<TimeSpan> strokeDuration);
}
public sealed class InkStrokeContainer : IInkStrokeContainer {
InkStroke GetStrokeById(uint id);
IAsyncOperationWithProgress<uint, uint> SaveAsync(IOutputStream outputStream, InkPersistenceFormat inkPersistenceFormat);
}
}
namespace Windows.UI.Input.Inking.Analysis {
public interface IInkAnalysisNode
public interface IInkAnalyzerFactory
public enum InkAnalysisDrawingKind
public sealed class InkAnalysisInkBullet : IInkAnalysisNode
public sealed class InkAnalysisInkDrawing : IInkAnalysisNode
public sealed class InkAnalysisInkWord : IInkAnalysisNode
public sealed class InkAnalysisLine : IInkAnalysisNode
public sealed class InkAnalysisListItem : IInkAnalysisNode
public sealed class InkAnalysisNode : IInkAnalysisNode
public enum InkAnalysisNodeKind
public sealed class InkAnalysisParagraph : IInkAnalysisNode
public sealed class InkAnalysisResult
public sealed class InkAnalysisRoot : IInkAnalysisNode
public enum InkAnalysisStatus
public enum InkAnalysisStrokeKind
public sealed class InkAnalysisWritingRegion : IInkAnalysisNode
public sealed class InkAnalyzer
}
namespace Windows.UI.Input.Spatial {
public sealed class SpatialInteractionController
public sealed class SpatialInteractionControllerProperties
public sealed class SpatialInteractionDetectedEventArgs {
SpatialInteractionSource InteractionSource { get; }
}
public enum SpatialInteractionPressKind
public sealed class SpatialInteractionSource {
SpatialInteractionController Controller { get; }
bool IsGraspSupported { get; }
bool IsMenuSupported { get; }
bool IsPointingSupported { get; }
SpatialInteractionSourceState TryGetStateAtTimestamp(PerceptionTimestamp timestamp);
}
public sealed class SpatialInteractionSourceEventArgs {
SpatialInteractionPressKind PressKind { get; }
}
public sealed class SpatialInteractionSourceState {
SpatialInteractionControllerProperties ControllerProperties { get; }
bool IsGrasped { get; }
bool IsMenuPressed { get; }
bool IsSelectPressed { get; }
double SelectPressedValue { get; }
}
public sealed class SpatialPointerInteractionSourcePose
public sealed class SpatialPointerPose {
SpatialPointerInteractionSourcePose TryGetInteractionSourcePose(SpatialInteractionSource source);
}
}
namespace Windows.UI.Notifications {
public sealed class NotificationData
public enum NotificationUpdateResult
public sealed class ToastCollection
public sealed class ToastCollectionManager
public sealed class ToastNotification {
NotificationData Data { get; set; }
}
public sealed class ToastNotificationHistoryChangedTriggerDetail {
string CollectionId { get; }
}
public static class ToastNotificationManager {
public static ToastNotificationManagerForUser GetDefault();
}
public sealed class ToastNotificationManagerForUser {
IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionIdAsync(string collectionId);
ToastCollectionManager GetToastCollectionManager();
ToastCollectionManager GetToastCollectionManager(string appId);
IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionIdAsync(string collectionId);
}
public sealed class ToastNotifier {
NotificationUpdateResult Update(NotificationData data, string tag);
NotificationUpdateResult Update(NotificationData data, string tag, string group);
}
}
namespace Windows.UI.StartScreen {
public sealed class StartScreenManager
}
namespace Windows.UI.Text {
public sealed class RichEditTextDocument : ITextDocument
public enum TextDecorations : uint
public enum TextGetOptions : uint {
UseLf = (uint)16777216,
}
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
ApplicationViewMode ViewMode { get; }
bool IsViewModeSupported(ApplicationViewMode viewMode);
IAsyncOperation<bool> TryConsolidateAsync();
IAsyncOperation<bool> TryEnterViewModeAsync(ApplicationViewMode viewMode);
IAsyncOperation<bool> TryEnterViewModeAsync(ApplicationViewMode viewMode, ViewModePreferences viewModePreferences);
}
public sealed class ApplicationViewConsolidatedEventArgs {
bool IsAppInitiated { get; }
}
public enum ApplicationViewMode
public static class ApplicationViewSwitcher {
public static IAsyncOperation<bool> TryShowAsViewModeAsync(int viewId, ApplicationViewMode viewMode);
public static IAsyncOperation<bool> TryShowAsViewModeAsync(int viewId, ApplicationViewMode viewMode, ViewModePreferences viewModePreferences);
}
public sealed class UISettings {
bool AdvancedEffectsEnabled { get; }
event TypedEventHandler<UISettings, object> AdvancedEffectsEnabledChanged;
}
public sealed class ViewModePreferences
public enum ViewSizePreference {
Custom = 6,
}
}
namespace Windows.UI.WebUI {
public sealed class WebUIContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
public sealed class WebUILockScreenComponentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
public sealed class WebUIPrintWorkflowForegroundTaskActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
}
namespace Windows.UI.Xaml {
public class Application {
ApplicationHighContrastAdjustment HighContrastAdjustment { get; set; }
}
public enum ApplicationHighContrastAdjustment : uint
public sealed class BringIntoViewOptions
public enum ElementHighContrastAdjustment : uint
public class FrameworkElement : UIElement {
public static void DeferTree(DependencyObject element);
}
public class UIElement : DependencyObject {
public static RoutedEvent GettingFocusEvent { get; }
ElementHighContrastAdjustment HighContrastAdjustment { get; set; }
public static DependencyProperty HighContrastAdjustmentProperty { get; }
double KeyTipHorizontalOffset { get; set; }
public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
KeyTipPlacementMode KeyTipPlacementMode { get; set; }
public static DependencyProperty KeyTipPlacementModeProperty { get; }
double KeyTipVerticalOffset { get; set; }
public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
IVector<XamlLight> Lights { get; }
public static DependencyProperty LightsProperty { get; }
public static RoutedEvent LosingFocusEvent { get; }
public static RoutedEvent NoFocusCandidateFoundEvent { get; }
KeyboardNavigationMode TabFocusNavigation { get; set; }
public static DependencyProperty TabFocusNavigationProperty { get; }
XYFocusNavigationStrategy XYFocusDownNavigationStrategy { get; set; }
public static DependencyProperty XYFocusDownNavigationStrategyProperty { get; }
XYFocusKeyboardNavigationMode XYFocusKeyboardNavigation { get; set; }
public static DependencyProperty XYFocusKeyboardNavigationProperty { get; }
XYFocusNavigationStrategy XYFocusLeftNavigationStrategy { get; set; }
public static DependencyProperty XYFocusLeftNavigationStrategyProperty { get; }
XYFocusNavigationStrategy XYFocusRightNavigationStrategy { get; set; }
public static DependencyProperty XYFocusRightNavigationStrategyProperty { get; }
XYFocusNavigationStrategy XYFocusUpNavigationStrategy { get; set; }
public static DependencyProperty XYFocusUpNavigationStrategyProperty { get; }
event TypedEventHandler<UIElement, GettingFocusEventArgs> GettingFocus;
event TypedEventHandler<UIElement, LosingFocusEventArgs> LosingFocus;
event TypedEventHandler<UIElement, NoFocusCandidateFoundEventArgs> NoFocusCandidateFound;
void StartBringIntoView();
void StartBringIntoView(BringIntoViewOptions options);
}
public sealed class Window {
Compositor Compositor { get; }
}
}
namespace Windows.UI.Xaml.Automation {
public sealed class AutomationElementIdentifiers {
public static AutomationProperty CultureProperty { get; }
}
public sealed class AutomationProperties {
public static DependencyProperty CultureProperty { get; }
public static int GetCulture(DependencyObject element);
public static void SetCulture(DependencyObject element, int value);
}
}
namespace Windows.UI.Xaml.Automation.Peers {
public class AutomationPeer : DependencyObject {
int GetCulture();
virtual int GetCultureCore();
}
public sealed class MapControlAutomationPeer : FrameworkElementAutomationPeer, IScrollProvider, ITransformProvider, ITransformProvider2 {
bool CanMove { get; }
bool CanResize { get; }
bool CanRotate { get; }
bool CanZoom { get; }
double MaxZoom { get; }
double MinZoom { get; }
double ZoomLevel { get; }
void Move(double x, double y);
void Resize(double width, double height);
void Rotate(double degrees);
void Zoom(double zoom);
void ZoomByUnit(ZoomUnit zoomUnit);
}
}
namespace Windows.UI.Xaml.Controls {
public class BitmapIcon : IconElement {
bool ShowAsMonochrome { get; set; }
public static DependencyProperty ShowAsMonochromeProperty { get; }
}
public class ComboBox : Selector {
ComboBoxSelectionChangedTrigger SelectionChangedTrigger { get; set; }
public static DependencyProperty SelectionChangedTriggerProperty { get; }
}
public enum ComboBoxSelectionChangedTrigger
public class ContentDialog : ContentControl {
ICommand CloseButtonCommand { get; set; }
object CloseButtonCommandParameter { get; set; }
public static DependencyProperty CloseButtonCommandParameterProperty { get; }
public static DependencyProperty CloseButtonCommandProperty { get; }
Style CloseButtonStyle { get; set; }
public static DependencyProperty CloseButtonStyleProperty { get; }
string CloseButtonText { get; set; }
public static DependencyProperty CloseButtonTextProperty { get; }
ContentDialogButton DefaultButton { get; set; }
public static DependencyProperty DefaultButtonProperty { get; }
Style PrimaryButtonStyle { get; set; }
public static DependencyProperty PrimaryButtonStyleProperty { get; }
Style SecondaryButtonStyle { get; set; }
public static DependencyProperty SecondaryButtonStyleProperty { get; }
event TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> CloseButtonClick;
}
public enum ContentDialogButton
public class Control : FrameworkElement {
Uri DefaultStyleResourceUri { get; set; }
public static DependencyProperty DefaultStyleResourceUriProperty { get; }
public static DependencyProperty IsTemplateKeyTipTargetProperty { get; }
public static bool GetIsTemplateKeyTipTarget(DependencyObject element);
public static void SetIsTemplateKeyTipTarget(DependencyObject element, bool value);
}
public sealed class FocusEngagedEventArgs : RoutedEventArgs {
bool Handled { get; set; }
}
public class Frame : ContentControl, INavigate {
void SetNavigationState(string navigationState, bool suppressNavigate);
}
public class InkToolbar : Control {
InkToolbarButtonFlyoutPlacement ButtonFlyoutPlacement { get; set; }
public static DependencyProperty ButtonFlyoutPlacementProperty { get; }
bool IsStencilButtonChecked { get; set; }
public static DependencyProperty IsStencilButtonCheckedProperty { get; }
Orientation Orientation { get; set; }
public static DependencyProperty OrientationProperty { get; }
event TypedEventHandler<InkToolbar, InkToolbarIsStencilButtonCheckedChangedEventArgs> IsStencilButtonCheckedChanged;
InkToolbarMenuButton GetMenuButton(InkToolbarMenuKind menu);
}
public enum InkToolbarButtonFlyoutPlacement
public class InkToolbarEraserButton : InkToolbarToolButton {
bool IsClearAllVisible { get; set; }
public static DependencyProperty IsClearAllVisibleProperty { get; }
}
public class InkToolbarFlyoutItem : ButtonBase
public enum InkToolbarFlyoutItemKind
public sealed class InkToolbarIsStencilButtonCheckedChangedEventArgs
public class InkToolbarMenuButton : ToggleButton
public enum InkToolbarMenuKind
public class InkToolbarStencilButton : InkToolbarMenuButton
public enum InkToolbarStencilKind
public class ListViewBase : Selector, ISemanticZoomInformation {
ConnectedAnimation PrepareConnectedAnimation(string key, object item, string elementName);
IAsyncOperation<bool> TryStartConnectedAnimationAsync(ConnectedAnimation animation, object item, string elementName);
}
public class MenuFlyoutItem : MenuFlyoutItemBase {
IconElement Icon { get; set; }
public static DependencyProperty IconProperty { get; }
}
public sealed class MenuFlyoutSubItem : MenuFlyoutItemBase {
IconElement Icon { get; set; }
public static DependencyProperty IconProperty { get; }
}
public class RichEditBox : Control {
int MaxLength { get; set; }
public static DependencyProperty MaxLengthProperty { get; }
SolidColorBrush SelectionHighlightColorWhenNotFocused { get; set; }
public static DependencyProperty SelectionHighlightColorWhenNotFocusedProperty { get; }
}
public sealed class RichEditBoxTextChangingEventArgs {
bool IsContentChanging { get; }
}
public sealed class RichTextBlock : FrameworkElement {
TextDecorations TextDecorations { get; set; }
public static DependencyProperty TextDecorationsProperty { get; }
}
public sealed class TextBlock : FrameworkElement {
TextDecorations TextDecorations { get; set; }
public static DependencyProperty TextDecorationsProperty { get; }
}
public class TextBox : Control {
SolidColorBrush SelectionHighlightColorWhenNotFocused { get; set; }
public static DependencyProperty SelectionHighlightColorWhenNotFocusedProperty { get; }
}
public sealed class TextBoxTextChangingEventArgs {
bool IsContentChanging { get; }
}
}
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapBillboard : MapElement
public sealed class MapContextRequestedEventArgs
public sealed class MapControl : Control {
MapProjection MapProjection { get; set; }
public static DependencyProperty MapProjectionProperty { get; }
MapStyleSheet StyleSheet { get; set; }
public static DependencyProperty StyleSheetProperty { get; }
Thickness ViewPadding { get; set; }
public static DependencyProperty ViewPaddingProperty { get; }
event TypedEventHandler<MapControl, MapContextRequestedEventArgs> MapContextRequested;
IVectorView<MapElement> FindMapElementsAtOffset(Point offset, double radius);
void GetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
void StartContinuousPan(double horizontalPixelsPerSecond, double verticalPixelsPerSecond);
void StopContinuousPan();
IAsyncOperation<bool> TryPanAsync(double horizontalPixels, double verticalPixels);
IAsyncOperation<bool> TryPanToAsync(Geopoint location);
}
public enum MapProjection
public enum MapStyle {
Custom = 7,
}
public sealed class MapStyleSheet : DependencyObject
}
namespace Windows.UI.Xaml.Controls.Primitives {
public class FlyoutBase : DependencyObject {
DependencyObject OverlayInputPassThroughElement { get; set; }
public static DependencyProperty OverlayInputPassThroughElementProperty { get; }
}
}
namespace Windows.UI.Xaml.Documents {
public sealed class Hyperlink : Span {
FocusState FocusState { get; }
public static DependencyProperty FocusStateProperty { get; }
XYFocusNavigationStrategy XYFocusDownNavigationStrategy { get; set; }
public static DependencyProperty XYFocusDownNavigationStrategyProperty { get; }
XYFocusNavigationStrategy XYFocusLeftNavigationStrategy { get; set; }
public static DependencyProperty XYFocusLeftNavigationStrategyProperty { get; }
XYFocusNavigationStrategy XYFocusRightNavigationStrategy { get; set; }
public static DependencyProperty XYFocusRightNavigationStrategyProperty { get; }
XYFocusNavigationStrategy XYFocusUpNavigationStrategy { get; set; }
public static DependencyProperty XYFocusUpNavigationStrategyProperty { get; }
event RoutedEventHandler GotFocus;
event RoutedEventHandler LostFocus;
bool Focus(FocusState value);
}
public class TextElement : DependencyObject {
DependencyObject AccessKeyScopeOwner { get; set; }
public static DependencyProperty AccessKeyScopeOwnerProperty { get; }
bool IsAccessKeyScope { get; set; }
public static DependencyProperty IsAccessKeyScopeProperty { get; }
double KeyTipHorizontalOffset { get; set; }
public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
KeyTipPlacementMode KeyTipPlacementMode { get; set; }
public static DependencyProperty KeyTipPlacementModeProperty { get; }
double KeyTipVerticalOffset { get; set; }
public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
TextDecorations TextDecorations { get; set; }
public static DependencyProperty TextDecorationsProperty { get; }
event TypedEventHandler<TextElement, AccessKeyDisplayDismissedEventArgs> AccessKeyDisplayDismissed;
event TypedEventHandler<TextElement, AccessKeyDisplayRequestedEventArgs> AccessKeyDisplayRequested;
event TypedEventHandler<TextElement, AccessKeyInvokedEventArgs> AccessKeyInvoked;
}
}
namespace Windows.UI.Xaml.Hosting {
public sealed class ElementCompositionPreview {
public static CompositionPropertySet GetPointerPositionPropertySet(UIElement targetElement);
public static void SetImplicitHideAnimation(UIElement element, ICompositionAnimationBase animation);
public static void SetImplicitShowAnimation(UIElement element, ICompositionAnimationBase animation);
public static void SetIsTranslationEnabled(UIElement element, bool value);
}
}
namespace Windows.UI.Xaml.Input {
public sealed class AccessKeyManager {
public static bool AreKeyTipsEnabled { get; set; }
}
public sealed class FindNextElementOptions
public enum FocusInputDeviceKind
public sealed class FocusManager {
public static DependencyObject FindFirstFocusableElement(DependencyObject searchScope);
public static DependencyObject FindLastFocusableElement(DependencyObject searchScope);
public static DependencyObject FindNextElement(FocusNavigationDirection focusNavigationDirection);
public static DependencyObject FindNextElement(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
public static bool TryMoveFocus(FocusNavigationDirection focusNavigationDirection, FindNextElementOptions focusNavigationOptions);
}
public sealed class GettingFocusEventArgs : RoutedEventArgs
public enum KeyTipPlacementMode
public sealed class LosingFocusEventArgs : RoutedEventArgs
public sealed class NoFocusCandidateFoundEventArgs : RoutedEventArgs
public enum XYFocusKeyboardNavigationMode
public enum XYFocusNavigationStrategy
public enum XYFocusNavigationStrategyOverride
}
namespace Windows.UI.Xaml.Markup {
public sealed class XamlMarkupHelper
}
namespace Windows.UI.Xaml.Media {
public sealed class LoadedImageSourceLoadCompletedEventArgs
public enum LoadedImageSourceLoadStatus
public sealed class LoadedImageSurface : IClosable, ICompositionSurface
public class XamlCompositionBrushBase : Brush
public class XamlLight : DependencyObject
}
namespace Windows.UI.Xaml.Media.Animation {
public sealed class ConnectedAnimation {
bool IsScaleAnimationEnabled { get; set; }
void SetAnimationComponent(ConnectedAnimationComponent component, ICompositionAnimationBase animation);
bool TryStart(UIElement destination, IIterable<UIElement> coordinatedElements);
}
public enum ConnectedAnimationComponent
}
namespace Windows.UI.Xaml.Media.Imaging {
public class SvgImageSource : ImageSource
public sealed class SvgImageSourceFailedEventArgs
public enum SvgImageSourceLoadStatus
public sealed class SvgImageSourceOpenedEventArgs
}
namespace Windows.Media.Capture {
public sealed class AppCaptureDurationGeneratedEventArgs
public sealed class AppCaptureFileGeneratedEventArgs
public enum AppCaptureMicrophoneCaptureState
public sealed class AppCaptureMicrophoneCaptureStateChangedEventArgs
public enum AppCaptureRecordingState
public sealed class AppCaptureRecordingStateChangedEventArgs
public sealed class AppCaptureRecordOperation
public sealed class AppCaptureServices
public sealed class AppCaptureSettings {
bool IsCursorImageCaptureEnabled { get; set; }
bool IsEchoCancellationEnabled { get; set; }
}
public sealed class AppCaptureState
}
namespace Windows.Security.EnterpriseData {
public static class FileProtectionManager {
public static IAsyncOperation<FileProtectionInfo> UnprotectAsync(IStorageItem target);
public static IAsyncOperation<FileProtectionInfo> UnprotectAsync(IStorageItem target, FileUnprotectOptions options);
}
public sealed class FileUnprotectOptions
public sealed class ProtectionPolicyManager {
public static string PrimaryManagedIdentity { get; }
public static string GetPrimaryManagedIdentityForIdentity(string identity);
public static IAsyncOperation<bool> IsFileProtectionRequiredAsync(IStorageItem target, string identity);
public static IAsyncOperation<bool> IsFileProtectionRequiredForNewFileAsync(IStorageFolder parentFolder, string identity, string desiredName);
public static bool IsRoamableProtectionEnabled(string identity);
public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessAsync(string sourceIdentity, string targetIdentity, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessForAppAsync(string sourceIdentity, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForAppAsync(IIterable<IStorageItem> sourceItemList, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo);
public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForAppAsync(IIterable<IStorageItem> sourceItemList, string appPackageFamilyName, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForProcessAsync(IIterable<IStorageItem> sourceItemList, uint processId, ProtectionPolicyAuditInfo auditInfo);
public static IAsyncOperation<ProtectionPolicyEvaluationResult> RequestAccessToFilesForProcessAsync(IIterable<IStorageItem> sourceItemList, uint processId, ProtectionPolicyAuditInfo auditInfo, string messageFromApp, ProtectionPolicyRequestAccessBehavior behavior);
}
}
namespace Windows.Services.Store {
public sealed class StoreContext {
IAsyncOperation<StoreProductResult> FindStoreProductForPackageAsync(IIterable<string> productKinds, Package package);
}
public sealed class StoreSendRequestResult {
HttpStatusCode HttpStatusCode { get; }
}
}
namespace Windows.System.Profile {
public static class SharedModeSettings {
public static bool ShouldAvoidLocalStorage { get; }
}
}
namespace Windows.Services.Cortana {
public sealed class CortanaSettings
}
namespace Windows.System {
public enum PowerState
public static class ShutdownManager {
public static void EnterPowerState(PowerState powerState);
public static void EnterPowerState(PowerState powerState, TimeSpan wakeUpAfter);
public static bool IsPowerStateSupported(PowerState powerState);
}
}

API Removals

namespace Windows.UI.Composition {
public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
}
}
namespace Windows.UI.Composition.Interactions {
public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource {
}
}

Windows 10 SDK Preview Build 14965 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14965 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14965 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

The Preview SDK can be downloaded from the developer section on Windows Insider.

For feedback and updates to the known issues, please see the developer forum.  For new feature requests, head over to our Windows Platform UserVoice.

Things to note:

What’s New

Known Issues Windows SDK

  • Wrong GenXBF.DLL
    If you installed a previous Windows SDK flight, either version 14951 or 14931, you may have an incorrect GenXBF.dll installed. Please follow the following steps after installing the Windows 10 SDK Preview build 14965.
  1. Exit Visual Studio
  2. Open an Administrative command prompt
  3. Type the following:

    DEL “c:Program Files (x86)Windows Kits10binx86genxbf.dll”

    DEL “c:Program Files (x86)Windows Kits10binx64genxbf.dll”

  1. Run Control Panel
  2. Select Uninstall a Program
  3. Highlight Windows Software Development Kit – Windows 10.0.14965.1000
  4. Click Change
  5. Select Repair
  6. Click Next

Windows SDK setup will restore the missing GenXBF.dlls  with the appropriate version.

  • Visual Studio 2017 fails with HRESULT: 0x80041FE2 when trying to create C++ UWP apps targeting build 14965 SDK

This is a known problem. Here are steps to address this issue in your project file:

  1. Close the project
  2. Open up the project file in notepad or your favorite editor
  3. Add the following to the project file:
      <PropertyGroup><DoBundleInstallationChecks>false</DoBundleInstallationChecks></PropertyGroup>
  4. Reopen the project in Visual Studio

Known Issues Microsoft Emulator

Microsoft Emulator Preview for Windows 10 Mobile (10.0.14965.0) crashes when launching

Impact:

Please note that there is a bug impacting the usage of hardware accelerated graphics in the latest release of the Mobile Emulator. Follow the instructions below to temporarily disable hardware accelerated graphics in the emulator and use the emulator with software rendered graphics (WARP).

NOTE: The following registry setting will impact any and all Microsoft Emulators installed on your machine. You will need to remove this registry setting in order to re-enable hardware accelerated graphics in the emulator.

  1. Create the following registry subkey if it doesn’t exist: HKEY_LOCAL_MACHINESOFTWAREWow6432NodeMicrosoftXde10.0
  2. Right click the 10.0 folder, point to New, and then click DWORD Value.
  3. Type DisableRemoteFx, and then press Enter.
  4. Double-click DisableRemoteFx, enter 1 in the Value data box, select the Decimal option, and then click OK.

API Updates and Additions

The following API changes are under development and new or updated for this release of the SDK.

namespace Windows.ApplicationModel.Preview.Notes {
public sealed class NotesWindowManagerPreview {
void SetFocusToPreviousView();
IAsyncAction SetThumbnailImageForTaskSwitcherAsync(SoftwareBitmap bitmap);
void ShowNoteRelativeTo(int noteViewId, int anchorNoteViewId, NotesWindowManagerPreviewShowNoteOptions options);
void ShowNoteWithPlacement(int noteViewId, IBuffer data, NotesWindowManagerPreviewShowNoteOptions options);
}
public sealed class NotesWindowManagerPreviewShowNoteOptions
}
namespace Windows.Devices.Gpio {
public sealed class GpioInterruptBuffer
public struct GpioInterruptEvent
public enum GpioOpenStatus {
MuxingConflict = 3,
UnknownError = 4,
}
public sealed class GpioPin : IClosable {
GpioInterruptBuffer InterruptBuffer { get; }
ulong InterruptCount { get; }
void CreateInterruptBuffer();
void CreateInterruptBuffer(int minimumCapacity);
void StartInterruptBuffer();
void StartInterruptBuffer(GpioPinEdge edge);
void StartInterruptCount();
void StartInterruptCount(GpioPinEdge edge);
void StopInterruptBuffer();
void StopInterruptCount();
}
}
namespace Windows.Devices.Gpio.Provider {
public interface IGpioInterruptBufferProvider
public interface IGpioPinProvider2
public struct ProviderGpioInterruptEvent
}
namespace Windows.Devices.I2c {
public enum I2cTransferStatus {
ClockStretchTimeout = 3,
UnknownError = 4,
}
}
namespace Windows.ApplicationModel {
public sealed class Package {
IAsyncOperation<PackageContentGroup> GetContentGroupAsync(string name);
IAsyncOperation<IVector<PackageContentGroup>> GetContentGroupsAsync();
IAsyncOperation<bool> SetInUseAsync(bool inUse);
IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names);
IAsyncOperation<IVector<PackageContentGroup>> StageContentGroupsAsync(IIterable<string> names, bool moveToHeadOfQueue);
}
public sealed class PackageCatalog {
event TypedEventHandler<PackageCatalog, PackageContentGroupStagingEventArgs> PackageContentGroupStaging;
IAsyncOperation<Package> AddOptionalPackageAsync(string optionalPackageFamilyName);
}
public sealed class PackageContentGroup
public sealed class PackageContentGroupStagingEventArgs
public enum PackageContentGroupState
}
namespace Windows.ApplicationModel.Activation {
public enum ActivationKind {
ContactPanel = 1017,
LockScreenComponent = 1016,
}
public sealed class ContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
public interface IContactPanelActivatedEventArgs
public sealed class LockScreenComponentActivatedEventArgs : IActivatedEventArgs
public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IToastNotificationActivatedEventArgs {
int CurrentlyShownApplicationViewId { get; }
}
}
namespace Windows.ApplicationModel.Background {
public sealed class GattCharacteristicNotificationTrigger : IBackgroundTrigger {
public GattCharacteristicNotificationTrigger(GattCharacteristic characteristic, BluetoothEventTriggeringMode eventTriggeringMode);
BluetoothEventTriggeringMode EventTriggeringMode { get; }
}
public sealed class GattServiceProviderTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Contacts {
public sealed class ContactAnnotation {
string ContactGroupId { get; set; }
string ContactListId { get; set; }
}
public enum ContactAnnotationOperations : uint {
Share = (uint)32,
}
public sealed class ContactAnnotationStore {
IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactGroupAsync(string contactGroupId);
IAsyncOperation<IVectorView<ContactAnnotation>> FindAnnotationsForContactListAsync(string contactListId);
}
public sealed class ContactGroup
public sealed class ContactGroupMember
public sealed class ContactGroupMemberBatch
public sealed class ContactGroupMemberReader
public enum ContactGroupOtherAppReadAccess
public static class ContactManager {
public static IAsyncOperation<bool> IsShowFullContactCardSupportedAsync();
}
public sealed class ContactManagerForUser {
void ShowFullContactCard(Contact contact, FullContactCardOptions fullContactCardOptions);
}
public sealed class ContactPanel
public sealed class ContactPanelClosingEventArgs
public sealed class ContactPanelLaunchFullAppRequestedEventArgs
public sealed class ContactPicker {
User User { get; }
public static ContactPicker CreateForUser(User user);
public static IAsyncOperation<bool> IsSupportedAsync();
}
public sealed class ContactStore {
IAsyncOperation<ContactGroup> CreateContactGroupAsync(string displayName);
IAsyncOperation<ContactGroup> CreateContactGroupAsync(string displayName, string userDataAccountId);
IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsByRemoteIdAsync(string remoteId);
IAsyncOperation<ContactGroup> GetContactGroupAsync(string contactGroupId);
}
public sealed class PinnedContactIdsQueryResult
public sealed class PinnedContactManager
public enum PinnedContactSurface
}
namespace Windows.ApplicationModel.Core {
public sealed class CoreApplicationView {
IPropertySet Properties { get; }
}
}
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataTransferManager {
public static void ShowShareUI(ShareUIOptions shareOptions);
}
public sealed class ShareUIOptions
}
namespace Windows.ApplicationModel.Email {
public sealed class EmailMessage {
IVector<EmailRecipient> ReplyTo { get; }
EmailRecipient SentRepresenting { get; set; }
}
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
public static class LicenseManager {
public static IAsyncAction RefreshLicensesAsync(LicenseRefreshOption refreshOption);
}
public enum LicenseRefreshOption
}
namespace Windows.ApplicationModel.UserDataAccounts {
public sealed class UserDataAccount {
bool CanShowCreateContactGroup { get; set; }
bool IsProtectedUnderLock { get; set; }
IPropertySet ProviderProperties { get; }
IAsyncOperation<IVectorView<ContactGroup>> FindContactGroupsAsync();
IAsyncOperation<IVectorView<UserDataTaskList>> FindUserDataTaskListsAsync();
IAsyncOperation<string> TryShowCreateContactGroupAsync();
}
public sealed class UserDataAccountStore {
IAsyncOperation<UserDataAccount> CreateAccountAsync(string userDisplayName, string packageRelativeAppId, string enterpriseId);
}
}
namespace Windows.ApplicationModel.UserDataTasks {
public sealed class UserDataTask
public sealed class UserDataTaskBatch
public enum UserDataTaskDaysOfWeek : uint
public enum UserDataTaskDetailsKind
public enum UserDataTaskKind
public sealed class UserDataTaskList
public sealed class UserDataTaskListLimitedWriteOperations
public enum UserDataTaskListOtherAppReadAccess
public enum UserDataTaskListOtherAppWriteAccess
public sealed class UserDataTaskListSyncManager
public enum UserDataTaskListSyncStatus
public static class UserDataTaskManager
public sealed class UserDataTaskManagerForUser
public enum UserDataTaskPriority
public enum UserDataTaskQueryKind
public sealed class UserDataTaskQueryOptions
public enum UserDataTaskQuerySortProperty
public sealed class UserDataTaskReader
public sealed class UserDataTaskRecurrenceProperties
public enum UserDataTaskRecurrenceUnit
public sealed class UserDataTaskRegenerationProperties
public enum UserDataTaskRegenerationUnit
public enum UserDataTaskSensitivity
public sealed class UserDataTaskStore
public enum UserDataTaskStoreAccessType
public enum UserDataTaskWeekOfMonth
}
namespace Windows.ApplicationModel.UserDataTasks.DataProvider {
public sealed class UserDataTaskDataProviderConnection
public sealed class UserDataTaskDataProviderTriggerDetails
public sealed class UserDataTaskListCompleteTaskRequest
public sealed class UserDataTaskListCompleteTaskRequestEventArgs
public sealed class UserDataTaskListCreateOrUpdateTaskRequest
public sealed class UserDataTaskListCreateOrUpdateTaskRequestEventArgs
public sealed class UserDataTaskListDeleteTaskRequest
public sealed class UserDataTaskListDeleteTaskRequestEventArgs
public sealed class UserDataTaskListSkipOccurrenceRequest
public sealed class UserDataTaskListSkipOccurrenceRequestEventArgs
public sealed class UserDataTaskListSyncManagerSyncRequest
public sealed class UserDataTaskListSyncManagerSyncRequestEventArgs
}
namespace Windows.Gaming.Input {
public sealed class FlightStick : IGameController
public enum FlightStickButtons : uint
public struct FlightStickReading
public enum GameControllerSwitchKind
public enum GameControllerSwitchPosition
public sealed class RawGameController : IGameController
}
namespace Windows.Gaming.Input.Custom {
public sealed class HidGameControllerProvider : IGameControllerProvider
public interface IHidGameControllerInputSink : IGameControllerInputSink
}
namespace Windows.Graphics.Printing.PrintTicket {
public interface IPrintTicketSchemaDisplayableElement : IPrintTicketSchemaElement
public interface IPrintTicketSchemaElement
public interface IPrintTicketSchemaOption : IPrintTicketSchemaDisplayableElement, IPrintTicketSchemaElement
public interface IPrintTicketSchemaParameterDefinition : IPrintTicketSchemaElement
public interface IPrintTicketSchemaValue
public sealed class PrintTicketSchemaCapabilities : IPrintTicketSchemaElement
public sealed class PrintTicketSchemaFeature : IPrintTicketSchemaDisplayableElement, IPrintTicketSchemaElement
public sealed class PrintTicketSchemaParameterInitializer : IPrintTicketSchemaElement
public enum tagSchemaParameterDataType
public enum tagSchemaSelectionType
public enum tagValueType
public sealed class WorkflowPrintSchemaTicket : IPrintTicketSchemaElement
public sealed class XmlNode
}
namespace Windows.Graphics.Printing.Workflow {
public interface IPrinterPropertyBag
public sealed class PrinterQueue
public sealed class PrintTaskBackgroundSessionManager
public sealed class PrintTaskConfig
public sealed class PrintTaskForegroundSessionManager
public sealed class PrintTaskSessionState
public enum PrintTaskSessionStatus
public sealed class PrintTaskSetupEventArgs
public sealed class PrintTaskSubmissionController
public sealed class PrintTaskSubmittedEventArgs
public sealed class PrintTaskTarget
public sealed class PrintTaskUIActivatedEventArgs : IActivatedEventArgs
public sealed class PrintTaskXpsDataAvailableEventArgs
public sealed class SourceContent
public sealed class SpoolStreamContent
public sealed class StreamTarget
public sealed class WorkflowTaskContext
public sealed class WorkflowTriggerDetails
public sealed class XpsOmContent
public sealed class XpsOmReceiver
}
namespace Windows.Management.Deployment {
public enum DeploymentOptions : uint {
EnableStreamedInstall = (uint)128,
RequiredContentGroupOnly = (uint)256,
}
public sealed class PackageManager {
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> AddPackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> RegisterPackageByFamilyNameAsync(string mainPackageFamilyName, IIterable<string> dependencyPackageFamilyNames, DeploymentOptions deploymentOptions, PackageVolume appDataVolume, IIterable<string> optionalPackageFamilyNames);
IAsyncOperationWithProgress<DeploymentResult, DeploymentProgress> StagePackageAsync(Uri packageUri, IIterable<Uri> dependencyPackageUris, DeploymentOptions deploymentOptions, PackageVolume targetVolume, IIterable<string> optionalPackageFamilyNames, IIterable<Uri> externalPackageUris);
}
}
namespace Windows.Management.Policies {
public sealed class BinaryPolicy
public sealed class BooleanPolicy
public static class BrowserPolicies
public sealed class BrowserPoliciesForUser
public sealed class Int32Policy
public sealed class StringPolicy
}
namespace Windows.Media {
public sealed class MediaExtensionManager {
void RegisterMediaExtensionForAppService(IMediaExtension extension, AppServiceConnection connection);
}
public sealed class MediaMarkerSpeechSentenceBoundary : IMediaMarker
public sealed class MediaMarkerSpeechWordBoundary : IMediaMarker
public static class MediaMarkerTypes {
public static string SentenceBoundary { get; }
public static string WordBoundary { get; }
}
public struct MediaTimeRange
}
namespace Windows.Media.Capture {
public sealed class MediaCaptureInitializationSettings {
bool AlwaysPlaySystemShutterSound { get; set; }
}
}
namespace Windows.Media.Core {
public sealed class ChapterCue : IMediaCue
public sealed class DataCue : IMediaCue {
PropertySet Properties { get; }
}
public sealed class ImageCue : IMediaCue
public sealed class MediaBindingEventArgs {
void SetAdaptiveMediaSource(AdaptiveMediaSource mediaSource);
void SetStorageFile(IStorageFile file);
}
public sealed class MediaSource : IClosable, IMediaPlaybackSource {
AdaptiveMediaSource AdaptiveMediaSource { get; }
MediaStreamSource MediaStreamSource { get; }
MseStreamSource MseStreamSource { get; }
Uri Uri { get; }
}
public sealed class MediaStreamSource : IMediaSource {
IReference<double> MaxSupportedPlaybackRate { get; set; }
}
public enum TimedMetadataKind {
ImageSubtitle = 6,
}
public enum TimedTextFontStyle
public sealed class TimedTextSource {
public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream);
public static TimedTextSource CreateFromStreamWithIndex(IRandomAccessStream stream, IRandomAccessStream indexStream, string defaultLanguage);
public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri);
public static TimedTextSource CreateFromUriWithIndex(Uri uri, Uri indexUri, string defaultLanguage);
}
public sealed class TimedTextStyle {
TimedTextFontStyle FontStyle { get; set; }
bool IsLineThroughEnabled { get; set; }
bool IsOverlineEnabled { get; set; }
bool IsUnderlineEnabled { get; set; }
}
}
namespace Windows.Media.Core.Preview {
public static class SoundLevelBroker
}
namespace Windows.Media.MediaProperties {
public static class MediaEncodingSubtypes {
public static string D16 { get; }
public static string L16 { get; }
public static string L8 { get; }
public static string Vp9 { get; }
}
public enum SphericalVideoFrameFormat
public sealed class VideoEncodingProperties : IMediaEncodingProperties {
SphericalVideoFrameFormat SphericalVideoFrameFormat { get; }
}
}
namespace Windows.Media.Playback {
public enum AutoLoadedDisplayPropertyKind
public sealed class CurrentMediaPlaybackItemChangedEventArgs {
MediaPlaybackItemChangedReason Reason { get; }
}
public sealed class MediaPlaybackItem : IMediaPlaybackSource {
AutoLoadedDisplayPropertyKind AutoLoadedDisplayProperties { get; set; }
bool IsDisabledInPlaybackList { get; set; }
double TotalDownloadProgress { get; }
}
public enum MediaPlaybackItemChangedReason
public sealed class MediaPlaybackList : IMediaPlaybackSource {
IReference<uint> MaxPlayedItemsToKeepOpen { get; set; }
}
public sealed class MediaPlaybackSession {
bool IsMirroring { get; set; }
MediaPlaybackSphericalVideoProjection SphericalVideoProjection { get; }
event TypedEventHandler<MediaPlaybackSession, object> BufferedRangesChanged;
event TypedEventHandler<MediaPlaybackSession, object> PlayedRangesChanged;
event TypedEventHandler<MediaPlaybackSession, object> SeekableRangesChanged;
event TypedEventHandler<MediaPlaybackSession, object> SupportedPlaybackRatesChanged;
IVectorView<MediaTimeRange> GetBufferedRanges();
IVectorView<MediaTimeRange> GetPlayedRanges();
IVectorView<MediaTimeRange> GetSeekableRanges();
bool IsSupportedPlaybackRateRange(double rate1, double rate2);
}
public sealed class MediaPlaybackSphericalVideoProjection
}
namespace Windows.Media.Protection.PlayReady {
public interface IPlayReadyLicenseSession2 : IPlayReadyLicenseSession
public sealed class PlayReadyLicense : IPlayReadyLicense {
bool ExpiresInRealTime { get; }
bool InMemoryOnly { get; }
Guid SecureStopId { get; }
uint SecurityLevel { get; }
}
public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
}
public sealed class PlayReadyLicenseSession : IPlayReadyLicenseSession, IPlayReadyLicenseSession2 {
PlayReadyLicenseIterable CreateLicenseIterable(PlayReadyContentHeader contentHeader, bool fullyEvaluated);
}
}
namespace Windows.Media.SpeechSynthesis {
public sealed class SpeechSynthesisOptions
public sealed class SpeechSynthesizer : IClosable {
SpeechSynthesisOptions Options { get; }
}
}
namespace Windows.Media.Streaming.Adaptive {
public sealed class AdaptiveMediaSource : IClosable, IMediaSource {
IReference<TimeSpan> DesiredSeekableWindowSize { get; set; }
AdaptiveMediaSourceDiagnostics Diagnostics { get; }
IReference<TimeSpan> MaxSeekableWindowSize { get; }
IReference<TimeSpan> MinLiveOffset { get; }
void Close();
AdaptiveMediaSourceCorrelatedTimes GetCorrelatedTimes();
}
public sealed class AdaptiveMediaSourceCorrelatedTimes
public sealed class AdaptiveMediaSourceDiagnosticAvailableEventArgs
public sealed class AdaptiveMediaSourceDiagnostics
public enum AdaptiveMediaSourceDiagnosticType
public sealed class AdaptiveMediaSourceDownloadBitrateChangedEventArgs {
AdaptiveMediaSourceDownloadBitrateChangedReason Reason { get; }
}
public enum AdaptiveMediaSourceDownloadBitrateChangedReason
}
namespace Windows.Networking.NetworkOperators {
public sealed class MobileBroadbandAccount {
Uri AccountExperienceUrl { get; }
}
public sealed class MobileBroadbandDeviceInformation {
string SimGid1 { get; }
string SimPnn { get; }
string SimSpn { get; }
}
}
namespace Windows.Payments {
public interface IPaymentItem
public sealed class PaymentAddress
public static class PaymentAppRegistration
public sealed class PaymentCurrencyAmount
public sealed class PaymentDetails
public sealed class PaymentDetailsModifier
public sealed class PaymentItem : IPaymentItem
public static class PaymentMediator
public sealed class PaymentMerchantInfo
public sealed class PaymentMethodData
public enum PaymentOptionPresence
public sealed class PaymentOptions
public sealed class PaymentRequest
public sealed class PaymentRequestChangedEventArgs
public delegate IAsyncOperation<PaymentRequestChangedEventResult> PaymentRequestChangedEventHandler(PaymentRequest paymentRequest, PaymentRequestChangedEventArgs args);
public sealed class PaymentRequestChangedEventResult
public enum PaymentRequestChangeSource
public enum PaymentRequestCompletionStatus
public enum PaymentRequestStatus
public sealed class PaymentRequestSubmitResult
public sealed class PaymentResponse
public sealed class PaymentShippingOption : IPaymentItem
public sealed class PaymentToken
public sealed class PaymentTransaction
public sealed class PaymentTransactionAcceptResult
}
namespace Windows.Perception.Spatial.Preview {
public interface ISpatialAnchorStorage
public sealed class SpatialAnchorMetadata
public enum SpatialAnchorStorageContentChange
public sealed class SpatialAnchorStorageContentChangedEventArgs
public sealed class SpatialElement
public sealed class SpatialElementChangedEventArgs
public sealed class SpatialElementStore
}
namespace Windows.Perception.Spatial.Preview.Sharing {
public interface ISpatialSharingSession
public interface ISpatialSharingSessionHost
public interface ISpatialSharingSessionManager
public sealed class SessionChangedEventArgs
public sealed class SessionInviteReceivedEventArgs
public sealed class SessionMessageReceivedEventArgs
public sealed class SessionParticipantEventArgs
public sealed class SessionParticipantLeftEventArgs
public sealed class SpatialSharingDevice
public sealed class SpatialSharingQueryResult
public sealed class SpatialSharingSession : ISpatialAnchorStorage, ISpatialSharingSession
public sealed class SpatialSharingSessionHost : ISpatialSharingSessionHost
public sealed class SpatialSharingSessionInvite
public sealed class SpatialSharingSessionManager : ISpatialSharingSessionManager
public sealed class SpatialSharingSessionParticipant
public enum SpatialSharingSessionState
public sealed class SpatialSharingSessionToken
}
namespace Windows.Security.Cryptography.Certificates {
public sealed class CertificateExtension
public sealed class CertificateRequestProperties {
IVector<CertificateExtension> Extensions { get; }
SubjectAlternativeNameInfo SubjectAlternativeName { get; }
IVector<string> SuppressedDefaults { get; }
}
public sealed class SubjectAlternativeNameInfo {
IVector<string> DistinguishedNames { get; }
IVector<string> DnsNames { get; }
IVector<string> EmailNames { get; }
CertificateExtension Extension { get; }
IVector<string> IPAddresses { get; }
IVector<string> PrincipalNames { get; }
IVector<string> Urls { get; }
}
}
namespace Windows.Services.Cortana {
public enum CortanaPermission
public enum CortanaPermissionsChangeResult
public sealed class CortanaPermissionsManager
}
namespace Windows.Services.Maps {
public sealed class EnhancedWaypoint
public static class MapRouteFinder {
public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints);
public static IAsyncOperation<MapRouteFinderResult> GetDrivingRouteFromEnhancedWaypointsAsync(IIterable<EnhancedWaypoint> waypoints, MapRouteDrivingOptions options);
}
public static class MapService {
public static MapServiceDataUsagePreference DataUsagePreference { get; set; }
}
public enum MapServiceDataUsagePreference
public enum WaypointKind
}
namespace Windows.Services.Maps.OfflineMaps {
public sealed class OfflineMapPackage
public sealed class OfflineMapPackageQueryResult
public enum OfflineMapPackageQueryStatus
public sealed class OfflineMapPackageStartDownloadResult
public enum OfflineMapPackageStartDownloadStatus
public enum OfflineMapPackageStatus
}
namespace Windows.System {
public sealed class DispatcherQueue
public delegate void DispatcherQueueHandler();
public delegate IAsyncAction DispatcherQueueHandlerAsync();
public sealed class DispatcherQueueOptions
public enum DispatcherQueuePriority
public sealed class DispatcherQueueTimer
}
namespace Windows.System.Preview.RemoteSessions {
public enum BinaryChannelTransportMode
public sealed class RemoteSession
public sealed class RemoteSessionAddedEventArgs
public sealed class RemoteSessionBinaryChannel
public sealed class RemoteSessionBinaryMessageReceivedEventArgs
public enum RemoteSessionConnectionStatus
public sealed class RemoteSessionConnectResult
public sealed class RemoteSessionDisconnectedEventArgs
public enum RemoteSessionDisconnectedReason
public sealed class RemoteSessionInfo
public sealed class RemoteSessionInvitationManager
public sealed class RemoteSessionInvitationReceivedEventArgs
public sealed class RemoteSessionJoinRequest
public sealed class RemoteSessionJoinRequestedEventArgs
public sealed class RemoteSessionParticipant
public sealed class RemoteSessionParticipantChangedEventArgs
public sealed class RemoteSessionRemovedEventArgs
public sealed class RemoteSessionUpdatedEventArgs
public sealed class RemoteSessionWatcher
}
namespace Windows.System.Profile {
public static class EducationSettings
}
namespace Windows.System.RemoteSystems {
public sealed class RemoteSystem {
IAsyncOperation<bool> GetResourceAvailableAsync(string query);
}
}
namespace Windows.System.RemoteSystems.Preview {
public static class RemoteSystemResourceQuery
}
namespace Windows.UI.Composition {
public class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
}
public sealed class CompositionGraphicsDevice : CompositionObject {
CompositionVirtualDrawingSurface CreateVirtualDrawingSurface(Size sizePixels, DirectXPixelFormat pixelFormat, DirectXAlphaMode alphaMode);
}
public sealed class CompositionVirtualDrawingSurface : CompositionDrawingSurface, ICompositionSurface
public sealed class CompositionVisualSurface : CompositionObject, ICompositionSurface
public sealed class CompositionWindowBackdropBrush : CompositionBrush
public sealed class Compositor : IClosable {
CompositionVisualSurface CreateVisualSurface();
CompositionWindowBackdropBrush CreateWindowBackdropBrush();
}
public sealed class LayerVisual : ContainerVisual {
CompositionShadow Shadow { get; set; }
}
public class Visual : CompositionObject {
Vector3 RelativeOffset { get; set; }
Vector2 RelativeSize { get; set; }
Visual TransformParent { get; set; }
}
}
namespace Windows.UI.Core {
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
event TypedEventHandler<CoreWindow, object> ResizeCompleted;
event TypedEventHandler<CoreWindow, object> ResizeStarted;
}
}
namespace Windows.UI.Input {
public static class KnownSimpleHapticsControllerWaveforms
public sealed class RadialController {
event TypedEventHandler<RadialController, RadialControllerButtonHoldingEventArgs> ButtonHolding;
event TypedEventHandler<RadialController, RadialControllerButtonPressedEventArgs> ButtonPressed;
event TypedEventHandler<RadialController, RadialControllerButtonReleasedEventArgs> ButtonReleased;
}
public sealed class RadialControllerButtonClickedEventArgs {
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerButtonHoldingEventArgs
public sealed class RadialControllerButtonPressedEventArgs
public sealed class RadialControllerButtonReleasedEventArgs
public sealed class RadialControllerConfiguration {
RadialController ActiveControllerWhenMenuIsSuppressed { get; set; }
bool IsMenuSuppressed { get; set; }
}
public sealed class RadialControllerControlAcquiredEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerMenuItem {
public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily);
public static RadialControllerMenuItem CreateFromFontGlyph(string displayText, string glyph, string fontFamily, Uri fontUri);
}
public sealed class RadialControllerRotationChangedEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerScreenContactContinuedEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class RadialControllerScreenContactEndedEventArgs
public sealed class RadialControllerScreenContactStartedEventArgs {
bool IsButtonPressed { get; }
SimpleHapticsController SimpleHapticsController { get; }
}
public sealed class SimpleHapticsController
public sealed class SimpleHapticsControllerFeedback
}
namespace Windows.UI.Input.Core {
public sealed class RadialControllerIndependentInputSource
}
namespace Windows.UI.Input.Inking {
public enum InkPersistenceFormat
public sealed class InkPresenterProtractor : IInkPresenterStencil
public sealed class InkPresenterRuler : IInkPresenterStencil {
bool AreTickMarksVisible { get; set; }
bool IsCompassVisible { get; set; }
}
public enum InkPresenterStencilKind {
Protractor = 2,
}
public sealed class InkStroke {
uint Id { get; }
IReference<TimeSpan> StrokeDuration { get; set; }
IReference<DateTime> StrokeStartedTime { get; set; }
}
public sealed class InkStrokeBuilder {
InkStroke CreateStrokeFromInkPoints(IIterable<InkPoint> inkPoints, Matrix3x2 transform, IReference<DateTime> strokeStartedTime, IReference<TimeSpan> strokeDuration);
}
public sealed class InkStrokeContainer : IInkStrokeContainer {
InkStroke GetStrokeById(uint id);
IAsyncOperationWithProgress<uint, uint> SaveAsync(IOutputStream outputStream, InkPersistenceFormat inkPersistenceFormat);
}
}
namespace Windows.UI.Input.Spatial {
public sealed class SpatialHoldCompletedEventArgs {
SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
}
public sealed class SpatialHoldStartedEventArgs {
SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
}
public sealed class SpatialInteractionDetectedEventArgs {
SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
}
public enum SpatialInteractionKind
public sealed class SpatialInteractionSource {
bool SupportsPointing { get; }
}
public sealed class SpatialInteractionSourceEventArgs {
SpatialInteractionKind InteractionKind { get; }
SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
}
public sealed class SpatialInteractionSourceState {
bool IsGrasped { get; }
bool IsPrimaryPressed { get; }
bool IsSecondaryPressed { get; }
SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
}
public sealed class SpatialPointerPose {
SpatialPointingPose TryGetPointingPose(SpatialInteractionSource source);
}
public sealed class SpatialPointingPose
public sealed class SpatialTappedEventArgs {
SpatialPointingPose TryGetPointingPose(SpatialCoordinateSystem coordinateSystem);
}
}
namespace Windows.UI.Notifications {
public sealed class NotificationData
public enum NotificationUpdateResult
public sealed class ToastCollection
public sealed class ToastCollectionManager
public sealed class ToastNotification {
NotificationData Data { get; set; }
}
public sealed class ToastNotificationHistoryChangedTriggerDetail {
string CollectionId { get; }
}
public static class ToastNotificationManager {
public static ToastNotificationManagerForUser Current { get; }
}
public sealed class ToastNotificationManagerForUser {
IAsyncOperation<ToastNotificationHistory> GetHistoryForToastCollectionIdAsync(string collectionId);
ToastCollectionManager GetToastCollectionManager();
ToastCollectionManager GetToastCollectionManager(string appId);
IAsyncOperation<ToastNotifier> GetToastNotifierForToastCollectionIdAsync(string collectionId);
}
public sealed class ToastNotifier {
NotificationUpdateResult Update(NotificationData data, string tag);
NotificationUpdateResult Update(NotificationData data, string tag, string group);
}
}
namespace Windows.UI.Text {
public enum TextDecorations : uint
}
namespace Windows.UI.ViewManagement {
public sealed class ApplicationView {
IAsyncOperation<bool> TryConsolidateAsync();
}
public sealed class ApplicationViewConsolidatedEventArgs {
bool IsAppInitiated { get; }
}
}
namespace Windows.UI.WebUI {
public sealed class WebUIContactPanelActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContactPanelActivatedEventArgs
public sealed class WebUILockScreenComponentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral
}
namespace Windows.UI.Xaml {
public sealed class BringIntoViewOptions
public class FrameworkElement : UIElement {
public static void DeferTree(DependencyObject element);
}
public class UIElement : DependencyObject {
double KeyTipHorizontalOffset { get; set; }
public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
KeyTipPlacementMode KeyTipPlacementMode { get; set; }
public static DependencyProperty KeyTipPlacementModeProperty { get; }
double KeyTipVerticalOffset { get; set; }
public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
XYFocusKeyboardNavigationMode XYFocusKeyboardNavigation { get; set; }
public static DependencyProperty XYFocusKeyboardNavigationProperty { get; }
void StartBringIntoView();
void StartBringIntoView(BringIntoViewOptions options);
}
}
namespace Windows.UI.Xaml.Automation {
public sealed class AutomationElementIdentifiers {
public static AutomationProperty CultureProperty { get; }
}
public sealed class AutomationProperties {
public static DependencyProperty CultureProperty { get; }
public static int GetCulture(DependencyObject element);
public static void SetCulture(DependencyObject element, int value);
}
}
namespace Windows.UI.Xaml.Automation.Peers {
public class AutomationPeer : DependencyObject {
int GetCulture();
virtual int GetCultureCore();
}
public sealed class MapControlAutomationPeer : FrameworkElementAutomationPeer, IScrollProvider, ITransformProvider, ITransformProvider2 {
bool CanMove { get; }
bool CanResize { get; }
bool CanRotate { get; }
bool CanZoom { get; }
double MaxZoom { get; }
double MinZoom { get; }
double ZoomLevel { get; }
void Move(double x, double y);
void Resize(double width, double height);
void Rotate(double degrees);
void Zoom(double zoom);
void ZoomByUnit(ZoomUnit zoomUnit);
}
}
namespace Windows.UI.Xaml.Controls {
public class ContentDialog : ContentControl {
bool IsTertiaryButtonEnabled { get; set; }
public static DependencyProperty IsTertiaryButtonEnabledProperty { get; }
Style PrimaryButtonStyle { get; set; }
public static DependencyProperty PrimaryButtonStyleProperty { get; }
Style SecondaryButtonStyle { get; set; }
public static DependencyProperty SecondaryButtonStyleProperty { get; }
ICommand TertiaryButtonCommand { get; set; }
object TertiaryButtonCommandParameter { get; set; }
public static DependencyProperty TertiaryButtonCommandParameterProperty { get; }
public static DependencyProperty TertiaryButtonCommandProperty { get; }
Style TertiaryButtonStyle { get; set; }
public static DependencyProperty TertiaryButtonStyleProperty { get; }
string TertiaryButtonText { get; set; }
public static DependencyProperty TertiaryButtonTextProperty { get; }
event TypedEventHandler<ContentDialog, ContentDialogButtonClickEventArgs> TertiaryButtonClick;
}
public enum ContentDialogResult {
Tertiary = 3,
}
public class Control : FrameworkElement {
Uri DefaultStyleResourceUri { get; set; }
public static DependencyProperty DefaultStyleResourceUriProperty { get; }
}
public sealed class FocusEngagedEventArgs : RoutedEventArgs {
bool Handled { get; set; }
}
public class Frame : ContentControl, INavigate {
void SetNavigationState(string navigationState, bool suppressNavigate);
}
public class InkToolbar : Control {
InkToolbarButtonFlyoutPlacement ButtonFlyoutPlacement { get; set; }
public static DependencyProperty ButtonFlyoutPlacementProperty { get; }
bool IsStencilButtonChecked { get; set; }
public static DependencyProperty IsStencilButtonCheckedProperty { get; }
Orientation Orientation { get; set; }
public static DependencyProperty OrientationProperty { get; }
event TypedEventHandler<InkToolbar, object> BringStencilIntoViewRequested;
event TypedEventHandler<InkToolbar, object> EraserWidthChanged;
event TypedEventHandler<InkToolbar, InkToolbarIsStencilButtonCheckedChangedEventArgs> IsStencilButtonCheckedChanged;
InkToolbarMenuButton GetMenuButton(InkToolbarMenuKind menu);
}
public enum InkToolbarButtonFlyoutPlacement
public class InkToolbarEraserButton : InkToolbarToolButton {
InkToolbarEraserKind EraserKind { get; set; }
public static DependencyProperty EraserKindProperty { get; }
bool IsClearAllVisible { get; set; }
public static DependencyProperty IsClearAllVisibleProperty { get; }
bool IsWidthSliderVisible { get; set; }
public static DependencyProperty IsWidthSliderVisibleProperty { get; }
double MaxStrokeWidth { get; set; }
public static DependencyProperty MaxStrokeWidthProperty { get; }
double MinStrokeWidth { get; set; }
public static DependencyProperty MinStrokeWidthProperty { get; }
double SelectedStrokeWidth { get; set; }
public static DependencyProperty SelectedStrokeWidthProperty { get; }
}
public enum InkToolbarEraserKind
public class InkToolbarFlyoutItem : ButtonBase
public enum InkToolbarFlyoutItemKind
public sealed class InkToolbarIsStencilButtonCheckedChangedEventArgs
public class InkToolbarMenuButton : ToggleButton
public enum InkToolbarMenuKind
public class InkToolbarPenConfigurationControl : Control {
InkToolbarEraserButton EraserButton { get; }
public static DependencyProperty EraserButtonProperty { get; }
}
public class InkToolbarStencilButton : InkToolbarMenuButton
public enum InkToolbarStencilKind
public sealed class RichTextBlock : FrameworkElement {
TextDecorations TextDecorations { get; set; }
public static DependencyProperty TextDecorationsProperty { get; }
}
public sealed class TextBlock : FrameworkElement {
TextDecorations TextDecorations { get; set; }
public static DependencyProperty TextDecorationsProperty { get; }
}
}
namespace Windows.UI.Xaml.Controls.Maps {
public sealed class MapBillboard : MapElement
public sealed class MapContextRequestedEventArgs
public sealed class MapControl : Control {
MapProjection MapProjection { get; set; }
public static DependencyProperty MapProjectionProperty { get; }
MapStyleSheet StyleSheet { get; set; }
public static DependencyProperty StyleSheetProperty { get; }
Thickness ViewPadding { get; set; }
public static DependencyProperty ViewPaddingProperty { get; }
event TypedEventHandler<MapControl, MapContextRequestedEventArgs> MapContextRequested;
IVectorView<MapElement> FindMapElementsAtOffset(Point offset, double radius);
void GetLocationFromOffset(Point offset, AltitudeReferenceSystem desiredReferenceSystem, out Geopoint location);
void StartContinuousPan(double horizontalPixelsPerSecond, double verticalPixelsPerSecond);
void StopContinuousPan();
IAsyncOperation<bool> TryPanAsync(double horizontalPixels, double verticalPixels);
IAsyncOperation<bool> TryPanToAsync(Geopoint location);
}
public enum MapProjection
public enum MapStyle {
Custom = 7,
}
public sealed class MapStyleSheet : DependencyObject
}
namespace Windows.UI.Xaml.Controls.Primitives {
public class FlyoutBase : DependencyObject {
DependencyObject OverlayInputPassThroughElement { get; set; }
public static DependencyProperty OverlayInputPassThroughElementProperty { get; }
}
}
namespace Windows.UI.Xaml.Documents {
public sealed class Hyperlink : Span {
FocusState FocusState { get; }
public static DependencyProperty FocusStateProperty { get; }
event RoutedEventHandler GotFocus;
event RoutedEventHandler LostFocus;
bool Focus(FocusState value);
}
public class TextElement : DependencyObject {
double KeyTipHorizontalOffset { get; set; }
public static DependencyProperty KeyTipHorizontalOffsetProperty { get; }
KeyTipPlacementMode KeyTipPlacementMode { get; set; }
public static DependencyProperty KeyTipPlacementModeProperty { get; }
double KeyTipVerticalOffset { get; set; }
public static DependencyProperty KeyTipVerticalOffsetProperty { get; }
TextDecorations TextDecorations { get; set; }
public static DependencyProperty TextDecorationsProperty { get; }
event TypedEventHandler<TextElement, AccessKeyDisplayDismissedEventArgs> AccessKeyDisplayDismissed;
event TypedEventHandler<TextElement, AccessKeyDisplayRequestedEventArgs> AccessKeyDisplayRequested;
event TypedEventHandler<TextElement, AccessKeyInvokedEventArgs> AccessKeyInvoked;
}
}
namespace Windows.UI.Xaml.Input {
public sealed class AccessKeyManager {
public static bool AreKeyTipsEnabled { get; set; }
}
public enum KeyTipPlacementMode
public enum XYFocusKeyboardNavigationMode
}
namespace Windows.UI.Xaml.Markup {
public sealed class XamlMarkupHelper
}
 
namespace Windows.Media.Capture {
public sealed class AppCaptureDurationGeneratedEventArgs
public sealed class AppCaptureFileGeneratedEventArgs
public enum AppCaptureMicrophoneCaptureState
public sealed class AppCaptureMicrophoneCaptureStateChangedEventArgs
public enum AppCaptureRecordingState
public sealed class AppCaptureRecordingStateChangedEventArgs
public sealed class AppCaptureRecordOperation
public sealed class AppCaptureServices
public sealed class AppCaptureState
}
 
namespace Windows.Services.Store {
public sealed class StoreContext {
IAsyncOperation<StoreProductResult> FindStoreProductForPackageAsync(IIterable<string> productKinds, Package package);
}
}

API Removals

namespace Windows.UI.Composition {
public sealed class CompositionDrawingSurface : CompositionObject, ICompositionSurface {
}
}

API Additions not yet implemented

The Bluetooth APIs were included to receive feedback from the Developer community.

namespace Windows.Devices.Bluetooth {
public sealed class BluetoothAdapter
public sealed class BluetoothDeviceId
public enum BluetoothError {
TransportNotSupported = 9,
}
public sealed class BluetoothLEDevice : IClosable {
DeviceAccessInformation DeviceAccessInformation { get; }
IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync();
IAsyncOperation<GattDeviceServicesResult> GetGattServicesAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(GattUuid serviceUuid);
IAsyncOperation<GattDeviceServicesResult> GetGattServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<DeviceAccessStatus> RequestAccessAsync();
}
public enum BluetoothTransportOptions : uint
}
namespace Windows.Devices.Bluetooth.Background {
public enum BluetoothEventTriggeringMode
public sealed class GattCharacteristicNotificationTriggerDetails {
BluetoothError Error { get; }
BluetoothEventTriggeringMode EventTriggeringMode { get; }
IVectorView<GattValueChangedEventArgs> ValueChangedEvents { get; }
}
public sealed class GattServiceProviderBackgroundInfo
public sealed class GattServiceProviderRequestActivityInfo
public enum GattServiceProviderRequestActivityType
public enum GattServiceProviderRequestAttributeType
public sealed class GattServiceProviderTriggerDetails
public enum GattServiceProviderTriggerReason
}
namespace Windows.Devices.Bluetooth.GenericAttributeProfile {
public sealed class GattCharacteristic {
IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync();
IAsyncOperation<GattDescriptorsResult> GetDescriptorsAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(GattUuid descriptorUuid);
IAsyncOperation<GattDescriptorsResult> GetDescriptorsForUuidAsync(GattUuid descriptorUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value, GattWriteOption writeOption);
}
public sealed class GattCharacteristicsResult
public sealed class GattClientNotificationResult
public enum GattCommunicationStatus {
ProtocolError = 2,
}
public sealed class GattDescriptor {
IAsyncOperation<GattWriteResult> WriteValueWithResultAsync(IBuffer value);
}
public sealed class GattDescriptorsResult
public sealed class GattDeviceService : IClosable {
DeviceAccessInformation DeviceAccessInformation { get; }
GattSession Session { get; }
public static IAsyncOperation<GattDeviceService> FromIdAsync(string deviceId, GattSharingMode sharingMode);
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync();
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(GattUuid characteristicUuid);
IAsyncOperation<GattCharacteristicsResult> GetCharacteristicsForUuidAsync(GattUuid characteristicUuid, BluetoothCacheMode cacheMode);
public static string GetDeviceSelector(GattUuid gattUuid);
public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId);
public static string GetDeviceSelectorForBluetoothDeviceId(BluetoothDeviceId bluetoothDeviceId, BluetoothCacheMode cacheMode);
public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid);
public static string GetDeviceSelectorForBluetoothDeviceIdAndGattUuid(BluetoothDeviceId bluetoothDeviceId, GattUuid gattUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync();
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesAsync(BluetoothCacheMode cacheMode);
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(GattUuid serviceUuid);
IAsyncOperation<GattDeviceServicesResult> GetIncludedServicesForUuidAsync(GattUuid serviceUuid, BluetoothCacheMode cacheMode);
IAsyncOperation<DeviceAccessStatus> RequestAccessAsync(GattSharingMode sharingMode);
}
public sealed class GattDeviceServicesResult
public sealed class GattLocalCharacteristic
public sealed class GattLocalCharacteristicParameters
public sealed class GattLocalDescriptor
public sealed class GattLocalDescriptorParameters
public sealed class GattPresentationFormat {
public static GattPresentationFormat FromParts(byte formatType, int exponent, ushort unit, byte namespaceId, ushort description);
}
public static class GattProtocolError
public sealed class GattPublishedService
public sealed class GattReadClientCharacteristicConfigurationDescriptorResult {
IReference<byte> ProtocolError { get; }
}
public sealed class GattReadRequest
public sealed class GattReadRequestedEventArgs
public sealed class GattReadResponse
public sealed class GattReadResult {
IReference<byte> ProtocolError { get; }
}
public sealed class GattReliableWriteTransaction {
IAsyncOperation<GattWriteResult> CommitWithResultAsync();
}
public sealed class GattServiceProvider
public sealed class GattServiceProviderAdvertisingParameters
public sealed class GattServiceProviderResult
public enum GattServiceProviderStatus
public sealed class GattServiceProviderStatusChangedEventArgs
public enum GattServiceType
public sealed class GattSession : IClosable
public enum GattSessionStatus
public sealed class GattSessionStatusChangedEventArgs
public enum GattSharingMode
public sealed class GattSubscribedClient
public sealed class GattUuid
public sealed class GattWriteRequest
public sealed class GattWriteRequestedEventArgs
public sealed class GattWriteResponse
public sealed class GattWriteResult
}
namespace Windows.Devices.Bluetooth.Rfcomm {
public sealed class RfcommDeviceService : IClosable {
public static IAsyncOperation<RfcommDeviceServicesResult> FromIdWithResultAsync(string deviceId);
}
public sealed class RfcommServiceProvider {
public static IAsyncOperation<RfcommServiceProviderResult> CreateWithResultAsync(RfcommServiceId serviceId);
}
public sealed class RfcommServiceProviderResult
}
 

Introducing the UWP Community Toolkit

Recently, we released the Windows Anniversary Update and a new Windows Software Developer Kit (SDK) for Windows 10 containing tools, app templates, platform controls, Windows Runtime APIs, emulators and much more, to help create innovative and compelling Universal Windows apps.

Today, we are introducing the open-source UWP Community Toolkit, a new project that enables the developer community to collaborate and contribute new capabilities on top of the SDK.

We designed the toolkit with these goals in mind:

1. Simplified app development: The toolkit includes new capabilities (helper functions, custom controls and app services) that simplify or demonstrate common developer tasks. Where possible, our goal is to allow app developers to get started with just one line of code.
2. Open-Source: The toolkit (source code, issues and roadmap) will be developed as an open-source project. We welcome contributions from the .NET developer community.
3. Alignment with SDK: The feedback from the community on this project will be reflected in future versions of the Windows SDK for Windows 10.

For example, the toolkit makes it easy to share content from your app with social providers like Twitter, taking care of all the OAuth authentication steps for you behind the scenes.

// Initialize service
TwitterService.Instance.Initialize("ConsumerKey", "ConsumerSecret", "CallbackUri");
// Login to Twitter
await TwitterService.Instance.LoginAsync();
// Post a tweet
await TwitterService.Instance.TweetStatusAsync("Hello UWP!");

Additionally, the toolkit provides extension methods that allow developers to animate UI elements with just one line of code.

await element.Rotate(30f).Fade(0.5).Offset(5f).StartAsync();

Below you will find more details about the features in the first release, how to get started, the roadmap and how to contribute.

UWP Community Toolkit 1.0

The toolkit can be used by any new or existing UWP application written in C# or VB.NET. Our goal is to support the latest and previous stable release of the SDK and at this time, the toolkit is compatible with apps developed with Windows 10 SDK Build 10586 or above.

The toolkit can be used to build UWP apps for any Windows 10 device, including PC, Mobile, XBOX, IoT and HoloLens. You can also use the toolkit with an existing desktop app converted to UWP using the Desktop Bridge.

Here are just some of the features included in the first release of the toolkit.

image1

We are also releasing the UWP Community Toolkit Sample App in the Windows Store that makes it easy to preview the toolkit capabilities even before installing the tools or downloading the SDK. The app will also allow you to easily copy & paste the code you will need to get started using the toolkit in your project.

image2

Getting Started

It’s easy to get started:

1. Download Visual Studio 2015 with Update 3 and the Windows 10 SDK
2. Create a new UWP project (or open an existing one)
3. Launch Visual Studio 2015
4. Create a new project using the Blank App template under Visual C# Windows Universal

Image 3

5. Add the UWP Community Toolkit to your project
6. In Solution Explorer panel, right click on your project name and select “Manage NuGet Packages”

image4

7. Search for “Microsoft.Toolkit.UWP”
8. Select desired packages and install them

image5

9. Add a reference to the toolkit in your XAML pages or C#

          a. In your XAML page, add a reference at the top of your page

<Page  x:Class="MainPage"
xmlns:controls="using:Microsoft.Toolkit.Uwp.UI.Controls"
...

          b. In your C# page, add the namespaces to the toolkit

using Microsoft.Toolkit.Uwp;
namespace MyApp
{
...

10. You can copy & paste code snippets for each feature from the Sample App, or find more details in the documentation.

Roadmap

In the future, we plan to release stable updates through the Visual Studio NuGet package at a regular cadence.

The toolkit is completely open-sourced on GitHub, including the source code of the toolkit, source code of the sample app and even the documentation. The roadmap for the next release is available here.

  • If you need to report a bug or share a feature request, please use this form.
  • If you would like to contribute your code, please start from here.

We are excited about the contributions that several community members already submitted in this first release, including Morten Nielsen, Scott Lovegrove, Pedro Lamas, Oren Novotny, James Croft, Diederik Krols, Hermit Dave, Thomas Nigro, Laurent Bugnion, Samuel Blanchard and Rudy Hyun. We are looking forward to continuing to grow the toolkit with even more community contributions.

So please go browse the sample app and learn about the experiences, then grab the NuGet package yourself and play around. We want developers to give us feedback on the usability and helpfulness of the features that exist in the toolkit. There is much to do in an open source project: we can get some help to improve accessibility and localization, and ensure the current capabilities work for all apps.

And while you are at it, JOIN THE FUN!

Giorgio Sardo, Principal Group Program Manager, Windows/PAX

David Catuhe, Principal Program Manager, Windows/PAX

Windows 10 Anniversary SDK Preview Build 14388 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14388 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14388 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Things to note:

  • We are getting close to Windows 10 Anniversary Update on August 2nd, 2016. It is a great time to start testing end to end with all the new APIs Windows 10 Anniversary Update provides.
  • This is still a pre-release build of the SDK. While the EULA does state this is an RTM release, it is not. This release does not have a go-live license. Apps built with this SDK will not be allowed to be on-boarded to the store.

What’s New since 14383

  • Minor bug fixes, no API delta changes

Windows 10 Anniversary SDK Preview Build 14366 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14366 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14366 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Things to note

  • We have fixed the issue with the Desktop App Converter Preview (Project Centennial) however you will need to download the updated version at http://aka.ms/converter.

What’s New

namespace Windows.ApplicationModel.Core {
public static class CoreApplication {
public static void EnablePrelaunch(bool value);
}
}
namespace Windows.Gaming.Input.ForceFeedback {
public enum ConditionForceEffectKind {
Inertia = 2,
}
public sealed class ConstantForceEffect : IForceFeedbackEffect {
public ConstantForceEffect();
}
public sealed class RampForceEffect : IForceFeedbackEffect {
public RampForceEffect();
}
}
namespace Windows.Media.Protection {
public sealed class ProtectionCapabilities {
public ProtectionCapabilities();
}
}
namespace Windows.Media.Protection.PlayReady {
public sealed class PlayReadyLicenseAcquisitionServiceRequest : IMediaProtectionServiceRequest, IPlayReadyLicenseAcquisitionServiceRequest, IPlayReadyServiceRequest {
Guid SessionId { get; }
}
}
namespace Windows.UI.Input {
public sealed class RadialController {
event TypedEventHandler<RadialController, RadialControllerButtonClickedEventArgs> ButtonClicked;
event TypedEventHandler<RadialController, RadialControllerControlAcquiredEventArgs> ControlAcquired;
}
public sealed class RadialControllerButtonClickedEventArgs
public sealed class RadialControllerControlAcquiredEventArgs
}
namespace Windows.UI.WebUI {
public static class WebUIApplication {
public static void EnablePrelaunch(bool value);
}
}
namespace Windows.UI.Xaml.Automation.Peers {
public class ComboBoxAutomationPeer : SelectorAutomationPeer, IExpandCollapseProvider, IValueProvider, IWindowProvider {
WindowInteractionState InteractionState { get; }
bool IsModal { get; }
bool IsTopmost { get; }
bool Maximizable { get; }
bool Minimizable { get; }
WindowVisualState VisualState { get; }
void Close();
void SetVisualState(WindowVisualState state);
bool WaitForInputIdle(int milliseconds);
}
}

Removed APIs

namespace Windows.Gaming.Input.ForceFeedback {
public enum ConditionForceEffectKind {
Interia = 2,
}
}

Windows 10 Anniversary SDK Preview Build 14332 Released

Today, we released a new Windows 10 Anniversary SDK Preview to be used in conjunction with Windows 10 Insider Preview (Build 14332 or greater). The Preview SDK is a pre-release and cannot be used in a production environment. Please only install the SDK on your test machine. The Preview SDK Build 14332 contains bug fixes and under development changes to the API surface area. If you are working on an application that you need to submit to the store, you should not install the preview.

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 feature requests, head over to our Windows Platform UserVoice.

Known issues

  • Desktop App Converter
    • The Desktop App Converter Preview (Project Centennial) will fail to run on the Windows 10 Insider Preview Build 14332. If you are a developer utilizing the converter tool to convert your desktop app to UWP, we suggest skipping Build 14332 until we can fix this issue.
  • Emulator
    • Known issue that currently blocks our users from injecting fake location data to their UWP applications running in the emulator

What’s New

This Windows SDK includes the following updates and additions to the Windows namespace since Preview SDK Build 14295. We sadly didn’t do a changelog for 14267 to 14295.

namespace Windows.ApplicationModel {
public sealed class EnteredBackgroundEventArgs : IEnteredBackgroundEventArgs
public interface IEnteredBackgroundEventArgs
public interface ILeavingBackgroundEventArgs
public sealed class LeavingBackgroundEventArgs : ILeavingBackgroundEventArgs
public sealed class Package {
IAsyncOperation<bool> VerifyContentIntegrityAsync();
}
public sealed class PackageCatalog
public sealed class PackageInstallingEventArgs
public sealed class PackageStagingEventArgs
public sealed class PackageStatusChangedEventArgs
public sealed class PackageUninstallingEventArgs
public sealed class PackageUpdatingEventArgs
}
namespace Windows.ApplicationModel.Activation {
public enum ActivationKind {
FilePickerExperience = 1015,
UserDataAccountsProvider = 1014,
}
public sealed class AppointmentsProviderAddAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderAddAppointmentActivatedEventArgs {
User User { get; }
}
public sealed class AppointmentsProviderRemoveAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderRemoveAppointmentActivatedEventArgs {
User User { get; }
}
public sealed class AppointmentsProviderReplaceAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderReplaceAppointmentActivatedEventArgs {
User User { get; }
}
public sealed class AppointmentsProviderShowAppointmentDetailsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
User User { get; }
}
public sealed class AppointmentsProviderShowTimeFrameActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowTimeFrameActivatedEventArgs {
User User { get; }
}
public sealed class BackgroundActivatedEventArgs : IBackgroundActivatedEventArgs
public sealed class CachedFileUpdaterActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ICachedFileUpdaterActivatedEventArgs {
User User { get; }
}
public sealed class DeviceActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDeviceActivatedEventArgs, IViewSwitcherProvider {
User User { get; }
}
public sealed class DevicePairingActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IDevicePairingActivatedEventArgs {
User User { get; }
}
public sealed class DialReceiverActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDialReceiverActivatedEventArgs, ILaunchActivatedEventArgs, IViewSwitcherProvider {
User User { get; }
}
public sealed class FileActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IFileActivatedEventArgs, IFileActivatedEventArgsWithCallerPackageFamilyName, IFileActivatedEventArgsWithNeighboringFiles, IViewSwitcherProvider {
User User { get; }
}
public sealed class FileOpenPickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IFileOpenPickerActivatedEventArgs, IFileOpenPickerActivatedEventArgs2 {
User User { get; }
}
public sealed class FileOpenPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileOpenPickerContinuationEventArgs {
User User { get; }
}
public sealed class FileSavePickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IFileSavePickerActivatedEventArgs, IFileSavePickerActivatedEventArgs2 {
User User { get; }
}
public sealed class FileSavePickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileSavePickerContinuationEventArgs {
User User { get; }
}
public sealed class FolderPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFolderPickerContinuationEventArgs {
User User { get; }
}
public interface IActivatedEventArgsWithUser : IActivatedEventArgs
public interface IBackgroundActivatedEventArgs
public interface ILaunchActivatedEventArgs2 : IActivatedEventArgs, ILaunchActivatedEventArgs
public interface IUserDataAccountProviderActivatedEventArgs : IActivatedEventArgs
public sealed class LaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, ILaunchActivatedEventArgs2, IPrelaunchActivatedEventArgs, IViewSwitcherProvider {
TileActivatedInfo TileActivatedInfo { get; }
User User { get; }
}
public sealed class LockScreenActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, ILockScreenActivatedEventArgs {
User User { get; }
}
public sealed class ProtocolActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IViewSwitcherProvider {
User User { get; }
}
public sealed class ProtocolForResultsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IProtocolForResultsActivatedEventArgs, IViewSwitcherProvider {
User User { get; }
}
public sealed class RestrictedLaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IRestrictedLaunchActivatedEventArgs {
User User { get; }
}
public sealed class SearchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ISearchActivatedEventArgs, ISearchActivatedEventArgsWithLinguisticDetails, IViewSwitcherProvider {
User User { get; }
}
public sealed class ShareTargetActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IShareTargetActivatedEventArgs {
User User { get; }
}
public sealed class TileActivatedInfo
public sealed class ToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IToastNotificationActivatedEventArgs {
User User { get; }
}
public sealed class UserDataAccountProviderActivatedEventArgs : IActivatedEventArgs, IUserDataAccountProviderActivatedEventArgs
public sealed class VoiceCommandActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IVoiceCommandActivatedEventArgs {
User User { get; }
}
public sealed class WebAccountProviderActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsWithUser, IWebAccountProviderActivatedEventArgs {
User User { get; }
}
}
namespace Windows.ApplicationModel.Appointments {
public enum AppointmentCalendarOtherAppReadAccess {
None = 3,
}
public static class AppointmentManager {
public static AppointmentManagerForUser GetForUser(User user);
}
public sealed class AppointmentManagerForUser
}
namespace Windows.ApplicationModel.AppService {
public sealed class AppServiceConnection : IClosable {
User User { get; set; }
IAsyncOperation<AppServiceConnectionStatus> OpenRemoteAsync(RemoteSystemConnectionRequest remoteSystemConnectionRequest);
}
public enum AppServiceConnectionStatus {
NotAuthorized = 7,
RemoteSystemNotSupportedByApp = 6,
RemoteSystemUnavailable = 5,
}
public enum AppServiceResponseStatus {
MessageSizeTooLarge = 5,
RemoteSystemUnavailable = 4,
}
public sealed class AppServiceTriggerDetails {
bool IsRemoteSystemConnection { get; }
}
}
namespace Windows.ApplicationModel.Background {
public enum BackgroundAccessStatus {
AllowedSubjectToSystemPolicy = 5,
AlwaysAllowed = 4,
DeniedBySystemPolicy = 6,
DeniedByUser = 7,
}
public interface IBackgroundTaskInstance4 : IBackgroundTaskInstance
public sealed class SecondaryAuthenticationFactorAuthenticationTrigger : IBackgroundTrigger
public sealed class SocketActivityTrigger : IBackgroundTrigger {
bool IsWakeFromLowPowerSupported { get; }
}
public enum SystemTriggerType {
DefaultSignInAccountChange = 15,
}
public sealed class UserNotificationChangedTrigger : IBackgroundTrigger
}
namespace Windows.ApplicationModel.Calls {
public static class PhoneCallHistoryManager {
public static PhoneCallHistoryManagerForUser GetForUser(User user);
}
public sealed class PhoneCallHistoryManagerForUser
}
namespace Windows.ApplicationModel.Chat {
public sealed class ChatConversation : IChatItem {
ChatItemKind ItemKind { get; }
}
public sealed class ChatMessage : IChatItem {
ChatItemKind ItemKind { get; }
}
}
namespace Windows.ApplicationModel.Core {
public static class CoreApplication {
public static event EventHandler<BackgroundActivatedEventArgs> BackgroundActivated;
public static event EventHandler<EnteredBackgroundEventArgs> EnteredBackground;
public static event EventHandler<LeavingBackgroundEventArgs> LeavingBackground;
}
}
namespace Windows.ApplicationModel.DataTransfer {
public sealed class DataTransferManager {
public static bool IsSupported();
}
}
namespace Windows.ApplicationModel.Email {
public enum EmailMailboxOtherAppReadAccess {
None = 2,
}
public static class EmailManager {
public static EmailManagerForUser GetForUser(User user);
}
public sealed class EmailManagerForUser
}
namespace Windows.ApplicationModel.Store.LicenseManagement {
public static class LicenseManager {
public static IAsyncOperation<LicenseSatisfactionResult> GetSatisfactionInfosAsync(IIterable<string> contentIds, IIterable<string> keyIds);
}
public sealed class LicenseSatisfactionInfo
public sealed class LicenseSatisfactionResult
}
namespace Windows.ApplicationModel.Store.Preview {
public static class StoreConfiguration {
public static IReference<uint> GetPurchasePromptingPolicyForUser(User user);
public static IAsyncOperation<IRandomAccessStreamReference> GetStoreLogDataAsync(StoreLogOptions options);
public static bool HasStoreWebAccount();
public static bool HasStoreWebAccountForUser(User user);
public static bool IsStoreWebAccountIdForUser(User user, string webAccountId);
public static void SetPurchasePromptingPolicyForUser(User user, IReference<uint> value);
public static void SetStoreWebAccountIdForUser(User user, string webAccountId);
}
public enum StoreLogOptions : uint
public enum StoreSystemFeature {
Memory12GB = 27,
Memory16GB = 28,
Memory20GB = 29,
Memory4GB = 24,
Memory6GB = 25,
Memory8GB = 26,
VideoMemory2GB = 30,
VideoMemory4GB = 31,
VideoMemory6GB = 32,
}
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
public sealed class AppInstallManager {
IAsyncOperation<bool> GetIsAppAllowedToInstallForUserAsync(User user, string productId, string skuId, string catalogId, string correlationVector);
IAsyncOperation<bool> GetIsApplicableForUserAsync(User user, string productId, string skuId);
IAsyncOperation<IVectorView<AppInstallItem>> SearchForAllUpdatesForUserAsync(User user, string correlationVector);
IAsyncOperation<AppInstallItem> SearchForUpdatesForUserAsync(User user, string productId, string skuId, string catalogId, string correlationVector);
IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallAsync(string productId, string catalogId, string flightId, string clientId, bool repair, bool forceUseOfNonRemovableStorage, string correlationVector, PackageVolume targetVolume);
IAsyncOperation<IVectorView<AppInstallItem>> StartProductInstallForUserAsync(User user, string productId, string catalogId, string flightId, string clientId, bool repair, bool forceUseOfNonRemovableStorage, string correlationVector, PackageVolume targetVolume);
IAsyncOperation<AppInstallItem> UpdateAppByPackageFamilyNameForUserAsync(User user, string packageFamilyName, string correlationVector);
}
public sealed class AppInstallStatus {
bool ReadyForLaunch { get; }
User User { get; }
}
}
namespace Windows.ApplicationModel.UserDataAccounts {
public sealed class UserDataAccount {
string DisplayName { get; set; }
IVector<string> ExplictReadAccessPackageFamilyNames { get; }
}
public static class UserDataAccountManager {
public static UserDataAccountManagerForUser GetForUser(User user);
}
public sealed class UserDataAccountManagerForUser
public enum UserDataAccountOtherAppReadAccess {
None = 2,
}
}
namespace Windows.ApplicationModel.UserDataAccounts.Provider {
public interface IUserDataAccountProviderOperation
public sealed class UserDataAccountPartnerAccountInfo
public sealed class UserDataAccountProviderAddAccountOperation : IUserDataAccountProviderOperation
public enum UserDataAccountProviderOperationKind
public enum UserDataAccountProviderPartnerAccountKind
public sealed class UserDataAccountProviderResolveErrorsOperation : IUserDataAccountProviderOperation
public sealed class UserDataAccountProviderSettingsOperation : IUserDataAccountProviderOperation
}
namespace Windows.ApplicationModel.UserDataAccounts.SystemAccess {
public sealed class DeviceAccountConfiguration {
bool IsSyncScheduleManagedBySystem { get; set; }
}
public static class UserDataAccountSystemAccessManager {
public static IAsyncAction SuppressLocalAccountWithAccountAsync(string userDataAccountId);
}
}
namespace Windows.Data.Text {
public sealed class TextPhoneme
public sealed class TextReverseConversionGenerator {
IAsyncOperation<IVectorView<TextPhoneme>> GetPhonemesAsync(string input);
}
}
namespace Windows.Devices.AllJoyn {
public enum AllJoynAuthenticationMechanism {
EcdheSpeke = 6,
}
public sealed class AllJoynBusAttachment {
event TypedEventHandler<AllJoynBusAttachment, AllJoynAcceptSessionJoinerEventArgs> AcceptSessionJoinerRequested;
event TypedEventHandler<AllJoynBusAttachment, AllJoynSessionJoinedEventArgs> SessionJoined;
IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync(AllJoynServiceInfo serviceInfo);
IAsyncOperation<AllJoynAboutDataView> GetAboutDataAsync(AllJoynServiceInfo serviceInfo, Language language);
public static AllJoynBusAttachment GetDefault();
public static DeviceWatcher GetWatcher(IIterable<string> requiredInterfaces);
}
public sealed class AllJoynBusObject
public sealed class AllJoynBusObjectStoppedEventArgs
public sealed class AllJoynServiceInfo {
public static IAsyncOperation<AllJoynServiceInfo> FromIdAsync(string deviceId);
}
public sealed class AllJoynSession
public sealed class AllJoynSessionJoinedEventArgs
public interface IAllJoynProducer
}
namespace Windows.Devices.Enumeration {
public sealed class EnclosureLocation {
uint RotationAngleInDegreesClockwise { get; }
}
}
namespace Windows.Devices.Geolocation {
public sealed class Geolocator {
void AllowFallbackToConsentlessPositions();
}
public enum PositionSource {
Obfuscated = 6,
}
}
namespace Windows.Devices.HumanInterfaceDevice {
public sealed class HidBooleanControlDescription {
bool IsAbsolute { get; }
}
}
namespace Windows.Devices.Midi {
public enum MidiMessageType {
EndSystemExclusive = 247,
}
}
namespace Windows.Devices.PointOfService {
public sealed class BarcodeScanner {
string VideoDeviceId { get; }
}
}
namespace Windows.Devices.Sensors {
public sealed class Accelerometer {
AccelerometerReadingType ReadingType { get; }
public static Accelerometer GetDefault(AccelerometerReadingType readingType);
}
public enum AccelerometerReadingType
public sealed class Inclinometer {
public static Inclinometer GetDefault(SensorReadingType sensorReadingtype);
}
public sealed class OrientationSensor {
public static OrientationSensor GetDefault(SensorReadingType sensorReadingtype);
public static OrientationSensor GetDefault(SensorReadingType sensorReadingType, SensorOptimizationGoal optimizationGoal);
}
public enum SensorOptimizationGoal
}
namespace Windows.Devices.SmartCards {
public enum SmartCardReaderKind {
EmbeddedSE = 5,
}
}
namespace Windows.Foundation.Metadata {
public sealed class CreateFromStringAttribute : Attribute
}
namespace Windows.Gaming.Input {
public sealed class ArcadeStick : IGameController
public enum ArcadeStickButtons : uint
public struct ArcadeStickReading
public enum GameControllerButtonLabel
public sealed class Gamepad : IGameController {
GameControllerButtonLabel GetButtonLabel(GamepadButtons button);
}
public enum GamepadButtons : uint {
Paddle1 = (uint)16384,
Paddle2 = (uint)32768,
Paddle3 = (uint)65536,
Paddle4 = (uint)131072,
}
public enum OptionalUINavigationButtons : uint
public sealed class RacingWheel : IGameController
public enum RacingWheelButtons : uint
public struct RacingWheelReading
public enum RequiredUINavigationButtons : uint
public sealed class UINavigationController : IGameController
public struct UINavigationReading
}
namespace Windows.Gaming.Input.ForceFeedback {
public sealed class ConditionForceEffect : IForceFeedbackEffect
public enum ConditionForceEffectKind
public sealed class ConstantForceEffect : IForceFeedbackEffect
public enum ForceFeedbackEffectAxes : uint
public enum ForceFeedbackEffectState
public enum ForceFeedbackLoadEffectResult
public sealed class ForceFeedbackMotor
public interface IForceFeedbackEffect
public sealed class PeriodicForceEffect : IForceFeedbackEffect
public enum PeriodicForceEffectKind
public sealed class RampForceEffect : IForceFeedbackEffect
}
namespace Windows.Globalization {
public static class CalendarIdentifiers {
public static string ChineseLunar { get; }
public static string JapaneseLunar { get; }
public static string KoreanLunar { get; }
public static string TaiwanLunar { get; }
public static string VietnameseLunar { get; }
}
}
namespace Windows.Globalization.PhoneNumberFormatting {
public enum PhoneNumberFormat
public sealed class PhoneNumberFormatter
public sealed class PhoneNumberInfo : IStringable
public enum PhoneNumberMatchResult
public enum PhoneNumberParseResult
public enum PredictedPhoneNumberKind
}
namespace Windows.Graphics.Display {
public sealed class DisplayInformation {
uint ScreenHeightInRawPixels { get; }
uint ScreenWidthInRawPixels { get; }
}
}
namespace Windows.Graphics.Printing {
public sealed class PrintManager {
public static bool IsSupported();
}
public sealed class PrintPageInfo
public sealed class PrintTaskOptions : IPrintTaskOptionsCore, IPrintTaskOptionsCoreProperties, IPrintTaskOptionsCoreUIConfiguration {
IRandomAccessStream GetPagePrintTicket(PrintPageInfo printPageInfo);
}
}
namespace Windows.Management.Workplace {
public static class MdmPolicy {
public static MessagingSyncPolicy GetMessagingSyncPolicy();
}
public enum MessagingSyncPolicy
}
namespace Windows.Media {
public sealed class MusicDisplayProperties {
uint AlbumTrackCount { get; set; }
}
}
namespace Windows.Media.Audio {
public sealed class AudioDeviceOutputNode : IAudioNode, IAudioNodeWithListener, IClosable
public sealed class AudioFileOutputNode : IAudioNode, IClosable
public sealed class AudioFrameOutputNode : IAudioNode, IClosable
public sealed class AudioNodeEmitter {
bool IsDopplerDisabled { get; }
}
public interface IAudioNodeWithListener : IAudioNode, IClosable
}
namespace Windows.Media.Capture {
public sealed class LowLagMediaRecording {
IAsyncOperation<MediaCapturePauseResult> PauseWithResultAsync(MediaCapturePauseBehavior behavior);
IAsyncOperation<MediaCaptureStopResult> StopWithResultAsync();
}
public sealed class MediaCapture : IClosable {
IMapView<string, MediaFrameSource> FrameSources { get; }
IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync(MediaFrameSource inputSource);
IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync(MediaFrameSource inputSource, string outputSubtype);
IAsyncOperation<MediaFrameReader> CreateFrameReaderAsync(MediaFrameSource inputSource, string outputSubtype, BitmapSize outputSize);
IAsyncOperation<MediaCapturePauseResult> PauseRecordWithResultAsync(MediaCapturePauseBehavior behavior);
IAsyncOperation<MediaCaptureStopResult> StopRecordWithResultAsync();
}
public sealed class MediaCaptureInitializationSettings {
MediaCaptureMemoryPreference MemoryPreference { get; set; }
MediaCaptureSharingMode SharingMode { get; set; }
MediaFrameSourceGroup SourceGroup { get; set; }
}
public enum MediaCaptureMemoryPreference
public sealed class MediaCapturePauseResult : IClosable
public enum MediaCaptureSharingMode
public sealed class MediaCaptureStopResult : IClosable
}
namespace Windows.Media.Capture.Frames {
public sealed class BufferMediaFrame
public sealed class DepthMediaFrame
public sealed class DepthMediaFrameFormat
public sealed class InfraredMediaFrame
public sealed class MediaFrameArrivedEventArgs
public sealed class MediaFrameFormat
public sealed class MediaFrameReader : IClosable
public enum MediaFrameReaderStartStatus
public sealed class MediaFrameReference : IClosable
public sealed class MediaFrameSource
public sealed class MediaFrameSourceController
public sealed class MediaFrameSourceGetPropertyResult
public enum MediaFrameSourceGetPropertyStatus
public sealed class MediaFrameSourceGroup
public sealed class MediaFrameSourceInfo
public enum MediaFrameSourceKind
public enum MediaFrameSourceSetPropertyStatus
public sealed class VideoMediaFrame
public sealed class VideoMediaFrameFormat
}
namespace Windows.Media.Core {
public sealed class AudioStreamDescriptor : IMediaStreamDescriptor {
IReference<uint> LeadingEncoderPadding { get; set; }
IReference<uint> TrailingEncoderPadding { get; set; }
}
public sealed class MediaStreamSource : IMediaSource {
event TypedEventHandler<MediaStreamSource, MediaStreamSourceSampleRenderedEventArgs> SampleRendered;
}
public sealed class MediaStreamSourceSampleLag
public sealed class MediaStreamSourceSampleLagOccuredEventArgs
}
namespace Windows.Media.Devices.Core {
public sealed class CameraIntrinsics {
Matrix4x4 UndistortedProjectionTransform { get; }
Point DistortPoint(Point input);
void DistortPoints(Point[] inputs, Point[] results);
Point UndistortPoint(Point input);
void UndistortPoints(Point[] inputs, Point[] results);
}
public sealed class DepthCorrelatedCoordinateMapper : IClosable
}
namespace Windows.Media.MediaProperties {
public enum StereoscopicVideoPackingMode
public sealed class VideoEncodingProperties : IMediaEncodingProperties {
StereoscopicVideoPackingMode StereoscopicVideoPackingMode { get; }
}
}
namespace Windows.Media.Playback {
public sealed class MediaBreakManager {
MediaPlaybackSession PlaybackSession { get; }
}
public enum MediaCommandEnablingRule
public sealed class MediaPlaybackCommandManager {
MediaPlaybackCommandManagerCommandBehavior AutoRepeatModeBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior FastForwardBehavior { get; }
MediaPlayer MediaPlayer { get; }
MediaPlaybackCommandManagerCommandBehavior NextBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior PauseBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior PlayBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior PositionBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior PreviousBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior RateBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior RewindBehavior { get; }
MediaPlaybackCommandManagerCommandBehavior ShuffleBehavior { get; }
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs> AutoRepeatModeReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerFastForwardReceivedEventArgs> FastForwardReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerNextReceivedEventArgs> NextReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPauseReceivedEventArgs> PauseReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PlaybackPositionCommandReceivedEventArgs> PlaybackPositionCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PlaybackRateCommandReceivedEventArgs> PlaybackRateCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPlayReceivedEventArgs> PlayReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPositionReceivedEventArgs> PositionReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerPreviousReceivedEventArgs> PreviousReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerRateReceivedEventArgs> RateReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerRewindReceivedEventArgs> RewindReceived;
event TypedEventHandler<MediaPlaybackCommandManager, MediaPlaybackCommandManagerShuffleReceivedEventArgs> ShuffleReceived;
}
public sealed class MediaPlaybackCommandManagerAutoRepeatModeReceivedEventArgs
public sealed class MediaPlaybackCommandManagerCommandBehavior
public sealed class MediaPlaybackCommandManagerFastForwardReceivedEventArgs
public sealed class MediaPlaybackCommandManagerNextReceivedEventArgs
public sealed class MediaPlaybackCommandManagerPauseReceivedEventArgs
public sealed class MediaPlaybackCommandManagerPlayReceivedEventArgs
public sealed class MediaPlaybackCommandManagerPositionReceivedEventArgs
public sealed class MediaPlaybackCommandManagerPreviousReceivedEventArgs
public sealed class MediaPlaybackCommandManagerRateReceivedEventArgs
public sealed class MediaPlaybackCommandManagerRewindReceivedEventArgs
public sealed class MediaPlaybackCommandManagerShuffleReceivedEventArgs
public sealed class MediaPlaybackItem : IMediaPlaybackSource {
void ApplyDisplayProperties(MediaItemDisplayProperties value);
MediaItemDisplayProperties GetDisplayProperties();
}
public sealed class MediaPlaybackSession
public enum MediaPlaybackState
public sealed class MediaPlayer : IClosable {
double AudioBalance { get; set; }
MediaPlaybackSession PlaybackSession { get; }
StereoscopicVideoRenderMode StereoscopicVideoRenderMode { get; set; }
event TypedEventHandler<MediaPlayer, object> IsMutedChanged;
event TypedEventHandler<MediaPlayer, object> SourceChanged;
void AddVideoEffect(string activatableClassId, bool effectOptional, IPropertySet effectConfiguration);
MediaPlayerSurface GetSurface(Compositor compositor);
void SetSurfaceSize(Size size);
void StepBackwardOneFrame();
void StepForwardOneFrame();
}
public sealed class MediaPlayerSurface : IClosable
public enum StereoscopicVideoRenderMode
}
namespace Windows.Media.Protection {
public enum HdcpProtection
public sealed class HdcpSession : IClosable
public enum HdcpSetProtectionResult
}
namespace Windows.Media.Protection.PlayReady {
public static class PlayReadyStatics {
public static string InputTrustAuthorityToCreate { get; }
public static Guid ProtectionSystemId { get; }
}
}
namespace Windows.Networking.NetworkOperators {
public sealed class NetworkOperatorTetheringManager {
public static NetworkOperatorTetheringManager CreateFromConnectionProfile(ConnectionProfile profile, NetworkAdapter adapter);
}
public enum TetheringOperationStatus {
BluetoothDeviceOff = 7,
NetworkLimitedConnectivity = 8,
}
}
namespace Windows.Networking.PushNotifications {
public static class PushNotificationChannelManager {
public static PushNotificationChannelManagerForUser GetForUser(User user);
}
public sealed class PushNotificationChannelManagerForUser
}
namespace Windows.Networking.Sockets {
public interface IWebSocketControl2 : IWebSocketControl
public interface IWebSocketInformation2 : IWebSocketInformation
public sealed class MessageWebSocket : IClosable, IWebSocket {
event TypedEventHandler<MessageWebSocket, WebSocketServerCustomValidationRequestedEventArgs> ServerCustomValidationRequested;
}
public sealed class MessageWebSocketControl : IWebSocketControl, IWebSocketControl2 {
IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
}
public sealed class MessageWebSocketInformation : IWebSocketInformation, IWebSocketInformation2 {
Certificate ServerCertificate { get; }
IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
IVectorView<Certificate> ServerIntermediateCertificates { get; }
}
public sealed class StreamSocket : IClosable {
public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync(HostName remoteHostName, string remoteServiceName);
public static IAsyncOperation<IVectorView<EndpointPair>> GetEndpointPairsAsync(HostName remoteHostName, string remoteServiceName, HostNameSortOptions sortOptions);
}
public sealed class StreamWebSocket : IClosable, IWebSocket {
event TypedEventHandler<StreamWebSocket, WebSocketServerCustomValidationRequestedEventArgs> ServerCustomValidationRequested;
}
public sealed class StreamWebSocketControl : IWebSocketControl, IWebSocketControl2 {
IVector<ChainValidationResult> IgnorableServerCertificateErrors { get; }
}
public sealed class StreamWebSocketInformation : IWebSocketInformation, IWebSocketInformation2 {
Certificate ServerCertificate { get; }
IVectorView<ChainValidationResult> ServerCertificateErrors { get; }
SocketSslErrorSeverity ServerCertificateErrorSeverity { get; }
IVectorView<Certificate> ServerIntermediateCertificates { get; }
}
public sealed class WebSocketServerCustomValidationRequestedEventArgs
}
namespace Windows.Networking.Vpn {
public sealed class VpnDomainNameInfo {
IVector<Uri> WebProxyUris { get; }
}
public enum VpnManagementConnectionStatus
public enum VpnManagementErrorStatus {
AlreadyConnected = 8,
AlreadyDisconnecting = 7,
CannotFindProfile = 6,
CertificateFailure = 12,
DnsNotResolvable = 17,
EapFailure = 10,
GeneralAuthenticationFailure = 9,
InvalidIP = 18,
NoConnection = 14,
ServerConfiguration = 13,
ServerConnection = 15,
SmartCardFailure = 11,
UserNamePassword = 16,
}
public sealed class VpnNativeProfile : IVpnProfile {
VpnManagementConnectionStatus ConnectionStatus { get; }
bool RequireVpnClientAppUI { get; set; }
}
public sealed class VpnPlugInProfile : IVpnProfile {
VpnManagementConnectionStatus ConnectionStatus { get; }
bool RequireVpnClientAppUI { get; set; }
}
}
namespace Windows.Security.Authentication.Identity.Core {
public sealed class MicrosoftAccountMultiFactorAuthenticationManager {
IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus, string userAccountId, string sessionId, MicrosoftAccountMultiFactorAuthenticationType sessionAuthenticationType);
IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus, MicrosoftAccountMultiFactorSessionInfo authenticationSessionInfo);
}
public enum MicrosoftAccountMultiFactorServiceResponse {
DeviceIdChanged = 21,
DeviceNotFound = 14,
FlowDisabled = 15,
InvalidOperation = 12,
InvalidSessionId = 10,
InvalidSessionType = 11,
InvalidStateTransition = 13,
NgcDisabledByServer = 18,
NgcKeyNotFoundOnServer = 19,
NgcNonceExpired = 9,
NgcNotSetup = 5,
OperationCanceledByUser = 17,
SessionAlreadyApproved = 7,
SessionAlreadyDenied = 6,
SessionExpired = 8,
SessionNotApproved = 16,
UIRequired = 20,
}
public enum MicrosoftAccountMultiFactorSessionApprovalStatus {
Denied = 2,
}
}
namespace Windows.Security.Authentication.Identity.Provider {
public sealed class SecondaryAuthenticationFactorAuthentication
public enum SecondaryAuthenticationFactorAuthenticationMessage
public sealed class SecondaryAuthenticationFactorAuthenticationResult
public enum SecondaryAuthenticationFactorAuthenticationScenario
public enum SecondaryAuthenticationFactorAuthenticationStage
public sealed class SecondaryAuthenticationFactorAuthenticationStageChangedEventArgs
public sealed class SecondaryAuthenticationFactorAuthenticationStageInfo
public enum SecondaryAuthenticationFactorAuthenticationStatus
public enum SecondaryAuthenticationFactorDeviceCapabilities : uint
public enum SecondaryAuthenticationFactorDeviceFindScope
public enum SecondaryAuthenticationFactorFinishAuthenticationStatus
public sealed class SecondaryAuthenticationFactorInfo
public sealed class SecondaryAuthenticationFactorRegistration
public sealed class SecondaryAuthenticationFactorRegistrationResult
public enum SecondaryAuthenticationFactorRegistrationStatus
}
namespace Windows.Storage {
public sealed class StorageLibrary {
StorageLibraryChangeTracker ChangeTracker { get; }
}
public sealed class StorageLibraryChange
public sealed class StorageLibraryChangeReader
public sealed class StorageLibraryChangeTracker
public enum StorageLibraryChangeType
}
namespace Windows.System {
public enum AppMemoryUsageLevel {
OverLimit = 3,
}
public static class Launcher {
public static IAsyncOperation<IVectorView<AppInfo>> FindAppUriHandlersAsync(Uri uri);
public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync(Uri uri);
public static IAsyncOperation<LaunchQuerySupportStatus> QueryAppUriSupportAsync(Uri uri, string packageFamilyName);
}
public sealed class LauncherOptions : ILauncherViewOptions {
bool IgnoreAppUriHandlers { get; set; }
}
public static class RemoteLauncher
public sealed class RemoteLauncherOptions
public enum RemoteLaunchUriStatus
public static class UserDeviceAssociation
public sealed class UserDeviceAssociationChangedEventArgs
public sealed class UserPicker
}
namespace Windows.System.Profile {
public static class SystemIdentification
public sealed class SystemIdentificationInfo
public enum SystemIdentificationSource
}
namespace Windows.System.RemoteSystems {
public interface IRemoteSystemFilter
public sealed class RemoteSystem
public enum RemoteSystemAccessStatus
public sealed class RemoteSystemAddedEventArgs
public sealed class RemoteSystemConnectionRequest
public enum RemoteSystemDiscoveryType
public sealed class RemoteSystemDiscoveryTypeFilter : IRemoteSystemFilter
public sealed class RemoteSystemKindFilter : IRemoteSystemFilter
public static class RemoteSystemKinds
public sealed class RemoteSystemRemovedEventArgs
public enum RemoteSystemStatus
public enum RemoteSystemStatusType
public sealed class RemoteSystemStatusTypeFilter : IRemoteSystemFilter
public sealed class RemoteSystemUpdatedEventArgs
public sealed class RemoteSystemWatcher
}
namespace Windows.System.UserProfile {
public static class AdvertisingManager {
public static AdvertisingManagerForUser GetForUser(User user);
}
public sealed class AdvertisingManagerForUser
}
namespace Windows.UI.ApplicationSettings {
public sealed class AccountsSettingsPane {
public static IAsyncAction ShowAddAccountAsync();
public static IAsyncAction ShowManageAccountsAsync();
}
}
namespace Windows.UI.Composition {
public sealed class AmbientLight : CompositionLight
public class CompositionAnimation : CompositionObject, ICompositionAnimationBase {
string Target { get; set; }
void SetBooleanParameter(string key, bool value);
}
public sealed class CompositionAnimationGroup : CompositionObject, ICompositionAnimationBase, IIterable<CompositionAnimation>
public sealed class CompositionBackdropBrush : CompositionBrush
public class CompositionLight : CompositionObject
public sealed class CompositionNineGridBrush : CompositionBrush
public class CompositionObject : IClosable {
string Comment { get; set; }
ImplicitAnimationCollection ImplicitAnimations { get; set; }
void StartAnimationGroup(ICompositionAnimationBase value);
void StopAnimationGroup(ICompositionAnimationBase value);
}
public sealed class CompositionPropertyChangedEventArgs : CompositionObject
public sealed class CompositionPropertySet : CompositionObject {
void InsertBoolean(string propertyName, bool value);
CompositionGetValueStatus TryGetBoolean(string propertyName, out bool value);
}
public sealed class Compositor : IClosable {
AmbientLight CreateAmbientLight();
AnimationGroup CreateAnimationGroup();
CompositionAnimationGroup CreateAnimationGroup();
CompositionBackdropBrush CreateBackdropBrush();
CompositionDestinationBrush CreateDestinationBrush();
DistantLight CreateDistantLight();
ImplicitAnimationCollection CreateImplicitAnimationCollection();
LayerVisual CreateLayerVisual();
CompositionNineGridBrush CreateNineGridBrush();
PointLight CreatePointLight();
SpotLight CreateSpotLight();
}
public sealed class DistantLight : CompositionLight
public sealed class DropShadow : CompositionShadow {
float Opacity { get; set; }
}
public interface ICompositionAnimationBase
public sealed class ImplicitAnimationCollection : CompositionObject, IIterable<IKeyValuePair<string, ICompositionAnimationBase>>, IMap<string, ICompositionAnimationBase>
public class KeyFrameAnimation : CompositionAnimation {
}
public sealed class LayerVisual : ContainerVisual
public sealed class PointLight : CompositionLight
public sealed class SpotLight : CompositionLight
public sealed class StepEasingFunction : CompositionEasingFunction {
int FinalStep { get; set; }
int InitialStep { get; set; }
bool IsFinalStepSingleFrame { get; set; }
bool IsInitialStepSingleFrame { get; set; }
}
public sealed class VisualUnorderedCollection : CompositionObject, IIterable<Visual>
}
namespace Windows.UI.Composition.Effects {
public sealed class SceneLightingEffect : IGraphicsEffect, IGraphicsEffectSource
}
namespace Windows.UI.Composition.Interactions {
public sealed class CompositionInteractionSourceCollection : CompositionObject, IIterable<ICompositionInteractionSource>
public interface ICompositionInteractionSource
public interface IInteractionTrackerOwner
public enum InteractionChainingMode
public enum InteractionSourceMode
public sealed class InteractionTracker : CompositionObject
public sealed class InteractionTrackerCustomAnimationStateEnteredArgs
public sealed class InteractionTrackerIdleStateEnteredArgs
public class InteractionTrackerInertiaModifier : CompositionObject
public sealed class InteractionTrackerInertiaMotion : InteractionTrackerInertiaModifier
public sealed class InteractionTrackerInertiaRestingValue : InteractionTrackerInertiaModifier
public sealed class InteractionTrackerInertiaStateEnteredArgs
public sealed class InteractionTrackerInteractingStateEnteredArgs
public sealed class InteractionTrackerRequestIgnoredArgs
public sealed class InteractionTrackerValuesChangedArgs
public sealed class VisualInteractionSource : CompositionObject, ICompositionInteractionSource
public enum VisualInteractionSourceRedirectionMode
}
namespace Windows.UI.Core {
public sealed class AcceleratorKeyEventArgs : ICoreWindowEventArgs {
string DeviceId { get; }
}
public sealed class CoreComponentInputSource : ICoreInputSourceBase, ICorePointerInputSource {
string GetCurrentKeyEventDeviceId();
}
public sealed class CoreWindow : ICorePointerRedirector, ICoreWindow {
string GetCurrentKeyEventDeviceId();
}
public sealed class KeyEventArgs : ICoreWindowEventArgs {
string DeviceId { get; }
}
}
namespace Windows.UI.Input {
public sealed class RadialController
public sealed class RadialControllerConfiguration
public sealed class RadialControllerMenu
public sealed class RadialControllerMenuItem
public enum RadialControllerMenuKnownIcon
public sealed class RadialControllerRotationChangedEventArgs
public sealed class RadialControllerScreenContact
public sealed class RadialControllerScreenContactContinuedEventArgs
public sealed class RadialControllerScreenContactStartedEventArgs
public enum RadialControllerSystemMenuItemKind
}
namespace Windows.UI.Input.Inking {
public interface IInkPresenterRulerFactory
public interface IInkPresenterStencil
public sealed class InkDrawingAttributes {
InkDrawingAttributesKind Kind { get; }
InkDrawingAttributesPencilProperties PencilProperties { get; }
public static InkDrawingAttributes CreateForPencil();
}
public enum InkDrawingAttributesKind
public sealed class InkDrawingAttributesPencilProperties
public sealed class InkPresenterRuler : IInkPresenterStencil
public enum InkPresenterStencilKind
}
namespace Windows.UI.Input.Inking.Core {
public enum CoreWetStrokeDisposition
public sealed class CoreWetStrokeUpdateEventArgs
public sealed class CoreWetStrokeUpdateSource
}
namespace Windows.UI.Input.Preview.Injection {
public enum InjectedInputButtonChangeKind
public sealed class InjectedInputKeyboardInfo
public enum InjectedInputKeyOptions : uint
public sealed class InjectedInputMouseInfo
public enum InjectedInputMouseOptions : uint
public enum InjectedInputPenButtons : uint
public sealed class InjectedInputPenInfo
public enum InjectedInputPenParameters : uint
public struct InjectedInputPoint
public struct InjectedInputPointerInfo
public enum InjectedInputPointerOptions : uint
public struct InjectedInputRectangle
public enum InjectedInputShortcut
public sealed class InjectedInputTouchInfo
public enum InjectedInputTouchParameters : uint
public enum InjectedInputVisualizationMode
public sealed class InputInjector
}
namespace Windows.UI.Notifications {
public enum AdaptiveNotificationContentKind
public sealed class AdaptiveNotificationText : IAdaptiveNotificationContent
public static class BadgeUpdateManager {
public static BadgeUpdateManagerForUser GetForUser(User user);
}
public sealed class BadgeUpdateManagerForUser
public interface IAdaptiveNotificationContent
public static class KnownAdaptiveNotificationHints
public static class KnownAdaptiveNotificationTextStyles
public static class KnownNotificationBindings
public sealed class Notification
public sealed class NotificationBinding
public enum NotificationKinds : uint
public enum NotificationMirroring
public sealed class NotificationVisual
public sealed class ScheduledToastNotification {
NotificationMirroring NotificationMirroring { get; set; }
string RemoteId { get; set; }
}
public sealed class ShownTileNotification
public static class TileUpdateManager {
public static TileUpdateManagerForUser GetForUser(User user);
}
public sealed class TileUpdateManagerForUser
public sealed class ToastNotification {
NotificationMirroring NotificationMirroring { get; set; }
string RemoteId { get; set; }
}
public static class ToastNotificationManager {
public static void ConfigureNotificationMirroring(NotificationMirroring value);
public static ToastNotificationManagerForUser GetForUser(User user);
}
public sealed class ToastNotificationManagerForUser
public sealed class UserNotification
public sealed class UserNotificationChangedEventArgs
public enum UserNotificationChangedKind
}
namespace Windows.UI.Notifications.Management {
public sealed class UserNotificationListener
public enum UserNotificationListenerAccessStatus
}
namespace Windows.UI.Text.Core {
public enum CoreTextInputScope {
ChatWithoutEmoji = 68,
}
}
namespace Windows.UI.WebUI {
public sealed class EnteredBackgroundEventArgs : IEnteredBackgroundEventArgs
public delegate void EnteredBackgroundEventHandler(object sender, IEnteredBackgroundEventArgs e);
public sealed class LeavingBackgroundEventArgs : ILeavingBackgroundEventArgs
public delegate void LeavingBackgroundEventHandler(object sender, ILeavingBackgroundEventArgs e);
public static class WebUIApplication {
public static event EnteredBackgroundEventHandler EnteredBackground;
public static event LeavingBackgroundEventHandler LeavingBackground;
}
public sealed class WebUIAppointmentsProviderAddAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderAddAppointmentActivatedEventArgs {
User User { get; }
}
public sealed class WebUIAppointmentsProviderRemoveAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderRemoveAppointmentActivatedEventArgs {
User User { get; }
}
public sealed class WebUIAppointmentsProviderReplaceAppointmentActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderReplaceAppointmentActivatedEventArgs {
User User { get; }
}
public sealed class WebUIAppointmentsProviderShowAppointmentDetailsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowAppointmentDetailsActivatedEventArgs {
User User { get; }
}
public sealed class WebUIAppointmentsProviderShowTimeFrameActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IAppointmentsProviderActivatedEventArgs, IAppointmentsProviderShowTimeFrameActivatedEventArgs {
User User { get; }
}
public sealed class WebUICachedFileUpdaterActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, ICachedFileUpdaterActivatedEventArgs {
User User { get; }
}
public sealed class WebUIDeviceActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDeviceActivatedEventArgs {
User User { get; }
}
public sealed class WebUIDevicePairingActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IDevicePairingActivatedEventArgs {
User User { get; }
}
public sealed class WebUIDialReceiverActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IDialReceiverActivatedEventArgs, ILaunchActivatedEventArgs {
User User { get; }
}
public sealed class WebUIFileActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IFileActivatedEventArgs, IFileActivatedEventArgsWithNeighboringFiles {
User User { get; }
}
public sealed class WebUIFileOpenPickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IFileOpenPickerActivatedEventArgs, IFileOpenPickerActivatedEventArgs2 {
User User { get; }
}
public sealed class WebUIFileOpenPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileOpenPickerContinuationEventArgs {
User User { get; }
}
public sealed class WebUIFileSavePickerActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IFileSavePickerActivatedEventArgs, IFileSavePickerActivatedEventArgs2 {
User User { get; }
}
public sealed class WebUIFileSavePickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFileSavePickerContinuationEventArgs {
User User { get; }
}
public sealed class WebUIFolderPickerContinuationEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IContinuationActivatedEventArgs, IFolderPickerContinuationEventArgs {
User User { get; }
}
public sealed class WebUILaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILaunchActivatedEventArgs, IPrelaunchActivatedEventArgs {
User User { get; }
}
public sealed class WebUILockScreenActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, ILockScreenActivatedEventArgs {
User User { get; }
}
public sealed class WebUIProtocolActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData {
User User { get; }
}
public sealed class WebUIProtocolForResultsActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IApplicationViewActivatedEventArgs, IProtocolActivatedEventArgs, IProtocolActivatedEventArgsWithCallerPackageFamilyNameAndData, IProtocolForResultsActivatedEventArgs {
User User { get; }
}
public sealed class WebUIRestrictedLaunchActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IRestrictedLaunchActivatedEventArgs {
User User { get; }
}
public sealed class WebUIShareTargetActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IShareTargetActivatedEventArgs {
User User { get; }
}
public sealed class WebUIToastNotificationActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IToastNotificationActivatedEventArgs {
User User { get; }
}
public sealed class WebUIUserDataAccountProviderActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IUserDataAccountProviderActivatedEventArgs
public sealed class WebUIVoiceCommandActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IVoiceCommandActivatedEventArgs {
User User { get; }
}
public sealed class WebUIWebAccountProviderActivatedEventArgs : IActivatedEventArgs, IActivatedEventArgsDeferral, IActivatedEventArgsWithUser, IWebAccountProviderActivatedEventArgs {
User User { get; }
}
}
namespace Windows.UI.Xaml {
public class Application {
FocusVisualKind FocusVisualKind { get; set; }
ApplicationRequiresPointerMode RequiresPointerMode { get; set; }
event EnteredBackgroundEventHandler EnteredBackground;
event LeavingBackgroundEventHandler LeavingBackground;
virtual void OnBackgroundActivated(BackgroundActivatedEventArgs args);
}
public enum ApplicationRequiresPointerMode
public sealed class DragEventArgs : RoutedEventArgs {
DataPackageOperation AllowedOperations { get; }
}
public sealed class DragStartingEventArgs : RoutedEventArgs {
DataPackageOperation AllowedOperations { get; set; }
}
public enum ElementSoundKind
public enum ElementSoundMode
public sealed class ElementSoundPlayer
public enum ElementSoundPlayerState
public delegate void EnteredBackgroundEventHandler(object sender, EnteredBackgroundEventArgs e);
public enum FocusVisualKind
public class FrameworkElement : UIElement {
bool AllowFocusWhenDisabled { get; set; }
public static DependencyProperty AllowFocusWhenDisabledProperty { get; }
Thickness FocusVisualMargin { get; set; }
public static DependencyProperty FocusVisualMarginProperty { get; }
Brush FocusVisualPrimaryBrush { get; set; }
public static DependencyProperty FocusVisualPrimaryBrushProperty { get; }
Thickness FocusVisualPrimaryThickness { get; set; }
public static DependencyProperty FocusVisualPrimaryThicknessProperty { get; }
Brush FocusVisualSecondaryBrush { get; set; }
public static DependencyProperty FocusVisualSecondaryBrushProperty { get; }
Thickness FocusVisualSecondaryThickness { get; set; }
public static DependencyProperty FocusVisualSecondaryThicknessProperty { get; }
}
public delegate void LeavingBackgroundEventHandler(object sender, LeavingBackgroundEventArgs e);
public class UIElement : DependencyObject {
bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
public static DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
}
}
namespace Windows.UI.Xaml.Automation.Peers {
public sealed class InkToolbarAutomationPeer : FrameworkElementAutomationPeer
public class MediaPlayerElementAutomationPeer : FrameworkElementAutomationPeer
}
namespace Windows.UI.Xaml.Controls {
public class AppBar : ContentControl {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public class AppBarButton : Button, ICommandBarElement, ICommandBarElement2 {
int DynamicOverflowOrder { get; set; }
public static DependencyProperty DynamicOverflowOrderProperty { get; }
bool IsInOverflow { get; }
public static DependencyProperty IsInOverflowProperty { get; }
}
public class AppBarSeparator : Control, ICommandBarElement, ICommandBarElement2 {
int DynamicOverflowOrder { get; set; }
public static DependencyProperty DynamicOverflowOrderProperty { get; }
bool IsInOverflow { get; }
public static DependencyProperty IsInOverflowProperty { get; }
}
public class AppBarToggleButton : ToggleButton, ICommandBarElement, ICommandBarElement2 {
int DynamicOverflowOrder { get; set; }
public static DependencyProperty DynamicOverflowOrderProperty { get; }
bool IsInOverflow { get; }
public static DependencyProperty IsInOverflowProperty { get; }
}
public sealed class AutoSuggestBox : ItemsControl {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public class CalendarDatePicker : Control {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public class ComboBox : Selector {
bool IsTextSearchEnabled { get; set; }
public static DependencyProperty IsTextSearchEnabledProperty { get; }
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public class CommandBar : AppBar {
bool IsDynamicOverflowEnabled { get; set; }
public static DependencyProperty IsDynamicOverflowEnabledProperty { get; }
event TypedEventHandler<CommandBar, DynamicOverflowItemsChangingEventArgs> DynamicOverflowItemsChanging;
}
public enum CommandBarDynamicOverflowAction
public class Control : FrameworkElement {
ElementSoundMode ElementSoundMode { get; set; }
public static DependencyProperty ElementSoundModeProperty { get; }
bool IsFocusEngaged { get; set; }
public static DependencyProperty IsFocusEngagedProperty { get; }
bool IsFocusEngagementEnabled { get; set; }
public static DependencyProperty IsFocusEngagementEnabledProperty { get; }
RequiresPointer RequiresPointer { get; set; }
event TypedEventHandler<Control, FocusDisengagedEventArgs> FocusDisengaged;
event TypedEventHandler<Control, FocusEngagedEventArgs> FocusEngaged;
void RemoveFocusEngagement();
}
public class DatePicker : Control {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public sealed class DynamicOverflowItemsChangingEventArgs
public sealed class FocusDisengagedEventArgs : RoutedEventArgs
public sealed class FocusEngagedEventArgs : RoutedEventArgs
public interface ICommandBarElement2
public sealed class Image : FrameworkElement {
CompositionBrush GetAlphaMask();
}
public class InkToolbar : Control
public class InkToolbarBallpointPenButton : InkToolbarPenButton
public class InkToolbarCustomPen : DependencyObject
public class InkToolbarCustomPenButton : InkToolbarPenButton
public class InkToolbarCustomToggleButton : InkToolbarToggleButton
public class InkToolbarCustomToolButton : InkToolbarToolButton
public class InkToolbarEraserButton : InkToolbarToolButton
public class InkToolbarHighlighterButton : InkToolbarPenButton
public enum InkToolbarInitialControls
public class InkToolbarPenButton : InkToolbarToolButton
public class InkToolbarPencilButton : InkToolbarPenButton
public class InkToolbarPenConfigurationControl : Control
public class InkToolbarRulerButton : InkToolbarToggleButton
public enum InkToolbarToggle
public class InkToolbarToggleButton : CheckBox
public enum InkToolbarTool
public class InkToolbarToolButton : RadioButton
public enum LightDismissOverlayMode
public class MediaPlayerElement : Control
public class MediaPlayerPresenter : FrameworkElement
public class MediaTransportControls : Control {
FastPlayFallbackBehaviour FastPlayFallbackBehaviour { get; set; }
public static DependencyProperty FastPlayFallbackBehaviourProperty { get; }
bool IsNextTrackButtonVisible { get; set; }
public static DependencyProperty IsNextTrackButtonVisibleProperty { get; }
bool IsPreviousTrackButtonVisible { get; set; }
public static DependencyProperty IsPreviousTrackButtonVisibleProperty { get; }
bool IsSkipBackwardButtonVisible { get; set; }
public static DependencyProperty IsSkipBackwardButtonVisibleProperty { get; }
bool IsSkipBackwardEnabled { get; set; }
public static DependencyProperty IsSkipBackwardEnabledProperty { get; }
bool IsSkipForwardButtonVisible { get; set; }
public static DependencyProperty IsSkipForwardButtonVisibleProperty { get; }
bool IsSkipForwardEnabled { get; set; }
public static DependencyProperty IsSkipForwardEnabledProperty { get; }
event TypedEventHandler<MediaTransportControls, MediaTransportControlsThumbnailRequestedEventArgs> ThumbnailRequested;
}
public class Pivot : ItemsControl {
PivotHeaderFocusVisualPlacement HeaderFocusVisualPlacement { get; set; }
public static DependencyProperty HeaderFocusVisualPlacementProperty { get; }
bool IsHeaderItemsCarouselEnabled { get; set; }
public static DependencyProperty IsHeaderItemsCarouselEnabledProperty { get; }
}
public enum PivotHeaderFocusVisualPlacement
public enum RequiresPointer
public class SplitView : Control {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public sealed class TextBlock : FrameworkElement {
CompositionBrush GetAlphaMask();
}
public class TimePicker : Control {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public enum WebViewPermissionType {
WebNotifications = 4,
}
}
namespace Windows.UI.Xaml.Controls.Primitives {
public class FlyoutBase : DependencyObject {
bool AllowFocusWhenDisabled { get; set; }
public static DependencyProperty AllowFocusWhenDisabledProperty { get; }
ElementSoundMode ElementSoundMode { get; set; }
public static DependencyProperty ElementSoundModeProperty { get; }
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
public sealed class Popup : FrameworkElement {
LightDismissOverlayMode LightDismissOverlayMode { get; set; }
public static DependencyProperty LightDismissOverlayModeProperty { get; }
}
}
namespace Windows.UI.Xaml.Documents {
public sealed class Hyperlink : Span {
ElementSoundMode ElementSoundMode { get; set; }
public static DependencyProperty ElementSoundModeProperty { get; }
}
public class TextElement : DependencyObject {
bool ExitDisplayModeOnAccessKeyInvoked { get; set; }
public static DependencyProperty ExitDisplayModeOnAccessKeyInvokedProperty { get; }
}
}
namespace Windows.UI.Xaml.Input {
public enum InputScopeNameValue {
ChatWithoutEmoji = 68,
}
public sealed class KeyRoutedEventArgs : RoutedEventArgs {
string DeviceId { get; }
}
}
namespace Windows.UI.Xaml.Media {
public sealed class BrushCollection : IIterable<Brush>, IVector<Brush>
public enum FastPlayFallbackBehaviour
public sealed class MediaTransportControlsThumbnailRequestedEventArgs
}
namespace Windows.UI.Xaml.Media.Animation {
public sealed class ConnectedAnimation
public sealed class ConnectedAnimationService
}
namespace Windows.UI.Xaml.Shapes {
public class Shape : FrameworkElement {
CompositionBrush GetAlphaMask();
}
}
namespace Windows.Media.Capture {
public sealed class AppCaptureSettings {
AppCaptureVideoEncodingFrameRateMode VideoEncodingFrameRateMode { get; set; }
}
public enum AppCaptureVideoEncodingFrameRateMode
}
namespace Windows.Networking.Sockets {
public sealed class ControlChannelTrigger : IClosable {
bool IsWakeFromLowPowerSupported { get; }
}
}

Removed APIs

namespace Windows.ApplicationModel.Contacts {
public sealed class ContactList {
ContactListConstraints Constraints { get; }
}
public sealed class ContactListConstraints
}
namespace Windows.ApplicationModel.Store {
public sealed class PackageUpdate
public static class PackageUpdateManager
public sealed class PackageUpdateResult
public enum PackageUpdateState
public struct PackageUpdateStatus
}
namespace Windows.ApplicationModel.Store.Preview.InstallControl {
public sealed class AppInstallManager {
IAsyncOperation<AppInstallItem> StartAppInstallAsync(string productId, string skuId, bool repair, bool forceUseOfNonRemovableStorage, string catalogId, string bundleId, string correlationVector, PackageVolume targetVolume);
}
}
namespace Windows.ApplicationModel.UserDataAccounts.SystemAccess {
public static class UserDataAccountSystemAccessManager {
public static IAsyncAction MakeDefaultAccountAsync(string userDataAccountId);
}
}
namespace Windows.Media.Audio {
public sealed class AudioDeviceOutputNode : IAudioNode, IAudioNode2, IClosable {
}
public sealed class AudioFileOutputNode : IAudioNode, IAudioNode2, IClosable {
AudioNodeListener Listener { get; set; }
}
public sealed class AudioFrameOutputNode : IAudioNode, IAudioNode2, IClosable {
AudioNodeListener Listener { get; set; }
}
public sealed class AudioNodeEmitter {
bool IsDopplerDisabled { get; }
}
public interface IAudioNode2 : IAudioNode, IClosable
}
namespace Windows.Media.Core {
public sealed class AudioStreamDescriptor : IMediaStreamDescriptor {
IReference<uint> EncoderDelay { get; set; }
IReference<uint> EncoderPadding { get; set; }
}
public sealed class MediaStreamSource : IMediaSource {
event TypedEventHandler<MediaStreamSource, MediaStreamSourceSampleLagOccuredEventArgs> SampleLagOccured;
}
public sealed class MediaStreamSourceSampleLag
public sealed class MediaStreamSourceSampleLagOccuredEventArgs
}
namespace Windows.Media.MediaProperties {
public enum StereoVideoPackingMode
public sealed class VideoEncodingProperties : IMediaEncodingProperties {
StereoVideoPackingMode StereoVideoPackingMode { get; }
}
}
namespace Windows.Media.Playback {
public sealed class AutoRepeatModeCommandReceivedEventArgs
public sealed class FastForwardCommandReceivedEventArgs
public enum FrameStepDirection
public sealed class MediaBreakManager {
MediaPlaybackSession PlaybackSession { get; }
}
public enum MediaCommandEnablingRule
public sealed class MediaItemDisplayProperties {
RandomAccessStreamReference BackgroundArt { get; set; }
void ApplyChanges();
}
public sealed class MediaPlaybackCommandManager {
PlaybackCommandEnabledBehavior AutoRepeatModeEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior FastForwardEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior NextEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior PauseEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior PlaybackPositionEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior PlaybackRateEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior PlayEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior PreviousEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior RewindEnabledBehavior { get; set; }
PlaybackCommandEnabledBehavior ShuffleEnabledBehavior { get; set; }
event TypedEventHandler<MediaPlaybackCommandManager, AutoRepeatModeCommandReceivedEventArgs> AutoRepeatModeCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, FastForwardCommandReceivedEventArgs> FastForwardCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, NextCommandReceivedEventArgs> NextCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PauseCommandReceivedEventArgs> PauseCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PlaybackPositionCommandReceivedEventArgs> PlaybackPositionCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PlaybackRateCommandReceivedEventArgs> PlaybackRateCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PlayCommandReceivedEventArgs> PlayCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, PreviousCommandReceivedEventArgs> PreviousCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, RewindCommandReceivedEventArgs> RewindCommandReceived;
event TypedEventHandler<MediaPlaybackCommandManager, ShuffleCommandReceivedEventArgs> ShuffleCommandReceived;
}
public sealed class MediaPlaybackItem : IMediaPlaybackSource {
MediaItemDisplayProperties DisplayProperties { get; }
}
public sealed class MediaPlayer : IClosable {
double Balance { get; set; }
double DownloadProgress { get; }
int NaturalVideoHeight { get; }
int NaturalVideoWidth { get; }
NormalizedRect PanAndZoomRect { get; set; }
StereoVideoPackingMode StereoVideoPackingMode { get; set; }
StereoVideoRenderMode StereoVideoRenderMode { get; set; }
event TypedEventHandler<MediaPlayer, object> BufferingProgressChanged;
event TypedEventHandler<MediaPlayer, object> DownloadProgressChanged;
event TypedEventHandler<MediaPlayer, object> MutingChanged;
event TypedEventHandler<MediaPlayer, object> NaturalDurationChanged;
event TypedEventHandler<MediaPlayer, object> NaturalVideoSizeChanged;
event TypedEventHandler<MediaPlayer, object> PositionChanged;
void AddVideoEffect(string effectID, bool effectOptional, IPropertySet effectConfiguration);
void FrameStep(FrameStepDirection value);
MediaPlayerPlaybackStatistics GetPlaybackStatistics();
}
public sealed class MediaPlayerPlaybackStatistics
public sealed class NextCommandReceivedEventArgs
public struct NormalizedRect
public sealed class PauseCommandReceivedEventArgs
public enum PlaybackCommandEnabledBehavior
public sealed class PlaybackPositionCommandReceivedEventArgs
public sealed class PlaybackRateCommandReceivedEventArgs
public sealed class PlayCommandReceivedEventArgs
public sealed class PreviousCommandReceivedEventArgs
public sealed class RewindCommandReceivedEventArgs
public sealed class ShuffleCommandReceivedEventArgs
public enum StereoVideoRenderMode
}
namespace Windows.Media.Protection {
public enum HdcpLevel
public enum HdcpLevelAsyncResultStatus
public sealed class HdcpSettingResult
public sealed class HdcpState
}
namespace Windows.Security.Authentication.Identity.Core {
public sealed class MicrosoftAccountMultiFactorAuthenticationManager {
IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(string userAccountId, string sessionId, MicrosoftAccountMultiFactorAuthenticationType sessionAuthenticationType, MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus);
IAsyncOperation<MicrosoftAccountMultiFactorServiceResponse> ApproveSessionAsync(MicrosoftAccountMultiFactorSessionInfo authenticationSessionInfo, MicrosoftAccountMultiFactorSessionAuthenticationStatus sessionAuthentictionStatus);
}
}
namespace Windows.System.Profile {
public static class DeviceIdentification
}
namespace Windows.UI.Composition {
public sealed class AnimationGroup : CompositionObject, IImplicitAnimationMapEntry, IIterable<IKeyValuePair<string, CompositionAnimation>>, IMap<string, CompositionAnimation>
public sealed class CompositionDestinationBrush : CompositionBrush
public class CompositionInteractionSource : CompositionObject, ICompositionInteractionSource
public sealed class CompositionInteractionSourceCollection : CompositionObject, IIterable<ICompositionInteractionSource>
public class CompositionObject : IClosable {
ImplicitAnimationMap ImplicitAnimations { get; set; }
}
public sealed class CompositionPropertyChangedEventArgs : CompositionObject
public sealed class Compositor : IClosable {
AnimationGroup CreateAnimationGroup();
CompositionDestinationBrush CreateDestinationBrush();
ImplicitAnimationMap CreateImplicitAnimationMap();
InteractionTracker CreateInteractionTracker();
InteractionTrackerInertiaEndpoint CreateInteractionTrackerInertiaEndpoint();
InteractionTrackerInertiaMotion CreateInteractionTrackerInertiaMotion();
}
public interface ICompositionInteractionSource
public interface IImplicitAnimationMapEntry
public interface IInteractionTrackerInertiaEndpoint
public interface IInteractionTrackerInertiaModifier
public interface IInteractionTrackerInertiaMotion
public interface IInteractionTrackerOwner
public sealed class ImplicitAnimationMap : CompositionObject, IIterable<IKeyValuePair<string, IImplicitAnimationMapEntry>>, IMap<string, IImplicitAnimationMapEntry>
public enum InteractionNestingMode
public enum InteractionSourceMode
public enum InteractionSystemManipulationMode
public sealed class InteractionTracker : CompositionObject
public sealed class InteractionTrackerCustomAnimationStateEnteredArgs : CompositionObject
public sealed class InteractionTrackerIdleStateEnteredArgs : CompositionObject
public sealed class InteractionTrackerInContactStateEnteredArgs : CompositionObject
public sealed class InteractionTrackerInertiaEndpoint : InteractionTrackerInertiaModifier, IInteractionTrackerInertiaEndpoint
public class InteractionTrackerInertiaModifier : IInteractionTrackerInertiaModifier
public sealed class InteractionTrackerInertiaMotion : InteractionTrackerInertiaModifier, IInteractionTrackerInertiaMotion
public sealed class InteractionTrackerInertiaStateEnteredArgs : CompositionObject
public sealed class InteractionTrackerRequestIgnoredArgs : CompositionObject
public sealed class InteractionTrackerValuesChangedArgs : CompositionObject
public class KeyFrameAnimation : CompositionAnimation, IImplicitAnimationMapEntry {
}
public sealed class StepEasingFunction : CompositionEasingFunction {
int FinishAtStep { get; set; }
bool InstantFinish { get; set; }
bool InstantStart { get; set; }
int StartAtStep { get; set; }
}
public class Visual : CompositionObject {
float RelativeHeight { get; set; }
float RelativeOffsetX { get; set; }
float RelativeOffsetY { get; set; }
float RelativeWidth { get; set; }
bool SnapToPixels { get; set; }
}
public sealed class VisualInteractionSource : CompositionInteractionSource, ICompositionInteractionSource
}
namespace Windows.UI.Xaml.Controls {
public class Control : FrameworkElement {
RequiresPointerMode RequiresPointer { get; set; }
}
public class Pivot : ItemsControl {
PivotHeaderOverflowMode HeaderOverflowMode { get; set; }
public static DependencyProperty HeaderOverflowModeProperty { get; }
}
public enum PivotHeaderOverflowMode
public enum RequiresPointerMode
}
namespace Windows.Media.Capture {
public enum AppCaptureCameraOverlayLocation
public enum AppCaptureCameraOverlaySize
public sealed class AppCaptureSettings {
AppCaptureCameraOverlayLocation CameraOverlayLocation { get; set; }
AppCaptureCameraOverlaySize CameraOverlaySize { get; set; }
bool IsCameraCaptureEnabledByDefault { get; set; }
bool IsEchoCancellationEnabled { get; set; }
string SelectedCameraId { get; set; }
}
}

How to leverage PubMatic’s Windows SDK to scale monetization across devices and formats

When developers and publishers work with Software Development Kits (SDKs), they typically think of mobile-specific applications. However, since the Windows 10 app is device-agnostic, PubMatic built a Windows SDK that can incorporate ads into Windows apps across devices, not just on mobile, helping developers and publishers scale monetization of their app inventory.

Who would find it useful?

PubMatic SDK is useful to Windows 10 app developers looking to monetize their apps. A key benefit is that you don’t need to swap or change the SDKs based on the targeted device. PubMatic’s Windows SDK is built for the Universal Windows Platform (UWP) app, so apps developed with the SDK can be deployed on any Windows 10 device (desktop, tablet, mobile, etc.) without any changes.

What is PubMatic’s Windows SDK?

The SDK is completely modular, providing multiple unique benefits. For example, you can integrate with either single or multiple ad formats at the same time.

PubMatic Windows SDK supports the following ad formats:

  • Banner
  • Interstitial
  • Native
  • Video

Additional features include:

  • Rich Media MRAID 2.0– compliant Banner ads
  • VAST 3.0– supported Video Ads

Why PubMatic?

PubMatic helps publishers choose the right ad format for their inventory through its dynamic ad format. The SDK is designed for use by both novice and advanced developers. The simple SDK integration can be done by including XAML control in the application with initialization, start, and stop functions.

The PubMatic XAML control fills the digital real estate with the appropriate ad format (banner, rich media, video, audio, native) by taking dimensions, network bandwidth, default targeting parameters (device id, application, advertising id, location, and user cookie), brand/category control, and eCPM requirements configured on the server. The advanced integration has an option to override the default parameters to take control of ad formats; dynamic brand/category control and enhanced targeting parameters (age range, gender, interests…). You also have an option to use the SDK with no user interface to take complete control over the rendering capabilities.

The PubMatic SDK is modular, based on ad format. For example, if you only want to activate banner ads in your app, and aren’t interested in native, video, or other formats, PubMatic’s Windows SDK allows you to download the code just for banner ads. If at any point you want to support other ad types, you can download that ad format type and add it to your app.

For example, a flashlight app that is barely two MBs won’t want or need an  5 MB SDK. By breaking the SDK out into modular pieces, the app’s publisher can include just what is needed, without burdening the application with unnecessary code.

By leveraging PubMatic’s Windows SDK, you can maximize revenue using PubMatic’s RTB auction to select the highest paying demand sources, with detailed reporting data on a range of metrics, including CPM, impressions and revenue. The SDK empowers you to make the most of your digital assets through enriched data parameters, sensitivity towards privacy, and integrations with dozens of mobile ad networks and hundreds of demand sources.

How can I use the SDK?

To add the SDK to an app project, follow these steps:

  1. Unzip the SDK zip file in your source code working area.
  2. Open PubMatic’s sample app; use one of the following methods:
    • Select the app’s solution file.
    • Create a new Universal Windows app project in the Visual Studio IDE.
  3. To include a reference to the SDK in your app, do one of the following:
    • Add the SDK as a .dll to your app (see below for instructions).
    • Add the source code of the SDK to your app (see below for instructions).

To add the SDK as a .dll:

  1. In Solution Explorer, right-click References.
  2. Click Add Reference.

1_addreference

  1. Locate the SDK .dll in your workspace.
  2. Click Add.

 2_add

 After you add the SDK .dll, you’ll see it in the References section of Solution Explorer.

3_references

To add the SDK source code:

  1. Select the Solution explorer and add the existing SDK source project into the IDE.
  2. Locate the SDK project from your workspace and select the .csproj file of the SDK.
    The SDK project and application project are added in IDE.

4_SDKproject

Adding the SDK project:

  1. Add the reference of the SDK project to the application.
  2. Go to Application -> References -> Add New Reference.
  3. Browse to the .csproj file of the SDK.
  4. Click OK.

Note: The .csproj file is visible only after you change the file filter to All Type.

5_alltype

For more information on how to get started with PubMatic’s SDK for Windows 10, including integrating ad formats, SDK components, and ad request parameters, see the PubMatic Windows SDK Developer Guide.