@luciq/react-native 18.0.0

package/RNLuciq.podspec

@@ -0,0 +1,21 @@
+require 'json'
+require_relative './ios/native'
+
+package = JSON.parse(File.read('package.json'))
+
+Pod::Spec.new do |s|
+  s.name         = 'RNLuciq'
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.author       = package["author"]
+  s.license      = package["license"]
+  s.homepage     = package["homepage"]
+  s.source       = { :git => "https://github.com/Instabug/Instabug-React-Native.git", :tag => 'v' + package["version"] }
+
+  s.platform     = :ios, "13.0"
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  s.dependency 'React-Core'
+  use_luciq!(s)
+
+end

package/android/build.gradle

@@ -0,0 +1,88 @@
+apply plugin: 'com.android.library'
+
+apply from: './jacoco.gradle'
+apply from: './native.gradle'
+apply from: './sourcemaps.gradle'
+
+String getExtOrDefault(String name) {
+    def defaultPropertyKey = 'LuciqReactNative_' + name
+    if (rootProject.ext.has(name)) {
+        return rootProject.ext.get(name)
+    }
+    return project.properties[defaultPropertyKey]
+}
+
+static boolean 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
+}
+
+void updateManifestPackage() {
+    def packageProp = 'package="ai.luciq.reactlibrary"'
+    def manifestFile = file("$projectDir/src/main/AndroidManifest.xml")
+    def currentContent = manifestFile.getText()
+    def content = currentContent
+    def hasPackage = currentContent.contains(packageProp)
+
+    if (supportsNamespace()) {
+        content = content.replaceAll(packageProp, '')
+    } else if (!hasPackage) {
+        content = content.replace(
+            '<manifest',
+            "<manifest $packageProp "
+        )
+    }
+
+    def shouldUpdateManifest = content != currentContent
+    if (shouldUpdateManifest) {
+        manifestFile.write(content)
+    }
+}
+
+updateManifestPackage()
+
+android {
+    if (supportsNamespace()) {
+        namespace "ai.luciq.reactlibrary"
+    }
+
+    compileSdkVersion getExtOrDefault('compileSdkVersion').toInteger()
+    buildToolsVersion getExtOrDefault('buildToolsVersion')
+
+    defaultConfig {
+        minSdkVersion getExtOrDefault('minSdkVersion').toInteger()
+        targetSdkVersion getExtOrDefault('targetSdkVersion').toInteger()
+        versionCode 1
+        versionName "15.0.1"
+        multiDexEnabled true
+        ndk {
+            abiFilters "armeabi-v7a", "x86"
+        }
+        consumerProguardFiles 'proguard-rules.txt'
+    }
+    lintOptions {
+       warning 'InvalidPackage'
+        abortOnError true
+        // SuppressLint WrongConstant was used to suppress errors when using arrays of ints to represent annotations.
+    }
+}
+
+dependencies {
+    implementation "androidx.multidex:multidex:2.0.1"
+    implementation 'com.facebook.react:react-native:+'
+
+    testImplementation "org.mockito:mockito-inline:3.12.1"
+    testImplementation "org.mockito:mockito-android:3.4.0"
+    testImplementation 'junit:junit:4.13.2'
+}
+
+rootProject.allprojects {
+	repositories {
+		google()
+		jcenter()
+	}
+}

package/android/gradle.properties

@@ -0,0 +1,4 @@
+LuciqReactNative_compileSdkVersion=30
+LuciqReactNative_buildToolsVersion=30.0.2
+LuciqReactNative_targetSdkVersion=31
+LuciqReactNative_minSdkVersion=16

package/android/jacoco.gradle

