FoolishTalk

ShotMark User Guide: Add Camera Info Watermarks on Mac

Mon, 27 Jul 2026 00:00:00 +0800

Introduction

ShotMark is a native macOS photo library and camera-info watermark app. It reads details such as camera, lens, focal length, aperture, shutter speed, and ISO from a photo, then presents them in a clean layout around the image.

ShotMark supports JPEG, PNG, HEIC, and RAW formats that the installed macOS Core Image RAW decoder can open. You can browse a group of photos, apply a template to one or many images, and export finished files as JPEG, PNG, or HEIC.

System Requirements

macOS 14 Sonoma or later.
RAW compatibility depends on the camera formats supported by your current macOS installation.
ShotMark includes English and Simplified Chinese and follows the app language selected in macOS.

Add Photos

Open ShotMark and click Add Photos, or drag photos directly into the library window.

ShotMark keeps access information for each source file without copying, moving, or modifying the original photo. If the same source file is imported again, you can skip the duplicate, import it anyway, or cancel the import.

The library toolbar helps you manage larger groups of photos:

Search by filename and by camera or lens information that has already been read.
Filter by availability, file format, or watermark template.
Sort by import order, import date, filename, camera, or capture date.
Adjust thumbnail size without losing your selection.

Preview a Photo and Choose a Watermark

Double-click a photo to open it in a separate preview window. Use Previous and Next, or the arrow keys, to move through the current library results.

ShotMark includes two watermark templates:

Classic adds a clean information bar below the photo.
Polaroid uses a print-inspired border with room for the photo details.

The preview and full-resolution export use the same layout rules, so the composition and text placement you review are preserved in the finished image.

Edit Camera Information

Click Edit Info in the preview window to control:

Camera
Lens
Focal Length
Aperture
Shutter
ISO

Each field has three display modes:

Automatic uses the value detected in the photo.
Custom lets you enter the text that should appear in the watermark.
Hidden removes that field from the watermark.

These choices are stored only in the ShotMark library. They are not written back to the photo’s EXIF metadata and do not alter the source file.

Select and Process Multiple Photos

ShotMark follows standard macOS selection behavior:

Command-click adds or removes one photo from the selection.
Shift-click selects a continuous range.
Command-A selects all photos in the current search and filter results.
Escape clears the selection.

After selecting multiple photos, you can apply either template to the whole selection or start a batch export.

Choosing Remove deletes only the ShotMark library records and thumbnail cache. It does not delete, move, or modify the source photos, and the operation can be undone with Command-Z.

Export Photos

Export One Photo

Click Export in the preview window, then choose JPEG, PNG, or HEIC. JPEG and HEIC include a quality setting, while PNG uses lossless encoding.

Batch Export

Select multiple photos in the library and click Export N Selected:

Choose a destination folder.
Choose JPEG, PNG, or HEIC.
Set the output quality for JPEG or HEIC.
Start the export and follow its progress.

The default output name is original-name-shotmark.extension. If that name already exists, ShotMark adds -2, -3, and so on instead of overwriting a file.

You can cancel a batch export. Files already completed are kept, and items that have not started are stopped. A failure on one photo does not stop the remaining photos; ShotMark shows a summary when the batch finishes.

Relocate an Unavailable File

Because ShotMark works with the original photo rather than an internal copy, a file may become unavailable after it is moved or renamed, or while an external drive is disconnected.

Right-click the photo and choose Relocate... to reconnect it to the source file. The same menu can reveal an available source in Finder or regenerate a thumbnail when needed.

Privacy and Source-File Safety

ShotMark does not upload photos and has no cloud-sync feature.
Original photos are not copied into the ShotMark library.
Camera-info edits remain in ShotMark’s local index.
Removing an item from the library does not delete the source photo.
Export never overwrites an imported source photo.

Q&A

Why can’t ShotMark preview a RAW file? RAW support is provided by the Core Image RAW decoder installed with macOS. Update macOS first. If the camera format is still unsupported, convert the photo to a compatible format before importing it.
Does editing camera information change the photo’s EXIF metadata? No. Custom and hidden settings affect only ShotMark previews and exports.
Does Remove from Library delete the file from my drive? No. It removes only ShotMark’s library record and thumbnail cache.
Can batch export overwrite an existing image? No. ShotMark automatically adds a numeric suffix when a filename is already in use.
Can I change the watermark template for several photos at once? Yes. Select the photos, open the Template menu, and choose Classic or Polaroid.
Why does a photo show “File unavailable” after I move it? ShotMark uses the source file and does not keep a separate photo copy. Choose Relocate... to reconnect the moved file.

If you report an issue, including your macOS version, photo format, and the exact steps that produced the problem will make troubleshooting much faster.

ShotMark 使用指南：在 Mac 上为照片添加拍摄信息水印

Mon, 27 Jul 2026 00:00:00 +0800

前言

ShotMark 是一款原生 macOS 照片图库与拍摄信息水印应用。它可以读取照片中的相机、镜头、焦距、光圈、快门和 ISO 等信息，并把这些内容以简洁的版式融入照片。

ShotMark 支持 JPEG、PNG、HEIC，以及当前 macOS Core Image 能够解码的 RAW 格式。你可以集中浏览一组照片，为单张或多张照片选择模板，再导出 JPEG、PNG 或 HEIC 成品。

系统要求

macOS 14 Sonoma 或更高版本。
如果需要处理 RAW，具体格式是否可用取决于当前 macOS 对相机 RAW 格式的支持情况。
ShotMark 支持英文和简体中文，并会跟随 macOS 的应用语言设置。

添加照片

打开 ShotMark 后，点击左上角的添加照片，也可以直接把照片拖入窗口。

照片加入后会显示在图库中。ShotMark 只保存访问原文件所需的信息，不会复制、移动或修改源照片。再次导入同一个源文件时，应用会提示你跳过重复项、仍然导入或取消。

图库上方提供以下工具：

搜索：按文件名，以及已读取的相机或镜头名称查找照片。
筛选：按文件可用性、图片格式和水印模板筛选。
排序：按导入顺序、导入日期、文件名、相机或拍摄日期排序。
大小：调整图库中的缩略图尺寸。

预览照片并选择水印

双击一张照片即可打开独立预览窗口。可以点击上一张、下一张，或使用键盘方向键浏览当前结果中的其他照片。

ShotMark 内置两种水印模板：

经典：在照片下方加入简洁的信息栏，适合横幅式展示拍摄参数。
拍立得：使用更接近相纸留白的版式展示照片和拍摄信息。

预览窗口与最终导出使用同一套排版规则，因此预览中的构图和文字效果会与成品保持一致。

编辑拍摄信息

在预览窗口点击编辑信息，可以分别设置以下内容：

相机
镜头
焦距
光圈
快门
ISO

每项信息都有三种显示方式：

自动：使用照片中检测到的拍摄信息。
自定义：输入你希望在水印中显示的内容。
隐藏：不在水印中显示该项。

这些修改只保存在 ShotMark 图库中，不会写回照片 EXIF，也不会改变源文件。

多选与批量操作

ShotMark 支持标准的 macOS 多选操作：

Command + 单击：添加或取消选择某张照片。
Shift + 单击：连续选择一段照片。
Command-A：选择当前搜索和筛选结果中的全部照片。
Escape：清空选择。

