Compare commits
3 Commits
3c97bab0df
...
7759186234
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
7759186234 | ||
|
|
3578697d60 | ||
|
|
6345aac22e |
41
README.md
41
README.md
@@ -1,21 +1,34 @@
|
||||
<div align="center">
|
||||
<img width="1200" height="475" alt="GHBanner" src="https://ai.google.dev/static/site-assets/images/share-ais-513315318.png" />
|
||||
</div>
|
||||
# Aplicativo de Gestão de Manutenção de Parada (Android)
|
||||
|
||||
# Run and deploy your AI Studio app
|
||||
Aplicativo Android **offline-first** desenvolvido em Kotlin e Jetpack Compose para gerenciamento, acompanhamento e auditoria de Ordens de Serviço (OS) em plantas industriais.
|
||||
|
||||
This contains everything you need to run your app locally.
|
||||
---
|
||||
|
||||
View your app in AI Studio: https://ai.studio/apps/d5626d9c-db6d-4067-9ba1-e80d37ea164f
|
||||
## 📚 Documentação Técnica do Projeto
|
||||
|
||||
## Run Locally
|
||||
- **[Documentação de Fluxo de Dados, Salvamento e Sincronização](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/documentacao/fluxo_de_dados_e_sincronizacao.md)**:
|
||||
- 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`, `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.
|
||||
|
||||
**Prerequisites:** [Android Studio](https://developer.android.com/studio)
|
||||
- **[Arquitetura do Sistema](file:///home/cesarjhony/dev/projects/gestao_de_manutencao/documentacao/arquitetura/arquitetura_do_sistema.md)**:
|
||||
- Diagramas de arquitetura MVVM + Repository Pattern.
|
||||
- Mapeamento de componentes Compose, ViewModel e Room DAO.
|
||||
- Algoritmo de reconciliação de dados e auditoria transacional.
|
||||
|
||||
---
|
||||
|
||||
1. Open Android Studio
|
||||
2. Select **Open** and choose the directory containing this project
|
||||
3. Allow Android Studio to fix any incompatibilities as it imports the project.
|
||||
4. Create a file named `.env` in the project directory and set `GEMINI_API_KEY` in that file to your Gemini API key (see `.env.example` for an example)
|
||||
5. Remove this line from the app's `build.gradle.kts` file: `signingConfig = signingConfigs.getByName("debugConfig")`
|
||||
6. Run the app on an emulator or physical device
|
||||
## 🚀 Como Executar o Projeto
|
||||
|
||||
**Pré-requisitos:** [Android Studio](https://developer.android.com/studio) / JDK 17+
|
||||
|
||||
1. Abra o Android Studio.
|
||||
2. Selecione **Open** e escolha a pasta deste projeto (`gestao_de_manutencao`).
|
||||
3. Execute os testes unitários via linha de comando ou terminal do estúdio:
|
||||
```bash
|
||||
./gradle_9_3_1/gradle-9.3.1/bin/gradle test
|
||||
```
|
||||
4. Execute o aplicativo em um emulador ou dispositivo físico Android.
|
||||
|
||||
@@ -93,6 +93,9 @@ interface MaintenanceDao {
|
||||
@Query("SELECT * FROM os_findings WHERE numeroOs = :numeroOs AND tipo = 'OBS' ORDER BY timestamp DESC LIMIT 1")
|
||||
suspend fun getLatestObservationForOsOneShot(numeroOs: String): OSFinding?
|
||||
|
||||
@Query("SELECT * FROM os_findings WHERE numeroOs = :numeroOs AND (tipo = 'FOTO' OR (fotoPath IS NOT NULL AND fotoPath != '')) ORDER BY timestamp DESC LIMIT 1")
|
||||
suspend fun getPhotoFindingForOsOneShot(numeroOs: String): OSFinding?
|
||||
|
||||
@Insert(onConflict = OnConflictStrategy.REPLACE)
|
||||
suspend fun insertFinding(finding: OSFinding)
|
||||
|
||||
|
||||
15
app/src/main/java/com/example/data/model/DeviceAccessInfo.kt
Normal file
15
app/src/main/java/com/example/data/model/DeviceAccessInfo.kt
Normal file
@@ -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"
|
||||
)
|
||||
@@ -26,13 +26,14 @@ data class OSFinding(
|
||||
)
|
||||
|
||||
enum class FindingType(val value: String, val displayName: String) {
|
||||
FOTO("FOTO", "Foto"),
|
||||
OBS("OBS", "Observação"),
|
||||
SEGURANCA("SEGURANCA", "Achado de Segurança"),
|
||||
MANUTENCAO("MANUTENCAO", "Achado de Manutenção");
|
||||
|
||||
companion object {
|
||||
fun fromValue(value: String): FindingType {
|
||||
return values().firstOrNull { it.value.equals(value, ignoreCase = true) } ?: OBS
|
||||
return values().firstOrNull { it.value.equals(value, ignoreCase = true) } ?: FOTO
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -24,24 +24,9 @@ class FirebaseStorageSyncService(
|
||||
private val storage: FirebaseStorage by lazy { FirebaseStorage.getInstance() }
|
||||
|
||||
/**
|
||||
* Uploads a local photo file to Firebase Storage under `photos/OS_{osNumber}/{fileName}`.
|
||||
* Returns FirebaseUploadResult containing the public download URL and storage path.
|
||||
* Ensures user is authenticated with Firebase Auth via Google ID Token if currentUser is null.
|
||||
*/
|
||||
suspend fun uploadPhoto(photoFile: File, osNumber: String): FirebaseUploadResult {
|
||||
if (!photoFile.exists()) {
|
||||
val err = "Arquivo local da foto não existe: ${photoFile.absolutePath}"
|
||||
appLogger.logError(tag, err)
|
||||
throw IOException(err)
|
||||
}
|
||||
|
||||
val timestamp = System.currentTimeMillis()
|
||||
val sanitizedOs = osNumber.replace("/", "_").replace(" ", "")
|
||||
val fileName = "OS_${sanitizedOs}_${timestamp}.jpg"
|
||||
val storagePath = "photos/OS_${sanitizedOs}/$fileName"
|
||||
|
||||
val photoRef: StorageReference = storage.reference.child(storagePath)
|
||||
|
||||
// Ensure user is authenticated with Firebase Auth if possible
|
||||
suspend fun ensureFirebaseAuth() {
|
||||
val auth = com.google.firebase.auth.FirebaseAuth.getInstance()
|
||||
if (auth.currentUser == null) {
|
||||
val lastAccount = com.google.android.gms.auth.api.signin.GoogleSignIn.getLastSignedInAccount(context)
|
||||
@@ -58,6 +43,26 @@ class FirebaseStorageSyncService(
|
||||
Log.w(tag, "Aviso: Nenhum usuário autenticado no FirebaseAuth nem ID Token do Google disponível.")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Uploads a local photo file to Firebase Storage under `photos/OS_{osNumber}/{fileName}`.
|
||||
* Returns FirebaseUploadResult containing the public download URL and storage path.
|
||||
*/
|
||||
suspend fun uploadPhoto(photoFile: File, osNumber: String): FirebaseUploadResult {
|
||||
if (!photoFile.exists()) {
|
||||
val err = "Arquivo local da foto não existe: ${photoFile.absolutePath}"
|
||||
appLogger.logError(tag, err)
|
||||
throw IOException(err)
|
||||
}
|
||||
|
||||
val timestamp = System.currentTimeMillis()
|
||||
val sanitizedOs = osNumber.replace("/", "_").replace(" ", "")
|
||||
val fileName = "OS_${sanitizedOs}_${timestamp}.jpg"
|
||||
val storagePath = "photos/OS_${sanitizedOs}/$fileName"
|
||||
|
||||
val photoRef: StorageReference = storage.reference.child(storagePath)
|
||||
ensureFirebaseAuth()
|
||||
|
||||
try {
|
||||
val fileToUpload = if (photoFile.length() > 500 * 1024L) {
|
||||
@@ -70,6 +75,7 @@ class FirebaseStorageSyncService(
|
||||
val downloadUrl = photoRef.downloadUrl.await().toString()
|
||||
|
||||
appLogger.logInfo(tag, "Foto enviada com sucesso para o Firebase Storage. OS: $osNumber, Path: $storagePath")
|
||||
downloadUrlCache[storagePath] = downloadUrl
|
||||
return FirebaseUploadResult(
|
||||
downloadUrl = downloadUrl,
|
||||
storagePath = storagePath,
|
||||
@@ -82,6 +88,75 @@ class FirebaseStorageSyncService(
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Downloads a photo file from Firebase Storage ON DEMAND to internal `os_photos` directory.
|
||||
* Returns the downloaded local File or null on error.
|
||||
*/
|
||||
suspend fun downloadPhotoFile(rawPath: String): File? {
|
||||
val trimmed = rawPath.trim()
|
||||
if (trimmed.isBlank() || trimmed.contains("_DELETED")) return null
|
||||
|
||||
val cleanPath = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = cleanPath.substringAfterLast("/").substringAfterLast("\\")
|
||||
.removeSuffix("_DELETED").removeSuffix(".jpg_DELETED").replace("_DELETED", "")
|
||||
|
||||
if (fileName.isBlank()) return null
|
||||
|
||||
val photosDir = File(context.filesDir, "os_photos")
|
||||
if (!photosDir.exists()) photosDir.mkdirs()
|
||||
|
||||
val targetLocalFile = File(photosDir, fileName)
|
||||
if (targetLocalFile.exists() && targetLocalFile.length() > 0) {
|
||||
return targetLocalFile
|
||||
}
|
||||
|
||||
var canonicalStoragePath = cleanPath.removePrefix("/")
|
||||
if (!canonicalStoragePath.startsWith("photos/")) {
|
||||
if (canonicalStoragePath.startsWith("o/photos/")) {
|
||||
canonicalStoragePath = canonicalStoragePath.removePrefix("o/")
|
||||
} else if (canonicalStoragePath.contains("photos/")) {
|
||||
canonicalStoragePath = "photos/" + canonicalStoragePath.substringAfter("photos/")
|
||||
} else if (canonicalStoragePath.startsWith("OS_")) {
|
||||
canonicalStoragePath = "photos/$canonicalStoragePath"
|
||||
}
|
||||
}
|
||||
|
||||
ensureFirebaseAuth()
|
||||
|
||||
return try {
|
||||
val photoRef = storage.reference.child(canonicalStoragePath)
|
||||
photoRef.getFile(targetLocalFile).await()
|
||||
|
||||
try {
|
||||
val tokenizedUrl = photoRef.downloadUrl.await().toString()
|
||||
registerDownloadUrl(canonicalStoragePath, tokenizedUrl)
|
||||
} catch (ignored: Exception) {}
|
||||
|
||||
appLogger.logInfo(tag, "Foto baixada com sucesso sob demanda para ${targetLocalFile.name}")
|
||||
targetLocalFile
|
||||
} catch (e: Exception) {
|
||||
appLogger.logError(tag, "Falha ao baixar foto sob demanda de '$canonicalStoragePath': ${e.message}", e)
|
||||
if (targetLocalFile.exists() && targetLocalFile.length() == 0L) {
|
||||
targetLocalFile.delete()
|
||||
}
|
||||
null
|
||||
}
|
||||
}
|
||||
|
||||
companion object {
|
||||
val downloadUrlCache = java.util.concurrent.ConcurrentHashMap<String, String>()
|
||||
|
||||
fun registerDownloadUrl(storagePath: String, downloadUrl: String) {
|
||||
if (storagePath.isNotBlank() && downloadUrl.isNotBlank()) {
|
||||
downloadUrlCache[storagePath] = downloadUrl
|
||||
}
|
||||
}
|
||||
|
||||
fun getCachedDownloadUrl(storagePath: String): String? {
|
||||
return downloadUrlCache[storagePath]
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs Soft Delete by copying the file object in Firebase Storage to have "_DELETED"
|
||||
* suffix in the exact same folder, and deleting the original reference.
|
||||
|
||||
@@ -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
|
||||
@@ -930,7 +931,7 @@ class GoogleSheetsSyncService(
|
||||
finding.timestamp.toString(),
|
||||
finding.responsavel,
|
||||
finding.emailEditor ?: "",
|
||||
filterRemoteOnlyPhotoPaths(finding.fotoPath)
|
||||
filterRemoteOnlyPhotoPaths(finding.fotoPath, finding.numeroOs)
|
||||
)
|
||||
}.toMutableList()
|
||||
|
||||
@@ -949,13 +950,131 @@ class GoogleSheetsSyncService(
|
||||
}
|
||||
}
|
||||
|
||||
fun filterRemoteOnlyPhotoPaths(pathStr: String?): String {
|
||||
fun cleanToStoragePath(pathStr: String?, defaultOsNumber: String = ""): String? {
|
||||
if (pathStr.isNullOrBlank()) return null
|
||||
val items = pathStr.split("|").map { item ->
|
||||
val trimmed = item.trim()
|
||||
if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
|
||||
val clean = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
if (clean.contains("/o/")) {
|
||||
clean.substringAfter("/o/").trim('/')
|
||||
} else if (clean.contains("photos/")) {
|
||||
"photos/" + clean.substringAfter("photos/")
|
||||
} else {
|
||||
trimmed
|
||||
}
|
||||
} else if (trimmed.startsWith("/")) {
|
||||
val clean = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = clean.substringAfterLast("/").substringAfterLast("\\")
|
||||
.removeSuffix("_DELETED").removeSuffix(".jpg_DELETED").replace("_DELETED", "")
|
||||
val osFolder = if (fileName.startsWith("OS_")) {
|
||||
val parts = fileName.split("_")
|
||||
if (parts.size >= 2) "${parts[0]}_${parts[1]}" else "OS_$defaultOsNumber"
|
||||
} else if (defaultOsNumber.isNotBlank()) {
|
||||
val osSanitized = defaultOsNumber.replace("/", "_").replace(" ", "")
|
||||
"OS_$osSanitized"
|
||||
} else {
|
||||
"OS_Geral"
|
||||
}
|
||||
"photos/$osFolder/$fileName"
|
||||
} else if (trimmed.startsWith("OS_") && trimmed.contains("/")) {
|
||||
"photos/$trimmed"
|
||||
} else {
|
||||
trimmed
|
||||
}
|
||||
}
|
||||
return items.distinct().joinToString("|").ifEmpty { null }
|
||||
}
|
||||
|
||||
fun filterRemoteOnlyPhotoPaths(pathStr: String?, defaultOsNumber: String = ""): String {
|
||||
if (pathStr.isNullOrBlank()) return ""
|
||||
return pathStr.split("|")
|
||||
val cleaned = cleanToStoragePath(pathStr, defaultOsNumber) ?: return ""
|
||||
return cleaned.split("|")
|
||||
.map { it.trim() }
|
||||
.filter { it.isNotBlank() && !it.startsWith("/") }
|
||||
.filter { it.isNotBlank() && !it.endsWith("_DELETED") && !it.contains("_DELETED") }
|
||||
.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<String> {
|
||||
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}")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -79,24 +79,64 @@ class MaintenanceRepository(
|
||||
val currentActivity = dao.getActivityByOsOneShot(numeroOs) ?: return@withContext
|
||||
val effectiveTimestamp = customTimestampMillis ?: System.currentTimeMillis()
|
||||
|
||||
// Handle observation and photo update as an OSFinding of type OBS if filled or photo attached
|
||||
// Handle text observation as OSFinding of type OBS
|
||||
val cleanObs = stripAuditTags(observacao)
|
||||
if (cleanObs != null || !fotoPath.isNullOrBlank()) {
|
||||
val obsText = cleanObs ?: "Foto anexada"
|
||||
val findingObs = OSFinding(
|
||||
id = java.util.UUID.randomUUID().toString(),
|
||||
numeroOs = numeroOs,
|
||||
tipo = "OBS",
|
||||
descricao = obsText,
|
||||
timestamp = effectiveTimestamp,
|
||||
responsavel = recurso,
|
||||
emailEditor = emailEditor,
|
||||
fotoPath = fotoPath,
|
||||
synced = false
|
||||
)
|
||||
if (cleanObs != null) {
|
||||
val existingObsFinding = dao.getLatestObservationForOsOneShot(numeroOs)
|
||||
val findingObs = if (existingObsFinding != null) {
|
||||
existingObsFinding.copy(
|
||||
descricao = cleanObs,
|
||||
timestamp = effectiveTimestamp,
|
||||
responsavel = recurso,
|
||||
emailEditor = emailEditor,
|
||||
synced = false
|
||||
)
|
||||
} else {
|
||||
OSFinding(
|
||||
id = java.util.UUID.randomUUID().toString(),
|
||||
numeroOs = numeroOs,
|
||||
tipo = "OBS",
|
||||
descricao = cleanObs,
|
||||
timestamp = effectiveTimestamp,
|
||||
responsavel = recurso,
|
||||
emailEditor = emailEditor,
|
||||
fotoPath = null,
|
||||
synced = false
|
||||
)
|
||||
}
|
||||
dao.insertFinding(findingObs)
|
||||
}
|
||||
|
||||
// Handle photos as exclusive OSFinding of type FOTO
|
||||
if (!fotoPath.isNullOrBlank()) {
|
||||
val existingPhotoFinding = dao.getPhotoFindingForOsOneShot(numeroOs)
|
||||
val findingPhoto = if (existingPhotoFinding != null) {
|
||||
val mergedFotoPath = mergePreservingDeletedPhotos(existingPhotoFinding.fotoPath, fotoPath)
|
||||
existingPhotoFinding.copy(
|
||||
tipo = "FOTO",
|
||||
descricao = if (existingPhotoFinding.descricao.isNotBlank() && existingPhotoFinding.descricao != "Foto anexada") existingPhotoFinding.descricao else "Foto anexada",
|
||||
timestamp = effectiveTimestamp,
|
||||
responsavel = recurso,
|
||||
emailEditor = emailEditor,
|
||||
fotoPath = mergedFotoPath,
|
||||
synced = false
|
||||
)
|
||||
} else {
|
||||
OSFinding(
|
||||
id = java.util.UUID.randomUUID().toString(),
|
||||
numeroOs = numeroOs,
|
||||
tipo = "FOTO",
|
||||
descricao = "Foto anexada",
|
||||
timestamp = effectiveTimestamp,
|
||||
responsavel = recurso,
|
||||
emailEditor = emailEditor,
|
||||
fotoPath = fotoPath,
|
||||
synced = false
|
||||
)
|
||||
}
|
||||
dao.insertFinding(findingPhoto)
|
||||
}
|
||||
|
||||
val latestObsText = cleanObs ?: stripAuditTags(currentActivity.observacoes)
|
||||
|
||||
val updatedActivity = currentActivity.copy(
|
||||
@@ -596,18 +636,15 @@ class MaintenanceRepository(
|
||||
val reconciledFindings = remoteFindings.map { remote ->
|
||||
val local = localFindingsMap[remote.id]
|
||||
if (local != null) {
|
||||
val localHasPhoto = !local.fotoPath.isNullOrBlank()
|
||||
val remoteHasPhoto = !remote.fotoPath.isNullOrBlank()
|
||||
val finalFotoPath = when {
|
||||
localHasPhoto && !remoteHasPhoto -> local.fotoPath
|
||||
remoteHasPhoto && localHasPhoto -> mergePreservingDeletedPhotos(local.fotoPath, remote.fotoPath)
|
||||
remoteHasPhoto -> remote.fotoPath
|
||||
else -> local.fotoPath
|
||||
val finalFotoPath = mergePreservingDeletedPhotos(local.fotoPath, remote.fotoPath)
|
||||
if (!local.synced) {
|
||||
local.copy(fotoPath = finalFotoPath)
|
||||
} else {
|
||||
remote.copy(
|
||||
fotoPath = finalFotoPath,
|
||||
synced = local.synced && (finalFotoPath == remote.fotoPath)
|
||||
)
|
||||
}
|
||||
remote.copy(
|
||||
fotoPath = finalFotoPath,
|
||||
synced = local.synced && (finalFotoPath == remote.fotoPath)
|
||||
)
|
||||
} else {
|
||||
remote
|
||||
}
|
||||
@@ -618,8 +655,43 @@ class MaintenanceRepository(
|
||||
val localOnlyFindings = localFindingsMap.values.filter { it.id !in remoteIds }
|
||||
reconciledFindings.addAll(localOnlyFindings)
|
||||
|
||||
if (reconciledFindings.isNotEmpty()) {
|
||||
dao.insertFindings(reconciledFindings)
|
||||
// Consolidate duplicate FOTO and OBS findings for the same OS into single OSFinding rows
|
||||
val consolidatedFindings = mutableListOf<OSFinding>()
|
||||
val groupedByOsAndType = reconciledFindings.groupBy { Pair(it.numeroOs, if (it.tipo == "FOTO" || !it.fotoPath.isNullOrBlank()) "FOTO" else it.tipo) }
|
||||
|
||||
groupedByOsAndType.forEach { (key, findingsList) ->
|
||||
val (osNum, groupType) = key
|
||||
if (findingsList.size > 1) {
|
||||
val latestItem = findingsList.maxByOrNull { it.timestamp } ?: findingsList.first()
|
||||
val mergedPhotoPath = findingsList.mapNotNull { it.fotoPath }
|
||||
.flatMap { it.split("|") }
|
||||
.map { it.trim() }
|
||||
.filter { it.isNotBlank() }
|
||||
.distinct()
|
||||
.joinToString("|")
|
||||
.ifEmpty { null }
|
||||
|
||||
consolidatedFindings.add(
|
||||
latestItem.copy(
|
||||
tipo = groupType,
|
||||
fotoPath = mergedPhotoPath
|
||||
)
|
||||
)
|
||||
// Cleanup duplicate IDs from Room DB
|
||||
val duplicateIds = findingsList.map { it.id }.filter { it != latestItem.id }
|
||||
duplicateIds.forEach { dupId -> dao.deleteFindingById(dupId) }
|
||||
} else {
|
||||
val single = findingsList.first()
|
||||
if (!single.fotoPath.isNullOrBlank() && single.tipo != "FOTO") {
|
||||
consolidatedFindings.add(single.copy(tipo = "FOTO"))
|
||||
} else {
|
||||
consolidatedFindings.add(single)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (consolidatedFindings.isNotEmpty()) {
|
||||
dao.insertFindings(consolidatedFindings)
|
||||
}
|
||||
|
||||
val allLocalActiveFindings = dao.getAllFindingsList()
|
||||
@@ -629,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
|
||||
@@ -639,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"
|
||||
@@ -760,8 +874,8 @@ class MaintenanceRepository(
|
||||
val result = firebaseStorageSyncService.uploadPhoto(compressedFile, finding.numeroOs)
|
||||
changed = true
|
||||
replacementsByOs.getOrPut(finding.numeroOs) { mutableListOf() }
|
||||
.add(Pair(trimmed, result.downloadUrl))
|
||||
result.downloadUrl
|
||||
.add(Pair(trimmed, result.storagePath))
|
||||
result.storagePath
|
||||
} catch (e: Exception) {
|
||||
android.util.Log.e("MaintenanceRepository", "Falha no upload da foto ${file.name} para o Firebase Storage: ${e.message}", e)
|
||||
trimmed
|
||||
@@ -799,8 +913,8 @@ class MaintenanceRepository(
|
||||
val result = firebaseStorageSyncService.uploadPhoto(compressedFile, history.numeroOs)
|
||||
changed = true
|
||||
replacementsByOs.getOrPut(history.numeroOs) { mutableListOf() }
|
||||
.add(Pair(trimmed, result.downloadUrl))
|
||||
result.downloadUrl
|
||||
.add(Pair(trimmed, result.storagePath))
|
||||
result.storagePath
|
||||
} catch (e: Exception) {
|
||||
android.util.Log.e("MaintenanceRepository", "Falha no upload da foto ${file.name} para o Firebase Storage: ${e.message}", e)
|
||||
trimmed
|
||||
|
||||
@@ -1117,37 +1117,142 @@ fun OSListItemCard(
|
||||
|
||||
fun resolvePhotoModel(path: String, context: android.content.Context? = null): String {
|
||||
val trimmed = path.trim()
|
||||
if (trimmed.isBlank()) return ""
|
||||
if (trimmed.isBlank() || trimmed.contains("_DELETED")) return ""
|
||||
|
||||
// 1. Prioritize local file path if it exists on disk
|
||||
// 1. Direct HTTP/HTTPS URLs (if already full download URL with token)
|
||||
if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
|
||||
return trimmed
|
||||
}
|
||||
|
||||
// 2. Direct local file path if file physically exists on disk
|
||||
if (trimmed.startsWith("/")) {
|
||||
val file = java.io.File(trimmed)
|
||||
if (file.exists()) return trimmed
|
||||
}
|
||||
|
||||
// 2. Check if local cached file with same name exists in internal os_photos directory
|
||||
if (context != null) {
|
||||
val clean = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = clean.substringAfterLast("/").substringAfterLast("\\")
|
||||
// 3. Extract filename to check if cached in internal `os_photos` directory
|
||||
val cleanPathForName = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = cleanPathForName.substringAfterLast("/").substringAfterLast("\\")
|
||||
.removeSuffix("_DELETED").removeSuffix(".jpg_DELETED").replace("_DELETED", "")
|
||||
|
||||
if (context != null && fileName.isNotBlank()) {
|
||||
val photosDir = java.io.File(context.filesDir, "os_photos")
|
||||
val localCachedFile = java.io.File(photosDir, fileName)
|
||||
if (localCachedFile.exists()) {
|
||||
return localCachedFile.absolutePath
|
||||
}
|
||||
}
|
||||
|
||||
// 4. Resolve relative storage path (e.g. "photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg", "/photos/...", "photos%2F...", "OS_OS-1503/...")
|
||||
var canonicalStoragePath = cleanPathForName.removePrefix("/")
|
||||
if (!canonicalStoragePath.startsWith("photos/")) {
|
||||
if (canonicalStoragePath.startsWith("o/photos/")) {
|
||||
canonicalStoragePath = canonicalStoragePath.removePrefix("o/")
|
||||
} else if (canonicalStoragePath.contains("photos/")) {
|
||||
canonicalStoragePath = "photos/" + canonicalStoragePath.substringAfter("photos/")
|
||||
} else if (canonicalStoragePath.startsWith("OS_")) {
|
||||
canonicalStoragePath = "photos/$canonicalStoragePath"
|
||||
}
|
||||
}
|
||||
|
||||
// Check if tokenized downloadUrl is registered in memory cache
|
||||
val cachedUrl = com.example.data.remote.FirebaseStorageSyncService.getCachedDownloadUrl(canonicalStoragePath)
|
||||
if (!cachedUrl.isNullOrBlank()) {
|
||||
return cachedUrl
|
||||
}
|
||||
|
||||
if (canonicalStoragePath.startsWith("photos/")) {
|
||||
val encoded = try {
|
||||
android.net.Uri.encode(canonicalStoragePath)
|
||||
} catch (e: Throwable) {
|
||||
java.net.URLEncoder.encode(canonicalStoragePath, "UTF-8").replace("+", "%20")
|
||||
}
|
||||
return "https://firebasestorage.googleapis.com/v0/b/gestao-parada-os.firebasestorage.app/o/$encoded?alt=media"
|
||||
}
|
||||
|
||||
return trimmed
|
||||
}
|
||||
|
||||
@Composable
|
||||
fun rememberResolvedPhotoModel(path: String): String {
|
||||
val context = LocalContext.current
|
||||
var resolvedUrl by remember(path) { mutableStateOf(resolvePhotoModel(path, context)) }
|
||||
|
||||
LaunchedEffect(path) {
|
||||
val trimmed = path.trim()
|
||||
if (trimmed.isBlank() || trimmed.contains("_DELETED")) return@LaunchedEffect
|
||||
|
||||
if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
|
||||
resolvedUrl = trimmed
|
||||
return@LaunchedEffect
|
||||
}
|
||||
if (trimmed.startsWith("/")) {
|
||||
val file = java.io.File(trimmed)
|
||||
if (file.exists()) {
|
||||
resolvedUrl = file.absolutePath
|
||||
return@LaunchedEffect
|
||||
}
|
||||
}
|
||||
|
||||
val cleanPathForName = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = cleanPathForName.substringAfterLast("/").substringAfterLast("\\")
|
||||
.removeSuffix("_DELETED").removeSuffix(".jpg_DELETED").replace("_DELETED", "")
|
||||
|
||||
if (fileName.isNotBlank()) {
|
||||
val photosDir = java.io.File(context.filesDir, "os_photos")
|
||||
val localCachedFile = java.io.File(photosDir, fileName)
|
||||
if (localCachedFile.exists()) {
|
||||
return localCachedFile.absolutePath
|
||||
resolvedUrl = localCachedFile.absolutePath
|
||||
return@LaunchedEffect
|
||||
}
|
||||
}
|
||||
|
||||
var canonicalStoragePath = cleanPathForName.removePrefix("/")
|
||||
if (!canonicalStoragePath.startsWith("photos/")) {
|
||||
if (canonicalStoragePath.startsWith("o/photos/")) {
|
||||
canonicalStoragePath = canonicalStoragePath.removePrefix("o/")
|
||||
} else if (canonicalStoragePath.contains("photos/")) {
|
||||
canonicalStoragePath = "photos/" + canonicalStoragePath.substringAfter("photos/")
|
||||
} else if (canonicalStoragePath.startsWith("OS_")) {
|
||||
canonicalStoragePath = "photos/$canonicalStoragePath"
|
||||
}
|
||||
}
|
||||
|
||||
val cachedUrl = com.example.data.remote.FirebaseStorageSyncService.getCachedDownloadUrl(canonicalStoragePath)
|
||||
if (!cachedUrl.isNullOrBlank()) {
|
||||
resolvedUrl = cachedUrl
|
||||
return@LaunchedEffect
|
||||
}
|
||||
|
||||
// Try downloading photo file ON DEMAND from Firebase Storage if not on local disk
|
||||
try {
|
||||
val syncService = com.example.data.remote.FirebaseStorageSyncService(context)
|
||||
val downloadedFile: java.io.File? = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) {
|
||||
syncService.downloadPhotoFile(trimmed)
|
||||
}
|
||||
if (downloadedFile != null && downloadedFile.exists()) {
|
||||
resolvedUrl = downloadedFile.absolutePath
|
||||
return@LaunchedEffect
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
android.util.Log.w("PhotoResolver", "Falha ao baixar foto sob demanda de $trimmed: ${e.message}")
|
||||
}
|
||||
|
||||
try {
|
||||
val storageRef = com.google.firebase.storage.FirebaseStorage.getInstance().reference.child(canonicalStoragePath)
|
||||
storageRef.downloadUrl.addOnSuccessListener { uri ->
|
||||
val tokenizedUrl = uri.toString()
|
||||
com.example.data.remote.FirebaseStorageSyncService.registerDownloadUrl(canonicalStoragePath, tokenizedUrl)
|
||||
resolvedUrl = tokenizedUrl
|
||||
}.addOnFailureListener { e ->
|
||||
android.util.Log.w("PhotoResolver", "Could not fetch signed downloadUrl for $canonicalStoragePath: ${e.message}")
|
||||
}
|
||||
} catch (e: Throwable) {
|
||||
android.util.Log.w("PhotoResolver", "Could not fetch signed downloadUrl for $canonicalStoragePath: ${e.message}")
|
||||
}
|
||||
}
|
||||
|
||||
// 3. Fallback to remote URLs
|
||||
if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
|
||||
return trimmed
|
||||
}
|
||||
if (trimmed.startsWith("photos/")) {
|
||||
val encoded = android.net.Uri.encode(trimmed)
|
||||
return "https://firebasestorage.googleapis.com/v0/b/cargill-parada-os.appspot.com/o/$encoded?alt=media"
|
||||
}
|
||||
return trimmed
|
||||
return resolvedUrl
|
||||
}
|
||||
|
||||
@Composable
|
||||
@@ -1174,8 +1279,7 @@ fun FullscreenPhotoViewerDialog(
|
||||
modifier = Modifier
|
||||
.fillMaxWidth()
|
||||
.align(Alignment.TopCenter)
|
||||
.statusBarsPadding()
|
||||
.padding(horizontal = 16.dp, vertical = 12.dp),
|
||||
.padding(16.dp),
|
||||
horizontalArrangement = Arrangement.SpaceBetween,
|
||||
verticalAlignment = Alignment.CenterVertically
|
||||
) {
|
||||
@@ -1250,7 +1354,7 @@ fun FullscreenPhotoViewerDialog(
|
||||
}
|
||||
|
||||
// Image display
|
||||
val resolvedModel = remember(photoPath) { resolvePhotoModel(photoPath, context) }
|
||||
val resolvedModel = rememberResolvedPhotoModel(photoPath)
|
||||
var retryKey by remember { mutableStateOf(0) }
|
||||
coil.compose.SubcomposeAsyncImage(
|
||||
model = coil.request.ImageRequest.Builder(context)
|
||||
@@ -1259,6 +1363,15 @@ fun FullscreenPhotoViewerDialog(
|
||||
.crossfade(true)
|
||||
.diskCachePolicy(coil.request.CachePolicy.ENABLED)
|
||||
.memoryCachePolicy(coil.request.CachePolicy.ENABLED)
|
||||
.listener(
|
||||
onError = { _, result ->
|
||||
com.example.util.AppLogger.getInstance(context).logError(
|
||||
tag = "PhotoDisplayError",
|
||||
message = "Falha ao carregar/exibir foto em tela cheia ($photoPath). Modelo: '$resolvedModel'",
|
||||
throwable = result.throwable
|
||||
)
|
||||
}
|
||||
)
|
||||
.build(),
|
||||
contentDescription = "Visualização em Tela Cheia",
|
||||
modifier = Modifier
|
||||
@@ -1360,7 +1473,8 @@ fun EditActivityBottomSheet(
|
||||
var selectedPhotoForViewer by remember { mutableStateOf<String?>(null) }
|
||||
var isSubmitting by remember { mutableStateOf(false) }
|
||||
|
||||
val activePhotos = remember(activity, history) {
|
||||
// Exibir fotos da galeria APENAS pela aba achados (findings)
|
||||
val activePhotos = remember(findings) {
|
||||
val list = mutableListOf<String>()
|
||||
fun processPath(raw: String?) {
|
||||
if (!raw.isNullOrBlank()) {
|
||||
@@ -1372,8 +1486,7 @@ fun EditActivityBottomSheet(
|
||||
}
|
||||
}
|
||||
}
|
||||
processPath(activity.fotoPath)
|
||||
history.forEach { processPath(it.fotoPath) }
|
||||
findings.forEach { processPath(it.fotoPath) }
|
||||
list
|
||||
}
|
||||
|
||||
@@ -1900,16 +2013,25 @@ fun EditActivityBottomSheet(
|
||||
border = BorderStroke(2.dp, if (isNew) BrandGreen else Color(0xFFE0E0E0))
|
||||
) {
|
||||
Box(modifier = Modifier.fillMaxSize()) {
|
||||
val currentCtx = LocalContext.current
|
||||
val resolvedModel = remember(photoPath) { resolvePhotoModel(photoPath, currentCtx) }
|
||||
val resolvedModel = rememberResolvedPhotoModel(photoPath)
|
||||
var retryKey by remember { mutableStateOf(0) }
|
||||
val currentContext = LocalContext.current
|
||||
coil.compose.SubcomposeAsyncImage(
|
||||
model = coil.request.ImageRequest.Builder(LocalContext.current)
|
||||
model = coil.request.ImageRequest.Builder(currentContext)
|
||||
.data(resolvedModel)
|
||||
.setParameter("retry_key", retryKey)
|
||||
.crossfade(true)
|
||||
.diskCachePolicy(coil.request.CachePolicy.ENABLED)
|
||||
.memoryCachePolicy(coil.request.CachePolicy.ENABLED)
|
||||
.listener(
|
||||
onError = { _, result ->
|
||||
com.example.util.AppLogger.getInstance(currentContext).logError(
|
||||
tag = "PhotoDisplayError",
|
||||
message = "Falha ao carregar miniatura da foto ($photoPath). Modelo: '$resolvedModel'",
|
||||
throwable = result.throwable
|
||||
)
|
||||
}
|
||||
)
|
||||
.build(),
|
||||
contentDescription = "Miniatura da foto",
|
||||
modifier = Modifier.fillMaxSize(),
|
||||
|
||||
61
app/src/main/java/com/example/util/DeviceUtils.kt
Normal file
61
app/src/main/java/com/example/util/DeviceUtils.kt
Normal file
@@ -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"
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -517,7 +517,7 @@ class ExampleUnitTest {
|
||||
|
||||
assertEquals("8h", act8h.formattedHoras)
|
||||
assertEquals("12.5h", actDecimal.formattedHoras)
|
||||
assertEquals("0h", actZero.formattedHoras)
|
||||
assertEquals("96h", actZero.formattedHoras)
|
||||
|
||||
val getDisplayDesc = { activity: com.example.data.model.MaintenanceActivity ->
|
||||
if (activity.quantidadeHoras > 0) "${activity.formattedHoras} - ${activity.descricao}" else activity.descricao
|
||||
@@ -527,6 +527,187 @@ class ExampleUnitTest {
|
||||
assertEquals("12.5h - SOLDA EIXO", getDisplayDesc(actDecimal))
|
||||
assertEquals("INSPEÇÃO", getDisplayDesc(actZero))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testResolvePhotoModelRelativePaths() {
|
||||
val resolveFn = { path: String ->
|
||||
com.example.ui.screens.resolvePhotoModel(path)
|
||||
}
|
||||
|
||||
// 1. Standard relative path
|
||||
val stdRel = "photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg"
|
||||
val res1 = resolveFn(stdRel)
|
||||
assertTrue(res1.startsWith("https://firebasestorage.googleapis.com"))
|
||||
assertTrue(res1.contains("photos%2FOS_OS-1503%2FOS_OS-1503_1786022754485.jpg"))
|
||||
|
||||
// 2. Relative path with leading slash
|
||||
val slashRel = "/photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg"
|
||||
val res2 = resolveFn(slashRel)
|
||||
assertTrue(res2.startsWith("https://firebasestorage.googleapis.com"))
|
||||
assertTrue(res2.contains("photos%2FOS_OS-1503%2FOS_OS-1503_1786022754485.jpg"))
|
||||
|
||||
// 3. Encoded relative path
|
||||
val encRel = "photos%2FOS_OS-1503%2FOS_OS-1503_1786022754485.jpg"
|
||||
val res3 = resolveFn(encRel)
|
||||
assertTrue(res3.startsWith("https://firebasestorage.googleapis.com"))
|
||||
assertTrue(res3.contains("photos%2FOS_OS-1503%2FOS_OS-1503_1786022754485.jpg"))
|
||||
|
||||
// 4. Folder relative path without "photos/" prefix
|
||||
val folderRel = "OS_OS-1503/OS_OS-1503_1786022754485.jpg"
|
||||
val res4 = resolveFn(folderRel)
|
||||
assertTrue(res4.startsWith("https://firebasestorage.googleapis.com"))
|
||||
assertTrue(res4.contains("photos%2FOS_OS-1503%2FOS_OS-1503_1786022754485.jpg"))
|
||||
|
||||
// 5. Direct HTTP/HTTPS URL
|
||||
val directUrl = "https://firebasestorage.googleapis.com/v0/b/gestao-parada-os.firebasestorage.app/o/photos%2FOS_OS-1503.jpg?alt=media"
|
||||
assertEquals(directUrl, resolveFn(directUrl))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testPhotoConcatenationPipeSeparator() {
|
||||
val photo1 = "photos/OS_OS-1503/photo1.jpg"
|
||||
val photo2 = "photos/OS_OS-1503/photo2.jpg"
|
||||
val combined = listOf(photo1, photo2).distinct().joinToString("|")
|
||||
assertEquals("photos/OS_OS-1503/photo1.jpg|photos/OS_OS-1503/photo2.jpg", combined)
|
||||
|
||||
val splitBack = combined.split("|").map { it.trim() }
|
||||
assertEquals(2, splitBack.size)
|
||||
assertEquals(photo1, splitBack[0])
|
||||
assertEquals(photo2, splitBack[1])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testGalleryPhotosFromFindingsOnly() {
|
||||
val activityPhoto = "photos/OS_OS-100/activity_photo.jpg"
|
||||
val findingPhoto1 = "photos/OS_OS-100/finding_photo1.jpg"
|
||||
val findingPhoto2 = "photos/OS_OS-100/finding_photo2.jpg"
|
||||
|
||||
val findings = listOf(
|
||||
com.example.data.model.OSFinding(
|
||||
id = "f1", numeroOs = "OS-100", tipo = "OBS", descricao = "Obs 1",
|
||||
responsavel = "Resp", fotoPath = "$findingPhoto1|$findingPhoto2"
|
||||
)
|
||||
)
|
||||
|
||||
// Extract photos EXCLUSIVELY from findings (achados sheet)
|
||||
val extractActivePhotos = { findingsList: List<com.example.data.model.OSFinding> ->
|
||||
val list = mutableListOf<String>()
|
||||
findingsList.forEach { finding ->
|
||||
finding.fotoPath?.split("|")?.forEach { p ->
|
||||
val trimmed = p.trim()
|
||||
if (trimmed.isNotBlank() && !trimmed.contains("_DELETED") && !list.contains(trimmed)) {
|
||||
list.add(trimmed)
|
||||
}
|
||||
}
|
||||
}
|
||||
list
|
||||
}
|
||||
|
||||
val photos = extractActivePhotos(findings)
|
||||
assertEquals(2, photos.size)
|
||||
assertFalse(photos.contains(activityPhoto))
|
||||
assertTrue(photos.contains(findingPhoto1))
|
||||
assertTrue(photos.contains(findingPhoto2))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testFotoFindingTypeAndConsolidation() {
|
||||
val photoFinding = com.example.data.model.OSFinding(
|
||||
id = "f_photo_1",
|
||||
numeroOs = "OS-1136",
|
||||
tipo = "FOTO",
|
||||
descricao = "Foto anexada",
|
||||
responsavel = "Jhony",
|
||||
fotoPath = "photos/OS_OS-1136/photo1.jpg|photos/OS_OS-1136/photo2.jpg"
|
||||
)
|
||||
|
||||
assertEquals("FOTO", photoFinding.tipo)
|
||||
assertEquals("Foto", com.example.data.model.FindingType.fromValue(photoFinding.tipo).displayName)
|
||||
assertTrue(photoFinding.fotoPath!!.contains("photo1.jpg"))
|
||||
assertTrue(photoFinding.fotoPath!!.contains("photo2.jpg"))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testOnDemandPhotoFileNameParsing() {
|
||||
val rawPath = "photos/OS_OS-2108/OS_OS-2108_1786031136680.jpg"
|
||||
val cleanPath = rawPath.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = cleanPath.substringAfterLast("/").substringAfterLast("\\")
|
||||
|
||||
assertEquals("OS_OS-2108_1786031136680.jpg", fileName)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun testAchadosSheetPhotoRegistrationAndCleaning() {
|
||||
val cleanToStoragePath = { pathStr: String?, defaultOsNumber: String ->
|
||||
if (pathStr.isNullOrBlank()) null
|
||||
else {
|
||||
val items = pathStr.split("|").map { item ->
|
||||
val trimmed = item.trim()
|
||||
if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
|
||||
val clean = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
if (clean.contains("/o/")) {
|
||||
clean.substringAfter("/o/").trim('/')
|
||||
} else if (clean.contains("photos/")) {
|
||||
"photos/" + clean.substringAfter("photos/")
|
||||
} else {
|
||||
trimmed
|
||||
}
|
||||
} else if (trimmed.startsWith("/")) {
|
||||
val clean = trimmed.substringBefore("?").substringBefore("#").replace("%2F", "/", ignoreCase = true)
|
||||
val fileName = clean.substringAfterLast("/").substringAfterLast("\\")
|
||||
.removeSuffix("_DELETED").removeSuffix(".jpg_DELETED").replace("_DELETED", "")
|
||||
val osFolder = if (fileName.startsWith("OS_")) {
|
||||
val parts = fileName.split("_")
|
||||
if (parts.size >= 2) "${parts[0]}_${parts[1]}" else "OS_$defaultOsNumber"
|
||||
} else if (defaultOsNumber.isNotBlank()) {
|
||||
val osSanitized = defaultOsNumber.replace("/", "_").replace(" ", "")
|
||||
"OS_$osSanitized"
|
||||
} else {
|
||||
"OS_Geral"
|
||||
}
|
||||
"photos/$osFolder/$fileName"
|
||||
} else if (trimmed.startsWith("OS_") && trimmed.contains("/")) {
|
||||
"photos/$trimmed"
|
||||
} else {
|
||||
trimmed
|
||||
}
|
||||
}
|
||||
items.distinct().joinToString("|").ifEmpty { null }
|
||||
}
|
||||
}
|
||||
|
||||
val filterRemoteOnlyPhotoPaths = { pathStr: String?, defaultOsNumber: String ->
|
||||
if (pathStr.isNullOrBlank()) ""
|
||||
else {
|
||||
val cleaned = cleanToStoragePath(pathStr, defaultOsNumber) ?: ""
|
||||
cleaned.split("|")
|
||||
.map { it.trim() }
|
||||
.filter { it.isNotBlank() && !it.endsWith("_DELETED") && !it.contains("_DELETED") }
|
||||
.distinct()
|
||||
.joinToString("|")
|
||||
}
|
||||
}
|
||||
|
||||
// 1. Absolute local file path before upload (taken on device)
|
||||
val localAbsolutePath = "/data/user/0/com.aistudio.cargillparadaos.xvyzwt/files/os_photos/OS_OS-1503_1786022754485.jpg"
|
||||
val cleaned1 = filterRemoteOnlyPhotoPaths(localAbsolutePath, "OS-1503")
|
||||
assertEquals("photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg", cleaned1)
|
||||
|
||||
// 2. Relative storage path
|
||||
val relPath = "photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg"
|
||||
val cleaned2 = filterRemoteOnlyPhotoPaths(relPath, "OS-1503")
|
||||
assertEquals("photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg", cleaned2)
|
||||
|
||||
// 3. Full Firebase HTTP URL with token
|
||||
val fullUrl = "https://firebasestorage.googleapis.com/v0/b/gestao-parada-os.firebasestorage.app/o/photos%2FOS_OS-1503%2FOS_OS-1503_1786022754485.jpg?alt=media&token=xyz"
|
||||
val cleaned3 = filterRemoteOnlyPhotoPaths(fullUrl, "OS-1503")
|
||||
assertEquals("photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg", cleaned3)
|
||||
|
||||
// 4. Combined pipe separated local and relative photo paths
|
||||
val combinedRaw = "$localAbsolutePath | photos/OS_OS-1503/photo2.jpg"
|
||||
val cleanedCombined = filterRemoteOnlyPhotoPaths(combinedRaw, "OS-1503")
|
||||
assertEquals("photos/OS_OS-1503/OS_OS-1503_1786022754485.jpg|photos/OS_OS-1503/photo2.jpg", cleanedCombined)
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
70
app/src/test/java/com/example/util/DeviceUtilsTest.kt
Normal file
70
app/src/test/java/com/example/util/DeviceUtilsTest.kt
Normal file
@@ -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<Context>()
|
||||
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<Context>()
|
||||
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)
|
||||
}
|
||||
}
|
||||
@@ -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.
|
||||
@@ -115,20 +119,57 @@ Representa o estado atualizado de uma Ordem de Serviço (OS).
|
||||
* `1%` a `99%` -> `ActivityStatus.EM_ANDAMENTO` ("Em andamento")
|
||||
* `100%` -> `ActivityStatus.CONCLUIDO` ("Concluído")
|
||||
|
||||
### 3.2. Entidade: `OSUpdateHistory` (Tabela: `os_update_history`)
|
||||
Armazena a trilha detalhada de atualizações aplicadas a cada OS. É o elemento fundamental para o sincronismo transacional.
|
||||
### 3.3. Entidade: `OSFinding` (Tabela: `os_findings`)
|
||||
Armazena os achados ativos e observações vinculados a cada OS. É a fonte exclusiva para a galeria de fotos do aplicativo.
|
||||
|
||||
| Campo | Tipo | Chave | Descrição |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `id` | `Long` | Primária (Auto) | Identificador sequencial do log. |
|
||||
| `numeroOs` | `String` | - | Relaciona o registro à OS correspondente. |
|
||||
| `timestamp` | `Long` | - | Data/hora exata em que o log foi registrado. |
|
||||
| `percentualAnterior`| `Int` | - | Progresso antes do salvamento da alteração. |
|
||||
| `percentualNovo` | `Int` | - | Novo progresso cadastrado pelo usuário. |
|
||||
| `observacao` | `String?` | - | Observação descritiva inserida no momento da atualização. |
|
||||
| `fotoPath` | `String?` | - | Foto de evidência vinculada a este incremento de progresso. |
|
||||
| `recurso` | `String` | - | Identificação do responsável que executou a modificação. |
|
||||
| `emailEditor` | `String?` | - | Email da conta do Google do usuário editor (auditoria). |
|
||||
| `id` | `String` | Primária | UUID único do achado. |
|
||||
| `numeroOs` | `String` | Indexado | Código da OS associada. |
|
||||
| `tipo` | `String` | Indexado | Tipo: `"FOTO"`, `"OBS"`, `"SEGURANCA"` ou `"MANUTENCAO"`. |
|
||||
| `descricao` | `String` | - | Descrição técnica do achado ou "Foto anexada". |
|
||||
| `timestamp` | `Long` | - | Timestamp UNIX de criação/edição. |
|
||||
| `responsavel` | `String` | - | Nome do responsável pela inclusão. |
|
||||
| `emailEditor` | `String?` | - | E-mail do usuário editor no Google SSO. |
|
||||
| `fotoPath` | `String?` | - | Caminhos de foto concatenados por `\|`. |
|
||||
| `synced` | `Boolean` | Indexado | `true` se sincronizado com a aba `achados` do Google Sheets. |
|
||||
|
||||
> **Tipo Exclusivo FOTO**: Registros de foto possuem `tipo = "FOTO"`. Cada OS possui no máximo 1 linha de `tipo = "FOTO"` com todas as fotos ativas da OS concatenadas por `|`.
|
||||
|
||||
### 3.4. Entidade: `AppLog` (Tabela: `app_logs`)
|
||||
Registra falhas, avisos e exceções de sistema exibidos na tela de **Configurações -> Histórico de Logs de Diagnóstico**.
|
||||
|
||||
| Campo | Tipo | Chave | Descrição |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `id` | `Long` | Primária (Auto) | ID sequencial do log. |
|
||||
| `timestamp` | `Long` | - | Timestamp da ocorrência. |
|
||||
| `level` | `String` | - | `"INFO"`, `"WARN"`, `"ERROR"`. |
|
||||
| `tag` | `String` | - | Tag do componente de origem (ex: `PhotoDisplayError`). |
|
||||
| `message` | `String` | - | Mensagem descritiva. |
|
||||
| `stackTrace` | `String?` | - | Rastreamento detalhado da exceção. |
|
||||
|
||||
### 3.5. Entidade: `SyncConflictLog` (Tabela: `sync_conflict_logs`)
|
||||
Registra desvios e consolidações ocorridas durante a reconciliação de dados com o Google Sheets.
|
||||
|
||||
| Campo | Tipo | Chave | Descrição |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `id` | `Long` | Primária (Auto) | ID do log de conflito. |
|
||||
| `numeroOs` | `String` | - | Código da OS afetada. |
|
||||
| `timestamp` | `Long` | - | Timestamp UNIX da ocorrência. |
|
||||
| `fieldName` | `String` | - | Campo afetado (ex: `percentualExecucao`). |
|
||||
| `localValue` | `String` | - | Valor salvo no aparelho local. |
|
||||
| `remoteValue` | `String` | - | Valor recebido do Google Sheets. |
|
||||
| `resolvedValue` | `String` | - | Valor final consolidado. |
|
||||
| `resolutionStrategy` | `String` | - | Estratégia aplicada (ex: `LWW_LOCAL_WIN`). |
|
||||
|
||||
### 3.6. Entidade: `UserAccess` (Tabela: `user_access`)
|
||||
Gerencia o nível de acesso e permissões das contas de usuário autenticadas no aplicativo.
|
||||
|
||||
| Campo | Tipo | Chave | Descrição |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| `email` | `String` | Primária | E-mail do usuário da conta Google. |
|
||||
| `nivelAcesso` | `String` | - | Permissão: `"ADMIN"`, `"ENCO"` ou `"VISUALIZADOR"`. |
|
||||
| `lastUpdated` | `Long` | - | Timestamp da atualização de acesso. |
|
||||
|
||||
---
|
||||
|
||||
|
||||
@@ -1,127 +1,235 @@
|
||||
# Documentação do Fluxo de Dados e Sincronização do Aplicativo
|
||||
# Documentação do Fluxo de Dados, Salvamento e Sincronização
|
||||
|
||||
Esta documentação resume as conversas e análises técnicas sobre o fluxo de dados, o armazenamento local, o mecanismo de sincronização e o planejamento de um banco de dados remoto baseado no Google Sheets para o aplicativo de manutenção.
|
||||
Esta documentação detalha a arquitetura **offline-first**, a estrutura completa da base de dados local (Room SQLite) e remota (Google Sheets / Firebase Storage), além do fluxo detalhado de salvamento de informações e download de mídias sob demanda.
|
||||
|
||||
---
|
||||
|
||||
## 1. Fluxo de Dados e Armazenamento Atual
|
||||
## 1. Visão Geral da Arquitetura de Dados
|
||||
|
||||
### Como o fluxo está desenhado?
|
||||
O aplicativo adota uma arquitetura **offline-first** (local prioritário) baseada no padrão **MVVM (Model-View-ViewModel)** com **Repository Pattern**:
|
||||
|
||||
1. **Camada de UI (Jetpack Compose):** A tela `MaintenanceDashboardScreen.kt` reage às mudanças de estado expostas pelo `MaintenanceViewModel.kt`.
|
||||
2. **ViewModel (`MaintenanceViewModel.kt`):** Gerencia o fluxo de estados (UI State) utilizando `StateFlow` e lida com ações do usuário (filtragem, atualização de progresso, importação de CSV, disparo de sincronização).
|
||||
3. **Repository (`MaintenanceRepository.kt`):** Atua como a fonte única de verdade (Single Source of Truth), mediando o acesso aos dados entre a UI e a persistência local (e futuramente a remota).
|
||||
4. **Banco de Dados Local (Room - `AppDatabase.kt` / `MaintenanceDao.kt`):** Toda leitura e escrita de dados de ordens de serviço (OS) acontece primeiro no banco local (SQLite) do dispositivo.
|
||||
O aplicativo adota o padrão **MVVM (Model-View-ViewModel)** com **Repository Pattern** e filosofia **Offline-First**:
|
||||
|
||||
```
|
||||
+--------------------------+
|
||||
| UI (Jetpack Compose) |
|
||||
+------------+-------------+
|
||||
| (Observa fluxos / dispara eventos)
|
||||
v
|
||||
+--------------------------+
|
||||
| MaintenanceViewModel |
|
||||
+------------+-------------+
|
||||
| (Dispara lógica de negócio)
|
||||
v
|
||||
+--------------------------+
|
||||
| MaintenanceRepository |
|
||||
+------------+-------------+
|
||||
| (Acessa dados locais)
|
||||
v
|
||||
+--------------------------+
|
||||
| Room Database (Local DB) |
|
||||
+--------------------------+
|
||||
+-------------------------------------------------------+
|
||||
| UI (Jetpack Compose) |
|
||||
| - MaintenanceDashboardScreen |
|
||||
| - EditActivityBottomSheet (Modal da OS) |
|
||||
+--------------------------+----------------------------+
|
||||
| Observa StateFlow / Dispara Ações
|
||||
v
|
||||
+-------------------------------------------------------+
|
||||
| MaintenanceViewModel |
|
||||
| - Gerencia estados da interface e busca |
|
||||
| - Valida níveis de acesso (Google SSO) |
|
||||
+--------------------------+----------------------------+
|
||||
| Executa Lógica de Negócio
|
||||
v
|
||||
+-------------------------------------------------------+
|
||||
| MaintenanceRepository |
|
||||
| - Fonte Única de Verdade (Single Source of Truth) |
|
||||
| - Orquestra gravação local e sync com nuvem |
|
||||
+-------------------+-------------------+---------------+
|
||||
| |
|
||||
Gravação | | Sincronização
|
||||
Local v v Remota
|
||||
+-----------------------+ +---------------------------+
|
||||
| Room DB (SQLite) | | Google Sheets API v4 |
|
||||
| - maintenance_activities | - Aba 'project' (Leitura) |
|
||||
| - os_update_history | | - Aba 'history' (Audit) |
|
||||
| - os_findings | | - Aba 'achados' (Linhas) |
|
||||
| - app_logs | | - Aba 'usage_history' (Rastreamento)|
|
||||
| - sync_conflict_logs | +---------------------------+
|
||||
| - user_access | | Firebase Storage SDK |
|
||||
+-----------------------+ | - Bucket de fotos / mídias|
|
||||
+---------------------------+
|
||||
```
|
||||
|
||||
### Como funciona o armazenamento?
|
||||
O armazenamento é realizado por meio do **Room Database**, que é uma camada de abstração sobre o **SQLite** nativo do Android.
|
||||
* O arquivo do banco de dados local (`maintenance_db`) é salvo no diretório privado do aplicativo dentro do armazenamento interno do aparelho: `/data/data/com.example/databases/maintenance_db`.
|
||||
---
|
||||
|
||||
### Múltiplos usuários conseguem acessar a mesma base de dados diretamente?
|
||||
**Não.** Por ser um banco de dados **local e interno ao dispositivo**, o arquivo SQLite é isolado e privado para a instância do aplicativo instalada naquele smartphone/tablet específico.
|
||||
* Dois usuários rodando o aplicativo em celulares diferentes possuem bases de dados 100% distintas e isoladas.
|
||||
* Para que múltiplos usuários compartilhem e visualizem os mesmos dados de manutenção, é **indispensável** implementar um servidor centralizado (ou um banco de dados na nuvem, como Google Sheets, Firebase, PostgreSQL, etc.) e um fluxo de sincronização bidirecional.
|
||||
## 2. Estrutura Completa da Base de Dados
|
||||
|
||||
O aplicativo utiliza o **Room Database** (`AppDatabase.kt`) sobre o SQLite interno no dispositivo (`/data/data/com.example/databases/maintenance_db`). A estrutura engloba 6 tabelas principais:
|
||||
|
||||
### 2.1. Tabela: `maintenance_activities` (Ordens de Serviço Ativas)
|
||||
Armazena a lista principal das Ordens de Serviço (OS) de manutenção da planta.
|
||||
|
||||
| Campo | Tipo | Chave | Descrição / Regras |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **`numeroOs`** | `String` | Primária | Código de identificação único da OS (ex: `OS-1503`). |
|
||||
| **`descricao`** | `String` | - | Descrição técnica do trabalho de manutenção. |
|
||||
| **`setor`** | `String` | - | Setor industrial da fábrica (ex: `EXTRAÇÃO`, `CALDEIRA`). |
|
||||
| **`equipe`** | `String` | - | Disciplina responsável (ex: `Mecânica`, `Elétrica`). |
|
||||
| **`recurso`** | `String` | - | Nome do inspetor ou encarregado atual. |
|
||||
| **`dataInicio`** | `String` | - | Data planejada/real de início (ex: `01/07/2026`). |
|
||||
| **`dataFim`** | `String` | - | Data planejada de conclusão. |
|
||||
| **`percentualExecucao`** | `Int` | - | Progresso medido de `0` a `100`%. |
|
||||
| **`observacoes`** | `String?` | - | Texto do comentário ou observação mais recente. |
|
||||
| **`fotoPath`** | `String?` | - | Evidência fotográfica vinculada à atividade. |
|
||||
| **`synced`** | `Boolean` | - | `true` se sincronizado com Google Sheets, `false` se pendente. |
|
||||
| **`lastUpdated`** | `Long` | - | Timestamp UNIX (milissegundos) da última edição. |
|
||||
|
||||
---
|
||||
|
||||
## 2. Análise da Sincronização Remota
|
||||
### 2.2. Tabela: `os_findings` (Achados, Fotos e Observações)
|
||||
Armazena os achados ativos associados a cada OS. É a **fonte exclusiva da galeria de fotos** do aplicativo.
|
||||
|
||||
### A sincronização remota está real e funcionalmente implementada?
|
||||
**Sim, a sincronização é REAL e BIDIRECIONAL.** O aplicativo utiliza a **Google Sheets API v4** (`GoogleSheetsSyncService.kt`) para sincronizar a estrutura do projeto e logs de alteração, e o **Firebase Storage SDK** (`FirebaseStorageSyncService.kt`) para upload de fotos das OSs no Firebase Storage.
|
||||
| Campo | Tipo | Chave | Descrição / Regras |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **`id`** | `String` | Primária | Identificador único (UUID). |
|
||||
| **`numeroOs`** | `String` | Indexado | Código da OS relacionada. |
|
||||
| **`tipo`** | `String` | Indexado | Tipo do registro: `"FOTO"`, `"OBS"`, `"SEGURANCA"` ou `"MANUTENCAO"`. |
|
||||
| **`descricao`** | `String` | - | Descrição do achado ou `"Foto anexada"`. |
|
||||
| **`timestamp`** | `Long` | - | Timestamp UNIX da criação/edição. |
|
||||
| **`responsavel`** | `String` | - | Nome do responsável pela gravação. |
|
||||
| **`emailEditor`** | `String?` | - | E-mail da conta do Google do editor. |
|
||||
| **`fotoPath`** | `String?` | - | Caminhos de fotos relativos ou locais concatenados por `\|`. |
|
||||
| **`synced`** | `Boolean` | Indexado | Status de sincronização com a aba `achados` no Google Sheets. |
|
||||
|
||||
### Como o fluxo de sincronização e envio de fotos funciona?
|
||||
1. **Captura, Suporte HEIC e Compactação Local (Offline-First):** As fotos capturadas pela Câmera ou selecionadas da Galeria (nos formatos JPEG, PNG ou HEIC/HEIF) são processadas pelo `ImageCompressor.kt`. O app decodifica a imagem, corrige a orientação EXIF, reduz a resolução para no máximo 1920x1920 px se necessário, e compacta iterativamente para garantir tamanho final **<= 500 KB**. O arquivo resultante é armazenado em `filesDir/os_photos/` e registrado no Room DB.
|
||||
2. **Upload Único para o Firebase Storage:** Durante a sincronização, o `MaintenanceRepository.kt` lê as fotos pendentes locais e aciona o `FirebaseStorageSyncService.kt`. Fotos que já possuem URL remota (`http://` ou `https://`) são ignoradas, garantindo que cada foto seja enviada apenas uma vez. As fotos pendentes são enviadas com trava de segurança de 500KB para a pasta `photos/OS_{numeroOs}/`.
|
||||
3. **URL de Download e Sincronismo com Google Sheets:** O serviço obtém a `downloadUrl` do Firebase Storage, atualizando a Room DB. Ao reconciliar os históricos (`remoteHistory + localHistory`), o sistema prioriza as URLs remotas em relação a caminhos locais desatualizados, refletindo o link público na aba `history` do Google Sheets.
|
||||
4. **Download Inteligente com Re-tentativas Automáticas (Retry & Cache):** Para garantir a exibição de fotos em ambientes de campo com oscilações de rede, o aplicativo utiliza o Coil configurado via `MainApplication.kt` com um `RetryInterceptor` customizado no OkHttp. Caso um download falhe por instabilidade de rede ou erro temporário do servidor, o app executa **até 3 tentativas** com **intervalo aleatório (jitter)** de 300ms a 1000ms. Fotos baixadas com sucesso são gravadas em um cache em disco dedicado de **50 MB** (`cacheDir/image_cache`), permitindo visualização offline instantânea de até ~100 fotos de 500KB.
|
||||
5. **Soft Delete e Consistência Local:** A exclusão de fotos executa um Soft Delete no Firebase Storage (adicionando o sufixo `_DELETED` ao arquivo) e atualiza incrementalmente os registros das tabelas `MaintenanceActivity`, `OSUpdateHistory` e `OSFinding` no Room DB local. A sincronização respeita a marcação `_DELETED` local, impedindo que fotos deletadas reapareçam.
|
||||
6. **Registro de Falhas no Histórico de Logs (`AppLogger`):** Todas as falhas de sincronização, erros de envio no Firebase e falhas no download de fotos (após o limite de 3 re-tentativas) são automaticamente registradas pelo `AppLogger.kt` na tabela `AppLog` do Room DB e ficam acessíveis para consulta na aba **Histórico de Logs** da tela de **Configurações**.
|
||||
7. **Controle de Acesso para Usuários Sem Login:** Usuários não autenticados via conta do Google têm acesso exclusivamente à visualização dos dados. Ações de edição de progresso, alteração de observações, inclusão/edição/exclusão de Achados e exclusão de fotos de campo são bloqueadas na UI e validadas no `MaintenanceViewModel.kt`.
|
||||
|
||||
### Arquivos responsáveis pela conexão, sincronização e exibição de fotos:
|
||||
* **`com.example.MainApplication`:** Configura o `ImageLoaderFactory` do Coil, interceptor OkHttp de retries automáticos com delay aleatório (300-1000ms), cache em memória (25% RAM) e cache em disco (50MB).
|
||||
* **`com.example.util.AppLogger`:** Gerencia o registro persistente de logs de auditoria (WARN, ERROR, INFO) exibidos no painel da tela de Configurações.
|
||||
* **`com.example.util.ImageCompressor`:** Utilitário responsável pelo decodificação de HEIC/HEIF/JPEG/PNG, rotação EXIF e compactação garantida de imagens para até 500KB.
|
||||
* **`com.example.data.remote.FirebaseStorageSyncService`:** Gerencia upload seguro de fotos (com trava de 500KB) e soft delete no Firebase Storage.
|
||||
* **`com.example.data.remote.GoogleSheetsSyncService`:** Gerencia autenticação via Service Account e reconciliação bidirecional com a planilha central do Google Sheets.
|
||||
* **`com.example.data.repository.MaintenanceRepository`:** Centraliza a orquestração do sync, upload de mídias pendentes sem reenvios duplicados, resolução de conflitos (LWW) e soft delete.
|
||||
* **`com.example.ui.viewmodel.MaintenanceViewModel`:** Gerencia os estados de sync na UI, disparos assíncronos, validação de permissões de acesso e callbacks de gerenciamento de fotos.
|
||||
> **Regra do Tipo Exclusivo `FOTO`**: Cada OS possui no máximo **1 registro ativo** de `tipo = "FOTO"` na tabela `os_findings` e na aba `achados` do Google Sheets. Todas as fotos daquela OS são concatenadas na coluna `fotoPath` com o caractere `|` (ex: `photos/OS_OS-1136/photo1.jpg|photos/OS_OS-1136/photo2.jpg`).
|
||||
|
||||
---
|
||||
|
||||
## 3. Estruturação para Integração com Google Sheets (Futuro)
|
||||
### 2.3. Tabela: `os_update_history` (Log de Transações de Auditoria)
|
||||
Registra o histórico cronológico de cada atualização efetuada por usuários em uma OS.
|
||||
|
||||
Se você decidir usar o **Google Sheets** como seu banco de dados remoto centralizado para permitir que múltiplos dispositivos acessem e sincronizem os mesmos dados, você precisará criar uma planilha no Google Drive com **duas abas (worksheets)** principais para refletir a estrutura de dados atual do aplicativo.
|
||||
| Campo | Tipo | Chave | Descrição / Regras |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **`id`** | `Long` | Primária (Auto) | Identificador sequencial do log. |
|
||||
| **`numeroOs`** | `String` | - | Código da OS alterada. |
|
||||
| **`timestamp`** | `Long` | - | Data/hora exata em milissegundos. |
|
||||
| **`percentualAnterior`** | `Int` | - | Progresso antes da edição. |
|
||||
| **`percentualNovo`** | `Int` | - | Progresso informado pelo usuário. |
|
||||
| **`observacao`** | `String?` | - | Texto da observação ou tag de auditoria. |
|
||||
| **`fotoPath`** | `String?` | - | Fotos anexadas nesta atualização. |
|
||||
| **`recurso`** | `String` | - | Responsável pela ação. |
|
||||
| **`emailEditor`** | `String?` | - | E-mail do usuário autenticado no Google. |
|
||||
|
||||
Abaixo está o mapeamento exato de tabelas e colunas que você deve configurar no seu Google Sheets:
|
||||
---
|
||||
|
||||
### Tabela/Aba 1: `activities` (Ordens de Serviço de Manutenção)
|
||||
Esta aba armazenará a lista de todas as ordens de serviço ativas na planta.
|
||||
### 2.4. Tabela: `app_logs` (Histórico de Diagnostic Log)
|
||||
Armazena registros de log e exceções de sistema exibidos na tela de **Configurações -> Histórico de Logs de Diagnóstico**.
|
||||
|
||||
| Nome da Coluna (Cabeçalho da Coluna A, B, C...) | Tipo Sugerido | Descrição / Observações |
|
||||
| :--- | :--- | :--- |
|
||||
| **`numeroOs`** | Texto (Chave Primária) | Ex: `OS-4010`. Deve ser único nesta tabela. |
|
||||
| **`descricao`** | Texto | Descrição detalhada da atividade de manutenção. |
|
||||
| **`setor`** | Texto | Setor da fábrica (ex: `Preparação`, `Extração`, `Caldeira`, `Refinaria`, `Envase`). |
|
||||
| **`equipe`** | Texto | Equipe técnica responsável (ex: `Mecânica`, `Elétrica`, `Confiabilidade`, `Lubrificação`). |
|
||||
| **`responsavel`** | Texto | Nome do técnico ou encarregado responsável pela atividade. |
|
||||
| **`dataInicio`** | Texto ou Data | Data programada para o início (ex: `30/06/2026`). |
|
||||
| **`dataFim`** | Texto ou Data | Data programada para conclusão (ex: `02/07/2026`). |
|
||||
| **`percentualExecucao`** | Número Inteiro | Progresso de execução de 0 a 100. |
|
||||
| **`observacoes`** | Texto (Opcional) | Comentários, notas adicionais ou relato de anomalias encontradas. |
|
||||
| **`fotoPath`** | Texto (URL) | **Importante:** O Sheets não armazena arquivos binários diretamente na célula de forma eficiente. O aplicativo deve fazer upload da foto para um servidor de arquivos ou pasta pública do **Google Drive**, e armazenar o **link direto da imagem (URL)** nesta coluna. |
|
||||
| **`lastUpdated`** | Número Inteiro (Long) | Timestamp Unix em milissegundos (ex: `1783965742000`). Essencial para saber qual dispositivo fez a alteração mais recente e evitar perda de dados. |
|
||||
| Campo | Tipo | Chave | Descrição / Regras |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **`id`** | `Long` | Primária (Auto) | ID do log. |
|
||||
| **`timestamp`** | `Long` | - | Data/hora da ocorrência. |
|
||||
| **`level`** | `String` | - | Nível de severidade: `"INFO"`, `"WARN"`, `"ERROR"`. |
|
||||
| **`tag`** | `String` | - | Tag de origem (ex: `PhotoDisplayError`, `FirebaseStorageSync`). |
|
||||
| **`message`** | `String` | - | Mensagem descritiva da falha ou evento. |
|
||||
| **`stackTrace`** | `String?` | - | Rastreamento da pilha de exceções em falhas. |
|
||||
|
||||
### Tabela/Aba 2: `history` (Histórico de Auditoria das OS e Achados)
|
||||
Esta aba registrará cada alteração feita em qualquer OS (avanços de progresso, observações e alterações/exclusões em Achados), permitindo auditoria detalhada de quem alterou e quando.
|
||||
---
|
||||
|
||||
| Nome da Coluna | Tipo Sugerido | Descrição / Observações |
|
||||
| :--- | :--- | :--- |
|
||||
| **`id`** | Texto ou Número | Identificador único da linha do histórico. |
|
||||
| **`numeroOs`** | Texto | Código da OS atualizada. |
|
||||
| **`timestamp`** | Número Inteiro (Long) | Timestamp Unix em milissegundos. |
|
||||
| **`percentualAnterior`** | Número Inteiro | Progresso anterior da OS. |
|
||||
| **`percentualNovo`** | Número Inteiro | Novo progresso da OS. |
|
||||
| **`observacao`** | Texto (Opcional) | Detalhamento do evento, incluindo marcações auditadas como `"[Achado de Segurança Criado] ..."`, `"[Achado de Manutenção Excluído] ..."`. |
|
||||
| **`fotoPath`** | Texto (URL) | Link da foto anexa. |
|
||||
| **`responsavel`** | Texto | Nome do responsável pela ação. |
|
||||
| **`email_editor`** | Texto | E-mail do usuário autenticado no Google que realizou a ação. |
|
||||
### 2.5. Tabela: `sync_conflict_logs` (Histórico de Conflitos de Sincronização)
|
||||
Registra eventos de desvio ou resolução de conflitos ocorridos na sincronização com o Sheets.
|
||||
|
||||
### Tabela/Aba 3: `achados` (Achados de Segurança, Manutenção e Observações Ativas)
|
||||
Esta aba armazena os registros ativos de Achados de Segurança, Achados de Manutenção e a Última Observação associados a cada OS.
|
||||
| Campo | Tipo | Chave | Descrição |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **`id`** | `Long` | Primária (Auto) | ID do evento de conflito. |
|
||||
| **`numeroOs`** | `String` | - | OS afetada. |
|
||||
| **`timestamp`** | `Long` | - | Timestamp da ocorrência. |
|
||||
| **`fieldName`** | `String` | - | Campo afetado (ex: `percentualExecucao`). |
|
||||
| **`localValue`** | `String` | - | Valor salvo no dispositivo. |
|
||||
| **`remoteValue`** | `String` | - | Valor recebido do Google Sheets. |
|
||||
| **`resolvedValue`**| `String` | - | Valor consolidado aplicado. |
|
||||
| **`resolutionStrategy`** | `String` | - | Estratégia de resolução (ex: `LWW_LOCAL_WIN`). |
|
||||
|
||||
| Nome da Coluna | Tipo Sugerido | Descrição / Observações |
|
||||
| :--- | :--- | :--- |
|
||||
| **`id`** | Texto (UUID) | Identificador exclusivo do achado. |
|
||||
| **`numeroOs`** | Texto | Código da OS relacionada. |
|
||||
| **`tipo`** | Texto | Tipo do registro: `"OBS"`, `"SEGURANCA"` ou `"MANUTENCAO"`. |
|
||||
| **`descricao`** | Texto | Texto descritivo do achado ou observação. |
|
||||
| **`timestamp`** | Número Inteiro (Long) | Data/hora de criação ou alteração. |
|
||||
| **`responsavel`** | Texto | Nome do responsável pelo registro. |
|
||||
| **`email_editor`** | Texto | E-mail do editor autenticado. |
|
||||
| **`fotoPath`** | Texto (URL) | Link de foto vinculada ao achado (opcional). |
|
||||
---
|
||||
|
||||
> **Nota de Exclusão Física**: Quando um usuário exclui um achado ativo no app, o registro é fisicamente removido do Room e da aba `achados` no Google Sheets. No entanto, o evento de exclusão permanece registrado na aba `history` para fins de auditoria inalterável.
|
||||
### 2.6. Tabela: `user_access` (Controle de Acesso de Usuários)
|
||||
Armazena o nível de permissão associado aos e-mails cadastrados.
|
||||
|
||||
| Campo | Tipo | Chave | Descrição |
|
||||
| :--- | :--- | :--- | :--- |
|
||||
| **`email`** | `String` | Primária | E-mail do usuário da conta Google. |
|
||||
| **`nivelAcesso`** | `String` | - | Permissão: `"ADMIN"`, `"ENCO"` (Encarregado) ou `"VISUALIZADOR"`. |
|
||||
| **`lastUpdated`** | `Long` | - | Data de atualização da regra. |
|
||||
|
||||
---
|
||||
|
||||
## 3. Fluxo Completo de Salvamento de Dados
|
||||
|
||||
### 3.1. Passos no Salvamento Local (Offline-First)
|
||||
|
||||
1. **Edição do Usuário na Interface (`EditActivityBottomSheet`)**:
|
||||
- O usuário seleciona o progresso de execução (0-100%), edita observações e captura/anexa novas fotos na galeria da OS.
|
||||
- Aciona o botão **Salvar Atualizações**.
|
||||
|
||||
2. **Processamento e Compactação de Fotos (`ImageCompressor.kt`)**:
|
||||
- As fotos capturadas pela câmera ou selecionadas da galeria (formatos JPEG, PNG, HEIC/HEIF) são processadas.
|
||||
- O aplicativo decodifica a foto, corrige a rotação baseando-se nos metadados EXIF, redimensiona se maior que 1920x1920 px e compacta com garantia de tamanho final **<= 500 KB**.
|
||||
- A foto é salva no armazenamento interno do aplicativo (`filesDir/os_photos/OS_{numeroOs}_{timestamp}.jpg`).
|
||||
|
||||
3. **Gravação Transacional no Room Database (`MaintenanceRepository.kt`)**:
|
||||
- **`maintenance_activities`**: Atualiza o percentual, a observação e altera o status para `synced = false`.
|
||||
- **`os_findings`**: Busca se a OS já possui um achado de `tipo = "FOTO"`.
|
||||
- Se existir: mescla o novo caminho com os caminhos anteriores usando `|` (`mergePreservingDeletedPhotos`), grava `synced = false` e atualiza o registro.
|
||||
- Se não existir: cria um novo `OSFinding` com `tipo = "FOTO"`, `descricao = "Foto anexada"` e `synced = false`.
|
||||
- **`os_findings` (Observação)**: Se houver observação de texto, atualiza/cria o achado de `tipo = "OBS"`.
|
||||
- **`os_update_history`**: Insere uma nova linha de log contendo `percentualAnterior`, `percentualNovo`, `observacao`, `fotoPath`, `recurso` e o `emailEditor`.
|
||||
|
||||
---
|
||||
|
||||
## 4. Fluxo de Sincronização Remota (Google Sheets & Firebase Storage)
|
||||
|
||||
### 4.1. Upload de Mídias ao Firebase Storage (`FirebaseStorageSyncService.kt`)
|
||||
1. Ao iniciar o sync, `uploadPendingPhotos()` varre os registros de achados com arquivos locais no aparelho (`/data/user/0/.../files/os_photos/OS_...jpg`).
|
||||
2. Garante o login silencioso no Firebase Auth via `ensureFirebaseAuth()`.
|
||||
3. Faz o upload seguro da imagem compactada para o bucket na nuvem (`photos/OS_{numeroOs}/OS_{numeroOs}_{timestamp}.jpg`).
|
||||
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 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`.
|
||||
3. **Aba `achados` (Sincronização Bidirecional de Achados e Fotos)**:
|
||||
- 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.
|
||||
|
||||
---
|
||||
|
||||
## 5. Download e Exibição de Fotos Sob Demanda (On-Demand Loading)
|
||||
|
||||
Para evitar consumo desnecessário de dados móveis e garantir o carregamento correto em múltiplos dispositivos ou após a limpeza de dados do aplicativo:
|
||||
|
||||
```
|
||||
[UI / Galeria de Fotos da OS]
|
||||
|
|
||||
v
|
||||
[rememberResolvedPhotoModel(photoPath)]
|
||||
|
|
||||
+---> Arquivo existe em 'filesDir/os_photos/'?
|
||||
| |
|
||||
| +--> (SIM) --> Carrega do disco local instantaneamente
|
||||
| |
|
||||
| +--> (NÃO) --> Dispara download SOB DEMANDA via Coroutine
|
||||
| |
|
||||
| v
|
||||
| [syncService.downloadPhotoFile(path)]
|
||||
| |
|
||||
| v
|
||||
| [ensureFirebaseAuth()]
|
||||
| |
|
||||
| v
|
||||
| [storageRef.getFile(localFile).await()]
|
||||
| |
|
||||
| v
|
||||
| [Salva em filesDir/os_photos/OS_...jpg]
|
||||
| |
|
||||
| v
|
||||
+<----------------------------+
|
||||
|
|
||||
v
|
||||
[Coil renderiza imagem local sem erro HTTP 403]
|
||||
```
|
||||
|
||||
### Principais Benefícios do Download Sob Demanda:
|
||||
- **Zero consumo desnecessário**: Fotos só são baixadas quando o usuário realmente abre a galeria da OS.
|
||||
- **Suporte Múltiplos Celulares**: O segundo celular baixa nativamente a foto via SDK do Firebase Storage e salva no armazenamento local.
|
||||
- **Resiliência e 100% Offline**: Após visualizada uma vez, a foto fica armazenada no disco local do aparelho, permitindo acesso offline em áreas sem cobertura de rede na fábrica.
|
||||
- **Eliminação de Erros HTTP 403**: Ao ler a imagem direto do disco local, elimina-se qualquer rejeição de acesso por falta de token nas requisições HTTP REST.
|
||||
|
||||
Reference in New Issue
Block a user