feat: rive-app#352

Author: zispidd

android/src/main/java/com/rivereactnative/RiveReactNativeView.kt

@@ -14,6 +14,7 @@ import app.rive.runtime.kotlin.controllers.RiveFileController
 import app.rive.runtime.kotlin.core.*
 import app.rive.runtime.kotlin.core.errors.*
 import app.rive.runtime.kotlin.renderers.PointerEvents
+import com.android.volley.DefaultRetryPolicy
 import com.android.volley.NetworkResponse
 import com.android.volley.ParseError
 import com.android.volley.Request
@@ -716,9 +717,33 @@ class RiveReactNativeView(private val context: ThemedReactContext) : FrameLayout
   }
 
 
-  private fun setUrlRiveResource(url: String, autoplay: Boolean = this.autoplay) {
+  private fun setUrlRiveResource(url: String) {
     downloadUrlAsset(url) { bytes ->
       try {
+        // Validate that we have valid content before attempting to create Rive file
+        if (bytes.isEmpty()) {
+          if (isUserHandlingErrors) {
+            val rnRiveError = RNRiveError.IncorrectRiveFileUrl
+            rnRiveError.message = "Downloaded file is empty from: $url"
+            sendErrorToRN(rnRiveError)
+          } else {
+            showRNRiveError("Downloaded file is empty from: $url", null)
+          }
+          return@downloadUrlAsset
+        }
+
+        // Basic validation - check if the content starts with the Rive file signature
+        if (!isValidRiveContent(bytes)) {
+          if (isUserHandlingErrors) {
+            val rnRiveError = RNRiveError.MalformedFile
+            rnRiveError.message = "Downloaded content is not a valid Rive file from: $url"
+            sendErrorToRN(rnRiveError)
+          } else {
+            showRNRiveError("Downloaded content is not a valid Rive file from: $url", null)
+          }
+          return@downloadUrlAsset
+        }
+
         riveAnimationView?.setRiveBytes(
           bytes,
           fit = this.fit,
@@ -737,6 +762,42 @@ class RiveReactNativeView(private val context: ThemedReactContext) : FrameLayout
     }
   }
 
+  /**
+   * Validates if the downloaded content is a valid Rive file by checking file signatures
+   */
+  private fun isValidRiveContent(bytes: ByteArray): Boolean {
+    if (bytes.size < 4) return false
+
+    // Check for Rive file signature (RIVE magic number)
+    // Rive files start with specific byte patterns
+    val header = bytes.take(4).toByteArray()
+
+    // Check for "RIVE" header (0x52495645)
+    if (header[0] == 0x52.toByte() && 
+        header[1] == 0x49.toByte() && 
+        header[2] == 0x56.toByte() && 
+        header[3] == 0x45.toByte()) {
+      return true
+    }
+
+    // Additional validation - check for common non-Rive content patterns
+    val headerString = String(header, Charsets.UTF_8)
+
+    // Check if it's HTML (error pages)
+    if (headerString.startsWith("<!DO") || headerString.startsWith("<htm")) {
+      return false
+    }
+
+    // Check if it's JSON (API error responses)
+    if (headerString.startsWith("{") || headerString.startsWith("[")) {
+      return false
+    }
+
+    // If we can't definitively identify it as non-Rive, let the Rive runtime validate it
+    // This allows for different Rive file formats/versions
+    return true
+  }
+
   fun setArtboardName(artboardName: String) {
     try {
       this.artboardName = artboardName
@@ -993,11 +1054,45 @@ class RiveReactNativeView(private val context: ThemedReactContext) : FrameLayout
       return
     }
 
+    // Properly encode the URL to handle spaces and special characters
+    val encodedUrl = try {
+      val uri = Uri.parse(url)
+      uri.toString() // This will properly encode the URL
+    } catch (e: Exception) {
+      handleInvalidUrlError(url)
+      return
+    }
+
     val queue = Volley.newRequestQueue(context)
 
     val stringRequest = RNRiveFileRequest(
-      url, listener
-    ) { error -> handleURLAssetError(url, error, isUserHandlingErrors) }
+      encodedUrl, listener
+    ) { error -> 
+      // Enhanced error handling for better debugging
+      val errorMessage = when {
+        error.networkResponse?.statusCode == 404 -> "File not found (404) at: $url"
+        error.networkResponse?.statusCode == 403 -> "Access forbidden (403) for: $url"
+        error.networkResponse?.statusCode == 500 -> "Server error (500) for: $url"
+        error.cause is java.net.SocketTimeoutException -> "Timeout downloading from: $url"
+        error.cause is java.net.UnknownHostException -> "Cannot resolve host for: $url"
+        else -> "Unable to download the Rive asset file from: $url"
+      }
+
+      if (isUserHandlingErrors) {
+        val rnRiveError = RNRiveError.IncorrectRiveFileUrl
+        rnRiveError.message = errorMessage
+        sendErrorToRN(rnRiveError)
+      } else {
+        showRNRiveError(errorMessage, error)
+      }
+    }
+
+    // Add timeout to prevent hanging requests
+    stringRequest.retryPolicy = DefaultRetryPolicy(
+      15000, // 15 second timeout
+      1, // no retries
+      DefaultRetryPolicy.DEFAULT_BACKOFF_MULT
+    )
 
     queue.add(stringRequest)
   }

ios/RNRiveError.swift

@@ -65,7 +65,7 @@ func createFileNotFoundError() -> NSError {
 }
 
 func createMalformedFileError() -> NSError {
-    return NSError(domain: RiveErrorDomain, code: RiveErrorCode.malformedFile.rawValue, userInfo: [NSLocalizedDescriptionKey: "Malformed Rive File", "name": "Malformed"])
+    return NSError(domain: RiveErrorDomain, code: RiveErrorCode.malformedFile.rawValue, userInfo: [NSLocalizedDescriptionKey: "Malformed Rive File - downloaded content is not a valid .riv file", "name": "Malformed"])
 }
 
 func createAssetFileError(_ assetName: String) -> NSError {

ios/RiveReactNativeView.swift

@@ -352,6 +352,13 @@ class RiveReactNativeView: RCTView, RivePlayerDelegate, RiveStateMachineDelegate
           handleRiveError(error: createIncorrectRiveURL(url))
           return
         }
+
+        // Validate that we have valid Rive content before attempting to create RiveFile
+        if !isValidRiveContent(data) {
+          handleRiveError(error: createMalformedFileError())
+          return
+        }
+
         do {
           let riveFile = try RiveFile(data: data, loadCdn: true, customAssetLoader: customLoader)
           let riveModel = RiveModel(riveFile: riveFile)
@@ -378,6 +385,38 @@ class RiveReactNativeView: RCTView, RivePlayerDelegate, RiveStateMachineDelegate
       }
 
     }
+
+    /**
+     * Validates if the downloaded content is a valid Rive file by checking file signatures
+     */
+    private func isValidRiveContent(_ data: Data) -> Bool {
+        guard data.count >= 4 else { return false }
+
+        // Check for Rive file signature (RIVE magic number)
+        let header = data.prefix(4)
+
+        // Check for "RIVE" header (0x52495645)
+        if header[0] == 0x52 && header[1] == 0x49 && header[2] == 0x56 && header[3] == 0x45 {
+            return true
+        }
+
+        // Additional validation - check for common non-Rive content patterns
+        if let headerString = String(data: header, encoding: .utf8) {
+            // Check if it's HTML (error pages)
+            if headerString.hasPrefix("<!DO") || headerString.hasPrefix("<htm") {
+                return false
+            }
+
+            // Check if it's JSON (API error responses)
+            if headerString.hasPrefix("{") || headerString.hasPrefix("[") {
+                return false
+            }
+        }
+
+        // If we can't definitively identify it as non-Rive, let the Rive runtime validate it
+        // This allows for different Rive file formats/versions
+        return true
+    }
 
     private func reloadView() {
         if resourceFromBundle {
@@ -522,18 +561,66 @@ class RiveReactNativeView: RCTView, RivePlayerDelegate, RiveStateMachineDelegate
             return
         }
 
-        let queue = URLSession.shared
-        guard let requestUrl = URL(string: url) else {
+        // Properly encode the URL to handle spaces and special characters
+        guard let encodedUrlString = url.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed),
+              let requestUrl = URL(string: encodedUrlString) else {
             handleInvalidUrlError(url: url)
             return
         }
 
-        let request = URLRequest(url: requestUrl)
-        let task = queue.dataTask(with: request) {[weak self] data, response, error in
-            if error != nil {
-                self?.handleInvalidUrlError(url: url)
+        let session = URLSession.shared
+        var request = URLRequest(url: requestUrl)
+        request.timeoutInterval = 15.0 // 15 second timeout
+
+        let task = session.dataTask(with: request) {[weak self] data, response, error in
+            guard let self = self else { return }
+
+            if let error = error {
+                let errorMessage: String
+                if let urlError = error as? URLError {
+                    switch urlError.code {
+                    case .timedOut:
+                        errorMessage = "Timeout downloading from: \(url)"
+                    case .notConnectedToInternet:
+                        errorMessage = "No internet connection for: \(url)"
+                    case .cannotFindHost:
+                        errorMessage = "Cannot find host for: \(url)"
+                    case .fileDoesNotExist:
+                        errorMessage = "File not found at: \(url)"
+                    default:
+                        errorMessage = "Network error downloading from: \(url)"
+                    }
+                } else {
+                    errorMessage = "Unknown error downloading from: \(url)"
+                }
+
+                let customError = createIncorrectRiveURL(errorMessage)
+                self.handleRiveError(error: customError)
             } else if let data = data {
-                listener(data)
+                // Check HTTP response status
+                if let httpResponse = response as? HTTPURLResponse {
+                    switch httpResponse.statusCode {
+                    case 200...299:
+                        listener(data)
+                    case 404:
+                        let error = createIncorrectRiveURL("File not found (404) at: \(url)")
+                        self.handleRiveError(error: error)
+                    case 403:
+                        let error = createIncorrectRiveURL("Access forbidden (403) for: \(url)")
+                        self.handleRiveError(error: error)
+                    case 500...599:
+                        let error = createIncorrectRiveURL("Server error (\(httpResponse.statusCode)) for: \(url)")
+                        self.handleRiveError(error: error)
+                    default:
+                        let error = createIncorrectRiveURL("HTTP error (\(httpResponse.statusCode)) for: \(url)")
+                        self.handleRiveError(error: error)
+                    }
+                } else {
+                    listener(data)
+                }
+            } else {
+                let error = createIncorrectRiveURL("No data received from: \(url)")
+                self.handleRiveError(error: error)
             }
         }