Mobile Performance Profiling: Memoria, Batería y Más Allá

El rendimiento es un factor crítico en el éxito de aplicaciones móviles. Los usuarios (como se discute en Detox: Grey-Box Testing for React Native Applications) esperan aplicaciones rápidas y responsivas que no agoten su batería ni consuman datos excesivos. El mal rendimiento conduce a reseñas negativas, mayor abandono y clasificaciones más bajas en app stores. Esta guía completa cubre técnicas esenciales de profiling de rendimiento móvil, desde detectar memory leaks hasta optimizar tiempo de inicio, ayudándote a entregar experiencias móviles excepcionales.

El Panorama del Rendimiento Móvil

Por Qué Importa el Rendimiento

El rendimiento impacta cada aspecto del éxito de una app móvil:

Métrica	Impacto
Tiempo de Carga	53% de usuarios abandonan apps que tardan >3 segundos en cargar
Consumo de Batería	Apps que usan >20% de batería diariamente se desinstalan
Uso de Memoria	Apps de alta memoria crashean 3x más frecuentemente
Tamaño de App	Cada aumento de 6MB = 1% de caída en conversión
Uso de Red	Consumo excesivo de datos = quejas de usuarios y desinstalaciones

El testing de rendimiento integral debe abordar cada uno de estos aspectos para garantizar una experiencia de usuario excepcional.

Detección de Memory Leaks

Profiling de Memoria en iOS con Instruments

Usando Memory Graph Debugger:

// Ejemplo: Retain cycle común con closures
class UserViewController: UIViewController {
    var userService: UserService?

    override func viewDidLoad() {
        super.viewDidLoad()

        // ❌ MAL: Crea retain cycle
        userService?.fetchUser { user in
            self.updateUI(with: user)  // 'self' capturado fuertemente
        }

        // ✅ BIEN: Usar weak self
        userService?.fetchUser { [weak self] user in
            self?.updateUI(with: user)
        }

        // ✅ ALTERNATIVA: Usar unowned si self está garantizado que existe
        userService?.fetchUser { [unowned self] user in
            self.updateUI(with: user)
        }
    }

    private func updateUI(with user: User) {
        // Actualizar UI
    }
}

Detectando Leaks con Unit Tests:

import XCTest

class MemoryLeakTests: XCTestCase {

    func testViewControllerDoesNotLeak() {
        let viewController = UserViewController()

        // Rastrear el view controller débilmente
        weak var weakVC = viewController

        // Presentar y descartar
        let window = UIWindow()
        window.rootViewController = viewController
        window.makeKeyAndVisible()

        // Simular descarte
        window.rootViewController = nil

        // Verificar desasignación
        XCTAssertNil(weakVC, "UserViewController debería ser desasignado")
    }

    func testImageCacheReleasesMemoryUnderPressure() {
        let cache = ImageCache.shared

        // Llenar cache con imágenes
        for i in 0..<100 {
            let image = generateTestImage()
            cache.store(image, forKey: "image-\(i)")
        }

        let initialMemory = cache.currentMemoryUsage

        // Simular advertencia de memoria
        NotificationCenter.default.post(
            name: UIApplication.didReceiveMemoryWarningNotification,
            object: nil
        )

        // Esperar limpieza
        let expectation = XCTestExpectation(description: "Memory cleanup")
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            expectation.fulfill()
        }
        wait(for: [expectation], timeout: 2)

        let finalMemory = cache.currentMemoryUsage

        // La memoria debería reducirse significativamente
        XCTAssertLessThan(
            finalMemory,
            initialMemory * 0.5,
            "Cache debería liberar al menos 50% de memoria"
        )
    }
}

Profiling de Memoria en Android

Usando LeakCanary:

// build.gradle
dependencies {
    debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.12'
}

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

        // LeakCanary inicializado automáticamente
        // Configurar si es necesario
        LeakCanary.config = LeakCanary.config.copy(
            retainedVisibleThreshold = 3,
            dumpHeap = true
        )
    }
}

Detección Personalizada de Memory Leaks:

@RunWith(AndroidJUnit4::class)
class MemoryLeakTests {

