Merge branch 'main' into dependabot/gradle/ktorClientCore-2.3.9

iosApp/iosApp/ContentView.swift

@@ -49,7 +49,8 @@ struct ContentView: View {
                     nearbyFetcher: nearbyFetcher,
                     scheduleFetcher: scheduleFetcher,
                     predictionsFetcher: predictionsFetcher,
-                    viewportProvider: viewportProvider
+                    viewportProvider: viewportProvider,
+                    alertsFetcher: alertsFetcher
                 )
             }
         }

iosApp/iosApp/Fetchers/NearbyFetcher.swift

@@ -79,13 +79,15 @@ class NearbyFetcher: ObservableObject {
     func withRealtimeInfo(
         schedules: ScheduleResponse?,
         predictions: PredictionsStreamDataResponse?,
+        alerts: AlertsStreamDataResponse?,
         filterAtTime: Instant
     ) -> [StopAssociatedRoute]? {
         guard let loadedLocation else { return nil }
         return nearbyByRouteAndStop?.withRealtimeInfo(
             sortByDistanceFrom: .init(longitude: loadedLocation.longitude, latitude: loadedLocation.latitude),
             schedules: schedules,
             predictions: predictions,
+            alerts: alerts,
             filterAtTime: filterAtTime
         )
     }

iosApp/iosApp/Localizable.xcstrings

@@ -27,6 +27,9 @@
     },
     "Couldn't load nearby transit, unable to parse response" : {
 
+    },
+    "Detour" : {
+
     },
     "Failed to load alerts, could not connect to the server" : {
 
@@ -54,12 +57,24 @@
     },
     "No results found" : {
 
+    },
+    "No Service" : {
+
     },
     "Routes" : {
 
+    },
+    "Shuttle" : {
+
+    },
+    "Stop Closed" : {
+
     },
     "Stops" : {
 
+    },
+    "Suspension" : {
+
     }
   },
   "version" : "1.0"

iosApp/iosApp/Pages/NearbyTransit/NearbyStopRoutePatternView.swift

