Sincronización en Segundo Plano y TaskManager

npx expo install expo-background-task expo-task-manager

// src/background/syncTask.ts - importa este archivo en la entrada de la aplicación (scope global)
import * as BackgroundTask from "expo-background-task";
import * as TaskManager from "expo-task-manager";
 
export const SYNC_TASK = "offline-sync-worker";
 
TaskManager.defineTask(SYNC_TASK, async () => {
  try {
    // Abre BD, vacía bandeja de salida, sube archivos - mantén el trabajo corto
    console.log("[sync] background worker ran");
    return BackgroundTask.BackgroundTaskResult.Success;
  } catch (error) {
    console.error("[sync] background worker failed", error);
    return BackgroundTask.BackgroundTaskResult.Failed;
  }
});

// src/background/registerSyncTask.ts
import * as BackgroundTask from "expo-background-task";
import * as TaskManager from "expo-task-manager";
import { SYNC_TASK } from "./syncTask";
 
export async function registerSyncTask() {
  const status = await BackgroundTask.getStatusAsync();
  if (status === BackgroundTask.BackgroundTaskStatus.Restricted) return;
 
  const registered = await TaskManager.isTaskRegisteredAsync(SYNC_TASK);
  if (!registered) {
    await BackgroundTask.registerTaskAsync(SYNC_TASK, {
      minimumInterval: 15, // minutos - el SO puede retrasar más
    });
  }
}

// index.ts o app/_layout.tsx - importación de efecto secundario en la parte superior
import "@/background/syncTask";

npx expo install expo-background-task expo-task-manager expo-sqlite

// src/background/syncTask.ts
import * as BackgroundTask from "expo-background-task";
import * as TaskManager from "expo-task-manager";
import * as SQLite from "expo-sqlite";
import { flushWorkOrders } from "@/sync/flushOutbox";
 
export const SYNC_TASK = "offline-sync-worker";
 
TaskManager.defineTask(SYNC_TASK, async () => {
  try {
    const db = await SQLite.openDatabaseAsync("field.db");
    // flushWorkOrders sin QueryClient - el segundo plano no tiene árbol React
    await flushWorkOrders(db, null);
    return BackgroundTask.BackgroundTaskResult.Success;
  } catch (error) {
    console.error("[sync] failed", error);
    return BackgroundTask.BackgroundTaskResult.Failed;
  }
});

// src/sync/flushOutbox.ts (extracto) - tolera queryClient nulo en segundo plano
export async function flushWorkOrders(
  db: SQLiteDatabase,
  queryClient: QueryClient | null
) {
  // ... envía filas pendientes ...
  if (queryClient) {
    await queryClient.invalidateQueries({ queryKey: ["work-orders"] });
  }
}

// app/_layout.tsx
import "@/background/syncTask"; // efecto secundario global defineTask
 
import { Stack } from "expo-router";
import { useEffect } from "react";
import * as BackgroundTask from "expo-background-task";
import { registerSyncTask } from "@/background/registerSyncTask";
import { setupMobileQuery } from "@/lib/setupMobileQuery";
 
export default function RootLayout() {
  useEffect(() => {
    setupMobileQuery();
    registerSyncTask();
  }, []);
 
  return <Stack />;
}

// src/dev/TriggerBackgroundSync.tsx - solo desarrollo
import * as BackgroundTask from "expo-background-task";
import { Button } from "react-native";
 
export function TriggerBackgroundSync() {
  if (!__DEV__) return null;
 
  return (
    <Button
      title="Prueba sincronización en segundo plano"
      onPress={() => BackgroundTask.triggerTaskWorkerForTestingAsync()}
    />
  );
}

// app.config.ts (extracto) - CNG aplica automáticamente las claves de iOS BGTaskScheduler
export default {
  expo: {
    name: "FieldApp",
    plugins: [
      "expo-router",
      // el plugin de configuración de expo-background-task aplica UIBackgroundModes + BGTaskSchedulerPermittedIdentifiers
    ],
  },
};

src/background/syncTask.ts   - defineTask aquí
app/_layout.tsx              - importa "@/background/syncTask" como primer efecto secundario

adb shell dumpsys jobscheduler | grep -A 40 -m 1 -E "JOB #.* "

BackgroundTask.addExpirationListener(() => {
  // Persiste progreso parcial; retorna rápidamente desde defineTask
});

TaskManager.defineTask(UPLOAD_TASK, async () => {
  const pending = await listPendingUploads(); // SQLite: uploaded = 0
  for (const file of pending) {
    await uploadChunked(file); // lotes cortos
  }
  return BackgroundTask.BackgroundTaskResult.Success;
});

Pila de sincronización recomendada:
 
1. UI optimista + bandeja de salida en acción del usuario (primer plano)
2. NetInfo reconecta - vacío inmediato (primer plano)
3. BackgroundTask - vacía el resto cuando la aplicación se pone en segundo plano
4. "Sincronizar ahora" manual para supervisores de campo