@octopus-community/react-native 1.0.4 → 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/OctopusEventManager.swift

@@ -2,16 +2,16 @@ import React
 import Octopus
 
 class OctopusEventManager {
-  private weak var eventEmitter: RCTEventEmitter?
+  private weak var bridge: RCTBridge?
   private var hasListeners = false
   
-  init(eventEmitter: RCTEventEmitter) {
-    self.eventEmitter = eventEmitter
+  init(bridge: RCTBridge?) {
+    self.bridge = bridge
   }
   
   func emitLoginRequired() {
     if hasListeners {
-      eventEmitter?.sendEvent(withName: "loginRequired", body: nil)
+      bridge?.eventDispatcher().sendAppEvent(withName: "loginRequired", body: nil)
     }
   }
   
@@ -19,14 +19,14 @@ class OctopusEventManager {
     if hasListeners {
       let fieldToEdit = ProfileFieldMapper.toReactNativeString(profileField)
       let eventBody = ["fieldToEdit": fieldToEdit]
-      eventEmitter?.sendEvent(withName: "editUser", body: eventBody)
+      bridge?.eventDispatcher().sendAppEvent(withName: "editUser", body: eventBody)
     }
   }
   
   func emitUserTokenRequest(requestId: String) {
     if hasListeners {
       let eventBody = ["requestId": requestId]
-      eventEmitter?.sendEvent(withName: "userTokenRequest", body: eventBody)
+      bridge?.eventDispatcher().sendAppEvent(withName: "userTokenRequest", body: eventBody)
     }
   }
   
@@ -37,8 +37,4 @@ class OctopusEventManager {
   func stopObserving() {
     hasListeners = false
   }
-  
-  func supportedEvents() -> [String] {
-    return ["loginRequired", "editUser", "userTokenRequest"]
-  }
 }

package/ios/OctopusReactNativeSdk-Bridging-Header.h

@@ -1,3 +1,2 @@
 #import <React/RCTBridgeModule.h>
 #import <React/RCTViewManager.h>
-#import <React/RCTEventEmitter.h>

package/ios/OctopusReactNativeSdk.mm

@@ -1,7 +1,6 @@
 #import <React/RCTBridgeModule.h>
-#import <React/RCTEventEmitter.h>
 
-@interface RCT_EXTERN_MODULE(OctopusReactNativeSdk, RCTEventEmitter)
+@interface RCT_EXTERN_MODULE(OctopusReactNativeSdk, NSObject)
 
 RCT_EXTERN_METHOD(initialize:(NSDictionary *)options
                   withResolver:(RCTPromiseResolveBlock)resolve
@@ -37,6 +36,10 @@ RCT_EXTERN_METHOD(updateTheme:(NSDictionary *)themeOptions
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
 
+RCT_EXTERN_METHOD(addListener:(NSString *)eventName)
+
+RCT_EXTERN_METHOD(removeListeners:(NSInteger)count)
+
 + (BOOL)requiresMainQueueSetup
 {
   return NO;

package/ios/OctopusReactNativeSdk.swift

@@ -2,20 +2,33 @@ import Octopus
 import OctopusUI
 import SwiftUI
 import UIKit
+import React
 
 @objc(OctopusReactNativeSdk)
-class OctopusReactNativeSdk: RCTEventEmitter {
+class OctopusReactNativeSdk: NSObject, RCTBridgeModule {
 
   // MARK: - Properties
 
   private var octopusSDK: OctopusSDK?
   private lazy var uiManager = OctopusUIManager()
-  private lazy var eventManager = OctopusEventManager(eventEmitter: self)
+  private lazy var eventManager = OctopusEventManager(bridge: bridge)
   private let sdkInitializer = OctopusSDKInitializer()
   private var ssoAuthenticator: OctopusSSOAuthenticator?
   private var theme: OctopusTheme?
   private var logoSource: [String: Any]?
   private var fontConfiguration: [String: Any]?
+  
+  // MARK: - RCTBridgeModule
+  
+  @objc var bridge: RCTBridge!
+  
+  @objc static func moduleName() -> String! {
+    return "OctopusReactNativeSdk"
+  }
+  
+  @objc static func requiresMainQueueSetup() -> Bool {
+    return false
+  }
 
   // MARK: - Initialization
 
@@ -151,22 +164,19 @@ class OctopusReactNativeSdk: RCTEventEmitter {
     octopusSDK = nil
   }
 
-  @objc override func invalidate() {
+  @objc func invalidate() {
     cleanup()
-    super.invalidate()
   }
-
-  // MARK: - RCTEventEmitter overrides
-
-  @objc override func supportedEvents() -> [String]! {
-    return eventManager.supportedEvents()
-  }
-
-  @objc override func startObserving() {
+  
+  // MARK: - Event Listener Support for NativeEventEmitter
+  
+  @objc func addListener(_ eventName: String) {
+    // Start observing when listeners are added
     eventManager.startObserving()
   }
-
-  @objc override func stopObserving() {
+  
+  @objc func removeListeners(_ count: Int) {
+    // Stop observing when listeners are removed
     eventManager.stopObserving()
   }
 }

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.4",
+  "version": "1.0.6",
   "description": "React Native module for the Octopus Community SDK",
   "source": "./src/index.ts",
   "main": "./lib/module/index.js",
@@ -67,7 +67,7 @@
     "@evilmartians/lefthook": "^1.5.0",
     "@react-native/eslint-config": "^0.78.0",
     "@types/jest": "^29.5.5",
-    "@types/react": "^19.0.0",
+    "@types/react": "^19.1.0",
     "commitlint": "^19.6.1",
     "del-cli": "^5.1.0",
     "eslint": "^9.22.0",
@@ -75,8 +75,8 @@
     "eslint-plugin-prettier": "^5.2.3",
     "jest": "^29.7.0",
     "prettier": "^3.0.3",
-    "react": "19.0.0",
-    "react-native": "0.78.2",
+    "react": "19.1.0",
+    "react-native": "^0.81.4",
     "react-native-builder-bob": "^0.40.12",
     "turbo": "^1.10.7",
     "typedoc": "^0.28.7",