Turbo Modules & Codegen

A Turbo Module is a set of native functions with no UI, called from JavaScript. A Fabric native component is a platform view in the React tree, configured by props, reporting through events, driven by commands. A signature pad draws on screen, so it needs a component.

Subclass the generated abstract NativeXxxSpec, passing the ReactApplicationContext to its constructor, and override every abstract method it declares, with a Promise parameter for async results and a plain return for sync ones. Then return an instance from a BaseReactPackage.

Return a Promise for one asynchronous result that can fail, declare an EventEmitter for many values over time, and treat a callback as a one-shot legacy alternative; a plain return value suits only cheap, immediate data.

The class adopts the generated NativeXxxSpec protocol, implements every selector it declares, returns the generated NativeXxxSpecJSI from getTurboModule:, returns the JavaScript name from +moduleName, and is registered in codegenConfig.ios so React Native can map that name to the class.

Name the file Native<Something>.ts, declare exactly one interface extending TurboModule named Spec, and load it with exactly one typed TurboModuleRegistry.getEnforcing<Spec>() or get<Spec>() call whose argument is a string literal of letters, digits and underscores.

getName() returns the name a native module is known by. Legacy packages registered modules under it, as NativeModules.<name>. In a Turbo Module the Codegen-generated spec implements it from the getEnforcing name, while lookup itself runs through the package's ReactModuleInfo key and getModule.

Call the spec's emitter property as a function with a handler, for example NativeHeartRate.onHeartRate(handler); it returns an EventSubscription, and calling its remove() in the effect cleanup stops the handler when the screen unmounts.

The Codegen spec is partly C++: getTurboModule: must return a std::shared_ptr to a generated C++ JSI class, and typed object parameters arrive as C++ structs. Only an Objective-C++ (.mm) file compiles C++ and Objective-C together.

A Turbo Native Module spec is a TypeScript or Flow file, such as NativeBatteryHealth.ts, whose Spec interface declares the module's methods. At build time Codegen turns it into C++ glue, a Java spec class and an Objective-C++ protocol for native code to implement.

getReactModuleInfoProvider advertises which module names the package can supply and how to treat them (isTurboModule, needsEagerInit, canOverrideExistingModule). getModule is the lazy factory React Native calls with one of those names to create the instance the first time JavaScript asks.

The module stops extending ReactContextBaseJavaModule directly and extends the generated spec, which itself extends it and carries the @ReactMethod annotations. Registration moves from an eager ReactPackage.createNativeModules list to a lazy BaseReactPackage with getModule and a module-info map.

Codegen maps number to double, boolean to a native boolean, string to String or NSString, object literals to ReadableMap on Android and a generated struct on iOS, and a Promise return to extra native arguments that settle it.

RCT_EXPORT_MODULE's two jobs split: you write +moduleName yourself and register the class under codegenConfig.ios in package.json. RCT_EXPORT_METHOD disappears: the TypeScript spec declares each method and the class implements the matching selector from the generated protocol.

An app must contain exactly one react-native and one react. A peerDependency tells the package manager to use the app's copy and to warn when versions are incompatible, instead of installing a second copy inside the library.

getEnforcing returns the module or throws an invariant error saying it could not be found in the native binary; get returns null instead. Use get only when the module may legitimately be missing, and null-check it at every call site.

Declare a NativeCommands interface whose methods take the component ref first, export Commands = codegenNativeCommands<NativeCommands>({supportedCommands: ['clear']}) from the spec, and call Commands.clear(ref.current). Codegen routes it to the Android manager's clear(view) and iOS handleCommand:args:.

A direct event is delivered only to the component that emitted it. A bubbling event goes through capture and bubble phases, so ancestors registered for it, including onXCapture handlers, can see it too. A signature pad's onStrokeEnd concerns only the pad, so DirectEventHandler fits.

Treat ReactApplicationContext as an Application-scoped handle: use it for system services, read currentActivity only when needed and never store it, pause the sensor from a LifecycleEventListener, and unregister everything in invalidate(), which runs before the React instance is torn down.

A method that returns a value runs synchronously on the JS thread and blocks it; void and Promise methods run later on a background native-modules queue. None of them runs on the main thread, so UI work needs explicit dispatch.

Asynchronous Turbo Module methods arrive on a background method queue, so UIKit calls must be dispatched to the main queue inside the method. +requiresMainQueueSetup only decides where the module is constructed; overriding methodQueue to force every call onto main is deprecated.

Use an adapter: a Swift class that calls the vendor SDK and exposes an Objective-C-compatible surface, plus a thin Objective-C++ class that adopts the Codegen spec, owns the adapter and forwards each call, because Swift cannot implement the C++-bearing spec directly.

Confirm the binary was rebuilt after install, then print the autolinking config: if the library is missing, fix discovery; if it is listed, check the native module is registered under the exact spec name.

Codegen runs during native builds: on Android through the generateCodegenArtifactsFromSchema Gradle task, on iOS during pod install and a CocoaPods build phase. A spec is missed when misnamed or outside jsSrcsDir, or, on iOS, added without re-running pod install.

Android needs a SimpleViewManager implementing the generated XxxManagerInterface, returning the generated delegate from getDelegate(), registered in a package. iOS needs an Objective-C++ RCTViewComponentView subclass that diffs props in updateProps:oldProps:, returns its component descriptor and is mapped in codegenConfig.ios.

Adopt a community library if it supports the New Architecture, meets your requirements, fits Expo and bare apps and is maintained; build in-house only when requirements or risk justify owning two native codebases through every upgrade.

A pure C++ Turbo Module implements a typed spec once in C++ and runs on both Android and iOS. Choose it for platform-independent logic or an existing C++ library; use Kotlin and Objective-C when the work needs platform SDKs.

codegenConfig tells Codegen what to generate: name labels the generated C++ and Objective-C++ files, type selects modules, components or all, jsSrcsDir is the folder searched for specs, and android.javaPackageName sets the package of the generated Java spec classes.

WithDefault<Type, Value> sets the native default of an optional prop, used when JavaScript omits or removes it. Props without it get Codegen's type default: 0 for numbers, false for booleans, null for strings.

iOS Fabric recycles component views: an unmounted RCTViewComponentView is pooled per component type and reused by a later mount. Strokes held in the view, not in props, survive. Reset them in prepareForRecycle, or opt the class out of recycling.