react-native-tvos 0.77.0-0rc5 → 0.78.0-0

package/ReactAndroid/src/main/java/com/facebook/react/internal/featureflags/ReactNativeFeatureFlagsProvider.kt

@@ -4,7 +4,7 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @generated SignedSource<<2217f2b9992c9424c3d1d221bdfa2236>>
+ * @generated SignedSource<<3cd802bdd1d383ea0668e43319d53b3f>>
  */
 
 /**
@@ -31,9 +31,7 @@ public interface ReactNativeFeatureFlagsProvider {
 
   @DoNotStrip public fun disableMountItemReorderingAndroid(): Boolean
 
-  @DoNotStrip public fun enableAlignItemsBaselineOnFabricIOS(): Boolean
-
-  @DoNotStrip public fun enableAndroidLineHeightCentering(): Boolean
+  @DoNotStrip public fun enableAccumulatedUpdatesInRawPropsAndroid(): Boolean
 
   @DoNotStrip public fun enableBridgelessArchitecture(): Boolean
 
@@ -49,14 +47,14 @@ public interface ReactNativeFeatureFlagsProvider {
 
   @DoNotStrip public fun enableFabricRenderer(): Boolean
 
-  @DoNotStrip public fun enableFabricRendererExclusively(): Boolean
-
   @DoNotStrip public fun enableFixForViewCommandRace(): Boolean
 
   @DoNotStrip public fun enableGranularShadowTreeStateReconciliation(): Boolean
 
   @DoNotStrip public fun enableIOSViewClipToPaddingBox(): Boolean
 
+  @DoNotStrip public fun enableImagePrefetchingAndroid(): Boolean
+
   @DoNotStrip public fun enableLayoutAnimationsOnAndroid(): Boolean
 
   @DoNotStrip public fun enableLayoutAnimationsOnIOS(): Boolean
@@ -79,12 +77,12 @@ public interface ReactNativeFeatureFlagsProvider {
 
   @DoNotStrip public fun excludeYogaFromRawProps(): Boolean
 
+  @DoNotStrip public fun fixDifferentiatorEmittingUpdatesWithWrongParentTag(): Boolean
+
   @DoNotStrip public fun fixMappingOfEventPrioritiesBetweenFabricAndReact(): Boolean
 
   @DoNotStrip public fun fixMountingCoordinatorReportedPendingTransactionsOnAndroid(): Boolean
 
-  @DoNotStrip public fun fuseboxEnabledDebug(): Boolean
-
   @DoNotStrip public fun fuseboxEnabledRelease(): Boolean
 
   @DoNotStrip public fun initEagerTurboModulesOnNativeModulesQueueAndroid(): Boolean
@@ -107,6 +105,8 @@ public interface ReactNativeFeatureFlagsProvider {
 
   @DoNotStrip public fun useOptimizedEventBatchingOnAndroid(): Boolean
 
+  @DoNotStrip public fun useRawPropsJsiValue(): Boolean
+
   @DoNotStrip public fun useRuntimeShadowNodeReferenceUpdate(): Boolean
 
   @DoNotStrip public fun useTurboModuleInterop(): Boolean

package/ReactAndroid/src/main/java/com/facebook/react/internal/interop/InteropEventEmitter.kt

@@ -31,12 +31,12 @@ public class InteropEventEmitter(private val reactContext: ReactContext) : RCTEv
   private var eventDispatcherOverride: EventDispatcher? = null
 
   @Deprecated("Deprecated in Java")
-  override fun receiveEvent(targetReactTag: Int, eventName: String, eventData: WritableMap?) {
+  override fun receiveEvent(targetTag: Int, eventName: String, params: WritableMap?) {
     val dispatcher: EventDispatcher? =
         eventDispatcherOverride
-            ?: UIManagerHelper.getEventDispatcherForReactTag(reactContext, targetReactTag)
+            ?: UIManagerHelper.getEventDispatcherForReactTag(reactContext, targetTag)
     val surfaceId = UIManagerHelper.getSurfaceId(reactContext)
-    dispatcher?.dispatchEvent(InteropEvent(eventName, eventData, surfaceId, targetReactTag))
+    dispatcher?.dispatchEvent(InteropEvent(eventName, params, surfaceId, targetTag))
   }
 
   @Deprecated("Deprecated in Java")

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskConfig.kt

@@ -0,0 +1,55 @@
+/*
+ * 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.jstasks
+
+import com.facebook.react.bridge.WritableMap
+
+/**
+ * Class that holds the various parameters needed to start a JS task.
+ *
+ * @property taskKey the key for the JS task to execute. This is the same key that you call
+ *   `AppRegistry.registerTask` with in JS.
+ * @property data a map of parameters passed to the JS task executor.
+ * @property timeout the amount of time (in ms) after which the React instance should be terminated
+ *   regardless of whether the task has completed or not. This is meant as a safeguard against
+ *   accidentally keeping the device awake for long periods of time because JS crashed or some
+ *   request timed out. A value of 0 means no timeout (should only be used for long-running tasks
+ *   such as music playback).
+ * @property allowedInForeground whether to allow this task to run while the app is in the
+ *   foreground (i.e. there is a host in resumed mode for the current ReactContext). Only set this
+ *   to true if you really need it. Note that tasks run in the same JS thread as UI code, so doing
+ *   expensive operations would degrade user experience.
+ * @property allowedInForeground whether to allow this task to run while the app is in the
+ *   foreground (i.e. there is a host in resumed mode for the current ReactContext). Only set this
+ *   to true if you really need it. Note that tasks run in the same JS thread as UI code, so doing
+ *   expensive operations would degrade user experience.
+ * @property retryPolicy the number of times & delays the task should be retried on error.
+ */
+public class HeadlessJsTaskConfig
+@JvmOverloads
+constructor(
+    public val taskKey: String,
+    public val data: WritableMap,
+    public val timeout: Long = 0,
+    public val isAllowedInForeground: Boolean = false,
+    public val retryPolicy: HeadlessJsTaskRetryPolicy? = NoRetryPolicy.INSTANCE
+) {
+
+  /**
+   * Copy constructor to create a HeadlessJsTaskConfig from an existing one. Equivalent to calling
+   * [HeadlessJsTaskConfig] with `false` for `allowedInBackground`.
+   */
+  public constructor(
+      source: HeadlessJsTaskConfig
+  ) : this(
+      source.taskKey,
+      source.data.copy(),
+      source.timeout,
+      source.isAllowedInForeground,
+      source.retryPolicy?.copy())
+}

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskContext.kt

