Formatowanie czasu rzeczywistego stopera na setne przy użyciu Swift

Question

Mam app za pomocą NSTimer w centisecond (0,01 sekundy) interwały aktualizacji, aby wyświetlić uruchomiony stoper w formacie ciągu jako 00: 00.00 (mm: ss.SS). (Zasadniczo klonowanie wbudowanego stopera iOS w celu zintegrowania z matematyką czasu rzeczywistego w czasie rzeczywistym, prawdopodobnie wymagające milisekundowej dokładności w przyszłości)

Używam (niewłaściwe użycie?) NSTimer'a do wymuszania aktualizacji UILabel. Jeśli użytkownik naciśnie przycisk Start, jest to kod NSTimer używany do uruchamiania powtórzenie funkcji:

displayOnlyTimer = NSTimer.scheduledTimerWithTimeInterval(0.01, target: self, selector: Selector("display"), userInfo: nil, repeats: true) 

i tutaj jest funkcja, która jest wykonywana przez wyżej NSTimer:

func display() { 
    let currentTime = CACurrentMediaTime() - timerStarted + elapsedTime 

    if currentTime < 60 { 
     timeDisplay.text = String(format: "%.2f", currentTime) 
    }else if currentTime < 3600 { 
     var minutes = String(format: "%00d", Int(currentTime/60)) 
     var seconds = String(format: "%05.2f", currentTime % 60) 
     timeDisplay.text = minutes + ":" + seconds 
    }else { 
     var hours = String(format: "%00d", Int(currentTime/3600)) 
     var minutes = String(format: "%02d", (Int(currentTime/60)-(Int(currentTime/3600)*60))) 
     var seconds = String(format: "%05.2f", currentTime % 60) 
     timeDisplay.text = hours + ":" + minutes + ":" + seconds 
    } 
} 

będzie co najmniej 2 łącza wyświetlacza działające w tym samym czasie. Czy ta metoda będzie zbyt nieefektywna, gdy wszystkie inne elementy będą w grze?

Wyświetlacz jest następnie aktualizowany bez użycia NSTimer, gdy użytkownik naciśnie przycisk stop/pause/reset. Nie znalazłem niczego, co bezpośrednio przełożyłoby się na Swift. Jestem dość pewny, że używam nieefektywnej metody, aby wymusić aktualizację tekstu UILabel szybko w UIView.

Więcej szczegółów: Pracuję nad mniej niechlujnym kodem dla formatu zegarka (mm: ss.SS). Zaktualizuję to jeszcze raz, kiedy to skończę.

AKTUALIZACJA: Dzięki Robowi i aplikacjom odpowiadającym na oba moje pytania (metoda formatowania i sposób aktualizacji ekranu). Łatwo było wymienić NSTimer (patrz wyżej) z CADisplayLink():

displayLink = CADisplayLink(target: self, selector: Selector("display")) 
     displayLink.addToRunLoop(NSRunLoop.currentRunLoop(), forMode: NSRunLoopCommonModes) 

a następnie zastąpić wszystkie wystąpienia w kodzie

displayOnlyTimer.invalidate() 

z

displayLink.paused = true 

(będzie wstrzymać aktualizację łącza wyświetlacza)

Answer 1

Aby zaktualizować aktualizacje interfejsu użytkownika, należy użyć a CADisplayLink. Wszystko, co jest szybsze niż częstotliwość odświeżania wyświetlacza, jest marnowaniem mocy obliczeniowej, ponieważ fizycznie nie można go wyświetlić. Zapewnia także timestamp z poprzedniej klatki, dzięki czemu można spróbować przewidzieć, kiedy będzie następna klatka.

Wielokrotne obliczanie wartości CACurrentMediaTime() - timerStarted + elapsedTime. Polecam zrobić to tylko raz i zapisać go w zmiennej lokalnej.

Rozważ użycie NSDateComponentsFormatter. Spróbuj użyć jednej instancji programu formatującego zamiast tworzyć nową za każdym razem (co jest zazwyczaj najdroższą częścią). Ogólnie rzecz biorąc, mniej manipulacji ciągami, które możesz zrobić, tym lepiej.

Możesz sprawdzić CACurrentMediaTime na początku i na końcu metody wyświetlania, aby sprawdzić, ile czasu to zajmie. Idealnie powinno być wiele mniej niż 16,6 ms. Miej oko na wykorzystanie procesora (i ogólne zużycie energii) w nawigatorze debugowania Xcode.

Answer 2

Rozwiązałem ten sam problem dzisiaj i znalazłem tę odpowiedź. Porady Rob i Jtbandes są bardzo pomocne i udało mi się stworzyć czyste i działające rozwiązanie z całego internetu. Dzięki wam. I dzięki mamie za pytanie.

Zdecydowałem się użyć CADisplayLink bo nie ma sensu wypalania zwrotnego synchronizatora częściej niż aktualizacji ekranu:

class Stopwatch: NSObject { 
    private var displayLink: CADisplayLink! 
    //... 

    override init() { 
     super.init() 

     self.displayLink = CADisplayLink(target: self, selector: "tick:") 
     displayLink.paused = true 
     displayLink.addToRunLoop(NSRunLoop.mainRunLoop(), forMode: NSRunLoopCommonModes) 
     //... 
    } 
    //... 
} 

mam śledzenie czasu, zwiększając zmienną ElapsedTime przez displayLink.duration każdego kleszcza :

var elapsedTime: CFTimeInterval! 

override init() { 
    //... 
    self.elapsedTime = 0.0 
    //... 
} 

func tick(sender: CADisplayLink) { 
    elapsedTime = elapsedTime + displayLink.duration 
    //... 
} 

Time-formatowanie odbywa się poprzez NSDateFormatter:

private let formatter = NSDateFormatter() 

override init() { 
//... 
     formatter.dateFormat = "mm:ss,SS" 
} 

func elapsedTimeAsString() -> String { 
     return formatter.stringFromDate(NSDate(timeIntervalSinceReferenceDate: elapsedTime)) 
} 

UI może być aktualizowany w zamknięciu zwrotnego, który nazywa Stoper na każdym tiku:

var callback: (() -> Void)? 

func tick(sender: CADisplayLink) { 
    elapsedTime = elapsedTime + displayLink.duration 

    // Calling the callback function if available 
    callback?() 
} 

I to jest wszystko, co trzeba zrobić w ViewController wykorzystać Stoper:

let stopwatch = Stopwatch() 
stopwatch.callback = self.tick 

func tick() { 
    elapsedTimeLabel.text = stopwatch.elapsedTimeAsString() 
} 

Oto Istota z pełnym kodem Stopwatch i instrukcją użycia: https://gist.github.com/Flar49/06b8c9894458a3ff1b14

Mam nadzieję, że to wyjaśnienie i istotę pomogą innym, którzy natkną się na ten wątek w przyszłości z tym samym problemem :)