选中多张照片后，可以统一套用经典或拍立得模板，也可以直接批量导出。选择状态会在调整缩略图尺寸时保留。

如果选择移除，ShotMark 只会移除图库记录和对应缩略图缓存，不会删除、移动或修改源照片；误操作后还可以通过Command-Z撤销。

导出照片

导出单张照片

在预览窗口点击导出，选择 JPEG、PNG 或 HEIC 格式。JPEG 和 HEIC 可以调整输出质量，PNG 则会保留无损编码方式。

批量导出

在图库中选择多张照片，再点击导出已选 N 张：

选择目标文件夹。
选择 JPEG、PNG 或 HEIC。
JPEG 和 HEIC 可设置输出质量。
开始导出并查看当前进度。

默认输出文件名为原文件名-shotmark.扩展名。如果目标文件夹中已有同名文件，ShotMark 会自动添加-2、-3等序号，不会覆盖已有文件。

批量导出过程中可以取消任务。已经成功导出的文件会保留，尚未开始的项目将停止；单张照片导出失败也不会中断整批任务，结束后会显示汇总结果。

文件失效与重新定位

由于 ShotMark 不会复制源照片，如果原文件被移动、重命名，或外置磁盘尚未连接，照片可能显示为“文件不可用”。

此时可以右键照片并选择重新定位…，找到对应的源文件后即可恢复访问。也可以通过右键菜单在 Finder 中显示源照片，或在缩略图异常时重新生成缩略图。

隐私与源文件安全

ShotMark 不会上传照片，也不包含云同步功能。
原始照片不会被复制到 ShotMark 图库中。
编辑后的拍摄信息只保存在本机 ShotMark 索引中。
从图库移除照片不会删除源文件。
导出时不会覆盖已导入的源照片。

Q&A

为什么有些 RAW 无法预览？ RAW 支持范围由当前 macOS 的 Core Image RAW 解码器决定。请先更新 macOS；如果系统仍不支持该相机格式，可以先转换为兼容格式再导入。
编辑拍摄信息会修改照片的 EXIF 吗？ 不会。自定义和隐藏规则只用于 ShotMark 中的预览与导出。
从图库移除照片会删除硬盘上的文件吗？ 不会。ShotMark 只移除自己的图库记录和缩略图缓存。
批量导出会覆盖同名图片吗？ 不会。ShotMark 会自动为重名文件添加数字序号。
可以一次修改多张照片的水印模板吗？ 可以。多选照片后，从工具栏的模板菜单选择经典或拍立得即可。
为什么移动照片后显示“文件不可用”？ ShotMark 通过原文件工作，不保存照片副本。请使用重新定位…重新关联移动后的文件。

如果在使用过程中遇到问题，建议同时提供 macOS 版本、照片格式和具体操作步骤，以便更快定位问题。

AI盛行后，我不再热衷于开源了

Fri, 05 Jun 2026 00:00:00 +0800

早在去年年底的时候，我就想聊聊这个话题，当时我对开源社区或者说是GitHub还有心存希望，实际上是越来越失望了。在过去，我参与一些开源项目主要动机是：

在自己vibe coding的项目里应用了一些开源库，发现了一些问题或者者有一些功能需求，就自己提PR来处理，因为我受益了，所以我希望反哺开源社区；
看到一些知名的库想参与进来，看看issue有什么问题是比较容易上手的，来锻炼一下自己的能力；

但是现在，AI的出现改变了这一切，开源社区的氛围变得越来越糟糕了，甚至有些项目已经不再欢迎外部贡献了。因为AI可以轻松地生成代码，甚至可以自动修复bug，有项目被AI优化后AI做的项目更火了，也有被AI生成PR充斥满整个项目，让我觉得参与到开源项目似乎已经没有什么意义了。过去参与开源能证明你有阅读和理解作者代码的能力，然而现在只能证明你会使用AI工具了而已。

这段由AI生成，但是我也表达了我的想法：
现在的开源，更像是资本家在利用开源社区来为他们的AI模型提供训练数据，开源社区成了AI模型的免费劳动力，而我们这些开发者则成了被剥削的对象。AI模型的训练需要大量的数据，而开源社区正好提供了这些数据，然而我们却没有得到任何回报，反而还要被AI模型取代了工作机会。我觉得这种情况非常不公平，也非常令人失望。开源社区曾经是一个充满激情和创造力的地方，但现在却变成了一个被AI统治的地方，我觉得我们应该重新思考一下我们在开源社区中的角色和价值。

Xcode26.3 AI体验

Fri, 05 Jun 2026 00:00:00 +0800

前言

随着Xcode26.3的发布，开发者们终于可以在Xcode中直接使用AI来辅助开发了。Xcode支持多种AI模型，包括OpenAI、Claude以及本地部署的模型，让开发者可以根据自己的需求选择合适的AI模型来提升开发效率。

安装本地模型

因为Xcode支持本地部署的AI模型，所以我体验了一下在本地进行部署，然后在Xcode中配置使用。这里我选择了ollama这个工具来部署本地模型，下面是具体的步骤，先安装ollama：

curl -fsSL https://ollama.com/install.sh | sh

这里可以看到ollama支持的模型，https://ollama.com/library

我这里选择的是qwen3-coder:30b，安装命令如下：

ollama pull qwen3-coder:30b

下载完成后可以看到模型已经安装好了：

ollama默认会在本地启动一个服务，监听11434端口，我们可以请求测试一下：

curl http://localhost:11434/api/generate -d '{
  "model": "qwen3-coder:30b",
  "prompt": "Write a Swift async HTTP request example"
}'

看到成功有返回之后就可以在Xcode中进行配置了使用了。

Xcode配置本地模型

打开Xcode，选择菜单栏的Xcode->Settings，在弹出的设置界面中选择Intelligence，这里可以看到支持OpenAI和Claude，我要演示的本地模型的使用，所以点击Add a Provider...：

选择Locally Hosted,填写Port为11434和Description后就可以了。

简单的让Xcode使用这个模型写了个demo，效果还不错：

总结

Xcode26.3终于支持了AI，但是目前其实非常有限，仅限于代码生成，连代码补全都不支持，感觉更像是一个独立的AI工具，而不是集成在Xcode中的AI助手，而官方提到的其他功能，在cursor、vscode等工具一样能做，而且别人做的更好，想必Xcode在这还有很长的一条路要走。

参考

Meet agentic coding in Xcode
Ollama

国行iPhone开启Apple Intelligence体验Foundation Models

Tue, 02 Dec 2025 00:00:00 +0800

前言

最近爆出iOS系统存在漏洞，国行iPhone可以在iOS18.1Beta-iOS26.2Beta1版本中，通过修改手机地区的配置文件可以开启Apple Intelligence功能，笔者也是第一时间尝试了该方法，成功在国行iPhone上体验到了Apple Intelligence，并且尝试了使用Foundation Models进行文本生成，效果也不错。

一、开启Apple Intelligence

要在国行iPhone开启Apple Intelligence功能，首先需要准备：

美区Apple ID
iOS18.1Beta-iOS26.2Beta1版本的iPhone
iPhone 15 Pro以上机型

