int fpc_auth_start()
{
int print_count = fpc_get_print_count();
fpc_fingerprint_index_t prints;
ALOGI("%s : Number Of Prints Available : %d",__func__,print_count);
prints = fpc_get_print_ids(print_count);
fpc_get_pint_index_cmd_t* send_cmd = (fpc_get_pint_index_cmd_t*) mHandle->ion_sbuffer;
fpc_send_std_cmd_t* rec_cmd = (fpc_send_std_cmd_t*) mHandle->ion_sbuffer + 64;
send_cmd->cmd_id = FPC_AUTH_START;
send_cmd->p1 = prints.prints[0];
send_cmd->p2 = prints.prints[1];
send_cmd->p3 = prints.prints[2];
send_cmd->p4 = prints.prints[3];
send_cmd->p5 = prints.prints[4];
send_cmd->print_count = prints.print_count;
int ret = send_cmd_fn(mHandle,send_cmd,64,rec_cmd,64);
if(ret < 0) {
ALOGE("Error sending FPC_AUTH_START to tz\n");
return -1;
}
return rec_cmd->ret_val;
}
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;
}
static int fingerprint_enumerate(struct fingerprint_device __unused *dev,
fingerprint_finger_id_t *results,
uint32_t *max_size)
{
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_index(print_count);
if (*max_size == 0) {
*max_size = print_count;
} else {
for (size_t i = 0; i < *max_size && i < print_count; i++) {
ALOGD("%s : found print : %lu at index %lu", __func__,(unsigned long) print_indexs.prints[i], i);
results[i].fid = print_indexs.prints[i];
results[i].gid = fpc_gid;
}
}
return print_count;
}
void *enroll_thread_loop()
{
ALOGI("%s", __func__);
uint32_t print_count = fpc_get_print_count();
ALOGD("%s : print count is : %u", __func__, print_count);
int ret = fpc_enroll_start(print_count);
if(ret < 0)
{
ALOGE("Starting enrol failed: %d\n", ret);
}
int status = 1;
while((status = fpc_capture_image()) >= 0) {
ALOGD("%s : Got Input status=%d", __func__, status);
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__);
uint32_t remaining_touches = 0;
int ret = fpc_enroll_step(&remaining_touches);
ALOGE("%s: step: %d, touches=%d\n", __func__, ret, remaining_touches);
if (ret > 0) {
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 {
uint32_t print_id = 0;
int print_index = fpc_enroll_end(&print_id);
if (print_index < 0){
ALOGE("%s : Error getting new print index : %d", __func__,print_index);
fingerprint_msg_t msg;
msg.type = FINGERPRINT_ERROR;
msg.data.error = FINGERPRINT_ERROR_UNABLE_TO_PROCESS;
callback(&msg);
break;
}
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);
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 = fpc_gid;
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);
}
uint32_t print_id = 0;
fpc_enroll_end(&print_id);
ALOGI("%s : finishing",__func__);
pthread_mutex_lock(&lock);
auth_thread_running = false;
pthread_mutex_unlock(&lock);
return NULL;
}
