+.debugbuild/

+.simdebug/

+.simdebug_*/

+.macdebug_*/

+# CloudKit Sync - Visual Reference

+

+## System Architecture Diagram

+

+```

+┌─────────────────────────────────────────────────────────────────────┐

+│                           USB Meter App                             │

+├─────────────────────────────────────────────────────────────────────┤

+│                                                                     │

+│  ┌──────────────────┐         ┌─────────────────────────────────┐  │

+│  │ Meter.swift      │         │ BluetoothManager.swift          │  │

+│  │  (UI + State)    │◄────────│  (BT Communication)            │  │

+│  └────────┬─────────┘         └─────────────────────────────────┘  │

+│           │                                                         │

+│           │ operationalState changes                               │

+│           │ (connect/disconnect)                                   │

+│           ▼                                                         │

+│  ┌────────────────────────────────────────────────────────────┐   │

+│  │           AppData                                          │   │

+│  │  (Global Sync Orchestrator)                               │   │

+│  ├────────────────────────────────────────────────────────────┤   │

+│  │ • publishMeterConnection(mac, type)                       │   │

+│  │ • clearMeterConnection(mac)                               │   │

+│  │ • reloadSettingsFromCloudStore()                          │   │

+│  │ • setupRemoteChangeNotificationObserver()                 │   │

+│  └────────┬──────────────────────────┬──────────────────────┘   │

+│           │                          │                           │

+│           ▼                          ▼                           │

+│  ┌────────────────┐        ┌────────────────────────┐           │

+│  │ CloudDeviceSettings  │        │ NSManagedObjectContext │           │

+│  │ Store                │        │ (viewContext)          │           │

+│  │ (CR operations)      │        └────────────────────────┘           │

+│  └────────┬──────┘                                                │

+│           │                                                        │

+│           ▼                                                        │

+│  ┌─────────────────────────────────────────────────────────┐    │

+│  │   NSPersistentCloudKitContainer                         │    │

+│  │  (Automatic sync layer)                                │    │

+│  ├─────────────────────────────────────────────────────────┤    │

+│  │ • Detects changes                                      │    │

+│  │ • Queues for CloudKit                                  │    │

+│  │ • Receives remote notifications                        │    │

+│  │ • Applies merge policy                                 │    │

+│  └──────────────┬──────────────────────┬────────────────┘    │

+│                │                      │                      │

+└────────────────┼──────────────────────┼──────────────────────┘

+                │                      │

+                ▼                      ▼

+        ┌───────────────────┐  ┌──────────────────────┐

+        │  Local SQLite DB  │  │  Persistent History  │

+        │  (DeviceSettings) │  │  Journal             │

+        └───────────────────┘  └──────────────────────┘

+                │                      │

+                └──────────┬───────────┘

+                           │

+                ┌──────────▼────────────┐

+                │  CloudKit Framework   │

+                │  (Device background   │

+                │   process)            │

+                └──────────┬────────────┘

+                           │

+                    [Network Sync]

+                           │

+                ┌──────────▼────────────┐

+                │   iCloud Servers      │

+                │   CloudKit Database   │

+                └──────────┬────────────┘

+                           │

+                ┌──────────▼──────────────────┐

+                │  Other Devices (iPhone,     │

+                │  iPad, Mac) on same         │

+                │  iCloud account             │

+                └─────────────────────────────┘

+```

+

+---

+

+## Local Write Flow (Sequence Diagram)

+

+```

+Device A              AppData              Core Data          CloudKit

+  │                    │                      │                  │

+  │─ User connects ───►│                      │                  │

+  │ meter              │                      │                  │

+  │                    │─ setConnection() ───►│                  │

+  │                    │ (foreground QoS)     │                  │

+  │                    │                      │                  │

+  │◄─ UI Updates      │◄─ @Published change  │                  │

+  │ (local)            │   (immediate)        │                  │

+  │                    │                      │                  │

+  │                    │─ context.save() ────►│                  │

+  │                    │                      │                  │

+  │                    │                      │─ Detect change   │

+  │                    │                      │─ Create CKRecord │

+  │                    │                      │─ Queue for sync ─►│

+  │                    │                      │                  │─ Network upload

+  │                    │                      │                  │ (1-2s)

+  │                    │                      │                  │

+  ┼────────────────────┼──────────────────────┼──────────────────┼───► [iCloud Server]

+  │                    │                      │                  │

+  │    (Device B receives remote change notification after ~5s)   │

+```

+

+---

+

+## Remote Change Reception (Sequence Diagram)

+

+```

+Device B           System iOS            Core Data          AppData

+  │                  │                      │                  │

+  │               [iCloud notifies]         │                  │

+  │                  │                      │                  │

+  │                  │─ Remote change ─────►│                  │

+  │                  │ notification posted  │                  │

+  │                  │                      │                  │

+  │                  │                      │─ Merge changes   │

+  │                  │                      │ (merge policy)  │

+  │                  │                      │─ Save locally   │

+  │                  │                      │                  │

+  │                  │─ NSPersistentStore ─►│─ remoteStoreDidChange()

+  │                  │  RemoteChange        │                  │

+  │                  │  notification        │                  │

+  │                  │                      │                  │

+  │                  │                      │◄─ reloadSettings()

+  │                  │                      │ FromCloudStore()

+  │◄─ UI updates ◄───────────────────────────────────────────────

+  │ "Connected on                           │

+  │  Device A"                              │

+```

+

+---

+

+## Connection Lock Lifecycle

+

+```

+t=0s:  Device A connects

+       ┌─────────────────────────────────────┐

+       │ connectedByDeviceID = UUID_A        │

+       │ connectedByDeviceName = "iPhone A"  │

+       │ connectedAt = 2025-03-26 10:00:00   │

+       │ connectedExpiryAt = 10:02:00        │ ◄─ TTL = 120s

+       └─────────────────────────────────────┘

+                │

+                │ [CloudKit syncs]

+                ▼

+       [Device B sees connection]

+       "Meter locked by iPhone A"

+

+t=60s: Device A still connected

+       (TTL still valid)

+

+t=120s: Connection expires

+       ┌─────────────────────────────────────┐

+       │ connectedExpiryAt = 10:02:00         │

+       │ now() > connectedExpiryAt ✓          │

+       └─────────────────────────────────────┘

+                │

+       [Device B checks expiry]

+                │

+       if (now > connectedExpiryAt)

+           Device B can connect!

+```

+

+---

+

+## Merge Conflict Resolution

