react-native-tvos 0.78.0-0rc3 → 0.79.0-0

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

@@ -0,0 +1,85 @@
+/*
+ * 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 com.facebook.common.logging.FLog
+import com.facebook.react.common.ReactConstants
+import java.nio.ByteBuffer
+import java.nio.CharBuffer
+import java.nio.charset.Charset
+import java.nio.charset.CharsetDecoder
+
+/**
+ * Class to decode encoded strings from byte array chunks. As in different encodings single
+ * character could take up to 4 characters byte array passed to decode could have parts of the
+ * characters which can't be correctly decoded.
+ *
+ * This class is designed in assumption that original byte stream is correctly formatted string in
+ * given encoding. Otherwise some parts of the data won't be decoded.
+ */
+internal class ProgressiveStringDecoder(charset: Charset) {
+  private val decoder: CharsetDecoder = charset.newDecoder()
+  private var remainder: ByteArray? = null
+
+  /**
+   * Parses data to String If there is a partial multi-byte symbol on the edge of the String it get
+   * saved to the reminder and added to the string on the decodeNext call.
+   *
+   * @param data The byte array containing the encoded string data.
+   * @param initialLength The number of valid bytes in the provided data array that should be
+   *   decoded.
+   * @return The decoded string. If decoding fails, an empty string is returned.
+   */
+  fun decodeNext(data: ByteArray, initialLength: Int): String {
+    var length = initialLength
+    var decodeData: ByteArray = data
+
+    remainder?.let { r ->
+      decodeData = ByteArray(r.size + length)
+      System.arraycopy(r, 0, decodeData, 0, r.size)
+      System.arraycopy(data, 0, decodeData, r.size, length)
+      length += r.size
+    }
+
+    var decodeBuffer = ByteBuffer.wrap(decodeData, 0, length)
+    var result: CharBuffer? = null
+    var decoded = false
+    var remainderLength = 0
+
+    while (!decoded && (remainderLength < 4)) {
+      try {
+        result = decoder.decode(decodeBuffer)
+        decoded = true
+      } catch (e: CharacterCodingException) {
+        remainderLength++
+        decodeBuffer = ByteBuffer.wrap(decodeData, 0, length - remainderLength)
+      }
+    }
+
+    val hasRemainder = decoded && remainderLength > 0
+    if (hasRemainder) {
+      remainder =
+          ByteArray(remainderLength).apply {
+            System.arraycopy(decodeData, length - remainderLength, this, 0, remainderLength)
+          }
+    } else {
+      remainder = null
+    }
+
+    if (!decoded) {
+      FLog.w(ReactConstants.TAG, "failed to decode string from byte array")
+      return EMPTY_STRING
+    } else {
+      return result?.let { String(it.array(), 0, it.length) } ?: EMPTY_STRING
+    }
+  }
+
+  companion object {
+    private const val EMPTY_STRING = ""
+  }
+}

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

@@ -16,7 +16,7 @@ import okhttp3.Headers
 import okhttp3.HttpUrl
 
 /** Basic okhttp3 CookieJar container */
