@octopus-community/react-native 1.0.5 → 1.0.6

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusSSOAuthenticator.kt

@@ -107,10 +107,12 @@ class OctopusSSOAuthenticator(private val eventEmitter: OctopusEventEmitter) {
     } else null
 
     val profilePicture = profileParams.getString("profilePicture")?.let { pictureUrl ->
-      if (pictureUrl.startsWith("http://") || pictureUrl.startsWith("https://")) {
+      if (pictureUrl.isNotBlank() && (pictureUrl.startsWith("http://") || pictureUrl.startsWith("https://"))) {
         Image.Remote(pictureUrl)
-      } else {
+      } else if (pictureUrl.isNotBlank()) {
         Image.Local(pictureUrl)
+      } else {
+        null
       }
     }
 

package/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusUIActivity.kt

@@ -44,6 +44,12 @@ import com.octopuscommunity.sdk.ui.octopusLightColorScheme
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.withContext
 import java.net.URL
+import java.util.concurrent.ConcurrentHashMap
+
+// Cache for loaded images to avoid reloading on recomposition
+private val imageCache = ConcurrentHashMap<String, Painter?>()
+// Cache for drawable resources list to avoid repeated reflection
+private var cachedDrawableResources: List<String>? = null
 
 class OctopusUIActivity : ComponentActivity() {
     private val closeUIReceiver = object : BroadcastReceiver() {
@@ -79,7 +85,7 @@ class OctopusUIActivity : ComponentActivity() {
 @Composable
 private fun OctopusUI(onBack: () -> Unit) {
     val context = LocalContext.current
-    
+
     // Get theme config once when UI is created - no need for polling
     val themeConfig = OctopusThemeManager.getThemeConfig()
 
@@ -122,19 +128,19 @@ private fun OctopusUI(onBack: () -> Unit) {
     // Handle logo loading using built-in Android capabilities
     var logoPainter by remember { mutableStateOf<Painter?>(null) }
 
-    LaunchedEffect(themeConfig) {
-        themeConfig?.logoSource?.let { logoSource ->
-            val uri = logoSource.getString("uri")
-            if (uri != null) {
-                logoPainter = loadImageFromUri(uri)
-            } else {
+        LaunchedEffect(themeConfig) {
+            themeConfig?.logoSource?.let { logoSource ->
+                val uri = logoSource.getString("uri")
+                if (uri != null) {
+                    logoPainter = loadImageFromUri(uri, context)
+                } else {
+                    logoPainter = null
+                }
+            } ?: run {
+                // No theme config or no logo source
                 logoPainter = null
             }
-        } ?: run {
-            // No theme config or no logo source
-            logoPainter = null
         }
-    }
 
     // Create drawables based on theme config
     val drawables = if (logoPainter != null) {
@@ -158,14 +164,14 @@ private fun OctopusUI(onBack: () -> Unit) {
 
 private fun createCustomTypography(themeConfig: OctopusThemeConfig?): OctopusTypography {
     val defaultTypography = OctopusTypographyDefaults.typography()
-    
+
     if (themeConfig?.fonts == null) {
         return defaultTypography
     }
-    
+
     val fontsConfig = themeConfig.fonts!!
     val textStyles = fontsConfig.textStyles
-    
+
     // Create custom typography based on new unified font configuration
     if (textStyles != null && textStyles.isNotEmpty()) {
         return OctopusTypographyDefaults.typography(
@@ -177,8 +183,8 @@ private fun createCustomTypography(themeConfig: OctopusThemeConfig?): OctopusTyp
             caption2 = createTextStyle(textStyles["caption2"], defaultTypography.caption2)
         )
     }
-    
-    
+
+
     return defaultTypography
 }
 
@@ -186,19 +192,19 @@ private fun createTextStyle(textStyleConfig: OctopusTextStyleConfig?, defaultSty
     if (textStyleConfig == null) {
         return defaultStyle
     }
-    
+
     val fontFamily = when (textStyleConfig.fontType) {
         "serif" -> FontFamily.Serif
         "monospace" -> FontFamily.Monospace
         "default" -> FontFamily.Default
         else -> FontFamily.Default
     }
-    
-    val fontSize = textStyleConfig.fontSize?.let { 
+
+    val fontSize = textStyleConfig.fontSize?.let {
         // Use points directly as sp (1 point ≈ 1 sp on Android)
         it.sp
     } ?: defaultStyle.fontSize
-    
+
     return defaultStyle.copy(
         fontFamily = fontFamily,
         fontSize = fontSize
@@ -247,21 +253,170 @@ private fun OctopusUIContent(onBack: () -> Unit) {
     }
 }
 
-private suspend fun loadImageFromUri(uri: String): Painter? {
+private suspend fun loadImageFromUri(uri: String, context: Context): Painter? {
+    // Check cache first
+    imageCache[uri]?.let { return it }
+
     return withContext(Dispatchers.IO) {
         try {
-            val url = URL(uri)
-            val inputStream = url.openStream()
-            val bitmap = BitmapFactory.decodeStream(inputStream)
-            inputStream.close()
-
-            if (bitmap != null) {
-                BitmapPainter(bitmap.asImageBitmap())
-            } else {
-                null
+            val result = when {
+                // Network URLs - load directly
+                uri.startsWith("http://", ignoreCase = true) ||
+                uri.startsWith("https://", ignoreCase = true) -> {
+                    loadFromNetwork(uri)
+                }
+                // Everything else - try as React Native asset
+                else -> {
+                    loadReactNativeAsset(uri, context)
+                }
             }
+
+            // Cache result (including null to avoid retrying failed loads)
+            imageCache[uri] = result
+            result
         } catch (e: Exception) {
+            Log.w("OctopusUIActivity", "Failed to load image from URI: $uri", e)
+            imageCache[uri] = null
             null
         }
     }
-}
+}
+
+private fun loadFromNetwork(url: String): Painter? {
+    return try {
+        URL(url).openStream().use { inputStream ->
+            val bitmap = BitmapFactory.decodeStream(inputStream)
+            bitmap?.let { BitmapPainter(it.asImageBitmap()) }
+        }
+    } catch (e: Exception) {
+        Log.w("OctopusUIActivity", "Failed to load image from network: $url", e)
+        null
+    }
+}
+
+private fun loadReactNativeAsset(assetName: String, context: Context): Painter? {
+    return try {
+        // First try: Direct drawable resource lookup (most common case)
+        val drawableResult = loadFromDrawableResources(assetName, context)
+        if (drawableResult != null) {
+            return drawableResult
+        }
+
+        // Second try: Assets folder with strategic path checking
+        loadFromAssetsFolder(assetName, context)
+    } catch (e: Exception) {
+        Log.w("OctopusUIActivity", "Failed to load asset: $assetName", e)
+        null
+    }
+}
+
+private fun loadFromAssetsFolder(assetName: String, context: Context): Painter? {
+    // Check if assetName already has extension
+    val hasExtension = assetName.contains(".")
+    val extensions = if (hasExtension) listOf("") else listOf("png", "jpg", "jpeg", "webp")
+
+    val folders = listOf(
+        "",
+        "drawable-mdpi",
+        "drawable-hdpi",
+        "drawable-xhdpi",
+        "drawable-xxhdpi",
+        "drawable-xxxhdpi",
+        "drawable"
+    )
+
+    for (folder in folders) {
+        for (ext in extensions) {
+            val filename = if (ext.isEmpty()) assetName else "$assetName.$ext"
+            val path = if (folder.isEmpty()) filename else "$folder/$filename"
+
+            try {
+                context.assets.open(path).use { inputStream ->
+                    val bitmap = BitmapFactory.decodeStream(inputStream)
+                    if (bitmap != null) {
+                        return BitmapPainter(bitmap.asImageBitmap())
+                    }
+                }
+            } catch (e: Exception) {
+                // Continue to next path
+            }
+        }
+    }
+
+    return null
+}
+
+private fun loadFromDrawableResources(assetName: String, context: Context): Painter? {
+    return try {
+        // Try exact match first
+        val resourceId = context.resources.getIdentifier(
+            assetName, "drawable", context.packageName
+        )
+        if (resourceId != 0) {
+            return loadBitmapFromResource(context, resourceId)
+        }
+
+        // Fallback: fuzzy search (only if exact match fails)
+        val drawableResources = getAllDrawableResources(context)
+        for (resourceName in drawableResources) {
+            if (isResourceNameMatch(resourceName, assetName)) {
+                val resId = context.resources.getIdentifier(
+                    resourceName, "drawable", context.packageName
+                )
+                if (resId != 0) {
+                    return loadBitmapFromResource(context, resId)
+                }
+            }
+        }
+
+        null
+    } catch (e: Exception) {
+        null
+    }
+}
+
+private fun loadBitmapFromResource(context: Context, resourceId: Int): Painter? {
+    return try {
+        val bitmap = BitmapFactory.decodeResource(context.resources, resourceId)
+        bitmap?.let { BitmapPainter(it.asImageBitmap()) }
+    } catch (e: Exception) {
+        null
+    }
+}
+
+private fun getAllDrawableResources(context: Context): List<String> {
+    // Return cached result if available
+    cachedDrawableResources?.let { return it }
+
+    return try {
+        val packageName = context.packageName
+        val drawableResources = mutableListOf<String>()
+
+        // Get all drawable resources by scanning the R.drawable class
+        val drawableClass = Class.forName("$packageName.R\$drawable")
+        val fields = drawableClass.declaredFields
+
+        for (field in fields) {
+            if (field.type == Int::class.javaPrimitiveType) {
+                drawableResources.add(field.name)
+            }
+        }
+
+        // Cache for future use
+        cachedDrawableResources = drawableResources
+        drawableResources
+    } catch (e: Exception) {
+        Log.w("OctopusUIActivity", "Failed to get drawable resources", e)
+        emptyList()
+    }
+}
+
+
+private fun isResourceNameMatch(resourceName: String, assetName: String): Boolean {
+    val normalizedResourceName = resourceName.lowercase()
+    val normalizedAssetName = assetName.lowercase()
+
+    // Only check if one contains the other - removed dangerous generic patterns
+    return normalizedResourceName.contains(normalizedAssetName) ||
+           normalizedAssetName.contains(normalizedResourceName)
+}

package/ios/OctopusSSOAuthenticator.swift

@@ -87,7 +87,7 @@ class OctopusSSOAuthenticator {
     let ageInformation: ClientUser.AgeInformation? = legalAgeReached != nil ? (legalAgeReached! ? .legalAgeReached : .underaged) : nil
     
     var profilePictureData: Data? = nil
-    if let pictureUrl = profileParams["profilePicture"] as? String {
+    if let pictureUrl = profileParams["profilePicture"] as? String, !pictureUrl.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
       profilePictureData = try await loadImageData(from: pictureUrl)
     }
     

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@octopus-community/react-native",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "React Native module for the Octopus Community SDK",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",