肇鑫 / Owen Zhao

独立开发者，主要开发 iOS、watchOS、macOS 应用。

目前在维护 SleepTap、Rooster Time，以及 Markdown Writer 相关工具。

获取状态项并制定图标

let statusItem = NSStatusBar.system.statusItem(withLength:NSStatusItem.squareLength)
guard let button = statusItem.button else {
    fatalError()
}
        
button.image = NSImage(imageLiteralResourceName: "TrayIcon")

图标的图片选择40x40像素的，放在2x下。

添加响应或菜单项

这里是一个坑。虽然状态项支持单击和显示菜单，但是苹果规定，当存在菜单时，单击无效，而只会显示菜单。

var menu: NSMenu?
When non-nil, the status item’s single click action behavior is not used. The menu can be removed by setting the value of this property to nil.

所以你要么添加button的点击功能，要么选择构建一个菜单。这个坑可以通过技术手段绕过，我们后面再提。

鼠标左键和鼠标右键对应不同的响应

状态项默认只支持鼠标左键的点击，而不支持其它的鼠标事件。如果想要支持鼠标右键的点击，我们需要自行实现。

https://stackoverflow.com/questions/32188581/call-action-when-nsstatusbarbutton-is-right-clicked

我选择是上面链接中的方案，新建一个自定义的视图，该视图支持鼠标右键点击，然后再将该视图添加到button上。

自定义的视图：

class MouseRightClickView: NSView {
    var closure:(() -> ())!

    override func rightMouseUp(with event: NSEvent) {
        super.rightMouseUp(with: event)
        
        closure()
    }
}

同时支持鼠标单击和菜单项

现在状态项支持鼠标左键和鼠标右键了，下面我们来实现鼠标左键点击“显示/隐藏应用”，右键点击“显示菜单项”。

guard let button = statusItem.button else {
    fatalError()
}
    
button.image = NSImage(imageLiteralResourceName: "TrayIcon")
button.action = #selector(mouseLeftButtonClicked)
    
// Add mouse right click
let subView = MouseRightClickView(frame: button.frame)
subView.closure = {
    self.constructMenu()
    button.performClick(nil) // menu won't show without this
}
button.addSubview(subView)

大家注意看，创建完成菜单后，必须手工添加一个按钮的点击。如果没有这个，那么只会生成菜单，而不会立即弹出菜单。最后，由于苹果规定如果存在菜单，则不会响应鼠标点击，我们必须在每次菜单关闭时，自动去掉菜单。这就需要设置菜单的代理。

private func constructMenu() {
    let menu = NSMenu()
    menu.delegate = self
    ...
}

菜单代理

extension AppDelegate:NSMenuDelegate {
    // remove the menu or later mouse left click will call it.
    func menuDidClose(_ menu: NSMenu) {
        statusItem.menu = nil
    }
}

Locale苹果官方文档补遗

2018/11/18 12:25 PM 通用

我们知道，在Xcode中可以通过指定运行时的语言，来测试相应的翻译。如图，我指定了中文作为在测试时的语言。

测试时指定语言

这个方式，在测试翻译的情况下是没有问题的。

最近我需要在应用中通过WKWebView，根据用户所使用的语言来动态加载网页。为了达到这个目的，我使用了

Locale.current.languageCode

根据苹果的文档，languageCode的含义是

The language code of the locale, or nil if has none.

但是实际使用中，我发现它并不能返回zh。

iOS_12.1_Locale_iPhoneX

如图，实际上返回的是en_CN。

我就此问题向苹果提交了错误报告。苹果回复说，从macOS 10.13, iOS 11开始，Locale.current.languageCode返回的实际上是Bundle.main.preferredLocalizations.first。这是因为苹果认为这样的用户体验最好。

苹果举例说，如果一个用户对于语言的偏好顺序是[ "zh-CN", "de-CN", "en-CN" ]，而某个应用仅支持德语和英语，那么Locale.current.languageCode返回的就是de_CN。

