@rive-app/react-native 0.1.1-beta.0

package/android/src/main/java/com/margelo/nitro/rive/DataSourceResolver.kt

@@ -0,0 +1,36 @@
+package com.margelo.nitro.rive
+
+import android.net.Uri
+import java.net.URI
+
+object DataSourceResolver {
+  fun resolve(asset: ResolvedReferencedAsset): DataSource? {
+    asset.sourceUrl?.let { return resolveFromUrl(it) }
+    asset.sourceAssetId?.let { return resolveFromAssetId(it) }
+    asset.sourceAsset?.let { return DataSource.resource(it) }
+    return null
+  }
+
+  private fun resolveFromUrl(urlString: String): DataSource {
+    val uri = runCatching { URI(urlString) }.getOrElse {
+      throw DataLoaderException.InvalidURL(urlString)
+    }
+
+    return when (uri.scheme) {
+      "file" -> uri.path?.let { DataSource.File(it) }
+        ?: throw DataLoaderException.InvalidURL(urlString)
+      "http", "https" -> DataSource.Http(urlString)
+      else -> throw DataLoaderException.InvalidURL(urlString)
+    }
+  }
+
+  private fun resolveFromAssetId(assetId: String): DataSource {
+    val scheme = runCatching { Uri.parse(assetId).scheme }.getOrNull()
+
+    if (scheme != null) {
+      return resolveFromUrl(assetId)
+    }
+
+    return DataSource.Resource(assetId)
+  }
+}

package/android/src/main/java/com/margelo/nitro/rive/EventPropertiesOutputExtensions.kt

@@ -0,0 +1,12 @@
+package com.margelo.nitro.rive
+
+object EventPropertiesOutputExtensions {
+  fun boolean(value: Boolean): EventPropertiesOutput =
+    EventPropertiesOutput.First(value)
+
+  fun string(value: String): EventPropertiesOutput =
+    EventPropertiesOutput.Second(value)
+
+  fun number(value: Double): EventPropertiesOutput =
+    EventPropertiesOutput.Third(value)
+}

package/android/src/main/java/com/margelo/nitro/rive/FileDataLoader.kt

@@ -0,0 +1,21 @@
+package com.margelo.nitro.rive
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.io.File
+
+object FileDataLoader : DataLoader {
+  override suspend fun load(source: DataSource): ByteArray {
+    val fileSource = source as? DataSource.File
+      ?: throw DataLoaderException.InvalidSource
+    return loadBytes(fileSource.path)
+  }
+
+  suspend fun loadBytes(path: String): ByteArray = withContext(Dispatchers.IO) {
+    val file = File(path)
+    if (!file.exists()) {
+      throw DataLoaderException.FileNotFound(path)
+    }
+    file.readBytes()
+  }
+}

package/android/src/main/java/com/margelo/nitro/rive/HTTPDataLoader.kt

@@ -0,0 +1,37 @@
+package com.margelo.nitro.rive
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.net.HttpURLConnection
+import java.net.MalformedURLException
+import java.net.URL
+
+object HTTPDataLoader : DataLoader {
+  override suspend fun load(source: DataSource): ByteArray {
+    val httpSource = source as? DataSource.Http
+      ?: throw DataLoaderException.InvalidSource
+    return downloadBytes(httpSource.url)
+  }
+
+  suspend fun downloadBytes(url: String): ByteArray = withContext(Dispatchers.IO) {
+    val urlObj = try {
+      URL(url)
+    } catch (e: MalformedURLException) {
+      throw DataLoaderException.InvalidURL(url)
+    }
+    val connection = urlObj.openConnection() as HttpURLConnection
+
+    try {
+      connection.requestMethod = "GET"
+      val statusCode = connection.responseCode
+
+      if (statusCode !in 200..299) {
+        throw DataLoaderException.HttpError(statusCode, url)
+      }
+
+      connection.inputStream.use { it.readBytes() }
+    } finally {
+      connection.disconnect()
+    }
+  }
+}

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

