react-native-tvos 0.77.1-0 → 0.78.0-0

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)
+  }
+}

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

@@ -14,7 +14,6 @@ import androidx.annotation.Nullable;
 import com.facebook.common.logging.FLog;
 import com.facebook.fbreact.specs.NativeNetworkingAndroidSpec;
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.GuardedAsyncTask;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.ReadableArray;
@@ -97,14 +96,14 @@ public final class NetworkingModule extends NativeNetworkingAndroidSpec {
       customClientBuilder = null;
 
   private final OkHttpClient mClient;
-  private final ForwardingCookieHandler mCookieHandler;
+  private final ForwardingCookieHandler mCookieHandler = new ForwardingCookieHandler();
   private final @Nullable String mDefaultUserAgent;
-  private final CookieJarContainer mCookieJarContainer;
-  private final Set<Integer> mRequestIds;
+  private final @Nullable CookieJarContainer mCookieJarContainer;
+  private final Set<Integer> mRequestIds = new HashSet<>();
   private final List<RequestBodyHandler> mRequestBodyHandlers = new ArrayList<>();
   private final List<UriHandler> mUriHandlers = new ArrayList<>();
   private final List<ResponseHandler> mResponseHandlers = new ArrayList<>();
-  private boolean mShuttingDown;
+  private boolean mShuttingDown = false;
 
   public NetworkingModule(
       ReactApplicationContext reactContext,
@@ -121,11 +120,14 @@ public final class NetworkingModule extends NativeNetworkingAndroidSpec {
       client = clientBuilder.build();
     }
     mClient = client;
-    mCookieHandler = new ForwardingCookieHandler(reactContext);
-    mCookieJarContainer = (CookieJarContainer) mClient.cookieJar();
-    mShuttingDown = false;
+
+    CookieJar cookieJar = client.cookieJar();
+    if (cookieJar instanceof CookieJarContainer) {
+      mCookieJarContainer = (CookieJarContainer) client.cookieJar();
+    } else {
+      mCookieJarContainer = null;
+    }
     mDefaultUserAgent = defaultUserAgent;
-    mRequestIds = new HashSet<>();
   }
 
   /**
@@ -186,7 +188,9 @@ public final class NetworkingModule extends NativeNetworkingAndroidSpec {
 
   @Override
   public void initialize() {
-    mCookieJarContainer.setCookieJar(new JavaNetCookieJar(mCookieHandler));
+    if (mCookieJarContainer != null) {
+      mCookieJarContainer.setCookieJar(new JavaNetCookieJar(mCookieHandler));
+    }
   }
 
   @Override
@@ -195,7 +199,9 @@ public final class NetworkingModule extends NativeNetworkingAndroidSpec {
     cancelAllRequests();
 
     mCookieHandler.destroy();
-    mCookieJarContainer.removeCookieJar();
+    if (mCookieJarContainer != null) {
+      mCookieJarContainer.removeCookieJar();
+    }
 
     mRequestBodyHandlers.clear();
     mResponseHandlers.clear();
@@ -666,14 +672,7 @@ public final class NetworkingModule extends NativeNetworkingAndroidSpec {
   }
 
   private void cancelRequest(final int requestId) {
-    // We have to use AsyncTask since this might trigger a NetworkOnMainThreadException, this is an
-    // open issue on OkHttp: https://github.com/square/okhttp/issues/869
-    new GuardedAsyncTask<Void, Void>(getReactApplicationContext()) {
-      @Override
-      protected void doInBackgroundGuarded(Void... params) {
-        OkHttpCallUtil.cancelTag(mClient, Integer.valueOf(requestId));
-      }
-    }.execute();
+    OkHttpCallUtil.cancelTag(mClient, Integer.valueOf(requestId));
   }
 
   @ReactMethod

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

@@ -0,0 +1,48 @@
+/*
+ * 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.
+ */
+
+@file:Suppress("DEPRECATION_ERROR") // Conflicting okhttp versions
+
+package com.facebook.react.modules.network
+
+import java.util.ArrayList
+import okhttp3.Cookie
+import okhttp3.CookieJar
+import okhttp3.Headers
+import okhttp3.HttpUrl
+
+/** Basic okhttp3 CookieJar container */
+public class ReactCookieJarContainer : CookieJarContainer {
+
+  private var cookieJar: CookieJar? = null
+
+  override fun setCookieJar(cookieJar: CookieJar) {
+    this.cookieJar = cookieJar
+  }
+
+  override fun removeCookieJar() {
+    cookieJar = null
+  }
+
+  override fun saveFromResponse(url: HttpUrl, cookies: List<Cookie>) {
+    cookieJar?.saveFromResponse(url, cookies)
+  }
+
+  override fun loadForRequest(url: HttpUrl): List<Cookie> {
+    val cookieJar = cookieJar ?: return emptyList()
+    val cookies = cookieJar.loadForRequest(url)
+    val validatedCookies = ArrayList<Cookie>()
+    for (cookie in cookies) {
+      try {
+        val cookieChecker = Headers.Builder()
+        cookieChecker.add(cookie.name(), cookie.value())
+        validatedCookies.add(cookie)
+      } catch (ignored: IllegalArgumentException) {}
+    }
+    return validatedCookies
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/systeminfo/ReactNativeVersion.java

@@ -16,7 +16,7 @@ import java.util.Map;
 public class ReactNativeVersion {
   public static final Map<String, Object> VERSION = MapBuilder.<String, Object>of(
       "major", 0,
-      "minor", 77,
-      "patch", 1,
+      "minor", 78,
+      "patch", 0,
       "prerelease", "0");
 }