Track barcode scanning success and failed events in barcode observer

- Calculate scan duration time in GameControllerBarcodeParser
- Track the events in GameControllerBarcodeObserver

Author: staskus

WooCommerce/Classes/POS/Presentation/Barcode Scanning/GameControllerBarcodeObserver.swift

@@ -88,7 +88,12 @@ final class GameControllerBarcodeObserver {
         cleanupKeyboard()
 
         coalescedKeyboard = keyboard
-        barcodeParser = GameControllerBarcodeParser(configuration: configuration, onScan: onScan)
+        barcodeParser = GameControllerBarcodeParser(
+            configuration: configuration,
+            onScan: { [weak self] result in
+                self?.handleScanResult(result)
+            }
+        )
 
         keyboard.keyboardInput?.keyChangedHandler = { [weak self] _, _, keyCode, pressed in
             guard let self = self else { return }
@@ -112,4 +117,29 @@ final class GameControllerBarcodeObserver {
         barcodeParser = nil
         isShiftPressed = false
     }
+
+    private func handleScanResult(_ result: HIDBarcodeParserResult) {
+        trackAnalyticsEvent(for: result)
+        onScan(result.asResult)
+    }
+
+    private func trackAnalyticsEvent(for result: HIDBarcodeParserResult) {
+        switch result {
+        case .success(let barcode, let scanDurationMs):
+            ServiceLocator.analytics.track(
+                event: WooAnalyticsEvent.PointOfSale.barcodeScanningSuccess(
+                    scanDurationMs: scanDurationMs,
+                    barcodeLength: barcode.count
+                )
+            )
+        case .failure(let error, let scanDurationMs):
+            ServiceLocator.analytics.track(
+                event: WooAnalyticsEvent.PointOfSale.barcodeScanningFailed(
+                    scanDurationMs: scanDurationMs,
+                    barcodeLength: error.barcode.count,
+                    failReason: error.analyticsReason
+                )
+            )
+        }
+    }
 }

WooCommerce/Classes/POS/Presentation/Barcode Scanning/GameControllerBarcodeParser.swift

@@ -8,15 +8,16 @@ final class GameControllerBarcodeParser {
     /// Configuration for the barcode scanner
     let configuration: HIDBarcodeParserConfiguration
     /// Callback that is triggered when a barcode scan completes (success or failure)
-    let onScan: (Result<String, Error>) -> Void
+    let onScan: (HIDBarcodeParserResult) -> Void
 
     private let timeProvider: TimeProvider
 
     private var buffer = ""
     private var lastKeyPressTime: Date?
+    private var scanStartTime: Date?
 
     init(configuration: HIDBarcodeParserConfiguration,
-         onScan: @escaping (Result<String, Error>) -> Void,
+         onScan: @escaping (HIDBarcodeParserResult) -> Void,
          timeProvider: TimeProvider = DefaultTimeProvider()) {
         self.configuration = configuration
         self.onScan = onScan
@@ -41,6 +42,12 @@ final class GameControllerBarcodeParser {
         } else {
             guard !excludedKeyCodes.contains(keyCode) else { return }
             checkForTimeoutBetweenKeystrokes()
+
+            // Start timing on first character
+            if buffer.isEmpty {
+                scanStartTime = timeProvider.now()
+            }
+
             buffer.append(character)
         }
     }
@@ -69,7 +76,10 @@ final class GameControllerBarcodeParser {
 
         if let lastTime = lastKeyPressTime,
            currentTime.timeIntervalSince(lastTime) > configuration.maximumInterCharacterTime {
-            onScan(.failure(HIDBarcodeParserError.timedOut(barcode: buffer)))
+            let scanDurationMs = calculateScanDurationMs()
+            let result = HIDBarcodeParserResult.failure(error: HIDBarcodeParserError.timedOut(barcode: buffer), scanDurationMs: scanDurationMs)
+
+            onScan(result)
             resetScan()
         }
 
@@ -175,14 +185,24 @@ final class GameControllerBarcodeParser {
     private func resetScan() {
         buffer = ""
         lastKeyPressTime = nil
+        scanStartTime = nil
+    }
+
+    private func calculateScanDurationMs() -> Int {
+        guard let startTime = scanStartTime else { return 0 }
+        return Int(timeProvider.now().timeIntervalSince(startTime) * 1000)
     }
 
     private func processScan() {
         checkForTimeoutBetweenKeystrokes()
+        let scanDurationMs = calculateScanDurationMs()
+
         if buffer.count >= configuration.minimumBarcodeLength {
-            onScan(.success(buffer))
+            let result = HIDBarcodeParserResult.success(barcode: buffer, scanDurationMs: scanDurationMs)
+            onScan(result)
         } else {
-            onScan(.failure(HIDBarcodeParserError.scanTooShort(barcode: buffer)))
+            let result = HIDBarcodeParserResult.failure(error: HIDBarcodeParserError.scanTooShort(barcode: buffer), scanDurationMs: scanDurationMs)
+            onScan(result)
         }
         resetScan()
     }
@@ -211,4 +231,34 @@ struct HIDBarcodeParserConfiguration {
 enum HIDBarcodeParserError: Error {
     case scanTooShort(barcode: String)
     case timedOut(barcode: String)
+
+    var analyticsReason: String {
+        switch self {
+        case .scanTooShort:
+            return "too_short"
+        case .timedOut:
+            return "no_terminator"
+        }
+    }
+
+    var barcode: String {
+        switch self {
+        case .scanTooShort(let barcode), .timedOut(let barcode):
+            return barcode
+        }
+    }
+}
+
+enum HIDBarcodeParserResult {
+    case success(barcode: String, scanDurationMs: Int)
+    case failure(error: HIDBarcodeParserError, scanDurationMs: Int)
+
+    var asResult: Result<String, Error> {
+        switch self {
+        case .success(let barcode, _):
+            return .success(barcode)
+        case .failure(let error, _):
+            return .failure(error)
+        }
+    }
 }