@octopus-community/react-native 1.0.5 → 1.0.7

package/README.md

@@ -115,7 +115,7 @@ await initialize({
       onPrimary: '#FFFFFF', // Text color on primary background
     },
     logo: {
-      image: Image.resolveAssetSource(require('./assets/logo.png')), // Your custom logo
+      image: Image.resolveAssetSource(require('./assets/images/logo.png')), // Your custom logo
     },
   }
 });
@@ -186,7 +186,7 @@ await initialize({
       onPrimary: '#FFFFFF', // Text color on primary background
     },
     logo: {
-      image: Image.resolveAssetSource(require('./assets/logo.png')),
+      image: Image.resolveAssetSource(require('./assets/images/logo.png')),
     },
   }
 });
@@ -351,7 +351,7 @@ await initialize({
     },
     // Custom logo
     logo: {
-      image: Image.resolveAssetSource(require('./assets/logo.png')),
+      image: Image.resolveAssetSource(require('./assets/images/logo.png')),
     },
   }
 });
@@ -408,7 +408,7 @@ const switchToGreenTheme = async () => {
 - `caption1`: Small captions (default: 12pt)
 - `caption2`: Extra small captions (default: 10pt)
 
-   
+
 
 **Supported Formats:**
 - **Colors**: 3-digit (`#F63`), 6-digit (`#FF6633`), 8-digit (`#FF6633FF`) hex codes

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

@@ -12,7 +12,7 @@ class OctopusReactNativeSdkModule(reactContext: ReactApplicationContext) :
   private val sdkInitializer = OctopusSDKInitializer()
   private val eventEmitter = OctopusEventEmitter(reactContext)
   private val uiController = OctopusUIController(reactContext)
-  private val ssoAuthenticator = OctopusSSOAuthenticator(eventEmitter)
+  private val ssoAuthenticator = OctopusSSOAuthenticator(reactContext, eventEmitter)
 
   override fun getName(): String = NAME
 
@@ -85,10 +85,10 @@ class OctopusReactNativeSdkModule(reactContext: ReactApplicationContext) :
       promise.reject("UPDATE_THEME_ERROR", "Failed to update theme", e)
     }
   }
-  
+
   private fun parseColor(colorString: String?): String? {
     if (colorString == null) return null
-    
+
     return try {
       // Validate that the color string is a valid hex color
       android.graphics.Color.parseColor(colorString)
@@ -99,31 +99,31 @@ class OctopusReactNativeSdkModule(reactContext: ReactApplicationContext) :
       null
     }
   }
-  
+
   private fun parseFontsConfig(fontsMap: ReadableMap): OctopusFontsConfig? {
     // Use pre-processed configuration from TypeScript layer
     val parsedConfig = fontsMap.getMap("parsedConfig")
     if (parsedConfig != null) {
       return parsePreProcessedFontsConfig(parsedConfig)
     }
-    
+
     return null
   }
