Cómo implementar Background Tasks en Swift: Ejecuta código en tu App cuando el usuario no la usa

Publicado el

En el competitivo ecosistema de las aplicaciones móviles, la experiencia del usuario lo es todo. Imagina que un usuario abre tu aplicación de noticias y tiene que esperar varios segundos a que carguen los últimos artículos, o que abre tu app de finanzas y los datos están desactualizados. Esta fricción puede hacer que un usuario abandone tu aplicación para siempre.

Afortunadamente, Apple nos proporciona una solución robusta: el framework BackgroundTasks. Con él, puedes ejecutar código en segundo plano de manera eficiente, manteniendo tu app actualizada y realizando tareas pesadas sin impactar el rendimiento del dispositivo ni agotar la batería.

En este artículo, aprenderás paso a paso cómo implementar Background Tasks en Swift, desde la configuración inicial en Xcode hasta la ejecución del código y las pruebas en el simulador.

¿Qué son las Background Tasks y cómo funcionan en iOS?

El sistema operativo iOS es extremadamente estricto con la gestión de recursos. Para preservar la vida útil de la batería y la memoria RAM, iOS suspende las aplicaciones poco después de que el usuario las envía al fondo.

Sin embargo, a partir de iOS 13, Apple introdujo el framework BackgroundTasks, el cual permite a las aplicaciones solicitar al sistema tiempo de ejecución en segundo plano. El sistema utiliza inteligencia artificial para aprender los patrones de uso del usuario y decidir el momento óptimo para ejecutar tus tareas.

Existen dos tipos principales de tareas en segundo plano:

  1. BGAppRefreshTask: Diseñada para tareas cortas (generalmente de menos de 30 segundos) que mantienen la app actualizada. Ideal para descargar nuevos tuits, actualizar el clima o sincronizar mensajes pequeños.
  2. BGProcessingTask: Pensada para tareas pesadas y de mayor duración (como procesar imágenes, entrenar modelos de Machine Learning locales o hacer copias de seguridad de bases de datos). El sistema suele ejecutarlas durante la noche, especialmente cuando el dispositivo está cargándose y conectado a Wi-Fi.

Paso 1: Configuración del proyecto en Xcode

Antes de escribir una sola línea de código en Swift, debemos indicarle a iOS que nuestra aplicación tiene permiso para ejecutar tareas en segundo plano.

1. Añadir la capacidad de Background Modes

  1. Abre tu proyecto en Xcode y selecciona el Target de tu aplicación.
  2. Ve a la pestaña Signing & Capabilities.
  3. Haz clic en el botón + Capability y busca Background Modes.
  4. Marca las siguientes casillas según tus necesidades:
    • Background fetch (para refrescar contenido).
    • Background processing (para procesos pesados).

2. Registrar los identificadores en el Info.plist

iOS necesita conocer de antemano qué tareas va a ejecutar tu app.

  1. Abre tu archivo Info.plist (o la sección Info de tu Target).
  2. Añade una nueva clave llamada Permitted background task scheduler identifiers (BGTaskSchedulerPermittedIdentifiers).
  3. Esta clave es un arreglo de cadenas (Array of Strings). Añade los identificadores únicos para tus tareas. Por ejemplo:
    • com.tuempresa.tuapp.refresh
    • com.tuempresa.tuapp.processing

> Nota SEO/Dev: Utiliza la convención de dominio inverso para tus identificadores para evitar conflictos con otras aplicaciones.

Paso 2: Implementación del código en Swift

Ahora que la configuración está lista, pasemos al código. Implementar tareas en segundo plano requiere tres pasos clave: registrar, programar y ejecutar.

Registrar la tarea al iniciar la App

Las tareas deben registrarse antes de que la aplicación termine de lanzarse. El lugar ideal para hacerlo es en el AppDelegate o en el @main de SwiftUI.

import UIKit
import BackgroundTasks

@main
class AppDelegate: UIResponder, UIApplicationDelegate {

    // Identificador idéntico al del Info.plist
    let refreshTaskIdentifier = "com.tuempresa.tuapp.refresh"

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

        // 1. Registrar la tarea
        BGTaskScheduler.shared.register(forTaskWithIdentifier: refreshTaskIdentifier, using: nil) { task in
            // Esta clausura se ejecuta cuando iOS activa la tarea
            self.handleAppRefresh(task: task as! BGAppRefreshTask)
        }

        return true
    }
}

Programar la solicitud de la tarea

Le pedimos a iOS que programe la tarea para el futuro. Recuerda que la fecha que indicas es un tiempo mínimo, no una garantía exacta de ejecución.

