fix(Android, Tabs): Fix tabs icons loading in release mode (#3413)

## Description

This PR improves the approach to loading image assets used as tab icons,
addressing issues with inconsistent or unreliable URI resolution -
particularly around local resources and assets in Android builds (debug
vs. release).

Previously, the image loading logic assumed that assets would always be
bundled with a `_` prefix in release builds. However, this is not a
reliable assumption and can break under certain project setups or custom
bundling configurations. Assets are now resolved directly using the
appropriate `android.resource` or `android_asset` URI schemes.

Additionally, now I'm resolving both drawable and raw into the
`res:/<id>` URI format before being converted to the proper
`android.resource://` URI expected by Fresco. This ensures consistent
behavior regardless of resource type.

This change ensures that both local resources and bundled assets are
correctly rendered as tab icons across different build variants, without
relying on unstable heuristics.

Fixes
#3399

## Changes

- Updated the approach in TabsImageLoader

## Screenshots / GIFs

Here you can add screenshots / GIFs documenting your change.

You can add before / after section if you're changing some behavior.

### Before

Debug:
<img width="325" height="747" alt="debug-before"
src="https://github.com/user-attachments/assets/22af3dde-e5c2-4596-82d8-71bff06d03e5"
/>

Release:
<img width="325" height="746" alt="release-before"
src="https://github.com/user-attachments/assets/9dfae14a-7858-45f2-84ca-75a81bb674ed"
/>

### After

Debug:
<img width="322" height="748" alt="debug-after"
src="https://github.com/user-attachments/assets/3c2b2da6-4927-47ff-b779-2e173dbb17c7"
/>

Release:
<img width="328" height="745" alt="release-after"
src="https://github.com/user-attachments/assets/e5d00ff9-49ff-440e-8c0f-6eea21643254"
/>

## Test code and steps to reproduce

It's working fine it both debug and release in our examples, before and
after applying these changes. Therefore, I was testing it on a separate
application with this code snippet:

```js
import React from 'react';
import { StyleSheet, Text, View } from 'react-native';
import { createNativeBottomTabNavigator } from '@react-navigation/bottom-tabs/unstable';
import { NavigationContainer } from '@react-navigation/native';

const Tab = createNativeBottomTabNavigator();

function App() {
  return (
    <NavigationContainer>
      <Tab.Navigator>
        <Tab.Screen
          name="Home"
          component={HomeScreen}
          options={{
            tabBarIcon: {
              type: "drawableResource",
              name: "custom_home_icon"
            },
          }}
        />
        <Tab.Screen
          name="Profile"
          component={ProfileScreen}
          options={{
            tabBarIcon: {
              type: 'image',
              source: require('./assets/icon_fill.png'),
            },
          }}
        />
        <Tab.Screen
          name="Settings"
          component={SettingsScreen}
          options={{
            tabBarIcon: {
              type: 'image',
              source: require('./assets/icon.png'),
            },
          }}
        />
      </Tab.Navigator>
    </NavigationContainer>
  );
}

const HomeScreen = () => (
  <View style={styles.container}>
    <Text>Home</Text>
  </View>
);

const ProfileScreen = () => (
  <View style={styles.container}>
    <Text>Profile</Text>
  </View>
);

const SettingsScreen = () => (
  <View style={styles.container}>
    <Text>Settings</Text>
  </View>
);

const styles = StyleSheet.create({
  container: {
    flex: 1,
    justifyContent: 'center',
    alignItems: 'center'
  },
});

export default App;
```

I'm adding `custom_home_icon` via android resource manager and other
icons via `assets/` directory

## Checklist

- [x] Included code example that can be used to test this change
- [x] Ensured that CI passes

Author: t0maboro

android/src/main/java/com/swmansion/rnscreens/gamma/tabs/image/TabsImageLoader.kt

@@ -1,12 +1,13 @@
 package com.swmansion.rnscreens.gamma.tabs.image
 
+import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.drawable.Drawable
+import android.net.Uri
 import android.os.Handler
 import android.os.Looper
 import android.util.Log
 import androidx.core.graphics.drawable.toDrawable
-import androidx.core.net.toUri
 import com.facebook.common.executors.CallerThreadExecutor
 import com.facebook.common.references.CloseableReference
 import com.facebook.datasource.BaseDataSubscriber
@@ -16,6 +17,7 @@ import com.facebook.imagepipeline.image.CloseableImage
 import com.facebook.imagepipeline.image.CloseableStaticBitmap
 import com.facebook.imagepipeline.request.ImageRequestBuilder
 import com.swmansion.rnscreens.gamma.tabs.TabScreen
+import java.util.Locale
 
 internal fun loadTabImage(
     context: Context,
@@ -25,7 +27,8 @@ internal fun loadTabImage(
     // Since image loading might happen on a background thread
     // ref. https://frescolib.org/docs/intro-image-pipeline.html
     // We should schedule rendering the result on the UI thread
-    loadTabImageInternal(context, uri) { drawable ->
+    val resolvedUri = ImageSource(context, uri).getUri(context) ?: return
+    loadTabImageInternal(context, resolvedUri) { drawable ->
         Handler(Looper.getMainLooper()).post {
             view.icon = drawable
         }
@@ -34,23 +37,12 @@ internal fun loadTabImage(
 
 private fun loadTabImageInternal(
     context: Context,
-    uri: String,
+    uri: Uri,
     onLoaded: (Drawable) -> Unit,
 ) {
-    val source = resolveTabImageSource(context, uri) ?: return
-    val finalUri =
-        when (source) {
-            is RNSImageSource.DrawableRes -> {
-                "res://${context.packageName}/${source.resId}".toUri()
-            }
-            is RNSImageSource.UriString -> {
-                source.uri.toUri()
-            }
-        }
-
     val imageRequest =
         ImageRequestBuilder
-            .newBuilderWithSource(finalUri)
+            .newBuilderWithSource(uri)
             .build()
 
     val dataSource = Fresco.getImagePipeline().fetchDecodedImage(imageRequest, context)
@@ -78,37 +70,86 @@ private fun loadTabImageInternal(
     )
 }
 
-private fun resolveTabImageSource(
-    context: Context,
-    uri: String,
-): RNSImageSource? {
-    // In release builds, assets are coming with bundle and we need to work with resource id.
-    // In debug, metro is responsible for handling assets via http.
-    // At the moment, we're supporting images (drawable) and SVG icons (raw).
-    // For any other type, we may consider adding a support in the future if needed.
-    if (uri.startsWith("_")) {
-        val drawableResId = context.resources.getIdentifier(uri, "drawable", context.packageName)
-        if (drawableResId != 0) {
-            return RNSImageSource.DrawableRes(drawableResId)
+// Adapted from https://github.com/callstackincubator/react-native-bottom-tabs/blob/main/packages/react-native-bottom-tabs/android/src/main/java/com/rcttabview/ImageSource.kt
+private class ImageSource(
+    private val context: Context,
+    private val uriString: String?,
+) {
+    private fun isLocalResourceUri(uri: Uri?): Boolean = uri?.scheme?.startsWith("res") ?: false
+
+    fun getUri(context: Context): Uri? {
+        val uri = computeUri(context)
+        if (isLocalResourceUri(uri)) {
+            return Uri.parse(
+                uri!!.toString().replace("res:/", "android.resource://${context.packageName}/"),
+            )
         }
-        val rawResId = context.resources.getIdentifier(uri, "raw", context.packageName)
-        if (rawResId != 0) {
-            return RNSImageSource.DrawableRes(rawResId)
+        return uri
+    }
+
+    private fun computeUri(context: Context): Uri? {
+        val stringUri = uriString ?: return null
+
+        return try {
+            val uri = Uri.parse(stringUri)
+            // Verify scheme is set, so that relative uri (used by static resources) are not handled.
+            if (uri.scheme == null) {
+                computeLocalUri(stringUri, context)
+            } else {
+                uri
+            }
+        } catch (_: Exception) {
+            computeLocalUri(stringUri, context)
         }
-        Log.e("[RNScreens]", "Resource not found in drawable or raw: $uri")
-        return null
     }
 
-    // If asset isn't included in android source directories and we're loading it from given path.
-    return RNSImageSource.UriString(uri)
+    private fun computeLocalUri(
+        name: String,
+        context: Context,
+    ): Uri? = ResourceIdHelper.getResourceUri(context, name)
 }
 
-private sealed class RNSImageSource {
-    data class DrawableRes(
-        val resId: Int,
-    ) : RNSImageSource()
+// Adapted from https://github.com/expo/expo/blob/sdk-52/packages/expo-image/android/src/main/java/expo/modules/image/ResourceIdHelper.kt
+private object ResourceIdHelper {
+    private val idMap = mutableMapOf<String, Int>()
+
+    @SuppressLint("DiscouragedApi")
+    private fun getIdForResourceType(
+        context: Context,
+        name: String,
+        type: String,
+    ): Int {
+        if (name.isEmpty()) return -1
+        val normalizedName = name.lowercase(Locale.ROOT).replace("-", "_")
+        val key = "$type/$normalizedName"
+        synchronized(this) {
+            idMap[key]?.let { return it }
+            val id = context.resources.getIdentifier(normalizedName, type, context.packageName)
+            idMap[key] = id
+            return id
+        }
+    }
 
-    data class UriString(
-        val uri: String,
-    ) : RNSImageSource()
+    fun getResourceUri(
+        context: Context,
+        name: String,
+    ): Uri? {
+        val normalizedName = name.lowercase(Locale.ROOT).replace("-", "_")
+
+        val drawableResId = getIdForResourceType(context, name, "drawable")
+        if (drawableResId != 0) {
+            return Uri.parse("res:/$drawableResId")
+        }
+
+        val rawResId = getIdForResourceType(context, name, "raw")
+        if (rawResId != 0) {
+            return Uri.parse("res:/$rawResId")
+        }
+
+        return if (name.startsWith("asset:/")) {
+            Uri.parse("file:///android_asset/" + name.removePrefix("asset:/"))
+        } else {
+            Uri.parse("file:///android_asset/$name")
+        }
+    }
 }