feat(ios): referencedAssetLoader - update on native side

Author: mfazekas

android/src/main/java/com/margelo/nitro/rive/HybridRiveFile.kt

@@ -3,12 +3,14 @@ package com.margelo.nitro.rive
 import androidx.annotation.Keep
 import app.rive.runtime.kotlin.core.File
 import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.NitroModules
 
 @Keep
 @DoNotStrip
 class HybridRiveFile : HybridRiveFileSpec() {
   var riveFile: File? = null
   var referencedAssetCache: ReferencedAssetCache? = null
+  var assetLoader: ReferencedAssetLoader? = null
 
   override val viewModelCount: Double?
     get() = riveFile?.viewModelCount?.toDouble()
@@ -39,10 +41,20 @@ class HybridRiveFile : HybridRiveFileSpec() {
   }
 
   override fun updateReferencedAssets(referencedAssets: ReferencedAssetsType) {
-    // TODO: Implement dynamic asset updates
+    val assetsData = referencedAssets.data ?: return
+    val cache = referencedAssetCache ?: return
+    val loader = assetLoader ?: return
+    val context = NitroModules.applicationContext ?: return
+
+    for ((key, assetData) in assetsData) {
+      val asset = cache[key] ?: continue
+      loader.updateAsset(assetData, asset, context)
+    }
   }
 
   override fun release() {
+    assetLoader?.dispose()
+    assetLoader = null
     riveFile?.release()
     riveFile = null
     referencedAssetCache?.clear()

android/src/main/java/com/margelo/nitro/rive/HybridRiveFileFactory.kt

@@ -16,20 +16,20 @@ import java.net.URL
 
 data class FileAndCache(
   val file: File,
-  val cache: ReferencedAssetCache
+  val cache: ReferencedAssetCache,
+  val loader: ReferencedAssetLoader?
 )
 
 @Keep
 @DoNotStrip
 class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
-  private val assetLoader = ReferencedAssetLoader()
-
   private fun buildRiveFile(
     data: ByteArray,
     referencedAssets: ReferencedAssetsType?
   ): FileAndCache {
     val cache = mutableMapOf<String, app.rive.runtime.kotlin.core.FileAsset>()
-    val customLoader = assetLoader.createCustomLoader(referencedAssets, cache)
+    val loader = ReferencedAssetLoader()
+    val customLoader = loader.createCustomLoader(referencedAssets, cache)
 
     // TODO: The File object in Android does not have the concept of loading CDN assets
     val riveFile = if (customLoader != null) {
@@ -38,7 +38,7 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
       File(data)
     }
 
-    return FileAndCache(riveFile, cache)
+    return FileAndCache(riveFile, cache, if (customLoader != null) loader else null)
   }
 
   override fun fromURL(url: String, loadCdn: Boolean, referencedAssets: ReferencedAssetsType?): Promise<HybridRiveFileSpec> {
@@ -53,6 +53,7 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
         val hybridRiveFile = HybridRiveFile()
         hybridRiveFile.riveFile = fileAndCache.file
         hybridRiveFile.referencedAssetCache = fileAndCache.cache
+        hybridRiveFile.assetLoader = fileAndCache.loader
         hybridRiveFile
       } catch (e: Exception) {
         throw Error("Failed to download Rive file: ${e.message}")
@@ -79,6 +80,7 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
         val hybridRiveFile = HybridRiveFile()
         hybridRiveFile.riveFile = fileAndCache.file
         hybridRiveFile.referencedAssetCache = fileAndCache.cache
+        hybridRiveFile.assetLoader = fileAndCache.loader
         hybridRiveFile
       } catch (e: Exception) {
         throw Error("Failed to load Rive file: ${e.message}")
@@ -105,6 +107,7 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
         val hybridRiveFile = HybridRiveFile()
         hybridRiveFile.riveFile = fileAndCache.file
         hybridRiveFile.referencedAssetCache = fileAndCache.cache
+        hybridRiveFile.assetLoader = fileAndCache.loader
         hybridRiveFile
       } catch (e: Exception) {
         throw Error("Failed to load Rive file: ${e.message}")
@@ -122,6 +125,7 @@ class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
         val hybridRiveFile = HybridRiveFile()
         hybridRiveFile.riveFile = fileAndCache.file
         hybridRiveFile.referencedAssetCache = fileAndCache.cache
+        hybridRiveFile.assetLoader = fileAndCache.loader
         hybridRiveFile
       } catch (e: Exception) {
         throw Error("Failed to load Rive file from bytes: ${e.message}")

android/src/main/java/com/margelo/nitro/rive/ReferencedAssetLoader.kt

@@ -183,6 +183,10 @@ class ReferencedAssetLoader {
     }
   }
 
+  fun updateAsset(assetData: ResolvedReferencedAsset, asset: FileAsset, context: Context) {
+    loadAsset(assetData, asset, context)
+  }
+
   fun createCustomLoader(
     referencedAssets: ReferencedAssetsType?,
     cache: ReferencedAssetCache

ios/HybridRiveFile.swift

@@ -5,7 +5,8 @@ typealias ReferencedAssetCache = [String: RiveFileAsset]
 class HybridRiveFile: HybridRiveFileSpec {
   var riveFile: RiveFile?
   var referencedAssetCache: ReferencedAssetCache?
-  
+  var assetLoader: ReferencedAssetLoader?
+
   public func setRiveFile(_ riveFile: RiveFile) {
     self.riveFile = riveFile
   }
@@ -49,7 +50,19 @@ class HybridRiveFile: HybridRiveFileSpec {
   }
 
   func updateReferencedAssets(referencedAssets: ReferencedAssetsType) {
-    
+    guard let assetsData = referencedAssets.data,
+          let cache = referencedAssetCache,
+          let loader = assetLoader,
+          let riveFile = riveFile else {
+      return
+    }
+
+    let factory = RiveFactory()
+
+    for (key, assetData) in assetsData {
+      guard let asset = cache[key] else { continue }
+      loader.loadAsset(source: assetData, asset: asset, factory: factory)
+    }
   }
 
   func release() throws {

ios/HybridRiveFileFactory.swift

@@ -2,17 +2,18 @@ import NitroModules
 import RiveRuntime
 
 final class HybridRiveFileFactory: HybridRiveFileFactorySpec {
-  private let assetLoader = ReferencedAssetLoader()
-
-  private func buildRiveFile(data: Data, loadCdn: Bool,referencedAssets: ReferencedAssetsType?) throws -> FileAndCache  {
+  private func buildRiveFile(data: Data, loadCdn: Bool, referencedAssets: ReferencedAssetsType?) throws -> (file: RiveFile, cache: ReferencedAssetCache, loader: ReferencedAssetLoader?)  {
     var referencedAssetCache = Ref(ReferencedAssetCache())
-    let riveFile =
-    if let customLoader = assetLoader.createCustomLoader(referencedAssets: referencedAssets, cache: referencedAssetCache) {
-          try RiveFile(data: data, loadCdn: loadCdn, customAssetLoader: customLoader)
-        } else {
-          try RiveFile(data: data, loadCdn: loadCdn)
-        }
-    return FileAndCache(file: riveFile, cache: referencedAssetCache.value)
+    let assetLoader = ReferencedAssetLoader()
+    let customLoader = assetLoader.createCustomLoader(referencedAssets: referencedAssets, cache: referencedAssetCache)
+
+    let riveFile = if let customLoader = customLoader {
+      try RiveFile(data: data, loadCdn: loadCdn, customAssetLoader: customLoader)
+    } else {
+      try RiveFile(data: data, loadCdn: loadCdn)
+    }
+
+    return (file: riveFile, cache: referencedAssetCache.value, loader: customLoader != nil ? assetLoader : nil)
   }
 
   // MARK: Public Methods
@@ -71,6 +72,7 @@ final class HybridRiveFileFactory: HybridRiveFileFactorySpec {
         let hybridRiveFile = HybridRiveFile()
         hybridRiveFile.riveFile = riveFile.file
         hybridRiveFile.referencedAssetCache = riveFile.cache
+        hybridRiveFile.assetLoader = riveFile.loader
         return hybridRiveFile
       } catch let error as NSError {
         throw RuntimeError.error(withMessage: "Failed to load Rive file: \(error.localizedDescription)")

ios/ReferencedAssetLoader.swift

@@ -172,7 +172,7 @@ final class ReferencedAssetLoader {
     }
   }
 
-  private func loadAsset(
+  private func loadAssetInternal(
     source: ResolvedReferencedAsset, asset: RiveFileAsset, factory: RiveFactory
   ) {
     let sourceAssetId = source.sourceAssetId
@@ -188,6 +188,12 @@ final class ReferencedAssetLoader {
     }
   }
 
+  func loadAsset(
+    source: ResolvedReferencedAsset, asset: RiveFileAsset, factory: RiveFactory
+  ) {
+    loadAssetInternal(source: source, asset: asset, factory: factory)
+  }
+
   func createCustomLoader(referencedAssets: ReferencedAssetsType?, cache: Ref<ReferencedAssetCache>)
     -> LoadAsset?
   {
@@ -204,7 +210,7 @@ final class ReferencedAssetLoader {
 
       cache.value[asset.uniqueName()] = asset
 
-      self.loadAsset(source: assetData, asset: asset, factory: factory)
+      self.loadAssetInternal(source: assetData, asset: asset, factory: factory)
 
       return false
     }