按照苹果的建议，如果想要测试中文，那么第一步就是添加中文的翻译。于是我添加了简体中文的翻译。这一下，简体中文的内容正确了。

简体中文

另外，对比一下没有中文翻译时，iOS 10和iOS 11的不同。

Locale 对比

事情还没有完，因为我希望的是用户懂中文时，使用中文；否则使用英文。而现在的方式仅能识别简体中文，当用户使用繁体中文时，还是会显示英文。于是我改了代码，新的代码

private func isChinese() -> Bool {
    let languages = Locale.preferredLanguages
    
    for lang in languages {
        if lang.hasPrefix("zh") {
            return true
        }
    }
    
    return false
}

iOS、watchOS应用用户设置相关问题的答案

2018/07/21 08:36 AM watchOSiOS

最近在写咕唧2，对于iOS应用与配套watchOS应用之间的设置的相关问题有了一些心得。记下来，备查。

问题与答案

1. 创建的Settings.bundle文件放在哪里？

无论iOS还是watchOS的，都放在iOS应用下。

2. iOS应用的设置，为什么watchOS应用不能直接读了？

这是一个历史遗留问题。1代的手表系统，当时还不叫watchOS，上的应用只有一种，叫瞥一眼（glance）。生成机制是所有的一切都在手机上生成，然后传到手表上显示。因此，当然手机应用和手表应用实际上都在手机上运行。因此，直接通过分享组（share group），手表应用就能读取手机应用的设置。

watchOS 2开始，手表应用改在手表上运行了。而手表上的共享组和手机上的共享组之间不自动同步，所以手表和手机之间的设置不能直接读了。

3. iOS应用如何获得watchOS应用的设置？

不能直接读。因为苹果规定，手表应用可以唤醒手机应用，反之则不行。

4. watchOS应用如何获得iOS应用的设置？

通过session的sendMessage方法唤醒手机，然后手机发送设置给手表。

5. 如何设置watchOS应用的设置？

通过手机端的手表应用。这个应用虽然在手机上，但是可以直接读手表应用的设置。并且会写回去。

一张图

iOS与watchOS的设置同步

参考资料

https://developer.apple.com/library/archive/documentation/General/Conceptual/WatchKitProgrammingGuide/Settings.html

自定义UITableViewCell的选中背景

2018/07/05 21:28 PM iOS

默认情况下，UITableViewCell的选中效果如图。单独选中的效果给人的感觉不是那么可靠。

但从编程角度看，使用选中状态比较简单。不使用选中，而采用标记替代选中比较麻烦。因为这个对号是属于UITableViewCell的accessoryType属性。它并不是和选中状态同步的。需要单独、小心地处理，稍有不慎，就会出现各种错误。

解决思路

创建一个背景透明的对号标记

我最初的想法是创建一个背景透明的对号标记。然后把它应用在UITableViewCell的selectedBackgroundView属性上。

这条路不好走。因为一旦制定了selectedBackgroundView。表格之间的分隔线就没有。解决方案有利用各种方式画分隔线的。比较麻烦。

在我采用默认的表格，并允许多选时，我发现苹果的默认选中，就是没有分割线的，只不过它用了有颜色的背景。这在单选时不明显，一旦有多选，就很明显。

创建一个有背景色的对号标记

创建好的图片如图。

checkmark_background@2x

用1x的语言描述，背景：宽320，高44。对号：宽16，高32，水平居中，右边距16。

难点来了

我们知道，不同格式设备的宽度是不一样的。那么对于320这个iOS设备的最小宽度，这个图片在遇到更宽的设备时是需要拉伸的。

关于如何拉伸图片，我们可以看这篇：UIImage图片拉伸平铺(resizableImage)。

看着不难，实际上全是坑。因为思维习惯不是直接的，是间接的。

简述一下拉伸图片的原理

如图，如果有一个图片，被分成1-9共9个部分。那么它的四个角的1、3、7、9图形保持不变。我们通过定义2/上、4/左、8/下、6/右的方式，来确定5的范围，然后选择拉伸5。这个就是定义图片拉伸的原理。

