com.facebook.react.modules.core

Class Timing

java.lang.Object

com.facebook.react.bridge.BaseJavaModule

com.facebook.react.bridge.ReactContextBaseJavaModule

com.facebook.react.modules.core.Timing

All Implemented Interfaces:

LifecycleEventListener, NativeModule, OnExecutorUnregisteredListener, HeadlessJsTaskEventListener

public final class Timing
extends ReactContextBaseJavaModule
implements LifecycleEventListener, OnExecutorUnregisteredListener, HeadlessJsTaskEventListener

Native module for JS timer execution. Timers fire on frame boundaries.

Nested Class Summary

Nested classes/interfaces inherited from class com.facebook.react.bridge.BaseJavaModule

BaseJavaModule.JavaMethod

Nested classes/interfaces inherited from interface com.facebook.react.bridge.NativeModule

NativeModule.NativeMethod

Field Summary

Fields

Modifier and Type	Field and Description
protected static java.lang.String	NAME

Fields inherited from class com.facebook.react.bridge.BaseJavaModule

METHOD_TYPE_ASYNC, METHOD_TYPE_PROMISE, METHOD_TYPE_SYNC

Constructor Summary

Constructors

Constructor and Description
Timing(ReactApplicationContext reactContext, DevSupportManager devSupportManager)

Method Summary

Modifier and Type	Method and Description
void	createTimer(ExecutorToken executorToken, int callbackID, int duration, double jsSchedulingTime, boolean repeat)
void	deleteTimer(ExecutorToken executorToken, int timerId)
java.lang.String	getName()
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	onExecutorDestroyed(ExecutorToken executorToken)
void	onHeadlessJsTaskFinish(int taskId) Called when a JS task finishes (i.e.
void	onHeadlessJsTaskStart(int taskId) Called when a JS task is started, on the UI thread.
void	onHostDestroy() Called when host activity receives destroy event (e.g.
void	onHostPause() Called when host activity receives pause event (e.g.
void	onHostResume() Called either when the host activity receives a resume event (e.g.
void	setSendIdleEvents(ExecutorToken executorToken, boolean sendIdleEvents)
boolean	supportsWebWorkers() In order to support web workers, a module must be aware that it can be invoked from multiple different JS VMs.

Methods inherited from class com.facebook.react.bridge.ReactContextBaseJavaModule

getCurrentActivity, getReactApplicationContext

Methods inherited from class com.facebook.react.bridge.BaseJavaModule

canOverrideExistingModule, getConstants, getMethods

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

NAME

protected static final java.lang.String NAME

See Also:

Constant Field Values

Constructor Detail

Timing

public Timing(ReactApplicationContext reactContext,
              DevSupportManager devSupportManager)

Method Detail

initialize

public void initialize()

Description copied from interface: NativeModule

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.

Specified by:

initialize in interface NativeModule

Overrides:

initialize in class BaseJavaModule

onHostPause

public void onHostPause()

Description copied from interface: LifecycleEventListener

Called when host activity receives pause event (e.g. Activity#onPause. Always called for the most current activity.

Specified by:

onHostPause in interface LifecycleEventListener

onHostDestroy

public void onHostDestroy()

Description copied from interface: LifecycleEventListener

Called when host activity receives destroy event (e.g. Activity#onDestroy. Only called for the last React activity to be destroyed.

Specified by:

onHostDestroy in interface LifecycleEventListener

onHostResume

public void onHostResume()

Description copied from interface: LifecycleEventListener

Called either when the host activity receives a resume event (e.g. Activity#onResume or if the native module that implements this is initialized while the host activity is already resumed. Always called for the most current activity.

Specified by:

onHostResume in interface LifecycleEventListener

onHeadlessJsTaskStart

public void onHeadlessJsTaskStart(int taskId)

Description copied from interface: HeadlessJsTaskEventListener

Called when a JS task is started, on the UI thread.

Specified by:

onHeadlessJsTaskStart in interface HeadlessJsTaskEventListener

Parameters:

taskId - the unique identifier of this task instance

onHeadlessJsTaskFinish

public void onHeadlessJsTaskFinish(int taskId)

Description copied from interface: HeadlessJsTaskEventListener

Called when a JS task finishes (i.e. when HeadlessJsTaskSupportModule#notifyTaskFinished is called, or when it times out), on the UI thread.

Specified by:

onHeadlessJsTaskFinish in interface HeadlessJsTaskEventListener

onCatalystInstanceDestroy

public void onCatalystInstanceDestroy()

Description copied from interface: NativeModule

Called before {CatalystInstance#onHostDestroy}

Specified by:

onCatalystInstanceDestroy in interface NativeModule

Overrides:

onCatalystInstanceDestroy in class BaseJavaModule

getName

public java.lang.String getName()

Specified by:

getName in interface NativeModule

Returns:

the name of this module. This will be the name used to require() this module from javascript.

supportsWebWorkers

public boolean supportsWebWorkers()

Description copied from interface: NativeModule

In order to support web workers, a module must be aware that it can be invoked from multiple different JS VMs. Supporting web workers means recognizing things like: 1) ids (e.g. timer ids, request ids, etc.) may only unique on a per-VM basis 2) the module needs to make sure to enqueue callbacks and JS module calls to the correct VM In order to facilitate this, modules that support web workers will have all their @ReactMethod- annotated methods passed a 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.

Specified by:

supportsWebWorkers in interface NativeModule

Overrides:

supportsWebWorkers in class BaseJavaModule

Returns:

whether this module supports web workers.

onExecutorDestroyed

public void onExecutorDestroyed(ExecutorToken executorToken)

Specified by:

onExecutorDestroyed in interface OnExecutorUnregisteredListener

createTimer

public void createTimer(ExecutorToken executorToken,
                        int callbackID,
                        int duration,
                        double jsSchedulingTime,
                        boolean repeat)

deleteTimer

public void deleteTimer(ExecutorToken executorToken,
                        int timerId)

setSendIdleEvents

public void setSendIdleEvents(ExecutorToken executorToken,
                              boolean sendIdleEvents)