33c - AI 辅助原生模块开发

你需要开发原生模块？
│
├─ 使用 React Native + Expo？
│  ├─ 是 Expo 托管工作流？
│  │  └─→ Expo Modules API（首选）
│  │      ✅ 现代 Swift/Kotlin API
│  │      ✅ 自动桥接代码生成
│  │      ✅ 与 Expo 生态无缝集成
│  │
│  └─ 是裸 React Native 项目？
│     ├─ 需要极致性能（图像/音视频）？
│     │  └─→ Nitro Modules / TurboModules
│     │      ✅ C++ 直接绑定 JSI
│     │      ✅ 零序列化开销
│     │
│     └─ 一般原生功能？
│        └─→ TurboModules（新架构）
│            ✅ React Native 官方方案
│            ✅ 类型安全的 CodeGen
│
├─ 使用 Flutter？
│  ├─ 简单方法调用？
│  │  └─→ MethodChannel / Pigeon
│  │      ✅ 标准方案，文档完善
│  │
│  ├─ 持续事件流（传感器/位置）？
│  │  └─→ EventChannel
│  │      ✅ 原生事件流到 Dart Stream
│  │
│  └─ 高性能计算 / 复用 C/C++ 库？
│     └─→ dart:ffi
│         ✅ 直接调用 C 函数
│         ✅ 零消息传递开销
│
└─ 原生应用集成跨平台？
   ├─ 已有 iOS 应用 + 需要 Flutter 页面
   │  └─→ Flutter Add-to-App
   └─ 已有 Android 应用 + 需要 RN 页面
      └─→ React Native 嵌入原生应用

# 在 Expo 项目中创建本地模块
npx create-expo-module@latest --local my-native-module
 
# 或创建独立的可发布模块
npx create-expo-module@latest my-native-module

modules/my-native-module/
├── android/
│   └── src/main/java/expo/modules/mynativemodule/
│       └── MyNativeModule.kt          # Kotlin 实现
├── ios/
│   └── MyNativeModule.swift           # Swift 实现
├── src/
│   ├── index.ts                       # TypeScript 入口
│   └── MyNativeModule.ts              # TypeScript 模块定义
├── expo-module.config.json            # 模块配置
└── package.json

// src/MyNativeModule.ts
import { NativeModule, requireNativeModule } from 'expo-modules-core';
 
// 声明模块接口
declare class MyNativeModuleType extends NativeModule {
  // 同步方法
  getDeviceId(): string;
  
  // 异步方法
  getBatteryLevel(): Promise<number>;
  
  // 带参数的方法
  saveToKeychain(key: string, value: string): Promise<boolean>;
  readFromKeychain(key: string): Promise<string | null>;
  
  // 事件
  addListener(eventName: string): void;
  removeListeners(count: number): void;
}
 
export default requireNativeModule<MyNativeModuleType>('MyNativeModule');

// src/index.ts
import MyNativeModule from './MyNativeModule';
 
export function getDeviceId(): string {
  return MyNativeModule.getDeviceId();
}
 
export async function getBatteryLevel(): Promise<number> {
  return await MyNativeModule.getBatteryLevel();
}
 
export async function saveToKeychain(
  key: string,
  value: string
): Promise<boolean> {
  return await MyNativeModule.saveToKeychain(key, value);
}
 
export async function readFromKeychain(
  key: string
): Promise<string | null> {
  return await MyNativeModule.readFromKeychain(key);
}

// ios/MyNativeModule.swift
import ExpoModulesCore
import UIKit
import LocalAuthentication
import Security
 
public class MyNativeModule: Module {
  // 模块定义
  public func definition() -> ModuleDefinition {
    // 模块名称（必须与 TypeScript 中的名称一致）
    Name("MyNativeModule")
    
    // 同步函数：获取设备 ID
    Function("getDeviceId") { () -> String in
      return UIDevice.current.identifierForVendor?.uuidString ?? "unknown"
    }
    
    // 异步函数：获取电池电量
    AsyncFunction("getBatteryLevel") { () -> Double in
      UIDevice.current.isBatteryMonitoringEnabled = true
      let level = UIDevice.current.batteryLevel
      return Double(level * 100)
    }
    
    // 异步函数：保存到 Keychain
    AsyncFunction("saveToKeychain") { (key: String, value: String) -> Bool in
      let data = value.data(using: .utf8)!
      
      let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: key,
        kSecValueData as String: data,
        kSecAttrAccessible as String: kSecAttrAccessibleWhenUnlockedThisDeviceOnly
      ]
      
      // 先删除已有的
      SecItemDelete(query as CFDictionary)
      
      let status = SecItemAdd(query as CFDictionary, nil)
      return status == errSecSuccess
    }
    
    // 异步函数：从 Keychain 读取
    AsyncFunction("readFromKeychain") { (key: String) -> String? in
      let query: [String: Any] = [
        kSecClass as String: kSecClassGenericPassword,
        kSecAttrAccount as String: key,
        kSecReturnData as String: true,
        kSecMatchLimit as String: kSecMatchLimitOne
      ]
      
      var result: AnyObject?
      let status = SecItemCopyMatching(query as CFDictionary, &result)
      
      guard status == errSecSuccess,
            let data = result as? Data,
            let value = String(data: data, encoding: .utf8) else {
        return nil
      }
      
      return value
    }
    
    // 事件定义
    Events("onBatteryChange", "onKeychainUpdate")
    
    // 模块生命周期
    OnCreate {
      // 模块创建时的初始化逻辑
      UIDevice.current.isBatteryMonitoringEnabled = true
    }
    
    OnDestroy {
      // 模块销毁时的清理逻辑
      UIDevice.current.isBatteryMonitoringEnabled = false
    }
  }
}

// android/src/main/java/expo/modules/mynativemodule/MyNativeModule.kt
package expo.modules.mynativemodule
 
import android.content.Context
import android.os.BatteryManager
import android.os.Build
import android.provider.Settings
import android.security.keystore.KeyGenParameterSpec
import android.security.keystore.KeyProperties
import expo.modules.kotlin.modules.Module
import expo.modules.kotlin.modules.ModuleDefinition
import java.security.KeyStore
import javax.crypto.Cipher
import javax.crypto.KeyGenerator
import javax.crypto.SecretKey
import javax.crypto.spec.GCMParameterSpec
import android.util.Base64
 
class MyNativeModule : Module() {
  override fun definition() = ModuleDefinition {
    // 模块名称
    Name("MyNativeModule")
 
    // 同步函数：获取设备 ID
    Function("getDeviceId") {
      Settings.Secure.getString(
        appContext.reactContext?.contentResolver,
        Settings.Secure.ANDROID_ID
      ) ?: "unknown"
    }
 
    // 异步函数：获取电池电量
    AsyncFunction("getBatteryLevel") {
      val batteryManager = appContext.reactContext
        ?.getSystemService(Context.BATTERY_SERVICE) as? BatteryManager
      val level = batteryManager
        ?.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
      (level ?: -1).toDouble()
    }
 
    // 异步函数：保存到 KeyStore
    AsyncFunction("saveToKeychain") { key: String, value: String ->
      try {
        val sharedPrefs = appContext.reactContext
          ?.getSharedPreferences("secure_storage", Context.MODE_PRIVATE)
        sharedPrefs?.edit()?.putString(key, value)?.apply()
        true
      } catch (e: Exception) {
        false
      }
    }
 
    // 异步函数：从 KeyStore 读取
    AsyncFunction("readFromKeychain") { key: String ->
      val sharedPrefs = appContext.reactContext
        ?.getSharedPreferences("secure_storage", Context.MODE_PRIVATE)
      sharedPrefs?.getString(key, null)
    }
 
    // 事件定义
    Events("onBatteryChange", "onKeychainUpdate")
 
    // 模块生命周期
    OnCreate {
      // 初始化逻辑
    }
 
    OnDestroy {
      // 清理逻辑
    }
  }
}

