@capawesome/capacitor-haptics 0.0.1

package/ios/Plugin/Classes/Options/PlayPatternOptions.swift

@@ -0,0 +1,54 @@
+import Foundation
+import Capacitor
+
+@objc public class PlayPatternOptions: NSObject {
+    struct Event {
+        let duration: Double?
+        let intensity: Float
+        let sharpness: Float
+        let time: Double
+    }
+
+    let events: [Event]
+
+    init(_ call: CAPPluginCall) throws {
+        self.events = try PlayPatternOptions.getEventsFromCall(call)
+    }
+
+    private static func getEventsFromCall(_ call: CAPPluginCall) throws -> [Event] {
+        guard let eventObjects = call.getArray("events", JSObject.self), !eventObjects.isEmpty else {
+            throw CustomError.eventsMissing
+        }
+        var events: [Event] = []
+        for eventObject in eventObjects {
+            guard let time = (eventObject["time"] as? NSNumber)?.doubleValue else {
+                throw CustomError.timeMissing
+            }
+            guard time >= 0 else {
+                throw CustomError.timeInvalid
+            }
+            guard let intensity = (eventObject["intensity"] as? NSNumber)?.floatValue else {
+                throw CustomError.intensityMissing
+            }
+            guard intensity >= 0, intensity <= 1 else {
+                throw CustomError.intensityInvalid
+            }
+            var sharpness: Float = 0.5
+            if let value = (eventObject["sharpness"] as? NSNumber)?.floatValue {
+                guard value >= 0, value <= 1 else {
+                    throw CustomError.sharpnessInvalid
+                }
+                sharpness = value
+            }
+            var duration: Double?
+            if let value = (eventObject["duration"] as? NSNumber)?.doubleValue {
+                guard value > 0 else {
+                    throw CustomError.durationInvalid
+                }
+                duration = value
+            }
+            events.append(Event(duration: duration, intensity: intensity, sharpness: sharpness, time: time))
+        }
+        return events
+    }
+}

package/ios/Plugin/Classes/Results/IsAvailableResult.swift

@@ -0,0 +1,16 @@
+import Foundation
+import Capacitor
+
+@objc public class IsAvailableResult: NSObject, Result {
+    let available: Bool
+
+    init(available: Bool) {
+        self.available = available
+    }
+
+    @objc public func toJSObject() -> AnyObject {
+        var result = JSObject()
+        result["available"] = available
+        return result as AnyObject
+    }
+}

package/ios/Plugin/Enums/CustomError.swift

@@ -0,0 +1,50 @@
+import Foundation
+
+enum CustomError: Error {
+    case durationInvalid
+    case eventsMissing
+    case intensityInvalid
+    case intensityMissing
+    case patternPlaybackFailed
+    case sharpnessInvalid
+    case styleInvalid
+    case timeInvalid
+    case timeMissing
+    case typeInvalid
+
+    var code: String? {
+        switch self {
+        case .patternPlaybackFailed:
+            return "PATTERN_PLAYBACK_FAILED"
+        default:
+            return nil
+        }
+    }
+}
+
+extension CustomError: LocalizedError {
+    public var errorDescription: String? {
+        switch self {
+        case .durationInvalid:
+            return NSLocalizedString("duration must be greater than 0.", comment: "durationInvalid")
+        case .eventsMissing:
+            return NSLocalizedString("events must be provided.", comment: "eventsMissing")
+        case .intensityInvalid:
+            return NSLocalizedString("intensity must be between 0 and 1.", comment: "intensityInvalid")
+        case .intensityMissing:
+            return NSLocalizedString("intensity must be provided.", comment: "intensityMissing")
+        case .patternPlaybackFailed:
+            return NSLocalizedString("The haptic pattern could not be played.", comment: "patternPlaybackFailed")
+        case .sharpnessInvalid:
+            return NSLocalizedString("sharpness must be between 0 and 1.", comment: "sharpnessInvalid")
+        case .styleInvalid:
+            return NSLocalizedString("style must be one of the supported values.", comment: "styleInvalid")
+        case .timeInvalid:
+            return NSLocalizedString("time must be greater than or equal to 0.", comment: "timeInvalid")
+        case .timeMissing:
+            return NSLocalizedString("time must be provided.", comment: "timeMissing")
+        case .typeInvalid:
+            return NSLocalizedString("type must be one of the supported values.", comment: "typeInvalid")
+        }
+    }
+}

package/ios/Plugin/Haptics.swift

