NSCollectionView的选中与恢复

2019/12/22 09:18 AM

在使用NSCollectionView中发现，如果有选中的项目，那么在重新加载后，选中的项目可能会出现随机的错位。如图：

seleted ite

已经选中了中间的项目，点击底部的Reload按钮后，选中的背景跑到右边的项目上去了。

seleted item reload

代码如下：

import Cocoa

class ViewController: NSViewController {
    @IBOutlet weak var collectionView: NSCollectionView!
    
    private var sources:[String] = [
        "step one",
        "step two",
        "step three",
        "step four",
        "step five",
        "step six",
        "step seven",
        "step eight"
    ]
    
    override func viewDidLoad() {
        super.viewDidLoad()

        registerCollectionViewItem()
    }
    
    private func registerCollectionViewItem() {
        collectionView.register(Item.self, forItemWithIdentifier: NSUserInterfaceItemIdentifier("Item"))
    }

    override var representedObject: Any? {
        didSet {
        // Update the view, if already loaded.
        }
    }

    @IBAction func reloadButtonClicked(_ sender: Any) {
        collectionView.reloadData()
    }
}

extension ViewController:NSCollectionViewDataSource {
    func collectionView(_ collectionView: NSCollectionView, numberOfItemsInSection section: Int) -> Int {
        return sources.count
    }
    
    func collectionView(_ collectionView: NSCollectionView, itemForRepresentedObjectAt indexPath: IndexPath) -> NSCollectionViewItem {
        
        let item = collectionView.makeItem(withIdentifier: NSUserInterfaceItemIdentifier("Item"), for: indexPath)
        item.textField?.stringValue = self.sources[indexPath.item]
         
        return item
    }
}

extension ViewController:NSCollectionViewDelegateFlowLayout {
    func collectionView(_ collectionView: NSCollectionView, didSelectItemsAt indexPaths: Set<IndexPath>) {
        print("select")
    }
    
    func collectionView(_ collectionView: NSCollectionView, didDeselectItemsAt indexPaths: Set<IndexPath>) {
        print("deselect")
    }
}

注意：上面提到，跑偏的是“选中的背景”，而“非选中的状态”。因为在collectionView.reloadData()之后，所有的选中状态都清空了。

@IBAction func reloadButtonClicked(_ sender: Any) {
    print(collectionView.selectionIndexPaths.count) // print 1
    
    collectionView.reloadData()
    
    print(collectionView.selectionIndexPaths.count) // print 0
}

根据苹果文档，重新加载的过程是

Call this method when the data in your data source object changes or when you want to force the collection view to update its contents. When you call this method, the collection view discards any currently visible items and views and redisplays them.

也就是说，在数据源改变的时候，重新加载。而如果我们的数据源没有包含选中的信息，大多数情况，我们不会将选中信息保存到数据源，那么重新加载之后，选中的状态就消失了。

分析

既然状态是清空的，为什么还会有错位显示“选中的背景”的问题呢？这是因为，苹果在重新加载的时候，为了效率，会重复使用之前创建的项目，同时还采用了并行的处理方式进行生成，因此，会导致显示背景的错乱。

解决思路有两个，一个是手动恢复选择。一个是将选中状态写到数据源。

方法一：手动恢复选择

思路：先保存选中的数据，然后重新加载，最后恢复。代码如下：

@IBAction func reloadButtonClicked(_ sender: Any) {
    let indexPaths = collectionView.selectionIndexPaths
    
    collectionView.reloadData()
    
    collectionView.selectItems(at: indexPaths, scrollPosition: .init())
}

func collectionView(_ collectionView: NSCollectionView, itemForRepresentedObjectAt indexPath: IndexPath) -> NSCollectionViewItem {
    
    let item = collectionView.makeItem(withIdentifier: NSUserInterfaceItemIdentifier("Item"), for: indexPath)
    item.textField?.stringValue = self.sources[indexPath.item]
    
    item.highlightState = .none
     
    return item
}