通过shortcut快捷指令获取修改地区配置文件： https://www.icloud.com/shortcuts/313d0562fc7f466b9775cef026577670
执行快捷指令：
根据提示步骤操作：
全选复制，导出到mac上，并保存为MobileGestalt.plist：
在这里,找到自己手机的型号，举个例子，我的是国行iPhone 16 Pro Max对应的型号就是A3297，通过Xcode打开MobileGestalt.plist，搜索找到A3297，将值改为美区对应的型号，如果是iPhone 16 Pro Max则改成A3084。另外还需要搜索CH改为LL,CH/A改为LL/A。
保存修改后的MobileGestalt.plist，在GitHub上下载misaka26项目。
iPhone连接上Mac，然后打开misaka26，选择MobileGestalt.plist，勾选Apple Intelligence，点击Apply，等待手机重启即可。（强烈建议操作之前备份手机，操作有误有可能导致无限重启！）
开启成功后，地区可以语言选择中国大陆&简体中文或者美国&English，均可使用Apple Intelligence功能，如果没出现Apple Intelligence可以尝试多重启几次手机。

二、体验Foundation Models

当手机下载完成Apple Interlligence模型后，就可以使用Foundation Models进行文本生成了，举一个简单的调用的例子：

import FoundationModels


let session = LanguageModelSession()
do {
    let response = try await session.respond(to: "What's a good name for a trip to Japan? Respond only with a title")
    
    print(response.content)
} catch {
    print(error)
}

如果已经正确下载了模型，运行后会得到类似下面的结果：

Journey of the Rising Sun

参考

2025年了，iOS终于可以实现闹钟了！

Sun, 24 Aug 2025 00:00:00 +0800

AlarmKit介绍

苹果在iOS 26中引入了全新的AlarmKit框架，这是一个令开发者们期待已久的功能。终于，我们可以在自己的应用中创建和管理系统级别的闹钟了！

AlarmKit是iOS 26新增的系统框架，允许第三方应用创建系统级闹钟。与通知不同，AlarmKit创建的闹钟会显示在系统时钟应用中，并且进行铃声强提醒。

对比EventKit的局限性

EventKit主要用于日历事件和提醒事项，虽然可以设置提醒，但有以下限制：

提醒不会在时钟应用中显示
只能存在通知或者日历中
用户体验不一致
无法利用系统闹钟的高级功能

AlarmKit的优势

创建系统体验一样的闹钟
支持所有系统闹钟功能
用户体验更好

代码示例

让我们通过实际代码来看看如何使用AlarmKit。

1. 请求权限

首先，需要在Info.plist中添加权限说明：

<key>NSAlarmKitUsageDescription</key>
<string>此应用需要创建闹钟来开始提醒</string>

然后在代码中请求权限：

import AlarmKit
func requestPermission() async {
    do {
        let manager = AlarmManager.shared
        let status = try await manager.requestAuthorization()
        switch status {
        case .authorized:
            print("Authorized")
        case .denied:
            print("Denied")
        case .notDetermined:
            print("Not Determined")
        @unknown default:
            break
        }
    } catch {
        print("Error requesting permission: \(error)")
    }
}

系统提供了两种闹钟，一种是倒计时闹钟，一种是指定时间闹钟。

2. 创建闹钟

AlarmKit提供了多种创建闹钟的方式，以下代码以固定日期闹钟以及倒计时闹钟为例。

创建固定日期闹钟:

        typealias AlarmConfiguration = AlarmManager.AlarmConfiguration<AlarmData>
        
        let id = UUID()
        
        let dateComponents = DateComponents(
            calendar: .current,
            year: 2025,
            month: 9,
            day: 3,
            hour: 22,
            minute: 27)
        let date = Calendar.current.date(from: dateComponents)!
        let scheduleFixed = Alarm.Schedule.fixed(date)
        
        let customMetadata = AlarmData()
        
        let stopButton = AlarmButton(
            text: "关闭",
            textColor: .white,
            systemImageName: "stop.circle")
        
        
        let alertContent = AlarmPresentation.Alert(title: "直播开始啦！",
                                                   stopButton: stopButton,
                                                   secondaryButton: nil,
                                                   secondaryButtonBehavior: nil)
        
        let attributes = AlarmAttributes(presentation: AlarmPresentation(alert: alertContent),
                                         metadata: customMetadata,
                                         tintColor: Color.accentColor)
        
        
        let alarmConfiguration = AlarmConfiguration.alarm(schedule: scheduleFixed,attributes: attributes)
        
        try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)

创建倒计时闹钟:

        
        // preAlert: 第一次提醒时间，单位为秒
        // postAlert: 再次提醒时间，单位为秒
        let duration = Alarm.CountdownDuration(preAlert: 30, postAlert: 10)
        // 创建警报UI样式
        let stopButton = AlarmButton(
            text: "关闭",
            textColor: .white,
            systemImageName: "stop.circle")
        
        let repeatButton = AlarmButton(
            text: "重复",
            textColor: .white,
            systemImageName: "repeat.circle")
        
        let alertPresentation = AlarmPresentation.Alert(
            title: "抢票开始啦!",
            stopButton: stopButton,
            secondaryButton: repeatButton,
            secondaryButtonBehavior: .countdown)
        
        // 创建通知UI样式
        let pauseButton = AlarmButton(
            text: "暂停",
            textColor: .green,
            systemImageName: "pause")
        let countdownPresentation = AlarmPresentation.Countdown(
            title: "抢票时间",
            pauseButton: pauseButton)

        // 创建闹钟属性
        let attributes = AlarmAttributes<AlarmData>(
            presentation: AlarmPresentation(
              alert: alertPresentation,
              countdown: countdownPresentation),
            metadata: customMetadata,
            tintColor: Color.green)

        // 创建闹钟配置
        let alarmConfiguration = AlarmConfiguration(
            countdownDuration: duration,
            attributes: attributes)

        // 真正创建闹钟的地方
        try await AlarmManager.shared.schedule(id: id, configuration: alarmConfiguration)

为了更方便理解，我画了一张图，方便理解AlarmKit在倒计时闹钟中的流程图。

处理完创建闹钟的代码之后，你会发现依然没有出现闹钟的样式，是因为我们还没有通过widget extension定义UI。
UI的代码需要通过SwiftUI实现，代码比较多，可以参考这里示例代码的实现。

另外还要注意一点，闹钟的操作事件需要通过AppIntent来实现，这里也比较容易理解，通过alarmID来获取对应的闹钟，然后就可以进行停止、暂停、恢复、重复等操作。

struct PauseIntent: LiveActivityIntent {
    func perform() throws -> some IntentResult {
        try AlarmManager.shared.pause(id: UUID(uuidString: alarmID)!)
        return .result()
    }
    
    static var title: LocalizedStringResource = "Pause"
    static var description = IntentDescription("Pause a countdown")
    
    @Parameter(title: "alarmID")
    var alarmID: String
    
    init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    init() {
        self.alarmID = ""
    }
}

struct StopIntent: LiveActivityIntent {
    func perform() throws -> some IntentResult {
        try AlarmManager.shared.stop(id: UUID(uuidString: alarmID)!)
        return .result()
    }
    
    static var title: LocalizedStringResource = "Stop"
    static var description = IntentDescription("Stop an alert")
    
    @Parameter(title: "alarmID")
    var alarmID: String
    
    init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    init() {
        self.alarmID = ""
    }
}