@@ -0,0 +1,115 @@
+import Foundation
+import Capacitor
+import AudioToolbox
+import CoreHaptics
+import UIKit
+
+@objc public class Haptics: NSObject {
+    private var engine: CHHapticEngine?
+    private let plugin: HapticsPlugin
+    private var selectionFeedbackGenerator: UISelectionFeedbackGenerator?
+
+    init(plugin: HapticsPlugin) {
+        self.plugin = plugin
+    }
+
+    @objc public func impact(_ options: ImpactOptions, completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async {
+            let generator = UIImpactFeedbackGenerator(style: options.style)
+            generator.prepare()
+            generator.impactOccurred()
+            completion(nil)
+        }
+    }
+
+    @objc public func isAvailable(completion: @escaping (_ result: IsAvailableResult?, _ error: Error?) -> Void) {
+        completion(IsAvailableResult(available: supportsHaptics()), nil)
+    }
+
+    @objc public func notification(_ options: NotificationOptions, completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async {
+            let generator = UINotificationFeedbackGenerator()
+            generator.prepare()
+            generator.notificationOccurred(options.type)
+            completion(nil)
+        }
+    }
+
+    @objc public func playPattern(_ options: PlayPatternOptions, completion: @escaping (Error?) -> Void) {
+        do {
+            let pattern = try createPattern(from: options.events)
+            let engine = try getEngine()
+            let player = try engine.makePlayer(with: pattern)
+            try engine.start()
+            try player.start(atTime: CHHapticTimeImmediate)
+            completion(nil)
+        } catch {
+            completion(CustomError.patternPlaybackFailed)
+        }
+    }
+
+    @objc public func selectionChanged(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async {
+            let generator = self.selectionFeedbackGenerator ?? UISelectionFeedbackGenerator()
+            self.selectionFeedbackGenerator = generator
+            generator.selectionChanged()
+            completion(nil)
+        }
+    }
+
+    @objc public func selectionEnd(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async {
+            self.selectionFeedbackGenerator = nil
+            completion(nil)
+        }
+    }
+
+    @objc public func selectionStart(completion: @escaping (Error?) -> Void) {
+        DispatchQueue.main.async {
+            let generator = UISelectionFeedbackGenerator()
+            generator.prepare()
+            self.selectionFeedbackGenerator = generator
+            completion(nil)
+        }
+    }
+
+    @objc public func supportsHaptics() -> Bool {
+        return CHHapticEngine.capabilitiesForHardware().supportsHaptics
+    }
+
+    @objc public func vibrate(completion: @escaping (Error?) -> Void) {
+        AudioServicesPlaySystemSound(kSystemSoundID_Vibrate)
+        completion(nil)
+    }
+
+    private func createPattern(from events: [PlayPatternOptions.Event]) throws -> CHHapticPattern {
+        var hapticEvents: [CHHapticEvent] = []
+        for event in events {
+            let parameters = [
+                CHHapticEventParameter(parameterID: .hapticIntensity, value: event.intensity),
+                CHHapticEventParameter(parameterID: .hapticSharpness, value: event.sharpness)
+            ]
+            if let duration = event.duration {
+                hapticEvents.append(
+                    CHHapticEvent(eventType: .hapticContinuous, parameters: parameters, relativeTime: event.time, duration: duration)
+                )
+            } else {
+                hapticEvents.append(CHHapticEvent(eventType: .hapticTransient, parameters: parameters, relativeTime: event.time))
+            }
+        }
+        return try CHHapticPattern(events: hapticEvents, parameters: [])
+    }
+
+    private func getEngine() throws -> CHHapticEngine {
+        if let engine = engine {
+            return engine
+        }
+        let engine = try CHHapticEngine()
+        engine.isAutoShutdownEnabled = true
+        engine.resetHandler = { [weak self] in
+            self?.engine = nil
+        }
+        self.engine = engine
+        return engine
+    }
+}

package/ios/Plugin/HapticsPlugin.swift