1	2	3
4	5	6
7	8	9

下面应用这个原理，放大上面的带对号的背景图。

checkmark_background 1-9@2x

因为我们需要保证对号的位置不变，所以要把它画在3的位置。这是唯一的限制。根据这个限制我们可以计算出。

上：
- 上边距 = (背景高 - 对号高) / 2 = (44 - 32) / 2 = 6
- 上 = 上边距 + 对号高 = 6 + 32 = 38
右 = 对号宽 + 右边距 = 16 + 16 = 32

至于下和左，我们因为要尽量保证5越大越好，就都取1。

最终代码如下：

override func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
    let cell = tableView.dequeueReusableCell(withIdentifier: "sampleCell", for: indexPath)
    
    // 获得背景图
    let image = #imageLiteral(resourceName: "Checkmark_background")
    // 指定拉伸范围
    let edgeInsets = UIEdgeInsetsMake(38, 1, 1, 32)
    // 获得拉伸图片
    let resizableImage = image.resizableImage(withCapInsets: edgeInsets, resizingMode: .stretch)
    // 生成图片视图，大小与表格项相同
    let imageView = UIImageView(frame: cell.bounds)
    // 指定图片
    imageView.image = resizableImage
    // 指定表格项选中时的背景视图
    cell.selectedBackgroundView = imageView
    // 设定文字
    cell.textLabel?.text = "条件\(indexPath.row)"

    return cell
}

最终效果

如图：

fina

UIImageView异步加载导致问题的解决

2018/06/29 10:05 AM iOS

当UIImageView加载了一张图片之后，如果再加载另外一张图片，然后立即删除第二张图片。则UIImageView会变黑。

演示代码如下：

import UIKit

class ViewController: UIViewController {
    lazy var image = { () -> UIImage? in
        guard let path = Bundle.main.path(forResource: "poster_icon_mac_1024", ofType: "png") else {
            return nil
        }
        
        return UIImage(contentsOfFile: path)
    }()
    
    lazy var replaceImage = { () -> UIImage? in
        guard let path = Bundle.main.path(forResource: "Miss Devil 恶魔人事·椿真子.Miss.Devil.Jinji.no.Akuma.Tsubaki.Mako.Ep05.Chi_Jap.HDTVrip.1280X720-0001", ofType: "png") else {
            
            return nil
        }
        
        return UIImage(contentsOfFile: path)
    }()
    
    lazy var saveImageURL = { () -> URL in
        let baseURL = FileManager.default.urls(for: .cachesDirectory, in: .userDomainMask).first
        let fileName = UUID().uuidString + ".jpg"
        
        return URL(fileURLWithPath: fileName, isDirectory: false, relativeTo: baseURL)
    }()
    
    var latestImage:UIImage? = nil

    override func viewDidLoad() {
        super.viewDidLoad()
        // Do any additional setup after loading the view, typically from a nib.
        
        addImage()
        
        DispatchQueue.main.asyncAfter(wallDeadline: .now() + .seconds(2)) { [unowned self] in
            self.createImage()
            self.loadImage()
            self.changeImageViewToLatestImage()
            self.removeLatestImage()
        }
    }

    override func didReceiveMemoryWarning() {
        super.didReceiveMemoryWarning()
        // Dispose of any resources that can be recreated.
    }

    @IBOutlet weak var imageView: UIImageView!
    
    func addImage() {
        imageView.image = image
    }
    
    func changeImage() {
        imageView.image = replaceImage
    }
    
    func createImage() {
        let imageData = UIImageJPEGRepresentation(replaceImage!, 1.0)
        FileManager.default.createFile(atPath: saveImageURL.path, contents: imageData!, attributes: nil)
    }
    
    func loadImage() {
        latestImage = UIImage(contentsOfFile: saveImageURL.path)
    }
    
    func changeImageViewToLatestImage() {
        imageView.image = latestImage
    }
    