struct RepeatIntent: LiveActivityIntent {
    func perform() throws -> some IntentResult {
        try AlarmManager.shared.countdown(id: UUID(uuidString: alarmID)!)
        return .result()
    }
    
    static var title: LocalizedStringResource = "Repeat"
    static var description = IntentDescription("Repeat a countdown")
    
    @Parameter(title: "alarmID")
    var alarmID: String
    
    init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    init() {
        self.alarmID = ""
    }
}

struct ResumeIntent: LiveActivityIntent {
    func perform() throws -> some IntentResult {
        try AlarmManager.shared.resume(id: UUID(uuidString: alarmID)!)
        return .result()
    }
    
    static var title: LocalizedStringResource = "Resume"
    static var description = IntentDescription("Resume a countdown")
    
    @Parameter(title: "alarmID")
    var alarmID: String
    
    init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    init() {
        self.alarmID = ""
    }
}

struct OpenAlarmAppIntent: LiveActivityIntent {
    func perform() throws -> some IntentResult {
        try AlarmManager.shared.stop(id: UUID(uuidString: alarmID)!)
        return .result()
    }
    
    static var title: LocalizedStringResource = "Open App"
    static var description = IntentDescription("Opens the Sample app")
    static var openAppWhenRun = true
    
    @Parameter(title: "alarmID")
    var alarmID: String
    
    init(alarmID: String) {
        self.alarmID = alarmID
    }
    
    init() {
        self.alarmID = ""
    }
}

最终效果如下：

闹钟自定义铃声

另外闹钟支持自定义铃声，如果不传入sound，系统将会使用默认声音：

   let sound = AlertConfiguration.AlertSound.named("Chime")
    let alarmConfiguration = AlarmConfiguration(
            countdownDuration: duration,
            attributes: attributes,
            sound: sound)

如果需要自定义声音，需要将声音文件放在mainbunle或者Library/Sounds下。

总结

AlarmKit是一个非常强大的框架，可以让我们在iOS上创建系统体验一样的闹钟，并且支持自定义铃声。我们可以通过闹钟替换到现有的日历提醒功能，给用户带来更好的体验。

参考链接

Wake up to the AlarmKit API

利用lldb分析Swift调试问题

Wed, 29 Jan 2025 00:00:00 +0800

问题

自从升级了Xcode 16之后，swift环境下使用po就会出现问题，报错如下：

error: type for self cannot be reconstructed: type for typename "$s17swift_lldb_module10ModuleViewCD" was not found
error: Couldn't realize Swift AST type of self. Hint: using `v` to directly inspect variables and fields may still work.

从日志信息可以看出，是因为lldb无法获取到类型信息，导致的问题。

类型信息的作用是什么？

编译器提供的调试信息会告诉给调试器变量在内存中的位置,然后通过Types，lldb可以知道聚合类型源变量中的结构和内存布局，从而知道有哪些字段，并且通过Types使用数据格式化打印出更客观的格式出来。

类型信息从哪里来

在调试器端，用frame variable或v命令的时候，lldb从debug info和swift反射获取类型信息。
而在编译器端，用expr或po命令的时候，lldb通过Modules获取类型信息。

Modules是编译器构建类型声明的方式。

由此可见，应该是因为Modules导入失败，导致了lldb无法获取到类型信息。
通过swift-healthcheck命令，可以用来诊断swift环境的问题，在运行po命令发送错误之后，执行swift-healthcheck命令:

(lldb) swift-healthcheck
Health check written to /var/folders/c5/7j9s6knn0wvfdhfkz1pv67bh0000gn/T/lldb/5648/lldb-healthcheck-cad017.log

然后可以看到输出的日志:

SwiftASTContextForExpressions(module: "swift_lldb_module", cu: "Base64.swift")::LoadOneModule() -- Missing Swift module or Clang module found for "swift_lldb_module", "imported" via SwiftDWARFImporterDelegate. Hint: Register Swift modules with the linker using -add_ast_path.
SwiftASTContextForExpressions(module: "swift_lldb_module", cu: "Base64.swift")::LoadOneModule() -- Missing Swift module or Clang module found for "swift_lldb_module", "imported" via SwiftDWARFImporterDelegate. Hint: Register Swift modules with the linker using -add_ast_path.

因此更加可以确定是Modules导入失败导致的问题。

解决

接下来要怎么解决这个问题已经很明显了，可以通过-add_ast_path来注册Swift模块，让lldb可以找到类型信息。
如果是使用cocoapods，可以通过在Podfile中添加post_integrate脚本来解决这个问题。

post_integrate do |installer|
    #将swift-lldb-debug替换成你的target名字
    xcconfig_path = installer.sandbox.target_support_files_root.to_s + '/Pods-swift-lldb-debug/Pods-swift-lldb-debug.debug.xcconfig'

    xcconfig_content = File.read xcconfig_path
    xcconfig_original_ld_flags = xcconfig_content.match(/OTHER_LDFLAGS = ([^\n]+)\n/)[1]

    swift_module_flags = installer.pods_project.targets.map do |target|
           "-Wl,-add_ast_path,$(TARGET_BUILD_DIR)/#{target.name}/#{target.name}.swiftmodule/$(NATIVE_ARCH_ACTUAL)-apple-$(SHALLOW_BUNDLE_TRIPLE).swiftmodule"
    end.join(' ')

    xcconfig_new_ld_flags = <<~CONTENT

    OTHER_LDFLAGS = #{xcconfig_original_ld_flags} #{swift_module_flags}

    CONTENT

    xcconfig_content.gsub! /OTHER_LDFLAGS = ([^\n]+)\n/, xcconfig_new_ld_flags

    File.open(xcconfig_path, 'w') do |f|
      f.puts xcconfig_content
    end
end

执行pod install之后，就可以在Pods-xxx.debug.xcconfig中看到通过-add_ast_path注册的swift模块。

这样就可以解决lldb无法获取类型信息的问题了，这里还有一个小插曲，如果你的项目是通过rosetta运行到模拟器上，还需要注册到x86_64的swift模块，可以将$(NATIVE_ARCH_ACTUAL)替换成这段手动指定不同架构上：

    swift_module_flags = installer.pods_project.targets.map do |target|      
      "-Wl,-add_ast_path,$(TARGET_BUILD_DIR)/#{target.name}/#{target.name}.swiftmodule/x86_64-apple-$(SHALLOW_BUNDLE_TRIPLE).swiftmodule -Wl,-add_ast_path,$(TARGET_BUILD_DIR)/#{target.name}/#{target.name}.swiftmodule/arm64-apple-$(SHALLOW_BUNDLE_TRIPLE).swiftmodule"
    end.join(' ')

参考

Debug Swift debugging with LLDB
Breakpoint issue: ‘self cannot be reconstructed’

appstore-server-api使用

Wed, 15 May 2024 00:00:00 +0800

前言

前段时间有用户要求我退款，实际上退款只能由用户发起退款，苹果审核通过就可以了，开发者并没有权限处理退款。
但是用户把订单号发我了，我也很好奇开发者能否查到相关的订单信息，因此我去折腾了一下，先说一下结论：

如果是用户是购买App产生的订单号，苹果并没有提供对应的能力给开发者查询。

如果是用户是在App内购产生的订单号，那么可以通过AppStore-Server-API查询相关的信息。

正文

