react-native-audio-browser 0.2.0-next.2 → 0.2.0-next.21

package/ios/Model/NitroTypeStubs.swift

@@ -5,6 +5,12 @@
   /// These stubs declare `Equatable` for test ergonomics — the generated
   /// Nitro types do NOT. Shared `ios/` sources must not rely on conformances
   /// that exist only here: `swift test` compiles, the app build breaks.
+  ///
+  /// Property names and types ARE checked against `nitrogen/generated/ios/swift`
+  /// by `src/nitro-stub-drift.test.ts`, which runs in the JS CI job — neither
+  /// native job can see both files at once. Declaring fewer properties than the
+  /// real type is fine and deliberate; spelling one differently is what that
+  /// test catches. Conformances and default values are still on you.
 
   struct ArtworkVariants: Equatable {
     var light: String
@@ -23,19 +29,20 @@
   }
 
   struct Track: Equatable {
-    var id: String
-    var url: String?
+    var id: String?
+    var path: String?
     var src: String?
+    var artwork: Variant_String_ArtworkVariants?
+    var artworkSource: ImageSource?
     var request: TrackRequest?
     var title: String = ""
     var artist: String?
-    var albumUrl: String?
+    var albumPath: String?
     var album: String?
+    var style: TrackStyle?
+    var disabled: Bool?
     var live: Bool?
-    var artwork: Variant_String_ArtworkVariants?
-    var artworkSource: ImageSource?
-    var groupTitle: String?
-    var imageRow: [ImageRowItem]?
+    var icyCharset: String?
   }
 
   struct TrackLoadEvent {
@@ -63,14 +70,24 @@
     }
   }
 
+  enum HttpMethod {
+    case get
+    case post
+    case put
+    case patch
+    case delete
+    case head
+    case options
+  }
+
   struct ImageSource: Equatable {
     var uri: String
-    var method: String?
+    var method: HttpMethod?
     var headers: [String: String]?
     var body: String?
   }
 
-  enum TrackStyle {
+  enum StyleDisplay: Equatable {
     case list
     case grid
 
@@ -83,17 +100,105 @@
     }
   }
 
