@octopus-community/react-native 1.0.7 → 1.9.1

package/OctopusReactNativeSdk.podspec

@@ -1,7 +1,7 @@
 require "json"
 
 package = JSON.parse(File.read(File.join(__dir__, "package.json")))
-octopus_version = '~> 1.5.1'
+octopus_version = '1.9.3'
 
 Pod::Spec.new do |s|
   s.name         = "OctopusReactNativeSdk"

package/README.md

@@ -1,7 +1,10 @@
 # @octopus-community/react-native
 
-React Native module for the Octopus Community [Android](https://github.com/Octopus-Community/octopus-sdk-android) and [Swift](https://github.com/Octopus-Community/octopus-sdk-swift) SDKs
+React Native module for the Octopus Community [Android](https://github.com/Octopus-Community/octopus-sdk-android) and [Swift](https://github.com/Octopus-Community/octopus-sdk-swift) SDKs.
 
+**Official documentation:** [Octopus Developer Guide](https://doc.octopuscommunity.com/) — for concepts, SSO setup, and native SDK details.
+
+- [Features](#features)
 - [Installation](#installation)
   - [iOS setup](#ios-setup)
   - [Compatibility table](#compatibility-table)
@@ -11,6 +14,18 @@ React Native module for the Octopus Community [Android](https://github.com/Octop
   - [API docs](./docs/api/README.md)
   - [Example app](./example)
 - [Troubleshooting](#troubleshooting)
+- [Documentation index](./docs/README.md)
+
+## Features
+
+- **SSO (Single Sign-On)** — Connect your users with JWT from your backend; app-managed profile fields
+- **Theme customization** — Colors, fonts, logo; light/dark and dual-mode support
+- **Display modes** — Fullscreen via [`openUI()`](./docs/api/functions/openUI.md) or embedded via the `OctopusUIView` component (see [API reference](./docs/api/README.md))
+- **Reactive events** — Unread notification count, community access state, and typed SDK events (content, interactions, gamification, navigation)
+- **Community access / A/B testing** — Two cases: (1) **Octopus manages the cohort**: the SDK decides who has access; use [`overrideCommunityAccess`](./docs/api/functions/overrideCommunityAccess.md) to override for testing and [`addHasAccessToCommunityListener`](./docs/api/functions/addHasAccessToCommunityListener.md) to react to the state. (2) **Your app manages access**: your app decides who sees the community (e.g. your own feature flag); use [`trackCommunityAccess`](./docs/api/functions/trackCommunityAccess.md) to report the value to Octopus for analytics only (it does not change actual access).
+- **Locale override** — Set SDK UI language programmatically ([`overrideDefaultLocale`](./docs/api/functions/overrideDefaultLocale.md))
+- **Custom analytics** — Track custom events ([`trackCustomEvent`](./docs/api/functions/trackCustomEvent.md))
+- **URL interception** — Handle link taps in your app ([`addNavigateToUrlListener`](./docs/api/functions/addNavigateToUrlListener.md))
 
 ## Installation
 
@@ -35,17 +50,15 @@ Due to a bug in XCode 15, you might need to set `ENABLE_USER_SCRIPT_SANDBOXING`
 
 ### Compatibility table
 
-| React Native version(s) | Android | iOS   | Old arch | New arch      | Supporting version(s) |
-|-------------------------| ------- |-------| -------- | ------------- | --------------------- |
-| v0.78+                  | 5.0+    | 14.0+ | ✅       | Interop layer | v1+                   |
+| React Native version(s) | Android | iOS   | Old arch | New arch      | Octopus native SDK |
+|-------------------------| ------- |-------| -------- | ------------- | ------------------- |
+| v0.81.x (tested 0.81.4)  | 5.0+    | 14.0+ | ✅       | Interop layer | 1.9                 |
 
-* Older React Native versions might be supported but were untested
-* New arch is currently supported with the interoperability layer
-* Other requirements for current version:
-  * Android
-    * Kotlin version 2
-  * iOS
-    * XCode 16.0+
+* Older React Native versions (e.g. v0.78+) may work but are untested
+* New architecture is supported via the React Native interoperability layer
+* Other requirements:
+  * **Android**: Kotlin 2.x
+  * **iOS**: Xcode 16.0+
 
 ### Expo
 
@@ -68,9 +81,9 @@ Configure `use_frameworks` (static or dynamic) with `expo-build-properties`:
 
 Initialize the SDK with your API key with [`initialize`](./docs/api/functions/initialize.md).
 
-Choose whether your app or Octopus handles user authentification:
+Choose whether your app or Octopus handles user authentication:
 
-#### Octopus-handled authentification
+#### Octopus-handled authentication
 
 ```ts
 import { initialize } from '@octopus-community/react-native';
@@ -85,9 +98,9 @@ await initialize({
 
 For SSO mode:
 
-* your app manages user authentication and certain profile fields. You specify which profile fields your app will handle directly
-* you need to provide a token provider function that returns a valid JWT token for the authenticated user.
-  * use the `useUserTokenProvider` hook in React components:
+* your app manages user authentication and certain profile fields; you specify which profile fields your app will handle directly
+* you must provide a token provider that returns a valid JWT for the connected user. **The JWT must be signed on your backend** using the secret key provided by Octopus — never embed the secret in the app. See [Generate a signed JWT for SSO](https://doc.octopuscommunity.com/backend/sso)
+* in React components, use the `useUserTokenProvider` hook to supply the token:
 
 ```ts
 import {
@@ -148,7 +161,6 @@ await connectUser({
     username: 'john_doe',
     profilePicture: 'https://example.com/avatar.jpg',
     biography: 'Software developer',
-    legalAgeReached: true,
   },
 });
 
@@ -162,9 +174,10 @@ editUserSubscription.remove();
 
 ### Show the UI
 
-Show the Octopus home screen with the [`openUI()`](./docs/api/functions/openUI.md) method.
+You can show the Octopus Community in two ways:
 
-Future versions of this React Native module will let you show the UI in your React components. Please reach out if you need this prioritized.
+- **Fullscreen** — Call [`openUI()`](./docs/api/functions/openUI.md) to open the native Octopus home screen (modal-style). Use [`closeUI()`](./docs/api/functions/closeUI.md) to dismiss it.
+- **Embedded** — Render the `OctopusUIView` component inside your React tree for an in-screen embed. Pass `displayMode="embed"` or `displayMode="fullscreen"` and optional theme/options. See the [API reference](./docs/api/README.md) and the [example app](./example) for usage.
 
 ### Theme Customization
 
@@ -438,24 +451,16 @@ For details about the Typescript API, head to the [API docs](./docs/api/README.m
 
 ### Example app
 
-Take a look at our [example app](./example/src/App.tsx) which demonstrates:
-
-- **Complete theming system** with multiple color themes and font customizations
-- **Dark/Light mode management** with system detection and forced modes
-- **Dual-mode color themes** with separate light and dark color sets
-- **Font customization** with different font types (serif, monospace, default) and sizes
-- **Theme switching** by re-initializing the SDK with new configurations
-- **Logo customization** with bundled image assets
-- **Interactive theme controls** to test different configurations
+The [example app](./example) demonstrates the full SDK surface. From the root, run `yarn example start` then `yarn example ios` or `yarn example android`. It uses a tabbed UI:
 
-The example app includes a comprehensive theme selector interface that lets you:
-- Switch between system, light, and dark modes
-- Choose from multiple pre-defined color themes (Theme 1, 2, 3, or None)
-- Customize font types (default, serif, monospace) and sizes (small, default, large)
-- Toggle custom logo display
-- See theme changes applied when the UI reopens
+| Tab | Purpose |
+|-----|---------|
+| **Setup** | Initialize the SDK (API key, SSO/Octopus mode), connect/disconnect user, display mode (fullscreen vs embed), locale override, URL interception toggle |
+| **Community** | Open the Octopus UI (fullscreen or embedded) with the current theme and options |
+| **Theme** | Theming: system/light/dark, color set, fonts, logo, bottom inset; see changes when reopening the UI |
+| **SDK Data** | Notifications count (refresh, listener), community access (override, track, listener), custom events, SDK event log |
 
-This is the perfect starting point to understand how to implement theming in your own React Native app.
+See [example/README.md](./example/README.md) for environment variables (API key, SSO user/token) and run instructions. The example is the best reference for implementing SSO, theming, reactive events, and URL interception in your app.
 
 ## Troubleshooting
 

package/android/build.gradle

@@ -85,6 +85,8 @@ dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation platform("androidx.compose:compose-bom:$compose_bom_version")
+  implementation "androidx.compose.foundation:foundation"
+  implementation "androidx.compose.material3:material3"
   implementation "androidx.navigation:navigation-compose:$android_x_navigation_version"
 
   api "com.octopuscommunity:octopus-sdk:$octopus_community_version"

package/android/gradle.properties

@@ -3,7 +3,7 @@ OctopusReactNativeSdk_minSdkVersion=24
 OctopusReactNativeSdk_targetSdkVersion=34
 OctopusReactNativeSdk_compileSdkVersion=35
 OctopusReactNativeSdk_ndkVersion=27.1.12297006
-OctopusReactNativeSdk_composeBomVersion=2025.06.01
+OctopusReactNativeSdk_composeBomVersion=2025.10.00
 OctopusReactNativeSdk_androidXNavigationVersion=2.9.0
 
-OctopusReactNativeSdk_octopusCommunityVersion=1.5.0
+OctopusReactNativeSdk_octopusCommunityVersion=1.9.1

package/android/src/main/AndroidManifest.xml

@@ -2,7 +2,8 @@
           package="com.octopuscommunity.octopusreactnativesdk">
   <application>
     <activity
-      android:name=".OctopusUIActivity"
+      android:name=".OctopusActivity"
+      android:windowSoftInputMode="adjustResize"
       android:exported="false"
       android:theme="@style/Theme.AppCompat.DayNight.NoActionBar"/>
   </application>

package/android/src/main/AndroidManifestNew.xml

@@ -1,8 +1,9 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
   <application>
     <activity
-      android:name=".OctopusUIActivity"
+      android:name=".OctopusActivity"
       android:exported="false"
+      android:windowSoftInputMode="adjustResize"
       android:theme="@style/Theme.AppCompat.DayNight.NoActionBar"/>
   </application>
 </manifest>

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

@@ -0,0 +1,56 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.content.IntentFilter
+import android.os.Build
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+import androidx.activity.enableEdgeToEdge
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.ui.Modifier
+
+class OctopusActivity : ComponentActivity() {
+
+  companion object {
+    const val EXTRA_INTERCEPT_URLS = "interceptUrls"
+  }
+
+  private val closeUIReceiver = object : BroadcastReceiver() {
+    override fun onReceive(context: Context?, intent: Intent?) {
+      finish()
+    }
+  }
+
+  override fun onCreate(savedInstanceState: Bundle?) {
+    super.onCreate(savedInstanceState)
+    enableEdgeToEdge()
+    registerCloseUIReceiver()
+    val interceptUrls = intent.getBooleanExtra(EXTRA_INTERCEPT_URLS, false)
+
+    setContent {
+      OctopusContent(
+        backButton = true,
+        interceptUrls = interceptUrls,
+        onBack = { finish() }
+      )
+    }
+  }
+
+  override fun onDestroy() {
+    super.onDestroy()
+    unregisterReceiver(closeUIReceiver)
+  }
+
+  private fun registerCloseUIReceiver() {
+    val intentFilter = IntentFilter(OctopusUIController.CLOSE_UI_ACTION)
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+      registerReceiver(closeUIReceiver, intentFilter, Context.RECEIVER_NOT_EXPORTED)
+    } else {
+      @Suppress("UnspecifiedRegisterReceiverFlag")
+      registerReceiver(closeUIReceiver, intentFilter)
+    }
+  }
+}

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

@@ -0,0 +1,396 @@
+package com.octopuscommunity.octopusreactnativesdk
+
+import android.content.Context
+import android.content.res.Configuration
+import android.graphics.BitmapFactory
+import android.util.Log
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.graphics.asImageBitmap
+import androidx.compose.ui.graphics.painter.BitmapPainter
+import androidx.compose.ui.graphics.painter.Painter
+import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.text.TextStyle
+import androidx.compose.ui.text.font.FontFamily
+import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.sp
+import androidx.core.graphics.toColorInt
+import androidx.navigation.compose.NavHost
+import androidx.navigation.compose.composable
+import androidx.navigation.compose.rememberNavController
+import com.octopuscommunity.sdk.ui.OctopusImagesDefaults
+import com.octopuscommunity.sdk.ui.OctopusTheme
+import com.octopuscommunity.sdk.ui.OctopusTypography
+import com.octopuscommunity.sdk.ui.OctopusTypographyDefaults
+import com.octopuscommunity.sdk.ui.components.UrlOpeningStrategy
+import com.octopuscommunity.sdk.ui.home.OctopusHomeDefaults
+import com.octopuscommunity.sdk.ui.home.OctopusHomeScreen
+import com.octopuscommunity.sdk.ui.octopusComposables
+import com.octopuscommunity.sdk.ui.octopusDarkColorScheme
+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
+
+/** Shared composable for both fullscreen Activity and embedded ViewManager. */
+@Composable
+internal fun OctopusContent(
+  modifier: Modifier = Modifier,
+  backButton: Boolean = false,
+  interceptUrls: Boolean = false,
+  onBack: () -> Unit = {}
+) {
+  val context = LocalContext.current
+
+  // Get theme config once when UI is created - no need for polling
+  val themeConfig = OctopusThemeManager.getThemeConfig()
+
+  // Function to detect if system is in dark mode
+  fun isSystemInDarkTheme(): Boolean {
+    return (context.resources.configuration.uiMode and Configuration.UI_MODE_NIGHT_MASK) == Configuration.UI_MODE_NIGHT_YES
+  }
+
+  // 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, context)
+      } else {
+        logoPainter = null
+      }
+    } ?: run {
+      // No theme config or no logo source
+      logoPainter = null
+    }
+  }
+
+  // Create images based on theme config
+  val images = if (logoPainter != null) {
+    OctopusImagesDefaults.images(logo = logoPainter)
+  } else {
+    OctopusImagesDefaults.images()
+  }
+
+  // Create typography based on theme config
+  val typography = createCustomTypography(themeConfig)
+  val uiConfiguration = OctopusUIConfigurationManager.getUIConfiguration()
+
+  val bottomContentPadding = uiConfiguration?.bottomContentPadding?.toFloat()?.dp
+
+  // Apply theme with custom colors, logo, typography, and content padding
+  OctopusTheme(
+    colorScheme = when (themeConfig?.colorScheme) {
+      "dark" -> octopusDarkColorScheme()
+      "light" -> octopusLightColorScheme()
+      else -> if (isSystemInDarkTheme()) octopusDarkColorScheme() else octopusLightColorScheme()
+    }.let { colorScheme ->
+      // Apply custom colors if theme config is provided
+      colorScheme.copy(
+        primary = themeConfig?.primaryColor?.let {
+          Color(it.toColorInt())
+        } ?: colorScheme.primary,
+        primaryLow = themeConfig?.primaryLowContrastColor?.let {
+          Color(it.toColorInt())
+        } ?: colorScheme.primaryLow,
+        primaryHigh = themeConfig?.primaryHighContrastColor?.let {
+          Color(it.toColorInt())
+        } ?: colorScheme.primaryHigh,
+        onPrimary = themeConfig?.onPrimaryColor?.let {
+          Color(it.toColorInt())
+        } ?: colorScheme.onPrimary
+      )
+    },
+    images = images,
+    typography = typography
+  ) {
+    val navController = rememberNavController()
+
+    NavHost(
+      modifier = modifier,
+      navController = navController,
+      startDestination = "OctopusHome"
+    ) {
+      composable(route = "OctopusHome") {
+        OctopusHomeScreen(
+          navController = navController,
+          contentPadding = if (bottomContentPadding != null) {
+            OctopusHomeDefaults.contentPadding(bottom = bottomContentPadding)
+          } else {
+            OctopusHomeDefaults.contentPadding()
+          },
+          backIcon = backButton,
+          onBack = onBack,
+          onNavigateToLogin = {
+            OctopusEventEmitter.instance?.emitLoginRequired()
+          },
+          onNavigateToProfileEdit = { fieldToEdit ->
+            OctopusEventEmitter.instance?.emitEditUser(fieldToEdit)
+          },
+          onNavigateToUrl = { url: String ->
+            if (interceptUrls) {
+              OctopusEventEmitter.instance?.emitNavigateToUrl(url)
+              UrlOpeningStrategy.HandledByApp
+            } else {
+              UrlOpeningStrategy.HandledByOctopus
+            }
+          }
+        )
+      }
+      octopusComposables(
+        navController = navController,
+        container = { _, content ->
+          OctopusTheme(content = content)
+        },
+        onBack = onBack,
+        onNavigateToLogin = {
+          OctopusEventEmitter.instance?.emitLoginRequired()
+        },
+        onNavigateToProfileEdit = { fieldToEdit ->
+          OctopusEventEmitter.instance?.emitEditUser(fieldToEdit)
+        },
+        onNavigateToUrl = { url: String ->
+          if (interceptUrls) {
+            OctopusEventEmitter.instance?.emitNavigateToUrl(url)
+            UrlOpeningStrategy.HandledByApp
+          } else {
+            UrlOpeningStrategy.HandledByOctopus
+          }
+        }
+      )
+    }
+  }
+}
+
+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(
+      title1 = createTextStyle(textStyles["title1"], defaultTypography.title1),
+      title2 = createTextStyle(textStyles["title2"], defaultTypography.title2),
+      body1 = createTextStyle(textStyles["body1"], defaultTypography.body1),
+      body2 = createTextStyle(textStyles["body2"], defaultTypography.body2),
+      caption1 = createTextStyle(textStyles["caption1"], defaultTypography.caption1),
+      caption2 = createTextStyle(textStyles["caption2"], defaultTypography.caption2)
+    )
+  }
+
+  return defaultTypography
+}
+
+private fun createTextStyle(
+  textStyleConfig: OctopusTextStyleConfig?,
+  defaultStyle: TextStyle
+): TextStyle {
+  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 {
+    // Use points directly as sp (1 point ≈ 1 sp on Android)
+    it.sp
+  } ?: defaultStyle.fontSize
+
+  return defaultStyle.copy(
+    fontFamily = fontFamily,
+    fontSize = fontSize
+  )
+}
+
+private suspend fun loadImageFromUri(uri: String, context: Context): Painter? {
+  // Check cache first
+  imageCache[uri]?.let { return it }
+
+  return withContext(Dispatchers.IO) {
+    try {
+      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("OctopusActivity", "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("OctopusActivity", "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("OctopusActivity", "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("OctopusActivity", "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/android/src/main/java/com/octopuscommunity/octopusreactnativesdk/OctopusEventEmitter.kt

@@ -34,6 +34,28 @@ class OctopusEventEmitter(private val reactContext: ReactContext) {
     sendEvent("userTokenRequest", params)
   }
 
+  fun emitNotSeenNotificationsCountChanged(count: Int) {
+    val params = Arguments.createMap()
+    params.putInt("count", count)
+    sendEvent("notSeenNotificationsCountChanged", params)
+  }
+
+  fun emitHasAccessToCommunityChanged(hasAccess: Boolean) {
+    val params = Arguments.createMap()
+    params.putBoolean("hasAccess", hasAccess)
+    sendEvent("hasAccessToCommunityChanged", params)
+  }
+
+  fun emitSDKEvent(eventData: WritableMap) {
+    sendEvent("sdkEvent", eventData)
+  }
+
+  fun emitNavigateToUrl(url: String) {
+    val params = Arguments.createMap()
+    params.putString("url", url)
+    sendEvent("navigateToUrl", params)
+  }
+
   private fun sendEvent(eventName: String, params: WritableMap?) {
     if (listenerCount > 0) {
       reactContext