+

+```

+Device A                          Device B

+t=0.5s: Sets meterName           t=0.6s: Sets meterName

+  "Kitchen Meter"                  "Charger Meter"

+  │                                │

+  ▼                                ▼

+  Save & Queue                     Save & Queue

+  │                                │

+  └───────────┬────────────────────┘

+              ▼

+        [Both pushed to CloudKit]

+        (Race condition)

+

+CloudKit Merge Policy:

+  NSMergeByPropertyStoreTrumpMergePolicy

+  → Latest write wins

+

+Result on both devices:

+  ✗ One value reverts (~1s after cloud update)

+  ✓ No data loss, eventually consistent

+```

+

+---

+

+## Rebuild Flow (v2 → v3)

+

+```

+User launches app (v3)

+  │

+  ▼

+AppDelegate.didFinishLaunchingWithOptions

+  │

+  ▼

+rebuildCanonicalStoreIfNeeded(version: 3)

+  │

+  ├─ Check UserDefaults["cloudStoreRebuildVersion.3"]

+  │

+  ├─ if already done:

+  │   return (skip)

+  │

+  └─ if not done:

+      │

+      ├─ Fetch all DeviceSettings records

+      │

+      ├─ Group by normalized macAddress

+      │

+      ├─ For each group:

+      │   ├─ Find "winner" (most data + most recent)

+      │   └─ Merge others INTO winner

+      │   └─ Delete duplicates

+      │

+      ├─ context.save()

+      │   (CloudKit propagates deletes)

+      │

+      ├─ UserDefaults["cloudStoreRebuildVersion.3"] = true

+      │

+      └─ ✓ Done (won't run again)

+```

+

+---

+

+## State Machine: Meter Connection

+

+```

+┌─────────────────┐

+│     OFFLINE     │  ◄──────────────────────────────┐

+└────────┬────────┘                                 │

+         │                                          │

+    advertisment heard

+         │

+         ▼

+┌─────────────────────────────┐

+│   PERIPHERAL_NOT_CONNECTED  │

+└────────┬────────────────────┘

+         │

+    user clicks "Connect"

+    Meter.connect() called

+         │

+         ▼

+┌─────────────────────────────┐

+│  PERIPHERAL_CONNECTION_PD   │

+└────────┬────────────────────┘

+         │

+    BT services discovered

+         │

+         ▼

+┌─────────────────────────────┐

+│   PERIPHERAL_CONNECTED      │

+│   (appData.publishMeterConn)│  ◄─────── CloudKit SyncStart

+└────────┬────────────────────┘

+         │

+    peripheral ready for commands

+         │

+         ▼

+┌─────────────────────────────┐

+│   PERIPHERAL_READY          │

+└────────┬────────────────────┘

+         │

+    data request sent

+         │

+         ▼

+┌─────────────────────────────┐

+│   COMMUNICATING             │

+└────────┬────────────────────┘

+         │

+    data received

+         │

+         ▼

+┌─────────────────────────────┐

+│   DATA_IS_AVAILABLE         │ ──────── Cloud Polling Loop

+└─────────────────────────────┘           (every 60s renew connection)

+         │

+    connect lost / timeout

+         │

+         ▼ (Or clear in UI)

+    OFFLINE again

+```

+

+---

+

+## Connection Renewal (Heartbeat)

+

+```

+┌─────────────────────────────┐

+│ Meter.connect() called      │

+│ operationalState changed    │

+│ → .peripheralConnected      │

+└──────────┬──────────────────┘

+           │

+           ▼

+       startConnectionRenewal()

+           │

+           ├─ Create timer: interval = 60s

+           │

+           └─ repeats every 60s:

+              │

+              ├─ appData.publishMeterConnection()

+              │  (updates connectedAt + connectedExpiryAt)

+              │

+              └─ CloudKit syncs (keeps lock alive)

+

+Disconnection:

+┌─────────────────────────────┐

+│ operationalState changed    │

+│ → .offline / .notConnected  │

+└──────────┬──────────────────┘

+           │

+           ▼

+       stopConnectionRenewal()

+           │

+           ├─ connectionRenewalTimer.invalidate()

+           │

+           └─ appData.clearMeterConnection()

+              (removes connectedByDeviceID)

+              │

+              └─ CloudKit syncs (lock released)

+```

+

+---

+

+## Error Recovery Paths

+

+```

+┌─────────────────────┐

+│ Normal Operation    │

+└─────────────────────┘

+         │

+         ▼ [Error: CloudKit unavailable]

+┌──────────────────────────────┐

+│ Queue changes locally         │

+│ (stored in SQLite)           │

+└──────────────────────────────┘

+         │

+         ▼ [Network restored]

+┌──────────────────────────────┐

+│ NSPersistentCloudKit         │

+│ resumes sync automatically    │

+└──────────────────────────────┘

+         │

+         ▼

+┌─────────────────────┐

+│ Back to normal      │

+└─────────────────────┘

+

+┌─────────────────────┐

+│ Collision detected  │ (Device A & B both edited same field)

+└─────────────────────┘

+         │

+         ▼

+┌──────────────────────────────┐

+│ NSMergeByPropertyStoreTrump   │

+│ (CloudKit version wins)       │

+└──────────────────────────────┘

+         │

+         └─ User sees local change revert ~1s after

+              cloud update arrives (rare, acceptable)

+```

+

+# CloudKit Sync Mechanism

+

+## Architecture Overview

+

+```

+┌──────────────────────────────────────────────────────────────┐

+│                        App Layer                            │

+│  Meter.swift (UI)  ←→  BluetoothManager.swift (BT comms)  │

+└───────────┬────────────────────────────┬────────────────────┘

+            │                            │

+            └───────────┬────────────────┘

+                        │

+              ┌─────────▼──────────┐

+              │ AppData.swift      │

+              │  (Orchestrator)    │

+              └──────────┬─────────┘

+                         │

+        ┌────────────────┼────────────────┐

+        │                │                │

+   ┌────▼─────┐   ┌─────▼──────┐   ┌────▼──────────┐

+   │ CloudDeviceSettingsStore   │   │ Bluetooth    │

+   │ (Core Data Layer)          │   │ Persistence  │

+   └────┬─────┘                 │   └──────────────┘

+        │                       │

+   ┌────▼────────────────────────────┐

+   │ NSManagedObjectContext           │

+   │ (viewContext)                    │

+   └────┬─────────────────────────────┘

+        │

+   ┌────▼──────────────────────────────────────────┐

+   │ NSPersistentCloudKitContainer                  │

+   │ - Automatic bi-directional sync               │

+   │ - Handles conflicts via merge policy          │

+   │ - Remote change notifications                │

+   └────┬─────────────────────┬────────────────────┘

+        │                     │

+   ┌────▼──────┐    ┌────────▼─────────────────┐

+   │ Local DB  │    │ CloudKit Framework       │

+   │ SQLite    │    │ - Push notifications     │

+   │           │    │ - Persistent history    │

+   └───────────┘    └────────┬──────────────────┘

+                             │

+                        ┌────▼────────────┐

+                        │ iCloud Server   │

+                        │ CloudKit DB     │

+                        └────┬────────────┘

+                             │

+                        (Sync'd to other devices)

+```