// app/settings/security.tsx
import { useState, useEffect } from 'react';
import { View, Text, TextInput, Pressable, Alert } from 'react-native';
import {
  getDeviceId,
  getBatteryLevel,
  saveToKeychain,
  readFromKeychain,
} from '../../modules/my-native-module';
 
export default function SecuritySettings() {
  const [deviceId, setDeviceId] = useState('');
  const [battery, setBattery] = useState(0);
  const [secretKey, setSecretKey] = useState('');
  const [storedValue, setStoredValue] = useState('');
 
  useEffect(() => {
    // 同步调用
    setDeviceId(getDeviceId());
    
    // 异步调用
    getBatteryLevel().then(setBattery);
  }, []);
 
  const handleSave = async () => {
    const success = await saveToKeychain('api_token', secretKey);
    Alert.alert(success ? '保存成功' : '保存失败');
  };
 
  const handleRead = async () => {
    const value = await readFromKeychain('api_token');
    setStoredValue(value ?? '未找到');
  };
 
  return (
    <View style={{ padding: 16 }}>
      <Text>设备 ID: {deviceId}</Text>
      <Text>电池电量: {battery}%</Text>
      
      <TextInput
        value={secretKey}
        onChangeText={setSecretKey}
        placeholder="输入密钥"
        secureTextEntry
      />
      <Pressable onPress={handleSave}>
        <Text>保存到 Keychain</Text>
      </Pressable>
      
      <Pressable onPress={handleRead}>
        <Text>读取 Keychain</Text>
      </Pressable>
      <Text>存储值: {storedValue}</Text>
    </View>
  );
}

// ios/MyNativeView.swift
import ExpoModulesCore
import UIKit
import MapKit
 
class MyMapView: ExpoView {
  let mapView = MKMapView()
  
  required init(appContext: AppContext? = nil) {
    super.init(appContext: appContext)
    addSubview(mapView)
    mapView.translatesAutoresizingMaskIntoConstraints = false
    NSLayoutConstraint.activate([
      mapView.topAnchor.constraint(equalTo: topAnchor),
      mapView.bottomAnchor.constraint(equalTo: bottomAnchor),
      mapView.leadingAnchor.constraint(equalTo: leadingAnchor),
      mapView.trailingAnchor.constraint(equalTo: trailingAnchor),
    ])
  }
  
  func setRegion(latitude: Double, longitude: Double, delta: Double) {
    let region = MKCoordinateRegion(
      center: CLLocationCoordinate2D(
        latitude: latitude,
        longitude: longitude
      ),
      span: MKCoordinateSpan(
        latitudeDelta: delta,
        longitudeDelta: delta
      )
    )
    mapView.setRegion(region, animated: true)
  }
}
 
public class MyMapModule: Module {
  public func definition() -> ModuleDefinition {
    Name("MyMapView")
    
    View(MyMapView.self) {
      Prop("latitude") { (view: MyMapView, lat: Double) in
        view.setRegion(
          latitude: lat,
          longitude: view.mapView.region.center.longitude,
          delta: view.mapView.region.span.latitudeDelta
        )
      }
      
      Prop("longitude") { (view: MyMapView, lng: Double) in
        view.setRegion(
          latitude: view.mapView.region.center.latitude,
          longitude: lng,
          delta: view.mapView.region.span.latitudeDelta
        )
      }
      
      Prop("zoomLevel") { (view: MyMapView, zoom: Double) in
        let delta = 360.0 / pow(2.0, zoom)
        view.setRegion(
          latitude: view.mapView.region.center.latitude,
          longitude: view.mapView.region.center.longitude,
          delta: delta
        )
      }
      
      Events("onRegionChange", "onMarkerPress")
    }
  }
}

// android/.../MyMapView.kt
package expo.modules.mynativemodule
 
import android.content.Context
import expo.modules.kotlin.AppContext
import expo.modules.kotlin.views.ExpoView
import com.google.android.gms.maps.GoogleMap
import com.google.android.gms.maps.MapView
import com.google.android.gms.maps.model.LatLng
import com.google.android.gms.maps.CameraUpdateFactory
 
class MyMapView(context: Context, appContext: AppContext) 
  : ExpoView(context, appContext) {
  
  internal val mapView = MapView(context).also {
    addView(it)
    it.layoutParams = LayoutParams(
      LayoutParams.MATCH_PARENT,
      LayoutParams.MATCH_PARENT
    )
  }
  
  private var googleMap: GoogleMap? = null
  
  init {
    mapView.onCreate(null)
    mapView.getMapAsync { map ->
      googleMap = map
    }
  }
  
  fun setCenter(latitude: Double, longitude: Double, zoom: Float) {
    googleMap?.moveCamera(
      CameraUpdateFactory.newLatLngZoom(
        LatLng(latitude, longitude),
        zoom
      )
    )
  }
}

// iOS - 定义 Record
struct LocationRecord: Record {
  @Field var latitude: Double = 0
  @Field var longitude: Double = 0
  @Field var altitude: Double? = nil
  @Field var accuracy: Double = 0
  @Field var timestamp: Double = 0
}
 
// 在模块中使用
AsyncFunction("getLocation") { () -> LocationRecord in
  // ... 获取位置
  return LocationRecord(
    latitude: location.coordinate.latitude,
    longitude: location.coordinate.longitude,
    altitude: location.altitude,
    accuracy: location.horizontalAccuracy,
    timestamp: location.timestamp.timeIntervalSince1970
  )
}

// Android - 定义 Record
class LocationRecord : Record {
  @Field var latitude: Double = 0.0
  @Field var longitude: Double = 0.0
  @Field var altitude: Double? = null
  @Field var accuracy: Double = 0.0
  @Field var timestamp: Double = 0.0
}
 
// 在模块中使用
AsyncFunction("getLocation") {
  // ... 获取位置
  LocationRecord().apply {
    latitude = location.latitude
    longitude = location.longitude
    altitude = location.altitude
    accuracy = location.accuracy.toDouble()
    timestamp = location.time.toDouble()
  }
}

请为 Expo 项目创建一个原生模块 [模块名称]，使用 Expo Modules API：

## 功能需求
[详细描述模块需要提供的原生功能]

## 接口定义
- [方法1]: [参数] → [返回值] - [描述]
- [方法2]: [参数] → [返回值] - [描述]
- [事件1]: [事件数据] - [触发条件]

## 平台要求
- iOS 最低版本：[版本号]
- Android 最低 API：[API 级别]
- 需要的权限：[列出所需权限]