@@ -0,0 +1,52 @@
+apply plugin: 'jacoco'
+
+jacoco {
+  toolVersion '0.8.8'
+}
+
+task jacocoTestReport(type: JacocoReport) {
+  group = 'Reporting'
+  description = 'Generate Jacoco coverage reports for the debug build.'
+
+  dependsOn 'testDebugUnitTest'
+
+  reports {
+    html.required = true
+    xml.required = true
+  }
+
+  def excludes = [
+      '**/R.class',
+      '**/R$*.class',
+      '**/BuildConfig.*',
+      '**/Manifest*.*',
+      '**/*Test*.*',
+      'android/**/*.*',
+      'androidx/**/*.*',
+      '**/*$ViewInjector*.*',
+      '**/*Dagger*.*',
+      '**/*MembersInjector*.*',
+      '**/*_Factory.*',
+      '**/*_Provide*Factory*.*',
+      '**/*_ViewBinding*.*',
+      '**/AutoValue_*.*',
+      '**/R2.class',
+      '**/R2$*.class',
+      '**/*Directions$*',
+      '**/*Directions.*',
+      '**/*Binding.*'
+  ]
+
+  def jClasses = "${project.buildDir}/intermediates/javac/debug/compileDebugJavaWithJavac/classes"
+  def javaClasses = fileTree(dir: jClasses, excludes: excludes)
+  def sourceDirs = ["${project.projectDir}/src/main/java"]
+  classDirectories.from = files(javaClasses)
+  sourceDirectories.from = files(sourceDirs)
+  executionData.from = files(["${project.buildDir}/jacoco/testDebugUnitTest.exec"])
+}
+
+tasks.whenTaskAdded { task ->
+  if (task.name == 'testDebugUnitTest') {
+    task.finalizedBy jacocoTestReport
+  }
+}

package/android/native.gradle

@@ -0,0 +1,7 @@
+project.ext.luciq = [
+    version: '18.0.0'
+]
+
+dependencies {
+    api "ai.luciq.library:luciq:${project.ext.luciq.version}"
+}

package/android/proguard-rules.txt

@@ -0,0 +1 @@
+-keep class com.luciq.** {*;}

package/android/sourcemaps.gradle

