ML Kit: bibliotecas e ML para Android e iOS

O que é ML Kit: capacidades e arquitetura

ML Kit é um SDK compatível com Firebase para plataformas móveis que fornece 14 APIs de ML para Android e iOS. O ML Kit substituiu o Firebase ML (nome antigo) em 2020 e agora está disponível como SDK independente através do Google Play Services (Android) ou CocoaPods/SPM (iOS). A principal vantagem é que todos os modelos funcionam no dispositivo, garantindo privacidade dos dados e operação offline.

Arquitetura do ML Kit é construída em torno de dois modos: bundled (modelo incorporado no APK/IPA) e downloaded (modelo descarregado através do Google Play Services na primeira chamada). O modo bundled oferece arranque instantâneo mas aumenta o tamanho da aplicação em 5–20 MB. O modo downloaded poupa espaço mas requer internet no primeiro lançamento. O Google recomenda downloaded para APIs não usadas em todos os ecrãs (Object Detection, Pose Detection).

Personalização através de TFLite — o ML Kit permite carregar o seu próprio modelo TensorFlow Lite através da Custom Model API. Isto oferece flexibilidade — use APIs prontas para tarefas padrão e o seu próprio modelo para tarefas específicas. O ML Kit fornece um manipulador Input/Output universal que trabalha com ByteBuffer e FloatArray. Segundo o Google (2025), 40% dos projetos ML Kit combinam APIs prontas e modelos personalizados.

// Configuração do ML Kit Text Recognition (Android)
val recognizer = TextRecognition.getClient(TextRecognizerOptions.DEFAULT_OPTIONS)

val image = InputImage.fromBitmap(bitmap)
recognizer.process(image)
    .addOnSuccessListener { result ->
        for (block in result.textBlocks) {
            Log.d("MLKit", block.text)
        }
    }
    .addOnFailureListener { error ->
        // Erro de processamento
    }

Firebase vs independente — o ML Kit pode ser usado com Firebase (funções Cloud, Analytics, Crashlytics) ou como SDK independente sem Firebase. O modo independente liga-se através do Google Play Services (Android) sem configurar uma conta Firebase. As APIs Cloud estão disponíveis através do Firebase (Cloud Vision, Natural Language) para tarefas que exigem redes neurais no servidor do Google, mas estas funcionalidades são pagas e não on-device.

ML Kit Text Recognition: reconhecimento de texto

ML Kit Text Recognition — API para reconhecimento ótico de caracteres (OCR) em imagens. Suporta dois modos: Latin-based (latim, cirílico, dígitos — 45 idiomas) e Chinese/Japanese/Korean (CJK — idiomas ideográficos). O reconhecimento latino usa o modelo V2 (mais rápido) ou V1 (alta precisão). O V2 oferece 10–30 ms por fotograma, V1 — 50–100 ms.

Capacidades do Text Recognition incluem reconhecimento de texto impresso e manuscrito, deteção de orientação do texto, localização de linhas, palavras e caracteres, determinação do idioma do texto. A API devolve uma estrutura: Text → TextBlock → Line → Element (Word/Symbol). Cada elemento tem bounding box, confiança e texto reconhecido. Segundo o Google (2025), a precisão do ML Kit Text Recognition V2 em escrita latina é de 96%, em cirílico — 91%.

Text Recognition em tempo real — uso com CameraX ou Camera2 para fluxo de vídeo. Crie um ImageAnalysis.Analyzer e passe fotogramas para o ML Kit. Para desempenho, reduza a resolução do fotograma para 480p (640x480) — este é o equilíbrio ideal entre velocidade e precisão. O ML Kit lida automaticamente com a rotação da imagem, mas para velocidade máxima passe a imagem na orientação correta.

// Reconhecimento de texto com CameraX Analyzer
class TextAnalyzer : ImageAnalysis.Analyzer {
    private val recognizer = TextRecognition.getClient(
        TextRecognizerOptions.DEFAULT_OPTIONS
    )

    override fun analyze(image: ImageProxy) {
        val inputImage = InputImage.fromMediaImage(
            image.image, image.imageInfo.rotationDegrees
        )
        recognizer.process(inputImage)
            .addOnSuccessListener { /* text found */ }
            .addOnCompleteListener { image.close() }
    }
}