注意看一下第14行，即item.highlightState = .none，因为在应用中恢复选中，并不会激发选中的状态改变，所以我们必须手动更新选中状态。这里相应的代码如下。

import Cocoa

class Item: NSCollectionViewItem {

    override func viewDidLoad() {
        super.viewDidLoad()
        
        self.view.wantsLayer = true
        self.highlightState = .none
    }
    
    override var highlightState: NSCollectionViewItem.HighlightState {
        didSet {
            switch highlightState {
            case .none:
                self.view.layer?.backgroundColor = isSelected ? NSColor.systemBlue.withAlphaComponent(0.8).cgColor : NSColor.systemGreen.withAlphaComponent(0.8).cgColor
            case .forSelection:
                self.view.layer?.backgroundColor = NSColor.systemBlue.withAlphaComponent(0.5).cgColor
            case .forDeselection:
                self.view.layer?.backgroundColor = NSColor.systemGreen.withAlphaComponent(0.5).cgColor
            case .asDropTarget:
                fatalError()
            @unknown default:
                fatalError()
            }
        }
    }
}

那么问题来了，我们的思路是先重新加载，之后恢复选中。既然是这样的顺序，为什么在重新加载的时候，项目会是已经选中的状态呢？不应该是重新加载完成，才选中的吗？这是因为，所有的重新加载，都不是立即重新加载的。而是先恢复状态，然后在下一个事件循环才加载。所以实际的运行类似如下的伪代码：

public func reloadData() {
    // 恢复状态
    DispatchQueue.main.async {
        // 重新加载
    }
}

因此，实际运行的顺序是：

恢复状态
恢复选中
重新加载

这样在实际的重新加载中，项目本身已经是选中的状态了。

另外一个小问题

我们知道，在macOS中，我们可以使用快捷键来进行一些常用的操作。比如利用cmd+a，我们可以进行全部选中。但是如果现在我们使用全部选中，虽然在控制台，我们看到的确是选中了。但是实际上，选中的背景并没有应用。这是因为NSCollectionViewItem.highlightState是针对鼠标操作的，直接用键盘操作，没有鼠标操作的过程，因此背景颜色就没有改变。

分析

highlightState没有改变的，但是选中状态改变了。所以我们在选中状态改变之后，进行背景颜色的改变。代码如下：

import Cocoa

class Item: NSCollectionViewItem {
    
    override var isSelected: Bool {
        didSet {
            self.view.layer?.backgroundColor = isSelected ? NSColor.systemBlue.withAlphaComponent(0.8).cgColor : NSColor.systemGreen.withAlphaComponent(0.8).cgColor
        }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        
        self.view.wantsLayer = true
        self.isSelected = false
    }
    
    override var highlightState: NSCollectionViewItem.HighlightState {
        didSet {
            switch highlightState {
            case .none:
                break
            case .forSelection:
                self.view.layer?.backgroundColor = NSColor.systemBlue.withAlphaComponent(0.5).cgColor
            case .forDeselection:
                self.view.layer?.backgroundColor = NSColor.systemGreen.withAlphaComponent(0.5).cgColor
            case .asDropTarget:
                fatalError()
            @unknown default:
                fatalError()
            }
        }
    }
}

func collectionView(_ collectionView: NSCollectionView, itemForRepresentedObjectAt indexPath: IndexPath) -> NSCollectionViewItem {
    
    let item = collectionView.makeItem(withIdentifier: NSUserInterfaceItemIdentifier("Item"), for: indexPath)
    item.textField?.stringValue = self.sources[indexPath.item]
     
    return item
}

这里，我们移除了.none状态对于背景颜色的改变，而是采用isSelected的didSet。并且在viewDidLoad()中恢复状态。这样，我们就不必在collectionView(_:itemForRepresentedObjectAt:)恢复状态了。

方法二：将选中状态写到数据源

单纯的将选中状态写入到数据源很简单，就不详细叙述了。这里介绍的是在不将选中状态写入到数据源的情况下，利用中间对象来进行处理的办法。