+

+---

+

+## Sync Flow - Step by Step

+

+### Local Write Flow

+

+```

+1. User Action (connect meter)

+   │

+2. Meter.swift → operationalState.didSet

+   │

+3. appData.publishMeterConnection(mac: String, modelType: String)

+   │

+4. CloudDeviceSettingsStore.setConnection(macAddress:, modelType:)

+   │

+   ├─ Fetch existing DeviceSettings for macAddress

+   │  • If nil: create new NSManagedObject

+   │  • If exists: update it

+   │

+5. Update attributes:

+   │  • connectedByDeviceID = UIDevice.current.identifierForVendor

+   │  • connectedByDeviceName = UIDevice.current.name

+   │  • connectedAt = Date()

+   │  • connectedExpiryAt = Date.now + 120 seconds

+   │  • updatedAt = Date()

+   │

+6. appData.persistentContainer.viewContext.save()

+   │

+7. NSPersistentCloudKitContainer intercepts save:

+   │  • Detects changes to DeviceSettings entity

+   │  • Serializes to CKRecord ("DeviceSettings/[macAddress]")

+   │

+8. CloudKit framework:

+   │  • Queues for upload (background)

+   │  • Sends to iCloud servers

+   │

+9. Remote device:

+   │  • Receives NSPersistentStoreRemoteChangeNotification

+   │  • Automatically merges into local Core Data

+   │  • AppData detects change → reloadSettingsFromCloudStore()

+   │  • UI updates via @Published updates

+```

+

+---

+

+### Receiving Remote Changes

+

+```

+1. iCloud Server discovers change

+   │

+2. Sends data to Device B via CloudKit

+   │

+3. iOS system fires:

+   NSPersistentStoreRemoteChangeNotificationPostOptionKey

+   │

+4. AppData.setupRemoteChangeNotificationObserver():

+   @objc private func remoteStoreDidChange() {

+     // This runs on background thread!

+     reloadSettingsFromCloudStore()

+   }

+   │

+5. reloadSettingsFromCloudStore() fetches fresh data:

+   │

+   ├─ cloudStore.fetch(for: macAddress) [async per-device]

+   │

+6. Updates local @Published properties

+   │  → triggers UI re-render in SwiftUI

+   │

+7. Meter.swift observes changes:

+   │  → updates connection state badges

+   │  → shows "Connected on [Device Name]" etc.

+```

+

+---

+

+## AppData: Core Sync Methods

+

+### Device Name Handling (AppData.myDeviceName)

+

+```swift

+static let myDeviceName: String = Self.getDeviceName()

+

+private static func getDeviceName() -> String {

+    #if os(macOS)

+    // On macOS (Catalyst, iPad App on Mac), use hostname

+    let hostname = ProcessInfo.processInfo.hostName

+    return hostname.trimmingCharacters(in: .whitespacesAndNewlines)

+    #else

+    // On iOS/iPadOS, use device name

+    return UIDevice.current.name.trimmingCharacters(in: .whitespacesAndNewlines)

+    #endif

+}

+```

+

+**Why:** `UIDevice.current.name` returns "iPad" on macOS, which is wrong. Using `hostname` gives correct names like "MacBook-Pro.local" or "iMac.local".

+

+### `persistentContainer` (AppDelegate.swift)

+

+```swift

+lazy var persistentContainer: NSPersistentCloudKitContainer = {

+    let container = NSPersistentCloudKitContainer(name: "CKModel")

+    if let description = container.persistentStoreDescriptions.first {

+        description.cloudKitContainerOptions =

+            NSPersistentCloudKitContainerOptions(

+                containerIdentifier: "iCloud.ro.xdev.USB-Meter"

+            )

+        // Enable historical tracking for conflict resolution

+        description.setOption(true as NSNumber, forKey: NSPersistentHistoryTrackingKey)

+        // Enable remote change notifications

+        description.setOption(true as NSNumber, forKey: NSPersistentStoreRemoteChangeNotificationPostOptionKey)

+    }

+    container.viewContext.automaticallyMergesChangesFromParent = true

+    container.viewContext.mergePolicy = NSMergeByPropertyStoreTrumpMergePolicy

+    return container

+}()

+```

+

+**Key configs:**

+- `automaticallyMergesChangesFromParent = true`: Auto-merge CloudKit changes without explicit fetch

+- `NSMergeByPropertyStoreTrumpMergePolicy`: CloudKit always wins on property conflicts

+

+### `activateCloudDeviceSync` (SceneDelegate.swift)

+

+```swift

+appData.activateCloudDeviceSync(context: appDelegate.persistentContainer.viewContext)

+```

+

+**Does:**

+1. Sets up remote change observers

+2. Triggers first `reloadSettingsFromCloudStore()` to load persisted CloudKit data

+3. Starts polling for connection expiry checks

+

+### `publishMeterConnection` (AppData.swift)

+

+```swift

+public func publishMeterConnection(macAddress: String, modelType: String) {

+    DispatchQueue.global(qos: .userInitiated).async { [weak self] in

+        self?.cloudStore.setConnection(macAddress: macAddress, modelType: modelType)

+    }

+}

+```

+

+**Called from:** `Meter.swift` when `operationalState` changes to `.peripheralConnected`

+

+### `clearMeterConnection` (AppData.swift)

+

+```swift

+public func clearMeterConnection(macAddress: String) {

+    DispatchQueue.global(qos: .userInitiated).async { [weak self] in

+        self?.cloudStore.clearConnection(macAddress: macAddress)

+    }

+}

+```

+

+**Called from:** `Meter.swift` when `operationalState` → `.offline` / `.peripheralNotConnected`

+

+### `reloadSettingsFromCloudStore` (AppData.swift)

+

