Initial implementation of KeyboardControl package

Author: Semen Osipov

.gitignore

@@ -27,7 +27,7 @@ playground.xcworkspace
 #
 # Xcode automatically generates this directory with a .xcworkspacedata file and xcuserdata
 # hence it is not needed unless you have added a package configuration file to your project
-# .swiftpm
+.swiftpm/
 
 .build/
 

Package.swift

@@ -0,0 +1,14 @@
+// swift-tools-version: 5.7
+
+import PackageDescription
+
+let package = Package(
+    name: "KeyboardControl",
+    platforms: [.iOS(.v13)],
+    products: [
+        .library(name: "KeyboardControl", targets: ["KeyboardControl"])
+    ],
+    targets: [
+        .target(name: "KeyboardControl")
+    ]
+)

README.md

@@ -1 +1,136 @@
-# ARKeyboardControl
+# ARKeyboardControl
+
+Lightweight Swift library that adds keyboard awareness and interactive dismissal to any `UIView`. Inspired by [DAKeyboardControl](https://github.com/danielamitay/DAKeyboardControl), rewritten from scratch in pure Swift without method swizzling.
+
+## Features
+
+- **Interactive dismiss** — drag down to dismiss keyboard, like in iMessage
+- **Non-panning mode** — track keyboard appearance/disappearance without gestures
+- **Two callback modes** — frame-based (inside animation block) and constraint-based (before animation)
+- **iOS 15+ optimization** — uses `keyboardLayoutGuide` for non-panning mode when available
+- **Minimal footprint** — single associated object per view, clean teardown
+- **No swizzling** — no `+load`, no method exchange, no global side effects
+
+## Requirements
+
+- iOS 13.0+
+- Swift 5.7+
+
+## Installation
+
+### Swift Package Manager
+
+Add the package dependency:
+
+```swift
+dependencies: [
+    .package(url: "https://github.com/AppleArealidea/ARKeyboardControl.git", from: "1.0.0")
+]
+```
+
+Or add it as a local package in Xcode via File > Add Package Dependencies.
+
+## Usage
+
+### Interactive keyboard dismiss (chat screens)
+
+```swift
+import KeyboardControl
+
+override func viewDidAppear(_ animated: Bool) {
+    super.viewDidAppear(animated)
+
+    view.addKeyboardPanning { beginFrame, endFrame, opening, closing in
+        // Called inside UIView.animate — update frames here
+        if opening {
+            tableView.contentOffset.y += beginFrame.minY - endFrame.minY
+        }
+    } constraintBasedActionHandler: { _, endFrame, _, _ in
+        // Called before animation — update constraints here
+        let offset = view.frame.height - endFrame.minY - view.safeAreaInsets.bottom
+        bottomConstraint.constant = offset > 0 ? -offset : 0
+    }
+}
+
+override func viewWillDisappear(_ animated: Bool) {
+    super.viewWillDisappear(animated)
+    view.removeKeyboardControl()
+}
+```
+
+### Keyboard awareness only (no gestures)
+
+```swift
+view.addKeyboardNonpanning { _, endFrame, opening, closing in
+    let offset = view.frame.height - endFrame.origin.y - view.safeAreaInsets.bottom
+    bottomConstraint.constant = offset > 0 ? -offset : 0
+    view.layoutIfNeeded()
+}
+```
+
+On iOS 15+ this automatically uses `keyboardLayoutGuide` under the hood.
+
+### Gesture coordination
+
+Access the pan gesture recognizer to coordinate with other gestures:
+
+```swift
+if let keyboardPan = view.keyboardPanRecognizer {
+    myGesture.require(toFail: keyboardPan)
+}
+```
+
+### Utilities
+
+```swift
+view.hideKeyboard()        // Programmatically dismiss
+view.isKeyboardOpened      // Current state
+view.keyboardFrameInView   // Keyboard frame in view's coordinate space
+```
+
+### Cleanup
+
+Always call `removeKeyboardControl()` when the view is going away:
+
+```swift
+// In viewWillDisappear or deinit
+view.removeKeyboardControl()
+```
+
+## API
+
+```swift
+public extension UIView {
+    func addKeyboardPanning(
+        frameBasedActionHandler: @escaping KeyboardDidMoveBlock,
+        constraintBasedActionHandler: @escaping KeyboardDidMoveBlock
+    )
+    func addKeyboardNonpanning(actionHandler: @escaping KeyboardDidMoveBlock)
+    func removeKeyboardControl()
+    func hideKeyboard()
+
+    var keyboardPanRecognizer: UIPanGestureRecognizer? { get }
+    var keyboardFrameInView: CGRect { get }
+    var isKeyboardOpened: Bool { get }
+}
+
+public typealias KeyboardDidMoveBlock = (
+    _ keyboardBeginFrame: CGRect,
+    _ keyboardEndFrame: CGRect,
+    _ opening: Bool,
+    _ closing: Bool
+) -> Void
+```
+
+## Callback parameters
+
+| Parameter | Description |
+|-----------|-------------|
+| `keyboardBeginFrame` | Keyboard frame before the transition (in view's coordinates) |
+| `keyboardEndFrame` | Keyboard frame after the transition (in view's coordinates) |
+| `opening` | `true` when keyboard is appearing |
+| `closing` | `true` when keyboard is disappearing |
+
+## License
+
+MIT. See [LICENSE](LICENSE) for details.

Sources/KeyboardControl/KeyboardControl.swift

@@ -0,0 +1,79 @@
+import UIKit
+import ObjectiveC
+
+private var keyboardObserverKey: UInt8 = 0
+
+public extension UIView {
+
+    // MARK: - Panning (interactive keyboard dismiss)
+
+    func addKeyboardPanning(
+        frameBasedActionHandler: @escaping KeyboardDidMoveBlock,
+        constraintBasedActionHandler: @escaping KeyboardDidMoveBlock
+    ) {
+        let observer = getOrCreateObserver()
+        observer.frameBasedBlock = frameBasedActionHandler
+        observer.constraintBasedBlock = constraintBasedActionHandler
+
+        if let scrollView = self as? UIScrollView {
+            scrollView.keyboardDismissMode = .interactive
+        }
+
+        observer.panHandler = KeyboardPanHandler(view: self, observer: observer)
+        observer.setupNotificationObservers()
+    }
+
+    // MARK: - Non-panning (keyboard awareness only)
+
+    func addKeyboardNonpanning(actionHandler: @escaping KeyboardDidMoveBlock) {
+        let observer = getOrCreateObserver()
+        observer.frameBasedBlock = actionHandler
+
+        if #available(iOS 15.0, *) {
+            let adapter = KeyboardLayoutGuideAdapter(view: self, actionBlock: actionHandler)
+            observer.layoutGuideAdapter = adapter
+            observer.setupNotificationObservers()
+        } else {
+            observer.setupNotificationObservers()
+        }
+    }
+
+    // MARK: - Cleanup
+
+    func removeKeyboardControl() {
+        guard let observer = keyboardObserver else { return }
+        observer.tearDown()
+        objc_setAssociatedObject(self, &keyboardObserverKey, nil, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+    }
+
+    // MARK: - Keyboard utilities
+
+    func hideKeyboard() {
+        keyboardObserver?.hideKeyboard()
+    }
+
+    var keyboardPanRecognizer: UIPanGestureRecognizer? {
+        keyboardObserver?.panHandler?.panRecognizer
+    }
+
+    var keyboardFrameInView: CGRect {
+        keyboardObserver?.keyboardFrameInView() ?? CGRect(x: 0, y: UIScreen.main.bounds.height, width: 0, height: 0)
+    }
+
+    var isKeyboardOpened: Bool {
+        keyboardObserver?.isKeyboardVisible ?? false
+    }
+
+    // MARK: - Private
+
+    private var keyboardObserver: KeyboardObserver? {
+        objc_getAssociatedObject(self, &keyboardObserverKey) as? KeyboardObserver
+    }
+
+    private func getOrCreateObserver() -> KeyboardObserver {
+        if let existing = keyboardObserver { return existing }
+        let observer = KeyboardObserver(view: self)
+        objc_setAssociatedObject(self, &keyboardObserverKey, observer, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        return observer
+    }
+}

Sources/KeyboardControl/KeyboardLayoutGuideAdapter.swift

@@ -0,0 +1,49 @@
+import UIKit
+
+@available(iOS 15.0, *)
+final class KeyboardLayoutGuideAdapter {
+
+    weak var view: UIView?
+    var actionBlock: KeyboardDidMoveBlock?
+    private var observation: NSKeyValueObservation?
+    private var lastLayoutFrame: CGRect = .zero
+    private var wasVisible = false
+
+    init(view: UIView, actionBlock: @escaping KeyboardDidMoveBlock) {
+        self.view = view
+        self.actionBlock = actionBlock
+
+        let guide = view.keyboardLayoutGuide
+        observation = guide.observe(\.layoutFrame, options: [.new, .old]) { [weak self] _, change in
+            self?.handleLayoutChange(oldFrame: change.oldValue, newFrame: change.newValue)
+        }
+    }
+
+    deinit {
+        observation?.invalidate()
+    }
+
+    private func handleLayoutChange(oldFrame: CGRect?, newFrame: CGRect?) {
+        guard let view = view, newFrame != nil else { return }
+
+        let screenHeight = view.bounds.height
+        guard screenHeight > 0 else { return }
+
+        let guide = view.keyboardLayoutGuide
+        let guideFrame = guide.layoutFrame
+
+        let isVisible = guideFrame.height > view.safeAreaInsets.bottom
+        let beginFrame = lastLayoutFrame.isEmpty ? CGRect(x: 0, y: screenHeight, width: view.bounds.width, height: 0) : lastLayoutFrame
+        let endFrame = CGRect(x: 0, y: guideFrame.minY, width: guideFrame.width, height: guideFrame.height)
+
+        let opening = isVisible && !wasVisible
+        let closing = !isVisible && wasVisible
+
+        if opening || closing || beginFrame != endFrame {
+            actionBlock?(beginFrame, endFrame, opening, closing)
+        }
+
+        wasVisible = isVisible
+        lastLayoutFrame = endFrame
+    }
+}