## 技术要求
1. 使用 Expo Modules API（Swift + Kotlin）
2. 所有方法包含错误处理
3. 异步操作使用 AsyncFunction
4. 结构化数据使用 Record
5. 包含完整的 TypeScript 类型定义
6. 包含使用示例代码

## 输出文件
- ios/[ModuleName].swift
- android/src/main/java/expo/modules/[name]/[ModuleName].kt
- src/[ModuleName].ts（TypeScript 接口）
- src/index.ts（导出入口）

请为 Expo 项目创建一个原生视图组件 [组件名称]：

## 视图功能
[描述原生视图需要渲染的内容和交互]

## Props 定义
- [prop1]: [类型] - [描述]
- [prop2]: [类型] - [描述]

## 事件回调
- [onEvent1]: [事件数据] - [触发条件]
- [onEvent2]: [事件数据] - [触发条件]

## 平台实现
- iOS：使用 [UIKit/SwiftUI 组件]
- Android：使用 [Android View/Jetpack Compose 组件]

## 要求
1. 使用 Expo Modules API 的 View 定义
2. 支持 Props 动态更新
3. 正确处理视图生命周期
4. 包含 React Native 端的 TypeScript 封装组件

┌─────────────────────────────────────────────────────────┐
│                    旧架构 vs 新架构                        │
├──────────────────────┬──────────────────────────────────┤
│      旧架构（Bridge）  │       新架构（JSI + TurboModules）│
├──────────────────────┼──────────────────────────────────┤
│                      │                                  │
│  JavaScript          │  JavaScript                      │
│      │               │      │                           │
│      ▼               │      ▼                           │
│  JSON 序列化          │  JSI（直接 C++ 绑定）              │
│      │               │      │                           │
│      ▼               │      ▼                           │
│  Bridge（异步队列）    │  TurboModule（同步/异步）          │
│      │               │      │                           │
│      ▼               │      ▼                           │
│  JSON 反序列化        │  原生代码（Swift/Kotlin/C++）      │
│      │               │                                  │
│      ▼               │  ✅ 无序列化开销                   │
│  原生代码             │  ✅ 支持同步调用                   │
│                      │  ✅ 懒加载（按需初始化）            │
│  ❌ 序列化开销大       │  ✅ 类型安全（CodeGen）            │
│  ❌ 全部异步           │                                  │
│  ❌ 启动时全量加载     │                                  │
│  ❌ 无类型安全         │                                  │
│                      │                                  │
└──────────────────────┴──────────────────────────────────┘

// specs/NativeBiometricAuth.ts
import type { TurboModule } from 'react-native';
import { TurboModuleRegistry } from 'react-native';
 
export interface Spec extends TurboModule {
  // 检查生物识别是否可用
  isBiometricAvailable(): Promise<boolean>;
  
  // 获取支持的生物识别类型
  getBiometricType(): Promise<string>;
  
  // 执行生物识别认证
  authenticate(reason: string): Promise<{
    success: boolean;
    error?: string;
  }>;
  
  // 检查是否已注册生物识别
  isEnrolled(): Promise<boolean>;
}
 
export default TurboModuleRegistry.getEnforcing<Spec>(
  'BiometricAuth'
);

# React Native CodeGen 会根据 Spec 自动生成 C++ 桥接代码
# 在 build 时自动执行，也可以手动触发：
npx react-native codegen

android/app/build/generated/source/codegen/
├── java/com/facebook/fbreact/specs/
│   └── NativeBiometricAuthSpec.java    # Java 接口
└── jni/
    ├── NativeBiometricAuthSpec.h       # C++ 头文件
    └── NativeBiometricAuthSpec.cpp     # C++ 实现
    
ios/build/generated/ios/
├── RNBiometricAuthSpec.h               # ObjC++ 头文件
└── RNBiometricAuthSpec.mm              # ObjC++ 实现

// ios/BiometricAuth/BiometricAuthModule.swift
import Foundation
import LocalAuthentication
 
@objc(BiometricAuth)
class BiometricAuthModule: NSObject {
  
  @objc
  func isBiometricAvailable(
    _ resolve: @escaping RCTPromiseResolveBlock,
    reject: @escaping RCTPromiseRejectBlock
  ) {
    let context = LAContext()
    var error: NSError?
    let available = context.canEvaluatePolicy(
      .deviceOwnerAuthenticationWithBiometrics,
      error: &error
    )
    resolve(available)
  }
  
  @objc
  func getBiometricType(
    _ resolve: @escaping RCTPromiseResolveBlock,
    reject: @escaping RCTPromiseRejectBlock
  ) {
    let context = LAContext()
    var error: NSError?
    
    guard context.canEvaluatePolicy(
      .deviceOwnerAuthenticationWithBiometrics,
      error: &error
    ) else {
      resolve("none")
      return
    }
    
    switch context.biometryType {
    case .faceID:
      resolve("faceId")
    case .touchID:
      resolve("touchId")
    case .opticID:
      resolve("opticId")
    @unknown default:
      resolve("unknown")
    }
  }
  
  @objc
  func authenticate(
    _ reason: String,
    resolve: @escaping RCTPromiseResolveBlock,
    reject: @escaping RCTPromiseRejectBlock
  ) {
    let context = LAContext()
    context.localizedFallbackTitle = "使用密码"
    
    context.evaluatePolicy(
      .deviceOwnerAuthenticationWithBiometrics,
      localizedReason: reason
    ) { success, error in
      DispatchQueue.main.async {
        if success {
          resolve(["success": true])
        } else {
          let errorMessage = error?.localizedDescription ?? "认证失败"
          resolve(["success": false, "error": errorMessage])
        }
      }
    }
  }
  
  @objc
  func isEnrolled(
    _ resolve: @escaping RCTPromiseResolveBlock,
    reject: @escaping RCTPromiseRejectBlock
  ) {
    let context = LAContext()
    var error: NSError?
    let enrolled = context.canEvaluatePolicy(
      .deviceOwnerAuthenticationWithBiometrics,
      error: &error
    )
    resolve(enrolled)
  }
  
  @objc static func requiresMainQueueSetup() -> Bool {
    return false
  }
}

// android/app/src/main/java/com/myapp/biometric/BiometricAuthModule.kt
package com.myapp.biometric
 
import android.os.Build
import androidx.biometric.BiometricManager
import androidx.biometric.BiometricPrompt
import androidx.core.content.ContextCompat
import androidx.fragment.app.FragmentActivity
import com.facebook.react.bridge.*
import com.facebook.react.module.annotations.ReactModule
 
