知乎 iOS 插件系统实践

// MARK: - TestMessagestruct TestMessage: PluginMessage {}func test() {    let composerA = PluginContainerComposer()
    let containerB = PluginContainer()    let composerB = PluginContainerComposer()
    composerA.compose(containerB)    composerA.compose(composerB)
    composerA.send(message: TestMessage())}

// MARK: - ComposibleContainerprotocol ComposibleContainer: AnyObject {    var containerAssociatedKey: ContainerAssociatedKey? { get set }    func receive(containerMessage: any PluginMessage, containerId: String)}extension ComposibleContainer {    var id: String { objectIdentifier(self) }}

// MARK: - PluginContainerComposer/// A special plugin container that can compose multiple `ComposibleContainer`s to relay messages among them.public final class PluginContainerComposer: ComposibleContainer {    private var composedContainers: [ComposibleContainer] = []
    var containerAssociatedKey: ContainerAssociatedKey?
        func compose(containers: [ComposibleContainer]) {        for container in containers {            if id == container.id {                assertionFailure("The container composer cannnot compose itself.")                return            }
            let deallocHook = DeallocHook { [weak self, weak container] in                guard let self, let container else { return }
                self.composedContainers.removeAll(where: { container.id == $0.id })            }            container.containerAssociatedKey = .init(associatedContainer: self, deallocHook: deallocHook)            composedContainers.append(container)        }    }
    func receive(containerMessage: PluginMessage, containerId: String) {        for container in composedContainers {            if container.id == containerId { continue }            container.receive(containerMessage: containerMessage, containerId: id)        }        containerAssociatedKey?.associatedContainer?.receive(containerMessage: containerMessage, containerId: id)    }}extension PluginContainerComposer {    public func send(message: any PluginMessage) {        receive(containerMessage: message, containerId: id)    }
    public func compose(_ containers: PluginContainer...) {        compose(containers: containers)    }
    public func compose(_ multiContainers: PluginContainerComposer...) {        compose(containers: multiContainers)    }}

/// MessageRelay Protocol/// Every conforming types can receive plugin messages with the `MessageObserver`, just like a plugin.public protocol MessageRelay: AnyObject {    func messageRelayConnected(messageSender: any MessageSender)}

/// MessageSender Protocolpublic protocol MessageSender {    /// A convenience observer for bridgin to RxSwift/ReactorKit seamlessly.    /// Every `PluginMessage` signal bound to this `publisher` will trigger the `send(message:)` method.    var publisher: AnyObserver<any PluginMessage> { get }
    /// Sends a plugin message.    func send(message: any PluginMessage)
    /// Relays messages to a message relay.    /// - Note: The `messageRealy` won't be retained.    @discardableResult    func relayMessages(to messageRelay: any MessageRelay) -> Result<Void, Error>}

var deallocHookKey = "ZHPluginSDK_deallocHookKey"// MARK: MessageSenderextension InnerMessageSender: MessageSender {    var publisher: AnyObserver<any PluginMessage> { messageObserver.asObserver() }
    func send(message: PluginMessage) {        messageCenter?.send(message: message, fromContainer: false)    }
    @discardableResult    func relayMessages(to messageRelay: MessageRelay) -> Result<Void, Error> {        guard let messageCenter else { return .failure("Never") }
        lock.lock()        defer { lock.unlock() }
        let relayIdentifier = messageRelay.id        if messageCenter.messageRelays[relayIdentifier] != nil {            return .failure("Has already been relayed")        }
        // Removes the message relay from the cache map when it releases.        let deallocCallback = DeallocHook(handler: { [weak self] in            self?.lock.lock()            self?.messageCenter?.messageRelays.removeValue(forKey: relayIdentifier)            self?.lock.unlock()        })        objc_setAssociatedObject(            messageRelay,            &deallocHookKey,            deallocCallback,            .OBJC_ASSOCIATION_RETAIN_NONATOMIC        )
        messageCenter.messageRelays[relayIdentifier] = WeakBox(messageRelay, policy: .weak)
        messageRelay.messageRelayConnected(messageSender: self)
        return .success(())    }}

