模块 API 参考

Constant("PI") {
  Double.pi
}

Constant("PI") {
  Math.PI
}

// 从字典创建
Constants([
  "PI": Double.pi
])

// 或由闭包返回
Constants {
  return [
    "PI": Double.pi
  ]
}

// 作为参数传入
Constants(
  "PI" to kotlin.math.PI
)

// 或由闭包返回
Constants {
  return@Constants mapOf(
    "PI" to kotlin.math.PI
  )
}

Function("mySyncFunction") { (message: String) in
  return message
}

Function("mySyncFunction") { message: String ->
  return@Function message
}

AsyncFunction("myAsyncFunction") { (message: String) in
  return message
}

// or

AsyncFunction("myAsyncFunction") { (message: String, promise: Promise) in
  promise.resolve(message)
}

AsyncFunction("myAsyncFunction") { message: String ->
  return@AsyncFunction message
}

// or

// 确保从 `expo.modules.kotlin` 导入 `Promise` 类，而不是 `expo.modules.core`。
AsyncFunction("myAsyncFunction") { message: String, promise: Promise ->
  promise.resolve(message)
}

AsyncFunction("myAsyncFunction") { (message: String) in
  return message
}.runOnQueue(.main)

AsyncFunction("myAsyncFunction") { message: String ->
  return@AsyncFunction message
}.runOnQueue(Queues.MAIN)

Property("foo") {
  return "bar"
}

Property("foo") {
  return@Property "bar"
}

Property("foo")
  .get { return "bar" }
  .set { (newValue: String) in
    // 使用新值做一些事情
  }

Property("foo")
  .get { return@get "bar" }
  .set { newValue: String ->
    // 使用新值做一些事情
  }

View(UITextView.self) {
  Prop("text") { %%placeholder-start%%... %%placeholder-end%% }

  AsyncFunction("focus") { (view: UITextView) in
    view.becomeFirstResponder()
  }
}

View(TextView::class) {
  Prop("text") { %%placeholder-start%%... %%placeholder-end%% }

  AsyncFunction("focus") { view: TextView ->
    view.requestFocus()
  }
}

Prop("background") { (view: UIView, color: UIColor) in
  view.backgroundColor = color
}

Prop("background") { view: View, @ColorInt color: Int ->
  view.setBackgroundColor(color)
}

Prop("background", UIColor.black) { (view: UIView, color: UIColor) in
  view.backgroundColor = color
}

Prop("background", Color.BLACK) { view: View, @ColorInt color: Int ->
  view.setBackgroundColor(color)
}

View(MyView.self) {
  AsyncFunction("myAsyncFunction") { (view: MyView, message: String) in
    view.displayMessage(message)
  }
}

View(MyView::class) {
  AsyncFunction("myAsyncFunction") { view: MyView, message: String ->
    view.displayMessage(message);
  }
}

struct FileReadOptions: Record {
  @Field
  var encoding: String = "utf8"

  @Field
  var position: Int = 0

  @Field
  var length: Int?
}

// 现在这个 record 可以作为函数或视图 prop setter 的参数使用。
Function("readFile") { (path: String, options: FileReadOptions) -> String in
  // 使用给定的 `options` 读取文件
}

class FileReadOptions : Record {
  @Field
  val encoding: String = "utf8"

  @Field
  val position: Int = 0

  @Field
  val length: Int? = null
}

// 现在这个 record 可以作为函数或视图 prop setter 的参数使用。
Function("readFile") { path: String, options: FileReadOptions ->
  // 使用给定的 `options` 读取文件
}

struct UserInfo: Record {
  @Field var id: Int = 0
  @Field var email: String = ""
  @Field var password: String = ""
}

Function("getUser") {
  let user = UserInfo(id: 1, email: "user@example.com", password: "secret123")

  // 返回不暴露密码的用户
  return user.format { formatter in
    formatter.property("password", keyPath: \.password).skip()
  }
}

class UserInfo(
  @Field val id: Int = 0,
  @Field val email: String = "",
  @Field val password: String = ""
) : Record

Function("getUser") {
  val user = UserInfo(id = 1, email = "user@example.com", password = "secret123")

  // 返回不暴露密码的用户
  formatter {
    property(UserInfo::password).skip()
  }.format(user)
}

