How miguelramosalarcon/novaserviciosapp works
Tipo y propósito del proyecto (qué diagrama conviene)
Por el árbol de archivos y el README, esto es una aplicación Android nativa (Java) construida con Gradle, con UI en Activities + layouts XML, y persistencia local en SQLite (vía NovaDbHelper). El README además declara una fase de consumo de API REST (JSON), aunque en el código actual no se ve un cliente HTTP/REST; por tanto, en el diagrama conviene:
• Representar lo que existe hoy (UI + lógica + SQLite).
• Representar como bloque opcional / planificado la integración REST (HT04) si el objetivo es “arquitectura objetivo”.
Análisis estructural (cómo mapear carpetas a componentes)
Estructura relevante en app/src/main/java/com/example/novaserviciosapp:
• ui/
• MainActivity.java
• ServiceListActivity.java
• AddServiceActivity.java
=> Capa de presentación (pantallas / navegación / eventos UI).
• model/Servicio.java
=> Modelo de dominio / DTO (estructura de “Servicio”).
• data/local/NovaDbHelper.java
=> Persistencia local (SQLiteOpenHelper o equivalente): creación de tablas + CRUD.
Y en app/src/main/res/:
• layout/ (activity_main.xml, activity_service_list.xml, activity_add_service.xml) => Vistas XML.
• AndroidManifest.xml => definición de Activities, permisos, configuración app.
Tests:
• src/test unit tests (JVM)
• src/androidTest instrumented tests (device/emulator)
Build/packaging:
• build.gradle.kts (root + app)
• proguard-rules.pro (shrink/obfuscation)
• gradle/libs.versions.toml (version catalog)
Qué diagramas dibujar (para “best and most accurate”)
Para una app Android pequeña/mediana, lo más claro y exacto es dibujar 3 niveles (tipo C4 adaptado a móvil):
Diagrama de Contexto (Sistema en su entorno)
Objetivo: mostrar “quién usa la app” y “con qué se integra”.
Elementos mínimos:
• Usuario (Cliente/Operario) usando
• Nova Servicios App (Android) ejecutándose en
• Dispositivo Android / Android OS
• SQLite (local, on-device) como almacenamiento
• API REST (externa, opcional/HT04) como integración futura (marcar como “planned” si no existe aún)
Relaciones (flechas):
• Usuario → App (interacción UI)
• App ↔ SQLite (CRUD local)
• App ↔ API REST (HTTP/JSON) *(si decides incluirlo, diferéncialo como no implementado aún)*
Diagrama de Contenedores / Sub-sistemas (dentro de la app)
Objetivo: separar claramente UI, dominio y datos.
Contenedores recomendados (bloques):
UI Layer (Activities + XML Layouts)
• MainActivity + activity_main.xml
• ServiceListActivity + activity_service_list.xml
• AddServiceActivity + activity_add_service.xml
Domain/Model
• Servicio
Data Layer
• NovaDbHelper (local DB gateway)
• (Opcional futuro) RemoteApiClient / Repository (si HT04 se implementa)
Local Storage
• SQLite Database (tablas de servicios)
Flechas (dirección de dependencias):
• Activities → NovaDbHelper (llamadas CRUD)
• NovaDbHelper ↔ SQLite DB (SQL queries)
• Activities ↔ Servicio (creación/consumo de objetos del modelo)
Nota importante de precisión: en este repo no aparece un patrón MVVM/MVP con ViewModel/Repository; por tanto, si hoy las Activities llaman directo al DB helper, el diagrama debe reflejarlo (aunque arquitectónicamente “ideal” sería interponer repositorios).
Diagrama de Componentes (nivel clase/paquete, “as many components as possible”)
Objetivo: detallar componentes internos sin inventar capas.
Componentes concretos (directamente del árbol):
• com.example.novaserviciosapp.ui
• MainActivity (menú/landing)
• ServiceListActivity (consulta/listado)
• AddServiceActivity (registro/alta)
• com.example.novaserviciosapp.data.local
• NovaDbHelper (schema + CRUD)
• com.example.novaserviciosapp.model
• Servicio
Relaciones típicas a dibujar:
• AddServiceActivity → NovaDbHelper.insertServicio(...) → SQLite
• ServiceListActivity → NovaDbHelper.getServicios(...) → SQLite → devuelve List<Servicio>
• MainActivity → navegación (Intents) → AddServiceActivity / ServiceListActivity
Aquí conviene un sub-diagrama de navegación (pantallas) porque es parte esencial de apps Android:
• MainActivity --(Intent)--> AddServiceActivity
• MainActivity --(Intent)--> ServiceListActivity
• (Opcional) ServiceListActivity --(Back/Up)--> MainActivity
Interacciones clave (qué “flows” dibujar como secuencia)
Incluye 2 diagramas de secuencia simples (muy útiles para exactitud):
Mapea filas a Servicio
5. UI renderiza (ListView/RecyclerView) *(en README se menciona, en el árbol no se ve el adapter; si no existe, no lo inventes: pon “UI List Component” genérico)*
Si vas a incluir REST (arquitectura objetivo HT04), agrega un Flow 3 “Sincronizar”:
• ServiceListActivity/“Sync use case” → HTTP Client → API REST → JSON → parse → persist en SQLite → render.
Tecnologías y artefactos que deben verse en el diagrama
Etiquetas recomendadas en los bloques:
• Android App (Java), Activities, Intents
• SQLite (on-device), NovaDbHelper
• XML Layouts (res/layout)
• Gradle build (opcional en diagrama de build/deploy)
• AndroidManifest (opcional como “configuración runtime”)
Y si incluyes lo futuro:
• REST API (JSON), HTTP client (biblioteca a definir)
Checklist final de “exactitud” contra este repo
• [ ] ¿Todas las Activities del paquete ui/ están en el diagrama?
• [ ] ¿Servicio aparece como modelo central?
• [ ] ¿NovaDbHelper aparece como único acceso a SQLite?
• [ ] ¿Se ve SQLite como almacenamiento local (en el dispositivo)?
• [ ] ¿Navegación por Intents entre pantallas está dibujada?
• [ ] Si se muestra REST API: ¿está marcado como fase HT04 / futuro si no hay implementación?
• [ ] Recursos XML (layouts/themes) aparecen al menos como parte de UI (sin entrar a cada drawable salvo que sea relevante).
Secuencias: “Registrar” y “Listar” (y “Sync” si aplica)
Con esto obtienes un diagrama que es a la vez fiel al árbol actual y lo bastante detallado como para comunicar arquitectura y evolución por fases (HT01–HT05).