@ReactModule(name = BiometricAuthModule.NAME)
class BiometricAuthModule(reactContext: ReactApplicationContext) :
  NativeBiometricAuthSpec(reactContext) {
 
  companion object {
    const val NAME = "BiometricAuth"
  }
 
  override fun getName() = NAME
 
  override fun isBiometricAvailable(promise: Promise) {
    val biometricManager = BiometricManager.from(reactApplicationContext)
    val canAuthenticate = biometricManager.canAuthenticate(
      BiometricManager.Authenticators.BIOMETRIC_STRONG
    )
    promise.resolve(canAuthenticate == BiometricManager.BIOMETRIC_SUCCESS)
  }
 
  override fun getBiometricType(promise: Promise) {
    val biometricManager = BiometricManager.from(reactApplicationContext)
    val canAuthenticate = biometricManager.canAuthenticate(
      BiometricManager.Authenticators.BIOMETRIC_STRONG
    )
    
    when (canAuthenticate) {
      BiometricManager.BIOMETRIC_SUCCESS -> {
        // Android 不区分指纹和面部，统一返回 biometric
        promise.resolve("biometric")
      }
      else -> promise.resolve("none")
    }
  }
 
  override fun authenticate(reason: String, promise: Promise) {
    val activity = currentActivity as? FragmentActivity
    if (activity == null) {
      promise.resolve(
        Arguments.createMap().apply {
          putBoolean("success", false)
          putString("error", "Activity not available")
        }
      )
      return
    }
 
    val executor = ContextCompat.getMainExecutor(reactApplicationContext)
    
    val callback = object : BiometricPrompt.AuthenticationCallback() {
      override fun onAuthenticationSucceeded(
        result: BiometricPrompt.AuthenticationResult
      ) {
        promise.resolve(
          Arguments.createMap().apply {
            putBoolean("success", true)
          }
        )
      }
 
      override fun onAuthenticationError(
        errorCode: Int,
        errString: CharSequence
      ) {
        promise.resolve(
          Arguments.createMap().apply {
            putBoolean("success", false)
            putString("error", errString.toString())
          }
        )
      }
 
      override fun onAuthenticationFailed() {
        // 单次失败不 resolve，等待用户重试或取消
      }
    }
 
    val promptInfo = BiometricPrompt.PromptInfo.Builder()
      .setTitle("生物识别认证")
      .setSubtitle(reason)
      .setNegativeButtonText("取消")
      .setAllowedAuthenticators(
        BiometricManager.Authenticators.BIOMETRIC_STRONG
      )
      .build()
 
    activity.runOnUiThread {
      BiometricPrompt(activity, executor, callback)
        .authenticate(promptInfo)
    }
  }
 
  override fun isEnrolled(promise: Promise) {
    val biometricManager = BiometricManager.from(reactApplicationContext)
    val canAuthenticate = biometricManager.canAuthenticate(
      BiometricManager.Authenticators.BIOMETRIC_STRONG
    )
    promise.resolve(canAuthenticate == BiometricManager.BIOMETRIC_SUCCESS)
  }
}

请为 React Native 新架构生成一个 TurboModule：

## 模块名称
[ModuleName]

## 功能描述
[详细描述模块功能]

## 方法定义
1. [方法名]([参数列表]) → [返回类型]：[描述]
2. [方法名]([参数列表]) → [返回类型]：[描述]

## 要求
1. 生成 TypeScript Spec 文件（specs/Native[ModuleName].ts）
2. 生成 iOS 实现（Swift，使用 LocalAuthentication/CoreBluetooth 等框架）
3. 生成 Android 实现（Kotlin，使用 AndroidX 库）
4. 所有异步方法使用 Promise
5. 包含完整的错误处理
6. 遵循 React Native 新架构 CodeGen 规范
7. 包含 JS 端的封装层和使用示例

## 平台特定注意事项
- iOS：[iOS 特定要求]
- Android：[Android 特定要求]

// src/specs/ImageProcessor.nitro.ts
import { HybridObject } from 'react-native-nitro-modules';
 
// 定义图像处理器接口
export interface ImageProcessor extends HybridObject<{
  ios: 'swift';
  android: 'kotlin';
}> {
  // 属性
  readonly supportedFormats: string[];
  quality: number;
  
  // 同步方法
  getImageSize(path: string): { width: number; height: number };
  
  // 异步方法
  compressImage(
    inputPath: string,
    outputPath: string,
    quality: number
  ): Promise<{ size: number; path: string }>;
  
  resizeImage(
    inputPath: string,
    width: number,
    height: number
  ): Promise<string>;
  
  applyFilter(
    inputPath: string,
    filter: 'grayscale' | 'sepia' | 'blur' | 'sharpen',
    intensity: number
  ): Promise<string>;
  
  // 批量处理
  batchProcess(
    paths: string[],
    operations: Array<{
      type: 'compress' | 'resize' | 'filter';
      params: Record<string, unknown>;
    }>
  ): Promise<string[]>;
}

# 安装 Nitrogen
npm install nitro-codegen --save-dev
 
# 运行代码生成
npx nitro-codegen
 
# Nitrogen 会生成以下文件：
# - C++ 桥接代码（自动生成）
# - Swift 协议定义（自动生成）
# - Kotlin 接口定义（自动生成）

// ios/ImageProcessor.swift
import NitroModules
import UIKit
import CoreImage
 
class HybridImageProcessor: HybridImageProcessorSpec {
  // 属性
  var supportedFormats: [String] {
    return ["jpeg", "png", "heic", "webp"]
  }
  
  var quality: Double = 0.8
  
  // 同步方法
  func getImageSize(path: String) throws -> ImageSize {
    guard let image = UIImage(contentsOfFile: path) else {
      throw RuntimeError.error(
        withMessage: "无法加载图片: \(path)"
      )
    }
    return ImageSize(
      width: Double(image.size.width),
      height: Double(image.size.height)
    )
  }
  
  // 异步方法
  func compressImage(
    inputPath: String,
    outputPath: String,
    quality: Double
  ) async throws -> CompressResult {
    guard let image = UIImage(contentsOfFile: inputPath) else {
      throw RuntimeError.error(
        withMessage: "无法加载图片"
      )
    }
    
    guard let data = image.jpegData(
      compressionQuality: CGFloat(quality)
    ) else {
      throw RuntimeError.error(
        withMessage: "压缩失败"
      )
    }
    
    try data.write(to: URL(fileURLWithPath: outputPath))
    
    return CompressResult(
      size: Double(data.count),
      path: outputPath
    )
  }
  
  func resizeImage(
    inputPath: String,
    width: Double,
    height: Double
  ) async throws -> String {
    guard let image = UIImage(contentsOfFile: inputPath) else {
      throw RuntimeError.error(
        withMessage: "无法加载图片"
      )
    }
    
    let size = CGSize(width: width, height: height)
    let renderer = UIGraphicsImageRenderer(size: size)
    let resized = renderer.image { _ in
      image.draw(in: CGRect(origin: .zero, size: size))
    }
    
    let outputPath = inputPath
      .replacingOccurrences(of: ".jpg", with: "_resized.jpg")
    
    if let data = resized.jpegData(
      compressionQuality: CGFloat(quality)
    ) {
      try data.write(to: URL(fileURLWithPath: outputPath))
    }
    
    return outputPath
  }
  