import Foundation// MARK: - TestMessagestruct TestMessage: PluginMessage {}// MARK: - PluginAclass PluginA: Plugin {    @MessageObserver    var testMessage: TestMessage?
    let component = ComponentB()
    required init?(params: Any?) {}
    func pluginInitialized(        messageSender: MessageSender,        name: String?,        slotViewAccessor: @escaping (String?) -> PluginSlotView?    ) {        messageSender.relayMessages(to: component)    }
    func queryView(with viewId: String) -> UIView? { nil }}// MARK: - ComponentBclass ComponentB: MessageRelay {    @MessageObserver    var testMessage: TestMessage?
    let component = ComponentC()
    func messageRelayConnected(messageSender: MessageSender) {        messageSender.relayMessages(to: component)    }}// MARK: - ComponentCclass ComponentC: MessageRelay {    @MessageObserver    var testMessage: TestMessage?
    func messageRelayConnected(messageSender: MessageSender) {}}func test() {    let pluginContainer = PluginContainer()    pluginContainer.addPlugin(PluginA.self)}

public protocol SyncPluginMessage {    associatedtype Response}

struct RouteToMessage: SyncPluginMessage {    typealias Response = Bool    let destinationUr: String    }

struct LiveUser {    let id: String    let name: String    let avator: String}struct QueryLiveUserInfo: SyncPluginMessage {    typealias Response = LiveUser
    let userId: String}

func send<Message: SyncPluginMessage>(message: Message, strategy: SyncMessageDispatchStrategy) -> [Message.Response]