+```swift

+private func reloadSettingsFromCloudStore() {

+    // Fetch all DeviceSettings records

+    // Update internal @Published state

+    // Publish changes via objectWillChange

+}

+```

+

+**Called from:**

+- `activateCloudDeviceSync` (initial load)

+- Remote change notification handler (when CloudKit syncs changes)

+- Periodic check for connection expiry

+

+---

+

+## CloudDeviceSettingsStore: Private Implementation

+

+```swift

+private class CloudDeviceSettingsStore {

+    let context: NSManagedObjectContext

+    let entityName = "DeviceSettings"

+

+    func setConnection(macAddress: String, modelType: String) {

+        context.performAndWait {

+            // 1. Normalize MAC

+            let mac = normalizedMACAddress(macAddress)

+

+            // 2. Fetch or create

+            let request = NSFetchRequest<NSManagedObject>(entityName: entityName)

+            request.predicate = NSPredicate(format: "macAddress == %@", mac)

+            var object = try? context.fetch(request).first

+            if object == nil {

+                object = NSManagedObject(entity: ..., insertInto: context)

+            }

+

+            // 3. Update connection metadata

+            object?.setValue(mac, forKey: "macAddress")

+            object?.setValue(modelType, forKey: "modelType")

+            object?.setValue(UIDevice.current.identifierForVendor?.uuidString, forKey: "connectedByDeviceID")

+            object?.setValue(UIDevice.current.name, forKey: "connectedByDeviceName")

+            object?.setValue(Date(), forKey: "connectedAt")

+            object?.setValue(Date().addingTimeInterval(120), forKey: "connectedExpiryAt")

+            object?.setValue(Date(), forKey: "updatedAt")

+

+            // 4. Save → triggers CloudKit sync

+            try? context.save()

+        }

+    }

+

+    func fetch(for macAddress: String) -> DeviceSettingsRecord? {

+        // Similar to setConnection, but returns data only

+    }

+}

+```

+

+---

+

+## Connection Lifecycle

+

+```

+Device A Connects                Expiry Timer Started

+    │                                    │

+    ▼                                    ▼

+┌─────────────────────────┐    ┌──────────────────┐

+│ DeviceSettings created  │    │  120 seconds     │

+│ connectedAt = now       │    │  (hardcoded TTL) │

+│ connectedExpiryAt=now+2m│◄───┴──────────────────┘

+└─────────────────────────┘

+    │

+    │ [CloudKit syncs]

+    │

+    ▼

+Device B detects via notification:

+  connectedByDeviceID ≠ my device → "Locked by Device A"

+

+After 120 seconds:

+  if (now > connectedExpiryAt) {

+    // Lock expired

+    // Device B can attempt new connection

+  }

+```

+

+---

+

+## Error Handling & Recovery

+

+### Scenario: CloudKit Unavailable

+- App detects no iCloud account → operations on viewContext proceed locally

+- Changes queue locally

+- When CloudKit available → sync resumes automatically

+

+### Scenario: Duplicate Records (Pre-v3)

+- `rebuildCanonicalStoreIfNeeded(version: 3)` runs at app launch

+- Detects and merges duplicates in-place

+- Marks as done in UserDefaults

+

+### Scenario: Sync Conflicts

+- Example: Device A and B both update `meterName` simultaneously

+- `NSMergeByPropertyStoreTrumpMergePolicy` applies: **latest CloudKit wins**

+- User may see their local change revert briefly (acceptable UX for rare case)

+

+---

+

+## Performance Considerations

+

+| Operation | Thread | Frequency | Impact |

+|-----------|--------|-----------|--------|

+| `setConnection()` | Background (global QoS) | Per meter connection | Minimal (~5-10ms) |

+| `reloadSettingsFromCloudStore()` | Main (UI updates) | On remote change + periodic | ~50-100ms for <10 meters |

+| `rebuildCanonicalStoreIfNeeded()` | Main (view context) | Once per app version | ~200ms (one-time) |

+| CloudKit sync (background) | System | Continuous | Battery: negligible |

+

+---

+

+## Testing Checklist

+

+- [ ] Connect meter on Device A, verify "Connected on A" badge on Device B within 5s

+- [ ] Disconnect on A, verify badge clears on B

+- [ ] Rename meter on A, verify name updates on B

+- [ ] Set TC66 temp unit on A, verify syncs to B

+- [ ] Airplane mode on A → CloudKit queues changes → reconnect → syncs ✓

+- [ ] Delete app data on A, reinstall → rebuilds from CloudKit ✓

+- [ ] Simulated multi-device conflict (manual Core Data edit) → resolves via merge policy ✓

+# CloudKit Sync Documentation

+

+Complete reference for USB Meter's multi-device synchronization system using CloudKit.

+

+---

+

+## Quick Start

+

+**Problem:** How do settings sync across my iPhone, iPad, and Mac?

+

+**Answer:**

+1. When you connect a meter on iPhone → `Meter.swift` calls `appData.publishMeterConnection()`

+2. This updates a **DeviceSettings** record in Core Data

+3. `NSPersistentCloudKitContainer` automatically syncs it to iCloud

+4. Your iPad + Mac receive a notification → refresh UI

+5. Within 2-5 seconds, all devices show "Connected on iPhone"

+

+---

+

+## Documentation Files

+

+### 1. **SCHEMA.md** — Data Model & Structure

+- DeviceSettings entity attributes

+- CloudKit record mapping

+- Why `uniquenessConstraint` was removed

+- Version history (v1 → v2 → v3)

+

+**Read this if:** You need to understand the data structure, add fields, or debug data corruption.

+

+### 2. **MECHANISM.md** — How Sync Works

+- Complete architecture diagram

+- Step-by-step local write flow

+- Remote change reception flow

+- Core AppData methods explained

+- Connection lifecycle (TTL, expiry, locking)

+- Error handling & recovery

+

+**Read this if:** You're troubleshooting sync issues, understanding threading, or extending functionality.

+

+### 3. **TROUBLESHOOTING.md** — Debugging Guide

+- Configuration verification checklist

+- Common issues & fixes

+- Real-time monitoring code

+- Performance benchmarks

+- Log analysis

+

+**Read this if:** Sync isn't working, you want to add debug UI, or need production troubleshooting.

+

+---

+

+## Key Concepts

+

+### DeviceSettings Record

+Represents a single Bluetooth meter device with its metadata:

+