@@ -0,0 +1,98 @@
+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
+import java.lang.ref.WeakReference
+import kotlinx.coroutines.CoroutineScope
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.SupervisorJob
+import kotlinx.coroutines.awaitAll
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.launch
+
+@Keep
+@DoNotStrip
+class HybridRiveFile : HybridRiveFileSpec() {
+  var riveFile: File? = null
+  var referencedAssetCache: ReferencedAssetCache? = null
+  var assetLoader: ReferencedAssetLoader? = null
+  private val weakViews = mutableListOf<WeakReference<HybridRiveView>>()
+  private val scope = CoroutineScope(Dispatchers.Main + SupervisorJob())
+
+  override val viewModelCount: Double?
+    get() = riveFile?.viewModelCount?.toDouble()
+
+  override fun viewModelByIndex(index: Double): HybridViewModelSpec? {
+    val vm = riveFile?.getViewModelByIndex(index.toInt()) ?: return null
+    return HybridViewModel(vm)
+  }
+
+  override fun viewModelByName(name: String): HybridViewModelSpec? {
+    val vm = riveFile?.getViewModelByName(name) ?: return null
+    return HybridViewModel(vm)
+  }
+
+  override fun defaultArtboardViewModel(artboardBy: ArtboardBy?): HybridViewModelSpec? {
+    try {
+      val artboard = when (artboardBy?.type) {
+        ArtboardByTypes.INDEX -> riveFile?.artboard(artboardBy.index!!.toInt())
+        ArtboardByTypes.NAME -> riveFile?.artboard(artboardBy.name!!)
+        null -> riveFile?.firstArtboard
+      } ?: return null
+
+      val vm = riveFile?.defaultViewModelForArtboard(artboard) ?: return null
+      return HybridViewModel(vm)
+    } catch (e: Exception) {
+      return null
+    }
+  }
+
+  fun registerView(view: HybridRiveView) {
+    weakViews.add(WeakReference(view))
+  }
+
+  fun unregisterView(view: HybridRiveView) {
+    weakViews.removeAll { it.get() == view }
+  }
+
+  private fun refreshAfterAssetChange() {
+    weakViews.removeAll { it.get() == null }
+
+    for (weakView in weakViews) {
+      weakView.get()?.refreshAfterAssetChange()
+    }
+  }
+
+  override fun updateReferencedAssets(referencedAssets: ReferencedAssetsType) {
+    val assetsData = referencedAssets.data ?: return
+    val cache = referencedAssetCache ?: return
+    val loader = assetLoader ?: return
+
+    val loadJobs = mutableListOf<kotlinx.coroutines.Deferred<Unit>>()
+
+    for ((key, assetData) in assetsData) {
+      val asset = cache[key] ?: continue
+      loadJobs.add(loader.updateAsset(assetData, asset))
+    }
+
+    if (loadJobs.isNotEmpty()) {
+      scope.launch {
+        loadJobs.awaitAll()
+        refreshAfterAssetChange()
+      }
+    }
+  }
+
+  override fun dispose() {
+    scope.cancel()
+    weakViews.clear()
+    assetLoader?.dispose()
+    assetLoader = null
+    riveFile?.release()
+    riveFile = null
+    referencedAssetCache?.clear()
+    referencedAssetCache = null
+  }
+}

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