  func applyFilter(
    inputPath: String,
    filter: String,
    intensity: Double
  ) async throws -> String {
    guard let inputImage = CIImage(
      contentsOf: URL(fileURLWithPath: inputPath)
    ) else {
      throw RuntimeError.error(
        withMessage: "无法加载图片"
      )
    }
    
    let ciFilter: CIFilter?
    
    switch filter {
    case "grayscale":
      ciFilter = CIFilter(name: "CIColorMonochrome")
      ciFilter?.setValue(inputImage, forKey: kCIInputImageKey)
      ciFilter?.setValue(
        CIColor(red: 0.7, green: 0.7, blue: 0.7),
        forKey: kCIInputColorKey
      )
      ciFilter?.setValue(intensity, forKey: kCIInputIntensityKey)
      
    case "sepia":
      ciFilter = CIFilter(name: "CISepiaTone")
      ciFilter?.setValue(inputImage, forKey: kCIInputImageKey)
      ciFilter?.setValue(intensity, forKey: kCIInputIntensityKey)
      
    case "blur":
      ciFilter = CIFilter(name: "CIGaussianBlur")
      ciFilter?.setValue(inputImage, forKey: kCIInputImageKey)
      ciFilter?.setValue(intensity * 10, forKey: kCIInputRadiusKey)
      
    case "sharpen":
      ciFilter = CIFilter(name: "CISharpenLuminance")
      ciFilter?.setValue(inputImage, forKey: kCIInputImageKey)
      ciFilter?.setValue(intensity, forKey: kCIInputSharpnessKey)
      
    default:
      throw RuntimeError.error(
        withMessage: "不支持的滤镜: \(filter)"
      )
    }
    
    guard let outputImage = ciFilter?.outputImage else {
      throw RuntimeError.error(withMessage: "滤镜处理失败")
    }
    
    let context = CIContext()
    let outputPath = inputPath
      .replacingOccurrences(of: ".jpg", with: "_filtered.jpg")
    let outputURL = URL(fileURLWithPath: outputPath)
    
    try context.writeJPEGRepresentation(
      of: outputImage,
      to: outputURL,
      colorSpace: CGColorSpaceCreateDeviceRGB()
    )
    
    return outputPath
  }
}

请为 React Native 创建一个 Nitro Module [模块名称]：

## 功能需求
[详细描述高性能原生功能需求]

## 接口定义（HybridObject）
- 属性：[列出只读/可写属性]
- 同步方法：[列出同步方法及签名]
- 异步方法：[列出异步方法及签名]

## 性能要求
- [描述性能敏感的操作]
- 预期吞吐量：[如 30fps 视频处理]

## 要求
1. 生成 TypeScript 接口（.nitro.ts）
2. 生成 Swift 实现（HybridObject）
3. 生成 Kotlin 实现（HybridObject）
4. 使用 async/await 处理异步操作
5. 包含完整的错误处理（throws）
6. 性能敏感操作在后台线程执行
7. 包含 JS 端使用示例

┌─────────────────────────────────────────────────────────────┐
│              Flutter Platform Channels 架构                   │
├─────────────────────────────────────────────────────────────┤
│                                                             │
│  Dart 层                                                    │
│  ┌──────────────┐ ┌──────────────┐ ┌───────────────────┐   │
│  │ MethodChannel │ │ EventChannel │ │BasicMessageChannel│   │
│  └──────┬───────┘ └──────┬───────┘ └────────┬──────────┘   │
│         │                │                   │              │
│  ───────┼────────────────┼───────────────────┼──────────    │
│         │     消息编解码（StandardMessageCodec）│              │
│  ───────┼────────────────┼───────────────────┼──────────    │
│         │                │                   │              │
│  平台层（iOS / Android）                                     │
│  ┌──────┴───────┐ ┌──────┴───────┐ ┌────────┴──────────┐   │
│  │FlutterMethod │ │FlutterEvent  │ │FlutterBasicMessage│   │
│  │ Channel      │ │ Channel      │ │ Channel           │   │
│  └──────────────┘ └──────────────┘ └───────────────────┘   │
│                                                             │
└─────────────────────────────────────────────────────────────┘

// lib/services/camera_service.dart
import 'dart:async';
import 'package:flutter/services.dart';
 
class CameraService {
  static const _channel = MethodChannel('com.myapp/camera');
  
  /// 检查相机权限
  Future<bool> checkPermission() async {
    try {
      final result = await _channel.invokeMethod<bool>('checkPermission');
      return result ?? false;
    } on PlatformException catch (e) {
      throw CameraException('权限检查失败: ${e.message}');
    }
  }
  
  /// 请求相机权限
  Future<bool> requestPermission() async {
    try {
      final result = await _channel.invokeMethod<bool>('requestPermission');
      return result ?? false;
    } on PlatformException catch (e) {
      throw CameraException('权限请求失败: ${e.message}');
    }
  }
  
  /// 拍照
  Future<String?> takePicture({
    bool frontCamera = false,
    int quality = 85,
  }) async {
    try {
      final result = await _channel.invokeMethod<String>(
        'takePicture',
        {
          'frontCamera': frontCamera,
          'quality': quality,
        },
      );
      return result;
    } on PlatformException catch (e) {
      throw CameraException('拍照失败: ${e.message}');
    }
  }
  
  /// 录制视频
  Future<String?> recordVideo({
    int maxDuration = 60,
    String quality = 'high',
  }) async {
    try {
      final result = await _channel.invokeMethod<String>(
        'recordVideo',
        {
          'maxDuration': maxDuration,
          'quality': quality,
        },
      );
      return result;
    } on PlatformException catch (e) {
      throw CameraException('录制失败: ${e.message}');
    }
  }
}
 
class CameraException implements Exception {
  final String message;
  CameraException(this.message);
  
  @override
  String toString() => 'CameraException: $message';
}

// ios/Runner/CameraPlugin.swift
import Flutter
import UIKit
import AVFoundation
import Photos
 
class CameraPlugin: NSObject, FlutterPlugin {
  
  static func register(with registrar: FlutterPluginRegistrar) {
    let channel = FlutterMethodChannel(
      name: "com.myapp/camera",
      binaryMessenger: registrar.messenger()
    )
    let instance = CameraPlugin()
    registrar.addMethodCallDelegate(instance, channel: channel)
  }
  
  func handle(
    _ call: FlutterMethodCall,
    result: @escaping FlutterResult
  ) {
    switch call.method {
    case "checkPermission":
      checkPermission(result: result)
    case "requestPermission":
      requestPermission(result: result)
    case "takePicture":
      let args = call.arguments as? [String: Any] ?? [:]
      takePicture(args: args, result: result)
    case "recordVideo":
      let args = call.arguments as? [String: Any] ?? [:]
      recordVideo(args: args, result: result)
    default:
      result(FlutterMethodNotImplemented)
    }
  }
  
  private func checkPermission(result: @escaping FlutterResult) {
    let status = AVCaptureDevice.authorizationStatus(for: .video)
    result(status == .authorized)
  }
  
  private func requestPermission(result: @escaping FlutterResult) {
    AVCaptureDevice.requestAccess(for: .video) { granted in
      DispatchQueue.main.async {
        result(granted)
      }
    }
  }
  
