@qafka/react-native 2.0.0

package/ios/QafkaAudio.swift

@@ -0,0 +1,519 @@
+import Foundation
+import AVFoundation
+import React
+
+#if DEBUG
+private func qafkaLog(_ message: String) { NSLog("%@", message) }
+#else
+private func qafkaLog(_ message: String) {}
+#endif
+
+@objc(QafkaAudio)
+class QafkaAudio: RCTEventEmitter {
+
+  private var audioEngine: AVAudioEngine?
+  private var playerNode: AVAudioPlayerNode?
+  private var isCapturing = false
+  private var hasListeners = false
+  private var configChangeObserver: NSObjectProtocol?
+  private var playChunkCount = 0
+
+  // MARK: - RCTEventEmitter overrides
+
+  override static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
+  override func supportedEvents() -> [String]! {
+    return ["onAudioData", "onAmplitude"]
+  }
+
+  override func startObserving() {
+    hasListeners = true
+  }
+
+  override func stopObserving() {
+    hasListeners = false
+  }
+
+  // MARK: - Route helpers
+
+  /// Re-assert the correct output route after VPIO state transitions.
+  ///
+  /// VPIO (Apple voice-processing IO) can silently park the output on the
+  /// receiver (the earpiece next to your face) instead of the loudspeaker —
+  /// the documented workaround is the `.none` → `.speaker` toggle. But that
+  /// toggle is destructive when an external accessory is connected: it yanks
+  /// audio off AirPods / wired headphones / CarPlay / USB and forces the
+  /// iPhone speaker, which is the opposite of what the user wants. Only
+  /// apply the speaker override when no accessory is in the current route.
+  private func reassertOutputRoute() {
+    let session = AVAudioSession.sharedInstance()
+    let hasExternalOutput = session.currentRoute.outputs.contains { output in
+      switch output.portType {
+      case .headphones,
+           .headsetMic,
+           .bluetoothA2DP,
+           .bluetoothHFP,
+           .bluetoothLE,
+           .airPlay,
+           .lineOut,
+           .usbAudio,
+           .carAudio:
+        return true
+      default:
+        return false
+      }
+    }
+    if hasExternalOutput {
+      try? session.overrideOutputAudioPort(.none)
+      let outputs = session.currentRoute.outputs.map { "\($0.portType.rawValue)" }.joined(separator: ",")
+      qafkaLog("[QafkaAudio] external output present — keeping accessory route outputs=[\(outputs)]")
+    } else {
+      try? session.overrideOutputAudioPort(.none)
+      try? session.overrideOutputAudioPort(.speaker)
+    }
+  }
+
+  // MARK: - Capture
+
+  @objc func startCapture(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    if isCapturing {
+      resolve(true)
+      return
+    }
+
+    AVAudioSession.sharedInstance().requestRecordPermission { [weak self] granted in
+      guard let self = self else { return }
+
+      if !granted {
+        reject("PERMISSION_DENIED", "Microphone permission denied", nil)
+        return
+      }
+
+      DispatchQueue.global(qos: .userInitiated).async {
+        self.doStartCapture(resolve, reject: reject)
+      }
+    }
+  }
+
+  private func doStartCapture(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    reject: @escaping RCTPromiseRejectBlock
+  ) {
+    qafkaLog("[QafkaAudio] === doStartCapture begin ===")
+
+    // Defensive startup cleanup — recover from any leaked VPIO/audio-unit state
+    // left by a prior crashed session. Apple Forums 721535 confirms the combo
+    // of (deactivate) + (force category) + (output-port toggle) is needed to
+    // break out of a stuck "silent after VPIO" state without a device reboot.
+    do {
+      let session = AVAudioSession.sharedInstance()
+
+      // 1. Deactivate any lingering session so the new category takes cleanly.
+      try? session.setActive(false, options: .notifyOthersOnDeactivation)
+
+      // 2. Force-set category even if it matches current — this causes iOS to
+      //    rebuild the audio graph and release stale audio-unit references.
+      try session.setCategory(.playAndRecord, mode: .voiceChat, options: [.defaultToSpeaker, .allowBluetooth])
+
+      // 3. Activate.
+      try session.setActive(true)
+
+      // 4. Output-port toggle — verified fix for "VPIO leaves output silent"
+      //    bug. Speaker is only re-asserted when no accessory (AirPods,
+      //    headphones, CarPlay) is connected; otherwise the accessory route
+      //    is preserved.
+      reassertOutputRoute()
+
+      let route = session.currentRoute
+      let outputs = route.outputs.map { "\($0.portType.rawValue)" }.joined(separator: ",")
+      qafkaLog("[QafkaAudio] AudioSession configured: mode=voiceChat sr=\(session.sampleRate) outputs=[\(outputs)] outVol=\(session.outputVolume)")
+    } catch {
+      qafkaLog("[QafkaAudio] ❌ AudioSession failed: \(error.localizedDescription)")
+      reject("AUDIO_SESSION_ERROR", "Failed to configure audio session: \(error.localizedDescription)", error)
+      return
+    }
+
+    let engine = AVAudioEngine()
+    let inputNode = engine.inputNode
+
+    // VPIO — Apple hardware AEC + noise suppression + AGC.
+    // Same API FaceTime/WhatsApp use. Clean teardown is critical — see
+    // stopCapture: VPIO MUST be disabled AFTER engine.stop(), not before,
+    // otherwise setVoiceProcessingEnabled throws (engine-running error) and
+    // the audio unit stays hot across app restarts.
+    var vpioEnabled = false
+    do {
+      try inputNode.setVoiceProcessingEnabled(true)
+      vpioEnabled = true
+      qafkaLog("[QafkaAudio] ✅ VPIO enabled")
+    } catch let vpioError as NSError {
+      qafkaLog("[QafkaAudio] ⚠️ VPIO failed: \(vpioError.localizedDescription) — continuing without VPIO")
+    }
+
+    // Read formats AFTER enabling VPIO — sample rate may change.
+    let inputFormat = inputNode.outputFormat(forBus: 0)
+    qafkaLog("[QafkaAudio] inputFormat: sr=\(inputFormat.sampleRate) ch=\(inputFormat.channelCount) vpio=\(vpioEnabled)")
+
+    // Player setup — mixer format aligns with VPIO output after it's enabled.
+    let player = AVAudioPlayerNode()
+    engine.attach(player)
+    let mixer = engine.mainMixerNode
+    let mixerFormat = mixer.outputFormat(forBus: 0)
+    engine.connect(player, to: mixer, format: mixerFormat)
+
+    // Target format for capture: 16kHz mono Int16.
+    guard let targetFormat = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 16000, channels: 1, interleaved: true) else {
+      reject("FORMAT_ERROR", "Failed to create target audio format", nil)
+      return
+    }
+
+    guard let converter = AVAudioConverter(from: inputFormat, to: targetFormat) else {
+      reject("CONVERTER_ERROR", "Failed to create audio converter", nil)
+      return
+    }
+
+    let bufferSize: AVAudioFrameCount = 4096
+
+    inputNode.installTap(onBus: 0, bufferSize: bufferSize, format: inputFormat) { [weak self] (buffer, _) in
+      guard let self = self, self.hasListeners else { return }
+
+      let frameCapacity: AVAudioFrameCount = AVAudioFrameCount(
+        Double(buffer.frameLength) * (16000.0 / inputFormat.sampleRate)
+      )
+
+      guard let convertedBuffer = AVAudioPCMBuffer(pcmFormat: targetFormat, frameCapacity: frameCapacity) else {
+        return
+      }
+
+      var error: NSError?
+      let status = converter.convert(to: convertedBuffer, error: &error) { inNumPackets, outStatus in
+        outStatus.pointee = .haveData
+        return buffer
+      }
+
+      guard status != .error, error == nil else { return }
+      guard let channelData = convertedBuffer.int16ChannelData?[0] else { return }
+
+      let audioData = Data(
+        bytes: channelData,
+        count: Int(convertedBuffer.frameLength) * MemoryLayout<Int16>.size
+      )
+
+      let sampleCount = Int(convertedBuffer.frameLength)
+      if sampleCount > 0 {
+        let samples = channelData
+        var sumSquares: Float = 0
+        for i in 0..<sampleCount {
+          let sample = Float(samples[i]) / Float(Int16.max)
+          sumSquares += sample * sample
+        }
+        let rms = sqrt(sumSquares / Float(sampleCount))
+        let level = min(rms * 3.0, 1.0)
+        self.sendEvent(withName: "onAmplitude", body: ["level": level, "source": "mic"])
+      }
+
+      let base64String = audioData.base64EncodedString()
+      self.sendEvent(withName: "onAudioData", body: ["audio": base64String])
+    }
+
+    engine.prepare()
+
+    // VPIO may trigger AVAudioEngineConfigurationChange which stops the engine.
+    // Auto-restart so capture continues. Apple's documented behavior.
+    if let existing = configChangeObserver {
+      NotificationCenter.default.removeObserver(existing)
+    }
+    configChangeObserver = NotificationCenter.default.addObserver(
+      forName: .AVAudioEngineConfigurationChange,
+      object: engine,
+      queue: .main
+    ) { [weak self, weak engine] _ in
+      guard let self = self, let engine = engine else { return }
+      qafkaLog("[QafkaAudio] 🔔 AVAudioEngineConfigurationChange — isRunning=\(engine.isRunning) isCapturing=\(self.isCapturing)")
+      guard self.isCapturing, let player = self.playerNode else { return }
+
+      // Config change on iOS rebuilds the audio graph and can change the mixer
+      // output format (hardware sample rate). The previous connection between
+      // player and mixer becomes invalid — scheduleBuffer still "succeeds" but
+      // no audio reaches the speaker. Must reconnect with current formats.
+      if engine.isRunning {
+        engine.stop()
+      }
+
+      engine.disconnectNodeInput(engine.mainMixerNode)
+      let currentMixerFormat = engine.mainMixerNode.outputFormat(forBus: 0)
+      engine.connect(player, to: engine.mainMixerNode, format: currentMixerFormat)
+      qafkaLog("[QafkaAudio] reconnected player → mixer (sr=\(currentMixerFormat.sampleRate) ch=\(currentMixerFormat.channelCount))")
+
+      do {
+        try engine.start()
+        player.play()
+
+        // Route re-assert — config change can also silently bump route off
+        // speaker. Preserves accessory routes (AirPods/headphones) when
+        // present.
+        self.reassertOutputRoute()
+
+        qafkaLog("[QafkaAudio] 🔄 Engine rebuilt + restarted after config change")
+      } catch let err as NSError {
+        qafkaLog("[QafkaAudio] ❌ Engine rebuild failed: \(err.localizedDescription)")
+      }
+    }
+
+    do {
+      try engine.start()
+    } catch let startError as NSError {
+      qafkaLog("[QafkaAudio] ❌ engine.start THREW: \(startError.localizedDescription)")
+      reject("ENGINE_ERROR", "engine.start: \(startError.localizedDescription)", startError)
+      return
+    }
+
+    player.play()
+
+    // Post-engine-start output-port toggle (Apple Forums 721535).
+    // VPIO can silently shift the output route to the receiver or to null
+    // during engine-start; this call reasserts the speaker route. When an
+    // external accessory (AirPods/headphones/CarPlay) is connected the
+    // accessory route is preserved — speaker is only forced for internal
+    // routes.
+    reassertOutputRoute()
+    let postStartOutputs = AVAudioSession.sharedInstance().currentRoute.outputs
+      .map { "\($0.portType.rawValue)" }.joined(separator: ",")
+    qafkaLog("[QafkaAudio] post-start route — outputs=[\(postStartOutputs)]")
+
+    qafkaLog("[QafkaAudio] ✅ engine started, player playing. vpio=\(vpioEnabled)")
+
+    self.audioEngine = engine
+    self.playerNode = player
+    self.isCapturing = true
+
+    resolve(true)
+  }
+
+  // MARK: - Stop Capture
+
+  @objc func stopCapture(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let engine = audioEngine else {
+      qafkaLog("[QafkaAudio] stopCapture: no engine, nothing to clean up")
+      resolve(true)
+      return
+    }
+
+    qafkaLog("[QafkaAudio] === stopCapture begin === isCapturing=\(isCapturing) engineRunning=\(engine.isRunning)")
+
+    // Remove observer BEFORE any teardown so auto-restart can't fire during it.
+    if let observer = configChangeObserver {
+      NotificationCenter.default.removeObserver(observer)
+      configChangeObserver = nil
+    }
+
+    // Apple-recommended VPIO teardown order. Critical: disable VPIO AFTER
+    // engine.stop(), not before. setVoiceProcessingEnabled(_:) throws when
+    // the engine is running — an earlier version of this code had VPIO
+    // disable BEFORE engine.stop with try?, which silently swallowed the
+    // error and never actually disabled VPIO. That leaked the audio unit
+    // across sessions and required a device reboot to recover.
+
+    // 1. Remove the input tap while the engine is still running.
+    if isCapturing {
+      engine.inputNode.removeTap(onBus: 0)
+    }
+
+    // 2. Stop + reset playback node. reset() purges any scheduled buffers that
+    //    haven't played yet. Without this, iOS can hold references to those
+    //    buffer's audio-unit nodes across the session boundary.
+    playerNode?.stop()
+    playerNode?.reset()
+
+    // 3. Stop the engine FIRST — VPIO can only be disabled on a stopped engine.
+    engine.stop()
+
+    // 4. Now disable VPIO. With the engine stopped this call succeeds and
+    //    releases the voice-processing audio unit back to the system.
+    do {
+      try engine.inputNode.setVoiceProcessingEnabled(false)
+      qafkaLog("[QafkaAudio] VPIO disabled")
+    } catch let err as NSError {
+      qafkaLog("[QafkaAudio] ⚠️ VPIO disable failed: \(err.localizedDescription)")
+    }
+
+    // 5. Break the engine graph and detach nodes. Without disconnectNodeInput,
+    //    the mixer keeps a strong reference to the player even after detach —
+    //    iOS doesn't fully release the audio unit until the graph is broken.
+    engine.disconnectNodeInput(engine.mainMixerNode)
+    if let player = playerNode {
+      engine.detach(player)
+    }
+    engine.reset()
+
+    // 6. Deactivate the audio session and notify other apps we're done.
+    do {
+      try AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+      qafkaLog("[QafkaAudio] AudioSession deactivated")
+    } catch let err as NSError {
+      qafkaLog("[QafkaAudio] ⚠️ AudioSession deactivate failed: \(err.localizedDescription)")
+    }
+
+    self.audioEngine = nil
+    self.playerNode = nil
+    self.isCapturing = false
+    self.playChunkCount = 0
+
+    qafkaLog("[QafkaAudio] === stopCapture done ===")
+    resolve(true)
+  }
+
+  // Last-resort cleanup if the JS side never calls stopCapture (e.g. app is
+  // killed mid-session). Best-effort — not all cleanup is guaranteed here.
+  deinit {
+    if let engine = audioEngine {
+      qafkaLog("[QafkaAudio] deinit: forcing teardown of live engine")
+      if let observer = configChangeObserver {
+        NotificationCenter.default.removeObserver(observer)
+      }
+      if isCapturing {
+        engine.inputNode.removeTap(onBus: 0)
+      }
+      playerNode?.stop()
+      playerNode?.reset()
+      engine.stop()
+      // VPIO disable AFTER engine.stop — same order as stopCapture.
+      try? engine.inputNode.setVoiceProcessingEnabled(false)
+      engine.disconnectNodeInput(engine.mainMixerNode)
+      if let player = playerNode {
+        engine.detach(player)
+      }
+      engine.reset()
+      try? AVAudioSession.sharedInstance().setActive(false, options: .notifyOthersOnDeactivation)
+    }
+  }
+
+  // MARK: - Playback
+
+  @objc func playAudioChunk(
+    _ base64Data: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    playChunkCount += 1
+    let isLoggedChunk = playChunkCount <= 3 || playChunkCount % 50 == 0
+
+    guard let player = playerNode, let engine = audioEngine else {
+      qafkaLog("[QafkaAudio] ❌ playAudioChunk #\(playChunkCount): engine not running")
+      reject("NOT_RUNNING", "Audio engine is not running. Call startCapture first.", nil)
+      return
+    }
+
+    // Engine may have stopped due to AVAudioEngineConfigurationChange — restart
+    if !engine.isRunning {
+      do {
+        try engine.start()
+        player.play()
+        qafkaLog("[QafkaAudio] 🔄 Engine restarted from playAudioChunk")
+      } catch let err as NSError {
+        qafkaLog("[QafkaAudio] ❌ playAudioChunk engine restart failed: \(err.localizedDescription)")
+        reject("NOT_RUNNING", "Audio engine restart failed: \(err.localizedDescription)", err)
+        return
+      }
+    }
+
+    guard let audioData = Data(base64Encoded: base64Data) else {
+      qafkaLog("[QafkaAudio] ❌ playAudioChunk #\(playChunkCount): invalid base64")
+      reject("INVALID_DATA", "Invalid base64 audio data", nil)
+      return
+    }
+
+    // Incoming audio: 24kHz mono Int16.
+    guard let srcFormat = AVAudioFormat(commonFormat: .pcmFormatInt16, sampleRate: 24000, channels: 1, interleaved: true) else {
+      reject("FORMAT_ERROR", "Failed to create source format", nil)
+      return
+    }
+
+    let frameCount = UInt32(audioData.count) / UInt32(MemoryLayout<Int16>.size)
+
+    guard let srcBuffer = AVAudioPCMBuffer(pcmFormat: srcFormat, frameCapacity: frameCount) else {
+      reject("BUFFER_ERROR", "Failed to create source buffer", nil)
+      return
+    }
+    srcBuffer.frameLength = frameCount
+
+    guard let srcChannelData = srcBuffer.int16ChannelData?[0] else {
+      reject("BUFFER_ERROR", "Failed to access source buffer channel data", nil)
+      return
+    }
+    audioData.withUnsafeBytes { rawPtr in
+      if let baseAddress = rawPtr.baseAddress {
+        memcpy(srcChannelData, baseAddress, audioData.count)
+      }
+    }
+
+    if hasListeners && frameCount > 0 {
+      let samples = srcChannelData
+      var sumSquares: Float = 0
+      for i in 0..<Int(frameCount) {
+        let sample = Float(samples[i]) / Float(Int16.max)
+        sumSquares += sample * sample
+      }
+      let rms = sqrt(sumSquares / Float(frameCount))
+      let level = min(rms * 3.0, 1.0)
+      sendEvent(withName: "onAmplitude", body: ["level": level, "source": "speaker"])
+    }
+
+    let mixerFormat = engine.mainMixerNode.outputFormat(forBus: 0)
+    guard let playbackConverter = AVAudioConverter(from: srcFormat, to: mixerFormat) else {
+      reject("CONVERT_ERROR", "Failed to convert audio to playback format", nil)
+      return
+    }
+
+    let outputFrameCount = AVAudioFrameCount(
+      Double(frameCount) * (mixerFormat.sampleRate / 24000.0)
+    )
+    guard let outputBuffer = AVAudioPCMBuffer(pcmFormat: mixerFormat, frameCapacity: outputFrameCount) else {
+      reject("CONVERT_ERROR", "Failed to convert audio to playback format", nil)
+      return
+    }
+
+    var convError: NSError?
+    playbackConverter.convert(to: outputBuffer, error: &convError) { _, outStatus in
+      outStatus.pointee = .haveData
+      return srcBuffer
+    }
+
+    if let convError = convError {
+      reject("CONVERT_ERROR", "Audio conversion failed: \(convError.localizedDescription)", convError)
+      return
+    }
+
+    player.scheduleBuffer(outputBuffer, completionHandler: nil)
+    if isLoggedChunk {
+      qafkaLog("[QafkaAudio] 🔊 playAudioChunk #\(playChunkCount): scheduled \(outputBuffer.frameLength)f @ \(mixerFormat.sampleRate)Hz playerPlaying=\(player.isPlaying) engineRunning=\(engine.isRunning)")
+    }
+
+    resolve(true)
+  }
+
+  // MARK: - Stop Playback
+
+  @objc func stopPlayback(
+    _ resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let player = playerNode else {
+      resolve(true)
+      return
+    }
+
+    player.stop()
+    player.play() // Reset and ready for new chunks
+
+    resolve(true)
+  }
+}

