biod/bio_library.h

// Copyright 2016 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#ifndef BIOD_BIO_LIBRARY_H_
#define BIOD_BIO_LIBRARY_H_

#include <memory>
#include <string>
#include <vector>

#include <base/files/file_path.h>

#include "biod/bio_algorithm.h"

namespace biod {

enum class BioAlgorithmType {
  kUnknown = -1,
  kFingerprint = BIO_ALGORITHM_FINGERPRINT,
  kIris = BIO_ALGORITHM_IRIS,
};

class BioLibrary;

class BioImage {
 public:
  BioImage() = default;
  BioImage(BioImage&& rhs);
  BioImage(const std::shared_ptr<BioLibrary>& lib, bio_image_t image)
      : lib_(lib), image_(image) {}
  ~BioImage();

  BioImage& operator=(BioImage&& rhs);

  explicit operator bool() const { return lib_ && image_; }

  bio_image_t get() const { return image_; }

  bool SetData(std::vector<uint8_t>* data);
  bool Destroy();

 private:
  std::shared_ptr<BioLibrary> lib_;
  std::vector<uint8_t> data_;
  bio_image_t image_ = nullptr;
};

class BioTemplate {
 public:
  BioTemplate() = default;
  BioTemplate(BioTemplate&& rhs);
  BioTemplate(const std::shared_ptr<BioLibrary>& lib, bio_template_t tmplate)
      : lib_(lib), template_(tmplate) {}
  ~BioTemplate();

  BioTemplate& operator=(BioTemplate&& rhs);

  explicit operator bool() const { return lib_ && template_; }

  int MatchImage(const BioImage& image);
  bool Serialize(std::vector<uint8_t>* out);

  bool Destroy();

 private:
  std::shared_ptr<BioLibrary> lib_;
  bio_template_t template_ = nullptr;
};

class BioEnrollment {
 public:
  BioEnrollment() = default;
  BioEnrollment(BioEnrollment&& rhs);
  BioEnrollment(const std::shared_ptr<BioLibrary>& lib,
                bio_enrollment_t enrollment)
      : lib_(lib), enrollment_(enrollment) {}
  ~BioEnrollment();

  BioEnrollment& operator=(BioEnrollment&& rhs);

  explicit operator bool() const { return lib_ && enrollment_; }

  int AddImage(const BioImage& image);
  int IsComplete();
  int GetPercentComplete();
  BioTemplate Finish();
  bool Destroy();

 private:
  std::shared_ptr<BioLibrary> lib_;
  bio_enrollment_t enrollment_ = nullptr;
};

class BioSensor {
 public:
  struct Model {
    uint32_t vendor_id;
    uint32_t product_id;
    uint32_t model_id;
    uint32_t version;
  };

  BioSensor() = default;
  BioSensor(BioSensor&& rhs);
  BioSensor(const std::shared_ptr<BioLibrary>& lib, bio_sensor_t sensor)
      : lib_(lib), sensor_(sensor) {}
  ~BioSensor();

  BioSensor& operator=(BioSensor&& rhs);

  explicit operator bool() const { return lib_ && sensor_; }

  bool SetModel(const Model& model);
  bool SetFormat(uint32_t pixel_format);
  bool SetSize(uint32_t width, uint32_t height);
  // Must have called SetSize prior to this call.
  BioImage CreateImage();
  BioEnrollment BeginEnrollment();
  bool Destroy();

 private:
  std::shared_ptr<BioLibrary> lib_;
  bio_sensor_t sensor_ = nullptr;
  uint32_t width_ = 0;
  uint32_t height_ = 0;
};

class BioLibrary : public std::enable_shared_from_this<BioLibrary> {
 public:
  ~BioLibrary();

  // Loads the bio algorithm implementation from the shared object at path. On
  // success, a valid BioLibrary pointer is returned.
  static std::shared_ptr<BioLibrary> Load(const base::FilePath& path);

  // Gets a single function named sym from the loaded bio library. Returns a
  // NULL pointer if the symbol can not be loaded. This is useful for accessing
  // non-standard bio library functions.
  template <typename T>
  T GetFunction(const std::string& sym) const {
    void* sym_ptr = GetSymbolPointer(sym);
    if (sym_ptr == nullptr)
      return nullptr;
    return reinterpret_cast<T>(sym_ptr);
  }

  BioAlgorithmType GetAlgorithmType();
  base::StringPiece GetAlgorithmName();
  base::StringPiece GetAlgorithmVersion();
  base::StringPiece GetAlgorithmBanner();
  BioSensor CreateSensor();
  BioTemplate DeserializeTemplate(const std::vector<uint8_t>& data);