-internal class ReactCookieJarContainer : CookieJarContainer {
+public class ReactCookieJarContainer : CookieJarContainer {
 
   private var cookieJar: CookieJar? = null
 

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

@@ -0,0 +1,179 @@
+/*
+ * 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 okio versions
+
+package com.facebook.react.modules.network
+
+import android.content.Context
+import android.net.Uri
+import android.util.Base64
+import com.facebook.common.logging.FLog
+import com.facebook.react.common.ReactConstants
+import java.io.ByteArrayInputStream
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.io.FileInputStream
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.InputStream
+import java.io.OutputStream
+import java.net.URL
+import java.nio.channels.Channels
+import java.util.zip.GZIPOutputStream
+import okhttp3.MediaType
+import okhttp3.RequestBody
+import okio.BufferedSink
+import okio.ByteString
+import okio.Okio
+import okio.Source
+
+/**
+ * Helper class that provides the necessary methods for creating the [RequestBody] from a file
+ * specification, such as a contentUri.
+ */
+internal object RequestBodyUtil {
+  private const val CONTENT_ENCODING_GZIP = "gzip"
+  private const val NAME = "RequestBodyUtil"
+  private const val TEMP_FILE_SUFFIX = "temp"
+
+  /** Returns whether encode type indicates the body needs to be gzip-ed. */
+  @JvmStatic
+  fun isGzipEncoding(encodingType: String?): Boolean {
+    return CONTENT_ENCODING_GZIP.equals(encodingType, ignoreCase = true)
+  }
+
+  /**
+   * Returns the input stream for a file given by its contentUri. Returns null if the file has not
+   * been found or if an error as occurred.
+   */
+  @JvmStatic
+  fun getFileInputStream(context: Context, fileContentUriStr: String): InputStream? {
+    try {
+      val fileContentUri = Uri.parse(fileContentUriStr)
+
+      if (fileContentUri.scheme?.startsWith("http") == true) {
+        return getDownloadFileInputStream(context, fileContentUri)
+      }
+
+      if (fileContentUriStr.startsWith("data:")) {
+        val decodedDataUrString =
+            Base64.decode(
+                fileContentUriStr
+                    .split(",".toRegex())
+                    .dropLastWhile { it.isEmpty() }
+                    .toTypedArray()[1],
+                Base64.DEFAULT)
+        return ByteArrayInputStream(decodedDataUrString)
+      }
+
+      return context.contentResolver.openInputStream(fileContentUri)
+    } catch (e: Exception) {
+      FLog.e(ReactConstants.TAG, "Could not retrieve file for contentUri $fileContentUriStr", e)
+      return null
+    }
+  }
+
+  /**
+   * Download and cache a file locally. This should be used when document picker returns a URI that
+   * points to a file on the network. Returns input stream for the downloaded file.
+   */
+  @Throws(IOException::class)
+  private fun getDownloadFileInputStream(context: Context, uri: Uri): InputStream {
+    val outputDir = context.applicationContext.cacheDir
+    val file = File.createTempFile(NAME, TEMP_FILE_SUFFIX, outputDir)
+    file.deleteOnExit()
+
+    val url = URL(uri.toString())
+    FileOutputStream(file).use { stream ->
+      url.openStream().use { `is` ->
+        Channels.newChannel(`is`).use { channel ->
+          stream.channel.transferFrom(channel, 0, Long.MAX_VALUE)
+          return FileInputStream(file)
+        }
+      }
+    }
+  }
+
+  /** Creates a [RequestBody] from a mediaType and gzip-ed body string. */
+  @JvmStatic
+  fun createGzip(mediaType: MediaType?, body: String): RequestBody? {
+    val gzipByteArrayOutputStream = ByteArrayOutputStream()
+    try {
+      val gzipOutputStream: OutputStream = GZIPOutputStream(gzipByteArrayOutputStream)
+      gzipOutputStream.write(body.toByteArray())
+      gzipOutputStream.close()
+    } catch (e: IOException) {
+      return null
+    }
+    @Suppress("DEPRECATION")
+    return RequestBody.create(mediaType, gzipByteArrayOutputStream.toByteArray())
+  }
+
+  /**
+   * Reference:
+   * https://github.com/square/okhttp/blob/8c8c3dbcfa91e28de2e13975ec414e07f153fde4/okhttp/src/commonMain/kotlin/okhttp3/internal/-UtilCommon.kt#L281-L288
+   * Checked exceptions will be ignored
+   */
+  private fun closeQuietly(source: Source) {
+    try {
+      source.close()
+    } catch (e: RuntimeException) {
+      throw e
+    } catch (e: Exception) {
+      // no-op
+    }
+  }
+
+  /** Creates a [RequestBody] from a mediaType and inputStream given. */
+  @JvmStatic
+  fun create(mediaType: MediaType?, inputStream: InputStream): RequestBody {
+    return object : RequestBody() {
+      override fun contentType(): MediaType? {
+        return mediaType
+      }
+
+      override fun contentLength(): Long {
+        return try {
+          inputStream.available().toLong()
+        } catch (e: IOException) {
+          0
+        }
+      }
+
+      @Throws(IOException::class)
+      override fun writeTo(sink: BufferedSink) {
+        var source: Source? = null
+        try {
+          source = Okio.source(inputStream)
+          sink.writeAll(source)
+        } finally {
+          source?.let { closeQuietly(it) }
+        }
+      }
+    }
+  }
+
+  /** Creates a [ProgressRequestBody] that can be used for showing uploading progress. */
+  @JvmStatic
+  fun createProgressRequest(
+      requestBody: RequestBody,
+      listener: ProgressListener
+  ): ProgressRequestBody {
+    return ProgressRequestBody(requestBody, listener)
+  }
+
+  /** Creates an empty [RequestBody] if required by the http method spec, otherwise use null. */
+  @JvmStatic
+  fun getEmptyBody(method: String): RequestBody? {
+    return if (method == "POST" || method == "PUT" || method == "PATCH") {
+      @Suppress("DEPRECATION") RequestBody.create(null, ByteString.EMPTY)
+    } else {
+      null
+    }
+  }
+}

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

@@ -0,0 +1,132 @@
+/*
+ * 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 com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import java.net.SocketTimeoutException
+
+/** Util methods to send network responses to JS. */
+internal object ResponseUtil {
+  @JvmStatic
+  fun onDataSend(
+      reactContext: ReactApplicationContext?,
+      requestId: Int,
+      progress: Long,
+      total: Long
+  ) {
+    reactContext?.emitDeviceEvent(
+        "didSendNetworkData",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushInt(progress.toInt())
+          pushInt(total.toInt())
+        })
+  }
+
+  @JvmStatic
+  fun onIncrementalDataReceived(
+      reactContext: ReactApplicationContext?,
+      requestId: Int,
+      data: String?,
+      progress: Long,
+      total: Long
+  ) {
+    reactContext?.emitDeviceEvent(
+        "didReceiveNetworkIncrementalData",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushString(data)
+          pushInt(progress.toInt())
+          pushInt(total.toInt())
+        })
+  }
+
+  @JvmStatic
+  fun onDataReceivedProgress(
+      reactContext: ReactApplicationContext?,
+      requestId: Int,
+      progress: Long,
+      total: Long
+  ) {
+    reactContext?.emitDeviceEvent(
+        "didReceiveNetworkDataProgress",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushInt(progress.toInt())
+          pushInt(total.toInt())
+        })
+  }
+
+  @JvmStatic
+  fun onDataReceived(reactContext: ReactApplicationContext?, requestId: Int, data: String?) {
+    reactContext?.emitDeviceEvent(
+        "didReceiveNetworkData",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushString(data)
+        })
+  }
+
+  @JvmStatic
+  fun onDataReceived(reactContext: ReactApplicationContext?, requestId: Int, data: WritableMap?) {
+    reactContext?.emitDeviceEvent(
+        "didReceiveNetworkData",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushMap(data)
+        })
+  }
+
+  @JvmStatic
+  fun onRequestError(
+      reactContext: ReactApplicationContext?,
+      requestId: Int,
+      error: String?,
+      e: Throwable?
+  ) {
+    reactContext?.emitDeviceEvent(
+        "didCompleteNetworkResponse",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushString(error)
+          if (e?.javaClass == SocketTimeoutException::class.java) {
+            pushBoolean(true) // last argument is a time out boolean
+          }
+        })
+  }
+
+  @JvmStatic
+  fun onRequestSuccess(reactContext: ReactApplicationContext?, requestId: Int) {
+    reactContext?.emitDeviceEvent(
+        "didCompleteNetworkResponse",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushNull()
+        })
+  }
+
+  @JvmStatic
+  fun onResponseReceived(
+      reactContext: ReactApplicationContext?,
+      requestId: Int,
+      statusCode: Int,
+      headers: WritableMap?,
+      url: String?
+  ) {
+    reactContext?.emitDeviceEvent(
+        "didReceiveNetworkResponse",
+        Arguments.createArray().apply {
+          pushInt(requestId)
+          pushInt(statusCode)
+          pushMap(headers)
+          pushString(url)
+        })
+  }
+}

