# Android **BCC Finger** é uma biblioteca Android destinada a ser integrada em um aplicativo Android. Essencialmente, ela abrirá uma câmera e capturará digitais para fins biométricos. Este Manual está atualizado para a versão 4.3.0 do BCC Finger Photo Android. ## Requisitos **BCC Finger Photo** é uma biblioteca Android e deve ser importada para o projeto alvo. * 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 construído 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 no 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** pasta e crie os seguintes diretórios `libs/bccfinger`. Em seguida, adicione a dependência `jna.aar` e o `bccfingerphotolib-release.aar` dependências. A estrutura de pastas deve ser semelhante a esta: ![](https://3411546999-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2F5TVzatVMAV3OF5tyA1VF%2Fuploads%2Fgit-blob-707b6bc10ae29cea4b04a34d5c228fd67a50b2f7%2FfingerFolderStructure.png?alt=media) O próximo passo é tornar esses arquivos visíveis às 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 1.8 (Java 8): ```groovy compileOptions { sourceCompatibility = 1.8 targetCompatibility = 1.8 } ``` ### Configurando 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.1.0' implementation 'androidx.constraintlayout:constraintlayout:1.1.3' implementation 'com.google.android.material:material:1.1.0' // LOTTIE // implementation 'com.airbnb.android:lottie:3.0.0' // CAMERA X // def camerax_version = "1.2.0-rc01" // 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" } ``` ## Uso ### Parâmetros e Construtor Um exemplo simples de uso da biblioteca é mostrado abaixo: ```kotlin // Para inicializar uma nova captura BCCFingerBuilder(this, this).initializeCapture() ``` O `classe BCCFingerBuilder` 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). O `classe BCCFingerBuilder` a classe é responsável por controlar a configuração de uso para `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 de 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 polegares. * `ONLY_LEFT_HAND` - Apenas a mão esquerda, sem polegares. * `ONLY_RIGHT_HAND` - Apenas a mão direita, sem polegares. * `THUMBS` - Ambos os polegares. * `LEFT_THUMB` - Apenas o polegar esquerdo. * `RIGHT_THUMB` - Apenas o polegar direito. * `FULL_HANDS` - Ambas as mãos com polegares. * `FULL_LEFT_HAND` - Apenas mão esquerda, com polegar. * `FULL_RIGHT_HAND` - Apenas mão direita, com polegar. * `buildBeginDelaySeconds(delay: Float)` - Define o atraso para iniciar o ajuste automático do limiar. * `buildThreshold` - Define parâmetros de limiar. 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 ``` ### Valores de Retorno Os resultados da última captura de impressão digital podem ser recuperados através do `fingerCaptureDidFinish` do `BCCFingerDelegate` interface: ```kotlin fun fingerCaptureDidFinish( returnData: BCCFingerReturnData, analytics: BCCFingerReturnAnalytics ) ``` O `returnData` o 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 biometria 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 escala de cinza. * `wsqAsBase64` - Imagem WSQ codificada em base64 da impressão digital. * `getSkippedFingers()` - Retorna a lista de índices de todas as capturas de dedos puladas. O `BCCFingerReturnData` a classe também contém atributos que armazenam as informações de captura agrupadas por mão: ```kotlin class BCCFingerReturnData { val leftHand: BCCHandData? val rightHand: BCCHandData? } ``` Esses atributos podem ser nulos sempre que capturas não forem solicitadas para alguma das mãos. O `HandData` a 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 puladas. * `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 a biometria, o método `fingerCaptureDidAbort` será chamado. Você pode implementar esse método para tratar esse cenário. #### Recuperando Imagens Originais É possível obter as imagens originais através da `BCCFingerReturnData` classe, conforme 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 captura de 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 ) { // ... } } ```