    func removeLatestImage() {
        try! FileManager.default.removeItem(at: saveImageURL)
    }
}

分析与解决

这个问题的造成，是因为为了性能，UIImageView其实是异步加载的。在它加载完成之前，如果图片被删除了，就会加载不到，变黑。

有人提出，可以将图片通过Data类型，加载到内存中，然后将内存中的图片加载到UIImageView的方式，来绕过这个问题。这个思路的确能解决这个问题，但是毕竟多占用了内存。不算是最好的方式。

其实，我们知道了原理，就等UIImageView加载完成之后，再删除图片就好了。虽然苹果并没有告诉我们图片何时加载好。但是我们知道，类似更新UI的这种操作，必然是在UI线程完成的，即main线程。那么我们只需要在main队列排队一下就可以了。

将代码

DispatchQueue.main.asyncAfter(wallDeadline: .now() + .seconds(2)) { [unowned self] in
    self.createImage()
    self.loadImage()
    self.changeImageViewToLatestImage()
    self.removeLatestImage()
}

改成

DispatchQueue.main.asyncAfter(wallDeadline: .now() + .seconds(2)) { [unowned self] in
    self.createImage()
    self.loadImage()
    self.changeImageViewToLatestImage()

    DispatchQueue.main.async { [unowned self] in
        self.removeLatestImage()
    }
}

思考

为什么上面的代码会成功呢？这是因为第一段代码的运行顺序是

DispatchQueue.main.asyncAfter(wallDeadline: .now() + .seconds(2)) { [unowned self] in
    self.createImage()
    self.loadImage()
    self.changeImageViewToLatestImage() // 异步操作，押后运行
    self.removeLatestImage() // 先删除了图片，之后才进行的图片加载
}

而修改之后的代码是

DispatchQueue.main.asyncAfter(wallDeadline: .now() + .seconds(2)) { [unowned self] in
    self.createImage()
    self.loadImage()
    self.changeImageViewToLatestImage() // 异步操作1，押后运行

    DispatchQueue.main.async { [unowned self] in // // 异步操作2，押后运行
        self.removeLatestImage()
    }
}

由于main队列是一个包执行完成之后，才会执行下一个。因此实际上修改后的代码是在图片加载完成之后才删除图片的。这就避免了这个问题。

循环结构中异步代码实现灵活退出（下）

2018/05/28 09:27 AM Swift

循环结构中异步代码实现灵活退出（上）

上一篇中，我们实现了基本结构。但是如果每次都这么做，会比较麻烦。这一篇中，我们尝试将代码封装起来，这样以后我们再做时，只需调用一次就可以了。

首先，我们将之前的代码变成closure。

import Cocoa

class ViewController: NSViewController {
    private let semaphore = DispatchSemaphore(value: 0)
    private let concurrentQueue = DispatchQueue.global()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        concurrentQueue.async {
            self.run()
        }
    }
    
    private func run() {
        for i in 1...10 {
            print(i)
            
            if shouldBreak(i, withClosure: { (result) in
                DispatchQueue.main.async {
                    self.textView.string += "\(i)\n"
                }
                
                if i == 5 {
                    result = true
                }
            }) {
                break
            }
        }
    }
    
    private func shouldBreak(_ i:Int, withClosure closure: @escaping (inout Bool) -> ()) -> Bool {
        var result = false
        let delayInSeconds = Int(arc4random() % 3)
        
        concurrentQueue.asyncAfter(wallDeadline: .now() + .seconds(delayInSeconds)) {
            closure(&result)
            
            self.semaphore.signal()
        }
        
        semaphore.wait()
        
        return result
    }

    @IBOutlet var textView: NSTextView!
}

接下来，我们新建一个文件RangeEnumerator.swift，扩展Sequence。

import Foundation

extension Sequence {
    public func breakableForEach(closureWithCondition: @escaping (Element, inout Bool)->()) {
        let semaphore = DispatchSemaphore(value: 0)
        
        DispatchQueue.global().async {
            for e in self {
                if self.shouldBreak(semaphore, e, withClosure: closureWithCondition) {
                    break
                }
            }
        }
    }
    
