# Android **BCC Finger** é uma biblioteca Android destinada a ser integrada em uma aplicação Android. Essencialmente, ela abrirá a câmera e capturará impressões digitais para fins biométricos. Este Manual está atualizado para a versão 5.2.0 do BCC Finger Photo Android. ## Requisitos **BCC Finger Photo** é uma biblioteca Android e deve ser importada para o projeto de destino. * Versão mínima do Android: *Android 6.0 (SDK 23), "Marshmallow"*. * Versão mínima do Kotlin: 1.6.0. * O dispositivo móvel deve ter uma câmera. * O aplicativo nativo deve ser desenvolvido com tecnologia Android. * Ambiente de desenvolvimento: é necessário um IDE Android, como [Android Studio](https://developer.android.com/studio) (recomendado) * Dependências externas adicionais: * [Lottie](https://lottiefiles.com), versão 3.0.0 ## Instalação ### Adicionando a Biblioteca ao Projeto do App A biblioteca BCC Finger Photo requer JNA para Android. Ambos são fornecidos pela Griaule como **.aar** arquivos. Para adicionar as bibliotecas, vá até o diretório do seu projeto, abra a pasta **app** e crie os seguintes diretórios `libs/bccfinger`. Em seguida, adicione as dependências `jna.aar` e `bccfingerphotolib-release.aar` . A estrutura de pastas deve ser semelhante a esta: ![](/files/ddad569d49d4a0a1386f350ac3b7896211363cf6) O próximo passo é tornar esses arquivos visíveis para as dependências do gradle. Para isso, adicione a seguinte linha no arquivo `build.gradle (:app)` no objeto dependencies: ```groovy dependencies { [...] implementation fileTree(dir: 'libs/bccfinger', include: ['*.aar']) } ``` Dentro do `build.gradle (:app)` arquivo, também adicione as opções de compilação e defina Source Compatibility e Target Compatibility para usar Java 17: ```groovy compileOptions { sourceCompatibility JavaVersion.VERSION_17 targetCompatibility JavaVersion.VERSION_17 } ``` ### Definindo Todas as Dependências Faça as alterações abaixo no arquivo `android/app/build.gradle`: ```groovy dependencies { // SUAS DEPENDÊNCIAS // // ... // BCC FINGER // implementation fileTree(dir: 'libs/bccfinger', include:['*.aar']) // ANDROIDX // implementation 'androidx.appcompat:appcompat:1.7.0' implementation 'androidx.constraintlayout:constraintlayout:2.1.4' // LOTTIE // implementation 'com.airbnb.android:lottie:3.0.0' // CAMERA X // def camerax_version = "1.5.1" // Biblioteca core do CameraX usando implementação camera2 implementation "androidx.camera:camera-camera2:$camerax_version" // Biblioteca Lifecycle do CameraX implementation "androidx.camera:camera-lifecycle:$camerax_version" // Classe View do CameraX implementation "androidx.camera:camera-view:$camerax_version" // MATERIAL implementation 'com.google.android.material:material:1.6.1' } ``` ## Uso ### Parâmetros e Construtor Um exemplo simples de uso da biblioteca é mostrado abaixo: ```kotlin // Para inicializar uma nova captura BCCFingerBuilder(this, this).initializeCapture() ``` A `BCCFingerBuilder` classe recebe os seguintes parâmetros: * `context: Context` - O contexto da aplicação. * `delegate: BCCFingerDelegate` - Interface responsável por notificar eventos de captura (por exemplo, falha ou sucesso). A `BCCFingerBuilder` classe é responsável por lidar com a configuração de uso do `BCCFinger`. Os seguintes parâmetros são aceitos para configurar a captura biométrica e o comportamento do software: * `setSkipCaptureOption(enable: Boolean)` - Habilita a opção de pular a captura atual. * `setDebugMode(enable: Boolean)` - Habilita o modo de depuração. * `buildCaptureType(type: BCCFingerPhotoCaptureType)` - Define o tipo de captura da impressão digital. As opções são: ```kotlin enum class BCCFingerPhotoCaptureType { BOTH_HANDS, ONLY_LEFT_HAND, ONLY_RIGHT_HAND, THUMBS, LEFT_THUMB, RIGHT_THUMB, FULL_HANDS, FULL_LEFT_HAND, FULL_RIGHT_HAND; } ``` * `BOTH_HANDS` - Ambas as mãos sem os polegares. * `ONLY_LEFT_HAND` - Apenas a mão esquerda, sem os polegares. * `ONLY_RIGHT_HAND` - Apenas a mão direita, sem os polegares. * `THUMBS` - Ambos os polegares. * `LEFT_THUMB` - Apenas o polegar esquerdo. * `RIGHT_THUMB` - Apenas o polegar direito. * `FULL_HANDS` - Ambas as mãos com os polegares. * `FULL_LEFT_HAND` - Apenas a mão esquerda, com o polegar. * `FULL_RIGHT_HAND` - Apenas a mão direita, com o polegar. * `buildBeginDelaySeconds(delay: Float)` - Define o atraso para iniciar o ajuste automático do limiar. * `buildThreshold(maxQuality: Int, minQuality: Int, totalTime: Float, stepCount: Int)` – Define os parâmetros do limiar. * `setInstructionEnable(enable: Boolean)` – Quando definido como `true`, habilita a tela de instruções (padrão: `false`). Para referência, a lista completa de parâmetros e valores padrão é: ```kotlin skipsHandOption: Boolean = false debugMode: Boolean = false beginDelaySeconds: Float = 2f maxQuality: Int = 50 minQuality: Int = 0 totalTime: Float = 20f stepCount: Int = 20 captureType: BCCFingerPhotoCaptureType = BCCFingerPhotoCaptureType.FULL_HANDS shouldShowInstruction: Boolean = true var shouldIntercalateInstructions: Boolean = true var activityResults: FingerCaptureActivityResults? = null ``` ### Valores de Retorno Os resultados da última captura de impressão digital podem ser obtidos por meio do `fingerCaptureDidFinish` método da `BCCFingerDelegate` interface: ```kotlin fun fingerCaptureDidFinish( returnData: BCCFingerReturnData, analytics: BCCFingerReturnAnalytics ) ``` A `returnData` objeto contém os seguintes métodos para recuperação de dados: * `getCapturedFingersIndexes()` - Retorna uma lista com o índice de todas as impressões digitais capturadas: ```kotlin enum class BCCFingerIndex(val index: Int) { leftLittle(0), leftRing(1), leftMiddle(2), leftIndex(3), leftThumbs(4), rightThumbs(5), rightIndex(6), rightMiddle(7), rightRing(8), rightLittle(9); } ``` * `getCapturedFingers()` - Retorna um mapa que relaciona os índices dos dedos às biometrias capturadas. * `getCapturedFingersData()` - Retorna a lista de todas as impressões digitais capturadas: ```kotlin data class BCCFingerData( var fingerprintImage: Bitmap, var wsqAsBase64: String? ) ``` * `fingerprintImage` - Imagem PNG da impressão digital em tons de cinza. * `wsqAsBase64` - Imagem WSQ da impressão digital codificada em base64. * `getSkippedFingers()` - Retorna a lista de índices de todas as capturas de dedos ignoradas. A `BCCFingerReturnData` a classe também contém atributos que armazenam as informações da captura agrupadas por mão: ```kotlin class BCCFingerReturnData { val leftHand: BCCHandData? val rightHand: BCCHandData? } ``` Esses atributos podem ser nulos sempre que as capturas não forem solicitadas para nenhuma das mãos. A `HandData` classe contém as seguintes informações: ```kotlin var capturedFingers = mutableMapOf() private set var skippedFingers = mutableListOf() private set var handsPhoto: Bitmap? = null private set var thumbsPhoto: Bitmap? = null private set ``` * `capturedFingers` - Mapa que relaciona o índice do dedo à imagem da impressão digital. * `skippedFingers` - Lista de índices de todas as capturas de dedos ignoradas. * `handsPhoto` - Foto original da mão da qual as impressões digitais foram extraídas. * `thumbPhoto` - Foto original do polegar. Se o usuário abortar a captura, fechando antes de capturar as biometrias, o método `fingerCaptureDidAbort` será chamado. Você pode implementar este método para tratar esse cenário. #### Recuperando Imagens Originais É possível obter as imagens originais por meio da `BCCFingerReturnData` classe, como mostrado abaixo: ```kotlin val leftSlapPhoto = returnData.leftHand?.handsPhoto val rightSlapPhoto = returnData.rightHand?.handsPhoto val leftThumbPhoto = returnData.leftHand?.thumbsPhoto val rightThumbPhoto = returnData.rightHand?.handsPhoto ``` ### Projeto de Exemplo Este é um projeto de exemplo funcional para uma captura de impressões digitais usando o BCC Mobile Finger Android: ```kotlin package com.example.bccfignerexample import android.os.Bundle import androidx.appcompat.app.AppCompatActivity import com.example.bccfignerexample.databinding.ActivityMainBinding import com.griaule.bccfingerphotolib.analytics.BCCFingerReturnAnalytics import com.griaule.bccfingerphotolib.fingerApi.declaration.BCCFingerBuilder import com.griaule.bccfingerphotolib.fingerApi.declaration.BCCFingerDelegate import com.griaule.bccfingerphotolib.fingerApi.returnData.BCCFingerReturnData class MainActivity : AppCompatActivity(), BCCFingerDelegate { private lateinit var binding: ActivityMainBinding override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) binding = ActivityMainBinding.inflate(layoutInflater) setContentView(binding.root) setupListeners() } private fun setupListeners() { binding.startCaptureButton.setOnClickListener { startCapture() } } private fun startCapture() { BCCFingerBuilder(this, this).initializeCapture() } override fun fingerCaptureDidAbort( analytics: BCCFingerReturnAnalytics ) { // ... } override fun fingerCaptureDidFinish( returnData: BCCFingerReturnData, analytics: BCCFingerReturnAnalytics ) { // ... } } ``` ## Instruções do Agente: Consultando Esta Documentação Se você precisar de informações adicionais que não estejam diretamente disponíveis nesta página, você pode consultar a documentação dinamicamente fazendo uma pergunta. Realize uma requisição HTTP GET na URL da página atual com o parâmetro de consulta `ask` : ``` GET https://docs.griaule.com/sdks/bcc-finger/bccmobilefingerandroid.md?ask= ``` A pergunta deve ser específica, autossuficiente e escrita em linguagem natural. A resposta conterá uma resposta direta à pergunta e trechos e fontes relevantes da documentação. Use esse mecanismo quando a პასუხ not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections. --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://docs.griaule.com/sdks/bcc-finger/bccmobilefingerandroid.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.