  private func takePicture(
    args: [String: Any],
    result: @escaping FlutterResult
  ) {
    let frontCamera = args["frontCamera"] as? Bool ?? false
    let quality = args["quality"] as? Int ?? 85
    
    guard let viewController = UIApplication.shared
      .keyWindow?.rootViewController else {
      result(FlutterError(
        code: "NO_VIEW_CONTROLLER",
        message: "无法获取视图控制器",
        details: nil
      ))
      return
    }
    
    let picker = UIImagePickerController()
    picker.sourceType = .camera
    picker.cameraDevice = frontCamera ? .front : .rear
    picker.allowsEditing = false
    
    // 使用闭包处理拍照结果
    let delegate = ImagePickerDelegate { image in
      if let image = image,
         let data = image.jpegData(
           compressionQuality: CGFloat(quality) / 100.0
         ) {
        let tempDir = NSTemporaryDirectory()
        let fileName = "photo_\(Int(Date().timeIntervalSince1970)).jpg"
        let filePath = (tempDir as NSString)
          .appendingPathComponent(fileName)
        
        do {
          try data.write(to: URL(fileURLWithPath: filePath))
          result(filePath)
        } catch {
          result(FlutterError(
            code: "SAVE_ERROR",
            message: "保存照片失败",
            details: error.localizedDescription
          ))
        }
      } else {
        result(nil)
      }
    }
    
    picker.delegate = delegate
    // 保持 delegate 引用
    objc_setAssociatedObject(
      picker, "delegate", delegate,
      .OBJC_ASSOCIATION_RETAIN_NONATOMIC
    )
    
    viewController.present(picker, animated: true)
  }
  
  private func recordVideo(
    args: [String: Any],
    result: @escaping FlutterResult
  ) {
    let maxDuration = args["maxDuration"] as? Int ?? 60
    let quality = args["quality"] as? String ?? "high"
    
    // 视频录制实现...
    result(FlutterMethodNotImplemented)
  }
}
 
// 图片选择器代理
class ImagePickerDelegate: NSObject,
  UIImagePickerControllerDelegate,
  UINavigationControllerDelegate {
  
  let completion: (UIImage?) -> Void
  
  init(completion: @escaping (UIImage?) -> Void) {
    self.completion = completion
  }
  
  func imagePickerController(
    _ picker: UIImagePickerController,
    didFinishPickingMediaWithInfo info: [
      UIImagePickerController.InfoKey: Any
    ]
  ) {
    let image = info[.originalImage] as? UIImage
    picker.dismiss(animated: true) {
      self.completion(image)
    }
  }
  
  func imagePickerControllerDidCancel(
    _ picker: UIImagePickerController
  ) {
    picker.dismiss(animated: true) {
      self.completion(nil)
    }
  }
}

// android/app/src/main/kotlin/.../CameraPlugin.kt
package com.myapp.camera
 
import android.Manifest
import android.app.Activity
import android.content.Intent
import android.content.pm.PackageManager
import android.net.Uri
import android.os.Environment
import android.provider.MediaStore
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.core.content.FileProvider
import io.flutter.embedding.engine.plugins.FlutterPlugin
import io.flutter.embedding.engine.plugins.activity.ActivityAware
import io.flutter.embedding.engine.plugins.activity.ActivityPluginBinding
import io.flutter.plugin.common.MethodCall
import io.flutter.plugin.common.MethodChannel
import io.flutter.plugin.common.PluginRegistry
import java.io.File
import java.text.SimpleDateFormat
import java.util.*
 
class CameraPlugin : FlutterPlugin, MethodChannel.MethodCallHandler,
  ActivityAware, PluginRegistry.ActivityResultListener,
  PluginRegistry.RequestPermissionsResultListener {
 
  private lateinit var channel: MethodChannel
  private var activity: Activity? = null
  private var pendingResult: MethodChannel.Result? = null
  private var currentPhotoPath: String? = null
 
  companion object {
    private const val CHANNEL_NAME = "com.myapp/camera"
    private const val REQUEST_CAMERA_PERMISSION = 1001
    private const val REQUEST_TAKE_PICTURE = 1002
    private const val REQUEST_RECORD_VIDEO = 1003
  }
 
  override fun onAttachedToEngine(
    binding: FlutterPlugin.FlutterPluginBinding
  ) {
    channel = MethodChannel(binding.binaryMessenger, CHANNEL_NAME)
    channel.setMethodCallHandler(this)
  }
 
  override fun onDetachedFromEngine(
    binding: FlutterPlugin.FlutterPluginBinding
  ) {
    channel.setMethodCallHandler(null)
  }
 
  override fun onMethodCall(call: MethodCall, result: MethodChannel.Result) {
    when (call.method) {
      "checkPermission" -> checkPermission(result)
      "requestPermission" -> requestPermission(result)
      "takePicture" -> {
        val frontCamera = call.argument<Boolean>("frontCamera") ?: false
        val quality = call.argument<Int>("quality") ?: 85
        takePicture(frontCamera, quality, result)
      }
      "recordVideo" -> {
        val maxDuration = call.argument<Int>("maxDuration") ?: 60
        val quality = call.argument<String>("quality") ?: "high"
        recordVideo(maxDuration, quality, result)
      }
      else -> result.notImplemented()
    }
  }
 
  private fun checkPermission(result: MethodChannel.Result) {
    val granted = ContextCompat.checkSelfPermission(
      activity!!,
      Manifest.permission.CAMERA
    ) == PackageManager.PERMISSION_GRANTED
    result.success(granted)
  }
 
  private fun requestPermission(result: MethodChannel.Result) {
    pendingResult = result
    ActivityCompat.requestPermissions(
      activity!!,
      arrayOf(Manifest.permission.CAMERA),
      REQUEST_CAMERA_PERMISSION
    )
  }
 
  private fun takePicture(
    frontCamera: Boolean,
    quality: Int,
    result: MethodChannel.Result
  ) {
    pendingResult = result
    
    val photoFile = createImageFile()
    currentPhotoPath = photoFile.absolutePath
    
    val photoUri = FileProvider.getUriForFile(
      activity!!,
      "${activity!!.packageName}.fileprovider",
      photoFile
    )
    
    val intent = Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply {
      putExtra(MediaStore.EXTRA_OUTPUT, photoUri)
      if (frontCamera) {
        putExtra(
          "android.intent.extras.CAMERA_FACING",
          android.hardware.Camera.CameraInfo.CAMERA_FACING_FRONT
        )
      }
    }
    
    activity?.startActivityForResult(intent, REQUEST_TAKE_PICTURE)
  }
 
  private fun recordVideo(
    maxDuration: Int,
    quality: String,
    result: MethodChannel.Result
  ) {
    pendingResult = result
    
    val intent = Intent(MediaStore.ACTION_VIDEO_CAPTURE).apply {
      putExtra(MediaStore.EXTRA_DURATION_LIMIT, maxDuration)
      putExtra(
        MediaStore.EXTRA_VIDEO_QUALITY,
        if (quality == "high") 1 else 0
      )
    }
    
    activity?.startActivityForResult(intent, REQUEST_RECORD_VIDEO)
  }
 
  private fun createImageFile(): File {
    val timeStamp = SimpleDateFormat(
      "yyyyMMdd_HHmmss", Locale.getDefault()
    ).format(Date())
    val storageDir = activity!!.getExternalFilesDir(
      Environment.DIRECTORY_PICTURES
    )
    return File.createTempFile("PHOTO_${timeStamp}_", ".jpg", storageDir)
  }
 
  // ActivityAware 接口实现
  override fun onAttachedToActivity(binding: ActivityPluginBinding) {
    activity = binding.activity
    binding.addActivityResultListener(this)
    binding.addRequestPermissionsResultListener(this)
  }
 
  override fun onDetachedFromActivity() {
    activity = null
  }
 
  override fun onReattachedToActivityForConfigChanges(
    binding: ActivityPluginBinding
  ) {
    activity = binding.activity
  }
 
  override fun onDetachedFromActivityForConfigChanges() {
    activity = null
  }
 
  // 处理权限请求结果
  override fun onRequestPermissionsResult(
    requestCode: Int,
    permissions: Array<out String>,
    grantResults: IntArray
  ): Boolean {
    if (requestCode == REQUEST_CAMERA_PERMISSION) {
      val granted = grantResults.isNotEmpty() &&
        grantResults[0] == PackageManager.PERMISSION_GRANTED
      pendingResult?.success(granted)
      pendingResult = null
      return true
    }
    return false
  }
 
  // 处理 Activity 结果
  override fun onActivityResult(
    requestCode: Int,
    resultCode: Int,
    data: Intent?
  ): Boolean {
    when (requestCode) {
      REQUEST_TAKE_PICTURE -> {
        if (resultCode == Activity.RESULT_OK) {
          pendingResult?.success(currentPhotoPath)
        } else {
          pendingResult?.success(null)
        }
        pendingResult = null
        return true
      }
      REQUEST_RECORD_VIDEO -> {
        if (resultCode == Activity.RESULT_OK) {
          val videoUri = data?.data
          pendingResult?.success(videoUri?.path)
        } else {
          pendingResult?.success(null)
        }
        pendingResult = null
        return true
      }
    }
    return false
  }
}