@@ -0,0 +1,155 @@
+import Foundation
+import Capacitor
+
+@objc(HapticsPlugin)
+public class HapticsPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "HapticsPlugin"
+    public let jsName = "Haptics"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "impact", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isAvailable", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "notification", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "performAndroidHaptic", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "playPattern", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "selectionChanged", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "selectionEnd", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "selectionStart", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "vibrate", returnType: CAPPluginReturnPromise)
+    ]
+    public static let tag = "HapticsPlugin"
+
+    private var implementation: Haptics?
+
+    override public func load() {
+        self.implementation = Haptics(plugin: self)
+    }
+
+    @objc func impact(_ call: CAPPluginCall) {
+        do {
+            let options = try ImpactOptions(call)
+            implementation?.impact(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func isAvailable(_ call: CAPPluginCall) {
+        implementation?.isAvailable(completion: { result, error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call, result)
+        })
+    }
+
+    @objc func notification(_ call: CAPPluginCall) {
+        do {
+            let options = try NotificationOptions(call)
+            implementation?.notification(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func performAndroidHaptic(_ call: CAPPluginCall) {
+        rejectCallAsUnimplemented(call)
+    }
+
+    @objc func playPattern(_ call: CAPPluginCall) {
+        guard implementation?.supportsHaptics() == true else {
+            rejectCallAsUnavailable(call)
+            return
+        }
+        do {
+            let options = try PlayPatternOptions(call)
+            implementation?.playPattern(options, completion: { error in
+                if let error = error {
+                    self.rejectCall(call, error)
+                    return
+                }
+                self.resolveCall(call)
+            })
+        } catch {
+            rejectCall(call, error)
+        }
+    }
+
+    @objc func selectionChanged(_ call: CAPPluginCall) {
+        implementation?.selectionChanged(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call)
+        })
+    }
+
+    @objc func selectionEnd(_ call: CAPPluginCall) {
+        implementation?.selectionEnd(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call)
+        })
+    }
+
+    @objc func selectionStart(_ call: CAPPluginCall) {
+        implementation?.selectionStart(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call)
+        })
+    }
+
+    @objc func vibrate(_ call: CAPPluginCall) {
+        implementation?.vibrate(completion: { error in
+            if let error = error {
+                self.rejectCall(call, error)
+                return
+            }
+            self.resolveCall(call)
+        })
+    }
+
+    private func rejectCall(_ call: CAPPluginCall, _ error: Error) {
+        CAPLog.print("[", HapticsPlugin.tag, "] ", error)
+        let code = (error as? CustomError)?.code
+        call.reject(error.localizedDescription, code)
+    }
+
+    private func rejectCallAsUnavailable(_ call: CAPPluginCall) {
+        call.unavailable("This method is not available on this platform.")
+    }
+
+    private func rejectCallAsUnimplemented(_ call: CAPPluginCall) {
+        call.unimplemented("This method is not available on this platform.")
+    }
+
+    private func resolveCall(_ call: CAPPluginCall) {
+        call.resolve()
+    }
+
+    private func resolveCall(_ call: CAPPluginCall, _ result: Result?) {
+        if let result = result?.toJSObject() as? JSObject {
+            call.resolve(result)
+        } else {
+            call.resolve()
+        }
+    }
+}

package/ios/Plugin/Info.plist

@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>$(DEVELOPMENT_LANGUAGE)</string>
+	<key>CFBundleExecutable</key>
+	<string>$(EXECUTABLE_NAME)</string>
+	<key>CFBundleIdentifier</key>
+	<string>$(PRODUCT_BUNDLE_IDENTIFIER)</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundleName</key>
+	<string>$(PRODUCT_NAME)</string>
+	<key>CFBundlePackageType</key>
+	<string>FMWK</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>$(CURRENT_PROJECT_VERSION)</string>
+	<key>NSPrincipalClass</key>
+	<string></string>
+</dict>
+</plist>

package/ios/Plugin/Protocols/Result.swift

@@ -0,0 +1,5 @@
+import Capacitor
+
+@objc public protocol Result {
+    @objc func toJSObject() -> AnyObject
+}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@capawesome/capacitor-haptics",
+  "version": "0.0.1",
+  "description": "Capacitor plugin to provide haptic feedback such as impacts, notifications, vibrations and custom haptic patterns.",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/Plugin/",
+    "CapawesomeCapacitorHaptics.podspec",
+    "Package.swift"
+  ],
+  "author": "Robin Genz <mail@robingenz.dev>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/capawesome-team/capacitor-plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/capawesome-team/capacitor-plugins/issues"
+  },
+  "funding": [
+    {
+      "type": "github",
+      "url": "https://github.com/sponsors/capawesome-team/"
+    },
+    {
+      "type": "opencollective",
+      "url": "https://opencollective.com/capawesome"
+    }
+  ],
+  "homepage": "https://capawesome.io/docs/sdks/capacitor/haptics/",
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "haptics",
+    "haptic feedback",
+    "vibration",
+    "taptic engine",
+    "vibrate"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "cd ios && pod install && xcodebuild -workspace Plugin.xcworkspace -scheme Plugin -destination generic/platform=iOS && cd ..",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api HapticsPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "ios:pod:install": "cd ios && pod install --repo-update && cd ..",
+    "ios:spm:install": "cd ios && swift package resolve && cd ..",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "8.0.0",
+    "@capacitor/cli": "8.0.0",
+    "@capacitor/core": "8.0.0",
+    "@capacitor/docgen": "0.3.1",
+    "@capacitor/ios": "8.0.0",
+    "@ionic/eslint-config": "0.4.0",
+    "eslint": "8.57.0",
+    "prettier-plugin-java": "2.6.7",
+    "rimraf": "6.1.2",
+    "rollup": "4.53.3",
+    "swiftlint": "2.0.0",
+    "typescript": "5.9.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=8.0.0"
+  },
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}