    @Test
    fun activityDoesNotLeak() {
        val scenario = ActivityScenario.launch(MainActivity::class.java)

        // Mantener referencia débil
        var weakActivity: WeakReference<MainActivity>? = null

        scenario.onActivity { activity ->
            weakActivity = WeakReference(activity)
        }

        // Cerrar activity
        scenario.close()

        // Forzar recolección de basura
        Runtime.getRuntime().gc()
        Thread.sleep(1000)
        Runtime.getRuntime().gc()

        // Verificar que activity fue recolectada
        assertNull(
            "MainActivity debería ser recolectada por garbage collector",
            weakActivity?.get()
        )
    }

    @Test
    fun bitmapRecycling() {
        val options = BitmapFactory.Options().apply {
            inMutable = true
        }

        var bitmap: Bitmap? = BitmapFactory.decodeResource(
            InstrumentationRegistry.getInstrumentation().context.resources,
            R.drawable.test_image,
            options
        )

        assertNotNull(bitmap)
        val byteCount = bitmap!!.byteCount

        // Reciclar bitmap
        bitmap.recycle()
        bitmap = null

        // Forzar GC
        Runtime.getRuntime().gc()
        Thread.sleep(500)

        // Verificar que la memoria fue liberada
        val runtime = Runtime.getRuntime()
        val freeMemory = runtime.freeMemory()

        assertTrue(
            "Memoria de bitmap debería ser liberada",
            freeMemory > byteCount
        )
    }
}

Testing de Consumo de Batería

El consumo excesivo de batería es una de las principales razones de desinstalación. Como parte del testing de rendimiento de apps móviles, el monitoreo de batería es esencial para la satisfacción del usuario.

Profiling de Batería en iOS

Usando XCTest para Impacto de Energía:

class BatteryConsumptionTests: XCTestCase {

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

        let metrics = [
            XCTCPUMetric(),
            XCTMemoryMetric(),
            XCTStorageMetric()
        ]

        let options = XCTMeasureOptions()
        options.iterationCount = 3

        measure(metrics: metrics, options: options) {
            // Habilitar seguimiento de ubicación
            app.switches["Location Tracking"].tap()

            // Simular modo background
            XCUIDevice.shared.press(.home)

            // Esperar actividad en background
            Thread.sleep(forTimeInterval: 60)

            // Volver a app
            app.activate()

            // Deshabilitar ubicación
            app.switches["Location Tracking"].tap()
        }
    }
}

Testing de Batería en Android

Usando Battery Historian:

# Recolectar datos de batería
adb shell dumpsys batterystats --reset
adb shell dumpsys batterystats --enable full-wake-history

# Ejecutar tests
./gradlew connectedAndroidTest

# Obtener estadísticas de batería
adb bugreport bugreport.zip

# Analizar con Battery Historian
# Subir bugreport.zip a https://bathist.ef.lc/

Testing Automatizado de Batería:

@RunWith(AndroidJUnit4::class)
class BatteryConsumptionTests {

    private lateinit var powerManager: PowerManager

    @Before
    fun setup() {
        val context = ApplicationProvider.getApplicationContext<Context>()
        powerManager = context.getSystemService(Context.POWER_SERVICE) as PowerManager
    }

    @Test
    fun testWakeLockIsReleasedProperly() {
        val wakeLock = powerManager.newWakeLock(
            PowerManager.PARTIAL_WAKE_LOCK,
            "MyApp::TestWakeLock"
        )

        // Adquirir wake lock
        wakeLock.acquire(10*60*1000L)  // 10 minutos
        assertTrue(wakeLock.isHeld)

        // Realizar operación
        performNetworkSync()

        // Liberar wake lock
        if (wakeLock.isHeld) {
            wakeLock.release()
        }

        assertFalse(wakeLock.isHeld)
    }

