public abstract class BaseJavaModule extends java.lang.Object implements NativeModule
initialize()
and onCatalystInstanceDestroy()
are provided for
convenience. Subclasses which override these don't need to call super
in case of
overriding those methods as implementation of those methods is empty.
BaseJavaModules can be linked to Fragments' lifecycle events, CatalystInstance
creation
and destruction, by being called on the appropriate method when a life cycle event occurs.
Native methods can be exposed to JS with ReactMethod
annotation. Those methods may
only use limited number of types for their arguments:
1/ primitives (boolean, int, float, double
2/ String
mapped from JS string
3/ ReadableArray
mapped from JS Array
4/ ReadableMap
mapped from JS Object
5/ Callback
mapped from js function and can be used only as a last parameter or in the
case when it express success & error callback pair as two last arguments respecively.
All methods exposed as native to JS with ReactMethod
annotation must return
void
.
Please note that it is not allowed to have multiple methods annotated with ReactMethod
with the same name.Modifier and Type | Class and Description |
---|---|
class |
BaseJavaModule.JavaMethod |
class |
BaseJavaModule.SyncJavaHook |
NativeModule.NativeMethod, NativeModule.SyncNativeHook
Modifier and Type | Field and Description |
---|---|
static java.lang.String |
METHOD_TYPE_ASYNC |
static java.lang.String |
METHOD_TYPE_PROMISE |
static java.lang.String |
METHOD_TYPE_SYNC |
Constructor and Description |
---|
BaseJavaModule() |
Modifier and Type | Method and Description |
---|---|
boolean |
canOverrideExistingModule()
Return true if you intend to override some other native module that was registered e.g.
|
java.util.Map<java.lang.String,java.lang.Object> |
getConstants() |
java.util.Map<java.lang.String,NativeModule.NativeMethod> |
getMethods() |
java.util.Map<java.lang.String,NativeModule.SyncNativeHook> |
getSyncHooks() |
void |
initialize()
This is called at the end of
CatalystApplicationFragment#createCatalystInstance()
after the CatalystInstance has been created, in order to initialize NativeModules that require
the CatalystInstance or JS modules. |
void |
onCatalystInstanceDestroy()
Called before {CatalystInstance#onHostDestroy}
|
void |
onReactBridgeInitialized(ReactBridge bridge)
Called on the JS thread after a ReactBridge has been created.
|
boolean |
supportsWebWorkers()
In order to support web workers, a module must be aware that it can be invoked from multiple
different JS VMs.
|
void |
writeConstantsField(JsonWriter writer,
java.lang.String fieldName)
Append a field which represents the constants this module exports
to JS.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
getName
public static final java.lang.String METHOD_TYPE_ASYNC
public static final java.lang.String METHOD_TYPE_PROMISE
public static final java.lang.String METHOD_TYPE_SYNC
public final java.util.Map<java.lang.String,NativeModule.NativeMethod> getMethods()
getMethods
in interface NativeModule
@Nullable public java.util.Map<java.lang.String,java.lang.Object> getConstants()
public final java.util.Map<java.lang.String,NativeModule.SyncNativeHook> getSyncHooks()
public final void writeConstantsField(JsonWriter writer, java.lang.String fieldName) throws java.io.IOException
NativeModule
writeConstantsField
in interface NativeModule
java.io.IOException
public void initialize()
NativeModule
CatalystApplicationFragment#createCatalystInstance()
after the CatalystInstance has been created, in order to initialize NativeModules that require
the CatalystInstance or JS modules.initialize
in interface NativeModule
public boolean canOverrideExistingModule()
NativeModule
canOverrideExistingModule
in interface NativeModule
public void onReactBridgeInitialized(ReactBridge bridge)
NativeModule
onReactBridgeInitialized
in interface NativeModule
bridge
- the ReactBridge instance that has just been createdpublic void onCatalystInstanceDestroy()
NativeModule
onCatalystInstanceDestroy
in interface NativeModule
public boolean supportsWebWorkers()
NativeModule
ExecutorToken
as the first parameter before any arguments
from JS. This ExecutorToken internally maps to a specific JS VM and can be used by the
framework to route calls appropriately. In order to make JS module calls correctly, start using
the version of ReactContext.getJSModule(ExecutorToken, Class)
that takes an
ExecutorToken. It will ensure that any calls you dispatch to the returned object will go to
the right VM. For Callbacks, you don't have to do anything special -- the framework
automatically tags them with the correct ExecutorToken when the are created.
Note: even though calls can come from multiple JS VMs on multiple threads, calls to this module
will still only occur on a single thread.supportsWebWorkers
in interface NativeModule