Pruebas de Rendimiento de Aplicaciones Móviles: Métricas, Herramientas y Mejores Prácticas

// AppDelegate.swift - Seguimiento de métricas de inicio
import UIKit

@main
class AppDelegate: UIResponder, UIApplicationDelegate {
    var launchStartTime: CFAbsoluteTime?

    func application(_ application: UIApplication,
                    didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        launchStartTime = CFAbsoluteTimeGetCurrent()

        // Realizar inicialización
        setupServices()

        let launchTime = CFAbsoluteTimeGetCurrent() - (launchStartTime ?? 0)
        print("Tiempo de inicio de app: \(launchTime) segundos")

        // Enviar a analytics
        Analytics.track("app_launch_time", properties: ["duration": launchTime])

        return true
    }
}

// MainActivity.kt
class MainActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // Medir tiempo hasta visualización inicial
        reportFullyDrawn()
    }
}

// Clase Application
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()

        // Inicializar métricas de inicio
        AppStartup.getInstance(this)
            .addOnStartupCompleteListener { startupTime ->
                Log.d("Startup", "Tiempo: $startupTime ms")
                Analytics.logEvent("app_startup", bundleOf("time_ms" to startupTime))
            }
    }
}

// Monitorear uso de memoria programáticamente
class MemoryMonitor {
    static func getCurrentMemoryUsage() -> UInt64 {
        var info = mach_task_basic_info()
        var count = mach_msg_type_number_t(MemoryLayout<mach_task_basic_info>.size)/4

        let kerr: kern_return_t = withUnsafeMutablePointer(to: &info) {
            $0.withMemoryRebound(to: integer_t.self, capacity: 1) {
                task_info(mach_task_self_,
                         task_flavor_t(MACH_TASK_BASIC_INFO),
                         $0,
                         &count)
            }
        }

        if kerr == KERN_SUCCESS {
            return info.resident_size
        }
        return 0
    }

    static func logMemoryUsage() {
        let usedMemory = Double(getCurrentMemoryUsage()) / 1024 / 1024
        print("Uso de memoria: \(String(format: "%.2f", usedMemory)) MB")
    }
}

// MemoryMonitor.kt
class MemoryMonitor(private val context: Context) {

    fun getMemoryInfo(): MemoryInfo {
        val activityManager = context.getSystemService(Context.ACTIVITY_SERVICE) as ActivityManager
        val memoryInfo = ActivityManager.MemoryInfo()
        activityManager.getMemoryInfo(memoryInfo)

        val runtime = Runtime.getRuntime()
        val usedMemory = runtime.totalMemory() - runtime.freeMemory()

        return MemoryInfo(
            usedMemoryMB = usedMemory / 1024 / 1024,
            totalMemoryMB = runtime.totalMemory() / 1024 / 1024,
            availableMemoryMB = memoryInfo.availMem / 1024 / 1024
        )
    }

    fun detectMemoryLeaks() {
        LeakCanary.install(context)
    }
}

data class MemoryInfo(
    val usedMemoryMB: Long,
    val totalMemoryMB: Long,
    val availableMemoryMB: Long
)

# Usando Xcode Energy Log
# 1. Ejecutar app con instrumento Energy Log
# 2. Realizar escenarios típicos de usuario
# 3. Analizar impacto energético por componente

# Monitoreo de batería por línea de comandos
xcrun xctrace record --device <device-id> \
  --template 'Energy Log' \
  --output battery_test.trace \
  --time-limit 10m

# Capturar estadísticas de batería
adb shell dumpsys batterystats --reset
# Usar app durante duración de prueba
adb shell dumpsys batterystats > batterystats.txt

# Generar reporte de Battery Historian
adb bugreport bugreport.zip
# Cargar a https://bathist.ef.lc/ para análisis

// BackgroundTaskManager.swift
class BackgroundTaskManager {
    private var backgroundTask: UIBackgroundTaskIdentifier = .invalid

    func beginBackgroundTask() {
        backgroundTask = UIApplication.shared.beginBackgroundTask {
            self.endBackgroundTask()
        }
    }

    func endBackgroundTask() {
        if backgroundTask != .invalid {
            UIApplication.shared.endBackgroundTask(backgroundTask)
            backgroundTask = .invalid
        }
    }

    // Optimizar actualizaciones de ubicación
    func optimizeLocationUpdates() {
        let locationManager = CLLocationManager()
        locationManager.desiredAccuracy = kCLLocationAccuracyHundredMeters
        locationManager.pausesLocationUpdatesAutomatically = true
        locationManager.allowsBackgroundLocationUpdates = false
    }
}

// PowerOptimization.kt
class PowerOptimization(private val context: Context) {

