Início / coding / Perguntas / 79469769
Accepted
Deepak Sharma
Asked: 2025-02-26 20:44:11 +0800 CST

Problema de loop infinito SwiftUI com variáveis ​​de tamanho @Environment

  • 772

Vejo o corpo do SwiftUI sendo repetidamente chamado em um loop infinito na presença de variáveis ​​de ambiente como horizontalSizeClassou verticalSizeClass. Isso acontece depois que o dispositivo é girado do modo retrato para paisagem e depois de volta para o modo retrato. O deinitmétodo de TestPlayerVMé repetidamente chamado. O código de exemplo minimamente reproduzível é colado abaixo.

O loop infinito não é visto se eu remover referências de ambiente de classe de tamanho OU se eu pular addPlayerObserversa chamada no TestPlayerVMinicializador.

import AVKit
import Combine

struct InfiniteLoopView: View {
       @Environment(\.verticalSizeClass) var verticalSizeClass
       @Environment(\.horizontalSizeClass) var horizontalSizeClass
    
       @State private var openPlayer = false
       @State var playerURL: URL = URL(fileURLWithPath: Bundle.main.path(forResource: "Test_Video", ofType: ".mov")!)
    
        var body: some View {
           PlayerView(playerURL: playerURL)
              .ignoresSafeArea()
        }
     }

struct PlayerView: View {
    @Environment(\.dismiss) var dismiss
    
    var playerURL:URL
    @State var playerVM = TestPlayerVM()
    
    var body: some View {
        VideoPlayer(player: playerVM.player)
            .ignoresSafeArea()
            .background {
                Color.black
            }
            .task {
                let playerItem = AVPlayerItem(url: playerURL)
                playerVM.playerItem = playerItem
            }
    }
  }

@Observable
class TestPlayerVM {
     private(set) public var player: AVPlayer = AVPlayer()

     var playerItem:AVPlayerItem? {
        didSet {
            player.replaceCurrentItem(with: playerItem)
        }
    }
    
    private var cancellable = Set<AnyCancellable>()
    
    init() {
        addPlayerObservers()
    }
    
    deinit {
        print("Deinit Video player manager")
        removeAllObservers()
    }
    
    private func removeAllObservers() {
        cancellable.removeAll()
    }
    
  
    private func addPlayerObservers() {
        
        player.publisher(for: \.timeControlStatus, options: [.initial, .new])
            .receive(on: DispatchQueue.main)
            .sink { timeControlStatus in
                print("Player time control status \(timeControlStatus)")
            }
            .store(in: &cancellable)
        
    }
}

1 respostas

  1. Best Answer

    Isso é causado por uma combinação de várias coisas no seu código:

    • @Statewith @Observablechamará TestPlayerVM.inittoda vez PlayerView.initque for chamado. Normalmente, essa nova instância será desinicializada imediatamente, pois a visualização precisa apenas de uma instância, mas o SwiftUI vaza uma instância às vezes. Esse é um bug bem conhecido.
    • cancellableé rastreado por@Observable
    • você modifica cancellableeminit
    • você modifica cancellableemdeinit

    Se nenhuma dessas quatro coisas acontecesse, você não entraria em um loop infinito.

    No início, PlayerView.inité chamado e isso cria a primeira instância de TestPlayerVM.

    Girar a tela faz com que o @Environments mude, então o SwiftUI executa uma atualização de visualização, chamando InfiniteLoopView.init, onde você chama PlayerView.init. Isso cria uma segunda instância de TestPlayerVM. Essa segunda instância é vazada, ou seja, retida erroneamente na memória pelo SwiftUI e não é desinicializada.

    É por isso que o loop infinito não começa até a segunda rotação da tela. Se o SwiftUI não vazar a segunda instância, ele deinitteria sido chamado após a primeira rotação, dando início ao loop infinito.

    Quando você gira a tela novamente, InfiniteLoopView.bodyé chamado novamente, então PlayerView.inittambém é chamado novamente, criando a terceira instância de TestPlayerVM. É aqui que a reação em cadeia começa.

    Em TestPlayerVM.init, cancellableé modificado conforme você insere um novo elemento nele. Como cancellableé rastreado por @Observable, o SwiftUI agora pensa que cancellableé uma dependência de InfiniteLoopView. InfiniteLoopViewserá atualizado sempre que cancellablehouver alterações. Devo enfatizar que este é InfiniteLoopView, não . Afinal, PlayerViewainda estamos no meio da avaliação , então o SwiftUI está encontrando as dependências para .InfiniteLoopView.bodyInfiniteLoopView

    Diferentemente da segunda instância, esta terceira instância é (corretamente) desinicializada imediatamente. Mas o que acontece em deinit? Você modifica cancellableremovendo todos os seus elementos. O SwiftUI observa esta mudança e, como determinou que cancellableé uma dependência de InfiniteLoopViewanteriormente, ele atualiza a visualização . InfiniteLoopView.bodyé chamado, então PlayerView.inité chamado e, portanto, outra instância de TestPlayerVMé criada e o loop continua.

    Você pode fazer qualquer uma destas opções (ou todas elas) para quebrar o ciclo:

    • Torne-o @Stateopcional e inicialize-o em .task.
    • Colocar .@ObservationIgnored​cancellable
    • Ligue addPlayerObserverspara fora de init- para dentro, onAppearpor exemplo.
    • Não cancellable.removeAll(). Deixe o ARC fazer seu trabalho. O AnyCancellableserá automaticamente desinicializado logo depois TestPlayerVM.deinit, de qualquer forma, assumindo que nada mais esteja mantendo uma referência a eles.
    • 0

relate perguntas