再造虫洞：一次 Objective-C 到 Swift 的改写之旅

既然 Swift 是未来，那手工将一些 Objective-C 的代码转成 Swift 就挺有必要。但如果只是简单的改写，而不使用 Swift 的特点，这个过程就会变得乏味。改写应当是一种再思考、再设计的过程。

作者：@nixzhu

我第一次知道有个叫 MMWormhole 的项目时，这个名字让我很是激动。又了解到它主要用于 iOS 扩展与主应用的实时通信，更让这个名字十分合理。因为物理上的虫洞就是一种能让我们不受空间的限制，远距离传递信息的超空间通道。

于是我去看它的代码，奇怪的是它为何用 Objective-C 写成。按理说，Swift 的发布也有一段时间了。这个项目又是用于扩展和主应用的通信，而且主要是为 WATCH 和对应 iPhone 应用的通信，用 Swift 来写不是更具有未来感吗？

因此我想到去改写，并看看用 Swift 去实现它是否会遇到困难。

分析

MMWormhole 的主要代码不过 300 行，看起来很容易，因此先分析一下它的 API

首先是初始化：

  1. - (instancetype)initWithApplicationGroupIdentifier:(NSString *)identifier
  2.                                  optionalDirectory:(NSString *)directory

它接收一个 App Group ID 和一个可选的目录名，表明了虫洞的实现需要 App Group 的支持。这很好理解，因为 iOS 应用的扩展和主应用并不在同一个沙盒内，要让它们通信，只能用 App Group，或者网络。

有了虫洞，就可以往里面传递消息：

  1. - (void)passMessageObject:(id <NSCoding>)messageObject
  2.                identifier:(NSString *)identifier;

它需要消息的名字，以及一个满足 NSCoding 协议的对象。具其文档解释，是因为它使用了 NSKeyedArchiver 来作为序列化媒介来将 messageObject 存储于 App Group 所在的文件系统里，以便虫洞的另一端读取。在实现上，为了及时性，它会使用 Darwin Notify Center 来发送一个名为 identifier 的通知。这种通知作用于整个系统范围，因此可以在 Extension 与 Container App 之间通信，但接收端必须处于 awake 状态。

有了传递，自然就有接收：

  1. - (void)listenForMessageWithIdentifier:(NSString *)identifier
  2.                               listener:(void (^)(id messageObject))listener;

这个方法监听特定的消息，并在听到时执行一个 block，很好理解。而且很明显，我们可以为一种消息增加多个监听者。只要多调用这个方法几次即可。

有了监听，就该有取消监听：

  1. - (void)stopListeningForMessageWithIdentifier:(NSString *)identifier;

但很遗憾，这个方法会移除所有监听此消息的监听者，而不能单个的移除。如果我们要用 Swift 改写，这该是一个可以改进的地方。

另外还有三个方法：

  1. - (id)messageWithIdentifier:(NSString *)identifier;
  3. - (void)clearMessageContentsForIdentifier:(NSString *)identifier;
  5. - (void)clearAllMessageContents;

分别用于根据消息的 ID 获取消息对象（在初始化时很有用，可以获取“过去”的消息），以及从文件系统中清除消息对象（单个，或全部）

改写

先定 API 如下：

  1. init(appGroupIdentifier: String, messageDirectoryName: String)
  3. func passMessage(message: Message?, withIdentifier identifier: String)
  5. func bindListener(listener: Listener, forMessageWithIdentifier identifier: String)
  7. func removeListener(listener: Listener, forMessageWithIdentifier identifier: String)
  9. func removeListenerByName(name: String, forMessageWithIdentifier identifier: String)
  11. func removeAllListenersForMessageWithIdentifier(identifier: String)
  13. func messageWithIdentifier(identifier: String) -> Message?
  15. func destroyMessageWithIdentifier(identifier: String)
  17. func destroyAllMessages()

除了 API 的命名外，并无太大区别。只是现在我们可以为某个消息移除单个 Listener 了。至于具体的实现，首先是一些类型定义：

  1. typealias Message = NSCoding

将 Message 作为 NSCoding 的别名，非常直观。然后是 Listener：

  1. struct Listener {
  3.     typealias Action = Message? -> Void
  5.     let name: String
  6.     let action: Action
  8.     init(name: String, action: Action) {
  9.         self.name = name
  10.         self.action = action
  11.     }
  12. }

Listener 有一个名字和一个操作。这也是有别于 MMWormhole 的地方，它的 listener 只是一个 block，相当于这里的 action，而没有名字，因此无法单独移除。

