Java LifecycleState.RESUMED属性代码示例

/**
 * Start a JS task. Handles invoking {@link AppRegistry#startHeadlessTask} and notifying
 * listeners.
 *
 * @return a unique id representing this task instance.
 */
public synchronized int startTask(final HeadlessJsTaskConfig taskConfig) {
  UiThreadUtil.assertOnUiThread();
  ReactContext reactContext = Assertions.assertNotNull(
    mReactContext.get(),
    "Tried to start a task on a react context that has already been destroyed");
  if (reactContext.getLifecycleState() == LifecycleState.RESUMED &&
    !taskConfig.isAllowedInForeground()) {
    throw new IllegalStateException(
      "Tried to start task " + taskConfig.getTaskKey() +
        " while in foreground, but this is not allowed.");
  }
  final int taskId = mLastTaskId.incrementAndGet();
  mActiveTasks.add(taskId);
  reactContext.getJSModule(AppRegistry.class)
    .startHeadlessTask(taskId, taskConfig.getTaskKey(), taskConfig.getData());
  if (taskConfig.getTimeout() > 0) {
    scheduleTaskTimeout(taskId, taskConfig.getTimeout());
  }
  for (HeadlessJsTaskEventListener listener : mHeadlessJsTaskEventListeners) {
    listener.onHeadlessJsTaskStart(taskId);
  }
  return taskId;
}
 

/**
 * Start a JS task. Handles invoking {@link AppRegistry#startHeadlessTask} and notifying
 * listeners.
 *
 * @return a unique id representing this task instance.
 */
public synchronized int startTask(final HeadlessJsTaskConfig taskConfig) {
  UiThreadUtil.assertOnUiThread();
  if (mReactContext.getLifecycleState() == LifecycleState.RESUMED &&
    !taskConfig.isAllowedInForeground()) {
    throw new IllegalStateException(
      "Tried to start task " + taskConfig.getTaskKey() +
        " while in foreground, but this is not allowed.");
  }
  final int taskId = mLastTaskId.incrementAndGet();
  mReactContext.getJSModule(AppRegistry.class)
    .startHeadlessTask(taskId, taskConfig.getTaskKey(), taskConfig.getData());
  if (taskConfig.getTimeout() > 0) {
    scheduleTaskTimeout(taskId, taskConfig.getTimeout());
  }
  mActiveTasks.add(taskId);
  for (HeadlessJsTaskEventListener listener : mHeadlessJsTaskEventListeners) {
    listener.onHeadlessJsTaskStart(taskId);
  }
  return taskId;
}
 

/**
 * Should be called by the hosting Fragment in {@link Fragment#onResume}
 */
public void onHostResume(@Nullable Activity activity) {
  UiThreadUtil.assertOnUiThread();
  mLifecycleState = LifecycleState.RESUMED;
  mCurrentActivity = new WeakReference(activity);
  ReactMarker.logMarker(ReactMarkerConstants.ON_HOST_RESUME_START);
  for (LifecycleEventListener listener : mLifecycleEventListeners) {
    try {
      listener.onHostResume();
    } catch (RuntimeException e) {
      handleException(e);
    }
  }
  ReactMarker.logMarker(ReactMarkerConstants.ON_HOST_RESUME_END);
}
 

private void moveToResumedLifecycleState(boolean force) {
  if (mCurrentReactContext != null) {
    // we currently don't have an onCreate callback so we call onResume for both transitions
    if (force ||
        mLifecycleState == LifecycleState.BEFORE_RESUME ||
        mLifecycleState == LifecycleState.BEFORE_CREATE) {
      mCurrentReactContext.onHostResume(mCurrentActivity);
    }
  }
  mLifecycleState = LifecycleState.RESUMED;
}
 

private void moveToBeforeResumeLifecycleState() {
  if (mCurrentReactContext != null) {
    if (mLifecycleState == LifecycleState.BEFORE_CREATE) {
      mCurrentReactContext.onHostResume(mCurrentActivity);
      mCurrentReactContext.onHostPause();
    } else if (mLifecycleState == LifecycleState.RESUMED) {
      mCurrentReactContext.onHostPause();
    }
  }
  mLifecycleState = LifecycleState.BEFORE_RESUME;
}
 

private void moveToBeforeCreateLifecycleState() {
  if (mCurrentReactContext != null) {
    if (mLifecycleState == LifecycleState.RESUMED) {
      mCurrentReactContext.onHostPause();
      mLifecycleState = LifecycleState.BEFORE_RESUME;
    }
    if (mLifecycleState == LifecycleState.BEFORE_RESUME) {
      mCurrentReactContext.onHostDestroy();
    }
  }
  mLifecycleState = LifecycleState.BEFORE_CREATE;
}
 

private void tearDownReactContext(ReactContext reactContext) {
  UiThreadUtil.assertOnUiThread();
  if (mLifecycleState == LifecycleState.RESUMED) {
    reactContext.onHostPause();
  }
  for (ReactRootView rootView : mAttachedRootViews) {
    detachViewFromInstance(rootView, reactContext.getCatalystInstance());
  }
  reactContext.destroy();
  mDevSupportManager.onReactInstanceDestroyed(reactContext);
  mMemoryPressureRouter.removeMemoryPressureListener(reactContext.getCatalystInstance());
}
 

@Override
protected void onResume() {
  super.onResume();

  mLifecycleState = LifecycleState.RESUMED;

  if (mReactInstanceManager != null) {
    mReactInstanceManager.onHostResume(this, this);
  }
}
 

/** Check whether on not the React Native application is in foreground. */
public static boolean isReactNativeAppInForeground(@NonNull ReactNativeHost reactNativeHost) {
  if (!reactNativeHost.hasInstance()) {
    // If the app was force-stopped the instace will be destroyed. The instance can't be created from a background thread.
    return false;
  }
  ReactContext reactContext = reactNativeHost.getReactInstanceManager().getCurrentReactContext();
  return reactContext != null && reactContext.getLifecycleState() == LifecycleState.RESUMED;
}
 

/**
 * Should be called by the hosting Fragment in {@link Fragment#onResume}
 */
public void onHostResume(@Nullable Activity activity) {
  UiThreadUtil.assertOnUiThread();
  mLifecycleState = LifecycleState.RESUMED;
  mCurrentActivity = new WeakReference(activity);
  mLifecycleState = LifecycleState.RESUMED;
  for (LifecycleEventListener listener : mLifecycleEventListeners) {
    listener.onHostResume();
  }
}
 

private void moveReactContextToCurrentLifecycleState() {
  if (mLifecycleState == LifecycleState.RESUMED) {
    moveToResumedLifecycleState(true);
  }
}