我们创建了一个中间对象StateObject<Element>来保存真正的数据和是否选中的状态。这样，就可以不必在真正的数据源中记录选中信息了。

class ViewController: NSViewController {
    @IBOutlet weak var collectionView: NSCollectionView!
    
    private var sources:[String] = [
        "step one",
        "step two",
        "step three",
        "step four",
        "step five",
        "step six",
        "step seven",
        "step eight"
    ]
    
    lazy private var elements:[StateObject<String>] = self.sources.map { StateObject($0) }
    
    override func viewDidLoad() {
        super.viewDidLoad()

        registerCollectionViewItem()
    }
    
    private func registerCollectionViewItem() {
        collectionView.register(Item.self, forItemWithIdentifier: NSUserInterfaceItemIdentifier("Item"))
    }

    override var representedObject: Any? {
        didSet {
        // Update the view, if already loaded.
        }
    }

    @IBAction func reloadButtonClicked(_ sender: Any) {
        collectionView.reloadData()
    }
}

extension ViewController:NSCollectionViewDataSource {
    func collectionView(_ collectionView: NSCollectionView, numberOfItemsInSection section: Int) -> Int {
        return elements.count
    }
    
    func collectionView(_ collectionView: NSCollectionView, itemForRepresentedObjectAt indexPath: IndexPath) -> NSCollectionViewItem {
        
        let dataObject = elements[indexPath.item]
        let item = collectionView.makeItem(withIdentifier: NSUserInterfaceItemIdentifier("Item"), for: indexPath)
        item.textField?.stringValue = dataObject.object
        
        if dataObject.isSelected {
            item.isSelected = true
            collectionView.selectionIndexPaths.insert(indexPath)
        } else {
            item.isSelected = false
        }
         
        return item
    }
}

extension ViewController:NSCollectionViewDelegateFlowLayout {
    func collectionView(_ collectionView: NSCollectionView, didSelectItemsAt indexPaths: Set<IndexPath>) {
        print("select")
        
        indexPaths.forEach {
            elements[$0.item].isSelected = true
        }
    }
    
    func collectionView(_ collectionView: NSCollectionView, didDeselectItemsAt indexPaths: Set<IndexPath>) {
        print("deselect")
        
        indexPaths.forEach {
            elements[$0.item].isSelected = false
        }
    }
}

class StateObject<Element> {
    var isSelected:Bool
    var object:Element
    
    init(_ object:Element) {
        self.object = object
        isSelected = false
    }
}

import Cocoa

class Item: NSCollectionViewItem {
    
    override var isSelected: Bool {
        didSet {
            self.view.layer?.backgroundColor = isSelected ? NSColor.systemBlue.withAlphaComponent(0.8).cgColor : NSColor.systemGreen.withAlphaComponent(0.8).cgColor
        }
    }

    override func viewDidLoad() {
        super.viewDidLoad()
        
        self.view.wantsLayer = true
    }
    
    override var highlightState: NSCollectionViewItem.HighlightState {
        didSet {
            switch highlightState {
            case .none:
                break
            case .forSelection:
                self.view.layer?.backgroundColor = NSColor.systemBlue.withAlphaComponent(0.5).cgColor
            case .forDeselection:
                self.view.layer?.backgroundColor = NSColor.systemGreen.withAlphaComponent(0.5).cgColor
            case .asDropTarget:
                fatalError()
            @unknown default:
                fatalError()
            }
        }
    }
}

总结