首先用户会向我们提供orderId，如下：
但是我们会发现，苹果的API大多数都是需要通过transactionId，而不是orderId，幸好苹果提供了API给我们可以通过orderId去查transactionId。

苹果的接口文档写的很复杂，建议是通过他们已经封装好的框架进行调用，目前已经有Swift、Java、Python、Node。在这里可以获取到对应语言的框架。

我这里也写了一个简单的demo调用可以参考

func fromUser() async {

    let issuerId = "xxx-xxx-xxx-xxx-xxx"
    let keyId = "xxx"
    let bundleId = "com.karim.xxx"

    let encodedKey = try! String(contentsOfFile: "/appstore-server/appstore-server/XXXX.p8")
    let environment = Environment.production
    let client = try! AppStoreServerAPIClient(signingKey: encodedKey, keyId: keyId, issuerId: issuerId, bundleId: bundleId, environment: environment)

    let response = await client.lookUpOrderId(orderId: "XXXXXX")
    switch response {
    case .success(let response):
        print(response)
    case .failure(let errorCode, let rawApiError, let apiError, let errorMessage, let causedBy):
        print(errorCode)
        print(rawApiError)
        print(apiError)
        print(errorMessage)
        print(causedBy)
    }
}

await fromUser()

上面代码中的issuerId、keyId、p8密钥，需要在appstoreconnect中自己生成，bundleId填入对应app的bundleId即可。

识别iOS虚拟定位

Wed, 16 Aug 2023 00:00:00 +0800

iOS虚拟定位几种方法：

使用Xcode自带Simulate Location，通过GPX文件修改；
通过Mac/PC应用修改手机定位；
通过外设修改手机定位；
逆向App，hook定位经纬度；

Xcode Simulate Location使用

要使用 Xcode 的Simulate Location，可以按照以下步骤：

打开 Xcode 并新建一个iOS项目；
运行项目，然后在菜单栏中，选择 Debug > Simulate Location；
在 Simulate Location 窗口中，选择Xcode预设的一些位置，或者通过GPX文件修改即可；

Usbmux

不管是Xcode、iTunes还是第三方的Mac/PC应用，都是通过Usbmux去调用iOS的com.apple.dt.simulatelocation服务。
Usbmux是可以通过一个usb管道建立多个连接的系统，他提供了一个类似TCP的系统，启动主机的进程连接到移动设备的端口号上，在Mac上，是由/System/Library/PrivateFrameworks/MobileDevice.framework/Resources/usbmuxd处理,这是一个由 launchd 启动的守护进程

它在 /var/run/usbmuxd 处创建一个监听 UNIX 域socket。然后usbmuxd通过USB监视设备连接，并和设备进行通讯。

usbmuxd建立了连接之后，iTunes/Xcode会通过MobileDevice.framework调用一些功能，通过class-dump可以发现一些安装DeviceSupport、固件升级、启动服务等的类：

而MobileDevice.framework只存在于Mac，通常会使用开源的libimobiledevice，他不仅实现了usbmuxd监听，并且为没有公开的服务进行的封装，iOS的性能测试、自动化测试基本都离不开它。

识别虚拟定位的方法

isSimulatedBySoftware & isProducedByAccessory

既然有攻，就会有守，先试试看从系统提供的定位API返回的信息中，是否有能有区分出是正常定位，还是虚拟定位。在查阅了Apple的文档后发现，在iOS 15之后，是有提供CLLocationSourceInformation定位来源可以区分是否是软件产生的虚拟定位或者是外设产生的虚拟定位。

@available(iOS 15.0, *)
open class CLLocationSourceInformation : NSObject, NSCopying, NSSecureCoding {

    
    public init(softwareSimulationState isSoftware: Bool, andExternalAccessoryState isAccessory: Bool)

    
    /*
     * isSimulatedBySoftware
     *
     * Discussion:
     *	Set to YES if this location was detected as being generated by a software simulator, such as Xcode
     */
    open var isSimulatedBySoftware: Bool { get }

    
    /*
     * isProducedByAccessory
     *
     * Discussion:
     * 	Set to YES if this location was generated from an external accessory, such as CarPlay or an MFi accessory
     */
    open var isProducedByAccessory: Bool { get }
}

经过测试后，这两个字段确实是有用的，正常定位的时候：

    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        print("是否是其他软件生成：\(locations.first?.sourceInformation?.isSimulatedBySoftware ?? false)") // 是否是其他软件生成：false
        print("是否是其他配件生成：\(locations.first?.sourceInformation?.isProducedByAccessory ?? false)") // 是否是其他配件生成：false
    }

使用其他软件修改定位的时候：

    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        print("是否是其他软件生成：\(locations.first?.sourceInformation?.isSimulatedBySoftware ?? false)") // 是否是其他软件生成：true
        print("是否是其他配件生成：\(locations.first?.sourceInformation?.isProducedByAccessory ?? false)") // 是否是其他配件生成：false
    }

altitude & verticalAccuracy

而在iOS 15之前，系统的没有提供的，查阅了网上的资料后，发现如果是虚拟定位CLLocation的altitude(海拔)总是会返回0，verticalAccuracy(精度)只会返回-1，所以测试了一下，使用正常定位的时候：

    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        print("location altitude:\(locations.first?.altitude)") // location altitude:Optional(27.427248001098633)
        print("location verticalAccuracy:\(locations.first?.verticalAccuracy)") // location verticalAccuracy:Optional(17.320518493652344)
    }

使用其他软件修改定位的时候：

    public func locationManager(_ manager: CLLocationManager, didUpdateLocations locations: [CLLocation]) {
        print("location altitude:\(locations.first?.altitude)") // location altitude:Optional(0.0)
        print("location verticalAccuracy:\(locations.first?.verticalAccuracy)") // location verticalAccuracy:Optional(-1.0)
    }

type

另外CLLocation还有个私有属性type，可以用来区分是否是虚拟定位，正常定位的时候：

let location = locations.first
print(location?.value(forKey: "type")) // 13

使用其他软件修改定位的时候：

let location = locations.first
print(location?.value(forKey: "type")) // 1

逆向

逆向是最头疼的问题，有攻才有防，在你不知道对方用什么招的时候，只能猜测对方会用什么方法，常规的方法，因为越狱后会存在Cydia，并且不再是沙盒权限，可以通过判断Cydia和越狱后才能获取得到的路径：

func isJailedDevice() -> Bool {
    let jailPaths = ["/Applications/Cydia.app",
                     "/Library/MobileSubstrate/MobileSubstrate.dylib",
                     "/bin/bash",
                     "/usr/sbin/sshd",
                     "/etc/apt"]
    
    for item in jailPaths {
        if FileManager.default.fileExists(atPath: item) {
            return true
        }
    }
    
    return false
}

越狱只是前提修改定位的前提，我们需要真正保护自己的App不受修改，防止被hook，iOS hook通常是通过注入dylib，替换方法实现达到效果，dladdr可以帮我们验证这个类的实现是来自哪里，在没有被hook的时候：

+ (void)test
{
    Dl_info info;
    IMP imp = class_getMethodImplementation(objc_getClass("CLLocation"),
                                            sel_registerName(@selector(coordinate)));
    if(dladdr(imp,&info)) {
        NSLog(@"dli_fname:%s",info.dli_fname);
    }
}

上面输出的是：

