@octopus-community/react-native 1.0.7 → 1.9.1

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

@@ -1,155 +0,0 @@
-package com.octopuscommunity.octopusreactnativesdk
-
-import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
-import com.facebook.react.bridge.Promise
-import com.facebook.react.bridge.ReadableMap
-
-class OctopusReactNativeSdkModule(reactContext: ReactApplicationContext) :
-  ReactContextBaseJavaModule(reactContext) {
-
-  private val sdkInitializer = OctopusSDKInitializer()
-  private val eventEmitter = OctopusEventEmitter(reactContext)
-  private val uiController = OctopusUIController(reactContext)
-  private val ssoAuthenticator = OctopusSSOAuthenticator(reactContext, eventEmitter)
-
-  override fun getName(): String = NAME
-
-  @ReactMethod
-  fun initialize(options: ReadableMap, promise: Promise) {
-    sdkInitializer.initialize(reactApplicationContext, options, promise)
-  }
-
-  @ReactMethod
-  fun openUI(promise: Promise) {
-    uiController.openUI(promise)
-  }
-
-  @ReactMethod
-  fun closeUI(promise: Promise) {
-    uiController.closeUI(promise)
-  }
-
-  @ReactMethod
-  fun connectUser(params: ReadableMap, promise: Promise) {
-    ssoAuthenticator.connectUser(params, promise)
-  }
-
-  @ReactMethod
-  fun disconnectUser(promise: Promise) {
-    ssoAuthenticator.disconnectUser(promise)
-  }
-
-  @ReactMethod
-  fun completeUserTokenRequest(requestId: String, token: String, promise: Promise) {
-    ssoAuthenticator.completeTokenRequest(requestId, token)
-    promise.resolve(null)
-  }
-
-  @ReactMethod
-  fun cancelUserTokenRequest(requestId: String, promise: Promise) {
-    ssoAuthenticator.cancelTokenRequest(requestId)
-    promise.resolve(null)
-  }
-
-  @ReactMethod
-  fun addListener(eventName: String) {
-    eventEmitter.addListener(eventName)
-  }
-
-  @ReactMethod
-  fun removeListeners(count: Int) {
-    eventEmitter.removeListeners(count)
-  }
-
-  @ReactMethod
-  fun updateColorScheme(colorScheme: String?, promise: Promise) {
-    // Update the theme config with the new color scheme
-    val currentThemeConfig = OctopusThemeManager.getThemeConfig()
-    if (currentThemeConfig != null) {
-      val updatedThemeConfig = currentThemeConfig.copy(colorScheme = colorScheme)
-      OctopusThemeManager.setThemeConfig(updatedThemeConfig)
-    }
-    promise.resolve(null)
-  }
-
-  @ReactMethod
-  fun updateTheme(themeOptions: ReadableMap, promise: Promise) {
-    try {
-      // Parse theme using the standard initializer
-      val themeConfig = sdkInitializer.parseThemeConfig(themeOptions)
-      OctopusThemeManager.setThemeConfig(themeConfig)
-      promise.resolve(null)
-    } catch (e: Exception) {
-      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)
-      // Return the original string if parsing succeeds
-      colorString
-    } catch (e: IllegalArgumentException) {
-      // Invalid color format - return null to skip this color
-      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,
-              fontSize = if (fontSize.isNaN() || fontSize <= 0) null else fontSize
-            )
-          }
-        }
-      }
-    }
-
-    // Only create fonts config if we have text styles
-    if (textStyles.isNotEmpty()) {
-      return OctopusFontsConfig(
-        textStyles = textStyles
-      )
-    }
-
-    return null
-  }
-
-
-  companion object {
-    const val NAME = "OctopusReactNativeSdk"
-  }
-
-  init {
-    OctopusEventEmitter.instance = eventEmitter
-  }
-}

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