    fun scheduleBatteryEfficientWork() {
        val constraints = Constraints.Builder()
            .setRequiresBatteryNotLow(true)
            .setRequiresCharging(false)
            .build()

        val workRequest = PeriodicWorkRequestBuilder<DataSyncWorker>(
            15, TimeUnit.MINUTES
        )
            .setConstraints(constraints)
            .build()

        WorkManager.getInstance(context).enqueue(workRequest)
    }

    fun isIgnoringBatteryOptimizations(): Boolean {
        val powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
        return powerManager.isIgnoringBatteryOptimizations(context.packageName)
    }
}

// NetworkMonitor.swift
import Network

class NetworkMonitor {
    private let monitor = NWPathMonitor()
    private let queue = DispatchQueue(label: "NetworkMonitor")

    func startMonitoring() {
        monitor.pathUpdateHandler = { path in
            if path.status == .satisfied {
                print("Red disponible")
                self.logNetworkType(path)
            } else {
                print("Sin conexión de red")
            }
        }
        monitor.start(queue: queue)
    }

    private func logNetworkType(_ path: NWPath) {
        if path.usesInterfaceType(.wifi) {
            print("Usando WiFi")
        } else if path.usesInterfaceType(.cellular) {
            print("Usando Celular")
        }
    }

    // Medir rendimiento de solicitud de red
    func measureRequestTime(url: URL, completion: @escaping (TimeInterval) -> Void) {
        let startTime = CFAbsoluteTimeGetCurrent()

        URLSession.shared.dataTask(with: url) { data, response, error in
            let endTime = CFAbsoluteTimeGetCurrent()
            let requestTime = endTime - startTime
            completion(requestTime)
        }.resume()
    }
}

// NetworkPerformanceTracker.kt
class NetworkPerformanceTracker {

    fun trackApiCall(url: String, block: () -> Response): Response {
        val startTime = System.currentTimeMillis()
        var responseSize = 0L

        val response = try {
            block().also { response ->
                responseSize = response.body?.contentLength() ?: 0
            }
        } catch (e: Exception) {
            logNetworkError(url, e)
            throw e
        }

        val duration = System.currentTimeMillis() - startTime

        logNetworkMetrics(NetworkMetrics(
            url = url,
            durationMs = duration,
            responseSizeBytes = responseSize,
            statusCode = response.code
        ))

        return response
    }

    private fun logNetworkMetrics(metrics: NetworkMetrics) {
        Log.d("NetworkPerf", """
            URL: ${metrics.url}
            Duración: ${metrics.durationMs}ms
            Tamaño: ${metrics.responseSizeBytes} bytes
            Estado: ${metrics.statusCode}
        """.trimIndent())
    }
}

data class NetworkMetrics(
    val url: String,
    val durationMs: Long,
    val responseSizeBytes: Long,
    val statusCode: Int
)

# Profiling de CPU
instruments -t "Time Profiler" -D cpu_profile.trace -l 60000 YourApp.app

# Profiling de GPU
instruments -t "Metal System Trace" -D gpu_profile.trace YourApp.app

// PerformanceOptimization.swift
class ImageProcessor {

    // Operación intensiva en CPU - optimizar con GCD
    func processImagesInParallel(images: [UIImage]) -> [UIImage] {
        let queue = DispatchQueue(label: "imageProcessing",
                                 attributes: .concurrent)
        var processedImages: [UIImage] = []
        let group = DispatchGroup()

        for image in images {
            group.enter()
            queue.async {
                let processed = self.applyFilter(to: image)
                processedImages.append(processed)
                group.leave()
            }
        }

        group.wait()
        return processedImages
    }

    // Usar GPU para procesamiento de imágenes cuando esté disponible
    func applyFilterGPU(to image: UIImage) -> UIImage {
        let context = CIContext(options: [.useSoftwareRenderer: false])
        let filter = CIFilter(name: "CISepiaTone")
        filter?.setValue(CIImage(image: image), forKey: kCIInputImageKey)

        if let output = filter?.outputImage,
           let cgImage = context.createCGImage(output, from: output.extent) {
            return UIImage(cgImage: cgImage)
        }
        return image
    }
}

// PerformanceTracker.kt
class PerformanceTracker {

    fun trackMethodPerformance(methodName: String, block: () -> Unit) {
        val startTime = System.nanoTime()
        val startCpu = Debug.threadCpuTimeNanos()

        block()

        val cpuTime = (Debug.threadCpuTimeNanos() - startCpu) / 1_000_000
        val wallTime = (System.nanoTime() - startTime) / 1_000_000

        Log.d("Performance", """
            Método: $methodName
            Tiempo CPU: ${cpuTime}ms
            Tiempo Total: ${wallTime}ms
        """.trimIndent())
    }