@@ -33,14 +33,18 @@ struct NearbyStopRoutePatternView: View {
         case loading
         case none
         case some([TripWithFormat])
+        case noService(shared.Alert)
 
-        static func from(upcomingTrips: [UpcomingTrip]?, now: Instant) -> Self {
+        static func from(upcomingTrips: [UpcomingTrip]?, alertsHere: [shared.Alert]?, now: Instant) -> Self {
             guard let upcomingTrips else { return .loading }
             let tripsToShow = upcomingTrips
                 .map { TripWithFormat($0, now: now) }
                 .filter { !$0.isHidden() }
                 .prefix(2)
             if tripsToShow.isEmpty {
+                if let alert = alertsHere?.first {
+                    return .noService(alert)
+                }
                 return .none
             }
             return .some(Array(tripsToShow))
@@ -56,6 +60,8 @@ struct NearbyStopRoutePatternView: View {
                 ForEach(predictions) { prediction in
                     UpcomingTripView(prediction: .some(prediction.format))
                 }
+            case let .noService(alert):
+                UpcomingTripView(prediction: .noService(alert.effect))
             case .none:
                 UpcomingTripView(prediction: .none)
             case .loading:
@@ -64,3 +70,23 @@ struct NearbyStopRoutePatternView: View {
         }
     }
 }
+
+struct NearbyStopRoutePatternView_Previews: PreviewProvider {
+    static var previews: some View {
+        VStack(alignment: .trailing) {
+            let now = Date.now
+            NearbyStopRoutePatternView(headsign: "Some", predictions: .some([
+                .init(.init(prediction: ObjectCollectionBuilder.Single.shared.prediction { prediction in
+                    prediction.departureTime = now.addingTimeInterval(5 * 60).toKotlinInstant()
+                }), now: now.toKotlinInstant()),
+            ]))
+            NearbyStopRoutePatternView(headsign: "None", predictions: .none)
+            NearbyStopRoutePatternView(headsign: "Loading", predictions: .loading)
+            NearbyStopRoutePatternView(headsign: "No Service", predictions: .noService(
+                ObjectCollectionBuilder.Single.shared.alert { alert in
+                    alert.effect = .suspension
+                }
+            ))
+        }
+    }
+}

iosApp/iosApp/Pages/NearbyTransit/NearbyStopView.swift

@@ -21,7 +21,8 @@ struct NearbyStopView: View {
                 ForEach(patternsAtStop.patternsByHeadsign, id: \.headsign) { patternsByHeadsign in
                     NearbyStopRoutePatternView(
                         headsign: patternsByHeadsign.headsign,
-                        predictions: .from(upcomingTrips: patternsByHeadsign.upcomingTrips, now: now)
+                        predictions: .from(upcomingTrips: patternsByHeadsign.upcomingTrips,
+                                           alertsHere: patternsByHeadsign.alertsHere, now: now)
                     )
                 }
             }

iosApp/iosApp/Pages/NearbyTransit/NearbyTransitPageView.swift

@@ -19,6 +19,7 @@ struct NearbyTransitPageView: View {
     @ObservedObject var scheduleFetcher: ScheduleFetcher
     @ObservedObject var predictionsFetcher: PredictionsFetcher
     @ObservedObject var viewportProvider: ViewportProvider
+    @ObservedObject var alertsFetcher: AlertsFetcher
 
     @State var cancellables: [AnyCancellable]
     @State var locationProvider: NearbyTransitLocationProvider
@@ -28,13 +29,15 @@ struct NearbyTransitPageView: View {
         nearbyFetcher: NearbyFetcher,
         scheduleFetcher: ScheduleFetcher,
         predictionsFetcher: PredictionsFetcher,
-        viewportProvider: ViewportProvider
+        viewportProvider: ViewportProvider,
+        alertsFetcher: AlertsFetcher
     ) {
         self.currentLocation = currentLocation
         self.nearbyFetcher = nearbyFetcher
         self.scheduleFetcher = scheduleFetcher
         self.predictionsFetcher = predictionsFetcher
         self.viewportProvider = viewportProvider
+        self.alertsFetcher = alertsFetcher
 
         cancellables = .init()
         locationProvider = .init(
@@ -49,7 +52,8 @@ struct NearbyTransitPageView: View {
             locationProvider: locationProvider,
             nearbyFetcher: nearbyFetcher,
             scheduleFetcher: scheduleFetcher,
-            predictionsFetcher: predictionsFetcher
+            predictionsFetcher: predictionsFetcher,
+            alertsFetcher: alertsFetcher
         )
         .onAppear {
             cancellables.append(

iosApp/iosApp/Pages/NearbyTransit/NearbyTransitView.swift

@@ -19,6 +19,7 @@ struct NearbyTransitView: View {
     @ObservedObject var nearbyFetcher: NearbyFetcher
     @ObservedObject var scheduleFetcher: ScheduleFetcher
     @ObservedObject var predictionsFetcher: PredictionsFetcher
+    @ObservedObject var alertsFetcher: AlertsFetcher
     @State var now = Date.now
 
     let timer = Timer.publish(every: 5, on: .main, in: .common).autoconnect()
@@ -29,6 +30,7 @@ struct NearbyTransitView: View {
             if let nearby = nearbyFetcher.withRealtimeInfo(
                 schedules: scheduleFetcher.schedules,
                 predictions: predictionsFetcher.predictions,
+                alerts: alertsFetcher.alerts,
                 filterAtTime: now.toKotlinInstant()
             ) {
                 List(nearby, id: \.route.id) { nearbyRoute in
@@ -247,7 +249,8 @@ struct NearbyTransitView_Previews: PreviewProvider {
                                     upcomingTrips: [
                                         UpcomingTrip(prediction: busPrediction1),
                                         UpcomingTrip(prediction: busPrediction2),
-                                    ]
+                                    ],
+                                    alertsHere: nil
                                 ),
                             ]
                         ),
@@ -268,7 +271,8 @@ struct NearbyTransitView_Previews: PreviewProvider {
                                     upcomingTrips: [
                                         UpcomingTrip(prediction: crPrediction1),
                                         UpcomingTrip(prediction: crPrediction2),
-                                    ]
+                                    ],
+                                    alertsHere: nil
                                 ),
                             ]
                         ),

iosApp/iosApp/Pages/NearbyTransit/UpcomingTripView.swift

@@ -23,6 +23,7 @@ struct UpcomingTripView: View {
     enum State: Equatable {
         case loading
         case none
+        case noService(shared.Alert.Effect)
         case some(UpcomingTrip.Format)
     }
 
@@ -51,6 +52,8 @@ struct UpcomingTripView: View {
             case let .minutes(format):
                 Text("\(format.minutes, specifier: "%ld") min")
             }
+        case let .noService(alertEffect):
+            NoServiceView(effect: .from(alertEffect: alertEffect))
         case .none:
             Text("No Predictions")
         case .loading:
@@ -60,3 +63,66 @@ struct UpcomingTripView: View {
             .frame(minWidth: 48, alignment: .trailing)
     }
 }
+
+struct NoServiceView: View {
+    let effect: Effect
+
+    enum Effect {
+        case detour
+        case shuttle
+        case stopClosed
+        case suspension
+        case unknown
+
+        static func from(alertEffect: shared.Alert.Effect) -> Self {
+            switch alertEffect {
+            case .detour: .detour
+            case .shuttle: .shuttle
+            case .stationClosure, .stopClosure: .stopClosed
+            case .suspension: .suspension
+            default: .unknown
+            }
+        }
+    }
+
+    var body: some View {
+        HStack {
+            rawText
+                .font(.system(size: 12))
+                .textCase(.uppercase)
+            rawImage
+        }
+    }
+
+    var rawText: Text {
+        switch effect {
+        case .detour: Text("Detour")
+        case .shuttle: Text("Shuttle")
+        case .stopClosed: Text("Stop Closed")
+        case .suspension: Text("Suspension")
+        case .unknown: Text("No Service")
+        }
+    }
+
+    var rawImage: Image {
+        switch effect {
+        case .detour: Image(systemName: "circle.fill")
+        case .shuttle: Image(systemName: "bus")
+        case .stopClosed: Image(systemName: "xmark.octagon.fill")
+        case .suspension: Image(systemName: "exclamationmark.triangle.fill")
+        case .unknown: Image(systemName: "questionmark.circle.fill")
+        }
+    }
+}
+
+struct UpcomingTripView_Previews: PreviewProvider {
+    static var previews: some View {
+        VStack(alignment: .trailing) {
+            UpcomingTripView(prediction: .noService(.suspension))
+            UpcomingTripView(prediction: .noService(.shuttle))
+            UpcomingTripView(prediction: .noService(.stopClosure))
+            UpcomingTripView(prediction: .noService(.detour))
+        }
+        .previewDisplayName("No Service")
+    }
+}