Grabbing final versions of updated XDR files because it's easier than trying to figure out the TOC merge conflicts after the big refactor.

Author: drewbatgit

hub/apps/develop/toc.yml

@@ -462,8 +462,14 @@ items:
           href: actions/action-provider-manifest.md
       - name: Cross Device People API
         href: windows-integration/cross-device-people-api.md
-      - name: Cross Device Resume
-        href: windows-integration/cross-device-resume.md
+      - name: Cross Device Resume (XDR)
+        items:
+        - name: Overview
+          href: develop/windows-integration/cross-device-resume-overview.md
+        - name: Cross Device Resume with Android Apps
+          href: develop/windows-integration/cross-device-resume.md
+        - name: WNS for Cross Device Resume
+          href: develop/windows-integration/integrate-app-continuity.md
       - name: Default apps platform
         href: windows-integration/default-apps-platform.md
       - name: Pin to taskbar

hub/apps/develop/windows-integration/cross-device-resume-overview.md

@@ -0,0 +1,21 @@
+---
+description: This section of the documentation provides developer guidance for integrating with the Windows Cross Device Resume (XDR) feature.
+title: Cross Device Resume (XDR)
+ms.topic: concept-article
+ms.date: 12/10/2025
+ms.localizationpriority: medium
+# customer intent: As a Windows developer, I want to learn how to integrate my app with Windows so that I can provide a seamless experience for my users.
+---
+
+# Cross Device Resume (XDR) Overview
+
+Cross Device Resume (XDR) is a Windows feature that enables developers to add continuity between Windows apps and apps on other platforms. This section of the documentation provides information about the technologies that are currently available to enable XDR scenarios.
+
+## In this section
+
+| Topic | Description |
+|-------|-------------|
+| [Use the Continuity SDK to implement XDR for Android and Windows Applications](cross-device-resume.md) | Learn how to use the Continuity SDK to implement XDR with Android apps. |
+| [Use WNS Notifications to implement XDR](integrate-app-continuity.md) | Learn how to implement Cross Device Resume (XDR) using Windows Push Notification Service (WNS) raw notifications. |
+
+

hub/apps/develop/windows-integration/cross-device-resume.md

@@ -1,12 +1,12 @@
 ---
-title: Cross Device Resume (XDR) Using Continuity SDK
+title: Use the Continuity SDK to implement Cross Device Resume (XDR) for Android and Windows Applications
 description: Guidelines for first & third party developers to integrate with Windows XDR experiences using the Continuity SDK.
 ms.date: 08/12/2025
 ms.topic: how-to
 # customer intent: As a Windows developer, I want to learn how to integrate my app with Windows XDR experiences so that I can provide a seamless experience for my users.
 ---
 
-# Cross Device Resume (XDR) using Continuity SDK (Android and Windows Applications)
+# Use the Continuity SDK to implement Cross Device Resume (XDR) for Android and Windows Applications
 
 This article provides comprehensive guidelines for first-party and third-party developers on how to integrate features using the Continuity SDK in your applications. The Continuity SDK enables seamless cross-device experiences, allowing users to resume activities across different platforms, including Android and Windows.
 
@@ -75,76 +75,236 @@ The App must:
    1. After calling the Initialize function, a callback that implements IAppContextEventHandler should be triggered.
 1. Send/Delete **AppContext**:
    1. After initializing the SDK, if **onContextRequestReceived** is called, it indicates the connection is established. The app can then send (including create and update) **AppContext** to LTW or delete **AppContext** from LTW.