// lib/services/sensor_service.dart
import 'dart:async';
import 'package:flutter/services.dart';
 
class SensorService {
  static const _eventChannel = EventChannel('com.myapp/sensors');
  static const _methodChannel = MethodChannel('com.myapp/sensors/control');
  
  Stream<SensorData>? _sensorStream;
  
  /// 获取传感器数据流
  Stream<SensorData> get sensorStream {
    _sensorStream ??= _eventChannel
        .receiveBroadcastStream()
        .map((event) {
      final map = Map<String, dynamic>.from(event as Map);
      return SensorData.fromMap(map);
    });
    return _sensorStream!;
  }
  
  /// 启动传感器监听
  Future<void> startListening({
    int intervalMs = 100,
    List<String> sensors = const ['accelerometer', 'gyroscope'],
  }) async {
    await _methodChannel.invokeMethod('startListening', {
      'intervalMs': intervalMs,
      'sensors': sensors,
    });
  }
  
  /// 停止传感器监听
  Future<void> stopListening() async {
    await _methodChannel.invokeMethod('stopListening');
  }
}
 
class SensorData {
  final String type;
  final double x;
  final double y;
  final double z;
  final int timestamp;
  
  SensorData({
    required this.type,
    required this.x,
    required this.y,
    required this.z,
    required this.timestamp,
  });
  
  factory SensorData.fromMap(Map<String, dynamic> map) {
    return SensorData(
      type: map['type'] as String,
      x: (map['x'] as num).toDouble(),
      y: (map['y'] as num).toDouble(),
      z: (map['z'] as num).toDouble(),
      timestamp: map['timestamp'] as int,
    );
  }
}

// ios/Runner/SensorPlugin.swift
import Flutter
import CoreMotion
 
class SensorPlugin: NSObject, FlutterPlugin, FlutterStreamHandler {
  
  private let motionManager = CMMotionManager()
  private var eventSink: FlutterEventSink?
  private var updateInterval: TimeInterval = 0.1
  
  static func register(with registrar: FlutterPluginRegistrar) {
    // EventChannel
    let eventChannel = FlutterEventChannel(
      name: "com.myapp/sensors",
      binaryMessenger: registrar.messenger()
    )
    
    // MethodChannel（控制）
    let methodChannel = FlutterMethodChannel(
      name: "com.myapp/sensors/control",
      binaryMessenger: registrar.messenger()
    )
    
    let instance = SensorPlugin()
    eventChannel.setStreamHandler(instance)
    methodChannel.setMethodCallHandler(instance.handleMethod)
  }
  
  // FlutterStreamHandler - 开始监听
  func onListen(
    withArguments arguments: Any?,
    eventSink events: @escaping FlutterEventSink
  ) -> FlutterError? {
    self.eventSink = events
    startSensors()
    return nil
  }
  
  // FlutterStreamHandler - 停止监听
  func onCancel(withArguments arguments: Any?) -> FlutterError? {
    eventSink = nil
    stopSensors()
    return nil
  }
  
  private func startSensors() {
    // 加速度计
    if motionManager.isAccelerometerAvailable {
      motionManager.accelerometerUpdateInterval = updateInterval
      motionManager.startAccelerometerUpdates(
        to: .main
      ) { [weak self] data, error in
        guard let data = data, let sink = self?.eventSink else { return }
        sink([
          "type": "accelerometer",
          "x": data.acceleration.x,
          "y": data.acceleration.y,
          "z": data.acceleration.z,
          "timestamp": Int(Date().timeIntervalSince1970 * 1000),
        ])
      }
    }
    
    // 陀螺仪
    if motionManager.isGyroAvailable {
      motionManager.gyroUpdateInterval = updateInterval
      motionManager.startGyroUpdates(to: .main) { [weak self] data, error in
        guard let data = data, let sink = self?.eventSink else { return }
        sink([
          "type": "gyroscope",
          "x": data.rotationRate.x,
          "y": data.rotationRate.y,
          "z": data.rotationRate.z,
          "timestamp": Int(Date().timeIntervalSince1970 * 1000),
        ])
      }
    }
  }
  
  private func stopSensors() {
    motionManager.stopAccelerometerUpdates()
    motionManager.stopGyroUpdates()
  }
  
  func handleMethod(
    call: FlutterMethodCall,
    result: @escaping FlutterResult
  ) {
    switch call.method {
    case "startListening":
      let args = call.arguments as? [String: Any] ?? [:]
      let intervalMs = args["intervalMs"] as? Int ?? 100
      updateInterval = TimeInterval(intervalMs) / 1000.0
      startSensors()
      result(nil)
    case "stopListening":
      stopSensors()
      result(nil)
    default:
      result(FlutterMethodNotImplemented)
    }
  }
}

// pigeons/camera_api.dart
import 'package:pigeon/pigeon.dart';
 
@ConfigurePigeon(PigeonOptions(
  dartOut: 'lib/src/generated/camera_api.g.dart',
  kotlinOut: 'android/app/src/main/kotlin/com/myapp/CameraApi.g.kt',
  kotlinOptions: KotlinOptions(package: 'com.myapp'),
  swiftOut: 'ios/Runner/CameraApi.g.swift',
))
 
/// 相机配置
class CameraConfig {
  final bool frontCamera;
  final int quality;
  final int maxWidth;
  final int maxHeight;
  
  CameraConfig({
    required this.frontCamera,
    required this.quality,
    required this.maxWidth,
    required this.maxHeight,
  });
}
 
/// 拍照结果
class PhotoResult {
  final String path;
  final int width;
  final int height;
  final int fileSize;
  
  PhotoResult({
    required this.path,
    required this.width,
    required this.height,
    required this.fileSize,
  });
}
 
/// 相机权限状态
enum PermissionStatus {
  granted,
  denied,
  restricted,
  permanentlyDenied,
}
 
/// 原生 → Dart 的 API（原生实现，Dart 调用）
@HostApi()
abstract class CameraHostApi {
  @async
  PermissionStatus checkPermission();
  
  @async
  PermissionStatus requestPermission();
  
