fix: Set inForeground to true after a new session has been started

Sources/Amplitude/Amplitude.swift

@@ -319,12 +319,13 @@ public class Amplitude {
     }
 
     func onEnterForeground(timestamp: Int64) {
-        inForeground = true
         let dummySessionStartEvent = BaseEvent(
             timestamp: timestamp,
             eventType: Constants.AMP_SESSION_START_EVENT
         )
         let events = sessions.processEvent(event: dummySessionStartEvent, inForeground: false)
+        // Set inForeground to true only after we have successfully started a new session if needed. 
+        inForeground = true
         events.forEach { e in timeline.processEvent(event: e) }
     }
 

Tests/AmplitudeTests/AmplitudeTests.swift

@@ -340,6 +340,43 @@ final class AmplitudeTests: XCTestCase {
         XCTAssertEqual(events[0].eventType, eventType)
         XCTAssertEqual(events[0].sessionId, -1)
     }
+
+    func testEventProcessingBeforeOnEnterForeground() async {
+        let configuration = Configuration(
+            apiKey: "api-key",
+            storageProvider: storageMem,
+            identifyStorageProvider: interceptStorageMem,
+            defaultTracking: DefaultTrackingOptions(sessions: false)
+        )
+        let amplitude = Amplitude(configuration: configuration)
+        amplitude.sessions = SessionsWithDelayedEventStartProcessing(amplitude: amplitude)
+        let timestamp = Int64(NSDate().timeIntervalSince1970 * 1000)
+
+        let oneHourEarlierTimestamp = timestamp - (1 * 60 * 60 * 1000)
+        amplitude.setSessionId(timestamp: oneHourEarlierTimestamp)
+
+        @Sendable
+        func processStartSessionEvent() async {
+            amplitude.onEnterForeground(timestamp: timestamp)
+        }
+
+        func processRegularEvent() async {
+            amplitude.track(eventType: "test_event")
+        }
+
+        // We process the session start event first. The session class will wait for 3 seconds before it processes
+        // the event
+        async let task = processStartSessionEvent();
+        // Sleep for 1 second and process a regular event. This is to try the case where an event gets processed
+        // before the session start event
+        sleep(1)
+        await processRegularEvent();
+        await task;
+
+        // We want to make sure that a new session was started
+        XCTAssertTrue(amplitude.getSessionId() > oneHourEarlierTimestamp)
+
+    }
 
     func testMigrationToApiKeyAndInstanceNameStorage() throws {
         let legacyUserId = "legacy-user-id"

Tests/AmplitudeTests/Supports/TestUtilities.swift

@@ -289,3 +289,12 @@ final class MockPathCreation: PathCreationProtocol {
         subject.send(networkPath)
     }
 }
+
+class SessionsWithDelayedEventStartProcessing: Sessions {
+    override func processEvent(event: BaseEvent, inForeground: Bool) -> [BaseEvent] {
+        if (event.eventType == Constants.AMP_SESSION_START_EVENT) {
+            sleep(3)
+        }
+        return super.processEvent(event: event, inForeground: inForeground)
+    }
+}