+   1. If there is no connection between the phone and PC and the app sends **AppContext** to LTW, the app will receive **onContextResponseError** with the message “PC is not connected.”
+   1. When the connection is re-established, **onContextRequestReceived** is called again. The app can then send the current AppContext to LTW. 
    1. After **onSyncServiceDisconnected** or deinitializing the SDK, the app should not send an **AppContext**.
 
 Below is a code example. For all the required and optional fields in **AppContext**, please refer to the [AppContext description](#appcontext). 
 
 The following Android code snippet demonstrates how to make API requests using the Continuity SDK:
 
 ```kotlin MainActivity.kt
-class MainActivity : ComponentActivity() { 
+import android.os.Bundle 
+import android.util.Log 
+import android.widget.Button 
+import android.widget.TextView 
+import android.widget.Toast 
+import androidx.activity.enableEdgeToEdge 
+import androidx.appcompat.app.AppCompatActivity 
+import androidx.core.view.ViewCompat 
+import androidx.core.view.WindowInsetsCompat 
+import androidx.lifecycle.LiveData 
+import androidx.lifecycle.MutableLiveData 
+import androidx.lifecycle.Observer 
+import com.microsoft.crossdevicesdk.continuity.AppContext 
+import com.microsoft.crossdevicesdk.continuity.AppContextManager 
+import com.microsoft.crossdevicesdk.continuity.ContextRequestInfo 
+import com.microsoft.crossdevicesdk.continuity.IAppContextEventHandler 
+import com.microsoft.crossdevicesdk.continuity.IAppContextResponse 
+import com.microsoft.crossdevicesdk.continuity.LogUtils 
+import com.microsoft.crossdevicesdk.continuity.ProtocolConstants 
+import java.util.UUID 
+
+  
+
+class MainActivity : AppCompatActivity() { 
+
+    //Make buttons member variables --- 
+    private lateinit var buttonSend: Button 
+    private lateinit var buttonDelete: Button 
+    private lateinit var buttonUpdate: Button 
 
-    // Required code for Continuity SDK integration 
     private val appContextResponse = object : IAppContextResponse { 
         override fun onContextResponseSuccess(response: AppContext) { 
             Log.d("MainActivity", "onContextResponseSuccess") 
+            runOnUiThread { 
+                Toast.makeText( 
+                    this@MainActivity, 
+                    "Context response success: ${response.contextId}", 
+                    Toast.LENGTH_SHORT 
+                ).show() 
+            } 
         } 
 
         override fun onContextResponseError(response: AppContext, throwable: Throwable) { 
-            Log.d("MainActivity", "onContextResponseError") 
+            Log.d("MainActivity", "onContextResponseError: ${throwable.message}") 
+            runOnUiThread { 
+                Toast.makeText( 
+                    this@MainActivity, 
+                    "Context response error: ${throwable.message}", 
+                    Toast.LENGTH_SHORT 
+                ).show() 
+
+                // Check if the error message contains the specific string 
+                if (throwable.message?.contains("PC is not connected") == true) { 
+                    //App should stop sending intent once this callback is received 
+                }
+            } 
         } 
     } 
 
     private lateinit var appContextEventHandler: IAppContextEventHandler 
 
-    private val appContext: AppContext = AppContext() 
+    private val _currentAppContext = MutableLiveData<AppContext?>() 
+
+    private val currentAppContext: LiveData<AppContext?> get() = _currentAppContext 
 
     override fun onCreate(savedInstanceState: Bundle?) { 
         super.onCreate(savedInstanceState) 
+        enableEdgeToEdge() 
+        setContentView(R.layout.activity_main) 
+        ViewCompat.setOnApplyWindowInsetsListener(findViewById(R.id.main)) { v, insets -> 
+            val systemBars = insets.getInsets(WindowInsetsCompat.Type.systemBars()) 
+            v.setPadding(systemBars.left, systemBars.top, systemBars.right, systemBars.bottom) 
+            insets 
+        } 
+
+        LogUtils.setDebugMode(true) 
         var ready = false 
-    // Existing code...
+        buttonSend = findViewById(R.id.buttonSend) 
+        buttonDelete = findViewById(R.id.buttonDelete) 
+        buttonUpdate = findViewById(R.id.buttonUpdate) 
+        setButtonDisabled(buttonSend) 
+        setButtonDisabled(buttonDelete) 
+        setButtonDisabled(buttonUpdate) 
+
+        buttonSend.setOnClickListener { 
+            if (ready) { 
+                sendResumeActivity() 
+            } 
+        } 
+
+        buttonDelete.setOnClickListener { 
+            if (ready) { 
+                deleteResumeActivity() 
+            } 
+        } 
+
+        buttonUpdate.setOnClickListener { 
+            if (ready) { 
+                updateResumeActivity() 
+            }
+        } 
 
-        // Required code for Continuity SDK integration 
         appContextEventHandler = object : IAppContextEventHandler { 
+
             override fun onContextRequestReceived(contextRequestInfo: ContextRequestInfo) { 
-                Log.d("MainActivity", "onContextRequestReceived") 
+                LogUtils.d("MainActivity", "onContextRequestReceived") 
                 ready = true 
-    
-                sendResume() 
-            } 
+                setButtonEnabled(buttonSend) 
+                setButtonEnabled(buttonDelete) 
+                setButtonEnabled(buttonUpdate) 
 
-            override fun onSyncServiceDisconnected() { 
-                Log.d("MainActivity", "onSyncServiceDisconnected") 
             } 
 
+  
+
             override fun onInvalidContextRequestReceived(throwable: Throwable) { 
                 Log.d("MainActivity", "onInvalidContextRequestReceived") 
+
+            } 
+
+  
+
+            override fun onSyncServiceDisconnected() { 
+                Log.d("MainActivity", "onSyncServiceDisconnected") 
                 ready = false 
-                deleteResume() 
+                setButtonDisabled(buttonSend) 
+                setButtonDisabled(buttonDelete) 
             } 
         } 
 
-        // Required code for Continuity SDK integration 
+        // Initialize the AppContextManager 
         AppContextManager.initialize(this.applicationContext, appContextEventHandler) 
+
+        // Update currentAppContext text view. 
+        val textView = findViewById<TextView>(R.id.appContext) 
+
+        currentAppContext.observe(this, Observer { appContext -> 
+            appContext?.let { 
+                textView.text = 
+                    "Current app context: ${it.contextId}\n App ID: ${it.appId}\n Created: ${it.createTime}\n Updated: ${it.lastUpdatedTime}\n Type: ${it.type}" 
+                Log.d("MainActivity", "Current app context: ${it.contextId}") 
+            } ?: run { 
+                textView.text = "No current app context available" 
+                Log.d("MainActivity", "No current app context available") 
+            } 
+        }) 
     } 
 
-    // Required code for Continuity SDK integration 
-    private fun sendResume() { 
-        appContext.setContextId("13f53be4-d0d1-448a-8c78-af28820af119") 
-        appContext.setAppId(this.packageName) 
-        appContext.type = ProtocolConstants.TYPE_RESUME_ACTIVITY 
-    
-        // Set context fields. Refer to the AppContext section for detailed field descriptions.
+
+    // Send resume activity to LTW 
+    private fun sendResumeActivity() { 
+        val appContext = AppContext().apply { 
+            this.contextId = generateContextId() 
+            this.appId = applicationContext.packageName 
+            this.createTime = System.currentTimeMillis() 
+            this.lastUpdatedTime = System.currentTimeMillis() 
+            this.type = ProtocolConstants.TYPE_RESUME_ACTIVITY 
+        } 
+
+        _currentAppContext.value = appContext 
         AppContextManager.sendAppContext(this.applicationContext, appContext, appContextResponse) 
     } 
 
-    // Required code for Continuity SDK integration 
-    private fun deleteResume() { 
-        AppContextManager.deleteAppContext(this.applicationContext, "13f53be4-d0d1-448a-8c78-af28820af119", appContextResponse) 
+    // Delete resume activity from LTW 
+    private fun deleteResumeActivity() { 
+        currentAppContext.value?.let { 
+            AppContextManager.deleteAppContext( 
+                this.applicationContext, 
+                it.contextId, 
+                appContextResponse 
+            ) 
+            _currentAppContext.value = null 
+        } ?: run { 
+            Toast.makeText(this, "No resume activity to delete", Toast.LENGTH_SHORT).show() 
+            Log.d("MainActivity", "No resume activity to delete") 
+        }
+    } 
+
+    private fun updateResumeActivity() { 
+        currentAppContext.value?.let { 
+            it.lastUpdatedTime = System.currentTimeMillis() 
+            AppContextManager.sendAppContext(this.applicationContext, it, appContextResponse) 
+            _currentAppContext.postValue(it) 
+        } ?: run { 
+            Toast.makeText(this, "No resume activity to update", Toast.LENGTH_SHORT).show() 
+            Log.d("MainActivity", "No resume activity to update") 
+        } 
+    } 
+
+    private fun setButtonDisabled(button: Button) { 
+        button.isEnabled = false 
+        button.alpha = 0.5f 
+    } 
+
+    private fun setButtonEnabled(button: Button) { 
+        button.isEnabled = true 
+        button.alpha = 1.0f 
     } 
 
-    // Existing code 
-}
+    override fun onDestroy() { 
+        super.onDestroy() 
+        // Deinitialize the AppContextManager 
+        AppContextManager.deInitialize(this.applicationContext) 
+    } 
+
+    override fun onStart() { 
+        super.onStart() 
+        // AppContextManager.initialize(this.applicationContext, appContextEventHandler) 
+    } 
+
+
+    override fun onStop() { 
+        super.onStop() 
+        // AppContextManager.deInitialize(this.applicationContext) 
+    } 
+
+    private fun generateContextId(): String { 
+        return "${packageName}.${UUID.randomUUID()}" 
+    } 
+
+} 
 ```
 
 ## Integration validation steps
@@ -170,7 +330,13 @@ The following steps are required to prepare for the integration validation:
 Next, follow these steps to validate the integration:
 
 1. Launch the app and initialize the SDK. Confirm that **onContextRequestReceived** is called. 
-1. After **onContextRequestReceived** has been called, the app can send the **AppContext** to LTW. If **onContextResponseSuccess** is called after sending **AppContext**, the SDK integration is successful. 
+1. After **onContextRequestReceived** has been called, the app can send the **AppContext** to LTW. If **onContextResponseSuccess** is called after sending **AppContext**, the SDK integration is successful.
+1. If the app sends **AppContext** while the PC is locked or disconnected, verify that **onContextResponseError** is called with “PC is not connected.”
+1. When the connection is restored, ensure **onContextRequestReceived** is called again and app can then send the current AppContext to LTW.
+
+The screenshot below shows the log entry when the PC is disconnected with the error message "PC is not connected" and the log entry after reconnection when **onContextRequestReceived** is called again.
+
+:::image type="content" source="images/xdr-not-connected-logs.png" alt-text="A screenshot of Windows log entries showing the PC is not connected error message and the subsequent onContextRequestReceived log entry after reconnection.":::
 
 ## AppContext 
 

hub/apps/develop/windows-integration/images/xdr-not-connected-logs.png

@@ -2,7 +2,7 @@
 description: This section of the documentation provides developer guidance for integrating with Windows system components and other Windows features.
 title: Integrate with Windows
 ms.topic: concept-article
-ms.date: 12/05/2025
+ms.date: 04/10/2025
 ms.localizationpriority: medium
 # customer intent: As a Windows developer, I want to learn how to integrate my app with Windows so that I can provide a seamless experience for my users.
 ---
@@ -22,13 +22,21 @@ The following table lists the Windows system components that support integration
 | [Search providers](../search/search-providers.md) | Learn how to integrate into the Windows Search experience. |
 | [Widget providers](../widgets/widget-providers.md) | Learn how to implement a Windows widget service provider to support your app. |
 
+## Windows features using AI
+
+| Feature | Description |
+|--|--|
+| [Recall](./recall/index.md) | Learn how to use the AI-assisted Recall feature with the User Activity API in Windows. |
+| [Click to Do](./click-to-do.md) | Learn how to use the AI-assisted Click to Do feature in Windows. |
+
 ## Other Windows integration features
 
 The following table lists other Windows integration features that support 3rd party developers.
 
 | Feature | Description |
 |--|--|
-| [Cross Device Resume (XDR) using Continuity SDK](cross-device-resume.md) | Guidelines for first & third party developers to integrate with Windows XDR experiences using the Continuity SDK. |
+| [Cross Device Resume (XDR)](cross-device-resume-overview.md) | Developer guidance for integrating with the Windows Cross Device Resume (XDR) feature. |
+| [Integrate with application continuity and WNS notifications](integrate-app-continuity.md) | A step-by-step guide for first and third parties to integrate application continuity (resume) with Windows Push Notification Service (WNS) raw notifications. |
 | [Smart App Control](../smart-app-control/overview.md) | Smart App Control is a new app execution control feature that combines Microsoft’s app intelligence services and Windows' code integrity features to protect users from untrusted or potentially dangerous code. |
 | [Windows Share integration](integrate-sharesheet-overview.md) | The Windows Share Sheet is a system-provided UI that enables users to share content from your app with other apps. |
 | [Windows People experiences](cross-device-people-api.md) | Learn how third party apps can integrate with Windows People experiences using APIs to store their contacts. |