fhn.h

Go to the documentation of this file.

/*
 * Copyright (c) 2026 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#ifndef BT_FAST_PAIR_FHN_H_
#define BT_FAST_PAIR_FHN_H_
 
#include <zephyr/bluetooth/conn.h>
#include <zephyr/sys/slist.h>
#include <zephyr/sys/util.h>
 
#ifdef __cplusplus
extern "C" {
#endif
 
enum bt_fast_pair_fhn_ring_src {
        BT_FAST_PAIR_FHN_RING_SRC_FHN_BT_GATT,
 
        BT_FAST_PAIR_FHN_RING_SRC_DULT_BT_GATT,
 
        BT_FAST_PAIR_FHN_RING_SRC_DULT_MOTION_DETECTOR,
};
 
enum bt_fast_pair_fhn_ring_comp {
        BT_FAST_PAIR_FHN_RING_COMP_RIGHT = BIT(0),
 
        BT_FAST_PAIR_FHN_RING_COMP_LEFT = BIT(1),
 
        BT_FAST_PAIR_FHN_RING_COMP_CASE = BIT(2),
};
 
#define BT_FAST_PAIR_FHN_RING_COMP_BM_NONE (0x00)
 
#define BT_FAST_PAIR_FHN_RING_COMP_BM_ALL (0xFF)
 
enum bt_fast_pair_fhn_ring_volume {
        BT_FAST_PAIR_FHN_RING_VOLUME_DEFAULT = 0x00,
 
        BT_FAST_PAIR_FHN_RING_VOLUME_LOW = 0x01,
 
        BT_FAST_PAIR_FHN_RING_VOLUME_MEDIUM = 0x02,
 
        BT_FAST_PAIR_FHN_RING_VOLUME_HIGH = 0x03,
};
 
#define BT_FAST_PAIR_FHN_RING_MSEC_PER_DSEC (100U)
 
#define BT_FAST_PAIR_FHN_RING_TIMEOUT_DS_TO_MS(_timeout_ds) \
        ((_timeout_ds) * BT_FAST_PAIR_FHN_RING_MSEC_PER_DSEC)
 
#define BT_FAST_PAIR_FHN_RING_TIMEOUT_MS_TO_DS(_timeout_ms) \
        ((_timeout_ms) / BT_FAST_PAIR_FHN_RING_MSEC_PER_DSEC)
 
struct bt_fast_pair_fhn_ring_req_param {
        uint8_t active_comp_bm;
 
        uint16_t timeout;
 
        enum bt_fast_pair_fhn_ring_volume volume;
};
 
struct bt_fast_pair_fhn_ring_cb {
        void (*start_request)(enum bt_fast_pair_fhn_ring_src src,
                              const struct bt_fast_pair_fhn_ring_req_param *param);
 
        void (*timeout_expired)(enum bt_fast_pair_fhn_ring_src src);
 
        void (*stop_request)(enum bt_fast_pair_fhn_ring_src src);
};
 
int bt_fast_pair_fhn_ring_cb_register(const struct bt_fast_pair_fhn_ring_cb *cb);
 
enum bt_fast_pair_fhn_ring_trigger {
        BT_FAST_PAIR_FHN_RING_TRIGGER_STARTED = 0x00,
 
        BT_FAST_PAIR_FHN_RING_TRIGGER_FAILED = 0x01,
 
        BT_FAST_PAIR_FHN_RING_TRIGGER_TIMEOUT_STOPPED = 0x02,
 
        BT_FAST_PAIR_FHN_RING_TRIGGER_UI_STOPPED = 0x03,
 
        BT_FAST_PAIR_FHN_RING_TRIGGER_GATT_STOPPED = 0x04,
};
 
struct bt_fast_pair_fhn_ring_state_param {
        enum bt_fast_pair_fhn_ring_trigger trigger;
 
        uint8_t active_comp_bm;
 
        uint16_t timeout;
};
 
int bt_fast_pair_fhn_ring_state_update(
        enum bt_fast_pair_fhn_ring_src src,
        const struct bt_fast_pair_fhn_ring_state_param *param);
 
struct bt_fast_pair_fhn_motion_detector_cb {
        void (*start)(void);
 
        bool (*period_expired)(void);
 
        void (*stop)(void);
};
 
int bt_fast_pair_fhn_motion_detector_cb_register(
        const struct bt_fast_pair_fhn_motion_detector_cb *cb);
 
#define BT_FAST_PAIR_FHN_BATTERY_LEVEL_NONE (0xFF)
 
int bt_fast_pair_fhn_battery_level_set(uint8_t percentage_level);
 
#define BT_FAST_PAIR_FHN_ADV_PARAM_INIT(_int_min, _int_max) \
{                                                            \
        .interval_min = (_int_min),                          \
        .interval_max = (_int_max),                          \
}
 
#define BT_FAST_PAIR_FHN_ADV_PARAM_DEFAULT                   \
        ((struct bt_fast_pair_fhn_adv_param[]) {              \
                BT_FAST_PAIR_FHN_ADV_PARAM_INIT(             \
                        0x0C80, /* 2s min interval */        \
                        0x0C80  /* 2s max interval */        \
        )})
 
struct bt_fast_pair_fhn_adv_param {
        uint32_t interval_min;
 
        uint32_t interval_max;
};
 
int bt_fast_pair_fhn_adv_param_set(
        const struct bt_fast_pair_fhn_adv_param *adv_param);
 
int bt_fast_pair_fhn_id_set(uint8_t id);
 
struct bt_fast_pair_fhn_info_cb {
        void (*clock_synced)(void);
 
        void (*conn_authenticated)(struct bt_conn *conn);
 
        void (*provisioning_state_changed)(bool provisioned);
 
        sys_snode_t node;
};
 
bool bt_fast_pair_fhn_is_provisioned(void);
 
int bt_fast_pair_fhn_info_cb_register(struct bt_fast_pair_fhn_info_cb *cb);
 
enum bt_fast_pair_fhn_read_mode {
        BT_FAST_PAIR_FHN_READ_MODE_FHN_RECOVERY,
 
        BT_FAST_PAIR_FHN_READ_MODE_DULT_ID,
};
 
struct bt_fast_pair_fhn_read_mode_cb {
        void (*exited)(enum bt_fast_pair_fhn_read_mode mode);
};
 
int bt_fast_pair_fhn_read_mode_cb_register(
        const struct bt_fast_pair_fhn_read_mode_cb *cb);
 
int bt_fast_pair_fhn_read_mode_enter(enum bt_fast_pair_fhn_read_mode mode);
 
#ifdef __cplusplus
}
#endif
 
#endif /* BT_FAST_PAIR_FHN_H_ */