@@ -0,0 +1,255 @@
+import org.apache.tools.ant.taskdefs.condition.Os
+
+project.afterEvaluate {
+    // Works for both `bundleReleaseJsAndAssets` and `createBundleReleaseJsAndAssets` and product flavors
+    def suffix = 'ReleaseJsAndAssets'
+    def bundleTasks = project(':app').tasks.findAll {
+        task -> task.name.endsWith(suffix)
+    }
+
+    bundleTasks.forEach { task ->
+        def name = task.name
+        def prefixes = ['bundle', 'createBundle']
+        def start = name.startsWith(prefixes[0]) ? prefixes[0].length() : prefixes[1].length()
+        def end = name.length() - suffix.length()
+        def flavor = name.substring(start, end).uncapitalize()
+        def defaultVersion = getDefaultVersion(flavor)
+
+
+
+        task.finalizedBy createUploadSourcemapsTask(flavor, defaultVersion.name, defaultVersion.code,task)
+    }
+}
+
+Task createUploadSourcemapsTask(String flavor, String defaultVersionName, String defaultVersionCode, Task task) {
+    def name = 'uploadSourcemaps' + flavor.capitalize()
+
+    // Don't recreate the task if it already exists.
+    // This prevents the build from failing in an edge case where the user has
+    // both `bundleReleaseJsAndAssets` and `createBundleReleaseJsAndAssets`
+    def taskExists = tasks.getNames().contains(name)
+    if (taskExists) {
+        return tasks.named(name).get()
+    }
+
+    def provider = tasks.register(name) {
+        group 'luciq'
+        description 'Uploads sourcemaps file to Luciq server'
+        enabled = isUploadSourcemapsEnabled()
+
+        doLast {
+            try {
+                def appProject = project(':app')
+                def appDir = appProject.projectDir
+                def sourceMapFile = getSourceMapFile(appDir, flavor,task)
+
+                def jsProjectDir = rootDir.parentFile
+                def luciqDir = new File(['node', '-p', 'require.resolve("@luciq/react-native/package.json")'].execute(null, rootDir).text.trim()).getParentFile()
+
+              def tokenJsFile = new File(luciqDir, 'scripts/find-token.js')
+              def inferredToken = executeNodeScript(tokenJsFile, jsProjectDir)
+
+
+                def appToken = resolveVar('App Token', 'LUCIQ_APP_TOKEN', inferredToken)
+
+                if (!appToken) {
+                    throw new GradleException("❌ Unable to infer Luciq token from script: ${tokenShellFile.absolutePath}")
+                }
+
+                def versionName = resolveVar('Version Name', 'LUCIQ_VERSION_NAME', defaultVersionName)
+                def versionCode = resolveVar('Version Code', 'LUCIQ_VERSION_CODE', defaultVersionCode)
+
+                println "📦 Uploading with versionName=${versionName}, versionCode=${versionCode}, appToken=${appToken.take(5)}..."
+
+                exec {
+                    def osCompatibility = Os.isFamily(Os.FAMILY_WINDOWS) ? ['cmd', '/c'] : []
+                    def args = [
+                            'npx', 'luciq', 'upload-sourcemaps',
+                            '--platform', 'android',
+                            '--file', sourceMapFile.absolutePath,
+                            '--token', appToken,
+                            '--name', versionName,
+                            '--code', versionCode
+                    ]
+
+                    commandLine(*osCompatibility, *args)
+                }
+            } catch (exception) {
+                project.logger.error "Failed to upload source map file.\n" +
+                        "Reason: ${exception.message}"
+                           throw exception
+
+            }
+        }
+    }
+
+    return provider.get()
+}
+
+File getSourceMapFile(File appDir, String flavor, Task task) {
+    def defaultFlavorPath = flavor.empty ? 'release' : "${flavor}Release"
+    def defaultSourceMapDest = "build/generated/sourcemaps/react/${defaultFlavorPath}/index.android.bundle.map"
+    def defaultSourceMapFile = new File(appDir, defaultSourceMapDest)
+    def props = task.getProperties()
+
+    def bundleAssetName = props.containsKey("bundleAssetName") ? props.bundleAssetName?.getOrNull() : null
+    def jsSourceMapsDir = props.containsKey("jsSourceMapsDir") ? props.jsSourceMapsDir?.getOrNull() : null
+    def jsIntermediateSourceMapsDir = props.containsKey("jsIntermediateSourceMapsDir") ? props.jsIntermediateSourceMapsDir?.getOrNull() : null
+
+    if (bundleAssetName && jsSourceMapsDir) {
+        def outputSourceMap = new File(jsSourceMapsDir.asFile.absolutePath, "${bundleAssetName}.map")
+        if (outputSourceMap.exists()) {
+            return outputSourceMap
+        }
+    }
+
+    if (bundleAssetName && jsIntermediateSourceMapsDir) {
+        def packagerOutputSourceMap = new File(jsIntermediateSourceMapsDir.asFile.absolutePath, "${bundleAssetName}.packager.map")
+        if (packagerOutputSourceMap.exists()) {
+            return packagerOutputSourceMap
+        }
+    }
+
+    if (defaultSourceMapFile.exists()) {
+        return defaultSourceMapFile
+    }
+
+    if (flavor.empty) {
+         println"Source map file not found at: ${defaultSourceMapFile.absolutePath}. Skipping."
+        return null
+    }
+
+    def fallbackSourceMapDest = "build/generated/sourcemaps/react/${flavor}/release/index.android.bundle.map"
+    def fallbackSourceMapFile = new File(appDir, fallbackSourceMapDest)
+
+  println "Unable to find source map file at: ${defaultSourceMapFile.absolutePath}.\n" +
+            "Falling back to ${fallbackSourceMapFile.absolutePath}."
+
+    if (!fallbackSourceMapFile.exists()) {
+    println "Fallback source map file not found at: ${fallbackSourceMapFile.absolutePath}. Skipping."
+        return null
+    }
+
+    return fallbackSourceMapFile
+}
+
+/**
+ * Infers the app version to use in source map upload based on the flavor.
+ * This is needed since different flavors may have different version codes and names (e.g. version suffixes).
+ *
+ * It checks the version for the flavor's variant.
+ * If no variant is found it falls back to the app's default config.
+ *
+ *
+ * @param flavor The flavor to get the app version for.
+ * @return A map containing the version code and version name.
+ */
+Map<String, String> getDefaultVersion(String flavor) {
+    def appProject = project(':app')
+    def defaultConfig = appProject.android.defaultConfig
+
+    def variants = appProject.android.applicationVariants
+
+    // uncapitalize is used to turn "Release" into "release" if the flavor is empty
+    def variantName = "${flavor}Release".uncapitalize()
+    def variant = variants.find { it.name.uncapitalize() == variantName }
+
+    def versionName = variant?.versionName ?: defaultConfig.versionName
+    def versionCode = variant?.versionCode ?: defaultConfig.versionCode
+
+    return [name: "${versionName}", code: "${versionCode}"]
+}
+
+boolean isUploadSourcemapsEnabled() {
+    def luciqEnvValue = System.getenv('LUCIQ_SOURCEMAPS_UPLOAD_DISABLE')?.toBoolean()
+    def instabugEnvValue = System.getenv('INSTABUG_SOURCEMAPS_UPLOAD_DISABLE')?.toBoolean()
+    def defaultValue = true
+
+    def envValue = luciqEnvValue ?: instabugEnvValue
+    return (envValue != null) ? !envValue : defaultValue
+}
+
+String resolveVar(String name, String envKey, String defaultValue) {
+    def env = System.getenv()
+    
+    // First try LUCIQ environment variable
+    def luciqEnvKey = envKey.replace('LUCIQ_', 'LUCIQ_')
+    def luciqEnvValue = env.get(luciqEnvKey)
+    
+    // Then try INSTABUG environment variable as fallback
+    def instabugEnvKey = envKey.replace('LUCIQ_', 'INSTABUG_')
+    def instabugEnvValue = env.get(instabugEnvKey)
+    
+    // Use LUCIQ value if available, otherwise use INSTABUG value, otherwise use default
+    def envValue = luciqEnvValue ?: instabugEnvValue
+
+    if (envValue != null && defaultValue !=null && envValue != defaultValue) {
+        project.logger.warn "Environment variable `${envKey}` might have incorrect value, " +
+                "make sure this was intentional:\n" +
+                "   Environment Value: ${envValue}\n" +
+                "   Default Value: ${defaultValue}"
+    }
+
+    def value = envValue ?: defaultValue
+
+    if (value == null) {
+        throw new InvalidUserDataException("Unable to find ${name}! " +
+                "Set the environment variable `${envKey}` or `${instabugEnvKey}` and try again.")
+    }
+
+    return value
+}
+
+static String executeNodeScript(File script, File workingDir) {
+    if (!script.exists()) {
+        println "Script not found: ${script.absolutePath}"
+        return null
+    }
+
+    def output = new StringBuffer()
+    def error = new StringBuffer()
+
+    try {
+        def process = ['node', script.getAbsolutePath()].execute(null, workingDir)
+        process.waitForProcessOutput(output, error)
+
+        if (process.exitValue() != 0) {
+            println "Script failed with exit code ${process.exitValue()}"
+            println "Standard Error:\n${error.toString().trim()}"
+            println "Standard Output:\n${output.toString().trim()}"
+            return null
+        }
+
+        return output.toString().trim()
+
+    } catch (Exception e) {
+        println "Exception while executing Node.js script: ${e.message}"
+        e.printStackTrace()
+        return null
+    }
+}
+
+static String executeShellScript(File script, File workingDir) {
+    if (Os.isFamily(Os.FAMILY_WINDOWS)) {
+        return null
+    }
+
+    if (!script.canExecute()) {
+        // Try to set executable permission
+        script.setExecutable(true)
+    }
+
+    def output = new StringBuffer()
+    def error = new StringBuffer()
+
+    // Using 'sh' instead of './' to avoid needing exec permission, but keeping chmod above just in case
+    def process = ['sh', script.getAbsolutePath()].execute(null, workingDir)
+    process?.waitForProcessOutput(output, error)
+
+    if (process.exitValue() != 0) {
+        println "Error running script: ${error.toString().trim()}"
+        return null
+    }
+
+    return output.toString().trim()
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,4 @@
+<manifest 
+  xmlns:android="http://schemas.android.com/apk/res/android">
+
+</manifest>