-  struct ImageRowItem: Equatable {
-    var id: String?
-    var url: String?
-    var src: String?
-    var artwork: String?
-    var artworkSource: ImageSource?
-    var title: String
+  enum ArtworkRendering: Equatable {
+    case original
+    case stencil
+
+    init?(fromString string: String) {
+      switch string {
+      case "original": self = .original
+      case "stencil": self = .stencil
+      default: return nil
+      }
+    }
+  }
+
+  enum ImageShape: Equatable {
+    case circular
+    case roundedRectangle
+
+    init?(fromString string: String) {
+      switch string {
+      case "circular": self = .circular
+      case "rounded-rectangle": self = .roundedRectangle
+      default: return nil
+      }
+    }
+  }
+
+  enum GridTile: Equatable {
+    case plain
+    case card
+    case condensed
+
+    init?(fromString string: String) {
+      switch string {
+      case "plain": self = .plain
+      case "card": self = .card
+      case "condensed": self = .condensed
+      default: return nil
+      }
+    }
+
+    // Mirrors the generated extension (nitrogen emits `stringValue` beside
+    // `init?(fromString:)` for every string-backed enum).
+    var stringValue: String {
+      switch self {
+      case .plain: "plain"
+      case .card: "card"
+      case .condensed: "condensed"
+      }
+    }
+  }
+
+  enum CardImage: Equatable {
+    case normal
+    case background
+
+    init?(fromString string: String) {
+      switch string {
+      case "normal": self = .normal
+      case "background": self = .background
+      default: return nil
+      }
+    }
+  }
+
+  struct TrackStyle: Equatable {
+    var display: StyleDisplay?
+    var artworkRendering: ArtworkRendering?
+    var imageShape: ImageShape?
+    var accessorySymbol: String?
+    var cardTint: String?
+    var cardImage: CardImage?
+  }
+
+  // Member order matches the generated init (own properties before inherited
+  // ones — Nitro flattens `extends` own-props-first): the memberwise init this
+  // produces must accept the same argument order as the real type, or
+  // `swift test` passes while the app build breaks on argument order.
+  struct SectionStyle: Equatable {
+    var gridWrap: Bool?
+    var gridTile: GridTile?
+    var display: StyleDisplay?
+    var artworkRendering: ArtworkRendering?
+    var imageShape: ImageShape?
+    var accessorySymbol: String?
+    var cardTint: String?
+    var cardImage: CardImage?
+  }
+
+  struct Section: Equatable {
+    var title: String?
+    var style: SectionStyle?
+    var path: String?
+    var children: [Track]
   }
 
   struct ResolvedTrack: Equatable {
-    var url: String
+    var path: String
+    var style: SectionStyle?
+    var sections: [Section]?
     var children: [Track]?
     var carPlaySiriListButton: CarPlaySiriListButtonPosition?
     var id: String?
@@ -101,21 +206,18 @@
     var artwork: Variant_String_ArtworkVariants?
     var artworkSource: ImageSource?
     var request: TrackRequest?
-    var artworkCarPlayTinted: Bool?
     var title: String
     var subtitle: String?
     var artist: String?
-    var albumUrl: String?
+    var albumPath: String?
     var album: String?
     var description: String?
     var genre: String?
     var duration: Double?
-    var style: TrackStyle?
-    var childrenStyle: TrackStyle?
+    var disabled: Bool?
     var favorited: Bool?
-    var groupTitle: String?
     var live: Bool?
-    var imageRow: [ImageRowItem]?
+    var icyCharset: String?
   }
 
   enum PlaybackState: Equatable {

package/ios/Model/PlayerUpdateOptions.swift

@@ -32,6 +32,9 @@ class PlayerUpdateOptions {
   /// Custom buttons for the CarPlay Now Playing screen
   var carPlayNowPlayingButtons: [CarPlayNowPlayingButton] = []
 
+  /// Where the now-playing indicator draws on CarPlay list rows
+  var carPlayPlayingIndicatorLocation: CarPlayPlayingIndicatorLocation = .leading
+
   // MARK: - Initialization
 
   init() {}
@@ -74,6 +77,9 @@ class PlayerUpdateOptions {
       if let buttons = ios.carPlayNowPlayingButtons {
         carPlayNowPlayingButtons = buttons
       }
+      if let location = ios.carPlayPlayingIndicatorLocation {
+        carPlayPlayingIndicatorLocation = location
+      }
     }
   }
 
@@ -92,6 +98,7 @@ class PlayerUpdateOptions {
         playbackRates: playbackRates,
         carPlayUpNextButton: carPlayUpNextButton,
         carPlayNowPlayingButtons: carPlayNowPlayingButtons,
+        carPlayPlayingIndicatorLocation: carPlayPlayingIndicatorLocation,
       ),
     )
   }

package/ios/Model/RemoteCommand.swift

