one 2.6.18 → 2.6.19

package/ios/Nitro/HybridOneSecureStore.swift

@@ -1,24 +1,67 @@
 import Foundation
+import LocalAuthentication
 import NitroModules
 import Security
 
-// string key-value storage matching expo-secure-store's item api, backed by
-// the keychain: generic-password items keyed by account under one service,
-// readable while the device is unlocked. a missing key reads nil; deleting
-// one resolves all the same.
+// string key-value storage matching expo-secure-store's item api and its
+// options, backed by the keychain: generic-password items keyed by account
+// under the option's service (default One.SecureStore, so items written
+// before options existed read back unchanged). an authenticated item lives
+// under "<service>:auth" with a biometryCurrentSet access control, like
+// expo's split; a read checks the plain service first, then the auth
+// service, and a write removes the other mode's item. a missing key reads
+// nil; deleting one resolves all the same and never prompts.
 final class HybridOneSecureStore: HybridOneSecureStoreSpec {
-  private static let service = "One.SecureStore"
+  private static let defaultService = "One.SecureStore"
 
-  private static func query(key: String) -> [String: Any] {
-    return [
+  private static func service(options: SecureStoreOptions, authenticated: Bool) -> String {
+    let base = options.keychainService ?? defaultService
+    return authenticated ? base + ":auth" : base
+  }
+
+  private static func query(key: String, options: SecureStoreOptions, authenticated: Bool)
+    -> [String: Any]
+  {
+    var query: [String: Any] = [
       kSecClass as String: kSecClassGenericPassword,
-      kSecAttrService as String: service,
+      kSecAttrService as String: service(options: options, authenticated: authenticated),
       kSecAttrAccount as String: key,
     ]
+    if let accessGroup = options.accessGroup {
+      query[kSecAttrAccessGroup as String] = accessGroup
+    }
+    return query
   }
 
-  private static func read(key: String) throws -> String? {
-    var lookup = query(key: key)
+  private static func accessible(options: SecureStoreOptions) -> CFString {
+    switch options.keychainAccessible {
+    case .afterfirstunlock: return kSecAttrAccessibleAfterFirstUnlock
+    case .afterfirstunlockthisdeviceonly: return kSecAttrAccessibleAfterFirstUnlockThisDeviceOnly
+    case .always: return kSecAttrAccessibleAlways
+    case .alwaysthisdeviceonly: return kSecAttrAccessibleAlwaysThisDeviceOnly
+    case .whenpasscodesetthisdeviceonly: return kSecAttrAccessibleWhenPasscodeSetThisDeviceOnly
+    case .whenunlockedthisdeviceonly: return kSecAttrAccessibleWhenUnlockedThisDeviceOnly
+    case .whenunlocked, nil: return kSecAttrAccessibleWhenUnlocked
+    }
+  }
+
+  // the authentication context carries the prompt; without a custom prompt
+  // no context is attached and the system wording stands.
+  private static func withPrompt(_ query: [String: Any], options: SecureStoreOptions)
+    -> [String: Any]
+  {
+    guard let prompt = options.authenticationPrompt else { return query }
+    var next = query
+    let context = LAContext()
+    context.localizedReason = prompt
+    next[kSecUseAuthenticationContext as String] = context
+    return next
+  }
+
+  private static func fetch(key: String, options: SecureStoreOptions, authenticated: Bool) throws
+    -> String?
+  {
+    var lookup = withPrompt(query(key: key, options: options, authenticated: authenticated), options: options)
     lookup[kSecReturnData as String] = true
     lookup[kSecMatchLimit as String] = kSecMatchLimitOne
     var item: CFTypeRef?
@@ -37,73 +80,96 @@ final class HybridOneSecureStore: HybridOneSecureStoreSpec {
     return value
   }
 
-  private static func write(key: String, value: String) throws {
+  private static func read(key: String, options: SecureStoreOptions) throws -> String? {
+    if let value = try fetch(key: key, options: options, authenticated: false) {
+      return value
+    }
+    return try fetch(key: key, options: options, authenticated: true)
+  }
+
+  private static func write(key: String, value: String, options: SecureStoreOptions) throws {
     guard let data = value.data(using: .utf8) else {
       throw oneNativeError(
         "E_SECURE_STORE_SET", "SecureStore.setItem: the value is not utf-8 text")
     }
-    let status = SecItemUpdate(query(key: key) as CFDictionary, [kSecValueData as String: data] as CFDictionary)
+    let authenticated = options.requireAuthentication ?? false
+    let target = query(key: key, options: options, authenticated: authenticated)
+    let status = SecItemUpdate(
+      withPrompt(target, options: options) as CFDictionary,
+      [kSecValueData as String: data] as CFDictionary)
     if status == errSecSuccess {
+      removeOther(key: key, options: options, authenticated: authenticated)
       return
     }
     if status != errSecItemNotFound {
       throw oneNativeError(
         "E_SECURE_STORE_SET", "SecureStore.setItem: the keychain write failed (status \(status))")
     }
-    var addition = query(key: key)
+    var addition = target
     addition[kSecValueData as String] = data
-    addition[kSecAttrAccessible as String] = kSecAttrAccessibleWhenUnlocked
+    if authenticated {
+      var error: Unmanaged<CFError>?
+      guard
+        let control = SecAccessControlCreateWithFlags(
+          kCFAllocatorDefault, accessible(options: options), .biometryCurrentSet, &error)
+      else {
+        throw oneNativeError(
+          "E_SECURE_STORE_SET",
+          "SecureStore.setItem: the authentication access control could not be created")
+      }
+      addition[kSecAttrAccessControl as String] = control
+    } else {
+      addition[kSecAttrAccessible as String] = accessible(options: options)
+    }
     let added = SecItemAdd(addition as CFDictionary, nil)
     if added != errSecSuccess {
       throw oneNativeError(
         "E_SECURE_STORE_SET", "SecureStore.setItem: the keychain write failed (status \(added))")
     }
+    removeOther(key: key, options: options, authenticated: authenticated)
   }
 
-  private static func remove(key: String) throws {
-    let status = SecItemDelete(query(key: key) as CFDictionary)
-    if status != errSecSuccess && status != errSecItemNotFound {
-      throw oneNativeError(
-        "E_SECURE_STORE_DELETE",
-        "SecureStore.deleteItem: the keychain delete failed (status \(status))")
-    }
+  // one value per key across the two modes: writing one mode clears the
+  // other, so a later read can never return a stale mode's value.
+  private static func removeOther(key: String, options: SecureStoreOptions, authenticated: Bool) {
+    SecItemDelete(query(key: key, options: options, authenticated: !authenticated) as CFDictionary)
   }
 
-  func getItem(key: String) throws -> Promise<String?> {
-    do {
-      return Promise.resolved(withResult: try Self.read(key: key))
-    } catch {
-      return Promise.rejected(withError: error)
+  private static func remove(key: String, options: SecureStoreOptions) throws {
+    for authenticated in [false, true] {
+      let status = SecItemDelete(
+        query(key: key, options: options, authenticated: authenticated) as CFDictionary)
+      if status != errSecSuccess && status != errSecItemNotFound {
+        throw oneNativeError(
+          "E_SECURE_STORE_DELETE",
+          "SecureStore.deleteItem: the keychain delete failed (status \(status))")
+      }
     }
   }
 
-  func setItem(key: String, value: String) throws -> Promise<Void> {
-    do {
-      try Self.write(key: key, value: value)
-      return Promise.resolved()
-    } catch {
-      return Promise.rejected(withError: error)
-    }
+  // the async verbs leave the js thread: an authenticated item's keychain
+  // call blocks until the user answers the biometric prompt.
+  func getItem(key: String, options: SecureStoreOptions) throws -> Promise<String?> {
+    return Promise.async { try Self.read(key: key, options: options) }
   }
 
-  func deleteItem(key: String) throws -> Promise<Void> {
-    do {
-      try Self.remove(key: key)
-      return Promise.resolved()
-    } catch {
-      return Promise.rejected(withError: error)
-    }
+  func setItem(key: String, value: String, options: SecureStoreOptions) throws -> Promise<Void> {
+    return Promise.async { try Self.write(key: key, value: value, options: options) }
+  }
+
+  func deleteItem(key: String, options: SecureStoreOptions) throws -> Promise<Void> {
+    return Promise.async { try Self.remove(key: key, options: options) }
   }
 
-  func getItemSync(key: String) throws -> String? {
-    return try Self.read(key: key)
+  func getItemSync(key: String, options: SecureStoreOptions) throws -> String? {
+    return try Self.read(key: key, options: options)
   }
 
-  func setItemSync(key: String, value: String) throws {
-    try Self.write(key: key, value: value)
+  func setItemSync(key: String, value: String, options: SecureStoreOptions) throws {
+    try Self.write(key: key, value: value, options: options)
   }
 
-  func deleteItemSync(key: String) throws {
-    try Self.remove(key: key)
+  func deleteItemSync(key: String, options: SecureStoreOptions) throws {
+    try Self.remove(key: key, options: options)
   }
 }

package/ios/Tests/ImageManipulator/Package.swift

@@ -0,0 +1,12 @@
+// swift-tools-version:5.9
+import PackageDescription
+
+let package = Package(
+  name: "OneImageManipulatorHarness",
+  platforms: [.iOS(.v17)],
+  targets: [
+    .target(name: "NitroModules"),
+    .target(name: "SDWebImageWebPCoder", dependencies: []),
+    .target(name: "OneImageManipulatorCore", dependencies: ["NitroModules", "SDWebImageWebPCoder"]),
+  ]
+)

package/ios/Tests/ImageManipulator/README.md

@@ -0,0 +1,21 @@
+# ImageManipulator native typecheck
+
+This SwiftPM harness compiles the production `HybridOneImageManipulator.swift`
+and `OneNativeError.swift` through source symlinks against the iOS simulator
+SDK. Only Nitro transport, generated value types, and the WebP coder are
+stand-ins. The class uses UIKit, so unlike the FileSystem harness nothing here
+runs on macOS: there is no test target, only a simulator-triple build.
+
+```sh
+swift build --triple arm64-apple-ios17.0-simulator \
+  --sdk $(xcrun --sdk iphonesimulator --show-sdk-path) \
+  --package-path packages/one/ios/Tests/ImageManipulator
+```
+
+The real `SDWebImageWebPCoder` call shape (`sharedCoder`, `.webP`,
+`.encodeCompressionQuality`) was read off the vendored 0.15.0 pod headers, not
+the stub. The stub only proves the production file is internally consistent.
+Real WebP bytes, flip pixels, and validation codes are proven by the
+native-features `image-manipulator` fixture on the iOS 27 simulator and
+Android 37 emulator; this harness does not prove transport, sandbox behavior,
+or a device pass.

package/ios/Tests/ImageManipulator/Sources/NitroModules/Promise.swift

@@ -0,0 +1,33 @@
+import Foundation
+
+// test transport only; the production class settles these off-thread.
+public final class Promise<T> {
+  private let condition = NSCondition()
+  private var result: Result<T, Error>?
+  public init() {}
+  public func resolve(withResult value: T) { settle(.success(value)) }
+  public func reject(withError error: Error) { settle(.failure(error)) }
+  private func settle(_ value: Result<T, Error>) {
+    condition.lock()
+    result = value
+    condition.broadcast()
+    condition.unlock()
+  }
+  public func wait() throws -> T {
+    condition.lock()
+    defer { condition.unlock() }
+    let deadline = Date().addingTimeInterval(5)
+    while result == nil {
+      guard condition.wait(until: deadline) else { throw RuntimeError.error(withMessage: "promise did not settle") }
+    }
+    return try result!.get()
+  }
+}
+
+extension Promise where T == Void {
+  public func resolve() { resolve(withResult: ()) }
+}
+
+public enum RuntimeError: Error {
+  case error(withMessage: String)
+}

package/ios/Tests/ImageManipulator/Sources/OneImageManipulatorCore/Types.swift

@@ -0,0 +1,41 @@
+// stand-ins for generated nitro value types; no image behavior.
+class HybridOneImageManipulatorSpec {}
+
+struct ImageCrop {
+  let x: Double
+  let y: Double
+  let width: Double
+  let height: Double
+}
+
+struct ImageResize {
+  let width: Double?
+  let height: Double?
+}
+
+enum OneImageFlip {
+  case horizontal
+  case vertical
+}
+
+enum OneImageFormat {
+  case jpeg
+  case png
+  case webp
+}
+
+struct ImageTransformOptions {
+  let crop: ImageCrop?
+  let resize: ImageResize?
+  let rotate: Double?
+  let flip: OneImageFlip?
+  let format: OneImageFormat
+  let quality: Double?
+}
+
+struct ImageTransformResult {
+  let uri: String
+  let width: Double
+  let height: Double
+  let size: Double
+}

package/ios/Tests/ImageManipulator/Sources/SDWebImageWebPCoder/SDImageWebPCoder.swift

@@ -0,0 +1,23 @@
+import UIKit
+
+// stand-in for the SDWebImageWebPCoder pod, which the harness never links.
+// member names mirror the vendored 0.15.0 headers (SDImageWebPCoder.h,
+// SDImageCoder.h, NSData+ImageContentType.h); only call-site shapes are stubbed.
+public struct SDImageFormat: Hashable {
+  public static let webP = SDImageFormat()
+}
+
+public struct SDImageCoderOption: Hashable {
+  public static let encodeCompressionQuality = SDImageCoderOption()
+}
+
+public final class SDImageWebPCoder {
+  public static let sharedCoder = SDImageWebPCoder()
+  public func encodedData(
+    with image: UIImage?,
+    format: SDImageFormat,
+    options: [SDImageCoderOption: Any]?
+  ) -> Data? {
+    nil
+  }
+}

package/nitrogen/generated/android/c++/JAndroidHaptic.hpp

@@ -0,0 +1,109 @@
+///
+/// JAndroidHaptic.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "AndroidHaptic.hpp"
+
+namespace margelo::nitro::one {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ enum "AndroidHaptic" and the Kotlin enum "AndroidHaptic".
+   */
+  struct JAndroidHaptic final: public jni::JavaClass<JAndroidHaptic> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/one/AndroidHaptic;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based enum to the C++ enum AndroidHaptic.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    AndroidHaptic toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldOrdinal = clazz->getField<int>("value");
+      int ordinal = this->getFieldValue(fieldOrdinal);
+      return static_cast<AndroidHaptic>(ordinal);
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based enum with the given C++ enum's value.
+     */
+    [[maybe_unused]]
+    static jni::alias_ref<JAndroidHaptic> fromCpp(AndroidHaptic value) {
+      static const auto clazz = javaClassStatic();
+      switch (value) {
+        case AndroidHaptic::CLOCK_TICK:
+          static const auto fieldCLOCK_TICK = clazz->getStaticField<JAndroidHaptic>("CLOCK_TICK");
+          return clazz->getStaticFieldValue(fieldCLOCK_TICK);
+        case AndroidHaptic::CONFIRM:
+          static const auto fieldCONFIRM = clazz->getStaticField<JAndroidHaptic>("CONFIRM");
+          return clazz->getStaticFieldValue(fieldCONFIRM);
+        case AndroidHaptic::CONTEXT_CLICK:
+          static const auto fieldCONTEXT_CLICK = clazz->getStaticField<JAndroidHaptic>("CONTEXT_CLICK");
+          return clazz->getStaticFieldValue(fieldCONTEXT_CLICK);
+        case AndroidHaptic::DRAG_START:
+          static const auto fieldDRAG_START = clazz->getStaticField<JAndroidHaptic>("DRAG_START");
+          return clazz->getStaticFieldValue(fieldDRAG_START);
+        case AndroidHaptic::GESTURE_END:
+          static const auto fieldGESTURE_END = clazz->getStaticField<JAndroidHaptic>("GESTURE_END");
+          return clazz->getStaticFieldValue(fieldGESTURE_END);
+        case AndroidHaptic::GESTURE_START:
+          static const auto fieldGESTURE_START = clazz->getStaticField<JAndroidHaptic>("GESTURE_START");
+          return clazz->getStaticFieldValue(fieldGESTURE_START);
+        case AndroidHaptic::KEYBOARD_PRESS:
+          static const auto fieldKEYBOARD_PRESS = clazz->getStaticField<JAndroidHaptic>("KEYBOARD_PRESS");
+          return clazz->getStaticFieldValue(fieldKEYBOARD_PRESS);
+        case AndroidHaptic::KEYBOARD_RELEASE:
+          static const auto fieldKEYBOARD_RELEASE = clazz->getStaticField<JAndroidHaptic>("KEYBOARD_RELEASE");
+          return clazz->getStaticFieldValue(fieldKEYBOARD_RELEASE);
+        case AndroidHaptic::KEYBOARD_TAP:
+          static const auto fieldKEYBOARD_TAP = clazz->getStaticField<JAndroidHaptic>("KEYBOARD_TAP");
+          return clazz->getStaticFieldValue(fieldKEYBOARD_TAP);
+        case AndroidHaptic::LONG_PRESS:
+          static const auto fieldLONG_PRESS = clazz->getStaticField<JAndroidHaptic>("LONG_PRESS");
+          return clazz->getStaticFieldValue(fieldLONG_PRESS);
+        case AndroidHaptic::NO_HAPTICS:
+          static const auto fieldNO_HAPTICS = clazz->getStaticField<JAndroidHaptic>("NO_HAPTICS");
+          return clazz->getStaticFieldValue(fieldNO_HAPTICS);
+        case AndroidHaptic::REJECT:
+          static const auto fieldREJECT = clazz->getStaticField<JAndroidHaptic>("REJECT");
+          return clazz->getStaticFieldValue(fieldREJECT);
+        case AndroidHaptic::SEGMENT_FREQUENT_TICK:
+          static const auto fieldSEGMENT_FREQUENT_TICK = clazz->getStaticField<JAndroidHaptic>("SEGMENT_FREQUENT_TICK");
+          return clazz->getStaticFieldValue(fieldSEGMENT_FREQUENT_TICK);
+        case AndroidHaptic::SEGMENT_TICK:
+          static const auto fieldSEGMENT_TICK = clazz->getStaticField<JAndroidHaptic>("SEGMENT_TICK");
+          return clazz->getStaticFieldValue(fieldSEGMENT_TICK);
+        case AndroidHaptic::TEXT_HANDLE_MOVE:
+          static const auto fieldTEXT_HANDLE_MOVE = clazz->getStaticField<JAndroidHaptic>("TEXT_HANDLE_MOVE");
+          return clazz->getStaticFieldValue(fieldTEXT_HANDLE_MOVE);
+        case AndroidHaptic::TOGGLE_OFF:
+          static const auto fieldTOGGLE_OFF = clazz->getStaticField<JAndroidHaptic>("TOGGLE_OFF");
+          return clazz->getStaticFieldValue(fieldTOGGLE_OFF);
+        case AndroidHaptic::TOGGLE_ON:
+          static const auto fieldTOGGLE_ON = clazz->getStaticField<JAndroidHaptic>("TOGGLE_ON");
+          return clazz->getStaticFieldValue(fieldTOGGLE_ON);
+        case AndroidHaptic::VIRTUAL_KEY:
+          static const auto fieldVIRTUAL_KEY = clazz->getStaticField<JAndroidHaptic>("VIRTUAL_KEY");
+          return clazz->getStaticFieldValue(fieldVIRTUAL_KEY);
+        case AndroidHaptic::VIRTUAL_KEY_RELEASE:
+          static const auto fieldVIRTUAL_KEY_RELEASE = clazz->getStaticField<JAndroidHaptic>("VIRTUAL_KEY_RELEASE");
+          return clazz->getStaticFieldValue(fieldVIRTUAL_KEY_RELEASE);
+        default:
+          std::string stringValue = std::to_string(static_cast<int>(value));
+          throw std::invalid_argument("Invalid enum value (" + stringValue + "!");
+      }
+    }
+  };
+
+} // namespace margelo::nitro::one

package/nitrogen/generated/android/c++/JCalendarInfo.hpp

@@ -0,0 +1,70 @@
+///
+/// JCalendarInfo.hpp
+/// This file was generated by nitrogen. DO NOT MODIFY THIS FILE.
+/// https://github.com/mrousavy/nitro
+/// Copyright © Marc Rousavy @ Margelo
+///
+
+#pragma once
+
+#include <fbjni/fbjni.h>
+#include "CalendarInfo.hpp"
+
+#include <optional>
+#include <string>
+
+namespace margelo::nitro::one {
+
+  using namespace facebook;
+
+  /**
+   * The C++ JNI bridge between the C++ struct "CalendarInfo" and the Kotlin data class "CalendarInfo".
+   */
+  struct JCalendarInfo final: public jni::JavaClass<JCalendarInfo> {
+  public:
+    static constexpr auto kJavaDescriptor = "Lcom/margelo/nitro/one/CalendarInfo;";
+
+  public:
+    /**
+     * Convert this Java/Kotlin-based struct to the C++ struct CalendarInfo by copying all values to C++.
+     */
+    [[maybe_unused]]
+    [[nodiscard]]
+    CalendarInfo toCpp() const {
+      static const auto clazz = javaClassStatic();
+      static const auto fieldCalendar = clazz->getField<jni::JString>("calendar");
+      jni::local_ref<jni::JString> calendar = this->getFieldValue(fieldCalendar);
+      static const auto fieldTimeZone = clazz->getField<jni::JString>("timeZone");
+      jni::local_ref<jni::JString> timeZone = this->getFieldValue(fieldTimeZone);
+      static const auto fieldUses24hourClock = clazz->getField<jni::JBoolean>("uses24hourClock");
+      jni::local_ref<jni::JBoolean> uses24hourClock = this->getFieldValue(fieldUses24hourClock);
+      static const auto fieldFirstWeekday = clazz->getField<jni::JDouble>("firstWeekday");
+      jni::local_ref<jni::JDouble> firstWeekday = this->getFieldValue(fieldFirstWeekday);
+      return CalendarInfo(
+        calendar != nullptr ? std::make_optional(calendar->toStdString()) : std::nullopt,
+        timeZone != nullptr ? std::make_optional(timeZone->toStdString()) : std::nullopt,
+        uses24hourClock != nullptr ? std::make_optional(static_cast<bool>(uses24hourClock->value())) : std::nullopt,
+        firstWeekday != nullptr ? std::make_optional(firstWeekday->value()) : std::nullopt
+      );
+    }
+
+  public:
+    /**
+     * Create a Java/Kotlin-based struct by copying all values from the given C++ struct to Java.
+     */
+    [[maybe_unused]]
+    static jni::local_ref<JCalendarInfo::javaobject> fromCpp(const CalendarInfo& value) {
+      using JSignature = JCalendarInfo(jni::alias_ref<jni::JString>, jni::alias_ref<jni::JString>, jni::alias_ref<jni::JBoolean>, jni::alias_ref<jni::JDouble>);
+      static const auto clazz = javaClassStatic();
+      static const auto create = clazz->getStaticMethod<JSignature>("fromCpp");
+      return create(
+        clazz,
+        value.calendar.has_value() ? jni::make_jstring(value.calendar.value()) : nullptr,
+        value.timeZone.has_value() ? jni::make_jstring(value.timeZone.value()) : nullptr,
+        value.uses24hourClock.has_value() ? jni::JBoolean::valueOf(value.uses24hourClock.value()) : nullptr,
+        value.firstWeekday.has_value() ? jni::JDouble::valueOf(value.firstWeekday.value()) : nullptr
+      );
+    }
+  };
+
+} // namespace margelo::nitro::one

package/nitrogen/generated/android/c++/JHapticImpact.hpp

@@ -42,12 +42,12 @@ namespace margelo::nitro::one {
     static jni::alias_ref<JHapticImpact> fromCpp(HapticImpact value) {
       static const auto clazz = javaClassStatic();
       switch (value) {
-        case HapticImpact::LIGHT:
-          static const auto fieldLIGHT = clazz->getStaticField<JHapticImpact>("LIGHT");
-          return clazz->getStaticFieldValue(fieldLIGHT);
         case HapticImpact::MEDIUM:
           static const auto fieldMEDIUM = clazz->getStaticField<JHapticImpact>("MEDIUM");
           return clazz->getStaticFieldValue(fieldMEDIUM);
+        case HapticImpact::LIGHT:
+          static const auto fieldLIGHT = clazz->getStaticField<JHapticImpact>("LIGHT");
+          return clazz->getStaticFieldValue(fieldLIGHT);
         case HapticImpact::HEAVY:
           static const auto fieldHEAVY = clazz->getStaticField<JHapticImpact>("HEAVY");
           return clazz->getStaticFieldValue(fieldHEAVY);

package/nitrogen/generated/android/c++/JHybridOneDeviceSpec.cpp

@@ -11,6 +11,10 @@
 namespace margelo::nitro::one { struct DeviceInfo; }
 // Forward declaration of `LocalizationInfo` to properly resolve imports.
 namespace margelo::nitro::one { struct LocalizationInfo; }
+// Forward declaration of `LocaleInfo` to properly resolve imports.
+namespace margelo::nitro::one { struct LocaleInfo; }
+// Forward declaration of `CalendarInfo` to properly resolve imports.
+namespace margelo::nitro::one { struct CalendarInfo; }
 
 #include "DeviceInfo.hpp"
 #include <NitroModules/Promise.hpp>
@@ -21,6 +25,13 @@ namespace margelo::nitro::one { struct LocalizationInfo; }
 #include "LocalizationInfo.hpp"
 #include "JLocalizationInfo.hpp"
 #include <vector>
+#include "LocaleInfo.hpp"
+#include "JLocaleInfo.hpp"
+#include "CalendarInfo.hpp"
+#include "JCalendarInfo.hpp"
+#include <functional>
+#include "JFunc_void.hpp"
+#include <NitroModules/JNICallable.hpp>
 
 namespace margelo::nitro::one {
 
@@ -87,5 +98,46 @@ namespace margelo::nitro::one {
       return __promise;
     }();
   }
+  std::vector<LocaleInfo> JHybridOneDeviceSpec::getLocales() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JLocaleInfo>>()>("getLocales");
+    auto __result = method(_javaPart);
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<LocaleInfo> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
+  std::vector<CalendarInfo> JHybridOneDeviceSpec::getCalendars() {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<jni::JArrayClass<JCalendarInfo>>()>("getCalendars");
+    auto __result = method(_javaPart);
+    return [&](auto&& __input) {
+      size_t __size = __input->size();
+      std::vector<CalendarInfo> __vector;
+      __vector.reserve(__size);
+      for (size_t __i = 0; __i < __size; __i++) {
+        auto __element = __input->getElement(__i);
+        __vector.push_back(__element->toCpp());
+      }
+      return __vector;
+    }(__result);
+  }
+  std::function<void()> JHybridOneDeviceSpec::addLocalizationListener(const std::function<void()>& listener) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<jni::local_ref<JFunc_void::javaobject>(jni::alias_ref<JFunc_void::javaobject> /* listener */)>("addLocalizationListener_cxx");
+    auto __result = method(_javaPart, JFunc_void_cxx::fromCpp(listener));
+    return [&]() -> std::function<void()> {
+      if (__result->isInstanceOf(JFunc_void_cxx::javaClassStatic())) [[likely]] {
+        auto downcast = jni::static_ref_cast<JFunc_void_cxx::javaobject>(__result);
+        return downcast->cthis()->getFunction();
+      } else {
+        auto __resultRef = jni::make_global(__result);
+        return JNICallable<JFunc_void, void()>(std::move(__resultRef));
+      }
+    }();
+  }
 
 } // namespace margelo::nitro::one

package/nitrogen/generated/android/c++/JHybridOneDeviceSpec.hpp

@@ -56,6 +56,9 @@ namespace margelo::nitro::one {
     // Methods
     std::shared_ptr<Promise<DeviceInfo>> getInfo() override;
     std::shared_ptr<Promise<LocalizationInfo>> getLocalizationInfo() override;
+    std::vector<LocaleInfo> getLocales() override;
+    std::vector<CalendarInfo> getCalendars() override;
+    std::function<void()> addLocalizationListener(const std::function<void()>& listener) override;
 
   private:
     jni::global_ref<JHybridOneDeviceSpec::JavaPart> _javaPart;

package/nitrogen/generated/android/c++/JHybridOneHapticsSpec.cpp

@@ -11,11 +11,15 @@
 namespace margelo::nitro::one { enum class HapticImpact; }
 // Forward declaration of `HapticNotification` to properly resolve imports.
 namespace margelo::nitro::one { enum class HapticNotification; }
+// Forward declaration of `AndroidHaptic` to properly resolve imports.
+namespace margelo::nitro::one { enum class AndroidHaptic; }
 
 #include "HapticImpact.hpp"
 #include "JHapticImpact.hpp"
 #include "HapticNotification.hpp"
 #include "JHapticNotification.hpp"
+#include "AndroidHaptic.hpp"
+#include "JAndroidHaptic.hpp"
 
 namespace margelo::nitro::one {
 
@@ -62,5 +66,9 @@ namespace margelo::nitro::one {
     static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JHapticNotification> /* type */)>("notification");
     method(_javaPart, JHapticNotification::fromCpp(type));
   }
+  void JHybridOneHapticsSpec::performAndroidHaptics(AndroidHaptic type) {
+    static const auto method = _javaPart->javaClassStatic()->getMethod<void(jni::alias_ref<JAndroidHaptic> /* type */)>("performAndroidHaptics");
+    method(_javaPart, JAndroidHaptic::fromCpp(type));
+  }
 
 } // namespace margelo::nitro::one

package/nitrogen/generated/android/c++/JHybridOneHapticsSpec.hpp

@@ -57,6 +57,7 @@ namespace margelo::nitro::one {
     void selection() override;
     void impact(HapticImpact style) override;
     void notification(HapticNotification type) override;
+    void performAndroidHaptics(AndroidHaptic type) override;
 
   private:
     jni::global_ref<JHybridOneHapticsSpec::JavaPart> _javaPart;