struct Product: Record {
  @Field var name: String = ""
  @Field var price: Double = 0.0
}

Function("getProduct") {
  let product = Product(name: "Widget", price: 19.99)

  return product.format { formatter in
    // 将价格转换为带货币符号的字符串
    formatter.property("price", keyPath: \.price).map { value in
      "$\(String(format: "%.2f", value))"
    }
  }
}

class Product(
  @Field val name: String = "",
  @Field val price: Double = 0.0
) : Record

Function("getProduct") {
  val product = Product(name = "Widget", price = 19.99)

  formatter {
    // 将价格转换为带货币符号的字符串
    property(Product::price).map { value ->
      "${"$"}${String.format("%.2f", value)}"
    }
  }.format(product)
}

struct Settings: Record {
  @Field var theme: String = "light"
  @Field var debugMode: Bool = false
  @Field var apiKey: String? = nil
}

Function("getSettings") {
  let settings = Settings(theme: "dark", debugMode: true, apiKey: "secret")

  return settings.format { formatter in
    // 如果 apiKey 为 nil 则跳过
    formatter.property("apiKey", keyPath: \.apiKey).skip { value in
      value == nil
    }
  }
}

class Settings(
  @Field val theme: String = "light",
  @Field val debugMode: Boolean = false,
  @Field val apiKey: String? = null
) : Record

Function("getSettings") {
  val settings = Settings(theme = "dark", debugMode = true, apiKey = "secret")

  formatter {
    // 如果 apiKey 为 null 则跳过
    property(Settings::apiKey).skip { value ->
      value == null
    }
  }.format(settings)
}

struct Data: Record {
  @Field var value: Int? = nil
}

Function("getData") {
  let data = Data(value: nil)

  return data.format { formatter in
    formatter.property("value", keyPath: \.value)
      .map { $0 ?? 0 }  // 如果为 nil，则默认为 0
      .map { $0 * 2 }   // 将值翻倍
  }
}

class Data(
  @Field val value: Int? = null
) : Record

Function("getData") {
  val data = Data(value = null)

  formatter {
    property(Data::value)
      .map { it ?: 0 }  // 如果为 null，则默认为 0
      .map { it * 2 }   // 将值翻倍
  }.format(data)
}

enum FileEncoding: String, Enumerable {
  case utf8
  case base64
}

struct FileReadOptions: Record {
  @Field
  var encoding: FileEncoding = .utf8
  %%placeholder-start%%... %%placeholder-end%%
}

// 注意：构造函数必须有一个名为 value 的参数。
enum class FileEncoding(val value: String) : Enumerable {
  utf8("utf8"),
  base64("base64")
}

class FileReadOptions : Record {
  @Field
  val encoding: FileEncoding = FileEncoding.utf8
  %%placeholder-start%%... %%placeholder-end%%
}

Function("foo") { (bar: Either<String, Int>) in
  if let bar: String = bar.get() {
    // `bar` 是一个 String
  }
  if let bar: Int = bar.get() {
    // `bar` 是一个 Int
  }
}

Function("foo") { bar: Either<String, Int> ->
  bar.get(String::class).let {
    // `it` 是一个 String
  }
  bar.get(Int::class).let {
    // `it` 是一个 Int
  }
}

Function("configure") { (timeout: ValueOrUndefined<Int>) in
  if timeout.isUndefined {
    // 参数未提供，使用默认行为
  } else if let value = timeout.optional {
    // 参数已提供且带有值
  }
}

Function("configure") { timeout: ValueOrUndefined<Int> ->
  if (timeout.isUndefined) {
    // 参数未提供，使用默认行为
  } else {
    timeout.optional?.let { value ->
      // 参数已提供且带有值
    }
  }
}

Function("setName") { (name: ValueOrUndefined<String?>) in
  switch name {
  case .undefined:
    // name 参数未提供
    break
  case .value(let unwrapped) where unwrapped == nil:
    // name 被显式设置为 null
    break
  case .value(let unwrapped):
    // name 被设置为字符串值
    print("Name: \(unwrapped!)")
  }
}