@@ -48,6 +48,24 @@ enum RemoteCommand: CustomStringConvertible, Equatable {
 
   var key: String { description }
 
+  /**
+   Commands in `self` that are absent from `next` and so should be disabled.
+
+   Compared by `key`, not by `==`. `RemoteCommand` is `Equatable` including its
+   associated values, but every case with associated values maps onto a single
+   `MPRemoteCommand` addressed by `key`: `.skipForward([15])` and
+   `.skipForward([30])` are two different values of one command. Diffing by `==`
+   would report the old interval as removed and disable the command that the new
+   interval had just re-enabled.
+   */
+  static func commandsToDisable(
+    enabled: [RemoteCommand],
+    replacedBy next: [RemoteCommand],
+  ) -> [RemoteCommand] {
+    let nextKeys = Set(next.map(\.key))
+    return enabled.filter { !nextKeys.contains($0.key) }
+  }
+
   /**
    All values in an array for convenience.
    Don't use for associated values.

package/ios/Model/TrackPlayerError.swift

@@ -103,10 +103,10 @@ public extension TrackPlayerError.PlaybackError {
   static func kind(forHttpStatus status: Int) -> PlaybackErrorKind {
     switch status {
     case 404, 410: .notFound
-    case 500...599: .serverError
+    case 500 ... 599: .serverError
     // Every other 4xx is the server refusing us — auth, geo-blocking, a
     // rate limit. All of them mean "you can't have this stream", not "retry".
-    case 400...499: .rejected
+    case 400 ... 499: .rejected
     default: .unknown
     }
   }

package/ios/Option/SessionCategories.swift

@@ -99,7 +99,7 @@ extension NativeIOSSetupOptions {
     category: AVAudioSession.Category,
     mode: AVAudioSession.Mode,
     policy: AVAudioSession.RouteSharingPolicy,
-    options: AVAudioSession.CategoryOptions
+    options: AVAudioSession.CategoryOptions,
   ) {
     let category = self.category
       .flatMap { SessionCategory(rawValue: $0.stringValue) }?
@@ -113,7 +113,8 @@ extension NativeIOSSetupOptions {
     let options = (self.categoryOptions ?? [])
       .reduce(into: AVAudioSession.CategoryOptions()) { acc, option in
         if let mapped = SessionCategoryOptions(rawValue: option.stringValue)?
-          .mapConfigToAVAudioSessionCategoryOptions() {
+          .mapConfigToAVAudioSessionCategoryOptions()
+        {
           acc.insert(mapped)
         }
       }

package/ios/Player/MediaIntentCriteria.swift

@@ -43,7 +43,7 @@ public struct MediaIntentCriteria: Sendable {
     artist: String? = nil,
     album: String? = nil,
     title: String? = nil,
-    playlist: String? = nil
+    playlist: String? = nil,
   ) {
     self.query = query
     self.reference = reference
@@ -90,7 +90,7 @@ public struct MediaIntentCriteria: Sendable {
     mediaTypeMode: String?,
     reference: Reference,
     hasMediaType: Bool,
-    appName: String?
+    appName: String?,
   ) -> MediaIntentCriteria {
     let name = (mediaName ?? "").trimmingCharacters(in: .whitespacesAndNewlines)
     let trimmedNonEmpty: (String?) -> String? = {
@@ -115,25 +115,33 @@ public struct MediaIntentCriteria: Sendable {
       hasGenres: !genreNames.isEmpty,
       hasMediaType: hasMediaType,
       matchesAppName: queryMatchesAppName(query, appName: appName),
-      searchMode: mediaTypeMode,   // mode is the vertical, verbatim — no derivation
+      searchMode: mediaTypeMode, // mode is the vertical, verbatim — no derivation
       genre: genre,
       artist: artist,
       album: album,
       title: title,
-      playlist: playlist
+      playlist: playlist,
     )
   }
 
   /// Whether `query` is effectively the host app's own name. Case- and
   /// diacritic-insensitive.
+  ///
+  /// Whole-word subset match in either direction. Siri may deliver only part of
+  /// the name ("Name" for «App Name»), so a partial match must count — but a
+  /// substring match swallowed any query appearing inside the app name, making
+  /// one-word stations unreachable by voice.
   private static func queryMatchesAppName(_ query: String, appName: String?) -> Bool {
     guard let appName else { return false }
-    let normalize: (String) -> String = {
-      $0.folding(options: [.diacriticInsensitive, .caseInsensitive], locale: nil)
-        .trimmingCharacters(in: .whitespacesAndNewlines)
+    let tokens: (String) -> Set<String> = {
+      Set(
+        $0.folding(options: [.diacriticInsensitive, .caseInsensitive], locale: nil)
+          .split(whereSeparator: { !$0.isLetter && !$0.isNumber })
+          .map(String.init),
+      )
     }
-    let q = normalize(query), a = normalize(appName)
+    let q = tokens(query), a = tokens(appName)
     guard !q.isEmpty, !a.isEmpty else { return false }
-    return a.contains(q) || q.contains(a)
+    return q.isSubset(of: a) || a.isSubset(of: q)
   }
 }

package/ios/Player/MediaLoader.swift

@@ -38,19 +38,28 @@ final class MediaLoader {
   func resolveAndLoad(src: String, track: Track? = nil) {
     if let resolver = mediaUrlResolver {
       mediaResolverTask?.cancel()
-      mediaResolverTask = Task {
-        self.logger.debug("resolveAndLoad: starting resolution for \(src)")
+      // `[weak self]` like the sibling load tasks below: the resolver is
+      // consumer-supplied and `cancelAll()` cannot force an in-flight `await`
+      // to return, so a strong capture let a resolver that never settles pin
+      // this loader (which also retains the task) indefinitely.
+      // `Logger` is a value type, so capturing it directly keeps the logging
+      // off `self` — and `self` weak, so a consumer resolver that never settles
+      // can't pin the loader (`cancelAll()` can't force an in-flight `await` to
+      // return).
+      let logger = logger
+      mediaResolverTask = Task { [weak self] in
+        logger.debug("resolveAndLoad: starting resolution for \(src)")
 
         guard !Task.isCancelled else {
-          self.logger.debug("resolveAndLoad: cancelled before start")
+          logger.debug("resolveAndLoad: cancelled before start")
           return
         }
 
-        self.logger.debug("resolveAndLoad: calling resolver...")
+        logger.debug("resolveAndLoad: calling resolver...")
         let resolved = await resolver(src, track)
 
-        guard !Task.isCancelled else {
-          self.logger.debug("resolveAndLoad: cancelled after resolver returned")
+        guard !Task.isCancelled, let self else {
+          logger.debug("resolveAndLoad: cancelled after resolver returned")
           return
         }
 
@@ -96,7 +105,7 @@ final class MediaLoader {
         .availableMetadataFormats,
       ) else { return }
 
-      guard !Task.isCancelled, pendingAsset == asset else { return }
+      guard isCurrent(pendingAsset) else { return }
 
       if !commonMetadata.isEmpty {
         delegate?.mediaLoaderDidReceiveCommonMetadata(commonMetadata)
@@ -104,19 +113,21 @@ final class MediaLoader {
 
       if !chapterLocales.isEmpty {
         for locale in chapterLocales {
-          guard !Task.isCancelled else { return }
+          guard isCurrent(pendingAsset) else { return }
           if let chapters = try? await pendingAsset.loadChapterMetadataGroups(
             withTitleLocale: locale,
             containingItemsWithCommonKeys: [],
           ) {
+            guard isCurrent(pendingAsset) else { return }
             delegate?.mediaLoaderDidReceiveChapterMetadata(chapters)
           }
         }
       } else {
         let duration = await (try? pendingAsset.load(.duration)) ?? .zero
         for format in metadataFormats {
-          guard !Task.isCancelled else { return }
+          guard isCurrent(pendingAsset) else { return }
           if let metadata = try? await pendingAsset.loadMetadata(for: format) {
+            guard isCurrent(pendingAsset) else { return }
             let timeRange = CMTimeRange(
               start: CMTime(seconds: 0, preferredTimescale: 1000),
               end: duration,
@@ -159,6 +170,19 @@ final class MediaLoader {
     }
   }
 
+  /// Whether `candidate` is still the load this loader cares about — checked
+  /// after EVERY await, not just once before a loop.
+  ///
+  /// Cancellation alone is not enough: it only sets a flag, and can't abort a
+  /// load already in flight inside AVFoundation (only `cancelLoading()` does,
+  /// and the track-change path deliberately doesn't call it — the old asset
+  /// still backs the playing item at that point). So a load that lands after
+  /// the track changed would otherwise attribute the old asset's metadata to
+  /// the newly loaded track.
+  private func isCurrent(_ candidate: AVURLAsset) -> Bool {
+    !Task.isCancelled && candidate == asset
+  }
+
   func cancelAll() {
     mediaResolverTask?.cancel()
     mediaResolverTask = nil

package/ios/Player/NowPlayingUpdater.swift

@@ -30,17 +30,51 @@ final class NowPlayingUpdater {
     let album: String?
   }
 
+  /// Dedupe baseline for `applyFields`. Only meaningful while it describes the
+  /// controller's current info dict, so the two are cleared together in
+  /// `clearNowPlaying()` — never separately.
   private var lastPublished: Published?
 
+  /// Empties the now-playing surface and the dedupe baseline that describes it.
+  /// One call, because clearing the dict without the baseline makes the next
+  /// publish of the SAME track dedupe against a dict that no longer holds it —
+  /// artwork lands (never deduped) but the text doesn't, and `onChanged`
+  /// never fires.
+  func clearNowPlaying() {
+    nowPlayingInfoController.clear()
+    lastPublished = nil
+    formattedTrackId = nil
+  }
+
   /// Bumped on every `render`; an async formatter result applies only if its render is still the
   /// latest (latest-render-wins — drops a result whose track skipped or whose state moved on while
   /// the formatter was in flight).
   private var renderGeneration: UInt = 0
 
+  /// The track whose *formatted* line is currently on the surface. While this
+  /// matches the rendering track, `render` skips its interim default write — see
+  /// the comment at that site. Cleared whenever the surface stops showing a
+  /// formatter result (a flash overwrites it, `clearNowPlaying` empties it).
+  private var formattedTrackId: String?
+
   init(nowPlayingInfoController: NowPlayingInfoController) {
     self.nowPlayingInfoController = nowPlayingInfoController
   }
 
+  /// Pixel width to request now-playing artwork at: the active scene's screen
+  /// width in pixels, capped at `maxArtworkPixelWidth`. With no foreground
+  /// scene (headless CarPlay) the cap stands in — every current device exceeds
+  /// it anyway, and this only sizes a CDN request.
+  private static var artworkPixelWidth: CGFloat {
+    guard let screen = UIApplication.shared.activeWindowScene?.screen else {
+      return maxArtworkPixelWidth
+    }
+    return min(screen.bounds.width * screen.scale, maxArtworkPixelWidth)
+  }
+
+  /// Mirrored by the Kotlin twin's `artworkSizePx`.
+  private static let maxArtworkPixelWidth: CGFloat = 1200
+
   /// Publishes the static, per-track fields + artwork on a track change. The title/artist/album
   /// lines are owned by `render` (routed through `applyFields` here so it dedupes against later
   /// renders).
@@ -75,6 +109,8 @@ final class NowPlayingUpdater {
     let defaultSecondary = override?.artist ?? track.artist
     let defaultAlbum = override?.album ?? track.album
 
+    let trackId = track.identity ?? track.path
+
     if let flash {
       applyFields(
         track: track,
@@ -82,10 +118,22 @@ final class NowPlayingUpdater {
         artist: flash.artist ?? defaultSecondary,
         album: flash.album ?? defaultAlbum,
       )
+      // The flash replaced the formatter's line, so the surface no longer shows
+      // one: the render that follows the flash reverting must publish the default
+      // immediately rather than sit on stale flash text awaiting the formatter.
+      formattedTrackId = nil
       return
     }
 
-    applyFields(track: track, title: defaultTitle, artist: defaultSecondary, album: defaultAlbum)
+    // Publish the raw default only while no formatter result is on screen for this
+    // track. `render` runs on EVERY playback transition (state change, playing/
+    // buffering flip, timed-metadata tick, connectivity change); writing the
+    // default each time would flash the track title over the formatter's line
+    // until the async result lands, since the two differ by construction on a live
+    // stream (station name vs. song line).
+    if formatter == nil || formattedTrackId != trackId {
+      applyFields(track: track, title: defaultTitle, artist: defaultSecondary, album: defaultAlbum)
+    }
 
     guard let formatter else { return }
     let params = FormatNowPlayingParams(
@@ -111,6 +159,9 @@ final class NowPlayingUpdater {
             artist: formatted.artist ?? defaultSecondary,
             album: formatted.album ?? defaultAlbum,
           )
+          // A formatter result now owns the surface for this track, so later
+          // renders skip the interim default write.
+          self.formattedTrackId = trackId
         }
       }
       .catch { @Sendable [weak self] error in
@@ -130,7 +181,7 @@ final class NowPlayingUpdater {
     let resolvedArtist = artist ?? track.artist
     let resolvedAlbum = album ?? track.album
     let published = Published(
-      trackId: track.src ?? track.url,
+      trackId: track.identity ?? track.path,
       title: resolvedTitle,
       artist: resolvedArtist,
       album: resolvedAlbum,
@@ -152,10 +203,7 @@ final class NowPlayingUpdater {
     let artworkUrl = track.artworkSource?.uri ?? track.artwork?.url
     logger.debug("loadArtwork: \(track.title), artworkUrl: \(artworkUrl ?? "nil")")
 
-    // Now Playing artwork: use screen width in pixels, capped at 1200px
-    let screenScale = UIScreen.main.scale
-    let screenWidth = UIScreen.main.bounds.width * screenScale
-    let artworkSize = min(screenWidth, 1200)
+    let artworkSize = Self.artworkPixelWidth
     let nowPlayingSize = ImageContext(width: artworkSize, height: artworkSize)
 
     artworkLoadTask?.cancel()

package/ios/Player/PlaybackCoordinator.swift

@@ -526,14 +526,21 @@ class PlaybackCoordinator {
         let changed = queue.add([track], initialIndex: 0)
         if changed { handleCurrentTrackChanged() }
       } else {
-        queue.replace(queue.currentIndex, track)
-        handleCurrentTrackChanged()
+        // `currentIndex` is invariantly -1 or in bounds, and -1 took the branch
+        // above, so this cannot fail — but surface it rather than reloading the
+        // old track if that invariant is ever broken.
+        do {
+          try queue.replace(queue.currentIndex, track)
+          handleCurrentTrackChanged()
+        } catch {
+          logger.error("load: replace at \(self.queue.currentIndex) failed: \(error)")
+        }
       }
     }
   }
 
-  func replace(_ index: Int, _ track: Track) {
-    queue.replace(index, track)
+  func replace(_ index: Int, _ track: Track) throws {
+    try queue.replace(index, track)
   }
 
   func setQueue(
@@ -691,14 +698,14 @@ class PlaybackCoordinator {
       guard let src = currentTrack.src else {
         logger.error("Failed to load track - no src")
         logger.error("  track.title: \(currentTrack.title)")
-        logger.error("  track.url: \(currentTrack.url ?? "nil")")
+        logger.error("  track.path: \(currentTrack.path ?? "nil")")
         effectHandler?.clearCurrentItem()
         transition(.errorOccurred(.invalidSourceUrl("nil")))
         return
       }
 
       logger.debug("Loading track: \(currentTrack.title)")
-      logger.debug("  track.url: \(currentTrack.url ?? "nil")")
+      logger.debug("  track.path: \(currentTrack.path ?? "nil")")
       logger.debug("  track.src: \(src)")
 
       effectHandler?.loadTrack(src: src, track: currentTrack)

package/ios/Player/PlaybackErrorHandler.swift

@@ -8,7 +8,7 @@ import os.log
   var isEnabled: Bool { get }
   /// Whether the current load has produced audio — selects the retry budget.
   var hasPlayed: Bool { get set }
-  func isRetryable(_ error: Error?) -> Bool
+  func isRetryable(_ error: Error?, httpStatusCode: Int?) -> Bool
   func attemptRetry(startFromCurrentTime: Bool) async -> Bool
   func reset()
 }
@@ -62,7 +62,7 @@ public enum PlaybackErrorContext {
       logger.error("[\(String(describing: context))] failure with nil error")
     }
 
-    if retryHandler.isEnabled, retryHandler.isRetryable(error) {
+    if retryHandler.isEnabled, retryHandler.isRetryable(error, httpStatusCode: httpStatusCode) {
       onRetryingError?(PlaybackErrorHandler.classify(
         error: error, fallback: context.fallbackError, httpStatusCode: httpStatusCode,
       ))
@@ -138,7 +138,7 @@ public enum PlaybackErrorContext {
       }
     }
 
-    if let httpStatusCode, !(200...299).contains(httpStatusCode) {
+    if let httpStatusCode, !(200 ... 299).contains(httpStatusCode) {
       return .httpStatus(httpStatusCode)
     }
 
@@ -155,7 +155,7 @@ public enum PlaybackErrorContext {
   /// with HTTP statuses — so only in-range values count, and the newest wins:
   /// a live stream reconnects, and older entries describe earlier attempts.
   public static func httpStatusCode(fromErrorStatusCodes codes: [Int]) -> Int? {
-    codes.last { (100...599).contains($0) }
+    codes.last { (100 ... 599).contains($0) }
   }
 
   /// The stream was fetched but cannot be decoded — unknown container,

package/ios/Player/PlaybackTimer.swift

@@ -48,10 +48,16 @@ final class PlaybackTimer {
 
   private func start(_ interval: TimeInterval) {
     guard timer == nil else { return }
-    timer = Timer.scheduledTimer(withTimeInterval: interval, repeats: true) {
-      [weak self] _ in
+    // `.common`, not the `.default` mode `Timer.scheduledTimer` installs: UIKit
+    // runs the main run loop in tracking mode while a list is being dragged, and
+    // a default-mode timer does not fire there. Missed repeats are dropped rather
+    // than replayed, so progress events would freeze and interval ticks would be
+    // lost for as long as the user scrolls. (VolumeFader already does this.)
+    let timer = Timer(timeInterval: interval, repeats: true) { [weak self] _ in
       MainActor.assumeIsolated { self?.onTick() }
     }
+    self.timer = timer
+    RunLoop.main.add(timer, forMode: .common)
   }
 
   private func stop() {