let results: [Bool] = sender.send(message: RouteToMessage(destinationUrl: "zhihu://education/live_room/123", channe: String, strategy: .first(1))

 public func send<Message: SyncPluginMessage>(message: Message) -> Message.Response? {        send(message: message, strategy: .first(1)).first    }

class RouteManagerPlugin: Plugin {
    @SyncMessageObserver<RouteManagerPlugin, RouteToMessage>    private var routeToMessage = .init { base, message in        return base.route(to: message.destinationUrl)    }   @SyncMessageObserver<RouteManagerPlugin, RouteToMessage>(channel: "")    private var routeToMessage2 = .init { base, message in        return base.route(to: message.destinationUrl)    }    @MessageObserver    private var requestToHomepage: $RequestToHomepage?    private func route(to url: String) -> Bool {        ...    }}

containerA.register(messageInterceptor: .listen(receiveSyncMessage: { syncMessage in     switch syncMessage {     case let message as SyncMessageY:         print(message)     default:         break     } }))

containerA.register(messageInterceptor: SyncMessageInterceptor<SyncMessageY>(receiveSyncMessage: { message, transformer, strategy in    // 拦截响应不继续派发    // return [];    // 拦截响应不继续派发，并注入返回值    // return ["value from containerA"]    // 不影响派发流程，只是记录日志, listen 的逻辑    // Log.debug("receive a sync message.")    // return transformer.transform(to: message, strategy: strategy)    // 变更派发流程    let results = transformer.transform(to: MessageB(), strategy: .first(1))    return results + transformer.transform(to: message, strategy: strategy)}))

protocol SyncMessage<Response> {    associatedtype Response}struct JumpToHomePage: SyncMessage {    typealias Response = Bool    }struct JumpToWallet: SyncMessage {    typealias Response = Void}protocol Plugin {}protocol AnySyncMessageObserver<Message> {    associatedtype Message: SyncMessage    func invoke(_ observer: Any, _ message: Message) -> Message.Response}@propertyWrapperclass SyncMessageObserver<Observer, Message: SyncMessage>: AnySyncMessageObserver {    var wrappedValue: (Observer, Message) -> Message.Response
    func invoke(_ observer: Any, _ message: Message) -> Message.Response {        wrappedValue(observer as! Observer, message)    }
    init(wrappedValue: @escaping (Observer, Message) -> Message.Response) {        self.wrappedValue = wrappedValue    }}class PluginA: Plugin {    private var state = true
//  #SyncMessageObserver<JumpToHomePage> { base, message in//      base.state//  }
    @SyncMessageObserver<PluginA, JumpToHomePage>    private var jumpToHomePage = { base, message in        base.state    }
    private var jumpToWallet = SyncMessageObserver<PluginA, JumpToWallet>{ base, messge in
    }}class MessageSender {        func send<M: SyncMessage>(_ message: M) -> [M.Response] {        let objects: [Plugin] = [PluginA()]        var results: [M.Response] = []        for item in objects {            for child in Mirror(reflecting: item).children {                                if let method = child.value as? any AnySyncMessageObserver<M> {                                       if let result = method.invoke(item, message) as? M.Response {                        results.append(result)                    }                }            }        }                return results    }}let result = MessageSender().send(JumpToHomePage())print(result)

// MARK: - Plugin/// Plugin Protocolpublic protocol Plugin {    /// Initializes a plugin with initialization parameters.    init?(params: Any?)
    /// The plugin has initialized and ready for sending/receiving messages or setting up UI.    func pluginInitialized(        messageSender: any MessageSender,        name: String?,        slotViewAccessor: @escaping (String?) -> PluginSlotView?    )
    /// Queries a specific view in the plugin system by the `viewId`.    func queryView(with viewId: String) -> UIView?
    /// Will be released.    func pluginDeinit()}extension Plugin {    public func pluginDeinit() {}}

import UIKitclass InputBarViewController: UIViewController {    private var messageSender: MessageSender?
    required init?(params: Any?) {        super.init(nibName: nil, bundle: nil)    }
    required init?(coder: NSCoder) {        fatalError("init(coder:) has not been implemented")    }}extension InputBarViewController: Plugin {    func pluginInitialized(        messageSender: MessageSender,        name: String?,        slotViewAccessor: @escaping (String?) -> PluginSlotView?    ) {        self.messageSender = messageSender
        guard            let viewAccessor = slotViewAccessor(nil),            let parentVC = viewAccessor.slotViewController        else { return }
        willMove(toParent: parentVC)        parentVC.addChild(self)        viewAccessor.slotView.addSubview(view)        view.snp.makeConstraints {            $0.edges.equalToSuperview()        }    }
    func queryView(with viewId: String) -> UIView? {        nil    }}

// MARK: - PluginMessage/// PluginMessage Protocolpublic protocol PluginMessage {    /// The `type` decides the message's dispatching policy. default to `event`.    static var type: PluginMessageType { get }}// MARK: - PluginMessageTypepublic enum PluginMessageType {    /// Event message.    case event
    /// State Message    ///    /// Messages of same types will be cached by the message centor,    /// subsequently added plugins will recevie these cached messages again for asyncing state.    case state}extension PluginMessage {    public static var type: PluginMessageType { .event }}

/// 消息： 发送一个文本聊天消息struct SendTextMessage: PluginMessage {    let text: String}

class LiveRoomViewController: UIViewController {    // 1. 创建 pluginContainer    let pluginContainer = PluginContainer()
    // 直播间负责管理视图的布局， 这里可以先为 UI 插件创建视图容器，后续方便做布局和动画    private let inputBarArea = UIView()    private let chatViewArea = UIView()
    override func viewDidLoad() {        super.viewDidLoad()

        view.addSubview(inputBarArea)        view.addSubview(chatViewArea)        inputBarArea.snp.makeConstraints {            $0.leading.bottom.trailing.equalToSuperview()            $0.height.equalTo(44)        }        chatViewArea.snp.makeConstraints {            $0.leading.trailing.equalToSuperview()            $0.bottom.equalTo(inputBarArea.snp.top)            $0.height.equalTo(500)        }
        // 2. 设置插件视图容器，并插入两个插件        pluginContainer.config(viewContainer: self, retainPolicy: .weak)        pluginContainer.addPlugin(ChatViewController.self)        pluginContainer.addPlugin(InputBarViewController.self)    }}// 3. 让 LiveRoomViewController 作为视图管理容器根据插件类型返回对应的插槽视图extension LiveRoomViewController: PluginViewContainer {    func slotView(pluginType: Plugin.Type, pluginName: String?, viewId: String?) -> PluginSlotView? {        switch pluginType {        case is ChatViewController.Type:            return AnyPluginSlotView(slotView: chatViewArea, slotViewController: self)        case is InputBarViewController.Type:            return AnyPluginSlotView(slotView: inputBarArea, slotViewController: self)        default:            return nil        }    }}

class InputBarViewController: UIViewController {    private var messageSender: MessageSender?    ...    private func send(text: String) {        // 1. 利用 messageSender 发送消息        messageSender?.send(message: SendTextMessage(text: text))    }    ...}

class ChatViewController: UIViewController {        // 1. 注册消息监听    @MessageObserver    private var receiveTextMessage: SendTextMessage?
    private let disposeBag = DisposeBag()    ...            override func viewDidLoad() {        super.viewDidLoad()
        // 2. 通过 $receiveTextMessages 就可以进行消息监听，        // 而且监听时收到的 message 是非可选值        $receiveTextMessage.bind(onNext: { message in            print("receive text message: \(message.text)")        }).disposed(by: disposeBag)    }    ...}

class PluginContainer {       /// Registers a `PluginParamProvider` for providing initialization data for plugins.    /// - Note: Must be invoked before registering plugins.    public func register(        pluginParamProvider: PluginParamProvider,        retainPolicy: RetainPolicy    )}

// MARK: - PluginParamProviderpublic protocol PluginParamProvider {    func initializationParam(pluginType: Plugin.Type, name: String?) -> Any?}

    /// Registers a plugin.    /// - Parameters:    ///   - pluginType: Meta type of the plugin.    ///   - name: Name of the plugin. Same type plugins can be registered with different names.    ///   - replaceExistingPlugin: Replaces the old plugin when registering a new plugin whth the same type.    ///   - messageObservingPriority: The higher priority will receive messages earlier.    /// - Returns: `true` means registered successfully.    @discardableResult    public func addPlugin(        _ pluginType: Plugin.Type,        name: String? = nil,        replaceExistingPlugin: Bool = false,        messageObservingPriority: MessageObservingPriority = .normal    ) -> Bool

// MARK: - MessageObservingPrioritypublic struct MessageObservingPriority: ExpressibleByIntegerLiteral, Comparable {    public let rawValue: Int
    public init(integerLiteral value: Int) {        self.rawValue = value    }
    public static func priority(_ value: Int) -> Self {        self.init(integerLiteral: value)    }
    public static func < (lhs: MessageObservingPriority, rhs: MessageObservingPriority) -> Bool {        lhs.rawValue < rhs.rawValue    }}extension MessageObservingPriority {    public static let low: Self = 100    public static let normal: Self = 1000    public static let high: Self = 10000}

  /// Registers a message interceptor, the lastest inserted interceptor will intercept messages firstly.    public func register(        messageInterceptor: any MessageInterceptor,        retainPolicy: RetainPolicy = .retain    )

/// Message Interceptorpublic protocol MessageInterceptor {    var uniqueId: any Hashable { get }    /// Intercepts messages and then discards or converts them.    /// - Parameters:    ///   - message: The recevied message.    ///   - transformer: Uses the method `transform(to:)` of the transformer to dispath new converted messages.    /// - Note: The recevied message will be discarded if you don't call the `transform(to:)` method once.    func intercept(message: any PluginMessage, transformer: MessageTransformer)}// MARK: - MessageTransformer/// Message Transformer/Dispatcherpublic struct MessageTransformer {    ...    /// Dispatches a new plugin message.    public func transform(to message: any PluginMessage)    ...}

pluginContainer.register(messageInterceptor: .listen({ message in
}))

extension PluginContainer {    public func setEnvironment<E>(_ environmentObject: E, key: (any Hashable)? = nil, policy: RetainPolicy = .retain) {        environments.updateValue(.init(environmentObject, policy: policy), forKey: key?.hashValue ?? typeIdentifier(E.self).hashValue)    }}

class LiveRoomInfo {    let roomId: String    var imState: LiveIMState = .disconnected}class ChatPlugin: Plugin {    @PluginEnvironment    var liveRoomInfo: LiveRoomInfo?    /// ....
    private func send(message: String) {        guard let liveRoomInfo else { return }
        if liveRoomInfo.imState != .connected {            Toast.show("IM 服务链接中断")            return        }    }}// ....class RootViewController: UIViewController {    let rootContainer = PluginContainer()    let liveRoomInfo = LiveRoomInfo()    func viewDidLoad() {                rootContainer.setEnvironment(liveRoomInfo)        rootContainer.addPlugin(ChatPlugin.self)    }}