Merge branch 'main' into aashcraft/main-cloud-files-add-copilot-plus-note

Author: alvinashcraft

windows.applicationmodel.core/coreapplicationview_ishosted.md

@@ -10,14 +10,47 @@ public bool IsHosted { get; }
 # Windows.ApplicationModel.Core.CoreApplicationView.IsHosted
 
 ## -description
-Gets the value that indicates whether this app view is hosted or not.
+
+Gets the value that indicates whether this app view is hosted.
 
 ## -property-value
-If **true**, this app view is hosted; if **false**, it is not.
+
+If **true**, this app view is hosted; if **false**, it isn't.
 
 ## -remarks
-An app view is considered hosted when the process that launched it controls its lifetime. For example, the window that opens when a [FileOpenPicker](../windows.storage.pickers/fileopenpicker.md) is launched is considered hosted.
+
+An app view is hosted when the process that launches it controls its lifetime. For example, the window that opens when a [FileOpenPicker](../windows.storage.pickers/fileopenpicker.md) is launched is hosted.
 
 ## -examples
 
+Here's a simple example that demonstrates how to use the `IsHosted` property:
+
+```csharp
+using Windows.ApplicationModel.Core;
+using Windows.UI.Xaml;
+
+namespace ExampleApp
+{
+    public sealed partial class MainPage : Page
+    {
+        public MainPage()
+        {
+            this.InitializeComponent();
+
+            // Check if the current app view is hosted
+            bool isHosted = CoreApplication.GetCurrentView().IsHosted;
+
+            // Display the result
+            if (isHosted)
+            {
+                System.Diagnostics.Debug.WriteLine("The app view is hosted.");
+            }
+            else
+            {
+                System.Diagnostics.Debug.WriteLine("The app view is not hosted.");
+            }
+        }
+    }
+}
+
 ## -see-also

windows.applicationmodel.datatransfer.dragdrop.core/coredragdropmanager.md

@@ -11,32 +11,67 @@ public class CoreDragDropManager : Windows.ApplicationModel.DataTransfer.DragDro
 # Windows.ApplicationModel.DataTransfer.DragDrop.Core.CoreDragDropManager
 
 ## -description
+
 Manages access for drag and drop within and between apps.
 
 ## -remarks
 
 ## -examples
+
+The following example demonstrates how to use the `CoreDragDropManager` to set up a drag-and-drop target that filters incoming data and delegates handling to a specified control.
+
 ```csharp