    private func shouldBreak(_ semaphore:DispatchSemaphore, _ e:Element, withClosure closure: @escaping (Element, inout Bool) -> ()) -> Bool {
        var result = false
        let delayInSeconds = Int(arc4random() % 3)
        
        DispatchQueue.global().asyncAfter(wallDeadline: .now() + .seconds(delayInSeconds)) {
            closure(e, &result)
            semaphore.signal()
        }
        
        semaphore.wait()
        
        return result
    }
}

之后，最初的代码就可以简化为。

class ViewController: NSViewController {
    override func viewDidLoad() {
        super.viewDidLoad()
        
        (1...10).breakableForEach { (i, result) in
            DispatchQueue.main.async {
                self.textView.string += "\(i)\n"
            }

            if i == 5 {
                result = true
            }
        }
    }
    
    @IBOutlet var textView: NSTextView!
}

另外，由于扩展中不能创建存储变量，所以，之前的信号量和队列，就必须放在函数里了。

循环结构中异步代码实现灵活退出（上）

2018/05/18 01:01 AM Swift

在同步代码时，循环要提前退出十分简单。

for i in 1...10 {
    print(i)
    
    if i == 5 {
        break
    }
}

但是在异步代码中，要灵活退出就不那么容易了。比如，在调用RestAPI时，如果一切正常，就执行下一次循环，如果出错，则进行提示用户，进行重试或者退出。这个就属于异步操作。

import Cocoa

class ViewController: NSViewController {
    private let concurrentQueue = DispatchQueue.global()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        run()
    }
    
    private func run() {
        for i in 1...10 {
            print(i)
            
            if shouldBreak(i) {
                break
            }
        }
    }
    
    private func shouldBreak(_ i:Int) -> Bool {
        var result = false
        let delayInSeconds = Int(arc4random() % 3)

        concurrentQueue.asyncAfter(wallDeadline: .now() + .seconds(delayInSeconds)) {
            if i == 5 {
                result = true
            }
        }
        
        return result
    }
}

由于采用了异步，shouldBreak(_ i:Int) -> Bool的result是先于DispatchQueue.main.async中的代码执行的。因此输出始终是1-10。

为保证执行的顺序，需要使用信号量。

import Cocoa

class ViewController: NSViewController {
    private let semaphore = DispatchSemaphore(value: 0)
    private let concurrentQueue = DispatchQueue.global()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        run()
    }
    
    private func run() {
        for i in 1...10 {
            print(i)
            
            if shouldBreak(i) {
                break
            }
        }
    }
    
    private func shouldBreak(_ i:Int) -> Bool {
        var result = false
        let delayInSeconds = Int(arc4random() % 3)

        concurrentQueue.asyncAfter(wallDeadline: .now() + .seconds(delayInSeconds)) {
            if i == 5 {
                result = true
            }
            
            self.semaphore.signal()
        }
        
        semaphore.wait()
        
        return result
    }
}

代码执行正确。下面我们加入改变UI的部分。添加一个NSTextView，让它显示每次的i。

import Cocoa

class ViewController: NSViewController {
    private let semaphore = DispatchSemaphore(value: 0)
    private let concurrentQueue = DispatchQueue.global()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        run()
    }
    
    private func run() {
        for i in 1...10 {
            print(i)
            
            if shouldBreak(i) {
                break
            }
        }
    }
    
    private func shouldBreak(_ i:Int) -> Bool {
        var result = false
        let delayInSeconds = Int(arc4random() % 3)

        concurrentQueue.asyncAfter(wallDeadline: .now() + .seconds(delayInSeconds)) {
            DispatchQueue.main.async {
                self.textView.string += "\(i)\n"
            }
            
            if i == 5 {
                result = true
            }
            
            self.semaphore.signal()
        }
        
        semaphore.wait()
        
        return result
    }
    
    @IBOutlet var textView: NSTextView!
}

