fix: App may crash silently for some users

- This affects some users on v3.3.0 but we have no definitive way to reproduce it. Fix is based on the stack trace.

Author: priyonto

Apps/RuuviStation/Sources/Classes/Presentation/Modules/Full Sensor Card/View/CardsBaseViewController.swift

@@ -656,6 +656,13 @@ private extension CardsBaseViewController {
         for tab: CardsMenuType,
         animated: Bool
     ) {
+        guard isViewLoaded else { return }
+        guard footerStackHeightConstraint != nil,
+              tabContainerBottomToViewConstraint != nil,
+              footerBottomToViewConstraint != nil,
+              footerBottomToSafeConstraint != nil else {
+            return
+        }
         let hasSnapshot = currentSnapshotIndex < currentSnapshots.count
         guard flags.showNewCardsMenu else {
             footerView.isHidden = !hasSnapshot

Packages/RuuviReactor/Sources/RuuviReactorImpl/RuuviReactorImpl.swift

@@ -12,6 +12,13 @@ class RuuviReactorImpl: RuuviReactor {
     private let sqliteContext: SQLiteContext
     private let sqlitePersistence: RuuviPersistence
     private let errorReporter: RuuviErrorReporter
+    private let stateLock = NSLock()
+    private let entityCombine: RuuviTagSubjectCombine
+
+    private var recordCombines = [String: RuuviTagRecordSubjectCombine]()
+    private var lastRecordCombines = [String: RuuviTagLastRecordSubjectCombine]()
+    private var latestRecordCombines = [String: RuuviTagLatestRecordSubjectCombine]()
+    private var sensorSettingsCombines = [String: SensorSettingsCombine]()
 
     init(
         sqliteContext: SQLiteContext,
@@ -21,38 +28,48 @@ class RuuviReactorImpl: RuuviReactor {
         self.sqliteContext = sqliteContext
         self.sqlitePersistence = sqlitePersistence
         self.errorReporter = errorReporter
+        self.entityCombine = RuuviTagSubjectCombine(
+            sqlite: sqliteContext,
+            errorReporter: errorReporter
+        )
     }
 
-    private lazy var entityCombine = RuuviTagSubjectCombine(
-        sqlite: sqliteContext,
-        errorReporter: errorReporter
-    )
-    private lazy var recordCombines = [String: RuuviTagRecordSubjectCombine]()
-    private lazy var lastRecordCombines = [String: RuuviTagLastRecordSubjectCombine]()
-    private lazy var latestRecordCombines = [String: RuuviTagLatestRecordSubjectCombine]()
-    private lazy var sensorSettingsCombines = [String: SensorSettingsCombine]()
+    private func synchronized<T>(_ block: () -> T) -> T {
+        stateLock.lock()
+        defer { stateLock.unlock() }
+        return block()
+    }
 
     func observe(
         _ luid: LocalIdentifier,
         _ block: @escaping ([AnyRuuviTagSensorRecord]) -> Void
     ) -> RuuviReactorToken {
-        var recordCombine: RuuviTagRecordSubjectCombine
-        if let combine = recordCombines[luid.value] {
-            recordCombine = combine
-        } else {
+        let recordCombine: RuuviTagRecordSubjectCombine = synchronized {
+            if let combine = recordCombines[luid.value] {
+                return combine
+            }
             let combine = RuuviTagRecordSubjectCombine(
                 luid: luid,
                 macId: nil,
                 sqlite: sqliteContext,
                 errorReporter: errorReporter
             )
             recordCombines[luid.value] = combine
-            recordCombine = combine
+            return combine
         }
+
         let cancellable = recordCombine.subject.sink { values in
             block(values)
         }
-        if !recordCombine.isServing {
+
+        let shouldStart = synchronized {
+            if recordCombine.isServing {
+                return false
+            }
+            recordCombine.isServing = true
+            return true
+        }
+        if shouldStart {
             recordCombine.start()
         }
         return RuuviReactorToken {
@@ -96,23 +113,32 @@ class RuuviReactorImpl: RuuviReactor {
                 let result = [sqliteRecord].compactMap { $0?.any }.last
                 block(.update(result))
             })
-        var recordCombine: RuuviTagLastRecordSubjectCombine
-        if let combine = lastRecordCombines[ruuviTag.id] {
-            recordCombine = combine
-        } else {
+        let recordCombine: RuuviTagLastRecordSubjectCombine = synchronized {
+            if let combine = lastRecordCombines[ruuviTag.id] {
+                return combine
+            }
             let combine = RuuviTagLastRecordSubjectCombine(
                 luid: ruuviTag.luid,
                 macId: ruuviTag.macId,
                 sqlite: sqliteContext,
                 errorReporter: errorReporter
             )
             lastRecordCombines[ruuviTag.id] = combine
-            recordCombine = combine
+            return combine
         }
+
         let cancellable = recordCombine.subject.sink { record in
             block(.update(record))
         }
-        if !recordCombine.isServing {
+
+        let shouldStart = synchronized {
+            if recordCombine.isServing {
+                return false
+            }
+            recordCombine.isServing = true
+            return true
+        }
+        if shouldStart {
             recordCombine.start()
         }
         return RuuviReactorToken {
@@ -129,23 +155,32 @@ class RuuviReactorImpl: RuuviReactor {
             let result = [sqliteRecord].compactMap { $0?.any }.last
             block(.update(result))
         })
-        var recordCombine: RuuviTagLatestRecordSubjectCombine
-        if let combine = latestRecordCombines[ruuviTag.id] {
-            recordCombine = combine
-        } else {
+        let recordCombine: RuuviTagLatestRecordSubjectCombine = synchronized {
+            if let combine = latestRecordCombines[ruuviTag.id] {
+                return combine
+            }
             let combine = RuuviTagLatestRecordSubjectCombine(
                 luid: ruuviTag.luid,
                 macId: ruuviTag.macId,
                 sqlite: sqliteContext,
                 errorReporter: errorReporter
             )
             latestRecordCombines[ruuviTag.id] = combine
-            recordCombine = combine
+            return combine
         }
+
         let cancellable = recordCombine.subject.sink { record in
             block(.update(record))
         }
-        if !recordCombine.isServing {
+
+        let shouldStart = synchronized {
+            if recordCombine.isServing {
+                return false
+            }
+            recordCombine.isServing = true
+            return true
+        }
+        if shouldStart {
             recordCombine.start()
         }
         return RuuviReactorToken {
@@ -162,19 +197,20 @@ class RuuviReactorImpl: RuuviReactor {
                 block(.initial([sensorSettings]))
             }
         }
-        var sensorSettingsCombine: SensorSettingsCombine
-         if let combine = sensorSettingsCombines[ruuviTag.id] {
-            sensorSettingsCombine = combine
-        } else {
+        let sensorSettingsCombine: SensorSettingsCombine = synchronized {
+            if let combine = sensorSettingsCombines[ruuviTag.id] {
+                return combine
+            }
             let combine = SensorSettingsCombine(
                 luid: ruuviTag.luid,
                 macId: ruuviTag.macId,
                 sqlite: sqliteContext,
                 errorReporter: errorReporter
             )
             sensorSettingsCombines[ruuviTag.id] = combine
-            sensorSettingsCombine = combine
+            return combine
         }
+
         let insert = sensorSettingsCombine.insertSubject.sink { value in
             block(.insert(value))
         }