+```

+macAddress: "aa:bb:cc:dd:ee:ff"  ← identifies the meter

+meterName: "Kitchen Meter"        ← user-friendly name

+modelType: "TC66C"                ← hardware type

+connectedByDeviceID: "UUID"       ← which device is using it now

+connectedExpiryAt: Date           ← connection lock TTL (120s)

+updatedAt: Date                   ← last sync timestamp

+```

+

+### Sync Heartbeat

+- **Connect:** `publishMeterConnection()` → saves record → syncs

+- **Disconnect:** `clearMeterConnection()` → clears record → syncs

+- **Refresh:** Periodically calls `reloadSettingsFromCloudStore()` to check for remote changes

+

+### Conflict Resolution

+If Device A and B edit the same record simultaneously:

+- **Policy:** `NSMergeByPropertyStoreTrumpMergePolicy`

+- **Rule:** CloudKit's version always wins

+- **Edge case:** User might see their local change revert (~1s after)

+

+---

+

+## Architecture Summary

+

+```

+Meter UI ──→ BT Connection ──→ AppData ──→ CloudDeviceSettingsStore ──→ Core Data

+                                  ↓                ↓

+                          [CloudKit Sync]   [persisted locally]

+                                  ↓

+                          [iCloud Servers]

+                                  ↓

+                          Other Devices ──→ UI Updates

+```

+

+---

+

+## Critical Files in Codebase

+

+| File | Role |

+|------|------|

+| `AppDelegate.swift` | Creates `NSPersistentCloudKitContainer` (line 85-127) |

+| `SceneDelegate.swift` | Calls `activateCloudDeviceSync()` at startup |

+| `AppData.swift` | Orchestrates sync: `publishMeterConnection`, `clearMeterConnection`, `reloadSettingsFromCloudStore` |

+| `Meter.swift` | Line 109, 118, 132: Calls `appData` methods on state changes |

+| `CKModel.xcdatamodeld/USB_Meter 2.xcdatamodel/contents` | Core Data schema (no uniqueness constraint) |

+| `USB Meter.entitlements` | iCloud container + CloudKit permissions |

+

+---

+

+## Debugging Checklist

+

+- [ ] CloudKit account status = `.available`?

+- [ ] Entitlements file includes `iCloud.ro.xdev.USB-Meter`?

+- [ ] Model version is `USB_Meter 2.xcdatamodel` or later?

+- [ ] `cloudStoreRebuildVersion` ≥ 3?

+- [ ] Remote change observer registered in `setupRemoteChangeNotificationObserver()`?

+- [ ] Merge policy = `NSMergeByPropertyStoreTrumpMergePolicy`?

+

+---

+

+## Common Workflows

+

+### "Settings won't sync to my other device"

+1. Check CloudKit account (TROUBLESHOOTING.md § 1)

+2. Verify entitlements (TROUBLESHOOTING.md § 2)

+3. Force reload: `appData.reloadSettingsFromCloudStore()`

+4. Check logs for `NSPersistentStoreRemoteChange` notifications

+

+### "I see duplicate meter entries"

+1. Verify `cloudStoreRebuildVersion = 3` deployed

+2. Check `rebuildCanonicalStoreIfNeeded` ran (UserDefaults `cloudStoreRebuildVersion.3`)

+3. If duplicates persist, see TROUBLESHOOTING.md § Issue 2

+

+### "Connection lock doesn't expire"

+1. Check system clock on Device A (ParentalControls?)

+2. Manual unlock: `appData.clearMeterConnection(mac: "...")`

+3. Verify TTL is 120s in `setConnection()`

+

+### "I need to add a new sync field"

+1. Edit `USB_Meter 2.xcdatamodel/contents` → add attribute (optional!)

+2. Bump Core Data version if needed (lightweight migration)

+3. Update `CloudDeviceSettingsStore` to populate it

+4. Sync resumes automatically

+

+---

+

+## Performance

+

+- **Local write latency:** ~10ms

+- **CloudKit network push:** ~1-2s (typical)

+- **Remote notification delivery:** ~2-5s

+- **UI update after notification:** <100ms

+- **Full reload (10 records):** ~50ms

+

+Total end-to-end for a setting change: **~5-8 seconds** (typical, good network)

+

+---

+

+## Testing Tips

+

+Use two devices on same iCloud account:

+

+1. **Connect meter on iPhone** → Check iPad within 5s for "Connected on iPhone"

+2. **Rename meter on iPhone** → Name updates on iPad instantly (local) after sync

+3. **Airplane mode iPhone** → Changes queue locally

+4. **Reconnect iPhone** → Changes resync automatically

+5. **Switch iCloud accounts** → No data loss (encrypted in CloudKit)

+

+---

+

+## References

+