接下来我们实现 passMessage：

  1. func passMessage(message: Message?, withIdentifier identifier: String) {
  3.     if identifier.isEmpty {
  4.         fatalError("ERROR: Message need identifier")
  5.     }
  7.     if let message = message {
  8.         var success = false
  10.         if let filePath = filePathForIdentifier(identifier) {
  11.             let data = NSKeyedArchiver.archivedDataWithRootObject(message)
  12.             success = data.writeToFile(filePath, atomically: true)
  13.         }
  15.         if success {
  16.             if let center = CFNotificationCenterGetDarwinNotifyCenter() {
  17.                 CFNotificationCenterPostNotification(center, identifier, nil, nil, 1)
  18.             }
  19.         }
  21.     } else {
  22.         if let center = CFNotificationCenterGetDarwinNotifyCenter() {
  23.             CFNotificationCenterPostNotification(center, identifier, nil, nil, 1)
  24.         }
  25.     }
  26. }

也很简单，首先确保消息的 identifier 不为空，不然接收端没办法区别不同的消息。然后根据消息主体的有无（有时候我们只需要 identifier 即可）来决定 CFNotificationCenterPostNotification 的时机，如有，就生成一个 filePath 并用 NSKeyedArchiver 将消息压缩为 NSData 在写入文件，在保证成功的前提下发送通知；如无，直接发送通知。

然后是实现 bindListener，这是真正的考验，因为 CFNotificationCenterAddObserver 

  1. void CFNotificationCenterAddObserver (
  2.    CFNotificationCenterRef center,
  3.    const void *observer,
  4.    CFNotificationCallback callBack,
  5.    CFStringRef name,
  6.    const void *object,
  7.    CFNotificationSuspensionBehavior suspensionBehavior
  8. );

需要的参数中的第三个 CFNotificationCallback 是函数指针，而 Swift (1.2) 还不能创建函数指针。基本上，这就会强制你写 Objective-C 代码，这也解决了之前的疑惑，为何 MMWormhole 用 Objective-C 来写。很明显，既然具体的实现离不开 Objective-C，那不妨全部用 Objective-C 来写。

但是（是的，世界上充满了但是）我还不打算放弃，因为在 Swift 中依然可以使用 Objective-C 的运行时。通过它，也许我们不需要显式的 Objective-C 代码就能构造出一个函数指针来。

根据这篇文章提到的一种 hack 方法（也就意味着有风险），我们可以将一个 Swift 的闭包转换为一个某个对象的 IMP，而 IMP 正是函数指针的一个别名。因此，bindListener 的实现如下：

  1. func bindListener(listener: Listener, forMessageWithIdentifier identifier: String) {
  3.     if let center = CFNotificationCenterGetDarwinNotifyCenter() {
  5.         let messageListener = MessageListener(messageIdentifier: identifier, listener: listener)
  6.         messageListenerSet.insert(messageListener)
  8.         let block: @objc_block (CFNotificationCenter!, UnsafeMutablePointer<Void>, CFString!, UnsafePointer<Void>, CFDictionary!) -> Void = { _, _, _, _, _ in
  10.             if self.messageListenerSet.contains(messageListener) {
  11.                 messageListener.listener.action(self.messageWithIdentifier(identifier))
  12.             }
  13.         }
  15.         let imp: COpaquePointer = imp_implementationWithBlock(unsafeBitCast(block, AnyObject.self))
  16.         let callBack: CFNotificationCallback = unsafeBitCast(imp, CFNotificationCallback.self)
  18.         CFNotificationCenterAddObserver(center, unsafeAddressOf(self), callBack, identifier, nil, CFNotificationSuspensionBehavior.DeliverImmediately)
  21.         // Try fire Listener's action for first time
  23.         listener.action(messageWithIdentifier(identifier))
  24.     }
  25. }

之所以一定要实现这个 callBack，是因为我们必须在这个 callBack 里调用我们的 Listener 的 Action 闭包以便执行使用此消息的一些操作。另外请注意 block 的形式参数都是 _, _, _, _, _， 一半原因是我的实现不需要使用到它们，另一半原因是这终究是一种 hack 的方法，也许有失效的一天，而不使用其参数可能减轻不利影响。

需要注意的是，在 Wormhole 内部，我增加了一个 MessageListener：

  1. func ==(lhs: Wormhole.MessageListener, rhs: Wormhole.MessageListener) -> Bool {
  2.     return lhs.hashValue == rhs.hashValue
  3. }
  5. struct MessageListener: Hashable {
  7.     let messageIdentifier: String
  8.     let listener: Listener
  10.     var hashValue: Int {
  11.         return (messageIdentifier + "<nixzhu.Wormhole>" + listener.name).hashValue
  12.     }
  13. }

用于封装 Listener 和 messageIdentifier。而且它满足 Hashable 协议，这样用集合 var messageListenerSet = Set<MessageListener>() 来装载所有的 MessageListener 就能带来好处：方便判断 Listener 的有效性，自动更新监听同一个 Message 的同名 Listener，也可以单独移除某一个 Listener。

除了 removeListener 外，其它的 API 就只是基本的改写，并无介绍的必要，有兴趣的读者请自行阅读代码，地址为：https://github.com/nixzhu/Wormhole。

欢迎转载，但请一定注明出处！ https://github.com/nixzhu/dev-blog