    // Detectar sobredibujo de GPU
    fun checkGpuOverdraw(activity: Activity) {
        val debugOverdraw = Settings.Global.getString(
            activity.contentResolver,
            "debug.hwui.overdraw"
        )
        Log.d("GPU", "Configuración de overdraw: $debugOverdraw")
    }
}

// FPSMonitor.swift
class FPSMonitor {
    private var displayLink: CADisplayLink?
    private var lastTimestamp: CFTimeInterval = 0
    private var frameCount: Int = 0

    func startMonitoring() {
        displayLink = CADisplayLink(target: self,
                                   selector: #selector(displayLinkTick))
        displayLink?.add(to: .main, forMode: .common)
    }

    @objc private func displayLinkTick(displayLink: CADisplayLink) {
        if lastTimestamp == 0 {
            lastTimestamp = displayLink.timestamp
            return
        }

        frameCount += 1
        let elapsed = displayLink.timestamp - lastTimestamp

        if elapsed >= 1.0 {
            let fps = Double(frameCount) / elapsed
            print("FPS: \(Int(fps))")

            frameCount = 0
            lastTimestamp = displayLink.timestamp

            // Alertar si FPS cae por debajo del umbral
            if fps < 55 {
                print("⚠️ FPS bajo detectado: \(Int(fps))")
            }
        }
    }

    func stopMonitoring() {
        displayLink?.invalidate()
        displayLink = nil
    }
}

// FrameMetricsTracker.kt
class FrameMetricsTracker(private val activity: Activity) {

    fun startTracking() {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
            activity.window.addOnFrameMetricsAvailableListener(
                { _, frameMetrics, _ ->
                    val totalDuration = frameMetrics.getMetric(
                        FrameMetrics.TOTAL_DURATION
                    )
                    val totalDurationMs = totalDuration / 1_000_000.0

                    // Tiempo de fotograma debe ser < 16.67ms para 60 FPS
                    if (totalDurationMs > 16.67) {
                        Log.w("FrameMetrics", "Fotograma lento: ${totalDurationMs}ms")

                        // Desglosar el fotograma lento
                        logFrameBreakdown(frameMetrics)
                    }
                },
                Handler(Looper.getMainLooper())
            )
        }
    }

    private fun logFrameBreakdown(metrics: FrameMetrics) {
        val inputMs = metrics.getMetric(FrameMetrics.INPUT_HANDLING_DURATION) / 1_000_000.0
        val animationMs = metrics.getMetric(FrameMetrics.ANIMATION_DURATION) / 1_000_000.0
        val layoutMs = metrics.getMetric(FrameMetrics.LAYOUT_MEASURE_DURATION) / 1_000_000.0
        val drawMs = metrics.getMetric(FrameMetrics.DRAW_DURATION) / 1_000_000.0

        Log.d("FrameBreakdown", """
            Entrada: ${inputMs}ms
            Animación: ${animationMs}ms
            Layout: ${layoutMs}ms
            Dibujo: ${drawMs}ms
        """.trimIndent())
    }
}

# Generar reporte de tamaño de app
xcodebuild -exportArchive \
  -archivePath YourApp.xcarchive \
  -exportPath AppSizeReport \
  -exportOptionsPlist exportOptions.plist \
  -exportFormat APP_SIZE_REPORT

# Analizar tamaño del binario
xcrun dyldinfo -size YourApp.app/YourApp

# Construir APK con análisis de tamaño
./gradlew assembleRelease

# Analizar tamaño de APK
bundletool dump manifest --bundle=app-release.aab
bundletool get-size total --bundle=app-release.aab

# Generar reporte de tamaño
./gradlew app:analyzeReleaseBundle

// PerformanceTests.swift
import XCTest

class PerformanceTests: XCTestCase {

    func testAppLaunchPerformance() {
        measure(metrics: [XCTApplicationLaunchMetric()]) {
            XCUIApplication().launch()
        }
    }

    func testScrollingPerformance() {
        let app = XCUIApplication()
        app.launch()

        measure(metrics: [XCTOSSignpostMetric.scrollDecelerationMetric]) {
            app.tables.firstMatch.swipeUp(velocity: .fast)
        }
    }

    func testMemoryPerformance() {
        measure(metrics: [XCTMemoryMetric()]) {
            // Realizar operación intensiva en memoria
            let viewController = DataViewController()
            viewController.loadLargeDataset()
        }
    }

    func testNetworkPerformance() {
        let expectation = XCTestExpectation(description: "Llamada API")

        measure {
            NetworkService.shared.fetchData { result in
                expectation.fulfill()
            }
            wait(for: [expectation], timeout: 10.0)
        }
    }
}

