Arquitectura General del Proyecto PAE

PAE utiliza una arquitectura multicapa basada en módulos independientes que comunican a través de contratos claramente definidos. El proyecto sigue patrones de clean architecture con separación de responsabilidades entre presentación, dominio y datos.

PAE (root)
├── Machine (app)               # Aplicación Android de máquina
├── RutaPAE (app)               # Aplicación Android de operador
│
├── MachineDomain               # Lógica de dominio de máquina
├── MachineData                 # Acceso a datos de máquina
│
├── RutaPAEDomain               # Lógica de dominio de ruta
├── RutaPAEData                 # Acceso a datos de ruta
│
├── Contract                    # Contrato P2P compartido
├── Core                        # Utilidades compartidas
├── DirectLink                  # Implementación P2P
│
├── ComputerVision              # Modelos de visión por computadora
├── VectorialDB                 # Motor de base de datos vectorial
└── gradle/                     # Configuración de dependencias

         ┌─────────────────────────────┐
         │   Capa de Presentación      │
         │   (Machine app)             │
         │   - UI Compose              │
         │   - ViewModels              │
         └──────────────┬──────────────┘
                        │
         ┌──────────────▼──────────────┐
         │   Capa de Dominio           │
         │   (MachineDomain)           │
         │   - StateManager            │
         │   - Estado de entregas      │
         │   - SyncDeliveries          │
         │   - P2PManager              │
         └──────────────┬──────────────┘
                        │
         ┌──────────────▼──────────────┐
         │   Capa de Datos             │
         │   (MachineData)             │
         │   - Delivery                │
         │   - Beneficiary             │
         │   - MachineEnrollmentShift  │
         │   - MinutaMenuDue           │
         │   - OperationalShift        │
         │   - Repository              │
         └─────────────────────────────┘
                        │
                    SQLite DB

         ┌─────────────────────────────┐
         │   Capa de Presentación      │
         │   (RutaPAE app)             │
         │   - UI Compose              │
         │   - Screens                 │
         │   - Components              │
         └──────────────┬──────────────┘
                        │
         ┌──────────────▼──────────────┐
         │   Capa de Dominio           │
         │   (RutaPAEDomain)           │
         │   - P2PManager              │
         │   - SyncDeliveries          │
         │   - Descubrimiento          │
         └──────────────┬──────────────┘
                        │
         ┌──────────────▼──────────────┐
         │   Capa de Datos             │
         │   (RutaPAEData)             │
         │   - Machine                 │
         │   - Delivery                │
         │   - Services                │
         └─────────────────────────────┘
                        │
                    SQLite DB

1. UI → usuario solicita captura
2. Data → se resuelve la jornada operativa visible del día con fallback a MachineEnrollmentShift cuando falta MinutaMenuDue para una modalidad válida
3. Domain → StateManager ejecuta WaitingForWeight
4. Data → Beneficiary consulta base de datos
5. Domain → GenerateEmbedding crea vector 512d
6. Data → Delivery se guarda en base de datos

1. UI → usuario selecciona máquina y solicita sincronización
2. Domain → P2PManager conecta vía P2P
3. Domain → syncDeliveriesFromMachine descarga entregas
4. Data → Delivery se almacena localmente
5. UI → muestra progreso y resultado

• Renderizar UI con Jetpack Compose
• Capturar interacciones del usuario
• Mostrar la card de sincronización con el mismo conteo de jornadas visibles que la lista operativa
• Mostrar estados vía ViewModels y StateFlow
• No contiene lógica de negocio

• Implementar casos de uso
• Orquestar flujos complejos
• Coordinar entre Data y Presentación
• Manejar errores y reintentos

• Acceso a repositorios locales
• Operaciones CRUD
• Caché y persistencia
• Mapeo de entidades
• Proyecciones operativas para UI cuando la entidad técnica no coincide con la entidad visible del negocio

• Contract: todos los módulos usan modelos P2P
• Core: interfaz para logging y utilidades

• StateNameEmitter: cambios de estado
• DeliverySyncUiEmitter: progreso de sincronización
• SyncRunningEmitter: estado global de sincronización

• Dagger2 / Hilt (Machine)
• Inyección manual (RutaPAE Domain)

• StateManager: máquina de estados para entregas (Machine)
• StateFlow: estado reactivo (Kotlin Coroutines)

• MachineService: acceso a Machine local
• DeliveryService: acceso a Delivery local
• Abstraen acceso a datos

• Emisores: para distribución de eventos
• Flow: para observar cambios

• Creación de estados en StateManager
• Creación de P2PManager en DomainManager

Machine                RutaPAE
  ├── MachineDomain      ├── RutaPAEDomain
  ├── MachineData        ├── RutaPAEData
  ├── Contract           ├── Contract
  └── Core               └── Core

MachineDomain
  ├── MachineData
  ├── Contract
  ├── DirectLink
  └── Core

RutaPAEDomain
  ├── RutaPAEData
  ├── Contract
  ├── DirectLink
  └── Core

MachineData / RutaPAEData
  ├── VectorialDB
  ├── Contract
  └── Core

DirectLink
  └── Contract

VectorialDB
  └── (sin dependencias PAE)

ComputerVision
  └── (sin dependencias PAE)

• API mínima: 24 (Android 7.0)
• API objetivo: 36 (Android 15)
• JVM target: 17
• Lenguaje: Kotlin

• Jetpack Compose: UI declarativa
• Coroutines: asincronía
• Dagger2/Hilt: inyección de dependencias (Machine)
• Fuel: cliente HTTP
• Kotlinx Serialization: serialización JSON
• Camera2 API: captura de imágenes
• WorkManager: tareas en segundo plano

• Paquetes: co.ada.<modulo>.xxx.xxx
• Servicios: *Service (e.g., MachineService)
• Managers: *Manager (e.g., StateManager)
• Emisores: *Emitter (e.g., DeliveryEmitter)
• Estados: *State (e.g., P2PMachineStatus)
• Data classes: nombres directos (e.g., Delivery, Machine)