Otimização do Text Recognition: use ImageDecoder para melhorar o reconhecimento de imagens borradas ou escuras. Para texto impresso — TextRecognizerOptions.DEFAULT_OPTIONS (modelo V2). Para texto manuscrito — TextRecognizerOptions.SCRIPT_LATIN (mais preciso mas mais lento). Nos projetos IT Sectr usamos V2 para reconhecimento de documentos e modelo Latin para cheques e recibos.

ML Kit Face Detection: deteção facial e contornos

ML Kit Face Detection — API para detetar rostos em imagens e vídeo. Deteta o bounding box do rosto, coordenadas dos olhos, nariz, boca, orelhas (468 pontos de contorno) e expressões básicas: sorriso, boca aberta, olhos fechados. Face Detection é uma das APIs mais rápidas do ML Kit: 5–15 ms por fotograma dependendo do número de rostos e pontos de contorno.

Modos de Face Detection: modo contour (468 pontos de contorno facial para sobreposição precisa de máscaras/filtros), modo classification (deteção de sorriso, olhos abertos), modo landmark (pontos chave sem contorno). Os modos são combinados no FaceDetectorOptions. Ativar todos os modos torna a deteção 2–3 vezes mais lenta — use o conjunto mínimo necessário para a sua tarefa.

Face Detection em aplicações AR — com base nos pontos de contorno, o ML Kit constrói uma máscara facial para filtros tipo Snapchat. O ML Kit devolve 468 pontos com coordenadas x, y, z (z = profundidade). Os pontos atualizam 30–60 vezes por segundo em dispositivos modernos. Para sobreposição AR use FaceMeshDetector (versão especializada) — também devolve triângulos de malha para texturização.

// Deteção facial com pontos de contorno
val options = FaceDetectorOptions.Builder()
    .setPerformanceMode(FaceDetectorOptions.PerformanceMode.FAST)
    .setContourMode(FaceDetectorOptions.ContourMode.ALL)
    .setClassificationMode(FaceDetectorOptions.ClassificationMode.ALL)
    .build()
val detector = FaceDetection.getClient(options)

detector.process(inputImage)
    .addOnSuccessListener { faces ->
        faces.forEach { face ->
            val bounds = face.boundingBox
            val smileProb = face.smilingProbability
        }
    }

Limitações do Face Detection: a API não reconhece a quem pertence o rosto (face recognition) — apenas deteta rostos. Para reconhecimento de identidade use FaceNet ou ArcFace num modelo TFLite personalizado. O ML Kit funciona corretamente com rostos em ângulos até 45°, com óculos e máscara parcial. Para ângulos de perfil (90°) a precisão cai para 40–60%.

ML Kit Barcode Scanning: leitura de todos os formatos de código

ML Kit Barcode Scanning — API para ler e descodificar códigos de barras 1D (EAN, UPC, Code 128) e 2D (QR, Data Matrix, PDF417). O Barcode Scanning deteta o código na imagem — ao contrário do ZXing que requer que o código ocupe quase todo o fotograma. O ML Kit deteta códigos de qualquer tamanho e orientação, incluindo múltiplos códigos num único fotograma (modo multi-barcode).

Formatos suportados: EAN-8, EAN-13, UPC-A, UPC-E, Code 39, Code 93, Code 128, ITF, Codabar, QR, Data Matrix, PDF417, Aztec. O ML Kit determina automaticamente o formato — não é necessário especificar o tipo de código. Em produção use setBarcodeFormats() para limitar os formatos suportados — isto acelera a leitura em 30–50% ao excluir algoritmos de descodificação desnecessários.

Barcode Scanning em tempo real — semelhante ao Text Recognition, integração com CameraX. O ML Kit processa fotogramas a até 60 FPS. Para velocidade máxima ative setPerformanceMode(PerformanceMode.FAST). O ML Kit Barcode Scanning é 2–3 vezes mais rápido que o ZXing e mais preciso a detetar códigos borrados ou parcialmente cobertos. Segundo o Google (2025), o ML Kit Barcode Scanning tem 98.5% de precisão em iluminação padrão.

// Leitura de códigos de barras com filtro de formato
val options = BarcodeScannerOptions.Builder()
    .setBarcodeFormats(Barcode.FORMAT_QR_CODE,
        Barcode.FORMAT_EAN_13)
    .build()
val scanner = BarcodeScanning.getClient(options)

scanner.process(inputImage)
    .addOnSuccessListener { barcodes ->
        barcodes.forEach { barcode ->
            val value = barcode.rawValue
            val type = barcode.format
        }
    }