+- [NSPersistentCloudKitContainer docs](https://developer.apple.com/documentation/coredata/nspersistentcloudkitcontainer)

+- [CloudKit best practices](https://developer.apple.com/documentation/cloudkit/best_practices)

+- [Core Data concurrency](https://developer.apple.com/documentation/coredata/concurrency)

+- [Merging edited Core Data objects](https://developer.apple.com/documentation/coredata/nsmergepolicy)

+

+---

+

+## Questions?

+

+Refer to specific sections above by file, or check the troubleshooting checklist in TROUBLESHOOTING.md.

+# CloudKit Sync Schema

+

+## Overview

+USB Meter utilizează `NSPersistentCloudKitContainer` pentru a sincroniza setările dispozitivelor Bluetooth pe mai multe device-uri iOS/iPadOS via iCloud CloudKit.

+

+**Container CloudKit:** `iCloud.ro.xdev.USB-Meter`

+

+---

+

+## Core Data Entity: DeviceSettings

+

+### Purpose

+Stocare centralizată a setărilor și metadatelor de conexiune pentru fiecare contor Bluetooth, cu sincronizare automată pe toate device-urile utilizatorului.

+

+### Device Name Source

+- **iOS/iPadOS:** `UIDevice.current.name` (ex: "Bogdan's iPhone")

+- **macOS (Catalyst, iPad App on Mac):** `ProcessInfo.processInfo.hostName` (ex: "MacBook-Pro.local")

+  - Rationale: `UIDevice.current.name` returnează "iPad" pe macOS, care e incorect

+

+### Attributes

+

+| Atribut | Tip | Optional | Descriere |

+|---------|-----|----------|-----------|

+| **macAddress** | String | YES | Adresa MAC unică a contorului BT (cheie candidat pentru deduplicare) |

+| **meterName** | String | YES | Renumire personalizată a contorului (ex: "Kitchen Meter") |

+| **tc66TemperatureUnit** | String | YES | Preferință unitate temperatură pentru TC66C (raw value enum: "celsius"/"fahrenheit") |

+| **modelType** | String | YES | Tip model contor ("UM25C", "UM34C", "TC66C") |

+| **connectedByDeviceID** | String | YES | UUID-ul device-ului iOS care l-a conectat ultima dată |

+| **connectedByDeviceName** | String | YES | Numele device-ului iOS care l-a conectat |

+| **connectedAt** | Date | YES | Timestamp al celei mai recente conexiuni |

+| **connectedExpiryAt** | Date | YES | TTL pentru lock-ul de conexiune (alt device poate prelua dacă a expirat) |

+| **lastSeenAt** | Date | YES | Timestamp al ultimei avertisment BT din device |

+| **lastSeenByDeviceID** | String | YES | UUID device-ul iOS care l-a văzut ultima dată |

+| **lastSeenByDeviceName** | String | YES | Nume device-ul iOS care l-a văzut |

+| **lastSeenPeripheralName** | String | YES | Numele periferalei așa cum raporta dispozitivul |

+| **updatedAt** | Date | YES | Timestamp al ultimei actualizări (audit trail) |

+

+### CloudKit Mapping

+Fiecare atribut Core Data → câmp CloudKit în record-ul `DeviceSettings`:

+- Sincronizare automată bidirecțională

+- Lightweight migration pentru schimbări de schemă

+- Conflict resolution: **NSMergeByPropertyStoreTrumpMergePolicy** (CloudKit wins pe changed properties)

+

+---

+

+## Constraints

+

+### ❌ **NOT** Used (v1 - v2):

+- `uniquenessConstraint` pe `macAddress` — **incompatibil cu NSPersistentCloudKitContainer** (genereaza erori silentioase)

+

+### ✅ Applied:

+- **Logical deduplication** per macAddress în `rebuildCanonicalStoreIfNeeded`

+  - Ruleaza o dată pe device (verifică `UserDefaults` cu key `"cloudStoreRebuildVersion.{n}"`)

+  - Merges conflicting records pe baza timestamp-urilor

+

+---

+

+## Data Flow

+

+```

+┌─────────────────────────────────────────────────────────────────┐

+│                      Device A (iPhone)                          │

+├─────────────────────────────────────────────────────────────────┤

+│  User connects UM25C (MAC: aa:bb:cc:dd:ee:ff)                  │

+│         ↓                                                        │

+│  Meter.swift → appData.publishMeterConnection(mac, type)       │

+│         ↓                                                        │

+│  CloudDeviceSettingsStore.setConnection()                      │

+│    - Creates / Updates DeviceSettings record                   │

+│    - Sets connectedByDeviceID = Device A UUID                 │

+│    - connectedAt = now                                         │

+│    - connectedExpiryAt = now + 120s                           │

+│         ↓                                                        │

+│  NSPersistentCloudKitContainer saves to Core Data              │

+│         ↓                                                        │

+│  CloudKit framework (automatic sync):                          │

+│    - Pushes record modificare → iCloud server                  │

+│    - Records: [CKRecord with RecordID "DeviceSettings/mac"]   │

+│         ↓                                                        │

+│  iCloud Server → Device B (iPad)                               │

+│         ↓                                                        │

+│  Device B receives remote change notification                  │

+│  (NSPersistentStoreRemoteChangeNotificationPostOptionKey)      │

+│         ↓                                                        │

+│  AppData.reloadSettingsFromCloudStore()                        │

+│    - Fetches updated record din local Core Data                │

+│    - Sees connectedByDeviceID = Device A UUID                 │

+│    - Checks connectedExpiryAt (not expired)                   │

+│    - Knows someone else is connected                          │

+│         ↓                                                        │

+│  UI updates: shows "Connected on iPhone"                       │

+└─────────────────────────────────────────────────────────────────┘

+```

+

+---

+

+## Conflict Resolution Scenarios

+

+### Scenario 1: Simultaneous Connection Attempt

+**Device A** și **Device B** conectează același contor ~același timp.

+

+```

+Device A:                          Device B:

+t=0.0s: setConnection()           t=0.1s: setConnection()

+  - connectedByDeviceID = A         - connectedByDeviceID = B

+  - connectedAt = 0.0s              - connectedAt = 0.1s

+       ↓ save                             ↓ save

+  CloudKit pushes A's record    CloudKit pushes B's record

+       ↓                              ↓

+       └──────→ iCloud Server ←──────┘

+               (concurrent writes)

+

+Merge Strategy:

+  - NSMergeByPropertyStoreTrumpMergePolicy

+  - Latest CloudKit record "wins" per property

+  - Result: B's connectedByDeviceID + connectedAt win

+    (mai recent timestamp)

+```

+

+### Scenario 2: Reconnection After Expiry

+**Device A** conectează la t=0. Expiry la t=120. **Device B** incearcă conexiune la t=150.

+

+```

+t=0s:   Device A connects (connectedAt=0, expiry=120)

+t=120s: Connection expires

+t=150s: Device B checks:

+        if (connectedExpiryAt < now):

+          // Lock expired, can connect

+        setConnection() → Device B becomes new owner

+```

+

+---

+

+## Deduplication Logic (v3+)

+

+Rulează la `AppDelegate.didFinishLaunchingWithOptions`:

+

+```swift

+rebuildCanonicalStoreIfNeeded(version: 3)

+  1. Fetch ALL DeviceSettings records

+  2. Group by normalized macAddress

+  3. Per group:

+     - Select "winner" (prefer: more recent updatedAt, more data fields populated)

+     - Merge other records INTO winner

+     - Delete duplicates (only delete-uri, no inserts)

+  4. Save context → CloudKit deletes propagate

+  5. Mark in UserDefaults as "done for v3"

+```

+

+**De ce in-place?** Pentru a nu cauza "delete storm":

+- ❌ Old way: Delete ALL + Insert ALL → alt device primește DELETE-uri înainte de INSERT-uri → pierde date

+- ✅ New way: Update IN-PLACE + Delete only duplicates → record ID-ul DeviceSettings este păstrat → sincronizare progresivă

+

+---

+

+## Version History

+

+| Model | Version | Changes |

+|-------|---------|---------|

+| USB_Meter.xcdatamodel | 1 | Original schema cu `uniquenessConstraint` |

+| USB_Meter 2.xcdatamodel | 2 | ❌ Removed constraint (but rebuild was destructive) |

+| USB_Meter 2.xcdatamodel | 3 | ✅ Rebuilt with in-place merge strategy |

+

+Migration path:

+```

+v1 → v2 (lightweight, auto) → v3 (rebuild in-place, UserDefaults gated)

+```

+# CloudKit Sync - Troubleshooting & Debugging

+

+## Debugging Checklist

+

+### 1. Verify CloudKit Account Status

+```swift

+// In AppDelegate

+private func logCloudKitStatus() {

+    let container = CKContainer(identifier: "iCloud.ro.xdev.USB-Meter")

+    container.accountStatus { status, error in

+        if let error {

+            print("CloudKit error: \(error.localizedDescription)")

+            return

+        }

+        switch status {

+        case .available:

+            print("✅ CloudKit available")

+        case .noAccount:

+            print("❌ No iCloud account")

+        case .restricted:

+            print("❌ CloudKit restricted (parental controls?)")

+        case .couldNotDetermine:

+            print("❌ Status unknown")

+        case .temporarilyUnavailable:

+            print("⚠️ CloudKit temporarily unavailable")

+        @unknown default:

+            print("⚠️ Unknown status")

+        }

+    }

+}

+```

+

+**Expected:** `.available` or changes won't sync

+

+---

+

+### 2. Check Entitlements

+Verify `USB Meter.entitlements` has:

+

+```xml

+<key>com.apple.developer.icloud-container-identifiers</key>

+<array>

+    <string>iCloud.ro.xdev.USB-Meter</string>

+</array>

+<key>com.apple.developer.icloud-services</key>

+<array>

+    <string>CloudKit</string>

+</array>

+<key>com.apple.developer.ubiquity-container-identifiers</key>

+<array>

+    <string>iCloud.ro.xdev.USB-Meter</string>

+</array>

+```

+

+If missing:

+- ❌ App can't access CloudKit

+- ❌ No sync errors in logs (silent failure)

+

+---

+

+### 3. Monitor Sync Logs

+

+Enable enhanced Core Data debugging:

+

+**In Xcode scheme editor:**

+1. Select scheme → Edit Scheme → Run → Arguments

+2. Add Launch Arguments:

+   ```

+   -com.apple.CoreData.SQLDebug 1

+   -com.apple.CoreData.ConcurrencyDebug 1

+   ```

+

+**In terminal:**

+```bash

+# Follow app logs

+log stream --predicate 'process == "USB Meter"' --level debug

+```

+

+**Look for:**

+- `NSPersistentCloudKitContainer` initialization messages

+- `cloudkit:` messages (sync operations)

+- `CoreData:` messages (database operations)

+

+---

+

+### 4. Check Persistent Store Description

+

+```swift

+// In AppDelegate.persistentContainer

+if let description = container.persistentStoreDescriptions.first {

+    print("Store URL: \(description.url?.path ?? "nil")")

+    print("Options: \(description.options ?? [:])")

+    print("CloudKit container: \(description.cloudKitContainerOptions?.containerIdentifier ?? "nil")")

+}

+```

+

+**Expected:**

+- URL should point to `.../Library/Application Support/CKModel.sqlite`

+- CloudKit container identifier must match entitlements

+

+---

+

+### 5. Verify Remote Notifications Are Set Up

+

+```swift

+// In AppData

+private func setupRemoteChangeNotificationObserver() {

+    NotificationCenter.default.addObserver(

+        self,

+        selector: #selector(remoteStoreDidChange),

+        name: .NSPersistentStoreRemoteChange,

+        object: nil

+    )

+    print("✅ Remote change observer registered")

+}

+

+@objc private func remoteStoreDidChange() {

+    print("🔄 Remote CloudKit change received")

+    DispatchQueue.main.async {

+        self.reloadSettingsFromCloudStore()

+    }

+}

+```

+

+**Problem:** If `reloadSettingsFromCloudStore` is never called, check if observer is registered

+

+---

+

+## Common Issues & Fixes

+

+### Issue 1: "Changes not syncing to other devices"

+

+**Diagnosis:**

+```swift

+// Check if save succeeded

+do {

+    try appData.persistentContainer.viewContext.save()

+    print("✅ Save successful")

+} catch {

+    print("❌ Save failed: \(error)")

+}

+

+// Check if DeviceSettings record exists

+let request = NSFetchRequest<NSFetchRequestExpression>(entityName: "DeviceSettings")

+let count = try? appData.persistentContainer.viewContext.count(for: request)

+print("Records in store: \(count ?? 0)")

+```

+

+**Fixes:**

+1. **Check Account Status** → must be `.available`

+2. **Check Merge Policy** → ensure `NSMergeByPropertyStoreTrumpMergePolicy`

+3. **Check Observer** → `remoteStoreDidChange` registered?

+4. **Force Sync:**

+   ```swift

+   appData.persistentContainer.viewContext.refreshAllObjects()

+   appData.reloadSettingsFromCloudStore()

+   ```

+

+### Issue 2: "Duplicates appearing in CloudKit"

+

+**Diagnosis:**

+```swift

+// Check for MAC address duplicates

+let request = NSFetchRequest<NSDictionary>(entityName: "DeviceSettings")

+request.returnsDistinctResults = true

+request.returnsObjectsAsFaults = false

+request.resultType = .dictionaryResultType

+request.returnsDistinctResults = true

+

+let macs = try? appData.persistentContainer.viewContext.fetch(request)

+    .compactMap { $0["macAddress"] as? String }

+

+let duplicates = macs?.filter { mac in

+    macs?.filter { $0 == mac }.count ?? 0 > 1

+}

+print("Duplicate MACs: \(duplicates ?? [])")

+```

+

+**Fixes:**

+1. **Rebuild v3:** Ensure `cloudStoreRebuildVersion = 3` is deployed

+2. **Check `rebuildCanonicalStoreIfNeeded`:**

+   ```swift

+   // Manually trigger

+   appData.cloudStore?.rebuildCanonicalStoreIfNeeded(version: 3)

+   ```

+3. **Verify UserDefaults:**

+   ```swift

+   let rebuilt = UserDefaults.standard.bool(forKey: "cloudStoreRebuildVersion.3")

+   print("Rebuild v3 completed: \(rebuilt)")

+   ```

+

+### Issue 3: "Connection status stuck as 'Connected on Device X'"

+

+**Diagnosis:**

+```swift

+// Check connection record

+let request = NSFetchRequest<NSManagedObject>(entityName: "DeviceSettings")

+let records = try? appData.persistentContainer.viewContext.fetch(request)

+

+for record in records ?? [] {

+    if let expiry = record.value(forKey: "connectedExpiryAt") as? Date {

+        let isExpired = expiry < Date.now

+        print("✋ MAC \(record.value(forKey: "macAddress") ?? "?") expires at \(expiry), expired: \(isExpired)")

+    }

+}

+```

+

+**Fixes:**

+1. **Manually clear lock:**

+   ```swift

+   appData.clearMeterConnection(macAddress: "aa:bb:cc:dd:ee:ff")

+   ```

+2. **Check TTL hardcode:** Should be 120s in `setConnection()`

+3. **Verify system clock** on Device A (didn't fall asleep or drift)

+

+### Issue 4: "Core Data save errors" with `NSError 1569`

+

+**Symptom:**

+```

+NSError Domain=NSCocoaErrorDomain Code=1569

+"The object's persistent store is not reachable"

+```

+

+**Causes:**

+1. ❌ Old model with `uniquenessConstraint` conflicting with CloudKit

+2. ❌ All attributes on DeviceSettings aren't `optional="YES"`

+

+**Fixes:**

+1. **Verify model v2+:** Check `.xccurrentversion` points to `USB_Meter 2.xcdatamodel`

+2. **Check attributes:** All must be `optional="YES"` (inspect `.xcdatamodel/contents`)

+3. **Reset store if persists:**

+   ```swift

+   // Delete local store to force rebuild from CloudKit

+   let storeURL = appData.persistentContainer.persistentStoreDescriptions.first?.url

+   let fileManager = FileManager.default

+   try? fileManager.removeItem(at: storeURL)

+   ```

+

+---

+

+## Monitoring CloudKit Sync in Real Time

+

+### Dashboard View (for debugging)

+

+```swift

+struct CloudKitDebugView: View {

+    @ObservedObject var appData: AppData

+

+    var body: some View {

+        VStack(alignment: .leading, spacing: 8) {

+            Text("CloudKit Sync Status")

+                .font(.headline)

+

+            DebugItem(label: "Account", value: appData.cloudKitAccountStatus)

+            DebugItem(label: "Device ID", value: UIDevice.current.identifierForVendor?.uuidString ?? "?")

+            DebugItem(label: "Device Name", value: UIDevice.current.name)

+            DebugItem(label: "Last Sync", value: formatDate(appData.lastSyncTime))

+            DebugItem(label: "Records", value: "\(appData.deviceSettingsCount)")

+            DebugItem(label: "Pending", value: "\(appData.pendingSyncCount)")

+

+            Button("Force Reload") {

+                appData.reloadSettingsFromCloudStore()

+            }

+        }

+        .padding()

+        .font(.caption)

+    }

+}

+

+struct DebugItem: View {

+    let label: String

+    let value: String

+

+    var body: some View {

+        HStack {

+            Text(label).font(.caption2).foregroundColor(.secondary)

+            Spacer()

+            Text(value).font(.caption).monospaced()

+        }

+    }

+}

+```

+

+---

+

+## Network Conditions Testing

+

+### Simulate CloudKit Unavailability

+1. Xcode → Debug → Simulate Location → [Custom]

+2. Instrument → Network Link Conditioner → "Very Bad Network"

+

+### Expected Behavior:

+- ✅ Local changes proceed (saved to local DB)

+- ✅ Notification badge appears: "📶 Waiting for sync…"

+- ✅ When network returns → auto-resumes sync

+

+---

+

+## CloudKit Container Inspection (Advanced)

+

+Using CloudKit Console (requires Apple developer account):

+

+1. Go to https://icloud.developer.apple.com/cloudkit

+2. Select container: `iCloud.ro.xdev.USB-Meter`

+3. Browse `DeviceSettings` records:

+   - Check for duplicates by `macAddress`

+   - Verify `connectedByDeviceID` matches expected device UUIDs

+   - Check `updatedAt` timestamps

+

+---

+

+## Performance Profiling

+

+```swift

+// Measure reloadSettingsFromCloudStore() performance

+let start = Date()

+appData.reloadSettingsFromCloudStore()

+let duration = Date().timeIntervalSince(start)

+print("Reload took \(duration * 1000)ms")  // Should be <100ms for ~10 records

+```

+

+**Benchmarks:**

+| Operation | Target | Actual (good) |

+|-----------|--------|---------------|

+| `setConnection()` | <50ms | ~10ms |

+| `reloadSettingsFromCloudStore()` | <100ms | ~30ms (5 records) |

+| CloudKit push (network) | <5s | varies by connection |

+| Remote notification delivery | <10s | ~2-5s (typically) |

+

+---

+

+## Recording Logs for Bug Reports

+

+```bash

+# Save full debug logs

+log collect --start '2025-03-26 10:00:00' --output /tmp/cloudkit_logs.logarchive

+

+# Extract readable format

+log show /tmp/cloudkit_logs.logarchive \

+  --predicate 'process == "USB Meter"' \

+  --level debug > ~/cloudkit_debug.txt

+```

+

+Include in bug report:

+1. `~/cloudkit_debug.txt`

+2. Reproduction steps

+3. What you expected vs. what happened

+4. Device names & OS versions involved

+		A1B2C3D4E5F6A7B8C9D0E100 /* USB_Meter 2.xcdatamodel */ = {isa = PBXFileReference; lastKnownFileType = wrapper.xcdatamodel; path = "USB_Meter 2.xcdatamodel"; sourceTree = "<group>"; };

+						ProvisioningStyle = Automatic;

+						SystemCapabilities = {

+							com.apple.iCloud = {

+								enabled = 1;

+							};

+						};

+				DEVELOPMENT_TEAM = 9K2U3V9GZF;

+				DEVELOPMENT_TEAM = 9K2U3V9GZF;

+				A1B2C3D4E5F6A7B8C9D0E100 /* USB_Meter 2.xcdatamodel */,

+			currentVersion = A1B2C3D4E5F6A7B8C9D0E100 /* USB_Meter 2.xcdatamodel */;

+import CloudKit

+    private let cloudKitContainerIdentifier = "iCloud.ro.xdev.USB-Meter"

+

+        logCloudKitStatus()

+    private func logCloudKitStatus() {

+        let container = CKContainer(identifier: cloudKitContainerIdentifier)

+        container.accountStatus { status, error in

+            if let error {

+                track("CloudKit account status error: \(error.localizedDescription)")