@capillarytech/react-native-hydra-lib 1.7.0-beta.1

package/android/build.gradle

@@ -0,0 +1,565 @@
+import groovy.json.JsonSlurper
+
+buildscript {
+  // Buildscript is evaluated before everything else so we can't use getExtOrDefault
+  def kotlin_version = rootProject.ext.has("kotlinVersion") ? rootProject.ext.get("kotlinVersion") : project.properties["HydraLib_kotlinVersion"]
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:7.2.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    classpath 'org.codehaus.groovy:groovy-json:3.0.9'
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+def isNewArchitectureEnabled() {
+  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+if (isNewArchitectureEnabled()) {
+  apply plugin: "com.facebook.react"
+}
+
+def getExtOrDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties["HydraLib_" + name]
+}
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["HydraLib_" + name]).toInteger()
+}
+
+def supportsNamespace() {
+  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
+  def major = parsed[0].toInteger()
+  def minor = parsed[1].toInteger()
+
+  // Namespace support was added in 7.3.0
+  return (major == 7 && minor >= 3) || major >= 8
+}
+
+def reactNativeMinorVersion(){
+  def jsonFile = file("${project.rootDir}/../package.json")
+  def parsedPackageJson = new JsonSlurper().parseText(jsonFile.text)
+  String reactNativeVersion = parsedPackageJson.dependencies["react-native"]
+  def minorReactNativeVersion = reactNativeVersion.tokenize('.')[1].toInteger()
+  return minorReactNativeVersion
+}
+
+def isHydraFirebaseRegistrationEnabled() {
+  def rnJsonFile = file("${project.rootDir}/../capillary/hydra-config.json")
+  if(rnJsonFile.exists()){
+    println "rnJsonFile exists"
+    def parsedHydraConfig = new JsonSlurper().parseText(rnJsonFile.text)
+    return parsedHydraConfig.enable_hydra_sdk_firebase_registration
+  }
+  else{
+    println "rnJsonFile does not exist"
+    def jsonFile = file("${project.rootDir}/app/src/main/assets/hydra-config.json")
+    if(!jsonFile.exists()){
+      throw new GradleException("Hydra config file not found at ${rnJsonFile.absolutePath}")
+    }
+    def parsedHydraConfig = new JsonSlurper().parseText(jsonFile.text)
+    return parsedHydraConfig.push_notification.enable_hydra_sdk_firebase_registration
+  }
+
+}
+
+def isPushNotificationEnabled() {
+  def rnJsonFile = file("${project.rootDir}/../capillary/hydra-config.json")
+  if(rnJsonFile.exists()){
+    def parsedHydraConfig = new JsonSlurper().parseText(rnJsonFile.text)
+    return parsedHydraConfig.enable_push_notification == null ? true : parsedHydraConfig.enable_push_notification
+  }
+  else{
+    def jsonFile = file("${project.rootDir}/app/src/main/assets/hydra-config.json")
+    if(!jsonFile.exists()){
+      throw new GradleException("Hydra config file not found at ${rnJsonFile.absolutePath}")
+    }
+    def parsedHydraConfig = new JsonSlurper().parseText(jsonFile.text)
+    def pushNotificationConfig = parsedHydraConfig.push_notification?.enable_push_notification
+    return pushNotificationConfig == null ? true : pushNotificationConfig
+  }
+}
+android {
+  if (supportsNamespace()) {
+    namespace "com.hydralib"
+
+    sourceSets {
+      main {
+        manifest.srcFile isPushNotificationEnabled() ? "src/main/AndroidManifestNew.xml" : "src/main/AndroidManifestNoFirebaseIcon.xml"
+      }
+    }
+  }
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    manifestPlaceholders.enable_hydra_messaging_service = isHydraFirebaseRegistrationEnabled()
+  }
+
+  buildFeatures {
+    buildConfig true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      if (isNewArchitectureEnabled()) {
+          java.srcDirs += [
+            "src/newarch"
+          ]
+          if(reactNativeMinorVersion() >= 76){
+            java.srcDirs += [
+              "generated/java",
+              "generated/jni"
+            ]
+          }
+      }
+      else{
+        java.srcDirs += ["src/oldarch"]
+      }
+      if(reactNativeMinorVersion() > 72){
+        java.srcDirs +=[
+          "src/rn73OrMore"
+        ]
+      }
+      else{
+        java.srcDirs +=[
+          "src/rn72OrLess"
+        ]
+      }
+      assets.srcDirs += ["${buildDir}/generated/assets"]
+      // Don't add generated/res to source sets to avoid task dependency conflicts
+      // The resources will be copied during the build process
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  // For < 0.71, this will be from the local maven repo
+  // For > 0.71, this will be replaced by `com.facebook.react:react-android:$version` by react gradle plugin
+  //noinspection GradleDynamicVersion
+  implementation "com.facebook.react:react-native:+"
+  //noinspection GradleDependency
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  implementation "com.capillarytech:hydra-core:1.9.22-beta05"
+  implementation "com.capillarytech:hydra-pushbase:1.9.22-beta05"
+  implementation "com.capillarytech:hydra-firebase:1.9.22-beta05"
+  implementation "com.capillarytech:hydra-richnotification:1.9.22-beta05"
+
+  implementation "com.capillarytech:hydra-inbox-core:1.9.22-beta05"
+  implementation "com.capillarytech:hydra-inbox-ui:1.9.22-beta05"
+  implementation "com.capillarytech:hydra-inapp:1.9.22-beta05"
+  implementation "com.google.firebase:firebase-messaging-ktx:24.1.0"
+
+  implementation "com.google.code.gson:gson:2.11.0"
+  implementation 'com.google.firebase:firebase-config-ktx:22.1.0'
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "HydraLib"
+    codegenJavaPackageName = "com.hydralib"
+  }
+}
+
+task copyHydraConfig {
+    doLast {
+        def configSource = file("${project.rootDir}/../capillary/hydra-config.json")
+        def assetsDir = file("${buildDir}/generated/assets/capillary/")
+
+        if (!configSource.exists()) {
+          def configFromAndroid = file("${project.rootDir}/app/src/main/assets/hydra-config.json")
+          if(configFromAndroid.exists()){
+            println "Hydra config file not found at ${configSource.absolutePath}. Will use config from android/app/src/main/assets/hydra-config.json"
+            return
+
+          }
+          else{
+            throw new GradleException("Hydra config file not found at ${configSource.absolutePath}")
+          }
+        }
+
+        if (!assetsDir.exists()) {
+            assetsDir.mkdirs()
+        }
+
+        copy {
+            from configSource
+            into assetsDir
+        }
+
+        println "✅ Copied hydra config to build folder"
+    }
+}
+
+task copyHydraDrawableResources {
+    doLast {
+        def iconsSourceDir = file("${project.rootDir}/../capillary/icons")
+        def drawableTargetDir = file("${projectDir}/src/main/res/drawable")
+
+        // Track which files were actually copied
+        def copiedFiles = []
+
+        // Check if source directory exists
+        if (!iconsSourceDir.exists()) {
+            println "⚠️  Icons source directory not found at ${iconsSourceDir.absolutePath}. Will check legacy location."
+        }
+
+        // Create target directory if it doesn't exist
+        if (!drawableTargetDir.exists()) {
+            drawableTargetDir.mkdirs()
+        }
+
+        // Determine which config file to use
+        def configFile = null
+        def configSource = "none"
+
+        def capillaryConfig = file("${project.rootDir}/../capillary/hydra-config.json")
+        def androidConfig = file("${project.rootDir}/app/src/main/assets/hydra-config.json")
+
+        if (capillaryConfig.exists()) {
+            configFile = capillaryConfig
+            configSource = "capillary directory"
+        } else if (androidConfig.exists()) {
+            configFile = androidConfig
+            configSource = "Android assets"
+        }
+
+        // Read feature flags from the determined config file
+        def enableInAppMessaging = false
+        def enableInboxUI = false
+        def enablePushNotification = true
+
+        if (configFile != null) {
+            try {
+                def config = new JsonSlurper().parseText(configFile.text)
+                enableInAppMessaging = config.enable_in_app_messaging ?: false
+                enableInboxUI = config.enable_inbox_ui ?: false
+                def pushNotificationConfig = (configSource == "capillary directory") ?
+                    config.enable_push_notification :
+                    config.push_notification?.enable_push_notification
+                enablePushNotification = pushNotificationConfig == null ? true : pushNotificationConfig
+                println "📋 Hydra config loaded from ${configSource} - InApp: ${enableInAppMessaging}, InboxUI: ${enableInboxUI}, PushNotification: ${enablePushNotification}"
+            } catch (Exception e) {
+                println "⚠️  Could not parse hydra-config.json from ${configSource}, using default values"
+            }
+        } else {
+            println "⚠️  hydra-config.json not found in any location, using default values"
+        }
+
+        // Define required resources based on config
+        def requiredResources = []
+
+        if (enablePushNotification) {
+            requiredResources.add("hydra_notification_small_icon")
+        }
+
+        if (enableInAppMessaging) {
+            requiredResources.add("hydra_in_app_placeholder")
+        }
+
+        if (enableInboxUI) {
+            requiredResources.add("hydra_inbox_ui_placeholder")
+        }
+
+        // Common image extensions to check
+        def imageExtensions = ["png", "jpg", "jpeg"]
+
+        requiredResources.each { baseFileName ->
+            def fileFound = false
+
+            // Try to find the file with different extensions in capillary/icons
+            for (extension in imageExtensions) {
+                def sourceFile = file("${iconsSourceDir.absolutePath}/${baseFileName}.${extension}")
+                if (sourceFile.exists()) {
+                    copy {
+                        from sourceFile
+                        into drawableTargetDir
+                    }
+                    println "✅ Copied ${baseFileName}.${extension} to generated drawable folder"
+                    copiedFiles.add("${baseFileName}.${extension}")
+                    fileFound = true
+                    break // Break out of the extension loop once file is found
+                }
+            }
+
+            // If not found in capillary/icons, check for backward compatibility in android/app/src/main/res/drawable
+            if (!fileFound) {
+                def legacyDrawableDir = file("${project.rootDir}/../android/app/src/main/res/drawable")
+                def legacyFileFound = false
+
+                // For legacy location, also check XML files (vector drawables)
+                def legacyExtensions = imageExtensions + ["xml"]
+                for (extension in legacyExtensions) {
+                    def legacyFile = file("${legacyDrawableDir.absolutePath}/${baseFileName}.${extension}")
+                    if (legacyFile.exists()) {
+                        println "ℹ️  Found ${baseFileName}.${extension} in legacy location (android/app/src/main/res/drawable). This will be used for backward compatibility."
+                        legacyFileFound = true
+                        break // Break out of the extension loop once file is found
+                    }
+                }
+
+                if (!legacyFileFound) {
+                    def errorMessage = "❌ ${baseFileName} not found in capillary/icons with any of the supported extensions: ${imageExtensions.join(', ')}"
+
+                    // Add context about why this resource is required
+                    if (baseFileName == "hydra_notification_small_icon") {
+                        errorMessage += "\n   This resource is required because enable_push_notification is set to true in hydra-config.json"
+                    } else if (baseFileName == "hydra_in_app_placeholder") {
+                        errorMessage += "\n   This resource is required because enable_in_app_messaging is set to true in hydra-config.json"
+                    } else if (baseFileName == "hydra_inbox_ui_placeholder") {
+                        errorMessage += "\n   This resource is required because enable_inbox_ui is set to true in hydra-config.json"
+                    }
+
+                    throw new GradleException(errorMessage)
+                }
+            }
+        }
+
+        // Store the list of copied files in project properties for cleanup task to use
+        project.ext.set("hydraCopiedFiles", copiedFiles)
+
+        println "✅ Completed copying Hydra drawable resources"
+    }
+}
+
+task cleanupHydraDrawableResources {
+    doLast {
+        def drawableTargetDir = file("${projectDir}/src/main/res/drawable")
+
+        // Get the list of files that were actually copied by copyHydraDrawableResources
+        def copiedFiles = project.ext.has("hydraCopiedFiles") ? project.ext.get("hydraCopiedFiles") : []
+
+        if (copiedFiles.isEmpty()) {
+            println "ℹ️  No Hydra drawable resources were copied, skipping cleanup"
+            return
+        }
+
+        copiedFiles.each { fileName ->
+            def fileToDelete = file("${drawableTargetDir.absolutePath}/${fileName}")
+            if (fileToDelete.exists()) {
+                fileToDelete.delete()
+                println "🗑️  Cleaned up ${fileName}"
+            } else {
+                println "⚠️  Expected file ${fileName} not found during cleanup"
+            }
+        }
+
+        println "✅ Completed cleanup of ${copiedFiles.size()} Hydra drawable resources"
+    }
+}
+
+task copyHydraColorResources{
+    doLast {
+        def valuesTargetDir = file("${projectDir}/src/main/res/values")
+        def hydraColorsFile = file("${valuesTargetDir}/hydra-colors.xml")
+        def valuesTargetDirRoot = file("${project.rootDir}/app/src/main/res/values")
+
+        // Determine which config file to use
+        def configFile = null
+        def configSource = "none"
+
+        def capillaryConfig = file("${project.rootDir}/../capillary/hydra-config.json")
+
+        if (capillaryConfig.exists()) {
+            configFile = capillaryConfig
+            configSource = "capillary directory"
+        }
+
+        def hydraNotificationColor = null
+
+        if (configFile != null) {
+            try {
+                def config = new JsonSlurper().parseText(configFile.text)
+                hydraNotificationColor = config.hydra_notification_color
+                println "📋 Hydra color config loaded from ${configSource} - Color: ${hydraNotificationColor}"
+            } catch (Exception e) {
+                println "❌ ERROR: Could not parse hydra-config.json from ${configSource}"
+                println "   Please ensure the JSON file is valid"
+            }
+        } else {
+            println "hydra-config.json not found"
+        }
+
+        if (hydraNotificationColor != null) {
+            // Create values directory if it doesn't exist
+
+            // Check for existing hydra_notification_color in any XML files in values directory
+            // But only skip if the color is actually defined and accessible
+            def conflictingFile = null
+
+            if (valuesTargetDirRoot.exists()) {
+                valuesTargetDirRoot.listFiles().each { file ->
+                    if (file.name.endsWith('.xml') && file.name != 'hydra-colors.xml') {
+                        try {
+                            def content = file.text
+                            // Check if the color is actually defined (not just mentioned in comments)
+                            if (content.contains('name="hydra_notification_color"')) {
+                                // Parse the content to find active (non-commented) color definitions
+                                def lines = content.split('\n')
+                                def activeColorFound = false
+
+                                lines.each { line ->
+                                    def trimmedLine = line.trim()
+                                    // Skip commented lines and look for active color definitions
+                                    if (!trimmedLine.startsWith('<!--') &&
+                                        !trimmedLine.startsWith('*') &&
+                                        trimmedLine.contains('name="hydra_notification_color"') &&
+                                        (trimmedLine.contains('<color') || trimmedLine.contains('color>'))) {
+                                        activeColorFound = true
+                                    }
+                                }
+
+                                if (activeColorFound) {
+                                    conflictingFile = file.name
+                                    println "ℹ️  Found active hydra_notification_color definition in ${file.name}"
+                                } else {
+                                    println "ℹ️  Found hydra_notification_color reference in ${file.name} but it's commented out or not actively defined"
+                                }
+                            }
+                        } catch (Exception ignored) {
+                            // Skip files that can't be read
+                        }
+                    }
+                }
+            }
+
+            // Only skip if the color is actually defined and accessible
+            if (conflictingFile != null) {
+                println "hydra_notification_color is already defined in ${conflictingFile}, skipping hydra-colors.xml creation"
+                project.ext.set("hydraColorFileCreated", false)
+                return
+            }
+
+            if (!valuesTargetDir.exists()) {
+                valuesTargetDir.mkdirs()
+            }
+            // Check if hydra-colors.xml already exists (shouldn't happen during normal build)
+            if (hydraColorsFile.exists()) {
+                println "⚠️  hydra-colors.xml already exists, will overwrite"
+            }
+
+            def colorResourceXml = """<?xml version="1.0" encoding="utf-8"?>
+<resources>
+  <color name="hydra_notification_color">${hydraNotificationColor}</color>
+</resources>"""
+
+            // Always create/overwrite the hydra-colors.xml file
+            hydraColorsFile.text = colorResourceXml
+            println "✅ Created hydra-colors.xml with hydra_notification_color"
+
+            // Mark that we created the file for cleanup
+            project.ext.set("hydraColorFileCreated", true)
+        } else {
+            println "ℹ️  No hydra_notification_color specified in config, skipping color resource generation"
+            project.ext.set("hydraColorFileCreated", false)
+        }
+    }
+}
+
+task cleanupHydraColorResources {
+    doLast {
+        def valuesTargetDir = file("${projectDir}/src/main/res/values")
+        def hydraColorsFile = file("${valuesTargetDir}/hydra-colors.xml")
+
+        // Only clean up if we actually created the file
+        def fileWasCreated = project.ext.has("hydraColorFileCreated") ? project.ext.get("hydraColorFileCreated") : false
+
+        if (!fileWasCreated) {
+            println "ℹ️  hydra-colors.xml was not created during build, skipping cleanup"
+            return
+        }
+
+        if (hydraColorsFile.exists()) {
+            hydraColorsFile.delete()
+            println "🗑️  Removed hydra-colors.xml file that was created during build"
+        } else {
+            println "⚠️  hydra-colors.xml not found during cleanup"
+        }
+
+        println "✅ Completed cleanup of Hydra color resources"
+    }
+}
+
+
+// Make it run before build
+preBuild.dependsOn copyHydraConfig
+preBuild.dependsOn copyHydraDrawableResources
+preBuild.dependsOn copyHydraColorResources
+
+
+// Ensure resources are copied before any build tasks
+afterEvaluate {
+    tasks.matching { task ->
+        task.name.contains('processReleaseResources') ||
+        task.name.contains('processDebugResources')
+    }.configureEach { task ->
+        task.dependsOn copyHydraDrawableResources
+        task.dependsOn copyHydraColorResources
+    }
+
+    // Clean up resources after build tasks complete
+    tasks.matching { task ->
+        task.name.contains('assembleRelease') ||
+        task.name.contains('assembleDebug') ||
+        task.name.contains('bundleRelease') ||
+        task.name.contains('bundleDebug') ||
+        task.name.contains('installDebug') ||
+        task.name.contains('installRelease') ||
+        task.name.contains('packageDebug') ||
+        task.name.contains('packageRelease')
+    }.configureEach { task ->
+        task.finalizedBy cleanupHydraDrawableResources
+        task.finalizedBy cleanupHydraColorResources
+    }
+
+    // Also clean up after any task that might be the final task in a build
+    tasks.matching { task ->
+        task.name == 'build' ||
+        task.name == 'assemble' ||
+        task.name == 'bundle'
+    }.configureEach { task ->
+        task.finalizedBy cleanupHydraDrawableResources
+        task.finalizedBy cleanupHydraColorResources
+    }
+}