Comparação com ZXing: o ML Kit é mais rápido, preciso e fácil de integrar. O ZXing é open-source, funciona completamente offline, não requer Google Play Services. O ML Kit requer Google Play Services (Android) ou CocoaPods (iOS). Para aplicações que funcionam em dispositivos sem Google (Huawei, Amazon Fire), use ZXing como fallback. Para as restantes — ML Kit, pois oferece melhor UX através da deteção de múltiplos códigos.

Object Detection e Pose Detection no ML Kit

ML Kit Object Detection — API para detetar e rastrear objetos em imagens. Deteta objetos de mais de 1000 categorias (classes ImageNet) — pessoas, animais, veículos, objetos domésticos. O Object Detection funciona em dois modos: single-image (foto única) e streaming (fluxo de vídeo com rastreio). O modo streaming rastreia objetos entre fotogramas, atribuindo a cada um um ID de rastreio único.

Pose Detection — API para determinar a pose humana através de 33 pontos chave (esqueleto): cabeça, ombros, cotovelos, pulsos, ancas, joelhos, pés. Determina coordenadas (x, y, z) e confiança de cada ponto. Pose Detection é usado em rastreadores de fitness (contagem de repetições, verificação de forma), aplicações AR (avatar imita movimentos) e análise desportiva. Velocidade — 10–30 ms por fotograma dependendo do número de pessoas.

Object Tracking — o ML Kit Object Detection com rastreio entre fotogramas usa um rastreador baseado em Optical Flow. Quando um objeto é detetado, o rastreador segue-o sem necessidade de nova deteção, poupando CPU/GPU. Se o rastreador perder o objeto (movimento rápido, oclusão), o ML Kit reinicia a deteção. Segundo o Google (2025), o rastreador mantém o objeto em 95% dos fotogramas a velocidades até 30 km/h.

// Deteção de pose (esqueleto humano)
val poseDetector = PoseDetection.getClient(
    PoseDetectorOptions.Builder()
        .setDetectorMode(PoseDetectorOptions.STREAM_MODE)
        .build()
)

poseDetector.process(inputImage)
    .addOnSuccessListener { pose ->
        pose.allPoseLandmarks.forEach { landmark ->
            val type = landmark.landmarkType // OMBRO_ESQUERDO, COTOVELO_DIREITO...
            val position = landmark.position3D
        }
    }

Selfie Segmentation — API para segmentar uma pessoa da imagem (separar pessoa do fundo). Devolve uma máscara de confiança para cada pixel. Selfie Segmentation é usado para desfocar ou substituir fundos em videochamadas, editores de foto e aplicações AR. A máscara é devolvida como UInt8Array do tamanho da imagem original — cada pixel contém um valor de 0.0 (fundo) a 1.0 (pessoa).

Modelos TFLite personalizados no ML Kit

Custom Model API — a capacidade de carregar e executar os seus próprios modelos TensorFlow Lite através da interface do ML Kit. O ML Kit fornece uma API Input/Output unificada: ByteBuffer como entrada, FloatArray/TensorImage como saída. Isto permite aproveitar as vantagens do ML Kit (gestão de modelos, processamento de imagem, integração com CameraX) com modelos personalizados para reconhecimento facial, classificação de objetos, PLN e mais.

Carregar um modelo — coloque o ficheiro .tflite em assets/ (Android) ou bundle (iOS) e carregue através de CustomModelDownloadConditions ou Firebase Model Manager. Para descarregar modelos grandes (5+ MB) use condições de descarga: Wi-Fi, carregado, em segundo plano. O Google recomenda descarregar o modelo no primeiro lançamento da aplicação, não no momento do primeiro uso.

// A carregar modelo TFLite personalizado
val conditions = CustomModelDownloadConditions.Builder()
    .requireWifi()
    .build()
val remoteModel = CustomRemoteModel.Builder("my_model")
    .setRemoteModelName("my_model_v2")
    .build()

remoteModel.download(conditions)
    .addOnSuccessListener { /* model ready */ }
    .addOnFailureListener {
        // Usar modelo incluído de assets
    }

Otimização de modelos personalizados: use TFLite Converter com compatibilidade de delegate. Para máximo desempenho quantize o modelo (INT8) — isto reduz o tamanho do modelo em 4x e acelera a inferência em 2–3x através do XNNPACK Delegate. O ML Kit Custom Model API suporta Dynamic Shape (batch = 1), Image Input (UInt8, Float32) e Tensor Output.