Timer Stops When Phone Goes Into Airplane Mode, Won't Restart After Leaving AM

Question

OK. Looked through the possible answers, but I don't see my issue here.

I have a fairly bog-standard GCD repeating timer:

class RepeatingGCDTimer {
    /// This holds our current run state.
    private var state: _State = ._suspended

    /// This is the time between fires, in seconds.
    let timeInterval: TimeInterval
    /// This is the callback event handler we registered.
    var eventHandler: (() -> Void)?

    /* ############################################################## */
    /**
     This calculated property will create a new timer that repeats.

     It uses the current queue.
     */
    private lazy var timer: DispatchSourceTimer = {
        let t = DispatchSource.makeTimerSource()    // We make a generic, default timer source. No frou-frou.
        t.schedule(deadline: .now() + self.timeInterval, repeating: self.timeInterval)  // We tell it to repeat at our interval.
        t.setEventHandler(handler: { [unowned self] in  // This is the callback.
            self.eventHandler?()    // This just calls the event handler we registered.
        })
        return t
    }()

    /// This is used to hold state flags for internal use.
    private enum _State {
        /// The timer is currently paused.
        case _suspended
        /// The timer has been resumed, and is firing.
        case _resumed
    }

    /* ############################################################## */
    /**
     Default constructor

     - parameter timeInterval: The time (in seconds) between fires.
     */
    init(timeInterval inTimeInterval: TimeInterval) {
        self.timeInterval = inTimeInterval
    }

    /* ############################################################## */
    /**
     If the timer is not currently running, we resume. If running, nothing happens.
     */
    func resume() {
        if self.state == ._resumed {
            return
        }
        self.state = ._resumed
        self.timer.resume()
    }

    /* ############################################################## */
    /**
     If the timer is currently running, we suspend. If not running, nothing happens.
     */
    func suspend() {
        if self.state == ._suspended {
            return
        }
        self.state = ._suspended
        self.timer.suspend()
    }

    /* ############################################################## */
    /**
     We have to carefully dismantle this, as we can end up with crashes if we don't clean up properly.
     */
    deinit {
        self.timer.setEventHandler {}
        self.timer.cancel()
        self.resume()   // You need to call resume after canceling. I guess it lets the queue clean up.
        self.eventHandler = nil
    }
}

Works great!

...except when it doesn't.

That would be when I put the device into Airplane Mode.

At that point, the timer stops firing.

Even when I come out of Airplane Mode, the timer doesn't restart.

The app uses UIApplication.shared.isIdleTimerDisabled = true/false to keep the app awake, but that doesn't seem to keep the events coming.

Can anyone clue me into what's happening here, and how I might be able to work around it?

This app needs to work in Airplane Mode. In fact, it is most likely to be used in Airplane Mode.

Answer 1

OK. I think I solved this. As is often the case with these things, it's PEBCAK.

I have a routine that stops the timer when the app is backgrounded, and failed to put in a corresponding restart for when it is foregrounded.

When I slide up the Control Center, it backgrounds the app.

My bad.

Yeah, it's embarrassing, but I want to leave this question here as a warning to others.