@@ -1,422 +0,0 @@
-package com.octopuscommunity.octopusreactnativesdk
-
-import android.content.BroadcastReceiver
-import android.content.Context
-import android.content.Intent
-import android.content.IntentFilter
-import android.content.res.Configuration
-import android.graphics.BitmapFactory
-import android.os.Build
-import android.os.Bundle
-import android.util.Log
-import androidx.activity.ComponentActivity
-import androidx.activity.compose.setContent
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.fillMaxSize
-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.navigation.compose.NavHost
-import androidx.navigation.compose.composable
-import androidx.navigation.compose.rememberNavController
-import com.octopuscommunity.sdk.ui.OctopusDrawablesDefaults
-import com.octopuscommunity.sdk.ui.OctopusTheme
-import com.octopuscommunity.sdk.ui.OctopusTypographyDefaults
-import com.octopuscommunity.sdk.ui.OctopusTypography
-import com.octopuscommunity.sdk.ui.components.OctopusNavigationHandler
-import androidx.compose.ui.text.TextStyle
-import androidx.compose.ui.text.font.FontFamily
-import androidx.compose.ui.text.font.FontWeight
-import androidx.compose.ui.unit.sp
-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
-
-class OctopusUIActivity : ComponentActivity() {
-    private val closeUIReceiver = object : BroadcastReceiver() {
-        override fun onReceive(context: Context?, intent: Intent?) {
-            finish()
-        }
-    }
-
-    override fun onCreate(savedInstanceState: Bundle?) {
-        super.onCreate(savedInstanceState)
-        registerCloseUIReceiver()
-        setContent {
-            OctopusUI(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)
-        }
-    }
-}
-
-@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()
-
-    // 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
-    }
-
-    // Determine base color scheme based on theme config or system theme
-    val baseColorScheme = if (themeConfig?.colorScheme == "dark") {
-        octopusDarkColorScheme()
-    } else if (themeConfig?.colorScheme == "light") {
-        octopusLightColorScheme()
-    } else if (isSystemInDarkTheme()) {
-        octopusDarkColorScheme()
-    } else {
-        octopusLightColorScheme()
-    }
-
-    // Apply custom colors if theme config is provided
-    val finalColorScheme = if (themeConfig != null) {
-        baseColorScheme.copy(
-            primary = themeConfig.primaryColor?.let {
-                Color(android.graphics.Color.parseColor(it))
-            } ?: baseColorScheme.primary,
-            primaryLow = themeConfig.primaryLowContrastColor?.let {
-                Color(android.graphics.Color.parseColor(it))
-            } ?: baseColorScheme.primaryLow,
-            primaryHigh = themeConfig.primaryHighContrastColor?.let {
-                Color(android.graphics.Color.parseColor(it))
-            } ?: baseColorScheme.primaryHigh,
-            onPrimary = themeConfig.onPrimaryColor?.let {
-                Color(android.graphics.Color.parseColor(it))
-            } ?: baseColorScheme.onPrimary
-        )
-    } else {
-        baseColorScheme
-    }
-
-    // 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 drawables based on theme config
-    val drawables = if (logoPainter != null) {
-        OctopusDrawablesDefaults.drawables(logo = logoPainter)
-    } else {
-        OctopusDrawablesDefaults.drawables()
-    }
-
-    // Create typography based on theme config
-    val typography = createCustomTypography(themeConfig)
-
-    // Apply theme with custom colors, logo, and typography
-    OctopusTheme(
-        colorScheme = finalColorScheme,
-        drawables = drawables,
-        typography = typography
-    ) {
-        OctopusUIContent(onBack = onBack)
-    }
-}
-
-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
-    )
-}
-
-
-@Composable
-private fun OctopusUIContent(onBack: () -> Unit) {
-    Box(modifier = Modifier.fillMaxSize()) {
-        val navController = rememberNavController()
-
-        NavHost(
-            navController = navController,
-            startDestination = "OctopusHome"
-        ) {
-            composable(route = "OctopusHome") {
-                OctopusNavigationHandler(
-                    navigateToLogin = {
-                        OctopusEventEmitter.instance?.emitLoginRequired()
-                    },
-                    navigateToProfileEdit = { fieldToEdit ->
-                        OctopusEventEmitter.instance?.emitEditUser(fieldToEdit)
-                    },
-                    navigateToClientObject = {
-                        // TODO : Bridge Post react
-                    }
-                ) {
-                    OctopusHomeScreen(
-                        navController = navController,
-                        backIcon = true,
-                        onBack = onBack
-                    )
-                }
-            }
-            octopusComposables(
-                navController = navController,
-                onNavigateToLogin = {
-                    OctopusEventEmitter.instance?.emitLoginRequired()
-                },
-                onNavigateToProfileEdit = { fieldToEdit ->
-                    OctopusEventEmitter.instance?.emitEditUser(fieldToEdit)
-                }
-            )
-        }
-    }
-}
-
-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("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)
-}