项目的选中，从鼠标点击角度看，一个分成三步：
1. 项目原始状态，此时的NSCollectionViewItem.HighlightState是none。
2. 鼠标按压，此时的NSCollectionViewItem.HighlightState是forSelection。
3. 鼠标放开，此时的NSCollectionViewItem.HighlightState是none。
而如果之前有选中的项目，并且只允许单选的话，那么已选中项目，对应上面2的是forDeselection。
我们可以通过状态none结合isSelected来判断应该设置何种的背景颜色。但是这种方式不如直接在isSelected的didSet中设置更为方便。这是因为，只有鼠标交互才会改变NSCollectionViewItem.HighlightState，而无论何种交互方式，都会改变isSelected，后者才是确认项目是否已经选中的方式。
每次重新加载，NSCollectionView的状态都会立即重置，并且在下一个主线程周期进行实际加载。
我们可以通过暂存并手动恢复的方式来恢复选择，也可以直接将选中状态直接写入到数据源。如果后者不方便，我们可以创建中间对象，来进行处理。
相对于手动恢复的方式，使用中间对象来进行处理，更加自然，代码也更加集中，更方便今后的修改。

苹果文档NotificationCenter中removeObserver(_:)，讨论的部分是错误的

2019/12/18 17:14 PM

苹果的文档，在讨论中说：

If your app targets iOS 9.0 and later or macOS 10.11 and later, you don't need to unregister an observer in its dealloc method. Otherwise, you should call this method or removeObserver(_:name:object:) before observer or any object specified in addObserver(forName:object:queue:using:) or addObserver(_:selector:name:object:) is deallocated.

这里很容易被认为是说，对于iOS 9.0和macOS 10.11以上的系统，开发者没有必要再手动移除观察器了。但是我测试的结果却并非如此。

小实验

view controllers 2

假设两个视图控制器的关系如上图所示。点击上面的视图控制器的Show按钮，会弹出下面的视图控制器，然后点击发送通知按钮，会发送一个通知。代码如下：

import Cocoa

class ViewController: NSViewController {
    static let foo = Notification.Name("foo")

    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

    override var representedObject: Any? {
        didSet {
        // Update the view, if already loaded.
        }
    }

    @IBAction func postNotificationButtonClicked(_ sender: Any) {
        NotificationCenter.default.post(Notification(name: ViewController.foo))
    }
}

import Cocoa

class V2ViewController: NSViewController {
    private let a = 200

    override func viewDidLoad() {
        super.viewDidLoad()
        
        NotificationCenter.default.addObserver(forName: ViewController.foo, object: nil, queue: nil) { [unowned self] (_) in
            
            print("foo!")
            self.run()
        }
    }
    
    deinit {
        print("V2ViewController deinit.")
    }
    
    private func run() {
        print(self.a)
    }
}

测试步骤

运行应用
点击Show按钮
点击Post Notification按钮
关闭弹出的窗口。此时控制台会显示V2视图控制器完全退出。
点击Post Notification按钮。
Xcode提示应用崩溃，因为V2视图控制器已经从内存中销毁了。没有想应的实例。

小结

虽然苹果说对于iOS 9.0和macOS 10.11之后的系统，开发者不必手动移除观察器。但是实际上，如果不移除，那么该观察器就是一直存在的，并有可能造成程序崩溃。

这是因为，NotificationCenter.default是NotificationCenter的静态属性，它一直在内存中存在。注册在它上面的观察器，因此也就一直在内存中存在。

解决

方法1

在deinit中手动移除观察器。

import Cocoa

class V2ViewController: NSViewController {
    private let a = 200
    private var observer:NSObjectProtocol!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        observer = NotificationCenter.default.addObserver(forName: ViewController.foo, object: nil, queue: nil) { [unowned self] (_) in
            
            print("foo!")
            self.run()
        }
    }
    
    deinit {
        if let observer = self.observer {
            NotificationCenter.default.removeObserver(observer)
        }
        
        print("V2ViewController deinit.")
    }
    
    private func run() {
        print(self.a)
    }
}

方法2

使用[weak self]替代[unowned self]。

import Cocoa

class V2ViewController: NSViewController {
    private let a = 200

    override func viewDidLoad() {
        super.viewDidLoad()
        
        NotificationCenter.default.addObserver(forName: ViewController.foo, object: nil, queue: nil) { [weak self] (_) in
            
            print("foo!")
            self?.run()
        }
    }
    