-  
+
   private fun parsePreProcessedFontsConfig(parsedConfig: ReadableMap): OctopusFontsConfig? {
     val textStylesMap = parsedConfig.getMap("textStyles")
     val textStyles = mutableMapOf<String, OctopusTextStyleConfig>()
-    
+
     // Parse pre-processed font configuration from TypeScript layer
     textStylesMap?.let { textStylesMap ->
       val textStyleKeys = arrayOf("title1", "title2", "body1", "body2", "caption1", "caption2")
-      
+
       textStyleKeys.forEach { key ->
         val textStyleMap = textStylesMap.getMap(key)
         textStyleMap?.let { style ->
           val fontType = style.getString("fontType")
           val fontSize = if (style.hasKey("fontSize")) style.getDouble("fontSize") else Double.NaN
-          
+
           if (fontType != null || (!fontSize.isNaN() && fontSize > 0)) {
             textStyles[key] = OctopusTextStyleConfig(
               fontType = fontType,
@@ -133,14 +133,14 @@ class OctopusReactNativeSdkModule(reactContext: ReactApplicationContext) :
         }
       }
     }
-    
+
     // Only create fonts config if we have text styles
     if (textStyles.isNotEmpty()) {
       return OctopusFontsConfig(
         textStyles = textStyles
       )
     }
-    
+
     return null
   }
 

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

@@ -18,11 +18,11 @@ class OctopusSDKInitializer {
 
     try {
       val connectionMode = parseConnectionMode(options)
-      
+
       // Store theme configuration for later use in UI
       val themeConfig = parseThemeConfig(options)
       OctopusThemeManager.setThemeConfig(themeConfig)
-      
+
       OctopusSDK.initialize(
         context = context,
         apiKey = apiKey,
@@ -35,19 +35,19 @@ class OctopusSDKInitializer {
       promise.reject("INITIALIZE_ERROR", "Failed to initialize Octopus SDK", e)
     }
   }
-  
+
   fun parseThemeConfig(options: ReadableMap): OctopusThemeConfig? {
-    
+
     val themeMap = options.getMap("theme")
     val colorScheme = options.getString("colorScheme") // Get colorScheme from React Native
-    
+
     var primaryColor: String? = null
     var primaryLowContrastColor: String? = null
     var primaryHighContrastColor: String? = null
     var onPrimaryColor: String? = null
     var logoSource: ReadableMap? = null
     var fontsConfig: OctopusFontsConfig? = null
-    
+
     // Parse colors from theme if available
     themeMap?.let { theme ->
       val colorsMap = theme.getMap("colors")
@@ -55,7 +55,7 @@ class OctopusSDKInitializer {
         // Check if this is a dual-mode theme (has light and dark properties)
         val lightColors = colors.getMap("light")
         val darkColors = colors.getMap("dark")
-        
+
         if (lightColors != null && darkColors != null) {
           // Dual-mode theme - select colors based on current color scheme
           val selectedColors = if (colorScheme == "dark") darkColors else lightColors
@@ -71,7 +71,7 @@ class OctopusSDKInitializer {
           onPrimaryColor = parseColor(if (colors.hasKey("onPrimary")) colors.getString("onPrimary") else null)
         }
       }
-      
+
       // Handle logo from theme
       val logoMap = theme.getMap("logo")
       logoMap?.let { logo ->
@@ -80,7 +80,7 @@ class OctopusSDKInitializer {
           logoSource = imageSource
         }
       }
-      
+
       // Handle fonts from theme - use pre-processed configuration from TypeScript layer
       val fontsMap = theme.getMap("fonts")
       fontsMap?.let { fonts ->
@@ -90,7 +90,7 @@ class OctopusSDKInitializer {
         }
       }
     }
-    
+
     // Handle logo at root level (for backward compatibility)
     if (logoSource == null) {
       val rootLogoMap = options.getMap("logo")
@@ -101,7 +101,7 @@ class OctopusSDKInitializer {
         }
       }
     }
-    
+
     // Only create theme config if we have at least one customization
     if (primaryColor != null || logoSource != null || colorScheme != null || fontsConfig != null) {
       return OctopusThemeConfig(
@@ -114,24 +114,24 @@ class OctopusSDKInitializer {
         fonts = fontsConfig
       )
     }
-    
+
     return null
   }
-  
+
   private fun parsePreProcessedFontsConfig(parsedConfig: ReadableMap): OctopusFontsConfig? {
     val textStylesMap = parsedConfig.getMap("textStyles")
     val textStyles = mutableMapOf<String, OctopusTextStyleConfig>()
-    
+
     // Parse pre-processed font configuration from TypeScript layer
     textStylesMap?.let { textStylesMap ->
       val textStyleKeys = arrayOf("title1", "title2", "body1", "body2", "caption1", "caption2")
-      
+
       textStyleKeys.forEach { key ->
         val textStyleMap = textStylesMap.getMap(key)
         textStyleMap?.let { style ->
           val fontType = style.getString("fontType")
           val fontSize = if (style.hasKey("fontSize")) style.getDouble("fontSize") else Double.NaN
-          
+
           if (fontType != null || (!fontSize.isNaN() && fontSize > 0)) {
             textStyles[key] = OctopusTextStyleConfig(
               fontType = fontType,
@@ -141,18 +141,18 @@ class OctopusSDKInitializer {
         }
       }
     }
-    
+
     // Only create fonts config if we have text styles
     if (textStyles.isNotEmpty()) {
       return OctopusFontsConfig(
         textStyles = textStyles
       )
     }
-    
+
     return null
   }
 
-  
+
   private fun extractResourceNameFromUri(uri: String): String? {
     // Extract resource name from React Native image URI
     // Examples: "logo.png" -> "logo", "images/logo.png" -> "logo"
@@ -163,10 +163,10 @@ class OctopusSDKInitializer {
       null
     }
   }
-  
+
   private fun parseColor(colorString: String?): String? {
     if (colorString == null) return null
-    
+
     return try {
       // Validate that the color string is a valid hex color
       Color.parseColor(colorString)

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

@@ -15,8 +15,13 @@ import java.util.UUID
 import java.util.concurrent.ConcurrentHashMap
 import kotlin.coroutines.resume
 import kotlin.coroutines.resumeWithException
+import android.content.Context
 
-class OctopusSSOAuthenticator(private val eventEmitter: OctopusEventEmitter) {
+
+class OctopusSSOAuthenticator(
+  private val context: Context,
+  private val eventEmitter: OctopusEventEmitter
+ ) {
 
   private val coroutineScope = CoroutineScope(Dispatchers.Main)
   private val pendingTokenRequests =
@@ -109,8 +114,22 @@ class OctopusSSOAuthenticator(private val eventEmitter: OctopusEventEmitter) {
     val profilePicture = profileParams.getString("profilePicture")?.let { pictureUrl ->
       if (pictureUrl.startsWith("http://") || pictureUrl.startsWith("https://")) {
         Image.Remote(pictureUrl)
-      } else {
+      } else if (pictureUrl.startsWith("file") || pictureUrl.startsWith("android.resource")) {
         Image.Local(pictureUrl)
+      } else if(pictureUrl.isNotBlank()) {
+        // Asset names like "assets_images_logo" need conversion
+        // Convert to drawable resource URI
+        val resourceId = context.resources.getIdentifier(pictureUrl, "drawable", context.packageName)
+        Image.Local(
+          if (resourceId != 0) {
+            "android.resource://${context.packageName}/$resourceId"
+          } else {
+            // Fallback: try assets folder
+            "file:///android_asset/$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.7",
   "description": "React Native module for the Octopus Community SDK",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",