react-native-tvos 0.80.1-0 → 0.81.0-0

package/ReactAndroid/src/main/java/com/facebook/react/ReactDelegate.java

@@ -1,420 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-package com.facebook.react;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.content.res.Configuration;
-import android.os.Bundle;
-import android.view.KeyEvent;
-import androidx.annotation.Nullable;
-import com.facebook.infer.annotation.Assertions;
-import com.facebook.react.bridge.ReactContext;
-import com.facebook.react.bridge.UiThreadUtil;
-import com.facebook.react.common.annotations.DeprecatedInNewArchitecture;
-import com.facebook.react.devsupport.DoubleTapReloadRecognizer;
-import com.facebook.react.devsupport.ReleaseDevSupportManager;
-import com.facebook.react.devsupport.interfaces.DevSupportManager;
-import com.facebook.react.interfaces.fabric.ReactSurface;
-import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags;
-import com.facebook.react.modules.core.DefaultHardwareBackBtnHandler;
-
-/**
- * A delegate for handling React Application support. This delegate is unaware whether it is used in
- * an {@link Activity} or a {@link android.app.Fragment}.
- */
-public class ReactDelegate {
-
-  private final Activity mActivity;
-  @Nullable private ReactRootView mReactRootView;
-
-  @Nullable private final String mMainComponentName;
-
-  @Nullable private Bundle mLaunchOptions;
-
-  @Nullable private DoubleTapReloadRecognizer mDoubleTapReloadRecognizer;
-
-  @Nullable private ReactNativeHost mReactNativeHost;
-
-  @Nullable private ReactHost mReactHost;
-
-  @Nullable private ReactSurface mReactSurface;
-
-  private boolean mFabricEnabled = ReactNativeNewArchitectureFeatureFlags.enableFabricRenderer();
-
-  /**
-   * Do not use this constructor as it's not accounting for New Architecture at all. You should
-   * either use {@link ReactDelegate#ReactDelegate(Activity, ReactHost, String, Bundle)} if you're
-   * on bridgeless mode or {@link ReactDelegate#ReactDelegate(Activity, ReactNativeHost, String,
-   * Bundle, boolean)} and use the last parameter to toggle paper/fabric.
-   *
-   * @deprecated Use one of the other constructors instead to account for New Architecture.
-   */
-  @Deprecated
-  public ReactDelegate(
-      Activity activity,
-      ReactNativeHost reactNativeHost,
-      @Nullable String appKey,
-      @Nullable Bundle launchOptions) {
-    mActivity = activity;
-    mMainComponentName = appKey;
-    mLaunchOptions = launchOptions;
-    mDoubleTapReloadRecognizer = new DoubleTapReloadRecognizer();
-    mReactNativeHost = reactNativeHost;
-  }
-
-  public ReactDelegate(
-      Activity activity,
-      ReactHost reactHost,
-      @Nullable String appKey,
-      @Nullable Bundle launchOptions) {
-    mActivity = activity;
-    mMainComponentName = appKey;
-    mLaunchOptions = launchOptions;
-    mDoubleTapReloadRecognizer = new DoubleTapReloadRecognizer();
-    mReactHost = reactHost;
-  }
-
-  public ReactDelegate(
-      Activity activity,
-      ReactNativeHost reactNativeHost,
-      @Nullable String appKey,
-      @Nullable Bundle launchOptions,
-      boolean fabricEnabled) {
-    mFabricEnabled = fabricEnabled;
-    mActivity = activity;
-    mMainComponentName = appKey;
-    mLaunchOptions = launchOptions;
-    mDoubleTapReloadRecognizer = new DoubleTapReloadRecognizer();
-    mReactNativeHost = reactNativeHost;
-  }
-
-  @Nullable
-  private DevSupportManager getDevSupportManager() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()
-        && mReactHost != null
-        && mReactHost.getDevSupportManager() != null) {
-      return mReactHost.getDevSupportManager();
-    } else if (getReactNativeHost().hasInstance()
-        && getReactNativeHost().getReactInstanceManager() != null) {
-      return getReactNativeHost().getReactInstanceManager().getDevSupportManager();
-    } else {
-      return null;
-    }
-  }
-
-  public void onHostResume() {
-    if (!(mActivity instanceof DefaultHardwareBackBtnHandler)) {
-      throw new ClassCastException(
-          "Host Activity does not implement DefaultHardwareBackBtnHandler");
-    }
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onHostResume(mActivity, (DefaultHardwareBackBtnHandler) mActivity);
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost()
-            .getReactInstanceManager()
-            .onHostResume(mActivity, (DefaultHardwareBackBtnHandler) mActivity);
-      }
-    }
-  }
-
-  public void onUserLeaveHint() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onHostLeaveHint(mActivity);
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost().getReactInstanceManager().onUserLeaveHint(mActivity);
-      }
-    }
-  }
-
-  public void onHostPause() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onHostPause(mActivity);
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost().getReactInstanceManager().onHostPause(mActivity);
-      }
-    }
-  }
-
-  public void onHostDestroy() {
-    unloadApp();
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onHostDestroy(mActivity);
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost().getReactInstanceManager().onHostDestroy(mActivity);
-      }
-    }
-  }
-
-  public boolean onBackPressed() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onBackPressed();
-      return true;
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost().getReactInstanceManager().onBackPressed();
-        return true;
-      }
-    }
-    return false;
-  }
-
-  public boolean onNewIntent(Intent intent) {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onNewIntent(intent);
-      return true;
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost().getReactInstanceManager().onNewIntent(intent);
-        return true;
-      }
-    }
-    return false;
-  }
-
-  public void onActivityResult(
-      int requestCode, int resultCode, Intent data, boolean shouldForwardToReactInstance) {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onActivityResult(mActivity, requestCode, resultCode, data);
-    } else {
-      if (getReactNativeHost().hasInstance() && shouldForwardToReactInstance) {
-        getReactNativeHost()
-            .getReactInstanceManager()
-            .onActivityResult(mActivity, requestCode, resultCode, data);
-      }
-    }
-  }
-
-  public void onWindowFocusChanged(boolean hasFocus) {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onWindowFocusChange(hasFocus);
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactNativeHost().getReactInstanceManager().onWindowFocusChange(hasFocus);
-      }
-    }
-  }
-
-  public void onConfigurationChanged(Configuration newConfig) {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactHost.onConfigurationChanged(Assertions.assertNotNull(mActivity));
-    } else {
-      if (getReactNativeHost().hasInstance()) {
-        getReactInstanceManager()
-            .onConfigurationChanged(Assertions.assertNotNull(mActivity), newConfig);
-      }
-    }
-  }
-
-  public boolean onKeyDown(int keyCode, KeyEvent event) {
-    if (keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD
-        && ((ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()
-                && mReactHost != null
-                && mReactHost.getDevSupportManager() != null)
-            || (getReactNativeHost().hasInstance()
-                && getReactNativeHost().getUseDeveloperSupport()))) {
-      event.startTracking();
-      return true;
-    }
-    return false;
-  }
-
-  public boolean onKeyLongPress(int keyCode) {
-    if (keyCode == KeyEvent.KEYCODE_MEDIA_FAST_FORWARD) {
-      if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()
-          && mReactHost != null) {
-        DevSupportManager devSupportManager = mReactHost.getDevSupportManager();
-        // onKeyLongPress is a Dev API and not supported in RELEASE mode.
-        if (devSupportManager != null && !(devSupportManager instanceof ReleaseDevSupportManager)) {
-          devSupportManager.showDevOptionsDialog();
-          return true;
-        }
-      } else {
-        if (getReactNativeHost().hasInstance() && getReactNativeHost().getUseDeveloperSupport()) {
-          getReactNativeHost().getReactInstanceManager().showDevOptionsDialog();
-          return true;
-        }
-      }
-    }
-    return false;
-  }
-
-  public void reload() {
-    DevSupportManager devSupportManager = getDevSupportManager();
-    if (devSupportManager == null) {
-      return;
-    }
-
-    // Reload in RELEASE mode
-    if (devSupportManager instanceof ReleaseDevSupportManager) {
-      // Do not reload the bundle from JS as there is no bundler running in release mode.
-      if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-        if (mReactHost != null) {
-          mReactHost.reload("ReactDelegate.reload()");
-        }
-      } else {
-        UiThreadUtil.runOnUiThread(
-            () -> {
-              if (mReactNativeHost.hasInstance()
-                  && mReactNativeHost.getReactInstanceManager() != null) {
-                mReactNativeHost.getReactInstanceManager().recreateReactContextInBackground();
-              }
-            });
-      }
-      return;
-    }
-
-    // Reload in DEBUG mode
-    devSupportManager.handleReloadJS();
-  }
-
-  /** Start the React surface with the app key supplied in the {@link ReactDelegate} constructor. */
-  public void loadApp() {
-    loadApp(mMainComponentName);
-  }
-
-  /**
-   * Start the React surface for the given app key.
-   *
-   * @param appKey The ID of the app to load into the surface.
-   */
-  public void loadApp(String appKey) {
-    // With Bridgeless enabled, create and start the surface
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      if (mReactSurface == null) {
-        mReactSurface = mReactHost.createSurface(mActivity, appKey, mLaunchOptions);
-      }
-      mReactSurface.start();
-    } else {
-      if (mReactRootView != null) {
-        throw new IllegalStateException("Cannot loadApp while app is already running.");
-      }
-      mReactRootView = createRootView();
-      mReactRootView.startReactApplication(
-          getReactNativeHost().getReactInstanceManager(), appKey, mLaunchOptions);
-    }
-  }
-
-  /** Stop the React surface started with {@link ReactDelegate#loadApp()}. */
-  public void unloadApp() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      if (mReactSurface != null) {
-        mReactSurface.stop();
-        mReactSurface = null;
-      }
-    } else {
-      if (mReactRootView != null) {
-        mReactRootView.unmountReactApplication();
-        mReactRootView = null;
-      }
-    }
-  }
-
-  public void setReactSurface(ReactSurface reactSurface) {
-    mReactSurface = reactSurface;
-  }
-
-  public void setReactRootView(ReactRootView reactRootView) {
-    mReactRootView = reactRootView;
-  }
-
-  @Nullable
-  public ReactRootView getReactRootView() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      if (mReactSurface != null) {
-        return (ReactRootView) mReactSurface.getView();
-      } else {
-        return null;
-      }
-    } else {
-      return mReactRootView;
-    }
-  }
-
-  // Not used in bridgeless
-  protected ReactRootView createRootView() {
-    ReactRootView reactRootView = new ReactRootView(mActivity);
-    reactRootView.setIsFabric(isFabricEnabled());
-    return reactRootView;
-  }
-
-  /**
-   * Handles delegating the {@link Activity#onKeyUp(int, KeyEvent)} method to determine whether the
-   * application should show the developer menu or should reload the React Application.
-   *
-   * @return true if we consume the event and either shoed the develop menu or reloaded the
-   *     application.
-   */
-  public boolean shouldShowDevMenuOrReload(int keyCode, KeyEvent event) {
-    DevSupportManager devSupportManager = getDevSupportManager();
-    // shouldShowDevMenuOrReload is a Dev API and not supported in RELEASE mode.
-    if (devSupportManager == null || devSupportManager instanceof ReleaseDevSupportManager) {
-      return false;
-    }
-
-    if (keyCode == KeyEvent.KEYCODE_MENU) {
-      devSupportManager.showDevOptionsDialog();
-      return true;
-    }
-    boolean didDoubleTapR =
-        Assertions.assertNotNull(mDoubleTapReloadRecognizer)
-            .didDoubleTapR(keyCode, mActivity.getCurrentFocus());
-    if (didDoubleTapR) {
-      devSupportManager.handleReloadJS();
-      return true;
-    }
-    return false;
-  }
-
-  /** Get the {@link ReactNativeHost} used by this app. */
-  @DeprecatedInNewArchitecture(message = "Use getReactHost()")
-  private ReactNativeHost getReactNativeHost() {
-    return mReactNativeHost;
-  }
-
-  @DeprecatedInNewArchitecture(message = "Use getReactHost()")
-  public ReactInstanceManager getReactInstanceManager() {
-    return getReactNativeHost().getReactInstanceManager();
-  }
-
-  public @Nullable ReactHost getReactHost() {
-    return mReactHost;
-  }
-
-  /**
-   * Get the current {@link ReactContext} from ReactHost or ReactInstanceManager
-   *
-   * <p>Do not store a reference to this, if the React instance is reloaded or destroyed, this
-   * context will no longer be valid.
-   */
-  public @Nullable ReactContext getCurrentReactContext() {
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      if (mReactHost != null) {
-        return mReactHost.getCurrentReactContext();
-      } else {
-        return null;
-      }
-    } else {
-      return getReactInstanceManager().getCurrentReactContext();
-    }
-  }
-
-  /**
-   * Override this method if you wish to selectively toggle Fabric for a specific surface. This will
-   * also control if Concurrent Root (React 18) should be enabled or not.
-   *
-   * @return true if Fabric is enabled for this Activity, false otherwise.
-   */
-  protected boolean isFabricEnabled() {
-    return mFabricEnabled;
-  }
-}

