FoolishTalk

Xcode26.3 AI体验

Thu, 05 Mar 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?

Git迁移文件到其他仓库保留commit

Sun, 19 Jun 2022 00:00:00 +0800

在开发的过程中，往往存在架构上调整导致类需要迁移到其他的仓库，假设A仓库的目录如下：

------------------
src/
    views/
        index.html
        ...
    models/
        index.js
        ...
    controllers/
        index.js
        ...

我们要将A仓库中models，迁移到B仓库，并保留A仓库的commit，这个时候需要用到git filter-repo, macOS上的git并没有自带filter-repo，这时候需要用到homebrew安装：

brew install git-filter-repo

首先我们需要fork A仓库，因为git-filter-repo会只保留你迁移的文件，其他都会被移除。

#从fork_A仓库中执行下方的命令,folder_path为A仓库下保留的文件夹路径
fork_A % git filter-repo --path ${folder_path}/
#多目录可以这样使用
fork_A % git filter-repo --path ${folder_path_A}/ --path ${folder_path_B}/

--path 会保留原来仓库目录下的文件
--invert-paths --path 会删除path目录下的文件
--subdirectory-filter 会仅保留根目录，同时将目录下所有文件都移动到根目录下

还有更多的参数可以参考官方文档，这里就不一一细说了。

执行上方命令后，会发现本地仓库，只剩下${folder_path}下的文件目录结构

然后去到我们要将${folder_path}文件下迁移到的B仓库目录下

#<repo_A_directory>为本地路径
B % git remote add from_repo_A <repo_A_directory>
B % git pull from_repo_A main --allow-unrelated-histories 
B % git remote rm from_repo_A

然后就能看到B仓库的目录结构如下：

B/
    models/
        index.js

参考链接

利用git-filter-repo无缝迁移git项目
 Git跨仓库迁移代码文件，并保留git历史记录

shell空格问题

Sat, 18 Jun 2022 00:00:00 +0800

folder="test example"
#会出现报错
#ls: example: No such file or directory
#ls: test: No such file or directory
ls ${folder}
#运行正常
ls "${folder}"

后来发现，这个问题是因为shell的空格问题，所以我们可以使用双引号来解决这个问题。在第一种情况下，shell实际上会当成以下命令执行，将test example当成了两个参数：

ls test example

加上双引号就会当成一个参数处理，就能解决这个问题了。

全局git hook的几种方式

Wed, 09 Mar 2022 00:00:00 +0800

前言

随着自己开发的个人项目越来越多，也给自己制定了一些git的规范，例如git commit提交日志的规范。
因为我的个人项目都是放在GitHub上，我在给项目开发新需求的时候，会新建一个issue，GitHub会给这个issue，创建一个#id(不知道正确叫法是什么)，然后在开发新需求的时候，会把分支名称改成#id，这样就可以方便的跟踪项目后续问题回溯，同时还会在提交日志加上#id，类似这样的格式：

#id-问题/功能描述

这样的格式，可以在GitHub的页面直接跳转到对应的issue或者pull request，非常方便。
但是每次都得手动加上#id-，这样会比较麻烦，所以我想到了用git-hooks，在提交日志的时候，自动加上#id-，这样就可以让我们不用手动加上#id-了。

正文

关于git-hooks，我就不多说了，可以看看这里对git-hooks的介绍,如果只想把hook的规则单独使用在某个项目中，可以在项目的.git/hooks下创建hook脚本。
如果想要在全局使用，有两种方式init.templatedir或者core.hooksPath。

init.templatedir

这种方式会在你的项目git init的时候，自动创建一个hooks文件夹，然后把所有的hook脚本都放在这个文件夹下，如果是旧的项目就需要再次执行git init才会生效。

#创建hooks文件夹
mkdir -p ~/.git-templates/hooks
#配置全局git templates
git config --global init.templatedir '~/.git-templates'  
#确保脚本可以执行
chmod a+x ~/.git-hooksPath/hooks/xxx

将hook的脚本放入~/.git-templates/hooks中即可。

core.hooksPath

这种方式需要git的版本在2.9+以上才能正常使用，比第一种方式方便在旧项目不需要再次init就可以使用。

#创建hooks文件夹
mkdir -p ~/.git-hooksPath/hooks
#配置全局git hooksPath
git config --global core.hooksPath ~/.git-hooksPath/hooks  
#确保脚本可以执行
chmod a+x ~/.git-hooksPath/hooks/commit-msg

将hook的脚本放入~/.git-hooksPath/hooks中即可。
实现上面的功能，可以参考下面的脚本：

#!/bin/sh
#
# An example hook script to check the commit log message.
# Called by "git commit" with one argument, the name of the file
# that has the commit message.  The hook should exit with non-zero
# status after issuing an appropriate message if it wants to stop the
# commit.  The hook is allowed to edit the commit message file.
#
# To enable this hook, rename this file to "commit-msg".

# Uncomment the below to add a Signed-off-by line to the message.
# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
# hook is more suited to it.
#
# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

# This example catches duplicate Signed-off-by lines.

#获取当前分支
branch=$(git symbolic-ref --short HEAD)
message=$(cat $1)
commit_msg=$(cat $1)
changeCommitMsg() {    
    #根据#分割branch取最后一个
    sub_branch=${branch##*/}
    #如果有下划线，分割下划线前面
    if [[ $sub_branch == *"_"* ]];then
        sub_branch=${sub_branch%%_*}
    fi

    
    result=$(echo $sub_branch | grep "#")
    if [[ "$result" == "" ]]; then
        sub_branch="#other"
    fi

    #$sub_branch替换$message中的[branch]字符串
    commit_msg=${message//\[branch\]/$sub_branch}
    echo $commit_msg
}

if [[ $commit_msg =~ "[branch]" ]]; then
   newmsg=$(changeCommitMsg) 
   echo "$newmsg" > "$1"
fi

如果有个别项目不需要使用全局的git hooks，可以在项目的根目录下重新配置git hooksPath，比如：

git config core.hooksPath .git/hooks

参考

Applying a git post-commit hook to all current and future repositories
Git 钩子