@octopus-community/react-native 1.0.8 → 1.9.1

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

@@ -1,434 +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.PaddingValues
-import androidx.compose.foundation.layout.fillMaxSize
-import androidx.compose.foundation.layout.padding
-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.unit.Dp
-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.home.OctopusHomeDefaults
-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 androidx.compose.ui.unit.dp
-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)
-    val uiConfiguration = OctopusUIConfigurationManager.getUIConfiguration()
-
-    // Apply theme with custom colors, logo, typography, and content padding
-    OctopusTheme(
-        colorScheme = finalColorScheme,
-        drawables = drawables,
-        typography = typography
-    ) {
-        OctopusUIContent(
-          bottomContentPadding = uiConfiguration?.bottomContentPadding?.toFloat()?.dp,
-          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(bottomContentPadding: Dp?, 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,
-                  floatingActionsPadding = OctopusHomeDefaults.floatingActionsPadding(
-                    bottom = bottomContentPadding ?: 16.dp
-                  ),
-                  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)
-}