Function("setName") { name: ValueOrUndefined<String?> ->
  when {
    name.isUndefined -> {
      // name 参数未提供
    }
    name.optional == null -> {
      // name 被显式设置为 null
    }
    else -> {
      // name 被设置为字符串值
      println("Name: ${name.optional}")
    }
  }
}

Function("mutateMe") { (value: JavaScriptValue) in
  if value.isObject() {
    let jsObject = value.getObject()
    jsObject.setProperty("expo", value: "modules")
  }
}

// or

Function("mutateMe") { (jsObject: JavaScriptObject) in
  jsObject.setProperty("expo", value: "modules")
}

Function("mutateMe") { value: JavaScriptValue ->
  if (value.isObject()) {
    val jsObject = value.getObject()
    jsObject.setProperty("expo", "modules")
  }
}

// or

Function("mutateMe") { jsObject: JavaScriptObject ->
  jsObject.setProperty("expo", "modules")
}

class LinearGradientView: ExpoView {}

public class LinearGradientModule: Module {
  public func definition() -> ModuleDefinition {
    View(LinearGradientView.self) {
      %%placeholder-start%%... %%placeholder-end%%
    }
  }
}

class LinearGradientView(
  context: Context,
  appContext: AppContext,
) : ExpoView(context, appContext)

class LinearGradientModule : Module() {
  override fun definition() = ModuleDefinition {
    View(LinearGradientView::class) {
      %%placeholder-start%%... %%placeholder-end%%
    }
  }
}

let CLIPBOARD_CHANGED_EVENT_NAME = "onClipboardChanged"

public class ClipboardModule: Module {
  public func definition() -> ModuleDefinition {
    Events(CLIPBOARD_CHANGED_EVENT_NAME)

    OnStartObserving {
      NotificationCenter.default.addObserver(
        self,
        selector: #selector(self.clipboardChangedListener),
        name: UIPasteboard.changedNotification,
        object: nil
      )
    }

    OnStopObserving {
      NotificationCenter.default.removeObserver(
        self,
        name: UIPasteboard.changedNotification,
        object: nil
      )
    }
  }

  @objc
  private func clipboardChangedListener() {
    sendEvent(CLIPBOARD_CHANGED_EVENT_NAME, [
      "contentTypes": availableContentTypes()
    ])
  }
}

const val CLIPBOARD_CHANGED_EVENT_NAME = "onClipboardChanged"

class ClipboardModule : Module() {
  override fun definition() = ModuleDefinition {
    Events(CLIPBOARD_CHANGED_EVENT_NAME)

    OnStartObserving {
      clipboardManager?.addPrimaryClipChangedListener(listener)
    }

    OnStopObserving {
      clipboardManager?.removePrimaryClipChangedListener(listener)
    }
  }

  private val clipboardManager: ClipboardManager?
    get() = appContext.reactContext?.getSystemService(Context.CLIPBOARD_SERVICE) as? ClipboardManager

  private val listener = ClipboardManager.OnPrimaryClipChangedListener {
    clipboardManager?.primaryClipDescription?.let { clip ->
      this@ClipboardModule.sendEvent(
        CLIPBOARD_CHANGED_EVENT_NAME,
        bundleOf(
          "contentTypes" to availableContentTypes(clip)
        )
      )
    }
  }
}

class CameraViewModule: Module {
  public func definition() -> ModuleDefinition {
    View(CameraView.self) {
      Events(
        "onCameraReady"
      )
      %%placeholder-start%%... %%placeholder-end%%
    }
  }
}

class CameraView: ExpoView {
  let onCameraReady = EventDispatcher()

  func callOnCameraReady() {
    onCameraReady([
      "message": "Camera was mounted"
    ]);
  }
}

class CameraViewModule : Module() {
  override fun definition() = ModuleDefinition {
    View(ExpoCameraView::class) {
      Events(
        "onCameraReady"
      )
      %%placeholder-start%%... %%placeholder-end%%
    }
  }
}

class CameraView(
  context: Context,
  appContext: AppContext
) : ExpoView(context, appContext) {
  val onCameraReady by EventDispatcher()

  fun callOnCameraReady() {
    onCameraReady(mapOf(
      "message" to "Camera was mounted"
    ));
  }
}