fix: UIDevice.current.orientation.isLandscape not main thread access (#102)

Move access to UIDevice.current.orientation.isLandscape onto main thread
access

<!-- CURSOR_SUMMARY -->
---

> [!NOTE]
> Capture orientation on the main thread and propagate it through the
image/export pipeline to viewport events, removing direct UIDevice
orientation access.
> 
> - **Session Replay Pipeline**:
> - Capture device orientation on the main thread in
`ScreenCaptureService.captureUIImage` and include it in `CapturedImage`.
> - Propagate orientation through `UIImage.exportImage(...)` and
`ExportImage` (new `orientation` field/initializer parameter).
> - `SessionReplayEventGenerator.viewPortEvent` now uses
`exportImage.orientation` instead of querying `UIDevice`.
> - `SnapshotTaker` passes `CapturedImage.orientation` when creating
`ExportImage`.
> - **Misc**:
> - Record `timestamp` once in `ScreenCaptureService` and reuse for the
captured frame.
>   - Test app config: minor cleanup in `Observability` options.
> 
> <sup>Written by [Cursor
Bugbot](https://cursor.com/dashboard?tab=bugbot) for commit
0728cca. This will update automatically
on new commits. Configure
[here](https://cursor.com/dashboard?tab=bugbot).</sup>
<!-- /CURSOR_SUMMARY -->

Author: abelonogov-ld

Sources/LaunchDarklySessionReplay/Exporter/SessionReplayEventGenerator.swift

@@ -220,18 +220,13 @@ actor SessionReplayEventGenerator {
     }
 
     func viewPortEvent(exportImage: ExportImage, timestamp: TimeInterval) -> Event {
-        #if os(iOS)
-        let currentOrientation = UIDevice.current.orientation.isLandscape ? 1 : 0
-        #else
-        let currentOrientation = 0
-        #endif
         let payload = ViewportPayload(width: exportImage.originalWidth,
                                       height: exportImage.originalHeight,
                                       availWidth: exportImage.originalWidth,
                                       availHeight: exportImage.originalHeight,
                                       colorDepth: 30,
                                       pixelDepth: 30,
-                                      orientation: currentOrientation)
+                                      orientation: exportImage.orientation)
         let eventData = CustomEventData(tag: .viewport, payload: payload)
         let event = Event(type: .Custom,
                           data: AnyEventData(eventData),

Sources/LaunchDarklySessionReplay/ScreenCapture/ExportImage.swift

@@ -9,15 +9,17 @@ struct ExportImage: Equatable {
     let scale: CGFloat
     let format: ExportFormat
     let timestamp: TimeInterval
-    
-    init(data: Data, originalWidth: Int, originalHeight: Int, scale: CGFloat, format: ExportFormat, timestamp: TimeInterval) {
+    let orientation: Int
+
+    init(data: Data, originalWidth: Int, originalHeight: Int, scale: CGFloat, format: ExportFormat, timestamp: TimeInterval, orientation: Int) {
         self.data = data
         self.dataHashValue = data.hashValue
         self.originalWidth = originalWidth
         self.originalHeight = originalHeight
         self.scale = scale
         self.format = format
         self.timestamp = timestamp
+        self.orientation = orientation
     }
 
     func eventNode(id: Int, rr_dataURL: String) -> EventNode {
@@ -51,14 +53,15 @@ struct ExportImage: Equatable {
 }
 
 extension UIImage {
-    func exportImage(format: ExportFormat, originalSize: CGSize, scale: CGFloat, timestamp: TimeInterval) -> ExportImage? {
+    func exportImage(format: ExportFormat, originalSize: CGSize, scale: CGFloat, timestamp: TimeInterval, orientation: Int) -> ExportImage? {
         guard let data = asData(format: format) else { return nil }
         return ExportImage(data: data,
                            originalWidth: Int(originalSize.width),
                            originalHeight: Int(originalSize.height),
                            scale: scale,
                            format: format,
-                           timestamp: timestamp)
+                           timestamp: timestamp,
+                           orientation: orientation)
     }
 }
 

Sources/LaunchDarklySessionReplay/ScreenCapture/ScreenCaptureService.swift

@@ -8,6 +8,7 @@ public struct CapturedImage {
     public let scale: CGFloat
     public let renderSize: CGSize
     public let timestamp: TimeInterval
+    public let orientation: Int
 }
 
 public final class ScreenCaptureService {
@@ -22,6 +23,12 @@ public final class ScreenCaptureService {
 
     /// Capture as UIImage (must be on main thread).
     public func captureUIImage(yield: @escaping (CapturedImage?) async -> Void) {
+#if os(iOS)
+        let orientation = UIDevice.current.orientation.isLandscape ? 1 : 0
+#else
+        let orientation = 0
+#endif
+        let timestamp = Date().timeIntervalSince1970
         let scale = 1.0
         let format = UIGraphicsImageRendererFormat()
         format.scale = scale
@@ -69,7 +76,8 @@ public final class ScreenCaptureService {
                 let capturedImage = CapturedImage(image: image,
                                                   scale: scale,
                                                   renderSize: enclosingBounds.size,
-                                                  timestamp: Date().timeIntervalSince1970)
+                                                  timestamp: timestamp,
+                                                  orientation: orientation)
 
                 await yield(capturedImage)
             }

Sources/LaunchDarklySessionReplay/ScreenCapture/SnapshotTaker.swift

@@ -88,7 +88,7 @@ final class SnapshotTaker: EventSource {
 
         let lastFrameDispatchTime = DispatchTime.now()
         self.lastFrameDispatchTime = lastFrameDispatchTime
-    
+        
         captureService.captureUIImage { capturedImage in
             guard let capturedImage else {
                 // dropped frame
@@ -98,7 +98,8 @@ final class SnapshotTaker: EventSource {
             guard let exportImage = capturedImage.image.exportImage(format: .jpeg(quality: 0.3),
                                                                     originalSize: capturedImage.renderSize,
                                                                     scale: capturedImage.scale,
-                                                                    timestamp: capturedImage.timestamp) else {
+                                                                    timestamp: capturedImage.timestamp,
+                                                                    orientation: capturedImage.orientation) else {
                 return
             }