Merge branch 'MicrosoftDocs:docs' into powertoys-run-valuegenerator-docs

Author: IHorvalds

.openpublishing.redirection.json

@@ -1930,11 +1930,6 @@
       "redirect_url": "/windows/uwp/devices-sensors/",
       "redirect_document_id": false
     },
-    {
-      "source_path": "uwp/devices-sensors/host-card-emulation.md",
-      "redirect_url": "/windows/uwp/devices-sensors/",
-      "redirect_document_id": false
-    },
     {
       "source_path": "uwp/devices-sensors/generate-3mf.md",
       "redirect_url": "/windows/uwp/devices-sensors/3d-generate-3mf",

hub/android/wsa/index.md

@@ -6,7 +6,7 @@ ms.author: mattwoj
 ms.reviewer: mousma
 manager: jken
 ms.topic: article
-ms.date: 02/13/2023
+ms.date: 06/06/2023
 ---
 
 # Windows Subsystem for Android™️
@@ -24,9 +24,9 @@ For more information or support:
 
 This guide can help you test and debug your Android app on Windows:
 
-- [Set up your development environment](#set-up-your-development-environment), including [prerequisites](#prerequisites), [installing the Amazon Appstore](#install-the-amazon-appstore), and using the [Settings app](#windows-subsystem-for-android-settings-app).
-- Handle input compatibility considerations for Windows devices, such as: [keyboard input](#keyboard-input), [mouse input](#mouse-input), and [window management and resizing](#window-management-and-resizing).
+- [Set up your development environment](#set-up-your-development-environment), including [prerequisites](#prerequisites), [installing the Amazon Appstore](#install-the-amazon-appstore), and using the [Settings](#windows-subsystem-for-android-settings).
 - [Test and debug](#test-and-debug) your app on a Windows 11 device.
+- Handle input compatibility considerations for Windows devices, such as: [keyboard input](#keyboard-input), [mouse input](#mouse-input), and [window management and resizing](#window-management-and-resizing).
 - [Troubleshoot and find answers](#troubleshooting-issues).
 
 ## Developer GitHub
@@ -49,22 +49,85 @@ Windows Subsystem for Android is available on Windows 11. Your device must meet
 
 The Microsoft Store will automatically install Windows Subsystem for Android silently in the background when either of the two following user actions are taken:
 
-1. Install the Amazon Appstore from the Microsoft Store. Selecting **Get** will begin the installation of the app.
+1. Install the [Amazon Appstore from the Microsoft Store](https://www.microsoft.com/store/productId/9NJHK44TTKSX). Selecting **Get** will begin the installation of the app.
 2. Install an Android app from the Microsoft Store for the first time, which will also install the Amazon Appstore.
 
-The Amazon Appstore and the Windows Subsystem for Android Settings app will then appear in the Windows 11 Start menu and be available on search, offering a catalogue of Android apps.
+The **Amazon Appstore** app will then appear in the Windows 11 Start menu and be available on search, offering a catalogue of Android apps. The **Windows Subsystem for Android** app, which lets you control mobile app settings and features, will also appear in the Start menu.
 
 ![Screenshot of Microsoft Store page featuring the Get button on the Amazon App Store](../../images/wsa-amazon-appstore-get.png)
 
 > [!NOTE]
 > The Amazon Appstore on Windows (a requirement for running Android apps on Windows 11) is available in [select regions](https://support.microsoft.com/windows/countries-and-regions-that-support-amazon-appstore-on-windows-d8dd17c7-5994-4187-9527-ddb076f9493e?preview=true).
 
-## Windows Subsystem for Android™️ Settings app
+## Windows Subsystem for Android™️ Settings
 
-To access the Windows Subsystem for Android Settings app, go to: **Start > All Apps > Windows Subsystem for Android™️ Settings**. Learn more about specific settings app features: [Manage settings for mobile apps on Windows](https://support.microsoft.com/windows/000f97e8-8c20-490e-9ef4-cd90d903f847).
+To modify Windows Subsystem for Android settings, go to: **Start > All Apps > Windows Subsystem for Android™️**. Learn more about specific settings app features: [Manage settings for mobile apps on Windows](https://support.microsoft.com/windows/000f97e8-8c20-490e-9ef4-cd90d903f847).
 
 ![Screenshot of Latte app settings](../../images/wsa-settings.png)
 
+## Test and debug
+
+To test and debug your app on a Windows 11 device using the Windows Subsystem for Android the following set up steps are required.
+
+### Enable developer mode in Windows Settings
+
+You must first enable developer mode. Open the **[Windows Subsystem for Android™️](#windows-subsystem-for-android-settings)** settings. Once open, enable **Developer mode** under **Advanced settings**.
+
+### Connect to the Windows Subsystem for Android for debugging
+
+To connect to the Windows Subsystem for Android VM for debugging:
+
+1. Launch an Android app that was installed using the Amazon Appstore.
+
+2. You can connect using adb connect with the following command (you must have [adb installed](https://developer.android.com/studio/command-line/adb)):
+
+    ```powershell
+    adb connect 127.0.0.1:58526
+    ```
+
+### Connect to a test device
+
+To connect to a test device (with Windows Subsystem for Android installed) on the same network from Windows/Mac:
+
+1. On the test device (where Windows Subsystem for Android is installed) open a PowerShell window and identify the IP address of the test device by running the command:
+
+    ```powershell
+    ipconfig
+    ```
+
+2. Using the debugging device terminal where Android Studio and the Android SDK is installed (Mac/Windows), enter the command:
+
+    ```console
+    adb connect <TEST DEVICE IP ADDRESS>:58526
+    ```
+
+The `<TEST DEVICE IP ADDRESS>` can be found in the output of "ipconfig" from the test device. You can also deploy and debug apps from Android Studio.
+
+To use Android Debug Bridge (ADB) to connect your development workstation directly to your Android device so you can install packages and evaluate changes, see [Android Debug Bridge in the Android Open Source Project docs](https://source.android.com/setup/build/adb).
+
+### Debug your app
+
+While apps should be installed using the Amazon Appstore, debugging an Android app on a Windows device is possible using an APK (Android application package) and adb (Android Debug Bridge).
+
+To debug an APK using adb:
+
+1. Follow the steps to connect to the Windows Subsystem for Android VM above.
+
+2. Install the APK using the adb install command: `adb install app-debug.apk`
+
+    Expected Output:
+
+    ```powershell
+    Performing Streamed Install
+    Success
+    ```
+
+3. A successful “app installed” notification  will appear in the Windows notification menu and the app will launch once selected.
+
+### Building Universal APKs
+
+Windows Subsystem for Android utilizes Intel Bridge Technology to enable Arm applications on x86 based processors. Arm applications will run on Arm-based processors natively. The emulation layer will induce a performance overhead – for optimal performance, submit your application for both the x86-64 and Arm64 architectures.
+
 ## Input compatibility considerations for Windows devices
 
 There are a few unique input behaviors to consider that will likely require updates to your Android app code, designed for handheld devices, to be compatible when running on a Windows desktop device via the Amazon Appstore.
@@ -138,73 +201,6 @@ Developing Android applications for a multi-window environment has an impact on
 
 See the [Android documentation](https://developer.android.com/guide/components/activities/activity-lifecycle) for a description of the lifecycle events. More often than not, you’ll want to use the `onStop` event and not the `onPause` or `onUserLeaveHint` events. In fact, many multi-window Android implementations do not deliver the `onUserLeaveHint` notification, and thus any business critical logic that might be in that event handler will not be called on these platforms, including Windows Subsystem for Android.
 
-## Test and debug
-
-To test and debug your app on a Windows 11 device using the Windows Subsystem for Android the following set up steps are required.
-
-### Enable developer mode in Windows Settings
-
-You must first enable developer mode in Windows Settings. There are three ways to enable developer mode:
-
-- Open the [Windows Subsystem for Android Settings app](#windows-subsystem-for-android-settings-app). Once open, enable **Developer Mode**.
-- Search for “Developer Settings” in Windows search.
-- Navigate to Settings > Privacy and Security > For developers > Developer mode.
-
-### Connect to the Windows Subsystem for Android for debugging
-
-To connect to the Windows Subsystem for Android VM for debugging:
-
-1. Launch an Android app that was installed using the Amazon Appstore.
-
-2. You can connect using adb connect with the following command (you must have [adb installed](https://developer.android.com/studio/command-line/adb)):
-
-    ```powershell
-    adb connect 127.0.0.1:58526
-    ```
-
-### Connect to a test device
-
-To connect to a test device (with Windows Subsystem for Android installed) on the same network from Windows/Mac:
-
-1. On the test device (where Windows Subsystem for Android is installed) open a PowerShell window and identify the IP address of the test device by running the command:
-
-    ```powershell
-    ipconfig
-    ```
-
-2. Using the debugging device terminal where Android Studio and the Android SDK is installed (Mac/Windows), enter the command:
-
-    ```console
-    adb connect <TEST DEVICE IP ADDRESS>:58526
-    ```
-
-The `<TEST DEVICE IP ADDRESS>` can be found in the output of "ipconfig" from the test device. You can also deploy and debug apps from Android Studio.
-
-To use Android Debug Bridge (ADB) to connect your development workstation directly to your Android device so you can install packages and evaluate changes, see [Android Debug Bridge in the Android Open Source Project docs](https://source.android.com/setup/build/adb).
-
-### Debug your app
-
-While apps should be installed using the Amazon Appstore, debugging an Android app on a Windows device is possible using an APK (Android application package) and adb (Android Debug Bridge).
-
-To debug an APK using adb:
-
-1. Follow the steps to connect to the Windows Subsystem for Android VM above.
-
-2. Install the APK using the adb install command: `adb install app-debug.apk`
-
-    Expected Output:
-
-    ```powershell
-    Performing Streamed Install
-    Success
-    ```
-
-3. A successful “app installed” notification  will appear in the Windows notification menu and the app will launch once selected.
-
-### Building Universal APKs
-
-Windows Subsystem for Android utilizes Intel Bridge Technology to emulate Arm applications on x86 based processors. Arm applications will run on Arm based processors natively. The emulation layer will induce a performance overhead – for optimal performance, submit your application for both the x86-64 and Arm64 architectures.
-
 ## VM lifecycle considerations
 
 Windows Subsystem for Android utilizes a virtual machine (VM) which provides compatibility with the [AOSP framework](https://source.android.com/) and devices like keyboards, mice, touch, pen, etc.

hub/android/wsa/preview-program.md

@@ -29,7 +29,7 @@ Windows Subsystem for Android™️ is available on Windows 11.
 
 - Your device must meet specific requirements. [Install mobile apps and the Amazon Appstore: Device requirements](https://support.microsoft.com/windows/install-mobile-apps-and-the-amazon-appstore-f8d0abb5-44ad-47d8-b9fb-ad6b1459ff6c).
 - You must have the [Amazon Appstore installed](https://support.microsoft.com/windows/install-mobile-apps-and-the-amazon-appstore-f8d0abb5-44ad-47d8-b9fb-ad6b1459ff6c) on your Windows 11 device to participate in the preview. An Amazon account is also required to download mobile apps from the Amazon Appstore.
-- Windows Subsystem for Android™️ is currently only available in the US.
+- Windows Subsystem for Android™️ is currently available in [select countries and regions](https://support.microsoft.com/windows/countries-and-regions-that-support-amazon-appstore-on-windows-d8dd17c7-5994-4187-9527-ddb076f9493e).
 
 ## Sign Up
 

hub/android/wsa/release-notes.md

@@ -13,6 +13,15 @@ ms.date: 03/15/2023
 
 These release notes are based on updates to the Windows Subsystem for Android™️. For basic information on how to install and run Android™️ apps on Windows, see the Support article: [Installing the Amazon Appstore and Android™️ Apps](https://support.microsoft.com/windows/mobile-apps-and-the-windows-subsystem-for-android-f8d0abb5-44ad-47d8-b9fb-ad6b1459ff6c).
 
+## Build 2304.40000.3.0
+
+June 1, 2023
+- Package verification for apps on WSA: Android apps are scanned using anti-virus software installed on Windows prior to app installation.
+- Ability for users to configure how much memory to assign to Android
+- Android apps will be launched when a user opens the supported app link from any app (Android AppLink support)
+- Linux kernel updated to 5.15.94
+- Improvements to platform reliability and performance
+
 ## Build 2303.40000.3.0
 
 April 11, 2023

hub/apps/design/controls/pivot.md

@@ -79,6 +79,8 @@ This XAML creates a NavigationView with 3 sections of content, like the example
         <NavigationViewItem Content="Section 2" x:Name="Section2Content" />
         <NavigationViewItem Content="Section 3" x:Name="Section3Content" />
     </NavigationView.MenuItems>
+    
+    <Frame x:Name="ContentFrame" />
 </NavigationView>
 
 <Page x:Class="AppName.Section1Page">
@@ -99,27 +101,26 @@ NavigationView provides more control over navigation customization and requires
 ```csharp
 private void NavView_ItemInvoked(NavigationView sender, NavigationViewItemInvokedEventArgs args)
 {
-    FrameNavigationOptions navOptions = new FrameNavigationOptions();
-    navOptions.TransitionInfoOverride = new SlideNavigationTransitionInfo() {
-         SlideNavigationTransitionDirection=args.RecommendedNavigationTransitionInfo
-    };
-
-    navOptions.IsNavigationStackEnabled = False;
-
-    switch (item.Name)
-    {
-        case "Section1Content":
-            ContentFrame.NavigateToType(typeof(Section1Page), null, navOptions);
-            break;
-
-        case "Section2Content":
-            ContentFrame.NavigateToType(typeof(Section2Page), null, navOptions);
-            break;
-
-        case "Section3Content":
-            ContentFrame.NavigateToType(typeof(Section3Page), null, navOptions);
-            break;
-    }  
+   var navOptions = new FrameNavigationOptions
+   {
+      TransitionInfoOverride = args.RecommendedNavigationTransitionInfo,
+      IsNavigationStackEnabled = false,
+   };
+
+   switch (args.InvokedItemContainer.Name)
+   {
+      case nameof(Section1Content):
+         ContentFrame.NavigateToType(typeof(Section1Page), null, navOptions);
+         break;
+
+      case nameof(Section2Content):
+         ContentFrame.NavigateToType(typeof(Section2Page), null, navOptions);
+         break;
+
+      case nameof(Section3Content):
+         ContentFrame.NavigateToType(typeof(Section3Page), null, navOptions);
+         break;
+   }  
 }
 ```
 

hub/apps/design/globalizing/loc-international-fonts.md

@@ -32,7 +32,7 @@ In the following table, the "Language tag" column lists the [BCP-47 language tag
 | Central Kurdish (Arabic) | ku-ARAB-IQ | Segoe UI |
 | Cherokee (Cherokee) | chr-CHER-US | Gadugi |
 | Chinese Simplified | zh-CN | Microsoft YaHei UI |
-| Chinese Traditional (Hong Kong) | zh-HK | Microsoft JhengHei UI |
+| Chinese Traditional (Hong Kong Special Administrative Region) | zh-HK | Microsoft JhengHei UI |
 | Chinese Traditional (Taiwan) | zh-TW | Microsoft JhengHei UI |
 | Croatian | hr-HR | Segoe UI |
 | Czech | cs-CZ | Segoe UI |

hub/apps/design/globalizing/use-utf8-code-page.md

@@ -1,7 +1,7 @@
 ---
-description: How to use UTF code pages in Windows apps.
 title: Use UTF-8 code pages in Windows apps
-ms.date: 01/11/2022
+description: How to use UTF code pages in Windows apps.
+ms.date: 06/21/2023
 ms.topic: article
 ms.custom: seo-windows-dev
 ---
@@ -16,7 +16,10 @@ UTF-8 is the universal code page for internationalization and is able to encode
 
 As of Windows Version 1903 (May 2019 Update), you can use the ActiveCodePage property in the appxmanifest for packaged apps, or the fusion manifest for unpackaged apps, to force a process to use UTF-8 as the process code page.
 
-You can declare this property and target/run on earlier Windows builds, but you must handle legacy code page detection and conversion as usual. With a minimum target version of Windows Version 1903, the process code page will always be UTF-8 so legacy code page detection and conversion can be avoided.
+> [!NOTE]
+> GDI doesn't currently support setting the ActiveCodePage property per process. Instead, GDI defaults to the active system codepage. To configure your app to render UTF-8 text via GDI, go to Windows **Settings** > **Time \& language** > **Language \& region** > **Administrative language settings** > **Change system locale**, and check **Beta: Use Unicode UTF-8 for worldwide language support**. Then reboot the PC for the change to take effect.
+
+You can declare the ActiveCodePage property, and target/run on earlier Windows builds, but you must handle legacy code page detection and conversion as usual. With a minimum target version of Windows Version 1903, the process code page will always be UTF-8, so legacy code page detection and conversion can be avoided.
 
 > [!NOTE]
 > An encoded character takes between 1 and 4 bytes. UTF-8 encoding supports longer byte sequences, up to 6 bytes, but the biggest code point of Unicode 6.0 (U+10FFFF) only takes 4 bytes.
@@ -59,22 +62,23 @@ You can declare this property and target/run on earlier Windows builds, but you
 ```
 
 > [!NOTE]
-> Add a manifest to an existing executable from the command line with `mt.exe -manifest <MANIFEST> -outputresource:<EXE>;#1`
+> Add a manifest to an existing executable from the command line with `mt.exe -manifest <MANIFEST> -outputresource:<EXE>;#1`.
 
 ## -A vs. -W APIs
 
 Win32 APIs often support both -A and -W variants.
 
 -A variants recognize the ANSI code page configured on the system and support `char*`, while -W variants operate in UTF-16 and support `WCHAR`.
 
-Until recently, Windows has emphasized "Unicode" -W variants over -A APIs. However, recent releases have used the ANSI code page and -A APIs as a means to introduce UTF-8 support to apps. If the ANSI code page is configured for UTF-8, -A APIs typically operate in UTF-8. This model has the benefit of supporting existing code built with -A APIs without any code changes.
+Until recently, Windows has emphasized "Unicode" -W variants over -A APIs. However, recent releases have used the ANSI code page and -A APIs as a means to introduce UTF-8 support to apps. If the ANSI code page is configured for UTF-8, then -A APIs typically operate in UTF-8. This model has the benefit of supporting existing code built with -A APIs without any code changes.
 
 ## Code page conversion
 
-As Windows operates natively in UTF-16 (`WCHAR`), you might need to convert UTF-8 data to UTF-16 (or vice versa) to interoperate with Windows APIs.
+Because Windows operates natively in UTF-16 (`WCHAR`), you might need to convert UTF-8 data to UTF-16 (or vice versa) to interoperate with Windows APIs.
 
 [MultiByteToWideChar](/windows/desktop/api/stringapiset/nf-stringapiset-multibytetowidechar) and [WideCharToMultiByte](/windows/desktop/api/stringapiset/nf-stringapiset-widechartomultibyte) let you convert between UTF-8 and UTF-16 (`WCHAR`) (and other code pages). This is particularly useful when a legacy Win32 API might only understand `WCHAR`. These functions allow you to convert UTF-8 input to `WCHAR` to pass into a -W API and then convert any results back if necessary.
-When using these functions with `CodePage` set to `CP_UTF8`, use `dwFlags` of either `0` or `MB_ERR_INVALID_CHARS`, otherwise an `ERROR_INVALID_FLAGS` occurs.
+
+Use `dwFlags` of either `0` or `MB_ERR_INVALID_CHARS` when using these functions with `CodePage` set to `CP_UTF8` (otherwise an `ERROR_INVALID_FLAGS` occurs).
 
 > [!NOTE]
 > `CP_ACP` equates to `CP_UTF8` only if running on Windows Version 1903 (May 2019 Update) or above and the ActiveCodePage property described above is set to UTF-8. Otherwise, it honors the legacy system code page. We recommend using `CP_UTF8` explicitly.