    @Test
    fun testLocationUpdatesUseAppropriateInterval() {
        val locationManager = ApplicationProvider
            .getApplicationContext<Context>()
            .getSystemService(Context.LOCATION_SERVICE) as LocationManager

        val locationListener = object : LocationListener {
            var updateCount = 0
            var timestamps = mutableListOf<Long>()

            override fun onLocationChanged(location: Location) {
                updateCount++
                timestamps.add(System.currentTimeMillis())
            }

            override fun onStatusChanged(provider: String?, status: Int, extras: Bundle?) {}
            override fun onProviderEnabled(provider: String) {}
            override fun onProviderDisabled(provider: String) {}
        }

        // Solicitar actualizaciones de ubicación
        locationManager.requestLocationUpdates(
            LocationManager.GPS_PROVIDER,
            60000L,  // 1 minuto mínimo
            100f,     // 100 metros distancia mínima
            locationListener
        )

        // Esperar y verificar frecuencia de actualización
        Thread.sleep(180000)  // 3 minutos

        locationManager.removeUpdates(locationListener)

        // Debería tener aproximadamente 3 actualizaciones (una por minuto)
        assertTrue(
            "Actualizaciones de ubicación muy frecuentes: ${locationListener.updateCount}",
            locationListener.updateCount <= 4
        )

        // Verificar intervalos entre actualizaciones
        for (i in 1 until locationListener.timestamps.size) {
            val interval = locationListener.timestamps[i] - locationListener.timestamps[i-1]
            assertTrue(
                "Intervalo de actualización muy corto: ${interval}ms",
                interval >= 55000  // Permitir 5s de tolerancia
            )
        }
    }
}

Optimización de Red

Monitoreando Eficiencia de Red

Testing de Red en iOS:

class NetworkPerformanceTests: XCTestCase {

    func testAppHandles3GNetworkWell() {
        let app = XCUIApplication()
        app.launchArguments = ["NETWORK_3G"]
        app.launch()

        measure(metrics: [XCTClockMetric()]) {
            app.buttons["Refresh"].tap()

            let loadingComplete = app.staticTexts["Content Loaded"]
            let exists = loadingComplete.waitForExistence(timeout: 10)

            XCTAssertTrue(exists, "Contenido debería cargar en 10s con 3G")
        }
    }

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

        // Navegar a galería de imágenes
        app.tabBars.buttons["Gallery"].tap()

        measure(metrics: [XCTClockMetric(), XCTMemoryMetric()]) {
            // Desplazarse por imágenes
            let collectionView = app.collectionViews.firstMatch
            for _ in 0..<20 {
                collectionView.swipeUp()
            }
        }
    }
}

Profiling de Red en Android:

@RunWith(AndroidJUnit4::class)
class NetworkOptimizationTests {

    @Test
    fun testRequestBatching() {
        val mockServer = MockWebServer()
        mockServer.start()

        var requestCount = 0
        mockServer.dispatcher = object : Dispatcher() {
            override fun dispatch(request: RecordedRequest): MockResponse {
                requestCount++
                return MockResponse().setResponseCode(200).setBody("{}")
            }
        }

        // Disparar múltiples operaciones que necesitan datos
        val scenario = ActivityScenario.launch(MainActivity::class.java)
        scenario.onActivity { activity ->
            activity.loadUserData()
            activity.loadPreferences()
            activity.loadNotifications()
        }

        Thread.sleep(2000)  // Esperar ventana de batching

        // Debería agrupar en un solo request o mínimos requests
        assertTrue(
            "Demasiados requests de red: $requestCount",
            requestCount <= 2  // Permitir algo de flexibilidad
        )

        mockServer.shutdown()
    }

    @Test
    fun testResponseCaching() {
        val context = ApplicationProvider.getApplicationContext<Context>()
        val cacheDir = context.cacheDir
        val cacheSize = 10 * 1024 * 1024  // 10 MB

        val cache = Cache(cacheDir, cacheSize.toLong())
        val client = OkHttpClient.Builder()
            .cache(cache)
            .build()

        val request = Request.Builder()
            .url("https://api.example.com/users")
            .build()

        // Primer request - debería ir a la red
        val response1 = client.newCall(request).execute()
        assertNotNull(response1.networkResponse)
        assertNull(response1.cacheResponse)
        response1.close()

        // Segundo request - debería usar cache
        val response2 = client.newCall(request).execute()
        assertNull(response2.networkResponse)
        assertNotNull(response2.cacheResponse)
        response2.close()
    }
}

