Wrap `GCKRequestDelegate` in a Combine `Subscriber`

GCKRequestSubscription.swift

import Combine
import GoogleCast

struct GCKRequestPublisher: Publisher {
    typealias Output = Void
    typealias Failure = Error

    let request: GCKRequest

    init(request: GCKRequest) {
        self.request = request
    }

    func receive<S>(subscriber: S) where S : Subscriber, Self.Failure == S.Failure, Self.Output == S.Input {
        let subscription = GCKRequestSubscription(request: request, subscriber: subscriber)
        subscriber.receive(subscription: subscription)
    }
}

class GCKRequestSubscription<S: Subscriber>: NSObject, GCKRequestDelegate, Subscription where S.Input == Void, S.Failure == Error {
    var subscriber: S?
    let request: GCKRequest

    enum GCKRequestError: Error {
        case error(GCKError)
        case abort(GCKRequestAbortReason)
    }
    
    init(request: GCKRequest, subscriber: S) {
        self.subscriber = subscriber
        self.request = request
        super.init()
        self.request.delegate = self
    }

    func request(_ demand: Subscribers.Demand) { }

    func cancel() {
        request.cancel()
        subscriber = nil
    }

    // MARK: - GCKRequestDelegate
    func requestDidComplete(_ request: GCKRequest) {
        subscriber?.receive(completion: .finished)
    }

    func request(_ request: GCKRequest, didFailWithError error: GCKError) {
        subscriber?.receive(completion: .failure(GCKRequestError.error(error)))
    }

    func request(_ request: GCKRequest, didAbortWith abortReason: GCKRequestAbortReason) {
        subscriber?.receive(completion: .failure(GCKRequestError.abort(abortReason)))
    }
}

Usage:

extension GCKRequest {
    func publisher() -> GCKRequestPublisher {
        return GCKRequestPublisher(request: self)
    }
}

remoteMediaClient
    .seek(with: seekOptions)
    .publisher()
    .materialize()
    .sink { event in
        switch event {
        case .value:
            debugPrint("Success")
        case .failure(let error):
            debugPrint("Failure: \(error)")
        case .finished:
            debugPrint("Finished")
        }
    }