package/ios/QafkaClipboard.m

@@ -0,0 +1,10 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(QafkaClipboard, NSObject)
+
+RCT_EXTERN_METHOD(setString:
+                  (NSString *)value
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/QafkaClipboard.swift

@@ -0,0 +1,21 @@
+import Foundation
+import UIKit
+
+@objc(QafkaClipboard)
+class QafkaClipboard: NSObject {
+
+  @objc static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
+  @objc func setString(
+    _ value: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    DispatchQueue.main.async {
+      UIPasteboard.general.string = value
+      resolve(NSNull())
+    }
+  }
+}

package/ios/QafkaReactImports.h

@@ -0,0 +1,2 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>

package/ios/QafkaStorage.m

@@ -0,0 +1,26 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(QafkaStorage, NSObject)
+
+RCT_EXTERN_METHOD(getItem:
+                  (NSString *)key
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(setItem:
+                  (NSString *)key
+                  value:(NSString *)value
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(removeItem:
+                  (NSString *)key
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(multiRemove:
+                  (NSArray<NSString *> *)keys
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/QafkaStorage.swift

@@ -0,0 +1,118 @@
+import Foundation
+import Security
+
+@objc(QafkaStorage)
+class QafkaStorage: NSObject {
+
+  private static let service = "app.qafka.sdk"
+
+  @objc static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
+
+  // MARK: - Helpers
+
+  private func baseQuery(forKey key: String) -> [String: Any] {
+    return [
+      kSecClass as String: kSecClassGenericPassword,
+      kSecAttrService as String: QafkaStorage.service,
+      kSecAttrAccount as String: key,
+      kSecAttrSynchronizable as String: kCFBooleanFalse as Any,
+    ]
+  }
+
+  // MARK: - React methods
+
+  @objc func getItem(
+    _ key: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    var query = baseQuery(forKey: key)
+    query[kSecReturnData as String] = kCFBooleanTrue
+    query[kSecMatchLimit as String] = kSecMatchLimitOne
+
+    var item: CFTypeRef?
+    let status = SecItemCopyMatching(query as CFDictionary, &item)
+
+    switch status {
+    case errSecSuccess:
+      if let data = item as? Data, let str = String(data: data, encoding: .utf8) {
+        resolve(str)
+      } else {
+        resolve(NSNull())
+      }
+    case errSecItemNotFound:
+      resolve(NSNull())
+    default:
+      reject("KEYCHAIN_READ_FAILED", "Keychain read failed (OSStatus \(status))", nil)
+    }
+  }
+
+  @objc func setItem(
+    _ key: String,
+    value: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let data = value.data(using: .utf8) else {
+      reject("INVALID_INPUT", "Value is not valid UTF-8", nil)
+      return
+    }
+
+    let query = baseQuery(forKey: key)
+    let updateAttrs: [String: Any] = [
+      kSecValueData as String: data,
+      kSecAttrAccessible as String: kSecAttrAccessibleAfterFirstUnlock,
+    ]
+
+    let updateStatus = SecItemUpdate(query as CFDictionary, updateAttrs as CFDictionary)
+    if updateStatus == errSecSuccess {
+      resolve(NSNull())
+      return
+    }
+    if updateStatus != errSecItemNotFound {
+      reject("KEYCHAIN_UPDATE_FAILED", "Keychain update failed (OSStatus \(updateStatus))", nil)
+      return
+    }
+
+    var addQuery = query
+    addQuery[kSecValueData as String] = data
+    addQuery[kSecAttrAccessible as String] = kSecAttrAccessibleAfterFirstUnlock
+
+    let addStatus = SecItemAdd(addQuery as CFDictionary, nil)
+    if addStatus == errSecSuccess {
+      resolve(NSNull())
+    } else {
+      reject("KEYCHAIN_ADD_FAILED", "Keychain add failed (OSStatus \(addStatus))", nil)
+    }
+  }
+
+  @objc func removeItem(
+    _ key: String,
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    let status = SecItemDelete(baseQuery(forKey: key) as CFDictionary)
+    if status == errSecSuccess || status == errSecItemNotFound {
+      resolve(NSNull())
+    } else {
+      reject("KEYCHAIN_DELETE_FAILED", "Keychain delete failed (OSStatus \(status))", nil)
+    }
+  }
+
+  @objc func multiRemove(
+    _ keys: [String],
+    resolver resolve: @escaping RCTPromiseResolveBlock,
+    rejecter reject: @escaping RCTPromiseRejectBlock
+  ) {
+    for key in keys {
+      let status = SecItemDelete(baseQuery(forKey: key) as CFDictionary)
+      if status != errSecSuccess && status != errSecItemNotFound {
+        reject("KEYCHAIN_DELETE_FAILED", "Keychain delete failed for key \(key) (OSStatus \(status))", nil)
+        return
+      }
+    }
+    resolve(NSNull())
+  }
+}