@@ -0,0 +1,123 @@
+package com.margelo.nitro.rive
+
+import android.annotation.SuppressLint
+import androidx.annotation.Keep
+import app.rive.runtime.kotlin.core.File
+import app.rive.runtime.kotlin.core.Rive
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.Promise
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+import java.net.URI
+
+data class FileAndCache(
+  val file: File,
+  val cache: ReferencedAssetCache,
+  val loader: ReferencedAssetLoader?
+)
+
+@Keep
+@DoNotStrip
+class HybridRiveFileFactory : HybridRiveFileFactorySpec() {
+  private fun buildRiveFile(
+    data: ByteArray,
+    referencedAssets: ReferencedAssetsType?
+  ): FileAndCache {
+    val cache = mutableMapOf<String, app.rive.runtime.kotlin.core.FileAsset>()
+    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) {
+      File(data, Rive.defaultRendererType, customLoader)
+    } else {
+      File(data)
+    }
+
+    return FileAndCache(riveFile, cache, if (customLoader != null) loader else null)
+  }
+
+  override fun fromURL(url: String, loadCdn: Boolean, referencedAssets: ReferencedAssetsType?): Promise<HybridRiveFileSpec> {
+    return Promise.async {
+      try {
+        val fileAndCache = withContext(Dispatchers.IO) {
+          val riveData = HTTPDataLoader.downloadBytes(url)
+          buildRiveFile(riveData, referencedAssets)
+        }
+
+        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}", e)
+      }
+    }
+  }
+
+  override fun fromFileURL(fileURL: String, loadCdn: Boolean, referencedAssets: ReferencedAssetsType?): Promise<HybridRiveFileSpec> {
+    if (!fileURL.startsWith("file://")) {
+      throw Error("fromFileURL: URL must be a file URL: $fileURL")
+    }
+
+    return Promise.async {
+      try {
+        val uri = URI(fileURL)
+        val path = uri.path ?: throw Error("fromFileURL: Invalid URL: $fileURL")
+
+        val fileAndCache = withContext(Dispatchers.IO) {
+          val riveData = FileDataLoader.loadBytes(path)
+          buildRiveFile(riveData, referencedAssets)
+        }
+
+        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}")
+      }
+    }
+  }
+
+  @SuppressLint("DiscouragedApi")
+  override fun fromResource(resource: String, loadCdn: Boolean, referencedAssets: ReferencedAssetsType?): Promise<HybridRiveFileSpec> {
+    return Promise.async {
+      try {
+        val fileAndCache = withContext(Dispatchers.IO) {
+          val riveData = ResourceDataLoader.loadBytes(resource)
+          buildRiveFile(riveData, referencedAssets)
+        }
+
+        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}")
+      }
+    }
+  }
+
+  override fun fromBytes(bytes: ArrayBuffer, loadCdn: Boolean, referencedAssets: ReferencedAssetsType?): Promise<HybridRiveFileSpec> {
+    val buffer = bytes.getBuffer(false)
+    return Promise.async {
+      try {
+        val byteArray = ByteArray(buffer.remaining())
+        buffer.get(byteArray)
+        val fileAndCache = buildRiveFile(byteArray, referencedAssets)
+        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}")
+      }
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/rive/HybridRiveImage.kt

@@ -0,0 +1,15 @@
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import app.rive.runtime.kotlin.core.RiveRenderImage
+import com.facebook.proguard.annotations.DoNotStrip
+
+@Keep
+@DoNotStrip
+class HybridRiveImage(
+  val renderImage: RiveRenderImage,
+  private val dataSize: Int
+) : HybridRiveImageSpec() {
+  override val byteSize: Double
+    get() = dataSize.toDouble()
+}

package/android/src/main/java/com/margelo/nitro/rive/HybridRiveImageFactory.kt

@@ -0,0 +1,23 @@
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import app.rive.runtime.kotlin.core.RiveRenderImage
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.ArrayBuffer
+import com.margelo.nitro.core.Promise
+
+@Keep
+@DoNotStrip
+class HybridRiveImageFactory : HybridRiveImageFactorySpec() {
+  private fun loadFromDataSource(source: DataSource): Promise<HybridRiveImageSpec> = Promise.async {
+    val imageData = source.createLoader().load(source)
+    val renderImage = RiveRenderImage.fromEncoded(imageData)
+    HybridRiveImage(renderImage, imageData.size)
+  }
+
+  override fun loadFromURLAsync(url: String) = loadFromDataSource(DataSource.fromURL(url))
+
+  override fun loadFromResourceAsync(resource: String) = loadFromDataSource(DataSource.resource(resource))
+
+  override fun loadFromBytesAsync(bytes: ArrayBuffer) = loadFromDataSource(DataSource.Bytes.from(bytes))
+}

package/android/src/main/java/com/margelo/nitro/rive/HybridRiveView.kt

@@ -0,0 +1,279 @@
+package com.margelo.nitro.rive
+
+import androidx.annotation.Keep
+import com.facebook.proguard.annotations.DoNotStrip
+import com.facebook.react.uimanager.ThemedReactContext
+import com.margelo.nitro.core.Promise
+import com.rive.BindData
+import com.rive.RiveReactNativeView
+import com.rive.ViewConfiguration
+import app.rive.runtime.kotlin.core.Fit as RiveFit
+import app.rive.runtime.kotlin.core.Alignment as RiveAlignment
+import app.rive.runtime.kotlin.core.errors.*
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.withContext
+
+fun Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName?.toBindData(): BindData {
+  if (this == null) return BindData.Auto
+
+  return when (this) {
+    is Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.First -> {
+      val instance = (this.asFirstOrNull() as? HybridViewModelInstance)?.viewModelInstance
+        ?: throw Error("Invalid ViewModelInstance")
+      BindData.Instance(instance)
+    }
+    is Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.Second -> {
+      when (this.asSecondOrNull()) {
+        DataBindMode.AUTO -> BindData.Auto
+        DataBindMode.NONE -> BindData.None
+        else -> BindData.None
+      }
+    }
+    is Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName.Third -> {
+      val name = this.asThirdOrNull()?.byName ?: throw Error("Missing byName value")
+      BindData.ByName(name)
+    }
+  }
+}
+
+object DefaultConfiguration {
+  const val AUTOPLAY = true
+  val FIT = RiveFit.CONTAIN
+  val ALIGNMENT = RiveAlignment.CENTER
+  val LAYOUTSCALEFACTOR = null
+}
+
+@Keep
+@DoNotStrip
+class HybridRiveView(val context: ThemedReactContext) : HybridRiveViewSpec() {
+  companion object {
+    private const val TAG = "HybridRiveView"
+  }
+
+  //region State
+  override val view: RiveReactNativeView = RiveReactNativeView(context)
+  private var needsReload = false
+  private var dataBindingChanged = false
+  private var initialUpdate = true
+  private var registeredFile: HybridRiveFile? = null
+  //endregion
+
+  //region View Props
+  override var artboardName: String? = null
+    set(value) {
+      changed(field, value) { field = it }
+    }
+  override var stateMachineName: String? = null
+    set(value) {
+      changed(field, value) { field = it }
+    }
+  override var autoPlay: Boolean? = null
+    set(value) {
+      changed(field, value) { field = it }
+    }
+  override var file: HybridRiveFileSpec = HybridRiveFile()
+    set(value) {
+      if (field != value) {
+        registeredFile?.unregisterView(this)
+        registeredFile = null
+      }
+      changed(field, value) { field = it }
+    }
+  override var alignment: Alignment? = null
+  override var fit: Fit? = null
+  override var layoutScaleFactor: Double? = null
+  override var dataBind: Variant_HybridViewModelInstanceSpec_DataBindMode_DataBindByName? = null
+    set(value) {
+      if (field != value) {
+        field = value
+        dataBindingChanged = true
+      }
+    }
+  override var onError: (error: RiveError) -> Unit = {}
+  //endregion
+
+  //region View Methods
+  override fun awaitViewReady(): Promise<Boolean> {
+    return Promise.async {
+      withContext(Dispatchers.Main) {
+        view.awaitViewReady()
+      }
+    }
+  }
+
+  override fun bindViewModelInstance(viewModelInstance: HybridViewModelInstanceSpec) =
+    executeOnUiThread {
+      val hybridVmi = viewModelInstance as? HybridViewModelInstance ?: return@executeOnUiThread
+      view.bindViewModelInstance(hybridVmi.viewModelInstance)
+    }
+
+  override fun getViewModelInstance(): HybridViewModelInstanceSpec? {
+    val viewModelInstance = view.getViewModelInstance() ?: return null
+    return HybridViewModelInstance(viewModelInstance)
+  }
+
+  override fun play() = asyncExecuteOnUiThread { view.play() }
+
+  override fun pause() = asyncExecuteOnUiThread { view.pause() }
+
+  override fun reset() = asyncExecuteOnUiThread { view.reset() }
+
+  override fun playIfNeeded() = view.playIfNeeded()
+
+  override fun onEventListener(onEvent: (event: UnifiedRiveEvent) -> Unit) =
+    executeOnUiThread { view.addEventListener(onEvent) }
+
+  override fun removeEventListeners() = executeOnUiThread { view.removeEventListeners() }
+
+  override fun setNumberInputValue(name: String, value: Double, path: String?) =
+    view.setNumberInputValue(name, value, path)
+
+  override fun getNumberInputValue(name: String, path: String?): Double =
+    view.getNumberInputValue(name, path)
+
+  override fun setBooleanInputValue(name: String, value: Boolean, path: String?) =
+    view.setBooleanInputValue(name, value, path)
+
+  override fun getBooleanInputValue(name: String, path: String?): Boolean =
+    view.getBooleanInputValue(name, path)
+
+  override fun triggerInput(name: String, path: String?) = view.triggerInput(name, path)
+
+  override fun setTextRunValue(name: String, value: String, path: String?) =
+    view.setTextRunValue(name, value, path)
+
+  override fun getTextRunValue(name: String, path: String?): String =
+    view.getTextRunValue(name, path)
+  //endregion
+
+  //region Update
+  fun refreshAfterAssetChange() {
+    afterUpdate()
+  }
+
+  override fun afterUpdate() {
+    logged(TAG, "afterUpdate") {
+      val hybridFile = file as? HybridRiveFile
+      val riveFile = hybridFile?.riveFile ?: return@logged
+
+      val config = ViewConfiguration(
+        artboardName = artboardName,
+        stateMachineName = stateMachineName,
+        autoPlay = autoPlay ?: DefaultConfiguration.AUTOPLAY,
+        riveFile = riveFile,
+        alignment = convertAlignment(alignment) ?: DefaultConfiguration.ALIGNMENT,
+        fit = convertFit(fit) ?: DefaultConfiguration.FIT,
+        layoutScaleFactor = layoutScaleFactor?.toFloat() ?: DefaultConfiguration.LAYOUTSCALEFACTOR,
+        bindData = dataBind.toBindData()
+      )
+      view.configure(config, dataBindingChanged = dataBindingChanged, needsReload, initialUpdate = initialUpdate)
+
+      if (needsReload && hybridFile != null) {
+        hybridFile.registerView(this)
+        registeredFile = hybridFile
+      }
+
+      needsReload = false
+      dataBindingChanged = false
+      initialUpdate = false
+      super.afterUpdate()
+    }
+  }
+  //endregion
+
+  //region Helpers
+  private fun <T> changed(current: T, new: T, setter: (T) -> Unit) {
+    if (current != new) {
+      setter(new)
+      needsReload = true
+    }
+  }
+
+  private fun asyncExecuteOnUiThread(action: () -> Unit): Promise<Unit> {
+    return Promise.async {
+      context.currentActivity?.runOnUiThread {
+        try {
+          action()
+        } catch (e: Exception) {
+          throw Error(e.message) // TODO: Correctly handling errors (https://nitro.margelo.com/docs/errors)
+        } catch (e: Error) {
+          throw Error(e.message)
+        }
+      }
+    }
+  }
+
+  private fun executeOnUiThread(action: () -> Unit) {
+    context.currentActivity?.runOnUiThread {
+      try {
+        action()
+      } catch (e: Exception) {
+        throw Error(e.message) // TODO: Correctly handling errors (https://nitro.margelo.com/docs/errors)
+      } catch (e: Error) {
+        throw Error(e.message)
+      }
+    }
+  }
+
+  private fun convertAlignment(alignment: Alignment?): RiveAlignment? {
+    if (alignment == null) return null
+
+    return when (alignment) {
+      Alignment.TOPLEFT -> RiveAlignment.TOP_LEFT
+      Alignment.TOPCENTER -> RiveAlignment.TOP_CENTER
+      Alignment.TOPRIGHT -> RiveAlignment.TOP_RIGHT
+      Alignment.CENTERLEFT -> RiveAlignment.CENTER_LEFT
+      Alignment.CENTER -> RiveAlignment.CENTER
+      Alignment.CENTERRIGHT -> RiveAlignment.CENTER_RIGHT
+      Alignment.BOTTOMLEFT -> RiveAlignment.BOTTOM_LEFT
+      Alignment.BOTTOMCENTER -> RiveAlignment.BOTTOM_CENTER
+      Alignment.BOTTOMRIGHT -> RiveAlignment.BOTTOM_RIGHT
+    }
+  }
+
+  private fun convertFit(fit: Fit?): RiveFit? {
+    if (fit == null) return null
+
+    return when (fit) {
+      Fit.FILL -> RiveFit.FILL
+      Fit.CONTAIN -> RiveFit.CONTAIN
+      Fit.COVER -> RiveFit.COVER
+      Fit.FITWIDTH -> RiveFit.FIT_WIDTH
+      Fit.FITHEIGHT -> RiveFit.FIT_HEIGHT
+      Fit.NONE -> RiveFit.NONE
+      Fit.SCALEDOWN -> RiveFit.SCALE_DOWN
+      Fit.LAYOUT -> RiveFit.LAYOUT
+    }
+  }
+
+  private fun detectErrorType(exception: Exception): Pair<RiveErrorType, String> {
+    val message = exception.message ?: exception.toString()
+    val type = when (exception) {
+      is ArtboardException -> RiveErrorType.INCORRECTARTBOARDNAME
+      is StateMachineException -> RiveErrorType.INCORRECTSTATEMACHINENAME
+      is AnimationException -> RiveErrorType.UNKNOWN
+      is MalformedFileException -> RiveErrorType.MALFORMEDFILE
+      is StateMachineInputException -> RiveErrorType.INCORRECTSTATEMACHINEINPUTNAME
+      is TextValueRunException -> RiveErrorType.UNKNOWN
+      is ViewModelException -> RiveErrorType.VIEWMODELINSTANCENOTFOUND
+      else -> RiveErrorType.UNKNOWN
+    }
+    return Pair(type, message)
+  }
+
+  fun logged(tag: String, note: String? = null, fn: () -> Unit) {
+    try {
+      fn()
+    } catch (e: Exception) {
+      val (errorType, errorDescription) = detectErrorType(e)
+      val noteString = note?.let { " $it" } ?: ""
+      val errorMessage = "[RIVE] $tag$noteString $errorDescription"
+      val riveError = RiveError(
+        type = errorType,
+        message = errorMessage
+      )
+      onError(riveError)
+    }
+  }
+  //endregion
+}