2023-08-16 23:35:07.194234+0800 LocationTest[2989:383262] dli_fname:/System/Library/Frameworks/CoreLocation.framework/CoreLocation

而被hook后，输出的是：

2023-08-16 23:35:18.194507+0800 LocationTest[2989:383262] dli_fname:/private/var/containers/Bundle/Application/1DB1541C-6997-4895-8850-B77645F4DB94/LocationTest.app/LocationTest

所以我们可以通过这个函数判断是否被hook。

总结

可以通过以下的几个方法识别出iOS的虚拟定位：

iOS 15以上，可以通过系统新增的两个属性isSimulatedBySoftware和isProducedByAccessory判断是否是虚拟定位；
判断海拔altitude为0，精度verticalAccuracy为-1；
通过CLLocation的私有属性type判断，为1的时候，是虚拟定位；
dladdr判断是否被hook

JSONDecoder源码分析

Wed, 14 Jun 2023 00:00:00 +0800

前言

JSONDecoder是Apple在Swift上实现JSON转模型的类，我在17年的时候，就写过相关介绍WWDC-2017笔记—Codable，所以这里就不做详细介绍了，有兴趣可以去考个古。

因为很久之前有做过ORM数据库的封装，而JSON转模型是ORM很基本的能力，所以一直以来对这个实现很感兴趣，Swift开源出来了，难得有机会读了一下。

最早的时候，是在swift-corelibs-foundation上看实现，但是swift-corelibs-foundation只是提供抽象到跨平台接口能力，具体swift中怎么实现的，是看不到的，幸好在swift-forums看到有相关讨论，很久之前有给swift提过mr，找到当时的commit是还有当初泄漏的JSONDecoder源码，在我看完这个版本之后，我以为已经结束了。偶然发现Apple又开源了个swift-foundation？？？居然是23年1月开源的（ps:可以通过github api查开源时间https://api.github.com/repos/apple/swift-foundation），并且声称速度比原来快了200-500%：

The tight integration of parsing JSON in Swift for initializing Codable types improves performance, too. In benchmarks parsing test data, there are improvements in decode time from 200% to almost 500%.

现在先从旧的JSONDecoder开始，看看苹果做了什么优化。

泄漏的JSONDecoder

先将data转成了json对象，初始化_JSONDecoder，unbox开始解包

    open func decode<T : Decodable>(_ type: T.Type, from data: Data) throws -> T {
        let topLevel: Any
        do {
           topLevel = try JSONSerialization.jsonObject(with: data)
        } catch {
            throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "The given data was not valid JSON.", underlyingError: error))
        }

        let decoder = _JSONDecoder(referencing: topLevel, options: self.options)
        guard let value = try decoder.unbox(topLevel, as: type) else {
            throw DecodingError.valueNotFound(type, DecodingError.Context(codingPath: [], debugDescription: "The given data did not contain a top-level value."))
        }

        return value
    }

因为我们都是要转成模型，就会直接走到对应类init(from decoder: Decoder)的方法

    fileprivate func unbox<T : Decodable>(_ value: Any, as type: T.Type) throws -> T? {
        if type == Date.self || type == NSDate.self {
            return try self.unbox(value, as: Date.self) as? T
        } else if type == Data.self || type == NSData.self {
            return try self.unbox(value, as: Data.self) as? T
        } else if type == URL.self || type == NSURL.self {
            guard let urlString = try self.unbox(value, as: String.self) else {
                return nil
            }

            guard let url = URL(string: urlString) else {
                throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: self.codingPath,
                                                                        debugDescription: "Invalid URL string."))
            }

            return url as! T
        } else if type == Decimal.self || type == NSDecimalNumber.self {
            return try self.unbox(value, as: Decimal.self) as? T
        } else {
            self.storage.push(container: value)
            defer { self.storage.popContainer() }
            return try type.init(from: self)
        }
    }

init(from decoder: Decoder)先要获取container

class Person: Codable {

    var name : String = ""
    var sex : Int = 0

    enum CodingKeys: String, CodingKey {
          case name
          case sex
      }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try values.decode(String.self, forKey: .name)
        sex = try values.decode(Int.self, forKey: .sex)
    }
}

    public func container<Key>(keyedBy: Key.Type) -> KeyedEncodingContainer<Key> {
        // If an existing keyed container was already requested, return that one.
        let topContainer: NSMutableDictionary
        if self.canEncodeNewValue {
            // We haven't yet pushed a container at this level; do so here.
            topContainer = self.storage.pushKeyedContainer()
        } else {
            guard let container = self.storage.containers.last as? NSMutableDictionary else {
                preconditionFailure("Attempt to push new keyed encoding container when already previously encoded at this path.")
            }

            topContainer = container
        }

        let container = _JSONKeyedEncodingContainer<Key>(referencing: self, codingPath: self.codingPath, wrapping: topContainer)
        return KeyedEncodingContainer(container)
    }

从container拿到value更新属性，如果是对象，会递归触发unbox进行解包

        public func decode(_ type: String.Type, forKey key: Key) throws -> String {
        guard let entry = self.container[key.stringValue] else {
            throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: self.decoder.codingPath, debugDescription: "No value associated with key \(_errorDescription(of: key))."))
        }

        self.decoder.codingPath.append(key)
        defer { self.decoder.codingPath.removeLast() }

        guard let value = try self.decoder.unbox(entry, as: String.self) else {
            throw DecodingError.valueNotFound(type, DecodingError.Context(codingPath: self.decoder.codingPath, debugDescription: "Expected \(type) value but found null instead."))
        }

        return value
    }

    public func decode<T : Decodable>(_ type: T.Type, forKey key: Key) throws -> T {
        guard let entry = self.container[key.stringValue] else {
            throw DecodingError.keyNotFound(key, DecodingError.Context(codingPath: self.decoder.codingPath, debugDescription: "No value associated with key \(_errorDescription(of: key))."))
        }

        self.decoder.codingPath.append(key)
        defer { self.decoder.codingPath.removeLast() }

        guard let value = try self.decoder.unbox(entry, as: type) else {
            throw DecodingError.valueNotFound(type, DecodingError.Context(codingPath: self.decoder.codingPath, debugDescription: "Expected \(type) value but found null instead."))
        }

        return value
    }

Swift-Foundation的JSONDecoder

decode方法的实现

open func decode<T: Decodable>(_ type: T.Type, from data: Data) throws -> T {
    try _decode({
        try $0.unwrap($1, as: type, for: .root, _JSONKey?.none)
    }, from: data)
}

