SwiftUI与Combine教程之做个乒乓球的动画效果(PassthroughSubject)

    let passthroughObject = PassthroughSubject<String,Error>()
    
    
      
    
    代码解读

    passthroughObject.send("Hello")
    passthroughObject.send("World")
    
    
      
      
    
    代码解读

       let passThroughSubject = PassthroughSubject<String, Error>()
        passThroughSubject.send("Hello")
    		 passThroughSubject.send("Hello")
    
        let subscription = passThroughSubject.sink(
            receiveCompletion: { completion in
                print("Received completion (sink)", completion)
        },
            receiveValue: { value in
                print("Received value (sink)", value)
        })
        
        
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

     let passThroughSubject = PassthroughSubject<String, Error>()
        passThroughSubject.send("Hello")
        let subscription = passThroughSubject.sink(
            receiveCompletion: { completion in
                print("Received completion (sink)", completion)
        },
            receiveValue: { value in
                print("Received value (sink)", value)
        })
        
         passThroughSubject.send("Hello")
    
    
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读

    hello
    
    
      
    
    代码解读

    import SwiftUI
    import Combine
    
    struct ContentView: View {
    let blinkPublisher = PassthroughSubject<Void, Never>()
    
    var body: some View {
        VStack(spacing: 10) {
            Text("SwiftUI和Combine乒乓球的动画效果")
                .frame(maxWidth:.infinity)
                .background(Color.orange)
                .padding()
            Button("启动看看效果") {
                self.blinkPublisher.send()
            }
            .padding()
            Text("一号选手")
                .addOpacityBlinker(subscribedTo: blinkPublisher)
            Text("二号选手")
                .addOpacityBlinker(subscribedTo: blinkPublisher, duration: 1)
            Text("三号选手")
                .addOpacityBlinker(subscribedTo: blinkPublisher, duration: 2)
        }
    }
    }
    
    struct ContentView_Previews: PreviewProvider {
    static var previews: some View {
        ContentView()
    }
    }
    
    extension View {
    // the generic constraints here tell the compiler to accept any publisher
    //   that sends outputs no value and never errors
    // this could be a PassthroughSubject like above, or we could even set up a TimerPublisher
    //   that publishes on an interval, if we wanted a looping animation
    //   (we'd have to map it's output to Void first)
    func addOpacityBlinker<T: Publisher>(subscribedTo publisher: T, duration: Double = 1)
        -> some View where T.Output == Void, T.Failure == Never {
            
            // here I take whatever publisher we got and type erase it to AnyPublisher
            //   that just simplifies the type so I don't have to add extra generics below
            self.modifier(OpacityBlinker(subscribedTo: publisher.eraseToAnyPublisher(),
                                         duration: duration))
    }
    }
    
    // you could call the .modifier(OpacityBlinker(...)) on your view directly,
    //   but I like the View extension method, as it just feels cleaner to me
    struct OpacityBlinker: ViewModifier {
    // this is just here to switch on and off, animating the blur on and off
    @State private var isBlurred = false
    var publisher: AnyPublisher<Void, Never>
    // The total time it takes to blur and unblur
    var duration: Double
    
    // this initializer is not necessary, but allows us to specify a default value for duration,
    //   and the call side looks nicer with the 'subscribedTo' label
    init(subscribedTo publisher: AnyPublisher<Void, Never>, duration: Double = 1) {
        self.publisher = publisher
        self.duration = duration
    }
    
    func body(content: Content) -> some View {
        content
            .blur(radius: isBlurred ? 10 : 0)
            // This basically subscribes to the publisher, and triggers the closure
            //   whenever the publisher fires
            .onReceive(publisher) { _ in
                // perform the first half of the animation by changing isBlurred to true
                // this takes place over half the duration
                withAnimation(.linear(duration: self.duration / 2)) {
                    self.isBlurred = true
                    // schedule isBlurred to return to false after half the duration
                    // this means that the end state will return to an unblurred view
                    DispatchQueue.main.asyncAfter(deadline: .now() + self.duration / 2) {
                        withAnimation(.linear(duration: self.duration / 2)) {
                            self.isBlurred = false
                        }
                    }
                }
        }
    }
    }
    
    
    
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
      
    
    代码解读