package/ReactAndroid/src/main/java/com/facebook/react/ReactFragment.java

@@ -1,270 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- *
- * This source code is licensed under the MIT license found in the
- * LICENSE file in the root directory of this source tree.
- */
-
-package com.facebook.react;
-
-import android.app.Activity;
-import android.content.Intent;
-import android.os.Bundle;
-import android.view.KeyEvent;
-import android.view.LayoutInflater;
-import android.view.View;
-import android.view.ViewGroup;
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-import androidx.fragment.app.Fragment;
-import com.facebook.react.internal.featureflags.ReactNativeNewArchitectureFeatureFlags;
-import com.facebook.react.modules.core.PermissionAwareActivity;
-import com.facebook.react.modules.core.PermissionListener;
-
-/**
- * Fragment for creating a React View. This allows the developer to "embed" a React Application
- * inside native components such as a Drawer, ViewPager, etc.
- */
-public class ReactFragment extends Fragment implements PermissionAwareActivity {
-
-  protected static final String ARG_COMPONENT_NAME = "arg_component_name";
-  protected static final String ARG_LAUNCH_OPTIONS = "arg_launch_options";
-  protected static final String ARG_FABRIC_ENABLED = "arg_fabric_enabled";
-
-  /**
-   * @deprecated We will remove this and use a different solution for handling Fragment lifecycle
-   *     events
-   */
-  @Deprecated
-  protected static final String ARG_DISABLE_HOST_LIFECYCLE_EVENTS =
-      "arg_disable_host_lifecycle_events";
-
-  protected ReactDelegate mReactDelegate;
-
-  private boolean mDisableHostLifecycleEvents;
-
-  @Nullable private PermissionListener mPermissionListener;
-
-  public ReactFragment() {
-    // Required empty public constructor
-  }
-
-  /**
-   * @param componentName The name of the react native component
-   * @param fabricEnabled Flag to enable Fabric for ReactFragment
-   * @return A new instance of fragment ReactFragment.
-   */
-  private static ReactFragment newInstance(
-      String componentName, Bundle launchOptions, Boolean fabricEnabled) {
-    ReactFragment fragment = new ReactFragment();
-    Bundle args = new Bundle();
-    args.putString(ARG_COMPONENT_NAME, componentName);
-    args.putBundle(ARG_LAUNCH_OPTIONS, launchOptions);
-    args.putBoolean(ARG_FABRIC_ENABLED, fabricEnabled);
-    fragment.setArguments(args);
-    return fragment;
-  }
-
-  // region Lifecycle
-  @Override
-  public void onCreate(Bundle savedInstanceState) {
-    super.onCreate(savedInstanceState);
-    String mainComponentName = null;
-    Bundle launchOptions = null;
-    Boolean fabricEnabled = null;
-    if (getArguments() != null) {
-      mainComponentName = getArguments().getString(ARG_COMPONENT_NAME);
-      launchOptions = getArguments().getBundle(ARG_LAUNCH_OPTIONS);
-      fabricEnabled = getArguments().getBoolean(ARG_FABRIC_ENABLED);
-      mDisableHostLifecycleEvents = getArguments().getBoolean(ARG_DISABLE_HOST_LIFECYCLE_EVENTS);
-    }
-    if (mainComponentName == null) {
-      throw new IllegalStateException("Cannot loadApp if component name is null");
-    }
-    if (ReactNativeNewArchitectureFeatureFlags.enableBridgelessArchitecture()) {
-      mReactDelegate =
-          new ReactDelegate(getActivity(), getReactHost(), mainComponentName, launchOptions);
-    } else {
-      mReactDelegate =
-          new ReactDelegate(
-              getActivity(), getReactNativeHost(), mainComponentName, launchOptions, fabricEnabled);
-    }
-  }
-
-  /**
-   * Get the {@link ReactNativeHost} used by this app. By default, assumes {@link
-   * Activity#getApplication()} is an instance of {@link ReactApplication} and calls {@link
-   * ReactApplication#getReactNativeHost()}. Override this method if your application class does not
-   * implement {@code ReactApplication} or you simply have a different mechanism for storing a
-   * {@code ReactNativeHost}, e.g. as a static field somewhere.
-   */
-  @Nullable
-  protected ReactNativeHost getReactNativeHost() {
-    ReactApplication application = ((ReactApplication) getActivity().getApplication());
-    if (application != null) {
-      return application.getReactNativeHost();
-    } else {
-      return null;
-    }
-  }
-
-  /**
-   * Get the {@link ReactHost} used by this app. By default, assumes {@link
-   * Activity#getApplication()} is an instance of {@link ReactApplication} and calls {@link
-   * ReactApplication#getReactHost()}. Override this method if your application class does not
-   * implement {@code ReactApplication} or you simply have a different mechanism for storing a
-   * {@code ReactHost}, e.g. as a static field somewhere.
-   *
-   * <p>If you're using Old Architecture/Bridge Mode, this method should return null as {@link
-   * ReactHost} is a Bridgeless-only concept.
-   */
-  @Nullable
-  protected ReactHost getReactHost() {
-    ReactApplication application = ((ReactApplication) getActivity().getApplication());
-    if (application != null) {
-      return application.getReactHost();
-    } else {
-      return null;
-    }
-  }
-
-  protected ReactDelegate getReactDelegate() {
-    return mReactDelegate;
-  }
-
-  @Override
-  public View onCreateView(
-      @NonNull LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
-    mReactDelegate.loadApp();
-    return mReactDelegate.getReactRootView();
-  }
-
-  @Override
-  public void onResume() {
-    super.onResume();
-    if (!mDisableHostLifecycleEvents) {
-      mReactDelegate.onHostResume();
-    }
-  }
-
-  @Override
-  public void onPause() {
-    super.onPause();
-    if (!mDisableHostLifecycleEvents) {
-      mReactDelegate.onHostPause();
-    }
-  }
-
-  @Override
-  public void onDestroy() {
-    super.onDestroy();
-    if (!mDisableHostLifecycleEvents) {
-      mReactDelegate.onHostDestroy();
-    } else {
-      mReactDelegate.unloadApp();
-    }
-  }
-
-  // endregion
-
-  @Override
-  public void onActivityResult(int requestCode, int resultCode, Intent data) {
-    super.onActivityResult(requestCode, resultCode, data);
-    mReactDelegate.onActivityResult(requestCode, resultCode, data, false);
-  }
-
-  /**
-   * Helper to forward hardware back presses to our React Native Host
-   *
-   * <p>This must be called via a forward from your host Activity
-   */
-  public boolean onBackPressed() {
-    return mReactDelegate.onBackPressed();
-  }
-
-  /**
-   * Helper to forward onKeyUp commands from our host Activity. This allows ReactFragment to handle
-   * double tap reloads and dev menus
-   *
-   * <p>This must be called via a forward from your host Activity
-   *
-   * @param keyCode keyCode
-   * @param event event
-   * @return true if we handled onKeyUp
-   */
-  public boolean onKeyUp(int keyCode, KeyEvent event) {
-    return mReactDelegate.shouldShowDevMenuOrReload(keyCode, event);
-  }
-
-  @Override
-  public void onRequestPermissionsResult(
-      int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
-    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
-    if (mPermissionListener != null
-        && mPermissionListener.onRequestPermissionsResult(requestCode, permissions, grantResults)) {
-      mPermissionListener = null;
-    }
-  }
-
-  @Override
-  public int checkPermission(String permission, int pid, int uid) {
-    return getActivity().checkPermission(permission, pid, uid);
-  }
-
-  @Override
-  public int checkSelfPermission(String permission) {
-    return getActivity().checkSelfPermission(permission);
-  }
-
-  @Override
-  public void requestPermissions(
-      String[] permissions, int requestCode, PermissionListener listener) {
-    mPermissionListener = listener;
-    requestPermissions(permissions, requestCode);
-  }
-
-  /** Builder class to help instantiate a ReactFragment */
-  public static class Builder {
-
-    @Nullable String mComponentName;
-    @Nullable Bundle mLaunchOptions;
-    @Nullable Boolean mFabricEnabled;
-
-    public Builder() {
-      mComponentName = null;
-      mLaunchOptions = null;
-      mFabricEnabled = false;
-    }
-
-    /**
-     * Set the Component name for our React Native instance.
-     *
-     * @param componentName The name of the component
-     * @return Builder
-     */
-    public Builder setComponentName(String componentName) {
-      mComponentName = componentName;
-      return this;
-    }
-
-    /**
-     * Set the Launch Options for our React Native instance.
-     *
-     * @param launchOptions launchOptions
-     * @return Builder
-     */
-    public Builder setLaunchOptions(Bundle launchOptions) {
-      mLaunchOptions = launchOptions;
-      return this;
-    }
-
-    public ReactFragment build() {
-      return ReactFragment.newInstance(mComponentName, mLaunchOptions, mFabricEnabled);
-    }
-
-    public Builder setFabricEnabled(boolean fabricEnabled) {
-      mFabricEnabled = fabricEnabled;
-      return this;
-    }
-  }
-}