代码执行后，我们会发现，textView中的i，不是一行一行显示的，而是一开始不显示，然后一下子都显示出来。这和我们期望的不符。

这是什么原因造成的呢？其实，这是因为视图控制器中的代码，默认运行在图形线程，因此semaphore.wait()其实每次都阻塞了图形线程。这导致textView一直没法刷新。直到循环跳出后，界面才成功刷新。

知道了原因，解决办法就有了。将代码从默认的图形线程中移除即可。最终代码：

import Cocoa

class ViewController: NSViewController {
    private let semaphore = DispatchSemaphore(value: 0)
    private let concurrentQueue = DispatchQueue.global()
    
    override func viewDidLoad() {
        super.viewDidLoad()
        
        concurrentQueue.async {
            self.run()
        }
    }
    
    private func run() {
        for i in 1...10 {
            print(i)
            
            if shouldBreak(i) {
                break
            }
        }
    }
    
    private func shouldBreak(_ i:Int) -> Bool {
        var result = false
        let delayInSeconds = Int(arc4random() % 3)

        concurrentQueue.asyncAfter(wallDeadline: .now() + .seconds(delayInSeconds)) {
            DispatchQueue.main.async {
                self.textView.string += "\(i)\n"
            }
            
            if i == 5 {
                result = true
            }
            
            self.semaphore.signal()
        }
        
        semaphore.wait()
        
        return result
    }
    
    @IBOutlet var textView: NSTextView!
}

循环结构中异步代码实现灵活退出（下）

AVMovie始终显示视频时长为0问题的分析、解决

2017/11/04 15:34 PM macOS

推特仅支持0.5秒到140秒之内长度的视频，因此上传前要先检验视频的长度。测试时，我发现，Finder分享的视频时长始终为0。

我查询了一下，最初看到的说法是，AVAsset（AVMovie的父类）的加载是异步的，不能够立即获得时长，而需要用键值观察的方法，注册通知来观察duration这个属性何时变化。昨晚看到这里，我就睡了。

今天再看，发现有协议AVAsynchronousKeyValueLoading，可以用来异步处理键值。方法loadValuesAsynchronously(forKeys:completionHandler:)会在加载完成后执行completionHandler。这样就不用我们自己手动注册键值观察的通知了。

但是，我测试这个方法不好用。Finder传来的视频，无论是否使用这个异步方法，时长都始终为0。

我不用Finder，采用照片应用进行调试，发现无论是不是用这个异步方法，都能获得正确的时长。

结合上一篇Finder分享视频到共享扩展的一些限制的小结。我产生了新的想法，经过测试，我的猜想是正确的。

那就是，AVMovie在读取URL的时候，会正确获得时长，如果是Data的话，则不可以。想测试也很简单，把URL变成Data，再创建AVMovie；或者把Data写入到URL，再创建AVMovie。就可以证实了。

我不清楚这个是苹果API的错误，还是特性。但是这个至少是没有注明的。

← 过去未来 →

肇鑫 / Owen Zhao

最新文章

macOS菜单栏状态项小结

获取状态项并制定图标

添加响应或菜单项

鼠标左键和鼠标右键对应不同的响应

同时支持鼠标单击和菜单项

Locale苹果官方文档补遗

iOS、watchOS应用用户设置相关问题的答案

问题与答案

1. 创建的Settings.bundle文件放在哪里？

2. iOS应用的设置，为什么watchOS应用不能直接读了？

3. iOS应用如何获得watchOS应用的设置？

4. watchOS应用如何获得iOS应用的设置？

5. 如何设置watchOS应用的设置？

一张图

参考资料

自定义UITableViewCell的选中背景

解决思路

创建一个背景透明的对号标记

创建一个有背景色的对号标记

难点来了

简述一下拉伸图片的原理

最终效果

UIImageView异步加载导致问题的解决

分析与解决

思考

循环结构中异步代码实现灵活退出（下）

循环结构中异步代码实现灵活退出（上）

AVMovie始终显示视频时长为0问题的分析、解决