    deinit {
        print("V2ViewController deinit.")
    }
    
    private func run() {
        print(self.a)
    }
}

这个方法只能避免应用的崩溃。其余的代码还是会执行。如果你有涉及到存储之类的操作，这种方式可能并不适合。

方法3

在NotificationCenter.default的文档中，苹果说：

All system notifications sent to an app are posted to the default notification center. You can also post your own notifications there.

If your app uses notifications extensively, you may want to create and post to your own notification centers rather than posting only to the default notification center. When a notification is posted to a notification center, the notification center scans through the list of registered observers, which may slow down your app. By organizing notifications functionally around one or more notification centers, less work is done each time a notification is posted, which can improve performance throughout your app.

我尝试自建一个NotificationCenter的实例。这么做的原理是，既然类属性会一直存在，那么我们就不使用类属性，而是使用实例。实例应该在V2视图控制器销毁时自动销毁。

import Cocoa

class ViewController: NSViewController {
    static let foo = Notification.Name("foo")
    private weak var center:NotificationCenter? = nil

    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

    override var representedObject: Any? {
        didSet {
        // Update the view, if already loaded.
        }
    }

    @IBAction func postNotificationButtonClicked(_ sender: Any) {
        center?.post(Notification(name: ViewController.foo))
    }
    
    override func prepare(for segue: NSStoryboardSegue, sender: Any?) {
        if segue.identifier == "showV2Segue" {
            let v2 = segue.destinationController as! V2ViewController
            center = v2.center
        }
    }
}

import Cocoa

class V2ViewController: NSViewController {
    private let a = 200
    var center  = NotificationCenter()

    override func viewDidLoad() {
        super.viewDidLoad()
        
        center.addObserver(forName: ViewController.foo, object: nil, queue: nil) { [unowned self] (_) in
            
            print("foo!")
            self.run()
        }
    }
    
    deinit {
        print("V2ViewController deinit.")
    }
    
    private func run() {
        print(self.a)
    }
}

我万万没想到，这个方案居然失败了。我本以为NotificationCenter的实例会自动释放。但是实际上并没有。查看苹果的文档。我发现这么一段：

The block is copied by the notification center and (the copy) held until the observer registration is removed.

块被复制到通知中心，（这个复制品）一直存在，知道观察器被移除。

因此，这个其实和closure导致的循环引用是类似的。

方法4

方法3失败了。不过苹果的说明，启发了我对于方法4的尝试。addObserver(_:selector:name:object:)是添加观察器的另外一个方法，它本身不复制块，而是发送消息给指定对象的函数。这个方式很Objective-C。因此，它需要@objc属性的函数。

import Cocoa

class V2ViewController: NSViewController {
    private let a = 200

    @objc fileprivate func extractedFunc() {
        print("foo!")
        self.run()
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()

        NotificationCenter.default.addObserver(self, selector: #selector(extractedFunc), name: ViewController.foo, object: nil)
    }
    
    deinit {
        print("V2ViewController deinit.")
    }
    
    private func run() {
        print(self.a)
    }
}

这个方法才是符合苹果文档的描述的添加方式。
不过，从原理上讲。这个能够生效的原因，是因为addObserver(_:selector:name:object:)的第一个参数，即observer，它是将整个对象作为观察器，然后在需要时发送消息（第二个参数selector）给观察器。因此，当观察器（一般是当前的视图控制器）自动销毁时，就相当于给nil发送了一个消息。这种方式在Objective-C中是允许的，什么事情也不会发生。从理论上讲，这个其实是一种更安全的方法2。

方法5

搞懂了方法4，我们现在可以改进方法2。方法5，改进了方法2。能够达到方法4类似的结果。不过我们要始终记得，无论是方法2还是方法5，只要不采用方法1的方式移除观察器，那么被复制的块就会一直在等待被执行。

import Cocoa

class V2ViewController: NSViewController {
    private let a = 200

