如何将数据从委托方法传递到可观察对象'；RxSwift中的s onNext方法？

我有一个管理类，它将连接和管理蓝牙设备的数据和状态

manager类符合IWDeviceManagerDelegate，并具有一个方法，该方法提供权重数据

函数receiveweightdata（\udevice:IWDevice！，data:IWWeightData！）

一旦我从任何控制器调用

listenToWeight（）

，我想使用Observable给出数据

如何使用

onReceiveWeightData

方法的数据触发onNext事件，以

listenToWeight

可见

下面是代码

class WeightMachineManager:NSObject{
函数设置（）{
IWDeviceManager.shared（）？.delegate=self
IWDeviceManager.shared（）？.initMgr（）
}
func listenToWeight（）->可观察{
让tag=WeightMachineManager.tag
如果让connectedDevice=connectedDevice{
IWDeviceManager.shared（）？.add（connectedDevice，回调：{（设备，代码）在
如果代码==.success{
打印（“\（标记）[成功]已成功添加设备。”）
}否则{
打印（“\（标记）[失败]添加设备失败。”）
}
})
}否则{
打印（“\（标记）[失败]找不到任何要连接的设备。”）
}
}
}
扩展权重机器管理员：IWDeviceManagerDelegate{
func onReceiveWeightData（device:IWDevice！，数据：IWWeightData！）{
//TODO:-在listenToWeight的observable的onNext事件中传递此数据。
}
}

我在下面做了很多假设，但结果应该是这样的：

class WeightMachineManager {

    var connectedDevice: IWDevice?

    func setup() {
        IWDeviceManager.shared()?.initMgr()
    }

    func listenToWeight() -> Observable<IWWeightData> {
        if let connectedDevice = connectedDevice, let deviceManager = IWDeviceManager.shared() {
            return deviceManager.rx.add(connectedDevice)
                .flatMap { deviceManager.rx.receivedWeightData() } // maybe this should be flatMapLatest or flatMapFirst. It depends on what is calling listenToWeight() and when.
        }
        else {
            return .error(NSError.init(domain: "WeightMachineManager", code: -1, userInfo: nil))
        }
    }
}

extension IWDeviceManager: HasDelegate {
    public typealias Delegate = IWDeviceManagerDelegate
}

class IWDeviceManagerDelegateProxy
    : DelegateProxy<IWDeviceManager, IWDeviceManagerDelegate>
    , DelegateProxyType
    , IWDeviceManagerDelegate {

    init(parentObject: IWDeviceManager) {
        super.init(parentObject: parentObject, delegateProxy: IWDeviceManagerDelegateProxy.self)
    }

    public static func registerKnownImplementations() {
        self.register { IWDeviceManagerDelegateProxy(parentObject: $0) }
    }
}

extension Reactive where Base: IWDeviceManager {

    var delegate: IWDeviceManagerDelegateProxy {
        return IWDeviceManagerDelegateProxy.proxy(for: base)
    }

    func add(_ device: IWDevice) -> Observable<Void> {
        return Observable.create { observer in
            self.base.add(device, callback: { device, code in
                if code == .success {
                    observer.onNext(())
                    observer.onCompleted()
                }
                else {
                    observer.onError(NSError.init(domain: "IWDeviceManager", code: -1, userInfo: nil))
                }
            })
            return Disposables.create()
        }
    }

    func receivedWeightData() -> Observable<IWWeightData> {
        return delegate.methodInvoked(#selector(IWDeviceManagerDelegate.onReceiveWeightData(_:data:)))
            .map { $0[1] as! IWWeightData }
    }
}

class WeightMachineManager{
var连接设备：IWDevice？
函数设置（）{
IWDeviceManager.shared（）？.initMgr（）
}
func listenToWeight（）->可观察{
如果让connectedDevice=connectedDevice，则让deviceManager=IWDeviceManager.shared（）{
返回设备管理器.rx.add（连接的设备）
.flatMap{deviceManager.rx.receivedWeightData（）}//可能应该是flatMapLatest或flatMapFirst。这取决于调用listenToWeight（）的内容和时间。
}
否则{
return.error（NSError.init（域：“WeightMachineManager”，代码：-1，用户信息：nil））
}
}
}
扩展IWDeviceManager:HasDelegate{
public-typealias-Delegate=IWDeviceManagerDelegate
}
IWDeviceManager类LegateProxy
：委派代理
，DelegateProxyType
，iDeviceManagerDelegate{
init（父对象：IWDeviceManager）{
init（parentObject:parentObject，delegateProxy:IWDeviceManagerDelegateProxy.self）
}
公共静态函数注册表项KnownImplements（）{
self.register{IWDeviceManagerDelegateProxy（父对象：$0）}
}
}
扩展无功where Base:IWDeviceManager{
变量委托：IWDeviceManagerDelegateProxy{
返回IWDeviceManagerDelegateProxy.proxy（for:base）
}
func add（u设备：IWDevice）->可观察{
返回可观察的。在中创建{observer
self.base.add（设备，回调：{device，中的代码
如果代码==.success{
observer.onNext（（））
observer.onCompleted（）
}
否则{
observer.onError（NSError.init（域：“IWDeviceManager”，代码：-1，用户信息：nil））
}
})
返回一次性物品。创建（）
}
}
func receivedWeightData（）->可观察{
返回delegate.methodInvoked（#选择器（IWDeviceManagerDelegate.onReceiveWeightData（#：数据：））
.map{$0[1]作为！IWWeightData}
}
}

什么是

ICDeviceManager

？什么是

IWDeviceManagerDelegate

？它们之间有某种联系吗？您的

listenToWeight（）

从未返回任何内容。@DanielT。是的，它们是相互关联的

IWDeviceManager

连接到硬件的管理器

IWDeviceManagerDelegate

是协议。该协议具有返回权重数据的方法。我不知道在

listenToWeight（）

方法中返回什么，因为在那里我只分配必须测量重量的设备。devices sdk在

IWDeviceManagerDelegate的

方法中返回权重。答案可以在这里找到：谢谢你的帖子，如果你不介意的话，可以在我的代码中给我看一下吗非常感谢。您是反应式编程的专家。

扩展IWDeviceManager:hasdegate

要求添加

var delegate:delegate？{get set}

在那里。我想你没有把它添加到那里。在你的问题中，你调用了

。delegate=self

。这告诉我var已经存在。不，很抱歉它没有存在，那么我在这里做什么呢？是的，您做了：

IWDeviceManager.shared（）？.delegate=self

。也就是说，要解决这个问题，您需要为委托实现一个

{get set}

，并获取和设置委托。