Início / coding / Perguntas / 78918013
Accepted
Vincent
Asked: 2024-08-27 17:03:32 +0800 CST

Swift Debounce ou delay com discriminador

  • 772

Meu aplicativo inclui vários widgets que indicam valores em tempo real (temperatura, uso da CPU, memória, etc....). Esses widgets são atualizados a partir de mensagens JSON recebidas por meio de um único websocket.

No momento, as atualizações são tratadas em tempo real, então atualizo meu widget assim que um novo valor é recebido.

As mensagens são as seguintes: {widget: "widgetId", value: 150}.

Meu problema é que às vezes há várias atualizações por segundo para o mesmo widget e isso faz a tela piscar e tem um custo de desempenho inútil. Quero reduzir isso apenas atrasando a atualização da IU para atualizar apenas com o último valor recebido por um período de tempo.

Gostaria de explorar as duas opções a seguir:

  1. Atualize todos os widgets ao mesmo tempo uma vez a cada X segundos (mantendo apenas a atualização mais recente para cada widget e enviando todas de uma vez para a interface do usuário).

  2. Atualiza um widget no máximo uma vez a cada X segundos (um debounce por canal).

Meu manipulador de soquete se parece com isto:

socket.receive(completionHandler: { [weak self] result in
    switch result {
        case .success(let message):
            switch message {
                case .data(let data):
                    guard let update = try? WidgetUpdate(serializedData: data) else {
                         print("Failed to deserialize data")
                         return
                     }
                     DispatchQueue.main.async {
                         self?.updateWidget(update: update)
                     }
                     @unknown default:
                         print("unknown")
            }
        }
    }
)

O que tentei até agora é usar algo PassthroughSubjectassim:

let subject = PassthroughSubject<WidgetUpdate, Never>()
cancellable = subject
    .debounce(for: .seconds(0.5), scheduler: RunLoop.main)
    .sink { update in
        self?.updateWidget(update: update)
    }

// And to publish inside the publisher from the socket handler like this
subject.send(update)

O problema é que ele obviamente debounces "todas" as atualizações e não por widget.
Eu gostaria de evitar criar um PassthroughSubject por widget, pois o widget pode ser adicionado ou excluído dinamicamente e eu não quero ter que gerenciar a criação/exclusão dos publicadores associados.

swift

1 respostas

  1. Best Answer

    Acho que o que vai ajudar você é o operador ReactiveX GroupBy . Infelizmente, Combine não vem com um GroupBy nativo, mas pode ser implementado em termos de um scan :

    import Combine
import Foundation

extension Publisher {
    public func grouped<Key: Hashable> (
        by key: @escaping (Self.Output) -> Key
    ) -> some Publisher<CurrentValueSubject<Self.Output, Never>, Self.Failure> {
        scan(([:], nil)) { (accum: ([Key: CurrentValueSubject<Self.Output, Never>], CurrentValueSubject<Self.Output, Never>?), next) in
            var (accumPubs, _) = accum
            if let existingSubject = accumPubs[key(next)] {
                existingSubject.send(next)
                
                return (accumPubs, nil)
            } else {
                let newSubject = CurrentValueSubject<Self.Output, Never>(next)
                accumPubs[key(next)] = newSubject
                
                return (accumPubs, newSubject)
            }
        }.compactMap { $0.1 }
    }
}

    Depois que você tiver isso, acredito que algo assim deve resolver seu problema (isso se baseia no seu exemplo original):

    struct Element {
    let channel: String
    let updateNum: Int
}
var subscriptions: Set<AnyCancellable> = Set()
withExtendedLifetime(subscriptions) {
    let pub1 = Just(Element(channel: "chan1", updateNum: 1)).delay(for: .seconds(0.1), scheduler: RunLoop.main)
    let pub2 = Just(Element(channel: "chan2", updateNum: 1)).delay(for: .seconds(0.2), scheduler: RunLoop.main)
    let pub3 = Just(Element(channel: "chan1", updateNum: 2)).delay(for: .seconds(0.2), scheduler: RunLoop.main)
    let pub4 = Just(Element(channel: "chan1", updateNum: 3)).delay(for: .seconds(0.3), scheduler: RunLoop.main)
    let pub5 = Just(Element(channel: "chan2", updateNum: 2)).delay(for: .seconds(0.4), scheduler: RunLoop.main)
    let pub6 = Just(Element(channel: "chan2", updateNum: 3)).delay(for: .seconds(0.5), scheduler: RunLoop.main)
    let pub7 = Just(Element(channel: "chan1", updateNum: 4)).delay(for: .seconds(0.6), scheduler: RunLoop.main)
    let pub = Publishers.MergeMany(pub1, pub2, pub3, pub4, pub5, pub6, pub7)
    pub
        .grouped { $0.channel }
        .flatMap {
            $0.debounce(for: .seconds(0.3), scheduler: RunLoop.main)
            // Or:
            // $0.throttle(for: .seconds(0.3), scheduler: RunLoop.main, latest: true)
        }
        .sink { result in print(result) }
        .store(in: &subscriptions)
}
RunLoop.main.run()

    E aqui está algo baseado no seu problema real com WebSockets:

    let subject = PassthroughSubject<WidgetUpdate, Never>()
cancellable = subject
    .grouped { $0.widget }
    .flatMap {
        $0.debounce(for: .seconds(0.5), scheduler: RunLoop.main)
        // Or:
        // $0.throttle(for: .seconds(0.5), scheduler: RunLoop.main, latest: true)
    }
    .sink { update in
        self?.updateWidget(update: update)
    }

// And to publish inside the publisher from the socket handler like this
subject.send(update)

    Além disso, parece-me que o que você quer é realmente throttle , em vez de debounce , embora para o seu caso de uso, a maioria dos usuários provavelmente não notará a diferença entre os dois. Contanto que você agrupe seus publicadores, você pode escolher throttle ou debounce.

    • 1

relate perguntas