KeyboardHostBundleID

Get the host app's Bundle ID from an iOS keyboard extension — fully working on iOS 26.4+, with an automatic fallback for iOS 16 ~ 26.3.

Language: English · 简体中文

---

Problem

If you ship a third-party iOS keyboard (UIInputViewController), you probably want to know which app the keyboard is currently embedded in — to tailor the UI, log analytics, or route deep-links back to the host.

For years the standard trick was:

parent._hostPID  →  PKService.defaultService.personalities[bundleID][pid].connection._xpcConnection
                 →  xpc_connection_copy_bundle_id(...)

This breaks on iOS 26.4. Apple refactored the private surface; _hostPID or the PKService personalities dictionary no longer yields a usable XPC connection, and xpc_connection_copy_bundle_id returns an empty string. Every keyboard relying on the old chain silently loses the host Bundle ID after the user upgrades.

What this library does

KeyboardHostBundleID gives you one unified call that Just Works from iOS 16 all the way through iOS 26.4+:

import KeyboardHostBundleID

class MyKeyboardVC: UIInputViewController {
    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)
        if let hostBundleId = KeyboardHost.resolve(from: self) {
            print("Host app:", hostBundleId) // e.g. "com.apple.MobileSMS"
        }
    }
}

Internally it dispatches to the right strategy automatically:

iOS range	Strategy
iOS 26.4+	Swizzles _UIKeyboardArbiterClientInputDestination and reads _sourceBundleIdentifier off the callback
iOS 16 – 26.3	Legacy PKService + xpc_connection_copy_bundle_id chain

No configuration. No app-group wiring. Drop it in and call one function.

Installation

Swift Package Manager

In Xcode: File → Add Packages… and paste:

https://github.com/editorss/KeyboardHostBundleID.git

Add the KeyboardHostBundleID library product to your keyboard extension target (not just the main app).

Or in Package.swift:

dependencies: [
    .package(url: "https://github.com/editorss/KeyboardHostBundleID.git", from: "1.0.0")
],
targets: [
    .target(name: "YourKeyboardExtension", dependencies: ["KeyboardHostBundleID"])
]

CocoaPods

target 'YourKeyboardExtension' do
  pod 'KeyboardHostBundleID', '~> 1.0'
end

Manually

Drag Sources/KBHostArbiterHookObjC/ and Sources/KeyboardHostBundleID/ into your keyboard-extension target. Make sure the header KBHostArbiterHook.h is exposed via your bridging header (or a module map).

Usage

import KeyboardHostBundleID

class KeyboardViewController: UIInputViewController {

    override func viewDidAppear(_ animated: Bool) {
        super.viewDidAppear(animated)

        // Primary call. Returns the host app's Bundle ID or nil.
        if let bid = KeyboardHost.resolve(from: self) {
            configureUI(forHost: bid)
        }
    }

    /// Cheap, side-effect-free read of whatever the swizzle has captured so
    /// far. Use when you're polling or don't want to spin the runloop.
    func currentHostIfKnown() -> String? {
        KeyboardHost.lastCapturedHostBundleId
    }
}

Tuning the synchronous wait

resolve(from:runloopWaitSeconds:) accepts an optional runloop wait (default 0.05s) used after pinging the arbiter, giving the swizzle a chance to fire before we fall back to the legacy path. Pass 0 to skip the wait entirely.

How it works (iOS 26.4+)

The iOS 26.4 keyboard arbiter dispatches host-change events through -[_UIKeyboardArbiterClientInputDestination queue_keyboardChanged:onComplete:]. The change argument carries a KVC key _sourceBundleIdentifier with the host app's Bundle ID.

The library installs itself with four careful moves:

1. ObjC +load installer. The hook ships as an ObjC class; +load runs at dyld image-load time, strictly before any Swift runtime init and before UIKit's first arbiter dispatch. Using Swift's static let/singleton initialization would be too late — the first keyboard-focus event fires on launch and would be missed.

2. Force +[_UIKeyboardArbiterClient enabled] to return YES. iOS 26.4 gates the destination-changed dispatch on this class method. Inside a keyboard extension process it returns NO by default and the callback chain is skipped entirely. method_setImplementation swaps it to an always-YES implementation so our trampoline gets called.

3. Swizzle the instance method. class_getInstanceMethod + method_setImplementation replaces queue_keyboardChanged:onComplete: with a trampoline that reads _sourceBundleIdentifier off the change argument (not self) via KVC, caches it under an os_unfair_lock, and forwards to the original IMP.

4. Active ping for on-demand reads. If you need the value synchronously before the arbiter has dispatched in the current process, call KBHostArbiterHook.activeArbiterCheck(). It invokes +[_UIKeyboardArbiterClient automaticSharedArbiterClient] -> checkConnection to nudge the arbiter, then spin a short runloop (done for you inside KeyboardHost.resolve).

All private symbol names (_UIKeyboardArbiterClient, queue_keyboardChanged:onComplete:, _sourceBundleIdentifier, …) are resolved at runtime via NSClassFromString / NSSelectorFromString so they never appear as static references.

Bundle IDs are sanity-checked before being cached: non-empty, must contain ., must not equal the current extension's own bundle, must not be com.apple.*.

Legacy path (iOS 16 ~ 26.3)

LegacyHostResolver.resolve(from:) is the classic chain, slightly hardened:

1. inputVC.parent.value(forKey: "_hostPID")
2. PKService.defaultService().personalities[bundleID][pid].connection._xpcConnection
3. xpc_connection_copy_bundle_id(xpcConnection) via dlsym on libc.dylib

Every link returns nil silently on failure — callers handle nil.

Requirements

• iOS 15.0+ (the library itself; the iOS 26.4 swizzle is gated at runtime)
• Xcode 15+
• Swift 5.9+

Known limitations

• Uses private APIs — Apple could change or remove them at any time. Re-test on every iOS beta.
• Single-process cache. If you need to share the captured Bundle ID with your main app or with other processes, write it into your App Group UserDefaults yourself — the library intentionally does not assume an App Group identifier.
• The active-ping path spins the current runloop briefly. Avoid calling resolve on a latency-sensitive path unless you pass runloopWaitSeconds: 0.
• KeyboardHost.resolve(from:) returns nil if invoked before the extension has a parent (pre viewDidLoad). Call it from viewDidAppear or later.

FAQ

Does this work in the App Store? Using private APIs is always "at your own risk." Major apps (including a number of popular Chinese keyboards) have shipped similar techniques for years, but Apple's review is ultimately discretionary. The library does not rely on any single private symbol being present — every runtime lookup is guarded and fails silently.

Will it ever return the wrong Bundle ID? The swizzle captures the most recent destination change reported by UIKit's arbiter, which is exactly the host your keyboard is currently attached to. The validation filter rejects your own bundle and Apple internal identities. That said, if you call resolve from a weird lifecycle moment (e.g. while the keyboard is being torn down), you may read a stale value.

Why not put everything in Swift? Swift class initialization is triggered lazily on first use, which is too late for UIKit's initial arbiter dispatch. ObjC +load is the only mechanism that runs before the arbiter fires.

License

MIT. See LICENSE.

Contributing

Issues and PRs welcome — especially reports confirming behavior on new iOS betas. Please include your exact iOS version and whether the iOS 26.4+ path or the legacy path succeeded.