func scheduleAppRefresh() {
    let request = BGAppRefreshTaskRequest(identifier: refreshTaskIdentifier)

    // Solicitar que se ejecute como mínimo dentro de 15 minutos
    request.earliestBeginDate = Date(timeIntervalSinceNow: 15 * 60)

    do {
        try BGTaskScheduler.shared.submit(request)
        print("Tarea programada con éxito.")
    } catch {
        print("No se pudo programar la tarea: \(error.localizedDescription)")
    }
}

Es una excelente práctica programar la siguiente tarea cada vez que la app entra en segundo plano (escuchando la notificación UIApplication.didEnterBackgroundNotification).

Manejar la ejecución de la tarea

Dentro del manejador de la tarea, debes realizar el trabajo asíncrono y, muy importante, notificar al sistema cuando la tarea termine o si se agota el tiempo asignado.

func handleAppRefresh(task: BGAppRefreshTask) {

    // 1. Programar la próxima tarea para mantener el ciclo
    scheduleAppRefresh()

    // 2. Crear una cola de operaciones o tarea asíncrona
    let queue = OperationQueue()
    queue.maxConcurrentOperationCount = 1

    let operation = BlockOperation {
        // Aquí va tu lógica: descargar datos, actualizar CoreData, etc.
        self.descargarUltimosDatos()
    }

    // 3. Manejar la expiración de la tarea (si el sistema necesita cancelar)
    task.expirationHandler = {
        queue.cancelAllOperations()
    }

    // 4. Informar al sistema cuando la operación finalice
    operation.completionBlock = {
        let success = !operation.isCancelled
        task.setTaskCompleted(success: success)
    }

    queue.addOperation(operation)
}

func descargarUltimosDatos() {
    // Tu código de red o procesamiento aquí
    print("Descargando datos en segundo plano...")
}

Paso 3: Cómo probar Background Tasks en Xcode (El truco del Simulador)

Esperar a que iOS decida ejecutar tu tarea de forma natural puede tardar horas o días. Afortunadamente, Apple nos permite forzar la ejecución de una Background Task utilizando la consola de depuración (LLDB) en Xcode.

Pasos para simular una tarea:

  1. Ejecuta tu app en el simulador de Xcode.
  2. Envía la app al segundo plano (presiona Cmd + Shift + H).
  3. Asegúrate de que la tarea haya sido programada (debe haberse ejecutado tu función submit).
  4. Pausa la ejecución de la app haciendo clic en el botón de Pause en la barra inferior de Xcode (junto a la consola).
  5. En la consola LLDB, escribe el siguiente comando (reemplazando el identificador por el tuyo):
e -l swift -- import BackgroundTasks; BGTaskScheduler.shared._simulateLaunch(forTaskWithIdentifier: "com.tuempresa.tuapp.refresh")
  1. Reanuda la ejecución de la app (botón Continue).

¡Listo! Verás cómo tu código en segundo plano se ejecuta inmediatamente en la consola.

Buenas prácticas para dominar las Background Tasks en iOS

Para asegurar que tu app no consuma recursos desmedidos y que iOS no limite la ejecución de tus tareas, sigue estas recomendaciones:

  • Llama siempre a setTaskCompleted(success:): Si no informas al sistema que la tarea terminó, iOS asumirá que tu app es ineficiente y le concederá menos tiempo en el futuro.
  • Maneja el expirationHandler: Si el sistema te pide detenerte porque se agota el tiempo o la batería es baja, limpia los procesos inmediatamente y guarda el estado actual.
  • No abuses de la frecuencia: Si estableces un earliestBeginDate muy corto, iOS ignorará tu petición y aplicará un algoritmo de aprendizaje para decidir cuándo ejecutarla.
  • Comprueba la conectividad: Si tu tarea requiere red, valida la conexión antes de realizar peticiones pesadas para no malgastar batería innecesariamente.

Conclusión

Implementar Background Tasks en Swift es una de las mejores formas de elevar la calidad de tus aplicaciones iOS. No solo mejoras significativamente la percepción de velocidad de tu app al mantener los datos siempre frescos, sino que lo haces respetando el ecosistema del dispositivo y la batería del usuario.

Siguiendo los pasos de configuración, implementación limpia y uso de las herramientas de depuración de Xcode, estarás listo para integrar procesos en segundo plano de manera profesional. ¡Empieza hoy mismo a optimizar tu aplicación y ofrece una experiencia verdaderamente fluida!

Deja una respuesta