private func _decode<T>(_ unwrap: (JSONDecoderImpl, JSONMap.Value) throws -> T, from data: Data) throws -> T {
    do {
        //先通过二进制缓存区前几位，判断是否是utf8编码，如果不是，转成utf8编码
        return try Self.withUTF8Representation(of: data) { utf8Buffer in
            var impl: JSONDecoderImpl
            let topValue: JSONMap.Value
            do {
                // JSON5 is implemented with a separate scanner to allow regular JSON scanning to achieve higher performance without compromising for `allowsJSON5` checks throughout.
                // Since the resulting JSONMap is identical, the decoder implementation is mostly shared between the two, with only a few branches to handle different methods of parsing strings and numbers. Strings and numbers are not completely parsed until decoding time.
                let map: JSONMap
                if allowsJSON5 {
                    var scanner = JSON5Scanner(bytes: utf8Buffer, options: self.json5ScannerOptions)
                    map = try scanner.scan()
                } else {
                    var scanner = JSONScanner(bytes: utf8Buffer, options: self.scannerOptions)
                    //扫描字符串，记录key/value的位置
                    map = try scanner.scan()
                }
                topValue = map.loadValue(at: 0)!
                impl = JSONDecoderImpl(userInfo: self.userInfo, from: map, codingPathNode: .root, options: self.options)
            }
            impl.push(value: topValue) // This is something the old implementation did and apps started relying on. Weird.
            let result = try unwrap(impl, topValue)
            let uniquelyReferenced = isKnownUniquelyReferenced(&impl)
            impl.takeOwnershipOfBackingDataIfNeeded(selfIsUniquelyReferenced: uniquelyReferenced)
            return result
        }
    } catch let error as JSONError {
        #if FOUNDATION_FRAMEWORK
        let underlyingError: Error? = error.nsError
        #else
        let underlyingError: Error? = nil
        #endif
        throw DecodingError.dataCorrupted(DecodingError.Context(codingPath: [], debugDescription: "The given data was not valid JSON.", underlyingError: underlyingError))
    } catch {
        throw error
    }
}

判断前几个字节是否是 utf8 编码，如果不是，转成 utf8 编码

static func withUTF8Representation<T>(of jsonData: Data, _ closure: (BufferView<UInt8>) throws -> T ) throws -> T {
    return try jsonData.withBufferView {
        [length = jsonData.count] bytes in
        assert(bytes.count == length)
        // RFC4627 section 3
        // The first two characters of a JSON text will always be ASCII. We can determine encoding by looking at the first four bytes.
        let byte0 = (length > 0) ? bytes[uncheckedOffset: 0] : nil
        let byte1 = (length > 1) ? bytes[uncheckedOffset: 1] : nil
        let byte2 = (length > 2) ? bytes[uncheckedOffset: 2] : nil
        let byte3 = (length > 3) ? bytes[uncheckedOffset: 3] : nil
        // Check for explicit BOM first, then check the first two bytes. Note that if there is a BOM, we have to create our string without it.
        // This isn't strictly part of the JSON spec but it's useful to do anyway.
        let sourceEncoding : String._Encoding
        let bomLength : Int
        switch (byte0, byte1, byte2, byte3) {
        case (0, 0, 0xFE, 0xFF):
            sourceEncoding = .utf32BigEndian
            bomLength = 4
        case (0xFE, 0xFF, 0, 0):
            sourceEncoding = .utf32LittleEndian
            bomLength = 4
        case (0xFE, 0xFF, _, _):
            sourceEncoding = .utf16BigEndian
            bomLength = 2
        case (0xFF, 0xFE, _, _):
            sourceEncoding = .utf16LittleEndian
            bomLength = 2
        case (0xEF, 0xBB, 0xBF, _):
            sourceEncoding = .utf8
            bomLength = 3
        case let (0, 0, 0, .some(nz)) where nz != 0:
            sourceEncoding = .utf32BigEndian
            bomLength = 0
        case let (0, .some(nz1), 0, .some(nz2)) where nz1 != 0 && nz2 != 0:
            sourceEncoding = .utf16BigEndian
            bomLength = 0
        case let (.some(nz), 0, 0, 0) where nz != 0:
            sourceEncoding = .utf32LittleEndian
            bomLength = 0
        case let (.some(nz1), 0, .some(nz2), 0) where nz1 != 0 && nz2 != 0:
            sourceEncoding = .utf16LittleEndian
            bomLength = 0
        // These cases technically aren't specified by RFC4627, since it only covers cases where the input has at least 4 octets. However, when parsing JSON with fragments allowed, it's possible to have a valid UTF-16 input that is a single digit, which is 2 octets. To properly support these inputs, we'll extend the pattern described above for 4 octets of UTF-16.
        case let (0, .some(nz), nil, nil) where nz != 0:
            sourceEncoding = .utf16BigEndian
            bomLength = 0
        case let (.some(nz), 0, nil, nil) where nz != 0:
            sourceEncoding = .utf16LittleEndian
            bomLength = 0
        default:
            sourceEncoding = .utf8
            bomLength = 0
        }
        let postBOMBuffer = bytes.dropFirst(bomLength)
        if sourceEncoding == .utf8 {
            return try closure(postBOMBuffer)
        } else {
            guard var string = String(bytes: postBOMBuffer, encoding: sourceEncoding) else {
                throw JSONError.cannotConvertEntireInputDataToUTF8
            }
            return try string.withUTF8 {
                // String never passes an empty buffer with a `nil` `baseAddress`.
                try closure(BufferView(unsafeBufferPointer: $0)!)
            }
        }
    }
}

JSONScanner.scan()的过程中，会将字段信息记录在一个数组中，方便后面直接取出

    enum TypeDescriptor : Int {
        case string  // [marker, count, sourceByteOffset]
        case number  // [marker, count, sourceByteOffset]
        case null    // [marker]
        case `true`  // [marker]
        case `false` // [marker]

        case object  // [marker, nextSiblingOffset, count, <keys and values>, .collectionEnd]
        case array   // [marker, nextSiblingOffset, count, <values>, .collectionEnd]
        case collectionEnd

        case simpleString // [marker, count, sourceByteOffset]
        case numberContainingExponent // [marker, count, sourceByteOffset]

        @inline(__always)
        var mapMarker: Int {
            self.rawValue
        }
    }

mutating func recordStartCollection(tagType: JSONMap.TypeDescriptor, with reader: DocumentReader) -> Int {
    resizeIfNecessary(with: reader)
    mapData.append(tagType.mapMarker)
    // Reserve space for the next object index and object count.
    let startIdx = mapData.count
    mapData.append(contentsOf: [0, 0])
    return startIdx
}

mutating func recordEndCollection(count: Int, atStartOffset startOffset: Int, with reader: DocumentReader) {
    resizeIfNecessary(with: reader)
    mapData.append(JSONMap.TypeDescriptor.collectionEnd.rawValue)
    let nextValueOffset = mapData.count
    mapData.withUnsafeMutableBufferPointer {
        $0[startOffset] = nextValueOffset
        $0[startOffset + 1] = count
    }
}

mutating func record(tagType: JSONMap.TypeDescriptor, count: Int, dataOffset: Int, withreader: DocumentReader) {
    resizeIfNecessary(with: reader)
    mapData.append(contentsOf: [tagType.mapMarker, count, dataOffset])
}

根据不同类型进行解包

func unwrap<T: Decodable>(_ mapValue: JSONMap.Value, as type: T.Type, for codingPathNode: _JSONCodingPathNode, _ additionalKey: (some CodingKey)? = nil) throws -> T {
    if type == Date.self {
        return try self.unwrapDate(from: mapValue, for: codingPathNode, additionalKey) as! T
    }
    if type == Data.self {
        return try self.unwrapData(from: mapValue, for: codingPathNode, additionalKey) as! T
    }
#if FOUNDATION_FRAMEWORK // TODO: Reenable once URL and Decimal are moved
    if type == URL.self {
        return try self.unwrapURL(from: mapValue, for: codingPathNode, additionalKey) as! T
    }
    if type == Decimal.self {
        return try self.unwrapDecimal(from: mapValue, for: codingPathNode, additionalKey) as! T
    }
#endif// FOUNDATION_FRAMEWORK
    if T.self is _JSONStringDictionaryDecodableMarker.Type {
        return try self.unwrapDictionary(from: mapValue, as: type, for: codingPathNode, additionalKey)
    }
    return try self.with(value: mapValue, path: codingPathNode.pushing(additionalKey)) {
        try type.init(from: self)
    }
}

