static int fingerprint_remove(struct fingerprint_device __unused *dev,
                              uint32_t gid, uint32_t fid)
{


    if (fpc_del_print_id(fid) == 0){
        fingerprint_msg_t msg;
        msg.type = FINGERPRINT_TEMPLATE_REMOVED;
        msg.data.removed.finger.fid = fid;
        msg.data.removed.finger.gid = gid;
        callback(&msg);

        uint32_t db_length = fpc_get_user_db_length();
        ALOGD("%s : User Database Length Is : %lu", __func__,(unsigned long) db_length);
        fpc_store_user_db(db_length, db_path);
        return 0;
    } else {
        fingerprint_msg_t msg;
        msg.type = FINGERPRINT_ERROR;
        msg.data.error = FINGERPRINT_ERROR_UNABLE_TO_REMOVE;
        callback(&msg);

        return FINGERPRINT_ERROR;
    }
}
示例#2
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;
}
示例#3
0
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 *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;
}