How can I properly stop a 24-hour countdown timer in Swift?

Below is one way to stop the timer by keeping a reference to it and invalidating it when the countdown is finished.

Step 1. Define a Timer Property

Store the timer as a property in your view controller so that you can invalidate it when needed.

SWIFTCopied
class ViewController: UIViewController {
    var timer: Timer?
    
    override func viewDidLoad() {
        super.viewDidLoad()
        // Set up and start the timer, repeat every second
        timer = Timer.scheduledTimer(
            timeInterval: 1.0,
            target: self,
            selector: #selector(self.start),
            userInfo: nil,
            repeats: true
        )
    }
    
    @objc func start() {
        let countdownText = SLTimer().updateCountDown()
        saleButton.setTitle("\(countdownText)", for: .normal)
        
        // Invalidate the timer when the countdown reaches "stop"
        if countdownText == "stop" {
            timer?.invalidate()
            timer = nil
        }
    }
}

Step 2. Adjust Your Timer Logic

Your SLTimer class is recalculating a new date every time updateCountDown() is called. To prevent that (and get an accurate countdown), set the expiry date once (for instance when the sale starts) and then refer to it in each update.

Here’s one approach modifying your code:

SWIFTCopied
class SLTimer {
    // Store the final expiry date
    var expiryDate: Date?
    
    init(countdownDuration: Int) {
        // Set the expiry date once using the specified duration in seconds
        self.expiryDate = Calendar.current.date(byAdding: .second, value: countdownDuration, to: Date())
        // Alternatively, persist this date in UserDefaults if needed
    }
    
    func timeLeftExtended() -> String {
        guard let expiryDate = expiryDate else { return "" }
        
        let now = Date()
        let components = Calendar.current.dateComponents([.hour, .minute, .second], from: now, to: expiryDate)
        
        // Optional: You can safely unwrap component values or use default values
        let hours = components.hour ?? 0
        let minutes = components.minute ?? 0
        let seconds = components.second ?? 0
        
        return "\(hours) : \(minutes) : \(seconds)"
    }
    
    @objc func updateCountDown() -> String {
        guard let expiryDate = expiryDate else { return "" }
        
        // Check if the sale time is over
        if Date() >= expiryDate {
            return "stop"
        } else {
            return self.timeLeftExtended()
        }
    }
}

And then in your view controller you can create and use an instance of SLTimer:

SWIFTCopied
class ViewController: UIViewController {
    var timer: Timer?
    let saleTimer = SLTimer(countdownDuration: 35) // For testing with 35 seconds
    
    override func viewDidLoad() {
        super.viewDidLoad()
        timer = Timer.scheduledTimer(
            timeInterval: 1.0,
            target: self,
            selector: #selector(self.start),
            userInfo: nil,
            repeats: true
        )
    }
    
    @objc func start() {
        let countdownText = saleTimer.updateCountDown()
        saleButton.setTitle("\(countdownText)", for: .normal)
        
        if countdownText == "stop" {
            timer?.invalidate()
            timer = nil
        }
    }
}

Summary

• Store the Timer: Keeping a reference to the Timer allows you to call invalidate() when needed.
• Invalidate Timer: When your countdown logic returns "stop" (or when the current time exceeds the expiry date), call timer.invalidate() and optionally clear the reference.
• Establish a Fixed Expiry Date: Instead of recalculating the expiry date on every tick, set it once and reuse it to get a consistent countdown.

This way, your timer is properly stopped once your 24-hour (or testing with 35 seconds) countdown completes.