@javascriptcommon/react-native-track-player 1.2.23 → 4.1.5

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/NowPlayingInfoController/NowPlayingInfoProperty.swift

@@ -0,0 +1,234 @@
+//
+//  NowPlayingInfo.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 15/03/2018.
+//
+
+import Foundation
+import MediaPlayer
+
+
+/**
+ Enum representing MPNowPlayingInfoProperties.
+ Docs for each property is taken from [Apple docs](https://developer.apple.com/documentation/mediaplayer/mpnowplayinginfocenter/additional_metadata_properties).
+ */
+public enum NowPlayingInfoProperty: NowPlayingInfoKeyValue {
+    
+    /**
+     The identifier of the collection the now playing item belongs to.
+     The identifier can be an album, artist, playlist, etc.
+     */
+    case collectionIdentifier(String?)
+    
+    /**
+     The available language option groups for the now playing item.
+     Value is an array of MPNowPlayingInfoLanguageOptionGroup items. Only one language option in a given group can be played at a time.
+     */
+    case availableLanguageOptions([MPNowPlayingInfoLanguageOptionGroup]?)
+    
+    /**
+     The URL pointing to the now playing item's underlying asset.
+     This constant is used by the system UI when video thumbnails or audio waveform visualizations are applicable.
+     */
+    case assetUrl(URL?)
+    
+    /**
+     The total number of chapters in the now-playing item.
+     Value is an NSNumber object configured as an NSUInteger.
+     */
+    case chapterCount(UInt64?)
+    
+    /**
+     The number corresponding to the chapter currently being played.
+     Value is an NSNumber object configured as an NSUInteger. Chapter numbering uses zero-based indexing. If you want the first chapter in the now-playing item to be displayed as “Chapter 1,” for example, set the chapter number to 0.
+     */
+    case chapterNumber(UInt64?)
+    
+    /**
+     The currently active language options for the now playing item.
+     Value is an array of MPNowPlayingInfoLanguageOption items.
+     */
+    case currentLanguageOptions([MPNowPlayingInfoLanguageOption]?)
+    
+    /**
+     The default playback rate for the now playing item.
+     Value is an NSNumber object configured as a double. Set this property if your app is playing a media item at a playback rate other than 1.0 as its default rate.
+     */
+    case defaultPlaybackRate(Double?)
+    
+    /**
+     The elapsed time of the now playing item, in seconds.
+     Value is an NSNumber object configured as a double. Elapsed time is automatically calculated, by the system, from the previously provided elapsed time and the playback rate. Do not update this property frequently—it is not necessary
+     */
+    case elapsedPlaybackTime(Double?)
+    
+    /**
+     The opaque identifier that uniquely identifies the now playing item, even through app relaunches.
+     This is only used to reference the item to the now playing app and can be in any format.
+     */
+    case externalContentIdentifier(Any?)
+    
+    /**
+     The opaque identifier that uniquely identifies the profile the now playing item is played from, even through app relaunches.
+     This is only used to reference the profile to the now playing app and can be in any format.
+     */
+    case externalUserProfileIdentifier(Any?)
+    
+    /**
+     Denotes whether the now playing item is a live stream.
+     Value is an NSNumber object configured as a boolean. A value of 1.0 indicates the now playing item is a live stream.
+     */
+    case isLiveStream(Bool?)
+    
+    /**
+     The media type of the now playing item.
+     Value is an NSNumber object configured as a MPNowPlayingInfoMediaType.
+     */
+    case mediaType(MPNowPlayingInfoMediaType?)
+    
+    /**
+     The current progress of the now playing item.
+     Value is an NSNumber object configured as a float. A value of 0.0 indicates the item has not been watched while a value of 1.0 indicates the item has been fully watched. This is a high-level indicator. Use MPNowPlayingInfoPropertyElapsedPlaybackTime for fine-detailed information on how much of the item has been watched.
+     */
+    case playbackProgress(Float?)
+    
+    /**
+     The total number of items in the app’s playback queue.
+     Value is an NSNumber object configured as an NSUInteger.
+     */
+    case playbackQueueCount(UInt64?)
+    
+    /**
+     The index of the now-playing item in the app’s playback queue.
+     Value is an NSNumber object configured as an NSUInteger. The playback queue uses zero-based indexing. If you want the first item in the queue to be displayed as “item 1 of 10,” for example, set the item’s index to 0.
+     */
+    case playbackQueueIndex(UInt64?)
+    
+    /**
+     The playback rate of the now-playing item, with a value of 1.0 indicating the normal playback rate.
+     Value is an NSNumber object configured as a double. The default value is 1.0. A playback rate value of 2.0 means twice the normal playback rate; a piece of media played at this rate would take half as long to play to completion. A value of 0.5 means half the normal playback rate; a piece of media played at this rate would take twice as long to play to completion.
+     */
+    case playbackRate(Double?)
+    
+    /**
+     The service provider associated with the now-playing item.
+     Value is a unique NSString that identifies the service provider for the now-playing item. If the now-playing item belongs to a channel or subscription service, this key can be used to coordinate various types of now-playing content from the service provider.
+     */
+    case serviceIdentifier(String?)
+    
+    
+    public func getKey() -> String {
+        switch self {
+            
+        case .collectionIdentifier(_):
+            return MPNowPlayingInfoCollectionIdentifier
+            
+        case .availableLanguageOptions(_):
+            return MPNowPlayingInfoPropertyAvailableLanguageOptions
+            
+        case .assetUrl(_):
+            return MPNowPlayingInfoPropertyAssetURL
+        case .chapterCount(_):
+            return MPNowPlayingInfoPropertyChapterCount
+            
+        case .chapterNumber(_):
+            return MPNowPlayingInfoPropertyChapterNumber
+            
+        case .currentLanguageOptions(_):
+            return MPNowPlayingInfoPropertyCurrentLanguageOptions
+            
+        case .defaultPlaybackRate(_):
+            return MPNowPlayingInfoPropertyDefaultPlaybackRate
+            
+        case .elapsedPlaybackTime(_):
+            return MPNowPlayingInfoPropertyElapsedPlaybackTime
+            
+        case .externalContentIdentifier(_):
+            return MPNowPlayingInfoPropertyExternalContentIdentifier
+            
+        case .externalUserProfileIdentifier(_):
+            return MPNowPlayingInfoPropertyExternalUserProfileIdentifier
+            
+        case .isLiveStream(_):
+            return MPNowPlayingInfoPropertyIsLiveStream
+            
+        case .mediaType(_):
+            return MPNowPlayingInfoPropertyMediaType
+            
+        case .playbackProgress(_):
+            return MPNowPlayingInfoPropertyPlaybackProgress
+            
+        case .playbackQueueCount(_):
+            return MPNowPlayingInfoPropertyPlaybackQueueCount
+            
+        case .playbackQueueIndex(_):
+            return MPNowPlayingInfoPropertyPlaybackQueueIndex
+            
+        case .playbackRate(_):
+            return MPNowPlayingInfoPropertyPlaybackRate
+            
+        case .serviceIdentifier(_):
+            return MPNowPlayingInfoPropertyServiceIdentifier
+            
+        }
+    }
+    
+    public func getValue() -> Any? {
+        switch self {
+            
+        case .collectionIdentifier(let identifier):
+            return identifier
+            
+        case .availableLanguageOptions(let options):
+            return options
+            
+        case .assetUrl(let url):
+            return url
+            
+        case .chapterCount(let count):
+            return count != nil ? NSNumber(value: count!) : nil
+            
+        case .chapterNumber(let number):
+            return number != nil ? NSNumber(value: number!) : nil
+            
+        case .currentLanguageOptions(let options):
+            return options
+            
+        case .defaultPlaybackRate(let rate):
+            return rate != nil ? NSNumber(floatLiteral: rate!) : nil
+            
+        case .elapsedPlaybackTime(let time):
+            return time != nil ? NSNumber(floatLiteral: time!) : nil
+            
+        case .externalContentIdentifier(let id):
+            return id
+            
+        case .externalUserProfileIdentifier(let id):
+            return id
+            
+        case .isLiveStream(let status):
+            return status
+            
+        case .mediaType(let type):
+            return type != nil ? NSNumber(value: type!.rawValue) : nil
+            
+        case .playbackProgress(let progress):
+            return progress != nil ? NSNumber(value: progress!) : nil
+            
+        case .playbackQueueCount(let count):
+            return count != nil ? NSNumber(value: count!) : nil
+            
+        case .playbackQueueIndex(let index):
+            return index != nil ? NSNumber(value: index!) : nil
+            
+        case .playbackRate(let rate):
+            return rate != nil ? NSNumber(floatLiteral: rate!) : nil
+            
+        case .serviceIdentifier(let id):
+            return id != nil ? NSString(string: id!) : nil
+            
+        }
+    }
+    
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/Observer/AVPlayerItemNotificationObserver.swift

@@ -0,0 +1,102 @@
+//
+//  AVPlayerItemNotificationObserver.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 12/03/2018.
+//
+
+import Foundation
+import AVFoundation
+
+protocol AVPlayerItemNotificationObserverDelegate: AnyObject {
+    func itemDidPlayToEndTime()
+    func itemFailedToPlayToEndTime()
+    func itemPlaybackStalled()
+}
+
+/**
+ Observes notifications posted by an AVPlayerItem.
+ 
+ Currently only listening for the AVPlayerItemDidPlayToEndTime notification.
+ */
+class AVPlayerItemNotificationObserver {
+    
+    private let notificationCenter: NotificationCenter = NotificationCenter.default
+    
+    private(set) weak var observingItem: AVPlayerItem?
+    weak var delegate: AVPlayerItemNotificationObserverDelegate?
+    
+    private(set) var isObserving: Bool = false
+    
+    deinit {
+        stopObservingCurrentItem()
+    }
+    
+    /**
+     Will start observing notifications from an item.
+     
+     - parameter item: The item to observe.
+     - important: Cannot observe more than one item at a time.
+     */
+    func startObserving(item: AVPlayerItem) {
+        stopObservingCurrentItem()
+        observingItem = item
+        isObserving = true
+        notificationCenter.addObserver(
+            self,
+            selector: #selector(itemDidPlayToEndTime),
+            name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
+            object: item
+        )
+        notificationCenter.addObserver(
+            self,
+            selector: #selector(itemFailedToPlayToEndTime),
+            name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
+            object: item
+        )
+        notificationCenter.addObserver(
+            self,
+            selector: #selector(itemPlaybackStalled),
+            name: NSNotification.Name.AVPlayerItemPlaybackStalled,
+            object: item
+        )
+    }
+    
+    /**
+     Stop receiving notifications for the current item.
+     */
+    func stopObservingCurrentItem() {
+        guard let observingItem = observingItem, isObserving else {
+            return
+        }
+        notificationCenter.removeObserver(
+            self,
+            name: NSNotification.Name.AVPlayerItemDidPlayToEndTime,
+            object: observingItem
+        )
+        notificationCenter.removeObserver(
+            self,
+            name: NSNotification.Name.AVPlayerItemFailedToPlayToEndTime,
+            object: observingItem
+        )
+        notificationCenter.removeObserver(
+            self,
+            name: NSNotification.Name.AVPlayerItemPlaybackStalled,
+            object: observingItem
+        )
+        self.observingItem = nil
+        isObserving = false
+    }
+    
+    @objc private func itemDidPlayToEndTime() {
+        delegate?.itemDidPlayToEndTime()
+    }
+
+    @objc private func itemFailedToPlayToEndTime() {
+        delegate?.itemFailedToPlayToEndTime()
+    }
+
+    @objc private func itemPlaybackStalled() {
+        delegate?.itemPlaybackStalled()
+    }
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/Observer/AVPlayerItemObserver.swift

@@ -0,0 +1,136 @@
+//
+//  AVPlayerItemObserver.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 28/07/2018.
+//
+
+import Foundation
+import AVFoundation
+
+protocol AVPlayerItemObserverDelegate: AnyObject {
+    
+    /**
+     Called when the duration of the observed item is updated.
+     */
+    func item(didUpdateDuration duration: Double)
+    
+    /**
+     Called when the playback of the observed item is or is no longer likely to keep up.
+     */
+    func item(didUpdatePlaybackLikelyToKeepUp playbackLikelyToKeepUp: Bool)
+    /**
+     Called when the observed item receives metadata
+     */
+    func item(didReceiveTimedMetadata metadata: [AVTimedMetadataGroup])
+    
+}
+
+/**
+ Observing an AVPlayers status changes.
+ */
+class AVPlayerItemObserver: NSObject {
+    
+    private static var context = 0
+    private var currentMetadataOutput: AVPlayerItemMetadataOutput?
+    
+    private struct AVPlayerItemKeyPath {
+        static let duration = #keyPath(AVPlayerItem.duration)
+        static let loadedTimeRanges = #keyPath(AVPlayerItem.loadedTimeRanges)
+        static let playbackLikelyToKeepUp = #keyPath(AVPlayerItem.isPlaybackLikelyToKeepUp)
+    }
+    
+    private(set) var isObserving: Bool = false
+    
+    private(set) weak var observingItem: AVPlayerItem?
+    weak var delegate: AVPlayerItemObserverDelegate?
+    
+    override init() {
+        super.init()
+    }
+    
+    deinit {
+        stopObservingCurrentItem()
+    }
+    
+    /**
+     Start observing an item. Will remove self as observer from old item, if any.
+     
+     - parameter item: The player item to observe.
+     */
+    func startObserving(item: AVPlayerItem) {
+        stopObservingCurrentItem()
+        
+        self.isObserving = true
+        self.observingItem = item
+        item.addObserver(self, forKeyPath: AVPlayerItemKeyPath.duration, options: [.new], context: &AVPlayerItemObserver.context)
+        item.addObserver(self, forKeyPath: AVPlayerItemKeyPath.loadedTimeRanges, options: [.new], context: &AVPlayerItemObserver.context)
+        item.addObserver(self, forKeyPath: AVPlayerItemKeyPath.playbackLikelyToKeepUp, options: [.new], context: &AVPlayerItemObserver.context)
+        
+        // Create and add a new metadata output to the item.
+        let metadataOutput = AVPlayerItemMetadataOutput()
+        metadataOutput.setDelegate(self, queue: .main)
+        item.add(metadataOutput)
+        self.currentMetadataOutput = metadataOutput
+    }
+    
+    func stopObservingCurrentItem() {
+        guard let observingItem = observingItem, isObserving else {
+            return
+        }
+        
+        observingItem.removeObserver(self, forKeyPath: AVPlayerItemKeyPath.duration, context: &AVPlayerItemObserver.context)
+        observingItem.removeObserver(self, forKeyPath: AVPlayerItemKeyPath.loadedTimeRanges, context: &AVPlayerItemObserver.context)
+        observingItem.removeObserver(self, forKeyPath: AVPlayerItemKeyPath.playbackLikelyToKeepUp, context: &AVPlayerItemObserver.context)
+        
+        // Remove all metadata outputs from the item.
+        observingItem.removeAllMetadataOutputs()
+        
+        isObserving = false
+        self.observingItem = nil
+        self.currentMetadataOutput = nil
+    }
+    
+    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey : Any]?, context: UnsafeMutableRawPointer?) {
+        guard context == &AVPlayerItemObserver.context, let observedKeyPath = keyPath else {
+            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+            return
+        }
+        
+        switch observedKeyPath {
+        case AVPlayerItemKeyPath.duration:
+            if let duration = change?[.newKey] as? CMTime {
+                delegate?.item(didUpdateDuration: duration.seconds)
+            }
+            
+        case AVPlayerItemKeyPath.loadedTimeRanges:
+            if let ranges = change?[.newKey] as? [NSValue], let duration = ranges.first?.timeRangeValue.duration {
+                delegate?.item(didUpdateDuration: duration.seconds)
+            }
+            
+        case AVPlayerItemKeyPath.playbackLikelyToKeepUp:
+            if let playbackLikelyToKeepUp = change?[.newKey] as? Bool {
+                delegate?.item(didUpdatePlaybackLikelyToKeepUp: playbackLikelyToKeepUp)
+            }
+            
+        default: break
+            
+        }
+    }
+}
+
+extension AVPlayerItemObserver: AVPlayerItemMetadataOutputPushDelegate {
+    func metadataOutput(_ output: AVPlayerItemMetadataOutput, didOutputTimedMetadataGroups groups: [AVTimedMetadataGroup], from track: AVPlayerItemTrack?) {
+        if output == currentMetadataOutput {
+            delegate?.item(didReceiveTimedMetadata: groups)
+        }
+    }
+}
+
+extension AVPlayerItem {
+    func removeAllMetadataOutputs() {
+        for output in self.outputs.filter({ $0 is AVPlayerItemMetadataOutput }) {
+            self.remove(output)
+        }
+    }
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/Observer/AVPlayerObserver.swift

@@ -0,0 +1,120 @@
+//
+//  AudioPlayerObserver.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 09/03/2018.
+//  Copyright © 2018 Jørgen Henrichsen. All rights reserved.
+//
+
+import Foundation
+import AVFoundation
+
+protocol AVPlayerObserverDelegate: AnyObject {
+    
+    /**
+     Called when the AVPlayer.status changes.
+     */
+    func player(statusDidChange status: AVPlayer.Status)
+    
+    /**
+     Called when the AVPlayer.timeControlStatus changes.
+     */
+    func player(didChangeTimeControlStatus status: AVPlayer.TimeControlStatus)
+}
+
+/**
+ Observing an AVPlayers status changes.
+ */
+class AVPlayerObserver: NSObject {
+
+    private static var context = 0
+    private let main: DispatchQueue = .main
+
+    private struct AVPlayerKeyPath {
+        static let status = #keyPath(AVPlayer.status)
+        static let timeControlStatus = #keyPath(AVPlayer.timeControlStatus)
+    }
+
+    private let statusChangeOptions: NSKeyValueObservingOptions = [.new, .initial]
+    private let timeControlStatusChangeOptions: NSKeyValueObservingOptions = [.new]
+    private(set) var isObserving: Bool = false
+
+    weak var delegate: AVPlayerObserverDelegate?
+    weak var player: AVPlayer? {
+        willSet {
+            stopObserving()
+        }
+    }
+
+    deinit {
+        stopObserving()
+    }
+
+    /**
+     Start receiving events from this observer.
+     */
+    func startObserving() {
+        if (isObserving) { return };
+        guard let player = player else {
+            return
+        }
+        isObserving = true
+        player.addObserver(
+            self,
+            forKeyPath: AVPlayerKeyPath.status,
+            options: statusChangeOptions,
+            context: &AVPlayerObserver.context
+        )
+        player.addObserver(
+            self,
+            forKeyPath: AVPlayerKeyPath.timeControlStatus,
+            options: timeControlStatusChangeOptions,
+            context: &AVPlayerObserver.context
+        )
+    }
+
+    func stopObserving() {
+        guard let player = player, isObserving else {
+            return
+        }
+        player.removeObserver(self, forKeyPath: AVPlayerKeyPath.status, context: &AVPlayerObserver.context)
+        player.removeObserver(self, forKeyPath: AVPlayerKeyPath.timeControlStatus, context: &AVPlayerObserver.context)
+        isObserving = false
+    }
+
+    override func observeValue(forKeyPath keyPath: String?, of object: Any?, change: [NSKeyValueChangeKey: Any]?, context: UnsafeMutableRawPointer?) {
+        guard context == &AVPlayerObserver.context, let observedKeyPath = keyPath else {
+            super.observeValue(forKeyPath: keyPath, of: object, change: change, context: context)
+            return
+        }
+
+        switch observedKeyPath {
+        case AVPlayerKeyPath.status:
+            handleStatusChange(change)
+
+        case AVPlayerKeyPath.timeControlStatus:
+            handleTimeControlStatusChange(change)
+
+        default:
+            break
+        }
+    }
+
+    private func handleStatusChange(_ change: [NSKeyValueChangeKey: Any]?) {
+        let status: AVPlayer.Status
+        if let statusNumber = change?[.newKey] as? NSNumber {
+            status = AVPlayer.Status(rawValue: statusNumber.intValue)!
+        } else {
+            status = .unknown
+        }
+        delegate?.player(statusDidChange: status)
+    }
+
+    private func handleTimeControlStatusChange(_ change: [NSKeyValueChangeKey: Any]?) {
+        let status: AVPlayer.TimeControlStatus
+        if let statusNumber = change?[.newKey] as? NSNumber {
+            status = AVPlayer.TimeControlStatus(rawValue: statusNumber.intValue)!
+            delegate?.player(didChangeTimeControlStatus: status)
+        }
+    }
+}

package/ios/SwiftAudioEx/Sources/SwiftAudioEx/Observer/AVPlayerTimeObserver.swift

@@ -0,0 +1,112 @@
+//
+//  AudioPlayerTimeEventObserver.swift
+//  SwiftAudio
+//
+//  Created by Jørgen Henrichsen on 09/03/2018.
+//  Copyright © 2018 Jørgen Henrichsen. All rights reserved.
+//
+
+import Foundation
+import AVFoundation
+
+protocol AVPlayerTimeObserverDelegate: AnyObject {
+    func audioDidStart()
+    func timeEvent(time: CMTime)
+}
+
+/**
+ Class for observing time-based events from the AVPlayer
+ */
+class AVPlayerTimeObserver {
+    
+    /// The time to use as start boundary time. Cannot be zero.
+    private static let startBoundaryTime: CMTime = CMTime(value: 1, timescale: 1000)
+    
+    var boundaryTimeStartObserverToken: Any?
+    var periodicTimeObserverToken: Any?
+    
+    weak var player: AVPlayer? {
+        willSet {
+            unregisterForBoundaryTimeEvents()
+            unregisterForPeriodicEvents()
+        }
+    }
+    
+    /// The frequence to receive periodic time events.
+    /// Setting this to a new value will trigger a re-registering to the periodic events of the player.
+    var periodicObserverTimeInterval: CMTime {
+        didSet {
+            if oldValue != periodicObserverTimeInterval {
+                registerForPeriodicTimeEvents()
+            }
+        }
+    }
+    
+    weak var delegate: AVPlayerTimeObserverDelegate?
+    
+    init(periodicObserverTimeInterval: CMTime) {
+        self.periodicObserverTimeInterval = periodicObserverTimeInterval
+    }
+    
+    deinit {
+        unregisterForPeriodicEvents()
+        unregisterForBoundaryTimeEvents()
+    }
+    
+    /**
+     Will register for the AVPlayer BoundaryTimeEvents, to trigger start and complete events.
+     */
+    func registerForBoundaryTimeEvents() {
+        guard let player = player else {
+            return
+        }
+        unregisterForBoundaryTimeEvents()
+        boundaryTimeStartObserverToken = player.addBoundaryTimeObserver(
+            forTimes: [AVPlayerTimeObserver.startBoundaryTime].map({
+                NSValue(time: $0)
+            }),
+            queue: nil,
+            using: { [weak self] in
+                self?.delegate?.audioDidStart()
+            }
+        )
+    }
+    
+    /**
+     Unregister from the boundary events of the player.
+     */
+    func unregisterForBoundaryTimeEvents() {
+        guard
+            let player = player,
+            let boundaryTimeStartObserverToken = boundaryTimeStartObserverToken
+        else { return }
+        player.removeTimeObserver(boundaryTimeStartObserverToken)
+        self.boundaryTimeStartObserverToken = nil
+    }
+    
+    /**
+     Start observing periodic time events.
+     Will trigger unregisterForPeriodicEvents() first to avoid multiple subscriptions.
+     */
+    func registerForPeriodicTimeEvents() {
+        guard let player = player else {
+            return
+        }
+        unregisterForPeriodicEvents()
+        periodicTimeObserverToken = player.addPeriodicTimeObserver(forInterval: periodicObserverTimeInterval, queue: nil, using: { (time) in
+            self.delegate?.timeEvent(time: time)
+        })
+    }
+    
+    /**
+     Unregister for periodic events.
+     */
+    func unregisterForPeriodicEvents() {
+        guard let player = player, let periodicTimeObserverToken = periodicTimeObserverToken else {
+            return
+        }
+        player.removeTimeObserver(periodicTimeObserverToken)
+        self.periodicTimeObserverToken = nil
+    }
+    
+}