    override func viewDidLoad() {
        super.viewDidLoad()
        
        NotificationCenter.default.addObserver(forName: ViewController.foo, object: nil, queue: nil) { [weak self] (_) in
            
            guard let strongSelf = self else { return }
            
            print("foo!")
            strongSelf.run()
        }
    }
    
    deinit {
        print("V2ViewController deinit.")
    }
    
    private func run() {
        print(self.a)
    }
}

总结

综合苹果的文档和实际测试的结果。不难发现，苹果文档存在错误。总结如下：

对于addObserver(_:selector:name:object:)添加的观察器。如果是iOS 9.0，macOS 10.11以后的系统，无需用户手动移除观察器。
对于addObserver(forName:object:queue:using:)添加的观察器。需要使用方法1或方法2的方法来解决。推荐使用方法1。
对于removeObserver(_:)的文档。苹果的讨论是错误的。
addObserver(_:selector:name:object:)的优点是不用手动注销观察器，缺点是需要单独创建一个函数，并且该函数必须是@objc的动态函数。
addObserver(forName:object:queue:using:)的优点是无需单独创建函数，运行代码与添加代码紧密相连。缺点是每个控制器都需要单独用类变量记录下来，并且需要手动移除。（建议在deinit函数中移除）
综上，我认为方法4的方案是目前代价最小的方案。方法1是最完善的方案。方法5是最偷懒的方案。

closure导致的循环引用

2019/12/18 09:56 AM

最近在开发macOS版的咕唧2，遇到了视图控制器没有释放的问题。花了些时间进行调试。结果总结如下：

我们知道，如果存在循环引用，就会导致类无法释放。因此，我们通常会使用weak var delegate的方式来避免循环引用。

这里不谈一般的循环引用，谈谈closure的循环引用。

closure的循环引用

view controllers

如图，点击上面视图控制器的Next按钮，会自动弹出下面的视图控制器。代码如下：

import Cocoa

class ViewController: NSViewController {
    override func viewDidLoad() {
        super.viewDidLoad()

        // Do any additional setup after loading the view.
    }

    override var representedObject: Any? {
        didSet {
        // Update the view, if already loaded.
        }
    }
}

import Cocoa

class V2ViewController: NSViewController {
    private let a = 100
    private var foo:Foo!

    override func viewDidLoad() {
        super.viewDidLoad()
        
        foo = Foo(doStaff)
        foo.run()
    }
    
    deinit {
        print("V2ViewController deinit.")
    }
    
    func doStaff() {
        print(self.a)
    }
}

class Foo {
    private(set) var bar:() -> ()
    
    init(_ bar:@escaping () -> ()) {
        self.bar = bar
    }
    
    deinit {
        print("Foo deinit.")
    }
    
    func run() {
        bar()
    }
}

运行并关闭弹出的视图控制器，控制台没有输出deinit的打印。存在内存泄漏。

分析

这是因为Foo中的bar，引用了V2ViewController的doStaff。而doStaff引用了self。

解决

对于closure，我们不能使用weak，只能使用其它的方式。

方法1

调用完成后手动释放。

func run() {
    bar()
    bar = {}
}

方法2

还是手动释放，不过将bar定义为(()->())?，即Opitional。

class Foo {
    private(set) var bar:(() -> ())?
    
    init(_ bar:@escaping () -> ()) {
        self.bar = bar
    }
    
    deinit {
        print("Foo deinit.")
    }
    
    func run() {
        bar?()
        bar = nil
    }
}

方法3

更改调用的方式，不直接分配函数，而是增加一层closure。

override func viewDidLoad() {
    super.viewDidLoad()
    
    foo = Foo({ [unowned self] in
        self.doStaff()
    })
    
    foo.run()
}

通常我们认为直接分配和增加一层是等价的。但是这里我们看到，实际上，二者并不完全等价。

结论

综合起来，我认为方法3的解决方案，修改代码的成本是最低的。因为它是直接从源头解决了问题。

← 过去未来 →

肇鑫的技术博客

业精于勤，荒于嬉