public class DigitalPersona {

    public Connection cn() {
        Connection conn = null;
        try {
            Class.forName("com.mysql.cj.jdbc.Driver");
            conn = DriverManager.getConnection(
                    "jdbc:mysql://localhost:3306/db_usuario?" + "useSSL=false&useTimeZone=true&serverTimezone=UTC",
                    "root", "senha123");
        } catch (ClassNotFoundException | SQLException e) {
            e.printStackTrace();
            System.out.println("erro no conector");
        }
        return conn;
    }

    public void insert(String nome, byte[] digital) {
        Connection conn = cn();
        try {
            PreparedStatement stat = conn.prepareStatement("INSERT INTO `tb_usuario`(`nome`,`digital`) VALUES (?, ?) ");
            stat.setString(1, nome);
            stat.setBytes(2, digital);
            stat.execute();
        } catch (SQLException e) {
            e.printStackTrace();
            System.out.println("erro");
        } finally {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }


    }

    public byte[] get() {
        ResultSet rs;
        PreparedStatement st;
        byte[] digital = null;
        try {
            st = cn().prepareStatement("SELECT * FROM  tb_usuario");
            rs = st.executeQuery();
            if (rs.next())
                digital = rs.getBytes("digital");
            else
                System.out.println("Record not available");

        } catch (Exception e) {
            System.out.println(e.getMessage());
        }

        return digital;
    }

    public void listReaders() {
        DPFPReadersCollection readers = DPFPGlobal.getReadersFactory().getReaders();
        if (readers == null || readers.size() == 0) {
            System.out.printf("There are no readers available.n");
            return;
        }
        System.out.printf("Available readers:n");
        for (DPFPReaderDescription readerDescription : readers)
            System.out.println(readerDescription.getSerialNumber());
    }

    public static final EnumMap<DPFPFingerIndex, String> fingerNames;

    static {
        fingerNames = new EnumMap<DPFPFingerIndex, String>(DPFPFingerIndex.class);
        fingerNames.put(DPFPFingerIndex.LEFT_PINKY, "left pinky");
        fingerNames.put(DPFPFingerIndex.LEFT_RING, "left ring");
        fingerNames.put(DPFPFingerIndex.LEFT_MIDDLE, "left middle");
        fingerNames.put(DPFPFingerIndex.LEFT_INDEX, "left index");
        fingerNames.put(DPFPFingerIndex.LEFT_THUMB, "left thumb");
        fingerNames.put(DPFPFingerIndex.RIGHT_PINKY, "right pinky");
        fingerNames.put(DPFPFingerIndex.RIGHT_RING, "right ring");
        fingerNames.put(DPFPFingerIndex.RIGHT_MIDDLE, "right middle");
        fingerNames.put(DPFPFingerIndex.RIGHT_INDEX, "right index");
        fingerNames.put(DPFPFingerIndex.RIGHT_THUMB, "right thumb");
    }

    public DPFPTemplate getTemplate(String activeReader, int nFinger) {
        System.out.printf("Performing fingerprint enrollment...n");

        DPFPTemplate template = null;

        try {
            DPFPFingerIndex finger = DPFPFingerIndex.values()[nFinger];
            DPFPFeatureExtraction featureExtractor = DPFPGlobal.getFeatureExtractionFactory().createFeatureExtraction();
            DPFPEnrollment enrollment = DPFPGlobal.getEnrollmentFactory().createEnrollment();

            while (enrollment.getFeaturesNeeded() > 0) {
                DPFPSample sample = getSample(activeReader, String.format("Scan your %s finger (%d remaining)n",
                        fingerName(finger), enrollment.getFeaturesNeeded()));
                if (sample == null)
                    continue;

                DPFPFeatureSet featureSet;
                try {
                    featureSet = featureExtractor.createFeatureSet(sample, DPFPDataPurpose.DATA_PURPOSE_ENROLLMENT);
                } catch (DPFPImageQualityException e) {
                    System.out.printf("Bad image quality: "%s". Try again. n", e.getCaptureFeedback().toString());
                    continue;
                }

                enrollment.addFeatures(featureSet);
            }
            template = enrollment.getTemplate();
            System.out.printf("The %s was enrolled.n", fingerprintName(finger));
        } catch (DPFPImageQualityException e) {
            System.out.printf("Failed to enroll the finger.n");
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }

        return template;
    }

