From 77591862343523df1ac5fa507e1b5deed66cb3b9 Mon Sep 17 00:00:00 2001 From: Jhony Cesar Date: Thu, 6 Aug 2026 12:25:26 -0400 Subject: [PATCH] feat: add device access logging to Google Sheets with device identification utilities --- README.md | 3 +- .../example/data/model/DeviceAccessInfo.kt | 15 ++++ .../data/remote/GoogleSheetsSyncService.kt | 82 +++++++++++++++++++ .../data/repository/MaintenanceRepository.kt | 42 ++++++++++ .../main/java/com/example/util/DeviceUtils.kt | 61 ++++++++++++++ .../java/com/example/util/DeviceUtilsTest.kt | 70 ++++++++++++++++ .../arquitetura/arquitetura_do_sistema.md | 6 +- .../fluxo_de_dados_e_sincronizacao.md | 15 ++-- 8 files changed, 287 insertions(+), 7 deletions(-) create mode 100644 app/src/main/java/com/example/data/model/DeviceAccessInfo.kt create mode 100644 app/src/main/java/com/example/util/DeviceUtils.kt create mode 100644 app/src/test/java/com/example/util/DeviceUtilsTest.kt diff --git a/README.md b/README.md index 40f55a0..f0c0538 100644 --- a/README.md +++ b/README.md @@ -10,7 +10,8 @@ Aplicativo Android **offline-first** desenvolvido em Kotlin e Jetpack Compose pa - Estrutura completa das 6 tabelas do banco de dados local Room (`maintenance_activities`, `os_findings`, `os_update_history`, `app_logs`, `sync_conflict_logs`, `user_access`). - Fluxo detalhado de salvamento de progresso e achados com tipo exclusivo `FOTO`. - Processo de compactação (<= 500KB) e upload para Firebase Storage. - - Sincronização bidirecional com Google Sheets (abas `project`, `history` e `achados`). + - Sincronização bidirecional com Google Sheets (abas `project`, `history`, `achados` e `usage_history`). + - Rastreamento em tempo real do último acesso por dispositivo, e-mail de Google Sign-In e versão do sistema na aba `usage_history`. - Carregamento e download de fotos **sob demanda** (On-Demand Loading) para múltiplos celulares sem erros HTTP 403. - **[Arquitetura do Sistema](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/documentacao/arquitetura/arquitetura_do_sistema.md)**: diff --git a/app/src/main/java/com/example/data/model/DeviceAccessInfo.kt b/app/src/main/java/com/example/data/model/DeviceAccessInfo.kt new file mode 100644 index 0000000..53ca95d --- /dev/null +++ b/app/src/main/java/com/example/data/model/DeviceAccessInfo.kt @@ -0,0 +1,15 @@ +package com.example.data.model + +import com.squareup.moshi.JsonClass + +@JsonClass(generateAdapter = true) +data class DeviceAccessInfo( + val deviceId: String, + val dispositivo: String, + val email: String, + val nomeUsuario: String, + val versaoAndroid: String, + val versaoApp: String, + val ultimoAcesso: String, + val statusSincronizacao: String = "Sucesso" +) diff --git a/app/src/main/java/com/example/data/remote/GoogleSheetsSyncService.kt b/app/src/main/java/com/example/data/remote/GoogleSheetsSyncService.kt index c5bbdda..6c0790b 100644 --- a/app/src/main/java/com/example/data/remote/GoogleSheetsSyncService.kt +++ b/app/src/main/java/com/example/data/remote/GoogleSheetsSyncService.kt @@ -2,6 +2,7 @@ package com.example.data.remote import android.content.Context import android.util.Log +import com.example.data.model.DeviceAccessInfo import com.example.data.model.MaintenanceActivity import com.example.data.model.OSUpdateHistory import com.example.data.model.UserAccess @@ -994,5 +995,86 @@ class GoogleSheetsSyncService( .distinct() .joinToString("|") } + + /** + * Updates or appends the device last access record in the 'usage_history' sheet. + */ + fun updateUsageHistory(info: DeviceAccessInfo) { + val sheetName = "usage_history" + val defaultHeaders = listOf( + "device_id", "dispositivo", "email", "nome_usuario", "versao_android", "versao_app", "ultimo_acesso", "status_sincronizacao" + ) + ensureHeaders(sheetName, defaultHeaders) + + val rows = fetchValues("$sheetName!A:H") + if (rows.isEmpty()) { + val newRow = listOf( + info.deviceId, + info.dispositivo, + info.email, + info.nomeUsuario, + info.versaoAndroid, + info.versaoApp, + info.ultimoAcesso, + info.statusSincronizacao + ) + appendValues("$sheetName!A:H", listOf(newRow)) + Log.d(tag, "Successfully appended initial device access record for device_id: ${info.deviceId}") + return + } + + val headers = rows[0].map { it.trim().lowercase() } + val deviceIdIdx = headers.indexOfFirst { it == "device_id" || it == "deviceid" || it.contains("device") } + .let { if (it != -1) it else 0 } + val dispositivoIdx = headers.indexOfFirst { it == "dispositivo" || it.contains("modelo") || it.contains("aparelho") } + .let { if (it != -1) it else 1 } + val emailIdx = headers.indexOfFirst { it == "email" || it == "e-mail" || it.contains("email") } + .let { if (it != -1) it else 2 } + val nomeIdx = headers.indexOfFirst { it == "nome_usuario" || it == "nome" || it.contains("usuario") || it.contains("usuário") } + .let { if (it != -1) it else 3 } + val androidIdx = headers.indexOfFirst { it == "versao_android" || it.contains("android") } + .let { if (it != -1) it else 4 } + val appIdx = headers.indexOfFirst { it == "versao_app" || it.contains("app") } + .let { if (it != -1) it else 5 } + val ultimoAcessoIdx = headers.indexOfFirst { it == "ultimo_acesso" || it.contains("acesso") || it.contains("data") || it.contains("timestamp") } + .let { if (it != -1) it else 6 } + val statusIdx = headers.indexOfFirst { it == "status_sincronizacao" || it.contains("status") } + .let { if (it != -1) it else 7 } + + val maxIdx = maxOf(deviceIdIdx, dispositivoIdx, emailIdx, nomeIdx, androidIdx, appIdx, ultimoAcessoIdx, statusIdx) + + var existingRowIndex = -1 // 1-indexed line in sheet + for (i in 1 until rows.size) { + val row = rows[i] + if (deviceIdIdx < row.size && row[deviceIdIdx].trim().equals(info.deviceId.trim(), ignoreCase = true)) { + existingRowIndex = i + 1 + break + } + } + + fun buildRowValues(): List { + val list = MutableList(maxIdx + 1) { "" } + list[deviceIdIdx] = info.deviceId + list[dispositivoIdx] = info.dispositivo + list[emailIdx] = info.email + list[nomeIdx] = info.nomeUsuario + list[androidIdx] = info.versaoAndroid + list[appIdx] = info.versaoApp + list[ultimoAcessoIdx] = info.ultimoAcesso + list[statusIdx] = info.statusSincronizacao + return list + } + + val rowValues = buildRowValues() + + if (existingRowIndex != -1) { + val endCol = getColumnLetter(rowValues.size) + updateValues("$sheetName!A$existingRowIndex:$endCol$existingRowIndex", listOf(rowValues)) + Log.d(tag, "Successfully updated usage_history row $existingRowIndex for device_id: ${info.deviceId}") + } else { + appendValues("$sheetName!A:H", listOf(rowValues)) + Log.d(tag, "Successfully appended new device access record to usage_history for device_id: ${info.deviceId}") + } + } } 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 0a52f82..ad3bc3e 100644 --- a/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt +++ b/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt @@ -701,6 +701,12 @@ class MaintenanceRepository( android.util.Log.e("MaintenanceRepository", "Falha ao sincronizar aba achados", e) } + try { + recordDeviceAccessLog("Sucesso") + } catch (e: Exception) { + android.util.Log.e("MaintenanceRepository", "Falha ao registrar log de uso do dispositivo", e) + } + SyncResult.Success( syncedItems = reconciledActivities.size, conflictsResolved = conflictingOSs.size @@ -711,6 +717,42 @@ class MaintenanceRepository( } } + private fun recordDeviceAccessLog(status: String = "Sucesso") { + try { + val savedUser = getSavedUser() + val firebaseUser = try { + com.google.firebase.auth.FirebaseAuth.getInstance().currentUser + } catch (e: Throwable) { + null + } + val email = savedUser?.email ?: firebaseUser?.email ?: "" + val name = savedUser?.displayName ?: firebaseUser?.displayName ?: "" + + val deviceId = com.example.util.DeviceUtils.getDeviceId(context) + val model = com.example.util.DeviceUtils.getDeviceModel() + val androidVer = com.example.util.DeviceUtils.getAndroidVersion() + val appVer = com.example.util.DeviceUtils.getAppVersion(context) + + val sdf = java.text.SimpleDateFormat("yyyy-MM-dd HH:mm:ss", java.util.Locale.getDefault()) + val formattedTime = sdf.format(java.util.Date()) + + val accessInfo = com.example.data.model.DeviceAccessInfo( + deviceId = deviceId, + dispositivo = model, + email = email, + nomeUsuario = name, + versaoAndroid = androidVer, + versaoApp = appVer, + ultimoAcesso = formattedTime, + statusSincronizacao = status + ) + + sheetsSyncService.updateUsageHistory(accessInfo) + } catch (e: Exception) { + android.util.Log.e("MaintenanceRepository", "Falha ao registrar histórico de uso do dispositivo", e) + } + } + private fun sanitizeSetor(setor: String): String { val s = setor.trim() if (s.isBlank()) return "Preparação" diff --git a/app/src/main/java/com/example/util/DeviceUtils.kt b/app/src/main/java/com/example/util/DeviceUtils.kt new file mode 100644 index 0000000..c2865ac --- /dev/null +++ b/app/src/main/java/com/example/util/DeviceUtils.kt @@ -0,0 +1,61 @@ +package com.example.util + +import android.content.Context +import android.os.Build +import android.provider.Settings +import java.util.UUID + +object DeviceUtils { + + fun getDeviceId(context: Context): String { + val androidId = try { + Settings.Secure.getString(context.contentResolver, Settings.Secure.ANDROID_ID) + } catch (e: Exception) { + null + } + + if (!androidId.isNullOrBlank() && androidId != "9774d56d682e549c") { + return androidId + } + + val prefs = context.getSharedPreferences("device_prefs", Context.MODE_PRIVATE) + var uuid = prefs.getString("device_uuid", null) + if (uuid.isNullOrBlank()) { + uuid = UUID.randomUUID().toString() + prefs.edit().putString("device_uuid", uuid).apply() + } + return uuid + } + + fun getDeviceModel(): String { + val manufacturer = Build.MANUFACTURER ?: "" + val model = Build.MODEL ?: "" + return if (model.startsWith(manufacturer, ignoreCase = true)) { + model.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() } + } else { + "${manufacturer.replaceFirstChar { if (it.isLowerCase()) it.titlecase() else it.toString() }} $model" + }.trim() + } + + fun getAndroidVersion(): String { + val release = Build.VERSION.RELEASE ?: "Unknown" + val sdk = Build.VERSION.SDK_INT + return "Android $release (API $sdk)" + } + + fun getAppVersion(context: Context): String { + return try { + val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0) + val versionName = packageInfo.versionName ?: "1.0.0" + @Suppress("DEPRECATION") + val versionCode = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + packageInfo.longVersionCode + } else { + packageInfo.versionCode.toLong() + } + "$versionName (v$versionCode)" + } catch (e: Exception) { + "1.0.0" + } + } +} diff --git a/app/src/test/java/com/example/util/DeviceUtilsTest.kt b/app/src/test/java/com/example/util/DeviceUtilsTest.kt new file mode 100644 index 0000000..2b875af --- /dev/null +++ b/app/src/test/java/com/example/util/DeviceUtilsTest.kt @@ -0,0 +1,70 @@ +package com.example.util + +import android.content.Context +import androidx.test.core.app.ApplicationProvider +import com.example.data.model.DeviceAccessInfo +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertTrue +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class DeviceUtilsTest { + + @Test + fun testGetDeviceId_returnsNonNullString() { + val context = ApplicationProvider.getApplicationContext() + val deviceId = DeviceUtils.getDeviceId(context) + assertNotNull(deviceId) + assertTrue(deviceId.isNotBlank()) + } + + @Test + fun testGetDeviceModel_returnsNonEmptyModel() { + val model = DeviceUtils.getDeviceModel() + assertNotNull(model) + assertTrue(model.isNotBlank()) + } + + @Test + fun testGetAndroidVersion_containsAndroidAndApi() { + val version = DeviceUtils.getAndroidVersion() + assertNotNull(version) + assertTrue(version.contains("Android")) + assertTrue(version.contains("API")) + } + + @Test + fun testGetAppVersion_returnsValidString() { + val context = ApplicationProvider.getApplicationContext() + val appVersion = DeviceUtils.getAppVersion(context) + assertNotNull(appVersion) + assertTrue(appVersion.isNotBlank()) + } + + @Test + fun testDeviceAccessInfo_instantiation() { + val info = DeviceAccessInfo( + deviceId = "test-device-id-123", + dispositivo = "Pixel 8 Pro", + email = "teste@empresa.com", + nomeUsuario = "Usuario Teste", + versaoAndroid = "Android 14 (API 34)", + versaoApp = "1.0.0 (v1)", + ultimoAcesso = "2026-08-06 12:00:00", + statusSincronizacao = "Sucesso" + ) + assertEquals("test-device-id-123", info.deviceId) + assertEquals("Pixel 8 Pro", info.dispositivo) + assertEquals("teste@empresa.com", info.email) + assertEquals("Usuario Teste", info.nomeUsuario) + assertEquals("Android 14 (API 34)", info.versaoAndroid) + assertEquals("1.0.0 (v1)", info.versaoApp) + assertEquals("2026-08-06 12:00:00", info.ultimoAcesso) + assertEquals("Sucesso", info.statusSincronizacao) + } +} diff --git a/documentacao/arquitetura/arquitetura_do_sistema.md b/documentacao/arquitetura/arquitetura_do_sistema.md index cf305f8..1582784 100644 --- a/documentacao/arquitetura/arquitetura_do_sistema.md +++ b/documentacao/arquitetura/arquitetura_do_sistema.md @@ -69,10 +69,14 @@ A estrutura do código fonte está localizada no pacote `com.example` e é organ * [`MaintenanceDao.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/local/MaintenanceDao.kt): Consultas locais SQL (queries reativas com `Flow` e operações `suspend`). * [`model/`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/model/) * [`MaintenanceActivity.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/model/MaintenanceActivity.kt): Entidades Room (`MaintenanceActivity`, `OSUpdateHistory`), enumerador `ActivityStatus` e auxiliares de formatação/parsing de data. + * [`DeviceAccessInfo.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/model/DeviceAccessInfo.kt): Estrutura de dados contendo detalhes de hardware, software, e-mail do Google SSO e timestamp do último acesso. * [`remote/`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/remote/) - * [`GoogleSheetsSyncService.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/remote/GoogleSheetsSyncService.kt): Serviço de integração HTTP com a API v4 do Google Sheets, englobando serialização JSON (Moshi), autenticação e mapeamento de planilhas. + * [`GoogleSheetsSyncService.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/remote/GoogleSheetsSyncService.kt): Serviço de integração HTTP com a API v4 do Google Sheets, englobando serialização JSON (Moshi), autenticação e mapeamento de planilhas (`project`, `history`, `achados`, `usage_history`). * [`repository/`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/repository/) * [`MaintenanceRepository.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt): Mediador de dados, processamento de planilhas locais (CSV) e algoritmo central de reconciliação de estado. + * `util/` (Utilitários) + * [`DeviceUtils.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/util/DeviceUtils.kt): Utilitário de extração de metadados do aparelho (`ANDROID_ID`, modelo, versão do Android e versão do app). + * [`TimeGuardManager.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/util/TimeGuardManager.kt): Validador de hora do sistema e prevenção de data retroativa. * `ui/` (Camada de Apresentação) * [`components/`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/ui/components/) * [`AppLogo.kt`](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/app/src/main/java/com/example/ui/components/AppLogo.kt): Logotipo customizado desenhado via Canvas vetorial utilizando cores da marca. diff --git a/documentacao/fluxo_de_dados_e_sincronizacao.md b/documentacao/fluxo_de_dados_e_sincronizacao.md index 7f3fece..19c3cdc 100644 --- a/documentacao/fluxo_de_dados_e_sincronizacao.md +++ b/documentacao/fluxo_de_dados_e_sincronizacao.md @@ -36,10 +36,11 @@ O aplicativo adota o padrão **MVVM (Model-View-ViewModel)** com **Repository Pa | - maintenance_activities | - Aba 'project' (Leitura) | | - os_update_history | | - Aba 'history' (Audit) | | - os_findings | | - Aba 'achados' (Linhas) | -| - app_logs | +---------------------------+ -| - sync_conflict_logs | | Firebase Storage SDK | -| - user_access | | - Bucket de fotos / mídias| -+-----------------------+ +---------------------------+ +| - app_logs | | - Aba 'usage_history' (Rastreamento)| +| - sync_conflict_logs | +---------------------------+ +| - user_access | | Firebase Storage SDK | ++-----------------------+ | - Bucket de fotos / mídias| + +---------------------------+ ``` --- @@ -177,7 +178,7 @@ Armazena o nível de permissão associado aos e-mails cadastrados. 4. Obtém a `downloadUrl` oficial contendo o token de acesso (`?alt=media&token=...`), salva em cache de memória (`downloadUrlCache`), e converte o caminho da foto no banco local para o formato relativo normalizado `photos/OS_{numeroOs}/OS_{numeroOs}_{timestamp}.jpg`. ### 4.2. Sincronização com o Google Sheets (`GoogleSheetsSyncService.kt`) -O aplicativo sincroniza com três abas da planilha central: +O aplicativo sincroniza com quatro abas da planilha central: 1. **Aba `project` (Leitura Mestra)**: Carrega as ordens de serviço ativas. 2. **Aba `history` (Escrita de Auditoria)**: Envia novos registros da tabela `os_update_history`. @@ -185,6 +186,10 @@ O aplicativo sincroniza com três abas da planilha central: - Limpa e converte caminhos de fotos locais para o formato relativo `photos/OS_.../*.jpg` via `cleanToStoragePath`. - Reconcilia achados remotos e locais preservando alterações pendentes (`synced = false`). - Agrupa e consolida os registros por `(numeroOs, tipo)` para garantir **no máximo 1 linha por OS com `tipo = "FOTO"`** contendo todas as fotos ativas concatenadas por `|`. +4. **Aba `usage_history` (Rastreamento do Último Acesso por Dispositivo)**: + - Garante que a aba contenha os cabeçalhos: `device_id`, `dispositivo`, `email`, `nome_usuario`, `versao_android`, `versao_app`, `ultimo_acesso`, `status_sincronizacao`. + - 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. ---