uint32_t fpc_auth_step(uint32_t *print_id)
{
fpc_send_std_cmd_t* send_cmd = (fpc_send_std_cmd_t*) mHandle->ion_sbuffer;
fpc_send_auth_cmd_t* rec_cmd = (fpc_send_auth_cmd_t*) mHandle->ion_sbuffer + 64;
send_cmd->cmd_id = FPC_AUTH_STEP;
send_cmd->ret_val = 0x00;
int ret = send_cmd_fn(mHandle,send_cmd,64,rec_cmd,64);
if(ret < 0) {
return -1;
}
//if the print didnt capture properly return error and continue
if (rec_cmd->ret_val < 2) {
return -1;
}
*print_id = fpc_get_print_id(rec_cmd->id);
return 0;
}
fpc_fingerprint_index_t fpc_get_print_index(int count)
{
fpc_fingerprint_index_t data;
fpc_send_std_cmd_t* send_cmd = (fpc_send_std_cmd_t*) mHandle->ion_sbuffer;
fpc_get_pint_index_cmd_t* rec_cmd = (fpc_get_pint_index_cmd_t*) mHandle->ion_sbuffer + 64;
send_cmd->cmd_id = FPC_GET_ID_LIST;
send_cmd->ret_val = count;
send_cmd->length = count;
int ret = send_cmd_fn(mHandle,send_cmd,64,rec_cmd,64);
data.prints[0] = fpc_get_print_id(rec_cmd->p1);
data.prints[1] = fpc_get_print_id(rec_cmd->p2);
data.prints[2] = fpc_get_print_id(rec_cmd->p3);
data.prints[3] = fpc_get_print_id(rec_cmd->p4);
data.prints[4] = fpc_get_print_id(rec_cmd->p5);
data.print_count = rec_cmd->print_count;
return data;
}
int fpc_enroll_end(uint32_t *print_id)
{
int index = send_normal_command(FPC_ENROLL_END,0x0,mHandle);
if (index < 0 || index > 4) {
ALOGE("Error sending FPC_ENROLL_END to tz\n");
return -1;
}
*print_id = fpc_get_print_id(index);
return 0;
}
static int fingerprint_remove(struct fingerprint_device __unused *dev,
uint32_t __unused gid, uint32_t __unused fid)
{
//Maximum prints per gid is 5
uint32_t prints[5];
uint32_t print_count = fpc_get_print_count();
fpc_get_pint_index_cmd_t print_indexs = fpc_get_print_index(print_count);
//populate print array with index
prints[0] = print_indexs.p1;
prints[1] = print_indexs.p2;
prints[2] = print_indexs.p3;
prints[3] = print_indexs.p4;
prints[4] = print_indexs.p5;
ALOGI("%s : delete print : %lu", __func__,(unsigned long) fid);
for (int i = 0; i < 5; i++){
uint32_t print_id = fpc_get_print_id(prints[i]);
ALOGI("%s : found print : %lu at index %d", __func__,(unsigned long) print_id, i);
if (print_id == fid){
ALOGI("%s : Print index found at : %d", __func__, i);
int ret = fpc_del_print_id(prints[i]);
ALOGI("%s : fpc_del_print_id returns : %d", __func__, ret);
if (ret == 0){
uint32_t db_length = fpc_get_user_db_length();
ALOGI("%s : User Database Length Is : %lu", __func__,(unsigned long) db_length);
fpc_store_user_db(db_length, db_path);
fingerprint_msg_t msg;
msg.type = FINGERPRINT_TEMPLATE_REMOVED;
msg.data.removed.finger.fid = print_id;
msg.data.removed.finger.gid = 0;
callback(&msg);
return 0;
}
}
}
return FINGERPRINT_ERROR;
}
uint32_t fpc_del_print_id(uint32_t id)
{
uint32_t print_count = fpc_get_print_count();
ALOGD("%s : print count is : %u", __func__, print_count);
fpc_fingerprint_index_t print_indexs = fpc_get_print_ids(print_count);
ALOGI("%s : delete print : %lu", __func__,(unsigned long) id);
for (uint32_t i = 0; i < print_indexs.print_count; i++){
uint32_t print_id = fpc_get_print_id(print_indexs.prints[i]);
if (print_id == id){
ALOGD("%s : Print index found at : %d", __func__, i);
return send_normal_command(FPC_GET_DEL_PRINT,print_indexs.prints[i],mHandle);
}
}
return -1;
}
void *enroll_thread_loop()
{
ALOGI("%s", __func__);
fpc_enroll_start(1);
int status = 1;
while((status = fpc_capture_image()) >= 0) {
ALOGD("%s : Got Input", __func__);
if (status <= FINGERPRINT_ACQUIRED_TOO_FAST) {
fingerprint_msg_t msg;
msg.type = FINGERPRINT_ACQUIRED;
msg.data.acquired.acquired_info = status;
callback(&msg);
}
//image captured
if (status == FINGERPRINT_ACQUIRED_GOOD) {
ALOGI("%s : Enroll Step", __func__);
if (fpc_enroll_step() < 100) {
int remaining_touches = fpc_get_remaining_touches();
ALOGI("%s : Touches Remaining : %d", __func__, remaining_touches);
if (remaining_touches > 0) {
fingerprint_msg_t msg;
msg.type = FINGERPRINT_TEMPLATE_ENROLLING;
msg.data.enroll.finger.fid = 0;
msg.data.enroll.finger.gid = 0;
msg.data.enroll.samples_remaining = remaining_touches;
msg.data.enroll.msg = 0;
callback(&msg);
}
} else {
int print_index = fpc_enroll_end();
ALOGI("%s : Got print index : %d", __func__,print_index);
uint32_t db_length = fpc_get_user_db_length();
ALOGI("%s : User Database Length Is : %lu", __func__,(unsigned long) db_length);
fpc_store_user_db(db_length, db_path);
uint32_t print_id = fpc_get_print_id(print_index);
ALOGI("%s : Got print id : %lu", __func__,(unsigned long) print_id);
fingerprint_msg_t msg;
msg.type = FINGERPRINT_TEMPLATE_ENROLLING;
msg.data.enroll.finger.fid = print_id;
msg.data.enroll.finger.gid = 0;
msg.data.enroll.samples_remaining = 0;
msg.data.enroll.msg = 0;
callback(&msg);
break;
}
}
pthread_mutex_lock(&lock);
if (!auth_thread_running) {
pthread_mutex_unlock(&lock);
break;
}
pthread_mutex_unlock(&lock);
}
fpc_enroll_end();
ALOGI("%s : finishing",__func__);
pthread_mutex_lock(&lock);
auth_thread_running = false;
pthread_mutex_unlock(&lock);
return NULL;
}
void *auth_thread_loop()
{
ALOGI("%s", __func__);
fpc_auth_start();
int status = 1;
while((status = fpc_capture_image()) >= 0) {
ALOGD("%s : Got Input", __func__);
if (status <= FINGERPRINT_ACQUIRED_TOO_FAST) {
fingerprint_msg_t msg;
msg.type = FINGERPRINT_ACQUIRED;
msg.data.acquired.acquired_info = status;
callback(&msg);
}
if (status == FINGERPRINT_ACQUIRED_GOOD) {
int verify_state = fpc_auth_step();
ALOGI("%s : Auth step = %d", __func__, verify_state);
if (verify_state >= 0) {
uint32_t print_id = fpc_get_print_id(verify_state);
ALOGI("%s : Got print id : %lu", __func__, (unsigned long) print_id);
hw_auth_token_t hat;
fpc_get_hw_auth_obj(&hat, sizeof(hw_auth_token_t));
ALOGI("%s : hat->challange %lu",__func__,(unsigned long) hat.challenge);
ALOGI("%s : hat->user_id %lu",__func__,(unsigned long) hat.user_id);
ALOGI("%s : hat->authenticator_id %lu",__func__,(unsigned long) hat.authenticator_id);
ALOGI("%s : hat->authenticator_type %d",__func__, hat.authenticator_type);
ALOGI("%s : hat->timestamp %lu",__func__,(unsigned long) hat.timestamp);
ALOGI("%s : hat size %lu",__func__,(unsigned long) sizeof(hw_auth_token_t));
fingerprint_msg_t msg;
msg.type = FINGERPRINT_AUTHENTICATED;
msg.data.authenticated.finger.gid = 0;
msg.data.authenticated.finger.fid = print_id;
msg.data.authenticated.hat = hat;
callback(&msg);
break;
}
}
pthread_mutex_lock(&lock);
if (!auth_thread_running) {
pthread_mutex_unlock(&lock);
break;
}
pthread_mutex_unlock(&lock);
}
fpc_auth_end();
ALOGI("%s : finishing",__func__);
pthread_mutex_lock(&lock);
auth_thread_running = false;
pthread_mutex_unlock(&lock);
return NULL;
}