// PerformanceBenchmark.kt
@RunWith(AndroidJUnit4::class)
class PerformanceBenchmark {

    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    @Test
    fun startupCompilation() = benchmarkRule.measureRepeated(
        packageName = "com.yourapp",
        metrics = listOf(StartupTimingMetric()),
        iterations = 10,
        startupMode = StartupMode.COLD
    ) {
        pressHome()
        startActivityAndWait()
    }

    @Test
    fun scrollPerformance() = benchmarkRule.measureRepeated(
        packageName = "com.yourapp",
        metrics = listOf(FrameTimingMetric()),
        iterations = 5
    ) {
        startActivityAndWait()

        val recyclerView = device.findObject(By.res("article_list"))
        repeat(10) {
            recyclerView.scroll(Direction.DOWN, 0.8f)
            device.waitForIdle()
        }
    }
}

// PerformanceMetrics.kt
data class AppPerformanceMetrics(
    val launchTimeMs: Long,
    val memoryUsageMB: Double,
    val batteryDrainPercent: Double,
    val avgFrameTimeMs: Double,
    val networkLatencyMs: Long,
    val appSizeMB: Double,
    val crashFreeRate: Double
)

class PerformanceBenchmark {

    fun generatePerformanceReport(metrics: AppPerformanceMetrics): BenchmarkReport {
        val benchmarks = loadHistoricalBenchmarks()

        return BenchmarkReport(
            metrics = metrics,
            launchTimeDelta = calculateDelta(metrics.launchTimeMs, benchmarks.avgLaunchTime),
            memoryDelta = calculateDelta(metrics.memoryUsageMB, benchmarks.avgMemory),
            passed = metrics.launchTimeMs < 2000 &&
                     metrics.memoryUsageMB < 200 &&
                     metrics.avgFrameTimeMs < 16.67
        )
    }

    private fun calculateDelta(current: Double, baseline: Double): Double {
        return ((current - baseline) / baseline) * 100
    }
}

# .github/workflows/performance-test.yml
name: Pruebas de Rendimiento

on:
  pull_request:
    branches: [ main, develop ]
  schedule:
    - cron: '0 0 * * 0'  # Semanalmente

jobs:
  ios-performance:
    runs-on: macos-latest
    steps:
      - uses: actions/checkout@v3

      - name: Ejecutar Pruebas de Rendimiento iOS
        run: |
          xcodebuild test \
            -scheme YourApp \
            -destination 'platform=iOS Simulator,name=iPhone 14' \
            -testPlan PerformanceTests \
            -resultBundlePath TestResults.xcresult

      - name: Analizar Resultados
        run: |
          xcrun xcresulttool get --format json \
            --path TestResults.xcresult > results.json

          python scripts/analyze_performance.py results.json

      - name: Comentar PR con Resultados
        uses: actions/github-script@v6
        with:
          script: |
            const fs = require('fs');
            const report = fs.readFileSync('performance_report.md', 'utf8');
            github.rest.issues.createComment({
              issue_number: context.issue.number,
              owner: context.repo.owner,
              repo: context.repo.repo,
              body: report
            });

  android-performance:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v3

      - name: Configurar JDK
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '17'

      - name: Ejecutar Pruebas de Rendimiento Android
        run: |
          ./gradlew connectedAndroidTest \
            -Pandroid.testInstrumentationRunnerArguments.class=\
            com.yourapp.PerformanceBenchmark

      - name: Cargar Resultados de Benchmark
        run: |
          ./gradlew uploadBenchmarkResults \
            --benchmarkData build/outputs/benchmark/results.json

# scripts/detect_performance_regression.py
import json
import sys

def detect_regression(current_metrics, baseline_metrics, threshold=10):
    regressions = []

    metrics_to_check = [
        'launch_time_ms',
        'memory_usage_mb',
        'avg_frame_time_ms'
    ]

    for metric in metrics_to_check:
        current = current_metrics.get(metric, 0)
        baseline = baseline_metrics.get(metric, 0)

        if baseline > 0:
            change_percent = ((current - baseline) / baseline) * 100

            if change_percent > threshold:
                regressions.append({
                    'metric': metric,
                    'current': current,
                    'baseline': baseline,
                    'change_percent': change_percent
                })

    return regressions

def main():
    with open('current_results.json') as f:
        current = json.load(f)

    with open('baseline_results.json') as f:
        baseline = json.load(f)

    regressions = detect_regression(current, baseline)

    if regressions:
        print("⚠️ Regresiones de rendimiento detectadas:")
        for reg in regressions:
            print(f"  {reg['metric']}: {reg['change_percent']:.1f}% incremento")
        sys.exit(1)
    else:
        print("✅ No se detectaron regresiones de rendimiento")
        sys.exit(0)

if __name__ == '__main__':
    main()