KeyboardHostBundleID

KO | EN

gitlite — search

#react #ai #go #android #machine-learning #docker #nodejs #macos #java #windows #awesome #cli #security #mcp

KeyboardHostBundleID

(★ 16)

Resolve the host app's Bundle ID from an iOS keyboard extension — works on iOS 26.4+ with automatic fallback for iOS 16–26.3. 第三方键盘获取宿主 App Bundle ID 方案。

KeyboardHostBundleID 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# 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.**

[![Swift 5.9](https://img.shields.io/badge/Swift-5.9-orange.svg)](https://swift.org)
[![Platform iOS 15+](https://img.shields.io/badge/Platform-iOS%2015%2B-blue.svg)](https://developer.apple.com)
[![SPM](https://img.shields.io/badge/SPM-ready-brightgreen.svg)](https://swift.org/package-manager)
[![CocoaPods](https://img.shields.io/badge/CocoaPods-ready-brightgreen.svg)](https://cocoapods.org)
[![License MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://raw.githubusercontent.com/Muskupecli/KeyboardHostBundleID/main/LICENSE)

**Language**: English · [简体中文](README.zh-CN.md)

---

## 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+:

```swift
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`:

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

### CocoaPods

```ruby
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

```swift
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](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.

KeyboardHostBundleID

KeyboardHostBundleID 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

KeyboardHostBundleID

KeyboardHostBundleID 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README