diff --git a/CHANGELOG.md b/CHANGELOG.md index ce47257..d9380ea 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,21 @@ Todas as alterações notáveis neste projeto serão documentadas neste arquivo. O formato é baseado em [Keep a Changelog](https://keepachangelog.com/pt-BR/1.0.0/), e este projeto adere ao [Semantic Versioning](https://semver.org/lang/pt-BR/). +## [1.3.0] - 2026-08-07 + +### Adicionado +- **Sincronização Automática Periódica em Segundo Plano**: + - Implementado loop contínuo no `MaintenanceViewModel` (`viewModelScope`) com intervalo fixo de **5 minutos** (300.000 ms). + - Execução global ativa em **qualquer tela do aplicativo** (`Informações`, `Dashboard`, `Ordens` e `Configurações`) através do compartilhamento do ViewModel no escopo da `MainActivity`. +- **Card Informativo na Tela de Configurações (`AutoSyncStatusCard`)**: + - Adicionado componente visual na Tela de Configurações exibindo o período/frequência de tentativa de sincronização automática (*"A cada 5 minutos"*), a abrangência (*"Ativa em qualquer tela"*), o status da rede/sincronização e o timestamp exato da última sincronização realizada na sessão. +- **Registro Detalhado no Histórico de Logs (`AppLogger` / `app_logs`)**: + - Gravadas todas as tentativas de sincronização automática e manual no banco de dados local com tags `AutoSync` e `SyncManager` nos níveis de severidade `INFO` (início e sucesso com total de itens e conflitos), `WARN` (cancelado por falta de rede ou app bloqueado) e `ERROR` (falhas e exceções). + - Os logs ficam imediatamente disponíveis para auditoria no modal **Histórico de Logs** na tela de Configurações. + +### Alterado +- **Versão do Aplicativo**: Incrementada a versão para `1.3.0` (com `versionCode = 4`). + --- ## [1.2.0] - 2026-08-07 diff --git a/README.md b/README.md index d20a22e..e03f7f8 100644 --- a/README.md +++ b/README.md @@ -16,7 +16,7 @@ Aplicativo Android **offline-first** desenvolvido em Kotlin e Jetpack Compose pa - Carregamento e download de fotos **sob demanda** (On-Demand Loading) para múltiplos celulares sem erros HTTP 403. - **[Changelog / Histórico de Versões](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/CHANGELOG.md)**: - - Registro de alterações por versão (Versão Atual: **`1.2.0`** - `versionCode 3`). + - Registro de alterações por versão (Versão Atual: **`1.3.0`** - `versionCode 4`). - **[Arquitetura do Sistema](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/documentacao/arquitetura/arquitetura_do_sistema.md)**: - Diagramas de arquitetura MVVM + Repository Pattern. diff --git a/app/build.gradle.kts b/app/build.gradle.kts index 0b2ab75..8c9dc3c 100644 --- a/app/build.gradle.kts +++ b/app/build.gradle.kts @@ -17,8 +17,8 @@ android { applicationId = "com.aistudio.gestaoparadaos.xvyzwt" minSdk = 24 targetSdk = 36 - versionCode = 3 - versionName = "1.2.0" + versionCode = 4 + versionName = "1.3.0" testInstrumentationRunner = "androidx.test.runner.AndroidJUnitRunner" } diff --git a/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt b/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt index d73e1e0..50e5416 100644 --- a/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt +++ b/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt @@ -39,6 +39,15 @@ class MaintenanceRepository( appLogDao.clearAllLogs() } + fun logAppLog(level: String, tag: String, message: String, throwable: Throwable? = null) { + val logger = com.example.util.AppLogger.getInstance(context) + when (level.uppercase()) { + "ERROR" -> logger.logError(tag, message, throwable) + "WARN" -> logger.logWarning(tag, message) + else -> logger.logInfo(tag, message) + } + } + val isNetworkConnected: Flow = networkMonitor.isConnected fun isCurrentlyConnected(): Boolean = networkMonitor.isCurrentlyConnected() diff --git a/app/src/main/java/com/example/ui/screens/SettingsScreen.kt b/app/src/main/java/com/example/ui/screens/SettingsScreen.kt index ccf7592..37c024a 100644 --- a/app/src/main/java/com/example/ui/screens/SettingsScreen.kt +++ b/app/src/main/java/com/example/ui/screens/SettingsScreen.kt @@ -67,6 +67,9 @@ fun SettingsScreen( val appLogs by viewModel.appLogsState.collectAsStateWithLifecycle() val userAccessLevel by viewModel.userAccessLevel.collectAsStateWithLifecycle() val simulationConfig by viewModel.simulationConfig.collectAsStateWithLifecycle() + val isNetworkConnected by viewModel.isNetworkConnected.collectAsStateWithLifecycle(initialValue = true) + val autoSyncIntervalMinutes by viewModel.autoSyncIntervalMinutes.collectAsStateWithLifecycle() + val lastSyncTimestamp by viewModel.lastSyncTimestamp.collectAsStateWithLifecycle() val hasTotalAccess = remember(userAccessLevel) { userAccessLevel?.trim()?.equals("total", ignoreCase = true) == true @@ -152,6 +155,14 @@ fun SettingsScreen( verticalArrangement = Arrangement.spacedBy(20.dp) ) { + // Seção: Status da Sincronização Automática + AutoSyncStatusCard( + autoSyncIntervalMinutes = autoSyncIntervalMinutes, + isNetworkConnected = isNetworkConnected, + isSyncing = isSyncing, + lastSyncTimestamp = lastSyncTimestamp + ) + // Seção: Painel do Administrador Column { Text( @@ -1028,4 +1039,142 @@ fun AppLogsHistoryDialog( } } +@Composable +fun AutoSyncStatusCard( + autoSyncIntervalMinutes: Int, + isNetworkConnected: Boolean, + isSyncing: Boolean, + lastSyncTimestamp: Long? +) { + val dateFormatter = remember { SimpleDateFormat("HH:mm:ss - dd/MM/yyyy", Locale.getDefault()) } + val lastSyncFormatted = remember(lastSyncTimestamp) { + if (lastSyncTimestamp != null && lastSyncTimestamp > 0) { + dateFormatter.format(Date(lastSyncTimestamp)) + } else { + "Nenhuma sincronização nesta sessão" + } + } + + Card( + colors = CardDefaults.cardColors(containerColor = Color.White), + elevation = CardDefaults.cardElevation(defaultElevation = 2.dp), + shape = RoundedCornerShape(12.dp), + modifier = Modifier.fillMaxWidth() + ) { + Column( + modifier = Modifier.padding(16.dp), + verticalArrangement = Arrangement.spacedBy(10.dp) + ) { + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(10.dp) + ) { + Icon( + imageVector = Icons.Default.Sync, + contentDescription = null, + tint = BrandGreen, + modifier = Modifier.size(24.dp) + ) + Text( + text = "Sincronização Automática em Background", + fontSize = 16.sp, + fontWeight = FontWeight.Bold, + color = BrandBlack + ) + } + + HorizontalDivider(color = LightGrey) + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = "Frequência / Período:", + fontSize = 13.sp, + color = Color.Gray + ) + Surface( + color = BrandLightGreen, + shape = RoundedCornerShape(16.dp) + ) { + Text( + text = "A cada $autoSyncIntervalMinutes minutos", + fontSize = 12.sp, + fontWeight = FontWeight.Bold, + color = BrandGreen, + modifier = Modifier.padding(horizontal = 10.dp, vertical = 4.dp) + ) + } + } + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = "Abrangência:", + fontSize = 13.sp, + color = Color.Gray + ) + Text( + text = "Ativa em qualquer tela", + fontSize = 13.sp, + fontWeight = FontWeight.Medium, + color = BrandBlack + ) + } + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = "Status da Conexão:", + fontSize = 13.sp, + color = Color.Gray + ) + Row( + verticalAlignment = Alignment.CenterVertically, + horizontalArrangement = Arrangement.spacedBy(6.dp) + ) { + Box( + modifier = Modifier + .size(8.dp) + .clip(androidx.compose.foundation.shape.CircleShape) + .background(if (isNetworkConnected) BrandGreen else Color.Red) + ) + Text( + text = if (isSyncing) "Sincronizando..." else if (isNetworkConnected) "Conectado ao BD Online" else "Modo Offline", + fontSize = 13.sp, + fontWeight = FontWeight.SemiBold, + color = if (isSyncing) Color(0xFFFF9100) else if (isNetworkConnected) BrandGreen else Color.Red + ) + } + } + + Row( + modifier = Modifier.fillMaxWidth(), + horizontalArrangement = Arrangement.SpaceBetween, + verticalAlignment = Alignment.CenterVertically + ) { + Text( + text = "Última Sincronização:", + fontSize = 13.sp, + color = Color.Gray + ) + Text( + text = lastSyncFormatted, + fontSize = 12.sp, + fontWeight = FontWeight.Medium, + color = BrandBlack + ) + } + } + } +} + diff --git a/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt b/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt index 9ac9b59..7d55a52 100644 --- a/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt +++ b/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt @@ -170,6 +170,15 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View private val _syncStatusMessage = MutableStateFlow(null) val syncStatusMessage = _syncStatusMessage.asStateFlow() + // Auto-Sync Background Loop & Last Sync State + private val _autoSyncIntervalMinutes = MutableStateFlow(AUTO_SYNC_INTERVAL_MINUTES) + val autoSyncIntervalMinutes = _autoSyncIntervalMinutes.asStateFlow() + + private val _lastSyncTimestamp = MutableStateFlow(null) + val lastSyncTimestamp = _lastSyncTimestamp.asStateFlow() + + private var autoSyncJob: kotlinx.coroutines.Job? = null + val appSecurityState: StateFlow = repository.appSecurityState.stateIn( scope = viewModelScope, started = SharingStarted.WhileSubscribed(5000), @@ -479,6 +488,9 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View isFirstEmission = false } } + + // Start periodic auto-sync background loop (every 5 minutes) + startAutoSyncLoop() } fun selectActivity(activity: MaintenanceActivity?) { @@ -572,25 +584,91 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View val currentSecurity = appSecurityState.value if (currentSecurity !is AppSecurityState.Allowed) { checkSecurityConfigNow() + repository.logAppLog("WARN", "SyncManager", "Sincronização manual impedida: aplicativo bloqueado por regras de segurança.") return } if (!_internetAvailable.value) { _syncStatusMessage.value = "Sincronização impossível: Sem conectividade de rede na área atual." + repository.logAppLog("WARN", "SyncManager", "Sincronização manual impedida: sem conexão com a internet.") return } if (_isSyncing.value) { + repository.logAppLog("WARN", "SyncManager", "Tentativa de sincronização ignorada: já existe uma sincronização em andamento.") return } viewModelScope.launch { _isSyncing.value = true _syncStatusMessage.value = "Conectando ao servidor central..." + repository.logAppLog("INFO", "SyncManager", "Iniciando sincronização manual de dados...") + try { + when (val result = repository.synchronizeWithBackend()) { + is SyncResult.Success -> { + _lastSyncTimestamp.value = System.currentTimeMillis() + _syncStatusMessage.value = "Sincronização concluída! ${result.syncedItems} OSs sincronizadas com sucesso. Conflitos resolvidos: ${result.conflictsResolved}." + repository.logAppLog("INFO", "SyncManager", "Sincronização concluída com sucesso! ${result.syncedItems} itens sincronizados. Conflitos resolvidos: ${result.conflictsResolved}.") + // Refresh selected activity if active to show sync badge + _selectedActivity.value?.let { active -> + _selectedActivity.value = allActivitiesState.value.find { it.numeroOs == active.numeroOs } + } + _currentUser.value?.let { user -> + checkUserAccessLevel(user.email) + } + } + is SyncResult.Error -> { + _syncStatusMessage.value = "Falha na sincronização: ${result.message}" + repository.logAppLog("ERROR", "SyncManager", "Falha na sincronização: ${result.message}") + } + } + } catch (e: Exception) { + _syncStatusMessage.value = "Erro na sincronização: ${e.message}" + repository.logAppLog("ERROR", "SyncManager", "Exceção na sincronização: ${e.message}", e) + } finally { + _isSyncing.value = false + } + } + } + + private fun startAutoSyncLoop() { + autoSyncJob?.cancel() + autoSyncJob = viewModelScope.launch { + while (true) { + kotlinx.coroutines.delay(AUTO_SYNC_INTERVAL_MS) + performAutoSyncAttempt() + } + } + } + + private suspend fun performAutoSyncAttempt() { + val currentSecurity = appSecurityState.value + if (currentSecurity !is AppSecurityState.Allowed) { + repository.logAppLog("WARN", "AutoSync", "Tentativa de sincronização automática ignorada: aplicativo bloqueado por segurança.") + return + } + + if (!_internetAvailable.value) { + repository.logAppLog("WARN", "AutoSync", "Tentativa de sincronização automática ignorada: sem conectividade de rede no momento.") + return + } + + if (_isSyncing.value) { + repository.logAppLog("WARN", "AutoSync", "Tentativa de sincronização automática ignorada: outra sincronização já está em andamento.") + return + } + + repository.logAppLog("INFO", "AutoSync", "Iniciando tentativa de sincronização automática em segundo plano (intervalo: $AUTO_SYNC_INTERVAL_MINUTES min)...") + + _isSyncing.value = true + _syncStatusMessage.value = "Sincronizando em segundo plano (automático)..." + + try { when (val result = repository.synchronizeWithBackend()) { is SyncResult.Success -> { - _syncStatusMessage.value = "Sincronização concluída! ${result.syncedItems} OSs sincronizadas com sucesso. Conflitos resolvidos: ${result.conflictsResolved}." - // Refresh selected activity if active to show sync badge + _lastSyncTimestamp.value = System.currentTimeMillis() + _syncStatusMessage.value = "Sincronização automática concluída com sucesso! (${result.syncedItems} itens)" + repository.logAppLog("INFO", "AutoSync", "Sincronização automática concluída com sucesso! ${result.syncedItems} OSs sincronizadas. Conflitos resolvidos: ${result.conflictsResolved}.") _selectedActivity.value?.let { active -> _selectedActivity.value = allActivitiesState.value.find { it.numeroOs == active.numeroOs } } @@ -599,9 +677,13 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View } } is SyncResult.Error -> { - _syncStatusMessage.value = "Falha na sincronização: ${result.message}" + _syncStatusMessage.value = "Falha na sincronização automática: ${result.message}" + repository.logAppLog("ERROR", "AutoSync", "Falha na sincronização automática: ${result.message}") } } + } catch (e: Exception) { + repository.logAppLog("ERROR", "AutoSync", "Exceção na sincronização automática: ${e.message}", e) + } finally { _isSyncing.value = false } } @@ -885,6 +967,9 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View ): AnalyticsState = Companion.calculateAnalyticsState(activities, history, referenceDateOverride, selectedSetorSCurve) companion object { + private const val AUTO_SYNC_INTERVAL_MINUTES = 5 + private const val AUTO_SYNC_INTERVAL_MS = AUTO_SYNC_INTERVAL_MINUTES * 60 * 1000L + fun calculateAnalyticsState( activities: List, history: List, diff --git a/app/src/main/java/com/example/util/DeviceUtils.kt b/app/src/main/java/com/example/util/DeviceUtils.kt index 5a984d5..163aae3 100644 --- a/app/src/main/java/com/example/util/DeviceUtils.kt +++ b/app/src/main/java/com/example/util/DeviceUtils.kt @@ -46,7 +46,7 @@ object DeviceUtils { fun getAppVersion(context: Context): String { return try { val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0) - val versionName = packageInfo.versionName ?: "1.2.0" + val versionName = packageInfo.versionName ?: "1.3.0" @Suppress("DEPRECATION") val versionCode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { packageInfo.longVersionCode @@ -55,7 +55,7 @@ object DeviceUtils { } "$versionName (v$versionCode)" } catch (e: Exception) { - "1.2.0" + "1.3.0" } } } diff --git a/documentacao/fluxo_de_dados_e_sincronizacao.md b/documentacao/fluxo_de_dados_e_sincronizacao.md index 243ba5e..8bed3fb 100644 --- a/documentacao/fluxo_de_dados_e_sincronizacao.md +++ b/documentacao/fluxo_de_dados_e_sincronizacao.md @@ -212,6 +212,15 @@ O aplicativo sincroniza com quatro abas da planilha central: - Executa **Upsert**: localiza a linha do dispositivo através do `device_id` (`Settings.Secure.ANDROID_ID` ou UUID). Se já existir, atualiza os dados e o timestamp do último acesso; se for um aparelho novo, cria uma nova linha na planilha. - Permite auditoria em tempo real de quantos e quais celulares acessaram o app online e qual conta do Google Sign-In foi utilizada. +### 4.3. Loop de Sincronização Automática Periódica e Registros em Logs (`MaintenanceViewModel.kt`) +- **Frequência e Abrangência**: O aplicativo mantém um loop de sincronização automática em plano de fundo executado a cada **5 minutos** (300.000 ms). Por estar vinculado ao `MaintenanceViewModel` instanciado na `MainActivity`, ele é executado continuamente em **qualquer tela** do app (`Informações`, `Dashboard`, `Ordens` e `Configurações`). +- **Auditoria no Histórico de Logs (`app_logs`)**: Todas as tentativas de sincronização (automáticas e manuais) registram eventos no banco de dados local Room (`app_logs`) através do `AppLogger`: + - **`INFO` (Início)**: Registra o disparo da tentativa (`AutoSync` / `SyncManager`). + - **`INFO` (Sucesso)**: Registra a conclusão bem-sucedida, contagem de itens sincronizados e conflitos resolvidos. + - **`WARN` (Alerta/Ignorado)**: Registra quando a sincronização é pulada por falta de conectividade à internet ou por trava de segurança ativa (`AppSecurityLockDialog`). + - **`ERROR` (Falha)**: Registra erros capturados durante a transmissão com stack trace associado. +- **Visualização na Interface**: O card `AutoSyncStatusCard` na tela de Configurações exibe a frequência (*"A cada 5 minutos"*), a abrangência (*"Ativa em qualquer tela"*), o status da conexão e o horário formatado da última sincronização bem-sucedida. + --- ## 5. Download e Exibição de Fotos Sob Demanda (On-Demand Loading)