+using System;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.ApplicationModel.DataTransfer.DragDrop.Core;
+using Windows.UI.Xaml.Controls;
+
 public sealed partial class MainPage : Page
 {
-      private void DropOperationTargetRequested(CoreDragDropManager sender, 
-            CoreDropOperationTargetRequestedEventArgs evtArgs)
-      {
-            // Create a target (see above for more implementation details)
-            var target = new DropTarget ();
-            evtArgs.SetTarget(target);
-      }
-      
-      public MainPage()
-      {                           
-            InitializeComponents();
-            var dragDropManager = DragDropManager.GetForCurrentView();
-            dragDropManager.DropOperationTargetRequested += DropOperationTargetRequested;
-      }
-}
+    private void DropOperationTargetRequested(CoreDragDropManager sender, CoreDropOperationTargetRequestedEventArgs evtArgs)
+    {
+        // Create a target (see above for more implementation details)
+        var target = new DropTarget();
 
-```
+        // Example filter: Only allow storage files
+        target.DragOver += (s, e) =>
+        {
+            if (e.DataView.Contains(StandardDataFormats.StorageItems))
+            {
+                e.AcceptedOperation = DataPackageOperation.Copy;
+            }
+            else
+            {
+                e.AcceptedOperation = DataPackageOperation.None;
+            }
+        };
 
+        // Delegate handling to a specified control
+        target.Drop += (s, e) =>
+        {
+            // Assuming 'specifiedControl' is a UI element in your app
+            specifiedControl.HandleDrop(e);
+        };
 
+        evtArgs.SetTarget(target);
+    }
+
+    public MainPage()
+    {
+        InitializeComponent();
+        var dragDropManager = CoreDragDropManager.GetForCurrentView();
+        dragDropManager.TargetRequested += DropOperationTargetRequested;
+    }
+}
+
+// Example of a specified control handling the drop
+public class SpecifiedControl : UserControl
+{
+    public void HandleDrop(CoreDragInfo dragInfo)
+    {
+        // Handle the drop operation here
+    }
+}
+```
 
 ## -see-also

windows.applicationmodel.datatransfer/datapackage_setdata_2074524277.md

@@ -10,21 +10,168 @@ public void SetData(System.String formatId, System.Object value)
 # Windows.ApplicationModel.DataTransfer.DataPackage.SetData
 
 ## -description
+
 Sets the data contained in the [DataPackage](datapackage.md) in a [RandomAccessStream](../windows.storage.streams/randomaccessstream.md) format.
 
 ## -parameters
+
 ### -param formatId
-Specifies the format of the data. We recommend that you set this value by using the [StandardDataFormats](standarddataformats.md) class.
+
+Specifies the format of the data. Set this value by using the [StandardDataFormats](standarddataformats.md) class.
 
 ### -param value
+
 Specifies the content that the [DataPackage](datapackage.md) contains.
 
 ## -remarks
-To add data using this method, your app must convert the data into an object. You must also specify a *formatId* that target apps can use to request the data. Note that the target app can request this data only if it knows the *formatId*.
 
-This method is often used when you use a delegate function to share data. For more information, see [How to support pull operations](/previous-versions/windows/apps/hh770848(v=win.10)).
+To add data with this method, your app must convert the data into an object. You must also specify a *formatId* that target apps can use to request the data. The target app can request this data only if it knows the *formatId*.
+
+Use this method when you use a delegate function to share data. For more information, see [How to support pull operations](/previous-versions/windows/apps/hh770848(v=win.10)).
 
 ## -examples
 
+The following example demonstrates how to use the **SetData** method to serialize a custom C# object into a **RandomAccessStream** and pass it to the **DataPackage**. It also shows how to deserialize the data back to the original object type by using [GetDataAsync](datapackageview_getdataasync_225712847.md).
+
+```csharp
+using System;
+using System.IO;
+using System.Runtime.Serialization;
+using Windows.ApplicationModel.DataTransfer;
+using Windows.Storage.Streams;
+
+// Define a custom class to serialize
+[DataContract]
+public class PersonData
+{
+    [DataMember]
+    public string Name { get; set; }
+    
+    [DataMember]
+    public int Age { get; set; }
+    
+    [DataMember]
+    public string Email { get; set; }
+}
+
+// Method to serialize object and set data in DataPackage
+private async Task<DataPackage> CreateDataPackageWithSerializedObject()
+{
+    // Create sample data
+    var person = new PersonData
+    {
+        Name = "John Doe",
+        Age = 30,
+        Email = "john.doe@example.com"
+    };
+
+    // Serialize the object to a RandomAccessStream
+    var stream = await SerializeObjectToStreamAsync(person);
+    
+    // Create DataPackage and set the serialized data
+    var dataPackage = new DataPackage();
+    dataPackage.SetData("application/x-custom-person", stream);
+    
+    return dataPackage;
+}
+
+// Helper method to serialize an object to InMemoryRandomAccessStream
+private async Task<InMemoryRandomAccessStream> SerializeObjectToStreamAsync<T>(T obj)
+{
+    // Create a DataContractSerializer for the object type
+    var serializer = new DataContractSerializer(typeof(T));
+    
+    // Create a memory stream to hold the serialized data
+    using (var memoryStream = new MemoryStream())
+    {
+        // Serialize the object to the memory stream
+        serializer.WriteObject(memoryStream, obj);
+        
+        // Create an InMemoryRandomAccessStream and copy the data
+        var randomAccessStream = new InMemoryRandomAccessStream();
+        var outputStream = randomAccessStream.GetOutputStreamAt(0);
+        var dataWriter = new DataWriter(outputStream);
+        
+        // Write the serialized bytes to the random access stream
+        dataWriter.WriteBytes(memoryStream.ToArray());
+        await dataWriter.StoreAsync();
+        await dataWriter.FlushAsync();
+        
+        // Reset position to beginning for reading
+        randomAccessStream.Seek(0);
+        
+        dataWriter.Dispose();
+        outputStream.Dispose();
+        
+        return randomAccessStream;
+    }
+}
+
+// Method to deserialize data from DataPackageView back to original object
+private async Task<T> DeserializeObjectFromDataAsync<T>(DataPackageView dataPackageView, string formatId)
+{
+    try
+    {
+        // Get the stream data from the DataPackageView
+        var streamData = await dataPackageView.GetDataAsync(formatId);
+        var randomAccessStream = streamData as IRandomAccessStream;
+        
+        if (randomAccessStream == null)
+            throw new InvalidOperationException("Data is not in the expected stream format");
+        
+        // Create a DataContractSerializer for the target type
+        var serializer = new DataContractSerializer(typeof(T));
+        
+        // Convert RandomAccessStream to a regular .NET Stream for deserialization
+        var inputStream = randomAccessStream.GetInputStreamAt(0);
+        var dataReader = new DataReader(inputStream);
+        
+        // Read all bytes from the stream
+        var bytesLoaded = await dataReader.LoadAsync((uint)randomAccessStream.Size);
+        var bytes = new byte[bytesLoaded];
+        dataReader.ReadBytes(bytes);
+        
+        // Deserialize from memory stream
+        using (var memoryStream = new MemoryStream(bytes))
+        {
+            var deserializedObject = (T)serializer.ReadObject(memoryStream);
+            return deserializedObject;
+        }
+    }
+    catch (Exception ex)
+    {
+        throw new InvalidOperationException($"Failed to deserialize object: {ex.Message}", ex);
+    }
+}
+
+// Example usage demonstrating the complete round-trip
+private async Task ExampleUsageAsync()
+{
+    // Create DataPackage with serialized object
+    var dataPackage = await CreateDataPackageWithSerializedObject();
+    
+    // Simulate getting the data back (e.g., from clipboard or sharing operation)
+    var dataPackageView = dataPackage.GetView();
+    
+    // Deserialize the object back to its original type
+    var retrievedPerson = await DeserializeObjectFromDataAsync<PersonData>(
+        dataPackageView, "application/x-custom-person");
+    
+    // Use the deserialized object
+    Console.WriteLine($"Name: {retrievedPerson.Name}, Age: {retrievedPerson.Age}, Email: {retrievedPerson.Email}");
+}
+```
+
+This example shows how to:
+
+1. **Serialization**: Use **DataContractSerializer** to serialize a custom object and convert it to an **InMemoryRandomAccessStream** suitable for **SetData**.
+1. **Setting Data**: Call **SetData** with a custom format identifier and the serialized stream.
+1. **Deserialization**: Retrieve the data by using **GetDataAsync** and deserialize it back to the original object type.
+1. **Error Handling**: Implement basic error handling for serialization and deserialization operations.
+
+> [!NOTE]
+> This example uses **DataContractSerializer**, which is safer and more modern than the deprecated **BinaryFormatter**. To ensure proper serialization support, add the `[DataContract]` and `[DataMember]` attributes to your custom classes.
 
 ## -see-also
+
+[GetDataAsync](datapackageview_getdataasync_225712847.md)

windows.media.core/codecsubtypes_videoformatav1.md

@@ -0,0 +1,29 @@
+---
+-api-id: P:Windows.Media.Core.CodecSubtypes.VideoFormatAv1
+-api-type: winrt property
+---
+
+# Windows.Media.Core.CodecSubtypes.VideoFormatAv1
+
+<!--
+public static string VideoFormatAv1 { get; }
+-->
+
+
+## -description
+
+Gets the string representation of the [GUID](/windows/win32/api/guiddef/ns-guiddef-guid) for the AV1 video subtype.
+
+## -property-value
+
+The string representation of the AV1 video subtype.
+
+## -remarks
+
+This GUID matches the value of the Media Foundation subtype [MFVideoFormat_AV1](/windows/win32/medfound/video-subtype-guids), defined using the FOURCC 'AV01'.
+
+## -see-also
+
+## -examples
+
+

windows.media.core/codecsubtypes_videoformatdv25.md

@@ -10,9 +10,11 @@ public string VideoFormatDV25 { get; }
 # Windows.Media.Core.CodecSubtypes.VideoFormatDV25
 
 ## -description
+
 Gets the string representation of the [GUID](/windows/win32/api/guiddef/ns-guiddef-guid) for the DVCPRO 25 (525-60 or 625-50) video subtype.
 
 ## -property-value
+
 The string representation of the GUID for the DVCPRO 25 (525-60 or 625-50) video subtype.
 
 ## -remarks

windows.security.credentials/keycredentialmanager.md

@@ -16,8 +16,33 @@ Contains methods for basic management of key credentials.
 
 ## -remarks
 
+The `KeyCredentialManager` class provides methods to manage key credentials, which are RSA 2048-bit keys. These keys are used for secure authentication and cryptographic operations.
+
+#### Key Information
+
+- **Key Type**: RSA 2048-bit
+- **Signature Format**: PKCS #1 RSA PSS with SHA256
+- **Attestation Data**: The attestation data is a binary blob that includes metadata about the key, such as its origin and security properties.
+
+#### Attestation Data Format
+
+The attestation data is encoded in a binary format. It includes:
+
+1. **Key Metadata**: Information about the key's origin and properties.
+1. **Certificate Chain**: A chain of certificates that can be used to verify the authenticity of the attestation.
+
+#### Verifying Attestation Data
+
+To verify the attestation data:
+
+1. Parse the binary blob to extract the metadata and certificate chain.
+1. Use the certificate chain to validate the authenticity of the attestation.
+1. Ensure the metadata matches the expected properties of the key.
+
+For more details, refer to the [KeyCredentialManager sample](https://github.com/Microsoft/Windows-universal-samples/tree/main/Samples/KeyCredentialManager).
+
 ## -examples
 
 ## -see-also
 
-[KeyCredentialManager sample](https://github.com/Microsoft/Windows-universal-samples/tree/master/Samples/KeyCredentialManager)
+[KeyCredentialManager sample](https://github.com/Microsoft/Windows-universal-samples/tree/main/Samples/KeyCredentialManager)