 private:
  friend class BioImage;
  friend class BioTemplate;
  friend class BioEnrollment;
  friend class BioSensor;

  using bio_algorithm_init_fp = int (*)(void);
  using bio_algorithm_exit_fp = int (*)(void);
  using bio_algorithm_get_type_fp = enum bio_algoritm_type (*)(void);
  using bio_algorithm_get_name_fp = const char* (*)(void);
  using bio_algorithm_get_version_fp = const char* (*)(void);
  using bio_algorithm_get_banner_fp = const char* (*)(void);
  using bio_sensor_create_fp = int (*)(bio_sensor_t* sensor);
  using bio_sensor_destroy_fp = int (*)(bio_sensor_t sensor);
  using bio_sensor_set_model_fp = int (*)(bio_sensor_t sensor,
                                          uint32_t vendor_id,
                                          uint32_t product_id,
                                          uint32_t model_id,
                                          uint32_t version);
  using bio_sensor_set_format_fp = int (*)(bio_sensor_t sensor,
                                           uint32_t pixel_format);
  using bio_sensor_set_size_fp = int (*)(bio_sensor_t sensor,
                                         uint32_t width,
                                         uint32_t height);
  using bio_image_create_fp = int (*)(bio_sensor_t sensor,
                                      uint32_t width,
                                      uint32_t height,
                                      bio_image_t* image);
  using bio_image_set_size_fp = int (*)(bio_image_t image,
                                        uint32_t width,
                                        uint32_t height);
  using bio_image_set_data_fp = int (*)(bio_image_t image,
                                        const uint8_t* data,
                                        size_t size);
  using bio_image_destroy_fp = int (*)(bio_image_t image);
  using bio_template_image_match_fp = int (*)(bio_template_t tmpl,
                                              bio_image_t image);
  using bio_template_deserialize_fp = int (*)(const uint8_t* template_data,
                                              size_t size,
                                              bio_template_t* tmpl);
  using bio_template_get_serialized_size_fp = ssize_t (*)(bio_template_t tmpl);
  using bio_template_serialize_fp = int (*)(bio_template_t tmpl,
                                            uint8_t* template_data,
                                            size_t size);
  using bio_template_destroy_fp = int (*)(bio_template_t tmpl);
  using bio_enrollment_begin_fp = int (*)(bio_sensor_t sensor,
                                          bio_enrollment_t* enrollment);
  using bio_enrollment_add_image_fp = int (*)(bio_enrollment_t enrollment,
                                              bio_image_t image);
  using bio_enrollment_is_complete_fp = int (*)(bio_enrollment_t enrollment);
  using bio_enrollment_get_percent_complete_fp =
      int (*)(bio_enrollment_t enrollment);
  using bio_enrollment_finish_fp = int (*)(bio_enrollment_t enrollment,
                                           bio_template_t* tmpl);

  BioLibrary() = default;
  bool Init(const base::FilePath& path);
  void* GetSymbolPointer(const std::string& sym) const;

  void* handle_ = nullptr;
  bool needs_exit_ = false;

  // See bio_algorithm.h for the documentation about these functions.
  bio_algorithm_init_fp algorithm_init_;
  bio_algorithm_exit_fp algorithm_exit_;
  bio_algorithm_get_type_fp algorithm_get_type_;
  bio_algorithm_get_name_fp algorithm_get_name_;
  bio_algorithm_get_version_fp algorithm_get_version_;
  bio_algorithm_get_banner_fp algorithm_get_banner_;
  bio_sensor_create_fp sensor_create_;
  bio_sensor_destroy_fp sensor_destroy_;
  bio_sensor_set_model_fp sensor_set_model_;
  bio_sensor_set_format_fp sensor_set_format_;
  bio_sensor_set_size_fp sensor_set_size_;
  bio_image_create_fp image_create_;
  bio_image_set_size_fp image_set_size_;
  bio_image_set_data_fp image_set_data_;
  bio_image_destroy_fp image_destroy_;
  bio_template_image_match_fp template_image_match_;
  bio_template_deserialize_fp template_deserialize_;
  bio_template_get_serialized_size_fp template_get_serialized_size_;
  bio_template_serialize_fp template_serialize_;
  bio_template_destroy_fp template_destroy_;
  bio_enrollment_begin_fp enrollment_begin_;
  bio_enrollment_add_image_fp enrollment_add_image_;
  bio_enrollment_is_complete_fp enrollment_is_complete_;
  bio_enrollment_get_percent_complete_fp enrollment_get_percent_complete_;
  bio_enrollment_finish_fp enrollment_finish_;

  DISALLOW_COPY_AND_ASSIGN(BioLibrary);
};

}  //  namespace biod

#endif  // BIOD_BIO_LIBRARY_H_