@@ -0,0 +1,185 @@
+/*
+ * 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.jstasks
+
+import android.util.SparseArray
+import com.facebook.infer.annotation.Assertions
+import com.facebook.react.bridge.ReactContext
+import com.facebook.react.bridge.ReactSoftExceptionLogger.logSoftException
+import com.facebook.react.bridge.UiThreadUtil
+import com.facebook.react.common.LifecycleState
+import com.facebook.react.modules.appregistry.AppRegistry
+import java.lang.ref.WeakReference
+import java.util.WeakHashMap
+import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.CopyOnWriteArraySet
+import java.util.concurrent.atomic.AtomicInteger
+
+/**
+ * Helper class for dealing with JS tasks. Handles per-ReactContext active task tracking, starting /
+ * stopping tasks and notifying listeners.
+ */
+public class HeadlessJsTaskContext private constructor(reactContext: ReactContext) {
+  private val reactContext = WeakReference(reactContext)
+  private val headlessJsTaskEventListeners: MutableSet<HeadlessJsTaskEventListener> =
+      CopyOnWriteArraySet()
+  private val lastTaskId = AtomicInteger(0)
+  private val activeTasks: MutableSet<Int> = CopyOnWriteArraySet()
+  private val activeTaskConfigs: MutableMap<Int, HeadlessJsTaskConfig> = ConcurrentHashMap()
+  private val taskTimeouts = SparseArray<Runnable>()
+
+  /**
+   * Register a task lifecycle event listener. Synchronized in order to prevent race conditions with
+   * finishTask, as the listener will be invoked for already running tasks.
+   */
+  @Synchronized
+  public fun addTaskEventListener(listener: HeadlessJsTaskEventListener) {
+    headlessJsTaskEventListeners.add(listener)
+    for (activeTaskId in activeTasks) {
+      listener.onHeadlessJsTaskStart(activeTaskId)
+    }
+  }
+
+  /** Unregister a task lifecycle event listener. */
+  public fun removeTaskEventListener(listener: HeadlessJsTaskEventListener) {
+    headlessJsTaskEventListeners.remove(listener)
+  }
+
+  /** Get whether there are any running JS tasks at the moment. */
+  public fun hasActiveTasks(): Boolean = activeTasks.isNotEmpty()
+
+  /**
+   * Start a JS task. Handles invoking [AppRegistry.startHeadlessTask] and notifying listeners.
+   *
+   * @return a unique id representing this task instance.
+   */
+  @Synchronized
+  public fun startTask(taskConfig: HeadlessJsTaskConfig): Int =
+      lastTaskId.incrementAndGet().apply { startTask(taskConfig, this) }
+
+  /**
+   * Start a JS task the provided task id. Handles invoking [AppRegistry.startHeadlessTask] and
+   * notifying listeners.
+   */
+  @Synchronized
+  private fun startTask(taskConfig: HeadlessJsTaskConfig, taskId: Int) {
+    UiThreadUtil.assertOnUiThread()
+    val reactContext =
+        Assertions.assertNotNull(
+            reactContext.get(),
+            "Tried to start a task on a react context that has already been destroyed")
+    check(
+        !(reactContext.lifecycleState == LifecycleState.RESUMED &&
+            !taskConfig.isAllowedInForeground)) {
+          "Tried to start task ${taskConfig.taskKey} while in foreground, but this is not allowed."
+        }
+    activeTasks.add(taskId)
+    activeTaskConfigs[taskId] = HeadlessJsTaskConfig(taskConfig)
+    if (reactContext.hasActiveReactInstance()) {
+      reactContext
+          .getJSModule(AppRegistry::class.java)
+          .startHeadlessTask(taskId, taskConfig.taskKey, taskConfig.data)
+    } else {
+      logSoftException(
+          "HeadlessJsTaskContext",
+          RuntimeException("Cannot start headless task, CatalystInstance not available"))
+    }
+    if (taskConfig.timeout > 0) {
+      scheduleTaskTimeout(taskId, taskConfig.timeout)
+    }
+    for (listener in headlessJsTaskEventListeners) {
+      listener.onHeadlessJsTaskStart(taskId)
+    }
+  }
+
+  /**
+   * Retry a running JS task with a delay. Invokes [ ][HeadlessJsTaskContext.startTask] as long as
+   * the process does not get killed.
+   *
+   * @return true if a retry attempt has been posted.
+   */
+  @Synchronized
+  public fun retryTask(taskId: Int): Boolean {
+    val sourceTaskConfig = activeTaskConfigs[taskId]
+    checkNotNull(sourceTaskConfig) { "Tried to retrieve non-existent task config with id $taskId." }
+
+    val retryPolicy = sourceTaskConfig.retryPolicy
+    if (retryPolicy == null || !retryPolicy.canRetry()) {
+      return false
+    }
+
+    removeTimeout(taskId)
+    val taskConfig =
+        HeadlessJsTaskConfig(
+            sourceTaskConfig.taskKey,
+            sourceTaskConfig.data,
+            sourceTaskConfig.timeout,
+            sourceTaskConfig.isAllowedInForeground,
+            retryPolicy.update())
+
+    val retryAttempt = Runnable { startTask(taskConfig, taskId) }
+
+    UiThreadUtil.runOnUiThread(retryAttempt, retryPolicy.delay.toLong())
+    return true
+  }
+
+  /**
+   * Finish a JS task. Doesn't actually stop the task on the JS side, only removes it from the list
+   * of active tasks and notifies listeners.
+   *
+   * @param taskId the unique id returned by [.startTask].
+   */
+  @Synchronized
+  public fun finishTask(taskId: Int) {
+    val removed = activeTasks.remove(taskId)
+    activeTaskConfigs.remove(taskId)
+    removeTimeout(taskId)
+    if (removed) {
+      UiThreadUtil.runOnUiThread {
+        for (listener in headlessJsTaskEventListeners) {
+          listener.onHeadlessJsTaskFinish(taskId)
+        }
+      }
+    }
+  }
+
+  private fun removeTimeout(taskId: Int) {
+    val runnable = taskTimeouts[taskId]
+    if (runnable != null) {
+      UiThreadUtil.removeOnUiThread(runnable)
+      taskTimeouts.remove(taskId)
+    }
+  }
+
+  /**
+   * Check if a given task is currently running. A task is stopped if either [finishTask] is called
+   * or it times out.
+   */
+  @Synchronized public fun isTaskRunning(taskId: Int): Boolean = taskId in activeTasks
+
+  private fun scheduleTaskTimeout(taskId: Int, timeout: Long) {
+    val runnable = Runnable { finishTask(taskId) }
+    taskTimeouts.append(taskId, runnable)
+    UiThreadUtil.runOnUiThread(runnable, timeout)
+  }
+
+  public companion object {
+    private val INSTANCES = WeakHashMap<ReactContext, HeadlessJsTaskContext>()
+
+    /**
+     * Get the task helper instance for a particular [ReactContext]. There is only one instance per
+     * context.
+     *
+     * **Note:** do not hold long-lived references to the object returned here, as that will cause
+     * memory leaks. Instead, just call this method on-demand.
+     */
+    @JvmStatic
+    public fun getInstance(context: ReactContext): HeadlessJsTaskContext =
+        INSTANCES.getOrPut(context) { HeadlessJsTaskContext(context) }
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/{HeadlessJsTaskEventListener.java → HeadlessJsTaskEventListener.kt}

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.jstasks;
+package com.facebook.react.jstasks
 
 /** Listener interface for task lifecycle events. */
 public interface HeadlessJsTaskEventListener {
@@ -15,12 +15,11 @@ public interface HeadlessJsTaskEventListener {
    *
    * @param taskId the unique identifier of this task instance
    */
-  void onHeadlessJsTaskStart(int taskId);
+  public fun onHeadlessJsTaskStart(taskId: Int)
 
   /**
-   * Called when a JS task finishes (i.e. when {@link
-   * HeadlessJsTaskSupportModule#notifyTaskFinished} is called, or when it times out), on the UI
-   * thread.
+   * Called when a JS task finishes (i.e. when [HeadlessJsTaskSupportModule.notifyTaskFinished] is
+   * called, or when it times out), on the UI thread.
    */
-  void onHeadlessJsTaskFinish(int taskId);
+  public fun onHeadlessJsTaskFinish(taskId: Int)
 }

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/HeadlessJsTaskRetryPolicy.kt

@@ -0,0 +1,20 @@
+/*
+ * 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.jstasks
+
+import javax.annotation.CheckReturnValue
+
+public interface HeadlessJsTaskRetryPolicy {
+  public fun canRetry(): Boolean
+
+  public val delay: Int
+
+  @CheckReturnValue public fun update(): HeadlessJsTaskRetryPolicy?
+
+  public fun copy(): HeadlessJsTaskRetryPolicy?
+}

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/LinearCountingRetryPolicy.kt

@@ -12,11 +12,11 @@ public class LinearCountingRetryPolicy(
     private val delayBetweenAttemptsInMs: Int
 ) : HeadlessJsTaskRetryPolicy {
 
-  override public fun canRetry(): Boolean = retryAttempts > 0
+  public override fun canRetry(): Boolean = retryAttempts > 0
 
-  override public fun getDelay(): Int = delayBetweenAttemptsInMs
+  override val delay: Int = delayBetweenAttemptsInMs
 
-  override public fun update(): HeadlessJsTaskRetryPolicy {
+  public override fun update(): HeadlessJsTaskRetryPolicy {
     val remainingRetryAttempts = retryAttempts - 1
 
     return if (remainingRetryAttempts > 0) {
@@ -26,6 +26,6 @@ public class LinearCountingRetryPolicy(
     }
   }
 
-  override public fun copy(): HeadlessJsTaskRetryPolicy =
+  public override fun copy(): HeadlessJsTaskRetryPolicy =
       LinearCountingRetryPolicy(retryAttempts, delayBetweenAttemptsInMs)
 }

package/ReactAndroid/src/main/java/com/facebook/react/jstasks/NoRetryPolicy.kt

@@ -9,20 +9,19 @@ package com.facebook.react.jstasks
 
 internal class NoRetryPolicy private constructor() : HeadlessJsTaskRetryPolicy {
 
-  override public fun canRetry(): Boolean = false
+  override fun canRetry(): Boolean = false
 
-  override public fun getDelay(): Int {
-    throw IllegalStateException("Should not retrieve delay as canRetry is: ${canRetry()}")
-  }
+  override val delay: Int
+    get() = throw IllegalStateException("Should not retrieve delay as canRetry is: ${canRetry()}")
 
-  override public fun update(): HeadlessJsTaskRetryPolicy {
+  override fun update(): HeadlessJsTaskRetryPolicy {
     throw IllegalStateException("Should not update as canRetry is: ${canRetry()}")
   }
 
   // Class is immutable so no need to copy
-  override public fun copy(): HeadlessJsTaskRetryPolicy = this
+  override fun copy(): HeadlessJsTaskRetryPolicy = this
 
-  public companion object {
-    @JvmField public val INSTANCE: NoRetryPolicy = NoRetryPolicy()
+  companion object {
+    @JvmField val INSTANCE: NoRetryPolicy = NoRetryPolicy()
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/appearance/AppearanceModule.kt

@@ -13,6 +13,7 @@ import androidx.appcompat.app.AppCompatDelegate
 import com.facebook.fbreact.specs.NativeAppearanceSpec
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.UiThreadUtil
 import com.facebook.react.module.annotations.ReactModule
 
 /** Module that exposes the user's preferred color scheme. */
@@ -58,11 +59,13 @@ constructor(
   }
 
   public override fun setColorScheme(style: String) {
-    when (style) {
-      "dark" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
-      "light" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
-      "unspecified" ->
-          AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
+    UiThreadUtil.runOnUiThread {
+      when (style) {
+        "dark" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_YES)
+        "light" -> AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_NO)
+        "unspecified" ->
+            AppCompatDelegate.setDefaultNightMode(AppCompatDelegate.MODE_NIGHT_FOLLOW_SYSTEM)
+      }
     }
   }
 

package/ReactAndroid/src/main/java/com/facebook/react/modules/fresco/FrescoModule.kt

@@ -10,11 +10,10 @@ package com.facebook.react.modules.fresco
 import com.facebook.common.logging.FLog
 import com.facebook.drawee.backends.pipeline.DraweeConfig
 import com.facebook.drawee.backends.pipeline.Fresco
-import com.facebook.imagepipeline.backends.okhttp3.OkHttpImagePipelineConfigFactory.newBuilder
+import com.facebook.imagepipeline.backends.okhttp3.OkHttpImagePipelineConfigFactory
 import com.facebook.imagepipeline.core.DownsampleMode
 import com.facebook.imagepipeline.core.ImagePipeline
 import com.facebook.imagepipeline.core.ImagePipelineConfig
-import com.facebook.imagepipeline.decoder.ImageDecoderConfig
 import com.facebook.imagepipeline.listener.RequestListener
 import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.ReactApplicationContext
@@ -80,9 +79,6 @@ constructor(
     if (!hasBeenInitialized()) {
       val pipelineConfig = config ?: getDefaultConfig(reactContext)
       val draweeConfigBuilder = DraweeConfig.newBuilder()
-      if (ReactNativeFeatureFlags.loadVectorDrawablesOnImages()) {
-        draweeConfigBuilder.addCustomDrawableFactory(XmlFormat.getDrawableFactory())
-      }
       Fresco.initialize(
           reactContext.applicationContext,
           pipelineConfig,
@@ -158,22 +154,20 @@ constructor(
       requestListeners.add(SystraceRequestListener())
       val client = OkHttpClientProvider.createClient()
 
-      // Add support for XML drawable images
-      val decoderConfigBuilder = ImageDecoderConfig.Builder()
-      if (ReactNativeFeatureFlags.loadVectorDrawablesOnImages()) {
-        XmlFormat.addDecodingCapability(decoderConfigBuilder, context)
-      }
-
       // make sure to forward cookies for any requests via the okHttpClient
       // so that image requests to endpoints that use cookies still work
       val container = OkHttpCompat.getCookieJarContainer(client)
-      val handler = ForwardingCookieHandler(context)
+      val handler = ForwardingCookieHandler()
       container.setCookieJar(JavaNetCookieJar(handler))
-      return newBuilder(context.applicationContext, client)
-          .setNetworkFetcher(ReactOkHttpNetworkFetcher(client))
-          .setImageDecoderConfig(decoderConfigBuilder.build())
-          .setDownsampleMode(DownsampleMode.AUTO)
-          .setRequestListeners(requestListeners)
+      val builder =
+          OkHttpImagePipelineConfigFactory.newBuilder(context.applicationContext, client)
+              .setNetworkFetcher(ReactOkHttpNetworkFetcher(client))
+              .setDownsampleMode(DownsampleMode.AUTO)
+              .setRequestListeners(requestListeners)
+      builder
+          .experiment()
+          .setBinaryXmlEnabled(ReactNativeFeatureFlags.loadVectorDrawablesOnImages())
+      return builder
     }
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/fresco/ReactOkHttpNetworkFetcher.kt

@@ -60,9 +60,9 @@ internal class ReactOkHttpNetworkFetcher(private val okHttpClient: OkHttpClient)
     val headers = OkHttpCompat.getHeadersFromMap(requestHeaders)
     val request =
         Request.Builder()
+            .headers(headers)
             .cacheControl(cacheControlBuilder.build())
             .url(uri.toString())
-            .headers(headers)
             .get()
             .build()
     fetchWithRequest(fetchState, callback, request)

package/ReactAndroid/src/main/java/com/facebook/react/modules/network/CookieJarContainer.kt

@@ -0,0 +1,16 @@
+/*
+ * 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.modules.network
+
+import okhttp3.CookieJar
+
+public interface CookieJarContainer : CookieJar {
+  public fun setCookieJar(cookieJar: CookieJar)
+
+  public fun removeCookieJar()
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/network/ForwardingCookieHandler.kt

@@ -0,0 +1,107 @@
+/*
+ * 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.modules.network
+
+import android.webkit.CookieManager
+import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.ReactContext
+import java.io.IOException
+import java.net.CookieHandler
+import java.net.URI
+
+/**
+ * Cookie handler that forwards all cookies to the WebView CookieManager.
+ *
+ * This class relies on CookieManager to persist cookies to disk so cookies may be lost if the
+ * application is terminated before it syncs.
+ */
+public class ForwardingCookieHandler() : CookieHandler() {
+
+  @Deprecated("Use the default constructor", ReplaceWith("ForwardingCookieHandler()"))
+  public constructor(@Suppress("UNUSED_PARAMETER") reactContext: ReactContext) : this() {}
+
+  @Throws(IOException::class)
+  override fun get(uri: URI, headers: Map<String, List<String>>): Map<String, List<String>> {
+    val cookies = cookieManager?.getCookie(uri.toString())
+    if (cookies.isNullOrEmpty()) {
+      return emptyMap()
+    }
+
+    return mapOf(COOKIE_HEADER to listOf(cookies))
+  }
+
+  @Throws(IOException::class)
+  override fun put(uri: URI, headers: Map<String, List<String>>) {
+    val url = uri.toString()
+    for ((key, value) in headers) {
+      if (isCookieHeader(key)) {
+        addCookies(url, value)
+      }
+    }
+  }
+
+  public fun clearCookies(callback: Callback): Unit {
+    cookieManager?.removeAllCookies { value -> callback.invoke(value) }
+  }
+
+  public fun destroy(): Unit = Unit
+
+  public fun addCookies(url: String, cookies: List<String>): Unit {
+    for (cookie in cookies) {
+      addCookieAsync(url, cookie)
+    }
+    cookieManager?.flush()
+  }
+
+  private fun addCookieAsync(url: String, cookie: String) {
+    cookieManager?.setCookie(url, cookie, null)
+  }
+
+  private var cookieManager: CookieManager? = null
+    /**
+     * Instantiating CookieManager will load the Chromium task taking a 100ish ms so we do it lazily
+     * to make sure it's done on a background thread as needed.
+     */
+    get() {
+      if (field == null) {
+        try {
+          field = CookieManager.getInstance()
+        } catch (ex: IllegalArgumentException) {
+          // https://bugs.chromium.org/p/chromium/issues/detail?id=559720
+          return null
+        } catch (exception: Exception) {
+          // Ideally we would like to catch a `MissingWebViewPackageException` here.
+          // That API is private so we can't access it.
+          // Historically we used string matching on the error message to understand
+          // if the exception was a Missing Webview One.
+          // OEMs have been customizing that message making really hard to catch it.
+          // Therefore we result to returning null as a default instead of rethrowing
+          // the exception as it will result in a app crash at runtime.
+          // a) We will return null for all the other unhandled conditions when a webview provider
+          // is
+          // not found.
+          // b) We already have null checks in place for `getCookieManager()` calls.
+          // c) We have annotated the method as @Nullable to notify future devs about our return
+          // type.
+          return null
+        }
+      }
+
+      return field
+    }
+
+  private companion object {
+    private const val VERSION_ZERO_HEADER = "Set-cookie"
+    private const val VERSION_ONE_HEADER = "Set-cookie2"
+    private const val COOKIE_HEADER = "Cookie"
+
+    private fun isCookieHeader(name: String): Boolean =
+        name.equals(VERSION_ZERO_HEADER, ignoreCase = true) ||
+            name.equals(VERSION_ONE_HEADER, ignoreCase = true)
+  }
+}