Optimización de Tamaño de App

Midiendo Tamaño de App

iOS App Thinning:

# Generar reporte de tamaño de app
xcodebuild -exportArchive \
  -archivePath MyApp.xcarchive \
  -exportPath ./Export \
  -exportOptionsPlist ExportOptions.plist

# Analizar tamaño de app por dispositivo
ls -lh Export/*.ipa

Android APK Analyzer:

# Analizar tamaño de APK
./gradlew :app:assembleRelease

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

Testing Automatizado de Tamaño:

@RunWith(AndroidJUnit4::class)
class AppSizeTests {

    @Test
    fun verifyApkSizeWithinBudget() {
        val apkFile = File("app/build/outputs/apk/release/app-release.apk")
        assertTrue("Archivo APK no encontrado", apkFile.exists())

        val apkSizeMB = apkFile.length() / (1024.0 * 1024.0)
        val maxSizeMB = 50.0  // Presupuesto de 50 MB

        assertTrue(
            "Tamaño de APK (${apkSizeMB}MB) excede presupuesto (${maxSizeMB}MB)",
            apkSizeMB <= maxSizeMB
        )
    }

    @Test
    fun verifyNoUnusedResources() {
        // Esto típicamente se integraría en proceso de build
        val lintResults = runLintCheck()

        val unusedResources = lintResults
            .filter { it.id == "UnusedResources" }

        assertTrue(
            "Se encontraron ${unusedResources.size} recursos sin usar",
            unusedResources.isEmpty()
        )
    }
}

Optimización de Tiempo de Inicio

El tiempo de inicio es crítico para las primeras impresiones. Las estrategias modernas de testing móvil enfatizan la importancia de lanzamientos rápidos y responsivos en todos los dispositivos y versiones de SO.

Midiendo Tiempo de Lanzamiento de App

Testing de Tiempo de Lanzamiento en iOS:

class LaunchTimeTests: XCTestCase {

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

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

        // Enviar a background
        XCUIDevice.shared.press(.home)
        Thread.sleep(forTimeInterval: 2)

        // Relanzar
        measure(metrics: [XCTApplicationLaunchMetric()]) {
            app.activate()
        }
    }
}

Benchmarking de Inicio en Android:

@RunWith(AndroidJUnit4::class)
class StartupBenchmark {

    @get:Rule
    val benchmarkRule = MacrobenchmarkRule()

    @Test
    fun coldStartup() = benchmarkRule.measureRepeated(
        packageName = "com.example.app",
        metrics = listOf(StartupTimingMetric()),
        iterations = 5,
        startupMode = StartupMode.COLD
    ) {
        pressHome()
        startActivityAndWait()
    }

    @Test
    fun warmStartup() = benchmarkRule.measureRepeated(
        packageName = "com.example.app",
        metrics = listOf(StartupTimingMetric()),
        iterations = 5,
        startupMode = StartupMode.WARM
    ) {
        pressHome()
        startActivityAndWait()
    }
}

Conclusión

El profiling de rendimiento móvil es esencial para entregar aplicaciones de alta calidad que los usuarios aman. Al implementar estrategias integrales de testing para gestión de memoria, consumo de batería, eficiencia de red, tamaño de app y tiempo de inicio, los equipos pueden identificar y corregir problemas de rendimiento antes de que impacten a los usuarios (como se discute en Espresso & XCUITest: Mastering Native Mobile Testing Frameworks).

Conclusiones Clave:

Los memory leaks deben ser detectados y corregidos mediante testing automatizado y herramientas de profiling
El consumo de batería debe ser monitoreado para asegurar que las apps no agoten excesivamente la energía del dispositivo
La optimización de red reduce el uso de datos y mejora la capacidad de respuesta
El tamaño de app impacta directamente las tasas de conversión de descarga y satisfacción del usuario
El tiempo de inicio es crítico para primeras impresiones y retención de usuarios

El (como se discute en iOS UI Testing with XCTest: Advanced Techniques and Best Practices) testing de rendimiento debe integrarse a lo largo del ciclo de vida del desarrollo, desde tests unitarios hasta monitoreo de producción, asegurando experiencias móviles consistentemente excelentes.