iOS

BCC Finger é uma biblioteca destinada a ser integrada em um aplicativo iOS a partir de um .framework arquivo. Ela usa a câmera do dispositivo para tirar uma foto das impressões digitais para fins biométricos.

Este Manual está atualizado para a versão 4.3.0 do BCC Finger Photo iOS.

Requisitos

• Git

• Cocoapods, disponível em https://cocoapods.org/.

Instalação

Instalando Dependências

1 - Adicione os Pods a seguir às dependências do aplicativo no Podfile:

pod 'lottie-ios'

Se o aplicativo não possuir um Podfile, ele pode ser criado na pasta raiz do seu projeto Xcode usando o comando pod init no terminal.

É preferível usar frameworks dinâmicos. Isso pode ser indicado usando a flag use_frameworks! no Podfile.

Um exemplo de Podfile com um target chamado BCCs-Sample é mostrado abaixo:

target 'BCCs-Sample' do
	use_frameworks!

	pod 'lottie-ios', '~> 3.3.0'
end

post_install do |installer|
	installer.pods_project.targets.each do |target|
		target.build_configurations.each do |config|
			config.build_settings['BUILD_LIBRARY_FOR_DISTRIBUTION'] = 'YES'
		end
	end
end

Recomenda-se usar a versão mínima do iOS suportada pelo seu aplicativo igual à deste framework: iOS 13.0, como no exemplo acima.

2 - Feche seu projeto Xcode e abra no terminal a pasta onde está seu Podfile, então execute:

$ pod install

Após a execução terminar, um arquivo com .xcworkspace extensão será criado na mesma pasta.

3 - Abra o novo .xcworkspace arquivo.

A partir de agora, toda vez que o usuário quiser abrir o projeto, é necessário abri-lo através deste .xcworkspace arquivo, pois ele inclui as dependências.

Importando e Configurando

Importando o Projeto

• Abra o projeto usando o .xcworkspace arquivo.

• Adicione o FingerPhoto.framework arquivo ao projeto, em seguida adicione-o à lista de frameworks do seu aplicativo.

  • Mova o .framework arquivo para a árvore de arquivos do projeto.

    Se já existir uma pasta de frameworks, recomenda-se mover o arquivo para lá.

  • Abra as configurações do projeto.

  • Vá para a aba General.

  • Clique e arraste o .framework para a árvore do projeto sob a seção Frameworks, Libraries, etc.

• Altere a BCCFinger.framework configuração de Do not embed para Embed & Sign.

• Altere a versão target do seu projeto para no mínimo iOS 13.

Recomenda-se desativar iPad como target.

Configuração Inicial

Esta versão não possui dependências do Firebase, nem requer uma configuração inicial chamada pelo AppDelegate. A única configuração inicial necessária é que o aplicativo deve solicitar permissão de uso da câmera. Para isso, adicione a seguinte chave no arquivo info.plist, em Information Property List:

Privacy - Camera Usage Description

O valor da chave é uma mensagem a ser exibida ao usuário ao solicitar permissão de uso da câmera. Esse valor pode ficar em branco ou ser preenchido com a mensagem desejada.

Uso

Parâmetros e Construtor

Um exemplo simples de uso da biblioteca é mostrado abaixo:

// Para inicializar uma nova captura
BCCFingerBuilder(self, delegate: self).initializeCapture()

A classe BCCFingerBuilder recebe os seguintes parâmetros:

• hostVC: UIViewController - View controller que chama a tela de captura.

• delegate: BCCFingerDelegate - Interface responsável por notificar eventos de captura (ex.: falha ou sucesso).

A initialize o método também aceita um parâmetro opcional, como mostrado abaixo:

public func initializeCapture(
	_ navController: UINavigationController? = nil
) {
	// ...
}

Se você quiser que a navegação ocorra através de um navigation controller, você deve fornecê-lo ao chamar o método.

A classe BCCFingerBuilder a classe é responsável por tratar 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: Bool) - Habilita a opção de pular a captura atual.

• setDebugMode(_ enable: Bool) - Habilita o modo de depuração.

• buildCaptures(_ captures: BCCFingerCaptureType) - Define o tipo de captura de impressão digital. As opções são:

  public enum BCCFingerCaptureType {
  	case BOTH_HANDS
  	case ONLY_LEFT_HAND
  	case ONLY_RIGHT_HAND
  	case THUMBS
  	case LEFT_THUMB
  	case RIGHT_THUMB
  	case FULL_HANDS
  	case FULL_LEFT_HAND
  	case 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 a mão esquerda, com polegares.

  • FULL_RIGHT_HAND - Apenas a mão direita, com polegares.

• 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 é:

var skipsHandOption: Bool = false
var debugMode: Bool = false
var capture: BCCFingerCaptureType = .FULL_HANDS
var beginDelaySeconds: Float = 1
var minQuality: Int = 20
var maxQuality: Int = 80
var totalTime: Double = 30
var stepCount: Int = 30

Valores de Retorno

Os resultados da última captura de impressão digital podem ser recuperados através do fingerCaptureDidFinish método do BCCFingerDelegate interface:

func fingerCaptureDidFinish(
	_ returnData: BCCFingerReturnData,
	analytics: BCCFingerAnalytics
)

A 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:

  public enum FingerIndex: Int {
  	case leftLittle = 0
  	case leftRing = 1
  	case leftMiddle = 2
  	case leftIndex = 3
  	case leftThumb = 4
  	case rightThumb = 5
  	case rightIndex = 6
  	case rightMiddle = 7
  	case rightRing = 8
  	case 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:

  public var fingerprintPNG: UIImage
  public var wsqAsBase64: String

  • fingerprintPNG - 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.

A BCCFingerReturnData a classe também contém atributos que armazenam as informações de captura agrupadas por mão:

public class BCCFingerReturnData {
	public let leftHand: HandData?
	public let rightHand: HandData?
}

Esses atributos podem ser nulos sempre que capturas não forem solicitadas para alguma das mãos.

A HandData a classe contém as seguintes informações:

public internal(set) var capturedFingers: [FingerIndex : FingerData] = [:]
public internal(set) var skippedFingers: [FingerIndex] = []
public internal(set) var handsPhoto: UIImage? = nil
public internal(set) var thumbsPhoto: UIImage? = nil

• 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 as 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:

let leftSlapPhoto = returnData.leftHand?.handsPhoto
let rightSlapPhoto = returnData.rightHand?.handsPhoto
let leftThumbPhoto = returnData.leftHand?.thumbsPhoto
let rightThumbPhoto = returnData.rightHand?.handsPhoto

Projeto de Exemplo

Este é um projeto de exemplo funcional para uma captura de impressão digital usando o BCC Mobile Finger iOS:

import UIKit
import FingerPhoto
import BCCFinger

class ViewController: UIViewController {

	override func viewDidLoad() {
		super.viewDidLoad()
	}

	@IBAction func startCaptureAction(_ sender: UIButton) {
		BCCFingerBuilder(self, delegate: self)
			.initializeCapture()
	}
}

extension ViewController: BCCFingerDelegate {

	func fingerCaptureDidFinish(
		_ returnData: BCCFinger.BCCFingerReturnData,
		analytics: BCCFinger.BCCFingerAnalytics
	) {
		// ...
	}

	func didAbortFingerCapture(
		analytics: BCCFinger.BCCFingerAnalytics
	) {
		// ...
	}

}