如果触发模型的解包，会先从container<Key: CodingKey>(keyedBy _: Key.Type)拿到解包key后的[String:JSONMap.Value]，随后再根据字段进行decode，取到值赋值到属性

class Person: Codable {

    var name : String = ""
    var sex : Int = 0

    enum CodingKeys: String, CodingKey {
          case name
          case sex
      }

    required init(from decoder: Decoder) throws {
        let container = try decoder.container(keyedBy: CodingKeys.self)
        name = try container.decode(String.self, forKey: .name)
        sex = try container.decode(Int.self, forKey: .sex)
    }
}

初始化container,拿到解包key后的[String:JSONMap.Value]，返回container

func container<Key: CodingKey>(keyedBy _: Key.Type) throws -> KeyedDecodingContainer<Key> {
    switch topValue {
    case let .object(region):
        let container = try KeyedContainer<Key>(
            impl: self,
            codingPathNode: codingPathNode,
            region: region
        )
        return KeyedDecodingContainer(container)
    case .null:
        throw DecodingError.valueNotFound([String: Any].self, DecodingError.Context(
            codingPath: self.codingPath,
            debugDescription: "Cannot get keyed decoding container -- found null value instead"
        ))
    default:
        throw DecodingError.typeMismatch([String: Any].self, DecodingError.Context(
            codingPath: self.codingPath,
            debugDescription: "Expected to decode \([String: Any].self) but found \(topValue.debugDataTypeDescription) instead."
        ))
    }
}


init(impl: JSONDecoderImpl, codingPathNode: _JSONCodingPathNode, region: JSONMap.Region) throws {
    self.impl = impl
    self.codingPathNode = codingPathNode
    self.dictionary = try Self.stringify(objectRegion: region, using: impl, codingPathNode: codingPathNode, keyDecodingStrategy: impl.options.keyDecodingStrategy)
}

遍历当前结构下的所有keyValue,这里的keyValue还是指json里的key，value才是json的value，此时经过unwrapString后，会将解包成String的key更新到result

static func stringify(objectRegion: JSONMap.Region, using impl: JSONDecoderImpl, codingPathNode: _JSONCodingPathNode, keyDecodingStrategy: JSONDecoder.KeyDecodingStrategy) throws -> [String:JSONMap.Value] {
            var result = [String:JSONMap.Value]()
            result.reserveCapacity(objectRegion.count / 2)

            var iter = impl.jsonMap.makeObjectIterator(from: objectRegion.startOffset)
            switch keyDecodingStrategy {
            case .useDefaultKeys:
                while let (keyValue, value) = iter.next() {
                    // Failing to unwrap a string here is impossible, as scanning already guarantees that dictionary keys are strings.
                    let key = try! impl.unwrapString(from: keyValue, for: codingPathNode, _JSONKey?.none)
                    result[key]._setIfNil(to: value)
                }
            case .convertFromSnakeCase:
                while let (keyValue, value) = iter.next() {
                    // Failing to unwrap a string here is impossible, as scanning already guarantees that dictionary keys are strings.
                    let key = try! impl.unwrapString(from: keyValue, for: codingPathNode, _JSONKey?.none)

                    // Convert the snake case keys in the container to camel case.
                    // If we hit a duplicate key after conversion, then we'll use the first one we saw.
                    // Effectively an undefined behavior with JSON dictionaries.
                    result[JSONDecoder.KeyDecodingStrategy._convertFromSnakeCase(key)]._setIfNil(to: value)
                }
            case .custom(let converter):
                let codingPathForCustomConverter = codingPathNode.path
                while let (keyValue, value) = iter.next() {
                    // Failing to unwrap a string here is impossible, as scanning already guarantees that dictionary keys are strings.
                    let key = try! impl.unwrapString(from: keyValue, for: codingPathNode, _JSONKey?.none)

                    var pathForKey = codingPathForCustomConverter
                    pathForKey.append(_JSONKey(stringValue: key)!)
                    result[converter(pathForKey).stringValue]._setIfNil(to: value)
                }
            }

            return result
        }

和上面解包keyValue的类似，这里是解包value，如果value对应是对象，会再次触发unwrap递归解包剩下的字段

func decode(_ type: String.Type, forKey key: K) throws -> String {
    let value = try getValue(forKey: key)
    return try impl.unwrapString(from: value, for: self.codingPathNode, key)
}

mutating func decode<T: Decodable>(_ type: T.Type) throws -> T {
    let value = try self.peekNextValue(ofType: type)
    let result = try impl.unwrap(value, as: type, for: codingPathNode, currentIndexKey)
    advanceToNextValue()
    return result
}

如果value是字符串，会通过下面的方法将JSONMap.Value解包成String的实现，前面scan的时候，已经记录了字段位置了，经过stringify后，转成JSONMap.Value，再经过这里转成String，其他的类型也类似

private func unwrapString(from value: JSONMap.Value, for codingPathNode: _JSONCodingPathNode, _additionalKey: (some CodingKey)? = nil) throws -> String {
    try checkNotNull(value, expectedType: [String].self, for: codingPathNode, additionalKey)
    guard case .string(let region, let isSimple) = value else {
        throw self.createTypeMismatchError(type: String.self, for: codingPathNode.path(with: additionalKey), value: value)
    }
    return try withBuffer(for: region) { stringBuffer, fullSource in
    
        if isSimple {
            guard let result = String._tryFromUTF8(stringBuffer) else {
                throw JSONError.cannotConvertInputStringDataToUTF8(location: .sourceLocation(at: stringBuffer.startIndex, fullSource: fullSource))
            }
            return result
        }
        if options.json5 {
            return try JSON5Scanner.stringValue(from: stringBuffer, fullSource: fullSource)
        } else {
            return try JSONScanner.stringValue(from: stringBuffer, fullSource: fullSource)
        }
    }
}

对比

通过两者之间对比，不难发现现在的JSONDecoder和通过Swift重写后的JSONDecoder差别很大。现在的JSONDecoder：
需要先通过OC的JSONSerialization转成字典，然后再递归赋值； Swift-Foundation重写后：
直接通过Data进行操作，将整个Data扫描一次后，记录key和value的位置以及长度，然后再递归赋值；

总结

表面上看起来重写后的Swift-Foundtion是好了很多，至少我们能知道它是怎么工作的了，但是现实并没有那么美好，我试了单独将JSONDecoder抽出到工程测试，性能并没有比JSONSerialization好，甚至还慢了不少，不过还发现了个比较有意思的点，通过Swift 5.9运行要比Swift 5.8快了接近50%，Swift-Foundation本身是需要在Swift 5.9才能使用，不出意外的话，今年（2023）就会发布了，等正式发布后说不定能达到苹果说的优化呢？让我们期待一下吧。

参考链接

Swift-Foundation
How to build and debug JSONDecoder?