FuelBoard Contributor
494412ba99
ProximityMonitor now records each stage the live chain reaches (Settings → Debug → Alert trace, in-memory, newest-first, capped at 8): - didEnterRegion arrival (regionEventCount + entry line) — distinguishes 'geofence never fires' from 'gate blocked the alert' - gate misses: station not in loaded list, hourly dedup (with minutes ago), no fuel sellers within radius after fresh fetch, entered-not-cheapest (with the cheaper station + price) - the previously-silent fresh-fetch catch now logs the error - 'alert scheduled' once UNUserNotificationCenter.add is called — if that line appears but no banner shows, the failure is delivery/permission, not alert logic SettingsView shows the trace (symbol per kind) + region-event count; the existing Test-alert button already probes notification permission and reports denial inline. 83 tests, Release build green.
724 lines
35 KiB
Swift
724 lines
35 KiB
Swift
import CoreLocation
|
|
import UserNotifications
|
|
import SwiftUI
|
|
import MapKit
|
|
import UIKit
|
|
|
|
/// Debug-only location snapshot shown in Settings → Debug. Lets the
|
|
/// developer verify location services while testing: the last fix (with age)
|
|
/// plus how many stations selling the monitored fuel are within the alert
|
|
/// radius of that fix — the exact criteria live alerts use.
|
|
struct DebugLocationStatus: Equatable {
|
|
var coordinate: Coordinate?
|
|
var fixAge: TimeInterval?
|
|
var fuel: FuelType
|
|
var radiusKM: Double
|
|
var inRangeCount: Int
|
|
var cheapestInRange: FuelStation?
|
|
var cheapestDistanceKM: Double?
|
|
}
|
|
|
|
/// One recorded event in the live alert trace (Settings → Debug). Lets the
|
|
/// tester see exactly which stage of the alert chain ran — whether a region
|
|
/// event arrived at all, which gate (if any) suppressed the alert, and when
|
|
/// an alert was scheduled. In-memory only: resets on relaunch.
|
|
struct AlertLogEntry: Identifiable, Equatable {
|
|
enum Kind: String, Equatable {
|
|
/// A geofence entry event reached the monitor (didEnterRegion).
|
|
case entry
|
|
/// A gate blocked the alert (dedup, not-cheapest, station missing…).
|
|
case gate
|
|
/// A non-recoverable failure (fresh-price fetch threw).
|
|
case error
|
|
/// An alert was scheduled with UNUserNotificationCenter.
|
|
case fired
|
|
}
|
|
let id = UUID()
|
|
let date: Date
|
|
let kind: Kind
|
|
let text: String
|
|
}
|
|
|
|
/// App-view cheapest for the Debug section: mirrors EXACTLY what the Stations
|
|
/// list computes (selected fuel, stationLimit radius, current location), so
|
|
/// the debug "Cheapest in range" row matches the TOP badge in the app —
|
|
/// not the alert prediction (which uses alertsFuel + alert radius, a
|
|
/// different pool by design).
|
|
struct DebugAppCheapest: Equatable {
|
|
let station: FuelStation
|
|
let fuel: FuelType
|
|
let radiusKM: Double
|
|
let distanceKM: Double
|
|
}
|
|
|
|
/// A station the user wants to see on a map — set when a notification tap
|
|
/// can't hand off to Apple Maps (e.g. inside LiveContainer), so the app shows
|
|
/// an in-app map with directions instead.
|
|
struct StationMapRequest: Identifiable {
|
|
let id = UUID()
|
|
let name: String
|
|
let latitude: Double
|
|
let longitude: Double
|
|
}
|
|
|
|
/// One station offered as a dynamic notification action button when several
|
|
/// stations tie for the cheapest price within the radius.
|
|
struct TieChoice {
|
|
let station: FuelStation
|
|
/// Short button label, e.g. "Tesco · 0.8 mi".
|
|
let buttonTitle: String
|
|
}
|
|
|
|
/// Geofences favourite + closest stations and fires a local notification when
|
|
/// the user enters a station whose price is the cheapest within the radius.
|
|
///
|
|
/// Region budget: iOS allows 20 monitored regions per app — favourites are
|
|
/// always registered first, then the closest remaining stations fill the rest.
|
|
/// Each region is a circle around a station with radius = the alert radius
|
|
/// (clamped to the device ceiling), so the notification fires on APPROACH —
|
|
/// entering the winner's circle — not at the forecourt.
|
|
@MainActor
|
|
final class ProximityMonitor: NSObject, ObservableObject, @preconcurrency CLLocationManagerDelegate, UNUserNotificationCenterDelegate {
|
|
@Published var monitoredStationIDs: [String] = []
|
|
@Published var lastAlert: String?
|
|
@Published private(set) var lastTestResult: String?
|
|
@Published var pendingStationMap: StationMapRequest?
|
|
/// Debug-only snapshot for the Settings → Debug section. Recomputed on
|
|
/// every location/stations change via `refreshDebugStatus()`.
|
|
@Published private(set) var debugStatus: DebugLocationStatus?
|
|
/// Last CoreLocation region-monitoring failure, if any. Shown in Settings
|
|
/// → Debug so a silently-failed `startMonitoring` (region budget exceeded,
|
|
/// auth not granted, radius too large) is visible instead of invisible.
|
|
@Published private(set) var lastRegionError: String?
|
|
/// Live alert trace (Settings → Debug): every stage the chain reached,
|
|
/// newest first, capped at 8. Empty = no region event has ever arrived.
|
|
@Published private(set) var alertLog: [AlertLogEntry] = []
|
|
/// How many `didEnterRegion` callbacks this session — proof the geofences
|
|
/// actually fire (vs. a gate silently blocking every alert).
|
|
@Published private(set) var regionEventCount = 0
|
|
|
|
private let manager = CLLocationManager()
|
|
private var stations: [FuelStation] = []
|
|
private var favourites: [FuelStation] = []
|
|
private var fuel: FuelType = .e10
|
|
private var radiusKM: Double = 3.0
|
|
private var lastNotified: [String: Date] = [:] // dedup per station
|
|
private var enabled = false
|
|
/// Dynamically registered categories for tie-choice notifications. Kept so
|
|
/// setNotificationCategories never drops previously registered categories.
|
|
private var tieCategories: Set<UNNotificationCategory> = []
|
|
|
|
override init() {
|
|
super.init()
|
|
manager.delegate = self
|
|
manager.desiredAccuracy = kCLLocationAccuracyHundredMeters
|
|
manager.pausesLocationUpdatesAutomatically = true
|
|
// Show alert banners even while the app is open, and complete the tap
|
|
// action (opening FuelBoard) when the user taps a notification.
|
|
UNUserNotificationCenter.current().delegate = self
|
|
// Restore persisted state on background relaunch so region events work
|
|
// even before the view fully appears.
|
|
enabled = FuelStore.loadAlertsEnabled()
|
|
fuel = FuelStore.loadAlertsFuel()
|
|
// Effective radius honours "Follow search" even on a cold launch /
|
|
// background region-event wake (the raw manual radius would otherwise
|
|
// be used until the first foreground update re-targets geofences).
|
|
radiusKM = FuelStore.effectiveAlertsRadiusKM(
|
|
followsSearch: FuelStore.loadAlertsFollowsSearch(),
|
|
manualKM: FuelStore.loadAlertsRadius())
|
|
stations = FuelStore.loadStations()
|
|
favourites = FuelStore.loadFavourites().filter { $0.fuel == fuel }.map(\.station)
|
|
}
|
|
|
|
/// Re-registers geofences. Call whenever stations/favourites/settings change.
|
|
/// Favourites are fuel-scoped entries; only entries for the monitored fuel
|
|
/// get priority slots (a Diesel favourite must not grab a slot while
|
|
/// monitoring Unleaded).
|
|
func update(stations: [FuelStation], favourites: [FavouriteEntry], fuel: FuelType, radiusKM: Double) {
|
|
// Fall back to the shared cache when called before the first fetch
|
|
// completes (launch, background region-event wake).
|
|
self.stations = stations.isEmpty ? FuelStore.loadStations() : stations
|
|
self.favourites = favourites.isEmpty
|
|
? FuelStore.loadFavourites().filter { $0.fuel == fuel }.map(\.station)
|
|
: favourites.filter { $0.fuel == fuel }.map(\.station)
|
|
self.fuel = fuel
|
|
self.radiusKM = radiusKM
|
|
|
|
refreshDebugStatus()
|
|
|
|
for region in manager.monitoredRegions {
|
|
manager.stopMonitoring(for: region)
|
|
}
|
|
monitoredStationIDs = []
|
|
|
|
guard enabled else { return }
|
|
|
|
// A successful re-registration pass resets any earlier failure so the
|
|
// Debug section only shows the CURRENT region problem.
|
|
lastRegionError = nil
|
|
|
|
// Favourites first (guaranteed slots), then closest stations, max 18.
|
|
// `self.favourites` is already filtered to the monitored fuel.
|
|
var candidates: [FuelStation] = self.favourites
|
|
let favIDs = Set(self.favourites.map(\.id))
|
|
let location = FuelStore.loadLocation()
|
|
let others = stations
|
|
.filter { !favIDs.contains($0.id) }
|
|
.sorted { lhs, rhs in
|
|
guard let location else { return false }
|
|
return lhs.distanceKM(to: location.lat, lng2: location.lng) <
|
|
rhs.distanceKM(to: location.lat, lng2: location.lng)
|
|
}
|
|
candidates.append(contentsOf: others)
|
|
|
|
var registered: [String] = []
|
|
// Trigger radius = the ALERT radius (approach heads-up), not a tiny
|
|
// forecourt fence: entering the winner's region means you're within
|
|
// the alert radius of it, and the notification fires as you approach.
|
|
// Clamp to the device's region-monitoring ceiling — registering a
|
|
// larger region fails (kCLErrorRegionMonitoringFailure) or is reduced.
|
|
let maxRegion = manager.maximumRegionMonitoringDistance
|
|
let triggerRadius = maxRegion > 0 ? min(radiusKM * 1000, maxRegion) : radiusKM * 1000
|
|
for station in candidates.prefix(18) where station.prices[fuel] != nil {
|
|
let region = CLCircularRegion(
|
|
center: CLLocationCoordinate2D(latitude: station.lat, longitude: station.lng),
|
|
radius: triggerRadius,
|
|
identifier: station.id
|
|
)
|
|
region.notifyOnEntry = true
|
|
region.notifyOnExit = false
|
|
manager.startMonitoring(for: region)
|
|
registered.append(station.id)
|
|
}
|
|
monitoredStationIDs = registered
|
|
}
|
|
|
|
func setEnabled(_ enabled: Bool) {
|
|
self.enabled = enabled
|
|
if !enabled {
|
|
for region in manager.monitoredRegions {
|
|
manager.stopMonitoring(for: region)
|
|
}
|
|
monitoredStationIDs = []
|
|
} else {
|
|
requestPermissions()
|
|
// Re-register geofences from restored cache immediately.
|
|
update(stations: stations, favourites: FuelStore.loadFavourites(), fuel: fuel, radiusKM: radiusKM)
|
|
}
|
|
}
|
|
|
|
var isEnabled: Bool { enabled }
|
|
|
|
/// Records a stage in the live alert trace, newest first, capped at 8.
|
|
private func logAlert(_ kind: AlertLogEntry.Kind, _ text: String) {
|
|
alertLog.insert(AlertLogEntry(date: Date(), kind: kind, text: text), at: 0)
|
|
if alertLog.count > 8 { alertLog.removeLast() }
|
|
}
|
|
|
|
/// Recomputes the Settings → Debug location snapshot from current state.
|
|
/// "In range" uses the SAME criteria as live alerts: stations selling the
|
|
/// monitored fuel within the alert radius of the last known location.
|
|
func refreshDebugStatus() {
|
|
guard let fix = FuelStore.loadLocationWithDate() else {
|
|
debugStatus = DebugLocationStatus(
|
|
coordinate: nil, fixAge: nil,
|
|
fuel: fuel, radiusKM: radiusKM,
|
|
inRangeCount: 0, cheapestInRange: nil, cheapestDistanceKM: nil)
|
|
return
|
|
}
|
|
let sellers = stations.filter { $0.prices[fuel] != nil }
|
|
let inRange = sellers.filter {
|
|
$0.distanceKM(to: fix.coordinate.lat, lng2: fix.coordinate.lng) <= radiusKM
|
|
}
|
|
let cheapest = inRange.min { ($0.prices[fuel] ?? .infinity) < ($1.prices[fuel] ?? .infinity) }
|
|
let cheapestDistance = cheapest.map {
|
|
$0.distanceKM(to: fix.coordinate.lat, lng2: fix.coordinate.lng)
|
|
}
|
|
debugStatus = DebugLocationStatus(
|
|
coordinate: fix.coordinate,
|
|
fixAge: Date().timeIntervalSince(fix.date),
|
|
fuel: fuel, radiusKM: radiusKM,
|
|
inRangeCount: inRange.count,
|
|
cheapestInRange: cheapest, cheapestDistanceKM: cheapestDistance)
|
|
}
|
|
|
|
private func requestPermissions() {
|
|
// Region monitoring needs Always location for background delivery.
|
|
// Never request WhenInUse and Always back-to-back — iOS ignores the
|
|
// second call while the first prompt is pending, leaving the app
|
|
// stuck on WhenInUse and background geofence entries undelivered.
|
|
// Escalation happens in locationManagerDidChangeAuthorization:
|
|
// WhenInUse granted -> request Always -> re-register on grant.
|
|
switch manager.authorizationStatus {
|
|
case .notDetermined:
|
|
manager.requestWhenInUseAuthorization()
|
|
case .authorizedWhenInUse:
|
|
manager.requestAlwaysAuthorization()
|
|
default:
|
|
break
|
|
}
|
|
UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { _, _ in }
|
|
}
|
|
|
|
func locationManagerDidChangeAuthorization(_ manager: CLLocationManager) {
|
|
switch manager.authorizationStatus {
|
|
case .authorizedWhenInUse:
|
|
// Escalate: background region delivery (the whole point of
|
|
// alerts) requires Always. iOS shows the upgrade prompt here.
|
|
manager.requestAlwaysAuthorization()
|
|
case .authorizedAlways:
|
|
// Regions registered under WhenInUse-only won't deliver in the
|
|
// background; re-register now that Always is granted. (ContentView's
|
|
// LocationManager separately restarts significant-change tracking
|
|
// on its own delegate callback, so the region window follows the
|
|
// user in the background.)
|
|
update(stations: stations, favourites: FuelStore.loadFavourites(),
|
|
fuel: fuel, radiusKM: radiusKM)
|
|
default:
|
|
break
|
|
}
|
|
}
|
|
|
|
// MARK: - Region events
|
|
|
|
nonisolated func locationManager(_ manager: CLLocationManager, didEnterRegion region: CLRegion) {
|
|
Task { @MainActor in
|
|
// Trace: prove the geofence event itself arrived. This is the
|
|
// single point that distinguishes "no region delivery" from
|
|
// "delivery fine, a gate blocked the alert".
|
|
self.regionEventCount += 1
|
|
self.logAlert(.entry, "didEnterRegion — \(region.identifier)")
|
|
self.handleEntry(region)
|
|
}
|
|
}
|
|
|
|
nonisolated func locationManager(_ manager: CLLocationManager, didFailWithError error: Error) {
|
|
// Ignore — alerts still work while the app is open.
|
|
}
|
|
|
|
nonisolated func locationManager(
|
|
_ manager: CLLocationManager,
|
|
monitoringDidFailFor region: CLRegion?,
|
|
withError error: Error
|
|
) {
|
|
Task { @MainActor in
|
|
// Surface region-registration failures instead of swallowing
|
|
// them: a failed startMonitoring (region budget, auth, radius)
|
|
// means alerts silently stop. Cleared on the next successful
|
|
// re-registration (update() resets it).
|
|
lastRegionError = "\(region?.identifier ?? "?") · \(error.localizedDescription)"
|
|
}
|
|
}
|
|
|
|
private func handleEntry(_ region: CLRegion) {
|
|
let stationID = region.identifier
|
|
// Fall back to cached data on background wake (stations may not be
|
|
// fetched yet when the app is relaunched by a region event).
|
|
if stations.isEmpty { stations = FuelStore.loadStations() }
|
|
guard let station = stations.first(where: { $0.id == stationID }) else {
|
|
logAlert(.gate, "region \(stationID) — station not in loaded list (Stations tab not fetched yet?)")
|
|
return
|
|
}
|
|
|
|
// Dedup: one alert per station per hour.
|
|
if let last = lastNotified[stationID], Date().timeIntervalSince(last) < 3600 {
|
|
logAlert(.gate, "\(station.name) — dedup: already alerted \(Int(Date().timeIntervalSince(last) / 60)) min ago")
|
|
return
|
|
}
|
|
|
|
Task {
|
|
do {
|
|
// Fresh prices around the entered station (alert radius in km).
|
|
let fresh = try await FuelPriceProvider.active.fetchStations(
|
|
near: station.lat, lng: station.lng, fuel: fuel,
|
|
radiusKM: max(radiusKM, 10) // fetch wider than trigger radius
|
|
)
|
|
let withinRadius = fresh.filter {
|
|
$0.prices[fuel] != nil &&
|
|
$0.distanceKM(to: station.lat, lng2: station.lng) <= radiusKM
|
|
}
|
|
guard let cheapest = withinRadius.min(by: { $0.prices[fuel]! < $1.prices[fuel]! }) else {
|
|
logAlert(.gate, "\(station.name) — no \(fuel.displayName.lowercased()) sellers within \(String(format: "%.1f", radiusKM)) km after fresh fetch")
|
|
return
|
|
}
|
|
guard cheapest.id == station.id else {
|
|
logAlert(.gate, "\(station.name) — not cheapest: \(cheapest.name) at \(String(format: "%.1fp", cheapest.prices[fuel]!)) is cheaper within the radius")
|
|
return
|
|
}
|
|
// withinRadius guarantees the fuel exists on every candidate.
|
|
guard let price = cheapest.prices[fuel] else { return }
|
|
|
|
// Ties: all stations in radius at the same cheapest price.
|
|
let tied = FuelStore.tiedStations(
|
|
in: withinRadius, fuel: fuel, price: price,
|
|
fromLat: station.lat, lng: station.lng
|
|
)
|
|
|
|
fireAlert(for: cheapest, price: price, ties: tied)
|
|
lastNotified[stationID] = Date()
|
|
} catch {
|
|
// Trace the silent catch — a relay failure drops the alert
|
|
// with no banner, which previously looked like "no alert".
|
|
logAlert(.error, "\(station.name) — fresh-price fetch failed: \(error.localizedDescription)")
|
|
}
|
|
}
|
|
}
|
|
|
|
private func fireAlert(for station: FuelStation, price: Double, ties: [FuelStation] = []) {
|
|
let brand = station.brand.isEmpty ? station.name : station.brand
|
|
let unit = FuelStore.loadDistanceUnit()
|
|
let location = FuelStore.loadLocation()
|
|
let distanceText: String = {
|
|
guard let location else { return unit.format(0) }
|
|
return unit.format(station.distanceKM(to: location.lat, lng2: location.lng))
|
|
}()
|
|
let content = UNMutableNotificationContent()
|
|
content.sound = .default
|
|
|
|
// When several stations share the cheapest price, offer each as an
|
|
// action button so the user can pick which to get directions to.
|
|
let choices = ties.map { tie in
|
|
let tieDistance: String = {
|
|
guard let location else { return unit.format(0) }
|
|
return unit.format(tie.distanceKM(to: location.lat, lng2: location.lng))
|
|
}()
|
|
return TieChoice(station: tie, buttonTitle: "\(tie.name) · \(tieDistance)")
|
|
}
|
|
|
|
if choices.count > 1 {
|
|
content.title = "Cheapest \(fuel.displayName) nearby: \(choices.count) stations"
|
|
content.body = "\(choices.count) stations at \(String(format: "%.1fp", price)) within \(unit.format(radiusKM)). Pick one for directions."
|
|
addAlertRequest(content: content, station: station, ties: choices)
|
|
} else {
|
|
content.title = "Cheapest \(fuel.displayName) nearby: \(brand)"
|
|
content.body = "\(station.name) · \(distanceText) away · \(String(format: "%.1fp", price)). Tap for directions."
|
|
addAlertRequest(content: content, station: station)
|
|
}
|
|
logAlert(.fired, "alert scheduled — \(brand) · \(String(format: "%.1fp", price))")
|
|
lastAlert = "\(brand) · \(String(format: "%.1fp", price)) · \(distanceText) away"
|
|
}
|
|
|
|
/// Adds a notification whose tap opens directions to `station`. The
|
|
/// station's coordinates ride in `userInfo` so the tap handler can route
|
|
/// to Apple Maps (or an in-app fallback), and a map snapshot with a pin is
|
|
/// attached so the expanded notification shows where the station is.
|
|
/// `mapStatus` reports whether the snapshot attached (or why not), so the
|
|
/// test UI can show it instead of failing silently.
|
|
///
|
|
/// When `ties` is non-empty (several stations share the cheapest price), a
|
|
/// dynamic UNNotificationCategory with up to 4 action buttons is registered
|
|
/// — one per tied station — and the tie list rides in `userInfo` so the tap
|
|
/// handler can resolve which station an action button refers to.
|
|
private func addAlertRequest(
|
|
content: UNMutableNotificationContent,
|
|
station: FuelStation,
|
|
ties: [TieChoice] = [],
|
|
mapStatus: ((String) -> Void)? = nil
|
|
) {
|
|
content.userInfo = [
|
|
"stationName": station.name,
|
|
"stationLat": station.lat,
|
|
"stationLng": station.lng,
|
|
]
|
|
if !ties.isEmpty {
|
|
content.userInfo["tieStations"] = ties.map { tie in
|
|
[
|
|
"name": tie.station.name,
|
|
"lat": tie.station.lat,
|
|
"lng": tie.station.lng,
|
|
]
|
|
}
|
|
}
|
|
let identifier = UUID().uuidString
|
|
|
|
// Tie case: no map. A snapshot would only show one arbitrary station
|
|
// (the primary), which is misleading — the user must pick from the
|
|
// action buttons. Deliver immediately with the choice buttons.
|
|
if !ties.isEmpty {
|
|
self.registerTieCategory(identifier: identifier, ties: ties)
|
|
content.categoryIdentifier = "tie-\(identifier)"
|
|
mapStatus?("map: none (tie — pick a station)")
|
|
UNUserNotificationCenter.current().add(
|
|
UNNotificationRequest(identifier: identifier, content: content, trigger: nil)
|
|
)
|
|
return
|
|
}
|
|
|
|
// Single-station case: render the map FIRST, then deliver ONE
|
|
// notification with the map attached. (Earlier, delivering
|
|
// immediately and "replacing" via a second add() showed up as two
|
|
// notifications in LiveContainer — the replace-in-place contract
|
|
// isn't honoured there.) A timeout guarantees the alert still fires,
|
|
// without the map, if the snapshot hangs.
|
|
mapStatus?("map: preparing…")
|
|
|
|
let options = MKMapSnapshotter.Options()
|
|
options.region = MKCoordinateRegion(
|
|
center: CLLocationCoordinate2D(latitude: station.lat, longitude: station.lng),
|
|
span: MKCoordinateSpan(latitudeDelta: 0.02, longitudeDelta: 0.02)
|
|
)
|
|
options.size = CGSize(width: 800, height: 400)
|
|
options.mapType = .standard
|
|
let snapshotter = MKMapSnapshotter(options: options)
|
|
|
|
var finished = false
|
|
let deliver: (String) -> Void = { status in
|
|
guard !finished else { return }
|
|
finished = true
|
|
mapStatus?(status)
|
|
UNUserNotificationCenter.current().add(
|
|
UNNotificationRequest(identifier: identifier, content: content, trigger: nil)
|
|
)
|
|
}
|
|
|
|
// Timeout so a hung snapshot can't leave the alert undelivered (and
|
|
// the result line stuck on "preparing") forever.
|
|
let timeout = DispatchWorkItem {
|
|
Task { @MainActor in
|
|
deliver("map: timed out — no image")
|
|
}
|
|
}
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 10, execute: timeout)
|
|
|
|
snapshotter.start { [content] snapshot, error in
|
|
timeout.cancel()
|
|
Task { @MainActor in
|
|
var status = "map: no image"
|
|
if let snapshot, error == nil,
|
|
let image = Self.mapImage(snapshot: snapshot, station: station) {
|
|
let url = FileManager.default.temporaryDirectory
|
|
.appendingPathComponent("alert-map-\(UUID().uuidString).png")
|
|
if let data = image.pngData(), (try? data.write(to: url)) != nil,
|
|
let attachment = try? UNNotificationAttachment(identifier: "map", url: url, options: nil) {
|
|
content.attachments = [attachment]
|
|
status = "map: attached"
|
|
}
|
|
} else if let error {
|
|
status = "map: snapshot failed (\(error.localizedDescription))"
|
|
}
|
|
deliver(status)
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Registers (or updates) a notification category whose action buttons are
|
|
/// the tied stations, capped at the 4 the system shows. Categories are
|
|
/// accumulated so prior registrations are never dropped.
|
|
private func registerTieCategory(identifier: String, ties: [TieChoice]) {
|
|
let actions = ties.prefix(4).enumerated().map { index, tie in
|
|
UNNotificationAction(
|
|
identifier: "tie_\(index)",
|
|
title: tie.buttonTitle,
|
|
options: [.foreground]
|
|
)
|
|
}
|
|
let category = UNNotificationCategory(
|
|
identifier: "tie-\(identifier)",
|
|
actions: Array(actions),
|
|
intentIdentifiers: [],
|
|
options: []
|
|
)
|
|
tieCategories.insert(category)
|
|
UNUserNotificationCenter.current().setNotificationCategories(tieCategories)
|
|
}
|
|
|
|
/// Draws a red pin on the map snapshot at the station's location.
|
|
private static func mapImage(snapshot: MKMapSnapshotter.Snapshot, station: FuelStation) -> UIImage? {
|
|
let image = snapshot.image
|
|
let point = snapshot.point(for: CLLocationCoordinate2D(latitude: station.lat, longitude: station.lng))
|
|
let renderer = UIGraphicsImageRenderer(size: image.size)
|
|
return renderer.image { context in
|
|
image.draw(at: .zero)
|
|
let pinSize = CGSize(width: 36, height: 36)
|
|
let pinRect = CGRect(x: point.x - pinSize.width / 2, y: point.y - pinSize.height, width: pinSize.width, height: pinSize.height)
|
|
let pin = UIImage(systemName: "mappin.circle.fill")?
|
|
.withTintColor(.systemRed, renderingMode: .alwaysTemplate)
|
|
pin?.draw(in: pinRect)
|
|
}
|
|
}
|
|
|
|
/// Fires a test alert built from REAL data: the cheapest station selling
|
|
/// the monitored fuel within the configured alert radius of the current
|
|
/// location — the same criteria a live geofence entry would apply, minus
|
|
/// the geofence itself. Uses the monitor's live state (fuel, radius,
|
|
/// stations) so the notification reflects the Alerts-tab configuration.
|
|
func sendTestNotification() {
|
|
let unit = FuelStore.loadDistanceUnit()
|
|
let location = FuelStore.loadLocation()
|
|
let sellers = stations.filter { $0.prices[fuel] != nil }
|
|
|
|
// Cheapest within radius, judged around the current location —
|
|
// identical to handleEntry's withinRadius logic.
|
|
let inRadius = sellers.filter { station in
|
|
guard let location else { return true }
|
|
return station.distanceKM(to: location.lat, lng2: location.lng) <= radiusKM
|
|
}
|
|
let candidate = inRadius.min { ($0.prices[fuel] ?? .infinity) < ($1.prices[fuel] ?? .infinity) }
|
|
|
|
if let candidate, let price = candidate.prices[fuel] {
|
|
let brand = candidate.brand.isEmpty ? candidate.name : candidate.brand
|
|
let distanceText: String = {
|
|
guard let location else { return unit.format(0) }
|
|
return unit.format(candidate.distanceKM(to: location.lat, lng2: location.lng))
|
|
}()
|
|
let content = UNMutableNotificationContent()
|
|
content.sound = .default
|
|
|
|
// Ties: every station in radius at the same cheapest price, sorted
|
|
// nearest first. If more than one, offer them as action buttons.
|
|
let tieLat = location?.lat ?? candidate.lat
|
|
let tieLng = location?.lng ?? candidate.lng
|
|
let tied = FuelStore.tiedStations(
|
|
in: inRadius, fuel: fuel, price: price,
|
|
fromLat: tieLat, lng: tieLng
|
|
)
|
|
let choices = tied.map { station in
|
|
let tieDistance: String = {
|
|
guard let location else { return unit.format(0) }
|
|
return unit.format(station.distanceKM(to: location.lat, lng2: location.lng))
|
|
}()
|
|
return TieChoice(station: station, buttonTitle: "\(station.name) · \(tieDistance)")
|
|
}
|
|
|
|
if choices.count > 1 {
|
|
content.title = "Cheapest \(fuel.displayName) nearby: \(choices.count) stations"
|
|
content.body = "\(choices.count) stations at \(String(format: "%.1fp", price)) within \(unit.format(radiusKM)). Pick one for directions."
|
|
let baseResult = "\(fuel.displayName) · \(choices.count) tied at \(String(format: "%.1fp", price)) · radius \(unit.format(radiusKM))"
|
|
lastTestResult = baseResult
|
|
addAlertRequest(content: content, station: candidate, ties: choices) { status in
|
|
self.lastTestResult = "\(baseResult) · \(status)"
|
|
}
|
|
} else {
|
|
content.title = "Cheapest \(fuel.displayName) nearby: \(brand)"
|
|
content.body = "\(candidate.name) · \(distanceText) away · \(String(format: "%.1fp", price)). Tap for directions."
|
|
let baseResult = "\(fuel.displayName) · \(brand) · \(String(format: "%.1fp", price)) · \(distanceText) away · radius \(unit.format(radiusKM))"
|
|
lastTestResult = baseResult
|
|
addAlertRequest(content: content, station: candidate) { status in
|
|
self.lastTestResult = "\(baseResult) · \(status)"
|
|
}
|
|
}
|
|
} else {
|
|
// No real candidate (no stations loaded yet, or none sell the
|
|
// monitored fuel) — still fire so delivery is testable, but say
|
|
// why the real criteria found nothing.
|
|
let content = UNMutableNotificationContent()
|
|
content.title = "FuelBoard test alert"
|
|
content.body = sellers.isEmpty
|
|
? "No station data loaded yet — open the Stations tab first, then retry."
|
|
: "No \(fuel.displayName.lowercased()) station within \(unit.format(radiusKM)) of you."
|
|
content.sound = .default
|
|
let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
|
|
UNUserNotificationCenter.current().add(request)
|
|
lastTestResult = sellers.isEmpty
|
|
? "No stations loaded — open the Stations tab first"
|
|
: "No \(fuel.displayName.lowercased()) seller within \(unit.format(radiusKM))"
|
|
}
|
|
}
|
|
|
|
/// Fires a notification with NO criteria checks at all — no geofence, no
|
|
/// cheapest-within-radius, no dedup, no permission gate, no fuel/radius
|
|
/// coupling. Still carries a REAL station (the nearest one selling the
|
|
/// monitored fuel) with its real name, price, distance and coordinates, so
|
|
/// the tap action — directions to that station — is testable regardless of
|
|
/// every alert condition. If notifications are denied system-wide nothing
|
|
/// can display, but this fires regardless of every FuelBoard condition.
|
|
func sendPlainTestNotification() {
|
|
let unit = FuelStore.loadDistanceUnit()
|
|
let location = FuelStore.loadLocation()
|
|
let sellers = stations.filter { $0.prices[fuel] != nil }
|
|
let nearest = sellers.min { lhs, rhs in
|
|
let ld = location.map { lhs.distanceKM(to: $0.lat, lng2: $0.lng) } ?? 0
|
|
let rd = location.map { rhs.distanceKM(to: $0.lat, lng2: $0.lng) } ?? 0
|
|
return ld < rd
|
|
}
|
|
|
|
let content = UNMutableNotificationContent()
|
|
if let nearest, let price = nearest.prices[fuel] {
|
|
let brand = nearest.brand.isEmpty ? nearest.name : nearest.brand
|
|
let distanceText: String = {
|
|
guard let location else { return unit.format(0) }
|
|
return unit.format(nearest.distanceKM(to: location.lat, lng2: location.lng))
|
|
}()
|
|
content.title = "\(brand) — plain test notification"
|
|
content.body = "\(nearest.name) · \(distanceText) away · \(String(format: "%.1fp", price)). Tap for directions."
|
|
content.sound = .default
|
|
addAlertRequest(content: content, station: nearest)
|
|
} else {
|
|
content.title = "FuelBoard test notification"
|
|
content.body = "No station data loaded yet — open the Stations tab first."
|
|
content.sound = .default
|
|
let request = UNNotificationRequest(identifier: UUID().uuidString, content: content, trigger: nil)
|
|
UNUserNotificationCenter.current().add(request)
|
|
}
|
|
}
|
|
|
|
// MARK: - Notification presentation + tap
|
|
|
|
/// Show alert banners even while FuelBoard is in the foreground — without
|
|
/// this, the system silently suppresses notifications when the app is open.
|
|
nonisolated func userNotificationCenter(
|
|
_ center: UNUserNotificationCenter,
|
|
willPresent notification: UNNotification,
|
|
withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void
|
|
) {
|
|
Task { @MainActor in
|
|
completionHandler([.banner, .sound])
|
|
}
|
|
}
|
|
|
|
/// Tapping a notification opens Apple Maps directions to the station from
|
|
/// the user's current location. If Apple Maps can't be opened (e.g. inside
|
|
/// LiveContainer), an in-app map sheet with directions is shown instead.
|
|
///
|
|
/// When the notification carried tie-choice action buttons, the tapped
|
|
/// button's identifier ("tie_0", "tie_1", …) selects the corresponding
|
|
/// station from userInfo["tieStations"]. Tapping the body of a tie
|
|
/// notification does NOT open directions — nothing has been chosen yet;
|
|
/// only the option buttons make a choice.
|
|
nonisolated func userNotificationCenter(
|
|
_ center: UNUserNotificationCenter,
|
|
didReceive response: UNNotificationResponse,
|
|
withCompletionHandler completionHandler: @escaping () -> Void
|
|
) {
|
|
let userInfo = response.notification.request.content.userInfo
|
|
let isTie = userInfo["tieStations"] != nil
|
|
let name = userInfo["stationName"] as? String
|
|
let lat = userInfo["stationLat"] as? Double
|
|
let lng = userInfo["stationLng"] as? Double
|
|
Task { @MainActor in
|
|
if response.actionIdentifier.hasPrefix("tie_"),
|
|
let index = Int(response.actionIdentifier.dropFirst(4)),
|
|
let ties = userInfo["tieStations"] as? [[String: Any]],
|
|
ties.indices.contains(index),
|
|
let tieName = ties[index]["name"] as? String,
|
|
let tieLat = ties[index]["lat"] as? Double,
|
|
let tieLng = ties[index]["lng"] as? Double {
|
|
openDirections(to: tieName, latitude: tieLat, longitude: tieLng)
|
|
} else if !isTie, let name, let lat, let lng {
|
|
openDirections(to: name, latitude: lat, longitude: lng)
|
|
}
|
|
// Tie body tap: intentionally no directions — the user must pick
|
|
// an option button to choose a station.
|
|
completionHandler()
|
|
}
|
|
}
|
|
|
|
/// Opens Apple Maps with driving directions to the station; falls back to
|
|
/// the in-app map sheet when the hand-off fails.
|
|
@MainActor
|
|
private func openDirections(to name: String, latitude: Double, longitude: Double) {
|
|
let query = name.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed) ?? ""
|
|
guard let url = URL(string: "maps://?daddr=\(latitude),\(longitude)&q=\(query)") else {
|
|
pendingStationMap = StationMapRequest(name: name, latitude: latitude, longitude: longitude)
|
|
return
|
|
}
|
|
UIApplication.shared.open(url) { opened in
|
|
Task { @MainActor in
|
|
if !opened {
|
|
self.pendingStationMap = StationMapRequest(name: name, latitude: latitude, longitude: longitude)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|