|
| 1 | +// LoopFollow |
| 2 | +// VolumeButtonHandler.swift |
| 3 | + |
| 4 | +import AVFoundation |
| 5 | +import Combine |
| 6 | +import Foundation |
| 7 | +import UIKit |
| 8 | + |
| 9 | +class VolumeButtonHandler: NSObject { |
| 10 | + static let shared = VolumeButtonHandler() |
| 11 | + |
| 12 | + // Volume button snoozer activation delay in seconds |
| 13 | + private let volumeButtonActivationDelay: TimeInterval = 0.9 |
| 14 | + |
| 15 | + // Volume button detection parameters |
| 16 | + private let volumeButtonPressThreshold: Float = 0.02 |
| 17 | + private let volumeButtonPressTimeWindow: TimeInterval = 0.3 |
| 18 | + private let volumeButtonCooldown: TimeInterval = 0.5 |
| 19 | + |
| 20 | + // KVO observer for system volume |
| 21 | + private var volumeObserver: NSKeyValueObservation? |
| 22 | + |
| 23 | + private var lastVolume: Float = 0.0 |
| 24 | + private var isMonitoring = false |
| 25 | + private var alarmStartTime: Date? |
| 26 | + private var lastVolumeButtonPressTime: Date? |
| 27 | + |
| 28 | + // Button press detection |
| 29 | + private var recentVolumeChanges: [(volume: Float, timestamp: Date)] = [] |
| 30 | + private var lastSignificantVolumeChange: Date? |
| 31 | + private var volumeChangePattern: [TimeInterval] = [] |
| 32 | + |
| 33 | + private var cancellables = Set<AnyCancellable>() |
| 34 | + |
| 35 | + override private init() { |
| 36 | + super.init() |
| 37 | + |
| 38 | + Observable.shared.alarmSoundPlaying.$value |
| 39 | + .removeDuplicates() |
| 40 | + .sink { [weak self] alarmSoundPlaying in |
| 41 | + guard let self = self else { return } |
| 42 | + if alarmSoundPlaying { |
| 43 | + self.alarmStarted() |
| 44 | + } else { |
| 45 | + self.alarmStopped() |
| 46 | + } |
| 47 | + } |
| 48 | + .store(in: &cancellables) |
| 49 | + } |
| 50 | + |
| 51 | + private func recordVolumeChange(currentVolume: Float, timestamp: Date) { |
| 52 | + recentVolumeChanges.append((volume: currentVolume, timestamp: timestamp)) |
| 53 | + |
| 54 | + let cutoffTime = timestamp.timeIntervalSinceReferenceDate - volumeButtonPressTimeWindow |
| 55 | + recentVolumeChanges = recentVolumeChanges.filter { $0.timestamp.timeIntervalSinceReferenceDate > cutoffTime } |
| 56 | + |
| 57 | + if let lastChange = lastSignificantVolumeChange { |
| 58 | + let timeSinceLastChange = timestamp.timeIntervalSince(lastChange) |
| 59 | + volumeChangePattern.append(timeSinceLastChange) |
| 60 | + |
| 61 | + if volumeChangePattern.count > 5 { |
| 62 | + volumeChangePattern.removeFirst() |
| 63 | + } |
| 64 | + } |
| 65 | + lastSignificantVolumeChange = timestamp |
| 66 | + } |
| 67 | + |
| 68 | + private func isLikelyVolumeButtonPress(volumeDifference: Float, timestamp: Date) -> Bool { |
| 69 | + let isReasonableChange = volumeDifference >= 0.03 && volumeDifference <= 0.12 |
| 70 | + let isDiscreteChange = recentVolumeChanges.count <= 2 |
| 71 | + let hasConsistentTiming = volumeChangePattern.isEmpty || volumeChangePattern.last! >= 0.15 |
| 72 | + let isNotRapidSequence = recentVolumeChanges.count < 3 || |
| 73 | + (recentVolumeChanges.count >= 3 && |
| 74 | + recentVolumeChanges.suffix(3).map { $0.timestamp.timeIntervalSinceReferenceDate }.enumerated().dropFirst().allSatisfy { index, timestamp in |
| 75 | + let previousTimestamp = recentVolumeChanges.suffix(3).map { $0.timestamp.timeIntervalSinceReferenceDate }[index - 1] |
| 76 | + return timestamp - previousTimestamp > 0.08 |
| 77 | + }) |
| 78 | + |
| 79 | + return isReasonableChange && isDiscreteChange && hasConsistentTiming && isNotRapidSequence |
| 80 | + } |
| 81 | + |
| 82 | + private func snoozeActiveAlarm() { |
| 83 | + LogManager.shared.log(category: .volumeButtonSnooze, message: "Snoozing alarm") |
| 84 | + |
| 85 | + lastVolumeButtonPressTime = Date() |
| 86 | + AlarmManager.shared.performSnooze() |
| 87 | + |
| 88 | + let impactFeedback = UIImpactFeedbackGenerator(style: .medium) |
| 89 | + impactFeedback.impactOccurred() |
| 90 | + } |
| 91 | + |
| 92 | + private func alarmStarted() { |
| 93 | + guard Storage.shared.alarmConfiguration.value.enableVolumeButtonSnooze else { return } |
| 94 | + LogManager.shared.log(category: .volumeButtonSnooze, message: "Alarm start detected, setting up volume observer.") |
| 95 | + |
| 96 | + alarmStartTime = Date() |
| 97 | + recentVolumeChanges.removeAll() |
| 98 | + lastSignificantVolumeChange = nil |
| 99 | + volumeChangePattern.removeAll() |
| 100 | + |
| 101 | + startMonitoring() |
| 102 | + } |
| 103 | + |
| 104 | + private func alarmStopped() { |
| 105 | + LogManager.shared.log(category: .volumeButtonSnooze, message: "Alarm stop detected") |
| 106 | + |
| 107 | + alarmStartTime = nil |
| 108 | + stopMonitoring() |
| 109 | + |
| 110 | + recentVolumeChanges.removeAll() |
| 111 | + lastSignificantVolumeChange = nil |
| 112 | + volumeChangePattern.removeAll() |
| 113 | + } |
| 114 | + |
| 115 | + func startMonitoring() { |
| 116 | + guard !isMonitoring else { return } |
| 117 | + |
| 118 | + isMonitoring = true |
| 119 | + |
| 120 | + volumeObserver = AVAudioSession.sharedInstance().observe(\.outputVolume, options: [.new]) { [weak self] session, _ in |
| 121 | + guard let self = self, let alarmStartTime = self.alarmStartTime else { return } |
| 122 | + |
| 123 | + let currentVolume = session.outputVolume |
| 124 | + let now = Date() |
| 125 | + |
| 126 | + // On the first observation, capture the initial volume when the audio session |
| 127 | + // becomes active. This solves the race condition. We then return to avoid |
| 128 | + // treating this initial setup as a user-initiated button press. |
| 129 | + if self.lastVolume == 0.0, currentVolume > 0.0 { |
| 130 | + LogManager.shared.log(category: .volumeButtonSnooze, message: "Observer received initial valid volume: \(currentVolume)") |
| 131 | + self.lastVolume = currentVolume |
| 132 | + return |
| 133 | + } |
| 134 | + |
| 135 | + guard self.lastVolume > 0.0 else { return } |
| 136 | + |
| 137 | + let volumeDifference = abs(currentVolume - self.lastVolume) |
| 138 | + |
| 139 | + if volumeDifference > self.volumeButtonPressThreshold { |
| 140 | + let timeSinceAlarmStart = now.timeIntervalSince(alarmStartTime) |
| 141 | + |
| 142 | + // Ignore volume changes from the alarm system's own ramp-up. |
| 143 | + if timeSinceAlarmStart < 2.0, currentVolume > self.lastVolume { |
| 144 | + if volumeDifference <= 0.15, timeSinceAlarmStart < 1.5 { |
| 145 | + self.lastVolume = currentVolume |
| 146 | + return |
| 147 | + } |
| 148 | + } |
| 149 | + |
| 150 | + self.recordVolumeChange(currentVolume: currentVolume, timestamp: now) |
| 151 | + |
| 152 | + if timeSinceAlarmStart > self.volumeButtonActivationDelay { |
| 153 | + if let lastPress = self.lastVolumeButtonPressTime { |
| 154 | + let timeSinceLastPress = now.timeIntervalSince(lastPress) |
| 155 | + if timeSinceLastPress < self.volumeButtonCooldown { |
| 156 | + self.lastVolume = currentVolume |
| 157 | + return |
| 158 | + } |
| 159 | + } |
| 160 | + |
| 161 | + if self.isLikelyVolumeButtonPress(volumeDifference: volumeDifference, timestamp: now) { |
| 162 | + self.snoozeActiveAlarm() |
| 163 | + } |
| 164 | + } |
| 165 | + } |
| 166 | + self.lastVolume = currentVolume |
| 167 | + } |
| 168 | + } |
| 169 | + |
| 170 | + func stopMonitoring() { |
| 171 | + guard isMonitoring else { return } |
| 172 | + |
| 173 | + LogManager.shared.log(category: .volumeButtonSnooze, message: "Invalidating volume observer.") |
| 174 | + |
| 175 | + // Invalidate the observer to stop receiving notifications and prevent memory leaks. |
| 176 | + volumeObserver?.invalidate() |
| 177 | + volumeObserver = nil |
| 178 | + |
| 179 | + isMonitoring = false |
| 180 | + lastVolume = 0.0 // Reset for the next alarm. |
| 181 | + } |
| 182 | +} |
0 commit comments