From 54a1fe669a8be98baf1e58005fb0479298701af2 Mon Sep 17 00:00:00 2001 From: Jhony Cesar Date: Wed, 5 Aug 2026 15:05:13 -0400 Subject: [PATCH] feat: implement image compression utility and integrate it into maintenance repository sync logic --- .../data/remote/FirebaseStorageSyncService.kt | 7 +- .../data/repository/MaintenanceRepository.kt | 58 ++++- .../java/com/example/util/ImageCompressor.kt | 241 ++++++++++++++++++ .../com/example/util/ImageCompressorTest.kt | 71 ++++++ .../arquitetura/arquitetura_do_sistema.md | 3 +- .../design/descricao_layout_e_recursos.md | 6 +- .../fluxo_de_dados_e_sincronizacao.md | 11 +- 7 files changed, 374 insertions(+), 23 deletions(-) create mode 100644 app/src/main/java/com/example/util/ImageCompressor.kt create mode 100644 app/src/test/java/com/example/util/ImageCompressorTest.kt diff --git a/app/src/main/java/com/example/data/remote/FirebaseStorageSyncService.kt b/app/src/main/java/com/example/data/remote/FirebaseStorageSyncService.kt index f53bd3e..04449f9 100644 --- a/app/src/main/java/com/example/data/remote/FirebaseStorageSyncService.kt +++ b/app/src/main/java/com/example/data/remote/FirebaseStorageSyncService.kt @@ -60,7 +60,12 @@ class FirebaseStorageSyncService( } try { - val fileUri = Uri.fromFile(photoFile) + val fileToUpload = if (photoFile.length() > 500 * 1024L) { + com.example.util.ImageCompressor.compressImageFile(photoFile, 500 * 1024L) + } else { + photoFile + } + val fileUri = Uri.fromFile(fileToUpload) photoRef.putFile(fileUri).await() val downloadUrl = photoRef.downloadUrl.await().toString() 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 3fad582..9845628 100644 --- a/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt +++ b/app/src/main/java/com/example/data/repository/MaintenanceRepository.kt @@ -264,10 +264,29 @@ class MaintenanceRepository( // 3. Fetch local history logs from Room DB val localHistory = dao.getAllHistoryList() - // 4. Reconcile and merge all history logs - val allHistories = (remoteHistory + localHistory) - .distinctBy { "${it.numeroOs}_${it.timestamp}" } - .sortedByDescending { it.timestamp } + // 4. Reconcile and merge all history logs prioritizing entries with remote URLs (http/https) + val localHistoryMap = localHistory.associateBy { "${it.numeroOs}_${it.timestamp}" } + val remoteHistoryMap = remoteHistory.associateBy { "${it.numeroOs}_${it.timestamp}" } + val allKeys = (localHistoryMap.keys + remoteHistoryMap.keys).toSet() + + val allHistories = allKeys.map { key -> + val localItem = localHistoryMap[key] + val remoteItem = remoteHistoryMap[key] + + when { + localItem != null && remoteItem != null -> { + val localHasUrl = localItem.fotoPath?.let { it.contains("http://") || it.contains("https://") } == true + val remoteHasUrl = remoteItem.fotoPath?.let { it.contains("http://") || it.contains("https://") } == true + if (localHasUrl && !remoteHasUrl) { + localItem + } else { + remoteItem + } + } + localItem != null -> localItem + else -> remoteItem!! + } + }.sortedByDescending { it.timestamp } // 5. Update local Room DB with any remote history logs we don't have val localHistoryKeys = localHistory.map { "${it.numeroOs}_${it.timestamp}" }.toSet() @@ -282,17 +301,29 @@ class MaintenanceRepository( // 6. For each remote activity, determine its current state based on the latest history log val reconciledActivities = remoteActivities.map { activity -> val osHistory = allHistories.filter { it.numeroOs == activity.numeroOs } + val localAct = dao.getActivityByOsOneShot(activity.numeroOs) + val localFotoPath = localAct?.fotoPath + val localHasRemoteUrl = localFotoPath?.let { it.contains("http://") || it.contains("https://") } == true + if (osHistory.isNotEmpty()) { val latestLog = osHistory.first() // sorted descending, so first is latest + val finalFotoPath = if (localHasRemoteUrl && latestLog.fotoPath?.startsWith("http") != true) { + localFotoPath + } else { + latestLog.fotoPath ?: activity.fotoPath + } activity.copy( percentualExecucao = latestLog.percentualNovo, observacoes = latestLog.observacao ?: activity.observacoes, - fotoPath = latestLog.fotoPath ?: activity.fotoPath, + fotoPath = finalFotoPath, synced = true, lastUpdated = latestLog.timestamp ) } else { - activity.copy(synced = true) + activity.copy( + fotoPath = if (localHasRemoteUrl) localFotoPath else activity.fotoPath, + synced = true + ) } } @@ -452,12 +483,12 @@ class MaintenanceRepository( val sanitizedOs = osNumber.replace("/", "_").replace(" ", "") val targetFile = java.io.File(photosDir, "OS_${sanitizedOs}_${timestamp}.jpg") - context.contentResolver.openInputStream(uri)?.use { input -> - targetFile.outputStream().use { output -> - input.copyTo(output) - } - } - return targetFile.absolutePath + return com.example.util.ImageCompressor.compressUriToJpegFile( + context = context, + uri = uri, + targetFile = targetFile, + maxSizeBytes = 500 * 1024L + ).absolutePath } fun createTempCameraPhotoUri(osNumber: String): Pair { @@ -486,7 +517,8 @@ class MaintenanceRepository( val file = java.io.File(trimmed) if (file.exists()) { try { - val result = firebaseStorageSyncService.uploadPhoto(file, history.numeroOs) + val compressedFile = com.example.util.ImageCompressor.compressImageFile(file, 500 * 1024L) + val result = firebaseStorageSyncService.uploadPhoto(compressedFile, history.numeroOs) changed = true result.downloadUrl } catch (e: Exception) { diff --git a/app/src/main/java/com/example/util/ImageCompressor.kt b/app/src/main/java/com/example/util/ImageCompressor.kt new file mode 100644 index 0000000..1e45a1b --- /dev/null +++ b/app/src/main/java/com/example/util/ImageCompressor.kt @@ -0,0 +1,241 @@ +package com.example.util + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.BitmapFactory +import android.graphics.Matrix +import android.net.Uri +import android.os.Build +import android.util.Log +import android.media.ExifInterface +import java.io.ByteArrayOutputStream +import java.io.File +import java.io.FileOutputStream +import java.io.InputStream + +object ImageCompressor { + + private const val TAG = "ImageCompressor" + private const val MAX_DIMENSION = 1920 + private const val DEFAULT_MAX_SIZE_BYTES = 500 * 1024L // 500 KB + + /** + * Compresses an image from a [Uri] (supporting JPEG, PNG, HEIC/HEIF, WEBP) + * and saves it to [targetFile] as JPEG guaranteed to be <= [maxSizeBytes]. + */ + fun compressUriToJpegFile( + context: Context, + uri: Uri, + targetFile: File, + maxSizeBytes: Long = DEFAULT_MAX_SIZE_BYTES + ): File { + return try { + val inputStream = context.contentResolver.openInputStream(uri) + ?: throw IllegalArgumentException("Não foi possível abrir o Uri: $uri") + + // Read orientation if available + val orientation = getOrientationFromUri(context, uri) + + val bitmap = decodeBitmapFromStream(context, uri, inputStream, MAX_DIMENSION, MAX_DIMENSION) + ?: throw IllegalStateException("Falha ao decodificar imagem a partir de Uri: $uri") + + val rotatedBitmap = rotateBitmap(bitmap, orientation) + compressBitmapToFile(rotatedBitmap, targetFile, maxSizeBytes) + } catch (e: Exception) { + Log.e(TAG, "Erro ao comprimir imagem a partir de Uri $uri: ${e.message}", e) + // Fallback: try direct stream copy if decode fails + try { + context.contentResolver.openInputStream(uri)?.use { input -> + targetFile.outputStream().use { output -> + input.copyTo(output) + } + } + } catch (fallbackEx: Exception) { + Log.e(TAG, "Erro no fallback de cópia de imagem: ${fallbackEx.message}", fallbackEx) + } + targetFile + } + } + + /** + * Compresses an existing local [inputFile] (supporting JPEG, PNG, HEIC/HEIF) + * so that it is guaranteed to be <= [maxSizeBytes]. Returns the compressed file (or original if already <= maxSizeBytes). + */ + fun compressImageFile( + inputFile: File, + maxSizeBytes: Long = DEFAULT_MAX_SIZE_BYTES + ): File { + if (!inputFile.exists()) return inputFile + + // If file is already smaller than maxSizeBytes and is a standard JPG, return as is + if (inputFile.length() <= maxSizeBytes && inputFile.extension.lowercase() in listOf("jpg", "jpeg")) { + return inputFile + } + + return try { + val orientation = getOrientationFromFile(inputFile) + val options = BitmapFactory.Options().apply { + inJustDecodeBounds = true + } + BitmapFactory.decodeFile(inputFile.absolutePath, options) + + val sampleSize = calculateInSampleSize(options, MAX_DIMENSION, MAX_DIMENSION) + val decodeOptions = BitmapFactory.Options().apply { + inSampleSize = sampleSize + } + + val decodedBitmap = BitmapFactory.decodeFile(inputFile.absolutePath, decodeOptions) + ?: return inputFile + + val rotatedBitmap = rotateBitmap(decodedBitmap, orientation) + val compressedFile = compressBitmapToFile(rotatedBitmap, inputFile, maxSizeBytes) + compressedFile + } catch (e: Exception) { + Log.e(TAG, "Erro ao comprimir arquivo de imagem ${inputFile.name}: ${e.message}", e) + inputFile + } + } + + private fun decodeBitmapFromStream( + context: Context, + uri: Uri, + inputStream: InputStream, + reqWidth: Int, + reqHeight: Int + ): Bitmap? { + return try { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) { + val source = android.graphics.ImageDecoder.createSource(context.contentResolver, uri) + android.graphics.ImageDecoder.decodeBitmap(source) { decoder, info, _ -> + val width = info.size.width + val height = info.size.height + if (width > reqWidth || height > reqHeight) { + val scale = Math.min(reqWidth.toFloat() / width, reqHeight.toFloat() / height) + decoder.setTargetSize((width * scale).toInt(), (height * scale).toInt()) + } + decoder.allocator = android.graphics.ImageDecoder.ALLOCATOR_SOFTWARE + } + } else { + val bytes = inputStream.readBytes() + val options = BitmapFactory.Options().apply { + inJustDecodeBounds = true + } + BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options) + options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight) + options.inJustDecodeBounds = false + BitmapFactory.decodeByteArray(bytes, 0, bytes.size, options) + } + } catch (e: Exception) { + Log.w(TAG, "Falha na decodificação primária de bitmap: ${e.message}. Tentando decodeStream nativo.") + BitmapFactory.decodeStream(inputStream) + } finally { + try { inputStream.close() } catch (_: Exception) {} + } + } + + private fun compressBitmapToFile( + originalBitmap: Bitmap, + targetFile: File, + maxSizeBytes: Long + ): File { + var currentBitmap = originalBitmap + var quality = 85 + var stream = ByteArrayOutputStream() + + currentBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream) + + // Iterative reduction loop + while (stream.size() > maxSizeBytes && quality > 20) { + stream.reset() + quality -= 10 + currentBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream) + } + + // If quality reached lower limit and still larger than maxSizeBytes, scale dimensions down + while (stream.size() > maxSizeBytes && currentBitmap.width > 300 && currentBitmap.height > 300) { + stream.reset() + val newWidth = (currentBitmap.width * 0.85).toInt() + val newHeight = (currentBitmap.height * 0.85).toInt() + val scaledBitmap = Bitmap.createScaledBitmap(currentBitmap, newWidth, newHeight, true) + if (currentBitmap != originalBitmap) { + currentBitmap.recycle() + } + currentBitmap = scaledBitmap + quality = 70 + currentBitmap.compress(Bitmap.CompressFormat.JPEG, quality, stream) + } + + FileOutputStream(targetFile).use { out -> + out.write(stream.toByteArray()) + } + + if (currentBitmap != originalBitmap) { + currentBitmap.recycle() + } + originalBitmap.recycle() + + Log.d(TAG, "Foto compactada com sucesso: ${targetFile.name}, tamanho final: ${targetFile.length() / 1024} KB") + return targetFile + } + + private fun getOrientationFromFile(file: File): Int { + return try { + val exif = ExifInterface(file.absolutePath) + exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED) + } catch (e: Exception) { + ExifInterface.ORIENTATION_UNDEFINED + } + } + + private fun getOrientationFromUri(context: Context, uri: Uri): Int { + return try { + context.contentResolver.openInputStream(uri)?.use { stream -> + val exif = ExifInterface(stream) + exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_UNDEFINED) + } ?: ExifInterface.ORIENTATION_UNDEFINED + } catch (e: Exception) { + ExifInterface.ORIENTATION_UNDEFINED + } + } + + private fun rotateBitmap(bitmap: Bitmap, orientation: Int): Bitmap { + val matrix = Matrix() + when (orientation) { + ExifInterface.ORIENTATION_ROTATE_90 -> matrix.postRotate(90f) + ExifInterface.ORIENTATION_ROTATE_180 -> matrix.postRotate(180f) + ExifInterface.ORIENTATION_ROTATE_270 -> matrix.postRotate(270f) + ExifInterface.ORIENTATION_FLIP_HORIZONTAL -> matrix.postScale(-1f, 1f) + ExifInterface.ORIENTATION_FLIP_VERTICAL -> matrix.postScale(1f, -1f) + else -> return bitmap + } + return try { + val rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true) + if (rotated != bitmap) { + bitmap.recycle() + } + rotated + } catch (e: OutOfMemoryError) { + Log.e(TAG, "OOM ao rotacionar bitmap: ${e.message}") + bitmap + } + } + + private fun calculateInSampleSize( + options: BitmapFactory.Options, + reqWidth: Int, + reqHeight: Int + ): Int { + val (height: Int, width: Int) = options.run { outHeight to outWidth } + var inSampleSize = 1 + + if (height > reqHeight || width > reqWidth) { + val halfHeight: Int = height / 2 + val halfWidth: Int = width / 2 + + while (halfHeight / inSampleSize >= reqHeight && halfWidth / inSampleSize >= reqWidth) { + inSampleSize *= 2 + } + } + return inSampleSize + } +} diff --git a/app/src/test/java/com/example/util/ImageCompressorTest.kt b/app/src/test/java/com/example/util/ImageCompressorTest.kt new file mode 100644 index 0000000..de1c95c --- /dev/null +++ b/app/src/test/java/com/example/util/ImageCompressorTest.kt @@ -0,0 +1,71 @@ +package com.example.util + +import android.content.Context +import android.graphics.Bitmap +import android.graphics.Color +import android.net.Uri +import androidx.test.core.app.ApplicationProvider +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.rules.TemporaryFolder +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import java.io.File +import java.io.FileOutputStream + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [34]) +class ImageCompressorTest { + + @get:Rule + val tempFolder = TemporaryFolder() + + @Test + fun `compressImageFile should compress large bitmap file to under 500KB`() { + val largeFile = tempFolder.newFile("large_test_image.jpg") + + // Create a large 3000x3000 bitmap + val bitmap = Bitmap.createBitmap(3000, 3000, Bitmap.Config.ARGB_8888) + val canvas = android.graphics.Canvas(bitmap) + canvas.drawColor(Color.BLUE) + + FileOutputStream(largeFile).use { out -> + bitmap.compress(Bitmap.CompressFormat.JPEG, 100, out) + } + + val compressedFile = ImageCompressor.compressImageFile(largeFile, 500 * 1024L) + + assertTrue("File should exist", compressedFile.exists()) + assertTrue( + "Compressed file size (${compressedFile.length() / 1024} KB) should be <= 500 KB", + compressedFile.length() <= 500 * 1024L + ) + } + + @Test + fun `compressUriToJpegFile should compress uri content to under 500KB`() { + val context = ApplicationProvider.getApplicationContext() + val sourceFile = tempFolder.newFile("source_image.png") + + val bitmap = Bitmap.createBitmap(2500, 2500, Bitmap.Config.ARGB_8888) + val canvas = android.graphics.Canvas(bitmap) + canvas.drawColor(Color.RED) + + FileOutputStream(sourceFile).use { out -> + bitmap.compress(Bitmap.CompressFormat.PNG, 100, out) + } + + val uri = Uri.fromFile(sourceFile) + val targetFile = tempFolder.newFile("target_compressed.jpg") + + val resultFile = ImageCompressor.compressUriToJpegFile(context, uri, targetFile, 500 * 1024L) + + assertTrue("Target file should exist", resultFile.exists()) + assertTrue( + "Target file size (${resultFile.length() / 1024} KB) should be <= 500 KB", + resultFile.length() <= 500 * 1024L + ) + } +} diff --git a/documentacao/arquitetura/arquitetura_do_sistema.md b/documentacao/arquitetura/arquitetura_do_sistema.md index 6cd97bc..804736c 100644 --- a/documentacao/arquitetura/arquitetura_do_sistema.md +++ b/documentacao/arquitetura/arquitetura_do_sistema.md @@ -166,7 +166,8 @@ A gestão e armazenamento de arquivos de mídia (fotos das ordens de serviço) * **Projeto e Bucket Firebase:** `gestao-parada-os.firebasestorage.app` (autenticado com Google Sign-in / Firebase SDK). * **Pasta Destino na Nuvem:** Diretórios organizados por OS (`photos/OS_{numeroOs}/`). -* **Estratégia Offline-First & Múltiplas Fotos:** As fotos capturadas/selecionadas são salvas em armazenamento local privado (`filesDir/os_photos/`). O aplicativo suporta o anexo de **múltiplas fotos por atualização**, armazenando os caminhos/URLs concatenados pelo delimitador `|` (ex: `url1|url2|url3`), garantindo compatibilidade total com a Room DB e o Google Sheets. Durante a sincronização, o app realiza o upload assíncrono para o Firebase Storage e obtém a URL pública/assinada de download (`downloadUrl`). +* **Processamento, HEIC e Compressão (`ImageCompressor.kt`):** Fotos capturadas pela câmera ou selecionadas da galeria (incluindo o formato HEIC/HEIF) passam pelo `ImageCompressor.kt`. O app decodifica a imagem, corrige a orientação EXIF, limita a resolução para até 1920x1920 px e compacta iterativamente para garantir tamanho final **<= 500 KB** por foto antes do armazenamento local e upload. +* **Estratégia Offline-First, Múltiplas Fotos & Envio Único:** As fotos são salvas em armazenamento local privado (`filesDir/os_photos/`). O aplicativo suporta o anexo de **múltiplas fotos por atualização**, concatenadas pelo delimitador `|` (ex: `url1|url2|url3`). Durante a sincronização, o app realiza o upload assíncrono para o Firebase Storage e obtém a URL pública de download (`downloadUrl`). Fotos que já possuem URL remota são ignoradas, evitando reenvios duplicados. * **Regra de Exclusão (Soft Delete):** A exclusão de uma foto executa um Soft Delete no Firebase Storage, renomeando o arquivo na mesma pasta para incluir o sufixo `_DELETED` (ex: `OS_1001_1722780000_DELETED.jpg`), mantendo a rastreabilidade enquanto atualiza os registros da aplicação. ### 4.4. Sistema de Registro e Histórico de Logs (`AppLogger.kt`) diff --git a/documentacao/design/descricao_layout_e_recursos.md b/documentacao/design/descricao_layout_e_recursos.md index 50bb11e..30b9794 100644 --- a/documentacao/design/descricao_layout_e_recursos.md +++ b/documentacao/design/descricao_layout_e_recursos.md @@ -111,8 +111,8 @@ Para expandir o aplicativo de sua estrutura atual de tela única ("Single Screen * *Recurso:* Console para forçar limpezas na base SQLite ou exportar backup do banco de dados local. ### 3.2. Proposta de Recursos Técnicos para Implementação Visando Complexidade -1. **Câmera Nativa com Upload Real (Firebase Storage):** - * Substituir o simulador de fotos estáticas (`mockPhotos`) por captura real utilizando câmera nativa do Android. - * A imagem tirada é armazenada localmente e enviada ao Firebase Storage (`photos/OS_{numeroOs}/`) por meio do SDK assíncrono. A URL de download obtida é gravada no campo `fotoPath` no banco local e subida para a aba `history` do Sheets. +1. **Câmera Nativa com Upload Real (Firebase Storage), Suporte a HEIC e Compactação (<= 500KB):** + * Substituir o simulador de fotos estáticas (`mockPhotos`) por captura real utilizando câmera nativa do Android ou seleção de Galeria (com suporte nativo a HEIC, JPEG e PNG). + * As imagens são compactadas pelo `ImageCompressor.kt` para no máximo **500 KB** mantendo excelente qualidade e correção automática de rotação EXIF. As imagens são enviadas de forma única ao Firebase Storage (`photos/OS_{numeroOs}/`) via SDK assíncrono. A URL de download obtida é gravada no campo `fotoPath` no banco local e sincronizada na aba `history` do Sheets. 2. **Sincronização em Segundo Plano Resiliente (WorkManager):** * Substituir o clique manual em "Sincronizar" por um agendador automático em segundo plano que detecta conectividade Wi-Fi e envia logs pendentes sem travar ou exigir ação do inspetor. diff --git a/documentacao/fluxo_de_dados_e_sincronizacao.md b/documentacao/fluxo_de_dados_e_sincronizacao.md index 068680e..2438b40 100644 --- a/documentacao/fluxo_de_dados_e_sincronizacao.md +++ b/documentacao/fluxo_de_dados_e_sincronizacao.md @@ -52,15 +52,16 @@ O armazenamento é realizado por meio do **Room Database**, que é uma camada de **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. ### Como o fluxo de sincronização e envio de fotos funciona? -1. **Captura e Armazenamento Local (Offline-First):** As fotos capturadas pela Câmera ou selecionadas da Galeria são armazenadas em `filesDir/os_photos/` e registradas na Room DB. -2. **Upload para o Firebase Storage:** No momento do sync, o `MaintenanceRepository.kt` lê as fotos pendentes e aciona o `FirebaseStorageSyncService.kt`, que faz o upload seguro para o Firebase Storage na 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 e a aba `history` do Google Sheets. +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. **Soft Delete:** A exclusão de fotos no app executa um Soft Delete no Firebase Storage (renomeando a referência no mesmo diretório adicionando o sufixo `_DELETED`) e atualiza os registros locais. ### Arquivos responsáveis pela conexão e sincronização: -* **`com.example.data.remote.FirebaseStorageSyncService`:** Gerencia upload seguro de fotos e soft delete no Firebase Storage. +* **`com.example.util.ImageCompressor`:** Utilitário responsável pelo decodecimento 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, resolução de conflitos (LWW) e soft delete. +* **`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 e callbacks de gerenciamento de fotos. ---