build.gradle

// ═══════════════════════════════════════════════════════════════════════════════
// SafeRoomV2 Build Configuration
// Platform-specific dependency loading for minimal footprint
// ═══════════════════════════════════════════════════════════════════════════════

plugins {
    id 'java'
    id 'application'
    id 'com.google.protobuf' version '0.9.4'
    id 'org.openjfx.javafxplugin' version '0.0.14'
}

// ═══════════════════════════════════════════════════════════════════════════════
// PROJECT METADATA
// ═══════════════════════════════════════════════════════════════════════════════

group = 'com.saferoom'
version = '1.0'

// ═══════════════════════════════════════════════════════════════════════════════
// JAVA TOOLCHAIN
// ═══════════════════════════════════════════════════════════════════════════════

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(21)
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// REPOSITORIES
// ═══════════════════════════════════════════════════════════════════════════════

repositories {
    mavenCentral()
    flatDir {
        dirs 'libs'
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// PLATFORM DETECTION
// Using Gradle's official OperatingSystem API for reliable detection
// ═══════════════════════════════════════════════════════════════════════════════

import org.gradle.internal.os.OperatingSystem

def currentOs = OperatingSystem.current()
def osArch = System.getProperty('os.arch').toLowerCase()
def isArm = osArch.contains('aarch64') || osArch.contains('arm')

// Platform flags
ext {
    isWindows = currentOs.isWindows()
    isLinux = currentOs.isLinux()
    isMacOS = currentOs.isMacOsX()
    isMacOSArm = isMacOS && isArm
    isMacOSx64 = isMacOS && !isArm
}

// WebRTC native classifier based on current platform
def webrtcClassifier = isWindows ? 'windows-x86_64' :
                       (isMacOS ? (isArm ? 'macos-aarch64' : 'macos-x86_64') : 'linux-x86_64')

// SQLite native classifier (platform-specific loading)
def sqliteClassifier = isWindows ? 'windows-x86_64' :
                       (isMacOS ? (isArm ? 'osx-aarch64' : 'osx-x86_64') : 'linux-x86_64')

// ═══════════════════════════════════════════════════════════════════════════════
// BUILD INFO
// ═══════════════════════════════════════════════════════════════════════════════

println """
╔═══════════════════════════════════════════════════════════════════════════════╗
║                         SafeRoomV2 Build Configuration                        ║
╠═══════════════════════════════════════════════════════════════════════════════╣
║  Platform:      ${currentOs.familyName.padRight(58)}║
║  Architecture:  ${osArch.padRight(58)}║
║  WebRTC:        ${webrtcClassifier.padRight(58)}║
║  SQLite:        ${sqliteClassifier.padRight(58)}║
╠═══════════════════════════════════════════════════════════════════════════════╣
║  Features:                                                                    ║
║    • Screen Share:  ${(isWindows || isMacOS ? '✓ Enabled (native)' : '✗ Disabled (Linux)').padRight(55)}║
║    • PDF Preview:   ✗ Disabled (opens with OS default app)                   ║
╚═══════════════════════════════════════════════════════════════════════════════╝
"""

// ═══════════════════════════════════════════════════════════════════════════════
// VERSION CATALOG
// Centralized version management for easier updates
// ═══════════════════════════════════════════════════════════════════════════════

def versions = [
    javafx    : '21.0.1',
    grpc      : '1.58.0',
    protobuf  : '3.23.4',
    webrtc    : '0.14.0',
    sqlite    : '3.45.0.0',
    bouncycastle: '1.77',
    gson      : '2.10.1',
    zxing     : '3.5.3',
    jfoenix   : '9.0.10',
    ikonli    : '12.3.1',
    junit     : '5.10.2'
]

// ═══════════════════════════════════════════════════════════════════════════════
// DEPENDENCIES
// ═══════════════════════════════════════════════════════════════════════════════

dependencies {
    
    // ───────────────────────────────────────────────────────────────────────────
    // COMMON DEPENDENCIES (All Platforms)
    // Pure Java libraries with no native code
    // ───────────────────────────────────────────────────────────────────────────
    
    // UI Framework
    implementation "com.jfoenix:jfoenix:${versions.jfoenix}"
    implementation "org.kordamp.ikonli:ikonli-javafx:${versions.ikonli}"
    implementation "org.kordamp.ikonli:ikonli-fontawesome5-pack:${versions.ikonli}"
    
    // gRPC & Protobuf (networking)
    implementation "io.grpc:grpc-netty-shaded:${versions.grpc}"
    implementation "io.grpc:grpc-protobuf:${versions.grpc}"
    implementation "io.grpc:grpc-stub:${versions.grpc}"
    compileOnly 'org.apache.tomcat:annotations-api:6.0.53'
    implementation "com.google.protobuf:protobuf-java:${versions.protobuf}"
    
    // Cryptography
    implementation "org.bouncycastle:bcprov-jdk18on:${versions.bouncycastle}"
    
    // Utilities
    implementation "com.google.code.gson:gson:${versions.gson}"
    implementation "com.google.zxing:core:${versions.zxing}"
    implementation "com.google.zxing:javase:${versions.zxing}"
    
    // Local JARs (Pure Java)
    implementation files('libs/jstun-0.7.4.jar')      // STUN client
    implementation files('libs/weupnp-0.1.4.jar')     // UPnP port mapping
    implementation files('libs/javax.mail.jar')       // Email
    implementation files('libs/javax.activation-1.2.0.jar')
    implementation files('libs/mysql-connector-j-9.2.0.jar')
    implementation files('libs/slf4j-api-1.7.36.jar')
    implementation files('libs/slf4j-simple-1.7.36.jar')
    
    // WebRTC - Common API (no natives)
    implementation "dev.onvoid.webrtc:webrtc-java:${versions.webrtc}"
    
    // SQLite - Common API (no natives)
    implementation("org.xerial:sqlite-jdbc:${versions.sqlite}") {
        // Exclude bundled natives - we add platform-specific below
        // Note: sqlite-jdbc bundles all natives; this is a size optimization
    }
    
    // Testing
    testImplementation "org.junit.jupiter:junit-jupiter:${versions.junit}"
    
    // ───────────────────────────────────────────────────────────────────────────
    // PLATFORM-SPECIFIC DEPENDENCIES
    // Native libraries loaded only for current OS
    // ───────────────────────────────────────────────────────────────────────────
    
    // WebRTC Native Libraries (platform-specific)
    runtimeOnly "dev.onvoid.webrtc:webrtc-java:${versions.webrtc}:${webrtcClassifier}"
    
    if (isWindows) {
        // ═══════════════════════════════════════════════════════════════════════
        // WINDOWS-SPECIFIC DEPENDENCIES
        // ═══════════════════════════════════════════════════════════════════════
        
        // Windows uses native D3D rendering via JavaFX (handled by plugin)
        // WebRTC native loaded via classifier above
        // Screen sharing: ENABLED via native WebRTC VideoDesktopSource
    }
    
    if (isLinux) {
        // ═══════════════════════════════════════════════════════════════════════
        // LINUX-SPECIFIC DEPENDENCIES
        // ═══════════════════════════════════════════════════════════════════════
        
        // Linux uses OpenGL ES2 rendering via JavaFX (handled by plugin)
        // WebRTC native loaded via classifier above
        // Screen sharing: DISABLED (FFmpeg/JavaCV removed for size optimization)
        // 
        // NOTE: Linux screen share requires PipeWire/X11 FFmpeg pipeline
        //       which adds ~200MB+ of native dependencies.
        //       Feature disabled until native WebRTC solution available.
    }
    
    if (isMacOS) {
        // ═══════════════════════════════════════════════════════════════════════
        // macOS-SPECIFIC DEPENDENCIES
        // ═══════════════════════════════════════════════════════════════════════
        
        // macOS uses Metal/OpenGL ES2 rendering via JavaFX (handled by plugin)
        // WebRTC native loaded via classifier above (supports both x64 and ARM)
        // Screen sharing: ENABLED via native WebRTC VideoDesktopSource
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// APPLICATION CONFIGURATION
// ═══════════════════════════════════════════════════════════════════════════════

application {
    mainClass = 'com.saferoom.gui.MainApp'
}

// ═══════════════════════════════════════════════════════════════════════════════
// PROTOBUF / gRPC CODE GENERATION
// ═══════════════════════════════════════════════════════════════════════════════

protobuf {
    protoc {
        artifact = "com.google.protobuf:protoc:${versions.protobuf}"
    }
    plugins {
        grpc {
            artifact = "io.grpc:protoc-gen-grpc-java:${versions.grpc}"
        }
    }
    generateProtoTasks {
        all().each { task ->
            task.plugins {
                grpc {}
            }
        }
    }
}

// ═══════════════════════════════════════════════════════════════════════════════
// SOURCE SETS
// ═══════════════════════════════════════════════════════════════════════════════

sourceSets {
    main {
        java {
            srcDirs = [
                'src/main/java',
                'build/generated/source/proto/main/java',
                'build/generated/source/proto/main/grpc'
            ]
        }
        proto {
            srcDirs = ['src/main/proto']
        }
        resources {
            srcDirs = ['src/main/resources']
        }
    }
}

compileJava.dependsOn 'generateProto'

// ═══════════════════════════════════════════════════════════════════════════════
// JAVAFX CONFIGURATION
// Platform-specific natives handled automatically by plugin
// ═══════════════════════════════════════════════════════════════════════════════

javafx {
    version = versions.javafx
    modules = [
        'javafx.controls',
        'javafx.fxml', 
        'javafx.graphics', 
        'javafx.base', 
        'javafx.media', 
        'javafx.swing'
    ]
    // Note: javafx.web module excluded (saves ~80MB)
}

// ═══════════════════════════════════════════════════════════════════════════════
// TASK CONFIGURATION
// ═══════════════════════════════════════════════════════════════════════════════

// Duplicate handling
processResources {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

tasks.withType(Tar).configureEach {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

tasks.withType(Zip).configureEach {
    duplicatesStrategy = DuplicatesStrategy.EXCLUDE
}

// Compilation settings
tasks.withType(JavaCompile).configureEach {
    options.compilerArgs += '--enable-preview'
    options.release = 21
    options.encoding = 'UTF-8'
}

// Test settings
tasks.withType(Test).configureEach {
    useJUnitPlatform()
    jvmArgs += '--enable-preview'
}

// ═══════════════════════════════════════════════════════════════════════════════
// RUNTIME JVM CONFIGURATION
// Aggressive memory optimization for minimal footprint
// ═══════════════════════════════════════════════════════════════════════════════

tasks.withType(JavaExec).configureEach {
    jvmArgs += '--enable-preview'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // JFR PROFILING (optional)
    // Usage: ./gradlew run -Pjfr=pre_opt  → creates profiling/pre_opt.jfr
    // ─────────────────────────────────────────────────────────────────────────────
    if (project.hasProperty('jfr')) {
        def jfrName = project.property('jfr')
        file("${projectDir}/profiling").mkdirs()
        def jfrFile = "${projectDir}/profiling/${jfrName}.jfr"
        jvmArgs += "-XX:StartFlightRecording=filename=${jfrFile},dumponexit=true,settings=profile"
        println "🎬 JFR Recording: ${jfrFile}"
    }
    
    // ─────────────────────────────────────────────────────────────────────────────
    // HEAP CONFIGURATION
    // ─────────────────────────────────────────────────────────────────────────────
    // Setting min=max prevents heap resizing overhead during connection establishment
    // OPTIMIZATION: Reduced from 2g to 256m/512m to fit in 300MB-600MB RAM target
    jvmArgs += '-Xms256m'
    jvmArgs += '-Xmx512m'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // GARBAGE COLLECTOR (G1GC optimized for low latency media)
    // ─────────────────────────────────────────────────────────────────────────────
    jvmArgs += '-XX:+UseG1GC'
    jvmArgs += '-XX:G1HeapRegionSize=4m'       // Critical for 1080p frames (~1.2MB) to avoid humongous allocations
    jvmArgs += '-XX:MaxGCPauseMillis=10'       // Aggressive low-latency target
    jvmArgs += '-XX:ParallelGCThreads=4'       // Optimized for query/video processing
    jvmArgs += '-XX:ConcGCThreads=2'
    
    // Tuning Young Generation (Less aggressive to prevent 20ms+ Evac pauses)
    jvmArgs += '-XX:+UnlockExperimentalVMOptions'
    jvmArgs += '-XX:G1NewSizePercent=40'       // Was 20 - Increased to 40 to handle video frame allocations
    jvmArgs += '-XX:G1MaxNewSizePercent=60'    // Was 40 - Increased to 60 to allow bursts
    jvmArgs += '-XX:InitiatingHeapOccupancyPercent=45'
    jvmArgs += '-XX:+DisableExplicitGC'
    
    jvmArgs += '-XX:+UseStringDeduplication'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // THREAD STACK SIZE (DEFAULT 1MB → 512KB per thread)
    // With ~80 threads, this saves ~40MB
    // ─────────────────────────────────────────────────────────────────────────────
    jvmArgs += '-Xss512k'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // METASPACE LIMITS (Fix for Metadata GC Pauses)
    // ─────────────────────────────────────────────────────────────────────────────
    jvmArgs += '-XX:MetaspaceSize=128m'        // Start higher to avoid early GCs
    jvmArgs += '-XX:MaxMetaspaceSize=512m'     // Allow room for JFoenix/WebRTC overhead
    
    // ─────────────────────────────────────────────────────────────────────────────
    // CODE CACHE (Fix for CodeCache GC Pauses)
    // ─────────────────────────────────────────────────────────────────────────────
    jvmArgs += '-XX:ReservedCodeCacheSize=256m' // Increased from 64m
    jvmArgs += '-XX:InitialCodeCacheSize=32m'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // NETTY / gRPC OPTIMIZATION
    // Reduced buffer pools and arenas
    // ─────────────────────────────────────────────────────────────────────────────
    jvmArgs += '-Dio.netty.allocator.maxOrder=3'           // Smaller chunks
    jvmArgs += '-Dio.netty.allocator.numDirectArenas=2'    // Fewer arenas
    jvmArgs += '-Dio.netty.allocator.numHeapArenas=2'
    jvmArgs += '-Dio.netty.buffer.checkBounds=false'       // Skip bounds check
    jvmArgs += '-Dio.netty.buffer.checkAccessible=false'
    
    // Limit gRPC thread pool (default can grow unbounded)
    jvmArgs += '-Dio.grpc.netty.shaded.io.netty.eventLoopThreads=4'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // PLATFORM-SPECIFIC RENDERING
    // ─────────────────────────────────────────────────────────────────────────────
    if (isWindows) {
        // Windows: DirectX 11 (D3D) - no LLVM/Mesa overhead
        jvmArgs += '-Dprism.order=d3d,sw'
        jvmArgs += '-Dprism.d3d.forceGPU=true'
    } else if (isMacOS) {
        // macOS: Metal (if available) or OpenGL ES2
        jvmArgs += '-Dprism.order=es2,sw'
        jvmArgs += '-Dprism.forceGPU=true'
    } else {
        // Linux: OpenGL ES2 (loads LLVM+Mesa ~55MB - unavoidable)
        jvmArgs += '-Dprism.order=es2,sw'
        jvmArgs += '-Dprism.forceGPU=true'
        // Alternative: Software rendering (avoids LLVM but slower)
        // jvmArgs += '-Dprism.order=sw'
    }
    
    // Common rendering optimizations
    jvmArgs += '-Dprism.vsync=true'
    jvmArgs += '-Dprism.dirtyopts=true'
    jvmArgs += '-Dprism.poolstats=false'
    jvmArgs += '-Dglass.gtk.uiScale=1.0'
    
    // ─────────────────────────────────────────────────────────────────────────────
    // MISC OPTIMIZATIONS
    // ─────────────────────────────────────────────────────────────────────────────
    jvmArgs += '-XX:+UseCompressedOops'           // Compressed object pointers
    jvmArgs += '-XX:+UseCompressedClassPointers'  // Compressed class pointers
    jvmArgs += '-XX:+OptimizeStringConcat'        // String concat optimization
}

// ═══════════════════════════════════════════════════════════════════════════════
// NATIVE BUILD TASK (Automated C++ Compilation)
// ═══════════════════════════════════════════════════════════════════════════════

/**
 * Automatically compiles the NativeVideoEncoder C++ code for the host platform.
 * Supports: G++ (Linux/MinGW) and Clang (macOS)
 */
task compileNative {
    group = 'build'
    description = 'Compiles native video encoder library using CMake'
    
    // Inputs/Outputs for incremental build
    def sourceDir = file("src/main/native")
    inputs.dir sourceDir
    
    def platformDir = isWindows ? "windows-x86_64" : (isMacOS ? (isArm ? "macos-aarch64" : "macos-x86_64") : "linux-x86_64")
    def outputDir = file("src/main/resources/natives/${platformDir}")
    
    // Expected output library name
    def libName = isWindows ? "native_encoder.dll" : (isMacOS ? "libnative_encoder.dylib" : "libnative_encoder.so")
    def finalOutputFile = file("${outputDir}/${libName}")
    
    outputs.file finalOutputFile

    doLast {
        println "🔨 Building native library via CMake for ${platformDir}..."
        
        def buildDir = file("build/native_build")
        buildDir.mkdirs()
        
        // Ensure CMake is installed
        try {
            def checkCmake = isWindows ? ['cmd', '/c', 'cmake --version'] : ['cmake', '--version']
            def proc = checkCmake.execute()
            proc.waitFor()
            if (proc.exitValue() != 0) {
                throw new GradleException("CMake not found. Please install CMake to build native components.")
            }
        } catch (IOException e) {
             throw new GradleException("CMake not found. Please install CMake to build native components.")
        }

        // 1. Configure
        println "   → Configuring CMake..."
        exec {
            workingDir projectDir
            commandLine 'cmake', '-S', 'src/main/native', '-B', buildDir.absolutePath, '-DCMAKE_BUILD_TYPE=Release' 
        }
        
        // 2. Build
        println "   → Compiling..."
        exec {
            workingDir projectDir
            commandLine 'cmake', '--build', buildDir.absolutePath, '--config', 'Release'
        }
        
        // 3. Find and Copy Artifact
        // CMake build output location varies by generator (Debug/Release folder on Windows, root on Linux)
        def possiblePaths = [
            "${buildDir}/Release/${libName}",       // MSVC/Windows
            "${buildDir}/${libName}",               // Linux/Makefiles
            "${buildDir}/lib${libName}",            // Some defaults
            "${buildDir}/Release/lib${libName}"
        ]
        
        // On Windows, library might be named without 'lib' prefix usually, but let's check exact matches
        // CMakeLists specifies "native_encoder" target, so:
        // Linux: libnative_encoder.so
        // Windows: native_encoder.dll (Release/native_encoder.dll)
        // Mac: libnative_encoder.dylib
        
        def builtFile = null
        
        // We need to look for the file recursively or check specific locations
        // Let's use `find` approach if simple paths fail, or just check standard locations
        
        if (isWindows) {
             if (file("${buildDir}/Release/${libName}").exists()) builtFile = file("${buildDir}/Release/${libName}")
             else if (file("${buildDir}/${libName}").exists()) builtFile = file("${buildDir}/${libName}")
        } else {
             if (file("${buildDir}/${libName}").exists()) builtFile = file("${buildDir}/${libName}")
        }
        
        if (builtFile == null || !builtFile.exists()) {
             // Fallback search
             builtFile = fileTree(buildDir).matching { include "**/${libName}" }.singleFile
        }
        
        if (builtFile != null && builtFile.exists()) {
            println "   → Copying ${builtFile.name} to resources..."
            outputDir.mkdirs()
            
            copy {
                from builtFile
                into outputDir
                rename { libName } // Ensure name matches expectation
            }
            println "✅ Native build complete."
        } else {
            throw new GradleException("Could not locate compiled native library '${libName}' in ${buildDir}")
        }
    }
}

// Hook into the build process
processResources.dependsOn compileNative

// ═══════════════════════════════════════════════════════════════════════════════
// UTILITY TASKS
// ═══════════════════════════════════════════════════════════════════════════════

/**
 * Display runtime dependency sizes
 * Usage: ./gradlew showDeps
 */
task showDeps {
    group = 'help'
    description = 'Show runtime dependency sizes'
    doLast {
        println "\n╔═══════════════════════════════════════════════════════════════════╗"
        println "║               RUNTIME DEPENDENCIES (>500KB)                       ║"
        println "╠═══════════════════════════════════════════════════════════════════╣"
        def total = 0
        def artifacts = configurations.runtimeClasspath.resolvedConfiguration.resolvedArtifacts
            .sort { -it.file.length() }
        
        artifacts.each { artifact ->
            def sizeMB = artifact.file.length() / 1024.0 / 1024.0
            total += sizeMB
            if (sizeMB > 0.5) {
                def name = artifact.name.length() > 45 ? 
                    artifact.name.substring(0, 42) + "..." : artifact.name
                printf "║  %-45s %8.2f MB  ║\n", name, sizeMB
            }
        }
        println "╠═══════════════════════════════════════════════════════════════════╣"
        printf "║  %-45s %8.2f MB  ║\n", "TOTAL", total
        println "╚═══════════════════════════════════════════════════════════════════╝"
    }
}

/**
 * Display platform information
 * Usage: ./gradlew platformInfo
 */
task platformInfo {
    group = 'help'
    description = 'Show detected platform and feature status'
    doLast {
        println "\n╔═══════════════════════════════════════════════════════════════════╗"
        println "║                    PLATFORM INFORMATION                           ║"
        println "╠═══════════════════════════════════════════════════════════════════╣"
        println "║  Operating System:  ${currentOs.familyName.padRight(45)}║"
        println "║  Architecture:      ${osArch.padRight(45)}║"
        println "║  Java Version:      ${System.getProperty('java.version').padRight(45)}║"
        println "╠═══════════════════════════════════════════════════════════════════╣"
        println "║  FEATURE STATUS                                                   ║"
        println "╠═══════════════════════════════════════════════════════════════════╣"
        println "║  Video Calls:       ✓ Enabled                                    ║"
        println "║  Audio Calls:       ✓ Enabled                                    ║"
        println "║  Messaging:         ✓ Enabled                                    ║"
        println "║  File Transfer:     ✓ Enabled                                    ║"
        def screenShare = (isWindows || isMacOS) ? "✓ Enabled" : "✗ Disabled (Linux)"
        println "║  Screen Sharing:    ${screenShare.padRight(45)}║"
        println "║  PDF Preview:       ✗ Disabled (opens with system app)          ║"
        println "╚═══════════════════════════════════════════════════════════════════╝"
    }
}

/**
 * Clean build and show new dependency footprint
 * Usage: ./gradlew cleanBuild
 */
task cleanBuild {
    group = 'build'
    description = 'Clean build with dependency report'
    dependsOn 'clean', 'compileJava'
    finalizedBy 'showDeps'
}