Interface | Description |
---|---|
ActivityEventListener |
Listener for receiving activity events.
|
Callback |
Interface that represent javascript callback function which can be passed to the native module
as a method parameter.
|
CatalystInstance |
A higher level API on top of the asynchronous JSC bridge.
|
Dynamic |
Type representing a piece of data with unknown runtime type.
|
Inspector.RemoteConnection | |
JavaJSExecutor |
This is class represents java version of native js executor interface.
|
JavaJSExecutor.Factory | |
JavaScriptExecutorFactory | |
JavaScriptModule |
Interface denoting that a class is the interface to a module with the same name in JS.
|
JSBundleLoaderDelegate |
An interface for classes that initialize JavaScript using
JSBundleLoader |
JSIModule |
Marker interface used to represent a JSI Module.
|
JSIModulePackage |
Interface used to initialize JSI Modules into the JSI Bridge.
|
JSIModuleProvider<T extends JSIModule> | |
JSIModuleSpec<T extends JSIModule> |
Holder class used to register
JSIModule into JSI Bridge. |
JSInstance |
This interface includes the methods needed to use a running JS
instance, without specifying any of the bridge-specific
initialization or lifecycle management.
|
LifecycleEventListener |
Listener for receiving activity lifecycle events.
|
MemoryPressureListener |
Listener interface for memory pressure events.
|
NativeArrayInterface | |
NativeModule |
A native module whose API can be provided to JS catalyst instances.
|
NativeModule.NativeMethod | |
NativeModuleCallExceptionHandler |
Interface for a class that knows how to handle an Exception thrown by a native module invoked
from JS.
|
NotThreadSafeBridgeIdleDebugListener |
Interface for receiving notification for bridge idle/busy events.
|
OnBatchCompleteListener |
Interface for a module that will be notified when a batch of JS->Java calls has finished.
|
PerformanceCounter | |
Promise | |
ReactMarker.MarkerListener | |
ReactModuleWithSpec |
An interface to be implemented by react modules that extends from the
generated spec class.
|
ReadableArray |
Interface for an array that allows typed access to its members.
|
ReadableMap |
Interface for a map that allows typed access to its members.
|
ReadableMapKeySetIterator |
Interface of a iterator for a
NativeMap 's key set. |
Systrace |
Interface to the JavaScript Systrace Module
|
UIManager | |
WritableArray |
Interface for a mutable array.
|
WritableMap |
Interface for a mutable map.
|
Class | Description |
---|---|
Arguments | |
BaseActivityEventListener |
An empty implementation of
ActivityEventListener |
BaseJavaModule |
Base class for Catalyst native modules whose implementations are written in Java.
|
CallbackImpl |
Implementation of javascript callback function that use Bridge to schedule method execution
|
CatalystInstanceImpl |
This provides an implementation of the public CatalystInstance instance.
|
CatalystInstanceImpl.Builder | |
CatalystInstanceImpl.PendingJSCall | |
ContextBaseJavaModule |
Base class for React native modules that require access to an Android
Context instance. |
CxxCallbackImpl |
Callback impl that calls directly into the cxx bridge.
|
CxxModuleWrapper |
This does nothing interesting, except avoid breaking existing code.
|
CxxModuleWrapperBase |
A Java Object which represents a cross-platform C++ module
This module implements the NativeModule interface but will never be invoked from Java,
instead the underlying Cxx module will be extracted by the bridge and called directly.
|
DefaultNativeModuleCallExceptionHandler |
Crashy crashy exception handler.
|
DynamicFromArray |
Implementation of Dynamic wrapping a ReadableArray.
|
DynamicFromMap |
Implementation of Dynamic wrapping a ReadableMap.
|
FallbackJSBundleLoader |
FallbackJSBundleLoader
An implementation of
JSBundleLoader that will try to load from
multiple sources, falling back from one source to the next at load time
when an exception is thrown for a recoverable error. |
GuardedAsyncTask<Params,Progress> |
Abstract base for a AsyncTask that should have any RuntimeExceptions it throws
handled by the
NativeModuleCallExceptionHandler registered if
the app is in dev mode. |
GuardedResultAsyncTask<Result> |
Abstract base for a AsyncTask with result support that should have any RuntimeExceptions it
throws handled by the
NativeModuleCallExceptionHandler
registered if the app is in dev mode. |
GuardedRunnable |
Abstract base for a Runnable that should have any RuntimeExceptions it throws
handled by the
NativeModuleCallExceptionHandler registered if
the app is in dev mode. |
Inspector | |
Inspector.LocalConnection | |
Inspector.Page | |
JavaMethodWrapper | |
JavaModuleWrapper |
This is part of the glue which wraps a java BaseJavaModule in a C++
NativeModule.
|
JavaOnlyArray |
Java
ArrayList backed implementation of ReadableArray and WritableArray
Instances of this class SHOULD NOT be used for communication between java and JS, use instances
of WritableNativeArray created via Arguments.createArray() or just
ReadableArray interface if you want your "native" module method to take an array from JS
as an argument. |
JavaOnlyMap |
Java
HashMap backed implementation of ReadableMap and WritableMap
Instances of this class SHOULD NOT be used for communication between java and JS, use instances
of WritableNativeMap created via Arguments.createMap() or just ReadableMap
interface if you want your "native" module method to take a map from JS as an argument. |
JavaScriptContextHolder |
Wrapper for JavaScriptContext native pointer.
|
JavaScriptExecutor | |
JavaScriptModuleRegistry |
Class responsible for holding all the
JavaScriptModule s. |
JSBundleLoader |
A class that stores JS bundle information and allows a
JSBundleLoaderDelegate
(e.g. |
JSCJavaScriptExecutorFactory | |
JSIModuleHolder | |
JSIModuleRegistry | |
JsonWriter |
Simple Json generator that does no validation.
|
ModuleHolder |
Holder to enable us to lazy create native modules.
|
ModuleSpec |
A specification for a native module.
|
NativeArray |
Base class for an array whose members are stored in native code (C++).
|
NativeDeltaClient | |
NativeMap |
Base class for a Map whose keys and values are stored in native code (C++).
|
NativeModuleRegistry |
A set of Java APIs to expose to a particular JavaScript instance.
|
PromiseImpl | |
ProxyJavaScriptExecutor |
JavaScript executor that delegates JS calls processed by native code back to a java version
of the native executor interface.
|
ProxyJavaScriptExecutor.Factory | |
ReactApplicationContext |
A context wrapper that always wraps Android Application
Context and
CatalystInstance by extending ReactContext |
ReactBridge | |
ReactContext |
Abstract ContextWrapper for Android application or activity
Context and
CatalystInstance |
ReactContextBaseJavaModule |
Base class for Catalyst native modules that require access to the
ReactContext
instance. |
ReactMarker |
Static class that allows markers to be placed in React code and responded to in a
configurable way
|
ReadableNativeArray |
Implementation of a NativeArray that allows read-only access to its members.
|
ReadableNativeMap |
Implementation of a read-only map in native memory.
|
SoftAssertions |
Utility class to make assertions that should not hard-crash the app but instead be handled by the
Catalyst app
NativeModuleCallExceptionHandler . |
UiThreadUtil |
Utility for interacting with the UI thread.
|
WritableNativeArray |
Implementation of a write-only array stored in native memory.
|
WritableNativeMap |
Implementation of a write-only map stored in native memory.
|
Enum | Description |
---|---|
MemoryPressure | |
ReactMarkerConstants |
Constants used by ReactMarker.
|
ReadableType |
Defines the type of an object stored in a
ReadableArray or
ReadableMap . |
Exception | Description |
---|---|
AssertionException |
Like
AssertionError but extends RuntimeException so that it may be caught by a
NativeModuleCallExceptionHandler . |
InvalidIteratorException |
Exception thrown by
ReadableMapKeySetIterator.nextKey() when the iterator tries
to iterate over elements after the end of the key set. |
JavaJSExecutor.ProxyExecutorException | |
JSApplicationCausedNativeException |
A special RuntimeException that should be thrown by native code if it has reached an exceptional
state due to a, or a sequence of, bad commands.
|
JSApplicationIllegalArgumentException |
An illegal argument Exception caused by an argument passed from JS.
|
NativeArgumentsParseException |
Exception thrown when a native module method call receives unexpected arguments from JS.
|
NoSuchKeyException |
Exception thrown by
ReadableNativeMap when a key that does not exist is requested. |
ObjectAlreadyConsumedException |
Exception thrown when a caller attempts to modify or use a
WritableNativeArray or
WritableNativeMap after it has already been added to a parent array or map. |
UnexpectedNativeTypeException |
Exception thrown from native code when a type retrieved from a map or array (e.g.
|
Annotation Type | Description |
---|---|
ReactMethod |
Annotation which is used to mark methods that are exposed to React Native.
|