  @async
  PhotoResult takePicture(CameraConfig config);
  
  @async
  String recordVideo(int maxDurationSeconds);
  
  bool isCameraAvailable();
}
 
/// Dart → 原生的回调（Dart 实现，原生调用）
@FlutterApi()
abstract class CameraFlutterApi {
  void onCameraError(String errorCode, String message);
  void onRecordingProgress(int durationMs);
}

# 生成桥接代码
dart run pigeon --input pigeons/camera_api.dart
 
# 生成的文件：
# - lib/src/generated/camera_api.g.dart    （Dart 接口）
# - ios/Runner/CameraApi.g.swift           （Swift 接口）
# - android/.../CameraApi.g.kt             （Kotlin 接口）

// ios/Runner/CameraApiImpl.swift
import Flutter
 
class CameraHostApiImpl: CameraHostApi {
  
  func checkPermission(
    completion: @escaping (Result<PermissionStatus, Error>) -> Void
  ) {
    let status = AVCaptureDevice.authorizationStatus(for: .video)
    switch status {
    case .authorized:
      completion(.success(.granted))
    case .denied:
      completion(.success(.denied))
    case .restricted:
      completion(.success(.restricted))
    case .notDetermined:
      completion(.success(.denied))
    @unknown default:
      completion(.success(.denied))
    }
  }
  
  func requestPermission(
    completion: @escaping (Result<PermissionStatus, Error>) -> Void
  ) {
    AVCaptureDevice.requestAccess(for: .video) { granted in
      DispatchQueue.main.async {
        completion(.success(granted ? .granted : .denied))
      }
    }
  }
  
  func takePicture(
    config: CameraConfig,
    completion: @escaping (Result<PhotoResult, Error>) -> Void
  ) {
    // 实现拍照逻辑...
    let result = PhotoResult(
      path: "/tmp/photo.jpg",
      width: Int64(config.maxWidth),
      height: Int64(config.maxHeight),
      fileSize: 1024 * 100
    )
    completion(.success(result))
  }
  
  func recordVideo(
    maxDurationSeconds: Int64,
    completion: @escaping (Result<String, Error>) -> Void
  ) {
    // 实现录制逻辑...
    completion(.success("/tmp/video.mp4"))
  }
  
  func isCameraAvailable() throws -> Bool {
    return UIImagePickerController.isSourceTypeAvailable(.camera)
  }
}
 
// 在 AppDelegate 中注册
// CameraHostApiSetup.setUp(
//   binaryMessenger: controller.binaryMessenger,
//   api: CameraHostApiImpl()
// )

// lib/src/native/image_ffi.dart
import 'dart:ffi';
import 'dart:io';
import 'package:ffi/ffi.dart';
 
// 定义 C 函数签名
typedef NativeResizeImage = Int32 Function(
  Pointer<Utf8> inputPath,
  Pointer<Utf8> outputPath,
  Int32 width,
  Int32 height,
  Int32 quality,
);
 
typedef DartResizeImage = int Function(
  Pointer<Utf8> inputPath,
  Pointer<Utf8> outputPath,
  int width,
  int height,
  int quality,
);
 
class ImageFFI {
  late final DynamicLibrary _lib;
  late final DartResizeImage _resizeImage;
  
  ImageFFI() {
    // 加载原生库
    if (Platform.isAndroid) {
      _lib = DynamicLibrary.open('libimage_processor.so');
    } else if (Platform.isIOS) {
      _lib = DynamicLibrary.process();
    }
    
    // 绑定函数
    _resizeImage = _lib
        .lookupFunction<NativeResizeImage, DartResizeImage>(
          'resize_image',
        );
  }
  
  /// 调整图片大小（高性能，直接调用 C 代码）
  int resizeImage(
    String inputPath,
    String outputPath,
    int width,
    int height, {
    int quality = 85,
  }) {
    final inputPtr = inputPath.toNativeUtf8();
    final outputPtr = outputPath.toNativeUtf8();
    
    try {
      return _resizeImage(
        inputPtr, outputPtr, width, height, quality,
      );
    } finally {
      calloc.free(inputPtr);
      calloc.free(outputPtr);
    }
  }
}

请为 Flutter 应用创建一个原生模块 [模块名称]，使用 Platform Channels：

## 功能需求
[详细描述需要的原生功能]

## Channel 类型选择
- MethodChannel：[列出请求-响应式方法]
- EventChannel：[列出持续事件流]

## 接口定义
- [方法1]([参数]) → [返回值]：[描述]
- [事件流1]：[事件数据格式] - [触发条件]

## 要求
1. 生成 Dart 服务类（lib/services/[name]_service.dart）
2. 生成 iOS 实现（Swift，FlutterPlugin）
3. 生成 Android 实现（Kotlin，FlutterPlugin）
4. 包含完整的错误处理（PlatformException）
5. EventChannel 使用 Stream API
6. 在 AppDelegate / MainActivity 中注册插件
7. 包含使用示例（Widget 中调用）

## 平台权限
- iOS Info.plist 需要的权限描述
- Android AndroidManifest.xml 需要的权限

请使用 Flutter Pigeon 为 [功能名称] 生成类型安全的桥接代码：

## API 定义
### 数据模型
- [Model1]: { [字段列表] }
- [Model2]: { [字段列表] }

### HostApi（原生实现，Dart 调用）
- [方法1]([参数]) → [返回值]
- [方法2]([参数]) → [返回值]

### FlutterApi（Dart 实现，原生回调）
- [回调1]([参数])
- [回调2]([参数])

## 要求
1. 生成 Pigeon 定义文件（pigeons/[name]_api.dart）
2. 生成 Swift 实现类
3. 生成 Kotlin 实现类
4. 生成 Dart 封装服务类
5. 包含 @ConfigurePigeon 配置
6. 异步方法使用 @async 注解
7. 包含枚举类型定义

1. 在 Xcode 中打开项目
2. 激活 Claude Agent（Xcode → Preferences → AI → Claude Agent）
3. 描述原生模块需求：

   "创建一个 Swift 原生模块，封装 CoreBluetooth 框架，
    提供以下功能：
    - 扫描附近的 BLE 设备
    - 连接到指定设备
    - 读写 GATT 特征值
    - 监听特征值变化通知
    
    模块需要：
    - 使用 Expo Modules API 暴露给 React Native
    - 处理蓝牙权限请求
    - 支持后台蓝牙模式
    - 包含完整的错误处理"

4. Agent 自主执行：
   - 分析项目结构
   - 创建 Swift 文件
   - 配置 Info.plist 权限
   - 编写 Expo Module 定义
   - 构建验证
   - 修复编译错误

5. 开发者在里程碑处审查代码

在 Android Studio 的 Gemini 面板中：

"请帮我创建一个 Kotlin 原生模块，封装 Android 的推送通知功能：

1. 使用 Firebase Cloud Messaging (FCM)
2. 支持前台和后台通知处理
3. 支持通知渠道（Notification Channels）管理
4. 支持自定义通知样式（大图、进度条、操作按钮）
5. 使用 Expo Modules API 暴露给 React Native
6. 包含 AndroidManifest.xml 权限配置
7. 处理 Android 13+ 的通知权限请求

请生成完整的 Kotlin 代码和配置文件。"