implement pr comments

Author: medmonds

docs/capability-guides/mobile-access/mobile-device-sdks/handling-system-permissions.md

@@ -1,16 +1,40 @@
 # Handling System Permissions
 
-Missing or required system permissions (Bluetooth, internet connectivity, etc.) are surfaced as `CredentialError.userInteractionRequired(action)` entries on each credential’s `errors` array. Observe these errors after activation and handle the specified actions. Errors are automatically updated to reflect current requirements.
+The mobile SDK surfaces missing or required system permissions (Bluetooth, internet connectivity, and so on) as `CredentialError.userInteractionRequired(action)` entries in each credential’s `errors` array. After activation, observe these errors and handle the specified actions. Errors update automatically as requirements change.
 
 ## Monitoring Permission Errors
 
 {% tabs %}
+
+{% tab title="Android Kotlin" %}
+```kotlin
+coroutineScope.launch {
+    SeamSDK.getInstance().credentials.collect { credentialsList ->
+        val errors = credentialsList.flatMap { it.errors }
+        errors.forEach { error ->
+            when (error) {
+                is SeamCredentialError.Expired -> { /* handle credential expiration error */}
+                is SeamCredentialError.Loading -> { /* handle not loaded yet */ }
+                is SeamCredentialError.Unknown -> { /* handle unknown error */}
+                is SeamCredentialError.UserInteractionRequired -> {
+                    handleUserInteractionRequired(error.interaction)
+                }
+            }
+        }
+    }
+}
+```
+{% endtab %}
+
 {% tab title="iOS Swift" %}
 
 Use Combine to watch the published credentials array and handle permission-related errors:
 
 
 ```swift
+import SeamSDK
+import Combine
+
 func startMonitoringPermissionErrors() {
     permissionCancellable = Seam.shared.$credentials
         .map { credentials in
@@ -31,13 +55,27 @@ func startMonitoringPermissionErrors() {
 {% endtabs %}
 
 
-The Seam SDK automatically clears resolved permission errors once the required permission is granted, reflecting the updated credential state.
+The mobile SDK automatically clears resolved permission errors once the required permission is granted, reflecting the updated credential state.
 
 ## Handling Permission Actions
 
 Implement your handler for each action:
 
 {% tabs %}
+
+{% tab title="Android Kotlin" %}
+```kotlin
+fun handleUserInteractionRequired(interaction: SeamRequiredUserInteraction) {
+    when (interaction) {
+        is SeamRequiredUserInteraction.CompleteOtpAuthorization -> { /* handle OTP authorization */ }
+        is SeamRequiredUserInteraction.EnableBluetooth -> { /* handle Bluetooth error */ }
+        is SeamRequiredUserInteraction.EnableInternet -> { /* handle Internet connection error*/ }
+        is SeamRequiredUserInteraction.GrantPermissions -> { /* handle permissions error*/ }
+    }
+}
+```
+{% endtab %}
+
 {% tab title="iOS Swift" %}
 ```swift
 func handlePermissionAction(_ action: CredentialUserAction) {
@@ -57,4 +95,4 @@ func handlePermissionAction(_ action: CredentialUserAction) {
 
 ## See also
 
-For a complete SwiftUI-based implementation of credential error handling for iOS, see the `SeamUnlockCardView` in the SeamComponents library, which demonstrates observing credential errors and updating the UI accordingly.
+For a complete SwiftUI-based implementation of credential error handling for iOS, see `SeamUnlockCardView` in the SeamComponents library, which demonstrates observing credential errors and updating the UI accordingly.

docs/capability-guides/mobile-access/mobile-device-sdks/initializing-the-seam-mobile-sdk.md

@@ -37,7 +37,7 @@ dependencies {
 
 {% tab title="iOS Swift" %}
 You can install SeamSDK via CocoaPods or Swift Package Manager (SPM).  
-SeamSDK supports per-lock-provider integration granularity--include only the modules you need to minimize your app's footprint.
+SeamSDK supports per-lock-provider integration granularity. Include only the modules you need to keep your app footprint minimal.
 
 {% code title="Podfile" %}
 ```ruby
@@ -206,12 +206,11 @@ $token = $client_session->token;
 ## 4. Initialize the Mobile SDK with the Client Session Token
 
 
-Use the client session token you generated earlier to bootstrap the Seam SDK on the device. Under the hood, this will set up credential synchronization and start a background sync loop to keep credentials up to date.
-
+Use the client session token that you generated earlier to bootstrap the Seam SDK on the device. Under the hood, this action sets up credential synchronization and starts a background sync loop to keep permissions up to date.
 
 ### Initialization and Error Handling
 
-Perform initialization and activation within your app’s asynchronous context (e.g., Swift’s `Task` or Kotlin coroutines) so you can handle errors. The initialization call may fail due to configuration issues (such as an invalid token), and the activation call may fail due to network or runtime errors. Catch these errors and present a user-friendly message or fallback UI as appropriate.
+Perform initialization and activation within your app’s asynchronous context (for example, Swift’s `Task` or Kotlin coroutines) so that you can handle errors. The initialization call may fail due to configuration issues (such as an invalid token), and the activation call may fail due to network or runtime errors. Catch these errors and present a user-friendly message or fallback UI as appropriate.
 
 {% tabs %}
 {% tab title="Android Kotlin" %}
@@ -243,16 +242,16 @@ try {
 ```swift
 import SeamSDK
 
-// Initialize the Mobile SDK with the Client Session Token (CST)
+// Initialize the Mobile SDK with the client session token (CST).
 Task {
     do {
-        // Bootstrap the SDK with the CST from your login flow
+        // Bootstrap the SDK with the CST from your login flow.
         try Seam.initialize(clientSessionToken: token)
-        // Start credential sync and background polling
+        // Start credential sync and background polling.
         try await Seam.shared.activate()
-        print("Seam SDK is now active")
+        print("Seam SDK is now active.")
     } catch let error as SeamError {
-        // Handle SDK-specific initialization errors (invalid token, etc)
+        // Handle SDK-specific initialization errors (invalid token, etc).
         showAlert(title: "Initialization Failed", message: error.localizedDescription)
     }
 }
@@ -263,7 +262,7 @@ Task {
 
 ### Credential Errors
 
-Any errors that occur between activation and deactivation surface on individual credential objects via their `errors` property. Observe the `credentials` array to detect and handle these errors:
+Any errors that occur between activation and deactivation surface on individual credential objects through their `errors` property. Observe the `credentials` array to detect and handle these errors:
 
 ```swift
 import SeamSDK

docs/capability-guides/mobile-access/mobile-device-sdks/using-unlock-with-tap.md

@@ -5,12 +5,12 @@ description: >-
 
 # Unlocking
 
-Unlocking with SeamSDK uses proximity to communicate credentials to door readers. When a user initiates an unlock, the SDK performs scanning, error handling, and unlock events via `Seam.shared.unlock(using:)`.
+Unlocking with SeamSDK uses proximity to communicate credentials to door readers. When a user initiates an unlock, the SDK performs scanning, error handling, and unlock events using `Seam.shared.unlock(using:)`.
 
 Using this process involves the following steps:
 
 1. Retrieve available mobile credentials.  
-2. Monitor for permission or credential errors unhandled errors will be thrown as `credentialErrors([SeamCredentialError])`  
+2. Monitor for permission or credential errors. Unhandled errors are thrown as `credentialErrors([SeamCredentialError])`.  
 3. Perform the unlock operation.  
 4. Handle unlock status events.  
 5. Cancel the unlock operation if needed.
@@ -19,18 +19,21 @@ Using this process involves the following steps:
 
 ## 1. Retrieve Mobile Credentials
 
-Access the current credentials via the published `credentials` array on `Seam.shared`:
+Access the current credentials through the published `credentials` array on `Seam.shared`:
 
 {% tabs %}
 {% tab title="iOS Swift" %}
 ```swift
+import SeamSDK
+import Combine
+
 // Access credentials
 let credentials = Seam.shared.credentials
 
 // Observe updates with Combine
 let credentialsSubscription = Seam.shared.$credentials
     .sink { creds in
-        // Update UI with new credentials array
+        // Update UI with new credentials array.
     }
 ```
 {% endtab %}
@@ -43,30 +46,36 @@ Permission or setup issues appear in each credential’s `errors` property. Obse
 {% tabs %}
 {% tab title="iOS Swift" %}
 ```swift
+import SeamSDK
+import Combine
+
 let errorSubscription = Seam.shared.$credentials
     .flatMap { creds in creds.publisher }
     .map { $0.errors }
     .sink { errors in
-        // Handle errors, e.g. `.userInteractionRequired`, `.expired`, etc.
+        // Handle errors, for example, `.userInteractionRequired`, `.expired`, etc.
     }
 ```
 {% endtab %}
 {% endtabs %}
 
-> **Note:** The `.errors` array on credentials represents per-credential issues though some issues may be repeated across several credentials (e.g. bluetooth requirements). Seam SDK- or credential-level errors (such as invalid token or expired credential) are thrown directly by `unlock(using:)` as `SeamError` and must be handled via `do/catch`.
+> **Note:** The `.errors` array on credentials represents per-credential issues, though some issues may be repeated across several credentials (for example, bluetooth requirements). SDK- or credential-level errors (such as invalid token or expired credential) are thrown directly by methods like `unlock(using:)` because `SeamError` or `SeamCredentialError` and must be handled through `do/catch`.
 
 ## 3. Perform Unlock Operation
 
 The call to `Seam.shared.unlock(using:)` may throw:
-- `SeamError`: for SDK-level issues (e.g., invalid token, uninitialized SDK).
-- `SeamCredentialError`: for credential-specific issues (e.g., expired credential, device not eligible).
-Ensure you wrap the call in `do/catch` to handle these errors.
+- `SeamError`: For SDK-level issues (for example, invalid token, uninitialized SDK).
+- `SeamCredentialError`: For credential-specific issues (for example, expired credential, device not eligible).
+Ensure that you wrap the call in `do/catch` blocks to handle these errors.
 
 Use Async/Await or Combine to initiate an unlock with a selected credential:
 
 {% tabs %}
 {% tab title="iOS Swift" %}
 ```swift
+import SeamSDK
+import Combine
+
 let credentialId = credentials.first!.id
 
 // Async/Await example
@@ -75,14 +84,14 @@ Task {
         for try await event in try Seam.shared.unlock(using: credentialId).values {
             switch event {
             case .grantedAccess:
-                // The lock granted access—show a success indicator.
+                // The lock granted access. Show a success indicator.
             default:
                 print("Unlock event: \(event)")
-                // Access wasn't granted, inform the user and offer retry.
+                // Access wasn't granted. Inform the user and offer retry.
             }
         }
     } catch {
-        // Handle unlock error, e.g., invalid credential or SDK error
+        // Handle unlock error, for example, invalid credential or SDK error
         print("Unlock error: \(error)")
     }
 }
@@ -106,7 +115,7 @@ do {
     )
     // Retain `unlockSubscription`; discarding it will cancel the unlock attempt.
 } catch {
-    // Handle unlock initialization error
+    // Handle unlock initialization error.
     print("Unlock error: \(error)")
 }
 ```
@@ -137,17 +146,17 @@ Task {
         for try await event in Seam.shared.unlock(using: credentialID) {
             switch event {
             case .launched:
-                // Show scanning indicator
+                // Show scanning indicator.
             case .grantedAccess:
-                // Show access granted
+                // Show access granted.
             case .timedOut:
-                // Show timeout and offer retry
+                // Show timeout and offer retry.
             case .connectionFailed(let debugDescription):
-                // Show error with debugDescription
+                // Show error with debugDescription.
             }
         }
     } catch {
-        // Handle thrown errors
+        // Handle thrown errors.
     }
 }
 ```
@@ -176,9 +185,9 @@ do {
                 }           
             }
         )
-    // Retain `unlockSubscription` as a property and cancel when appropriate (e.g., in deinit or viewWillDisappear).
+    // Retain `unlockSubscription` as a property and cancel when appropriate (for example, in deinit or viewWillDisappear).
 } catch {
-    // Handle unlock initialization error
+    // Handle unlock initialization error.
     print("Unlock initialization error: \(error)")
 }
 ```
@@ -195,7 +204,7 @@ Stop scanning by cancelling your subscription or task:
 // For Combine
 unlockSubscription.cancel()
 
-// For Async/Await, cancel the Task as needed
+// For Async/Await, cancel the Task as needed.
 ```
 {% endtab %}
 {% endtabs %}