package/ReactAndroid/src/main/java/com/facebook/react/modules/permissions/PermissionsModule.kt

@@ -37,7 +37,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
    * Check if the app has the permission given. successCallback is called with true if the
    * permission had been granted, false otherwise. See [Activity.checkSelfPermission].
    */
-  override public fun checkPermission(permission: String, promise: Promise): Unit {
+  public override fun checkPermission(permission: String, promise: Promise): Unit {
     val context = getReactApplicationContext().getBaseContext()
     promise.resolve(context.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED)
   }
@@ -50,7 +50,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
    * again). For devices before Android M, this always returns false. See
    * [permissionAwareActivity.shouldShowRequestPermissionRationale].
    */
-  override public fun shouldShowRequestPermissionRationale(
+  public override fun shouldShowRequestPermissionRationale(
       permission: String,
       promise: Promise
   ): Unit {
@@ -67,7 +67,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
    * user has the permission given or not and resolves with GRANTED or DENIED. See
    * [Activity.checkSelfPermission].
    */
-  override public fun requestPermission(permission: String, promise: Promise): Unit {
+  public override fun requestPermission(permission: String, promise: Promise): Unit {
     val context = getReactApplicationContext().getBaseContext()
     if (context.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED) {
       promise.resolve(GRANTED)
@@ -78,7 +78,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
       callbacks.put(
           requestCode,
           object : Callback {
-            override public operator fun invoke(vararg args: Any?) {
+            override operator fun invoke(vararg args: Any?) {
               val results = args[0] as IntArray
               if (results.size > 0 && results[0] == PackageManager.PERMISSION_GRANTED) {
                 promise.resolve(GRANTED)
@@ -99,7 +99,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
     }
   }
 
-  override public fun requestMultiplePermissions(
+  public override fun requestMultiplePermissions(
       permissions: ReadableArray,
       promise: Promise
   ): Unit {
@@ -125,7 +125,7 @@ public class PermissionsModule(reactContext: ReactApplicationContext?) :
       callbacks.put(
           requestCode,
           object : Callback {
-            override public operator fun invoke(vararg args: Any?) {
+            override operator fun invoke(vararg args: Any?) {
               val results = args[0] as IntArray
               val callbackActivity = args[1] as PermissionAwareActivity
               for (j in permissionsToCheck.indices) {

package/ReactAndroid/src/main/java/com/facebook/react/modules/share/ShareModule.kt

@@ -60,8 +60,8 @@ public class ShareModule(reactContext: ReactApplicationContext) :
 
   public companion object {
     public const val NAME: String = NativeShareModuleSpec.NAME
-    const private val ACTION_SHARED: String = "sharedAction"
-    const public val ERROR_INVALID_CONTENT: String = "E_INVALID_CONTENT"
-    const private val ERROR_UNABLE_TO_OPEN_DIALOG: String = "E_UNABLE_TO_OPEN_DIALOG"
+    private const val ACTION_SHARED: String = "sharedAction"
+    public const val ERROR_INVALID_CONTENT: String = "E_INVALID_CONTENT"
+    private const val ERROR_UNABLE_TO_OPEN_DIALOG: String = "E_UNABLE_TO_OPEN_DIALOG"
   }
 }

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", 78,
+      "minor", 79,
       "patch", 0,
-      "prerelease", "0rc3");
+      "prerelease", "0");
 }

package/ReactAndroid/src/main/java/com/facebook/react/modules/toast/ToastModule.kt

@@ -20,7 +20,7 @@ import com.facebook.react.module.annotations.ReactModule
 public class ToastModule(reactContext: ReactApplicationContext) :
     NativeToastAndroidSpec(reactContext) {
 
-  override public fun getTypedExportedConstants(): Map<String, Any> =
+  public override fun getTypedExportedConstants(): Map<String, Any> =
       mutableMapOf(
           DURATION_SHORT_KEY to Toast.LENGTH_SHORT,
           DURATION_LONG_KEY to Toast.LENGTH_LONG,
@@ -29,13 +29,13 @@ public class ToastModule(reactContext: ReactApplicationContext) :
           GRAVITY_CENTER to (Gravity.CENTER_HORIZONTAL or Gravity.CENTER_VERTICAL),
       )
 
-  override public fun show(message: String?, durationDouble: Double) {
+  public override fun show(message: String?, durationDouble: Double) {
     val duration = durationDouble.toInt()
     UiThreadUtil.runOnUiThread(
         Runnable { Toast.makeText(getReactApplicationContext(), message, duration).show() })
   }
 
-  override public fun showWithGravity(
+  public override fun showWithGravity(
       message: String?,
       durationDouble: Double,
       gravityDouble: Double
@@ -50,7 +50,7 @@ public class ToastModule(reactContext: ReactApplicationContext) :
         })
   }
 
-  override public fun showWithGravityAndOffset(
+  public override fun showWithGravityAndOffset(
       message: String?,
       durationDouble: Double,
       gravityDouble: Double,

package/ReactAndroid/src/main/java/com/facebook/react/packagerconnection/NotificationOnlyHandler.kt

@@ -11,10 +11,10 @@ import com.facebook.common.logging.FLog
 
 public abstract class NotificationOnlyHandler : RequestHandler {
 
-  override final fun onRequest(params: Any?, responder: Responder) {
+  final override fun onRequest(params: Any?, responder: Responder) {
     responder.error("Request is not supported")
     FLog.e(JSPackagerClient::class.java.simpleName, "Request is not supported")
   }
 
-  override abstract fun onNotification(params: Any?)
+  abstract override fun onNotification(params: Any?)
 }

package/ReactAndroid/src/main/java/com/facebook/react/packagerconnection/{RequestHandler.java → RequestHandler.kt}

@@ -5,12 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.packagerconnection;
-
-import androidx.annotation.Nullable;
+package com.facebook.react.packagerconnection
 
 public interface RequestHandler {
-  void onRequest(@Nullable Object params, Responder responder);
+  public fun onRequest(params: Any?, responder: Responder)
 
-  void onNotification(@Nullable Object params);
+  public fun onNotification(params: Any?)
 }

package/ReactAndroid/src/main/java/com/facebook/react/packagerconnection/RequestOnlyHandler.kt

@@ -11,9 +11,9 @@ import com.facebook.common.logging.FLog
 
 public abstract class RequestOnlyHandler : RequestHandler {
 
-  override abstract fun onRequest(params: Any?, responder: Responder)
+  abstract override fun onRequest(params: Any?, responder: Responder)
 
-  override final fun onNotification(params: Any?) {
+  final override fun onNotification(params: Any?) {
     FLog.e(JSPackagerClient::class.java.simpleName, "Notification is not supported")
   }
 }

package/ReactAndroid/src/main/java/com/facebook/react/packagerconnection/{Responder.java → Responder.kt}

@@ -5,10 +5,10 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-package com.facebook.react.packagerconnection;
+package com.facebook.react.packagerconnection
 
 public interface Responder {
-  void respond(Object result);
+  public fun respond(result: Any)
 
-  void error(Object error);
+  public fun error(error: Any)
 }

package/ReactAndroid/src/main/java/com/facebook/react/processing/ReactLegacyArchitectureProcessor.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.
+ */
+
+package com.facebook.react.processing
+
+import com.facebook.annotationprocessors.common.ProcessorBase
+import com.facebook.react.common.annotations.internal.LegacyArchitecture
+import java.io.FileWriter
+import java.io.IOException
+import javax.annotation.processing.RoundEnvironment
+import javax.annotation.processing.SupportedAnnotationTypes
+import javax.annotation.processing.SupportedSourceVersion
+import javax.lang.model.SourceVersion
+import javax.lang.model.element.TypeElement
+
+@SupportedAnnotationTypes("com.facebook.react.common.annotations.internal.LegacyArchitecture")
+@SupportedSourceVersion(SourceVersion.RELEASE_11)
+class ReactLegacyArchitectureProcessor : ProcessorBase() {
+  override fun processImpl(annotations: Set<TypeElement>, roundEnv: RoundEnvironment): Boolean {
+    val outputFileName = System.getenv()["RN_LEGACY_ARCH_OUTPUT_FILE_PATH"]
+    if (outputFileName.isNullOrEmpty()) {
+      return true
+    }
+    val elements = roundEnv.getElementsAnnotatedWith(LegacyArchitecture::class.java)
+    val classes: MutableList<String> = mutableListOf()
+
+    elements.forEach { element ->
+      val classType = element as TypeElement
+      val className = classType.qualifiedName.toString().replace(".", "/")
+      classes.add("type L$className;")
+    }
+
+    try {
+      FileWriter(outputFileName, true).use { writer ->
+        for (clazz in classes) {
+          writer.write(clazz + "\n")
+        }
+      }
+    } catch (e: IOException) {
+      throw RuntimeException(e)
+    }
+    return true
+  }
+}