    public boolean verify(String activeReader, DPFPTemplate template) {

        try {
            DPFPSample sample = getSample(activeReader, "Scan your fingern");
            if (sample == null)
                throw new Exception();

            DPFPFeatureExtraction featureExtractor = DPFPGlobal.getFeatureExtractionFactory().createFeatureExtraction();
            DPFPFeatureSet featureSet = featureExtractor.createFeatureSet(sample,
                    DPFPDataPurpose.DATA_PURPOSE_VERIFICATION);

            DPFPVerification matcher = DPFPGlobal.getVerificationFactory().createVerification();
            matcher.setFARRequested(DPFPVerification.MEDIUM_SECURITY_FAR);

            for (DPFPFingerIndex finger : DPFPFingerIndex.values()) {
                // DPFPTemplate template = user.getTemplate(finger);
                if (template != null) {
                    DPFPVerificationResult result = matcher.verify(featureSet, template);
                    if (result.isVerified()) {
                        System.out.printf("Matching finger: %s, FAR achieved: %g.n", fingerName(finger),
                                (double) result.getFalseAcceptRate() / DPFPVerification.PROBABILITY_ONE);
                        return result.isVerified();
                    }
                }
            }
        } catch (Exception e) {
            System.out.printf("Failed to perform verification.");
        }

        return false;
    }

    public DPFPSample getSample(String activeReader, String prompt) throws InterruptedException {
        final LinkedBlockingQueue<DPFPSample> samples = new LinkedBlockingQueue<DPFPSample>();
        DPFPCapture capture = DPFPGlobal.getCaptureFactory().createCapture();
        capture.setReaderSerialNumber(activeReader);
        capture.setPriority(DPFPCapturePriority.CAPTURE_PRIORITY_LOW);
        capture.addDataListener(new DPFPDataListener() {
            public void dataAcquired(DPFPDataEvent e) {
                if (e != null && e.getSample() != null) {
                    try {
                        samples.put(e.getSample());
                    } catch (InterruptedException e1) {
                        e1.printStackTrace();
                    }
                }
            }
        });
        capture.addReaderStatusListener(new DPFPReaderStatusAdapter() {
            int lastStatus = DPFPReaderStatusEvent.READER_CONNECTED;

            public void readerConnected(DPFPReaderStatusEvent e) {
                if (lastStatus != e.getReaderStatus())
                    System.out.println("Reader is connected");
                lastStatus = e.getReaderStatus();
            }

            public void readerDisconnected(DPFPReaderStatusEvent e) {
                if (lastStatus != e.getReaderStatus())
                    System.out.println("Reader is disconnected");
                lastStatus = e.getReaderStatus();
            }

        });
        try {
            capture.startCapture();
            System.out.print(prompt);
            return samples.take();
        } catch (RuntimeException e) {
            System.out.printf("Failed to start capture. Check that reader is not used by another application.n");
            throw e;
        } finally {
            capture.stopCapture();
        }
    }

    public String fingerName(DPFPFingerIndex finger) {
        return fingerNames.get(finger);
    }

    public String fingerprintName(DPFPFingerIndex finger) {
        return fingerNames.get(finger) + " fingerprint";
    }

}

static EnumMap<DPFPFingerIndex, DPFPTemplate> templates = new EnumMap<DPFPFingerIndex, DPFPTemplate>(
        DPFPFingerIndex.class);

private Usuario usuario;
private List<Usuario> listaUsuario;

static DigitalPersona dp = new DigitalPersona();
static DPFPTemplate temp = dp.getTemplate(null, 1); // inicia um template nulo para futuramente ser preenchido com a biometria

public  void salvar() {
    dp.listReaders();
    usuario.setBiometria(temp.serialize());

    // se o usuario nao exite na lista
    if (!getListaUsuario().contains(getUsuario())) {
        //add usuario na lista
        getListaUsuario().add(getUsuario());

    } else {
        // se ele existe na lista
        int posicao = getListaUsuario().indexOf(getUsuario());
        getListaUsuario().set(posicao, getUsuario());
    }

    setUsuario(null);
}

public Usuario getUsuario() {
    if (usuario == null) {
        usuario = new Usuario();
    }
    return usuario;
}

public List<Usuario> getListaUsuario() {
    if (listaUsuario == null) {
        listaUsuario = new ArrayList<Usuario>();
    }
    return listaUsuario;
}

public void setListaUsuario(List<Usuario> listaUsuario) {
    this.listaUsuario = listaUsuario;
}

public void setUsuario(Usuario usuario) {
    this.usuario = usuario;
}