ble_connectivity_manager.h

Go to the documentation of this file.

/*
 * Copyright (c) 2023 Nordic Semiconductor ASA
 *
 * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
 */
 
#pragma once
 
#include "bridged_device_data_provider.h"
 
#include <bluetooth/gatt_dm.h>
#include <bluetooth/scan.h>
#include <zephyr/bluetooth/addr.h>
#include <zephyr/bluetooth/conn.h>
#include <zephyr/bluetooth/gatt.h>
#include <zephyr/kernel.h>
#include <zephyr/sys/ring_buffer.h>
#include <zephyr/sys/slist.h>
 
namespace Nrf
{
 
/* Forward declarations. */
struct BLEBridgedDevice;
struct BLEBridgedDeviceProvider;
 
class BLEConnectivityManager {
public:
        static constexpr uint16_t kScanTimeoutMs = CONFIG_BRIDGE_BT_SCAN_TIMEOUT_MS;
        static constexpr uint16_t kMaxScannedDevices = CONFIG_BRIDGE_BT_MAX_SCANNED_DEVICES;
        /* One BT connection is reserved for the Matter service purposes. */
        static constexpr uint16_t kMaxConnectedDevices = CONFIG_BT_MAX_CONN - 1;
        static constexpr uint8_t kMaxServiceUuids = CONFIG_BT_SCAN_UUID_CNT;
 
        enum State : uint8_t { Start = 0, Scanning = 0, Pairing, LostDevice, Connected, Idle, Unknown, End };
        using StateChangedCallback = void (*)(State state);
 
        struct ScannedDevice {
                bt_addr_le_t mAddr;
                bt_le_conn_param mConnParam;
                uint16_t mUuid;
        };
 
        struct ScanResult {
                ScannedDevice *mDevices = nullptr;
                uint8_t mCount = 0;
        };
 
private:
        class Recovery {
                friend class BLEConnectivityManager;
 
                /* Recovery intervals in seconds. */
                constexpr static auto kRecoveryIntervalSec = 1;
                constexpr static auto kRecoveryMaxIntervalSec = CONFIG_BRIDGE_BT_RECOVERY_MAX_INTERVAL;
 
                constexpr static auto kRecoveryScanTimeoutMs = CONFIG_BRIDGE_BT_RECOVERY_SCAN_TIMEOUT_MS;
 
                struct ListItem : public sys_snode_t {
                        BLEBridgedDeviceProvider *mProvider = nullptr;
                };
 
        public:
                Recovery();
                ~Recovery() { CancelTimer(); }
                void NotifyProviderToRecover(BLEBridgedDeviceProvider *provider);
 
        private:
                static bool EntryExists(BLEBridgedDeviceProvider *provider, sys_slist_t *list);
                static BLEBridgedDeviceProvider *GetProvider(sys_slist_t *list);
                static bool PutProvider(BLEBridgedDeviceProvider *provider, sys_slist_t *list);
                bool IsNeeded() { return !sys_slist_is_empty(&mListToRecover); }
                void StartTimer();
                void CancelTimer() { k_timer_stop(&mRecoveryTimer); }
                void RemoveRecovered(BLEBridgedDeviceProvider *provider);
                uint16_t GetFailedRecoveryAttempts();
 
                static void TimerTimeoutCallback(k_timer *timer);
 
                sys_slist_t mListToRecover;
                sys_slist_t mListToReconnect;
                k_timer mRecoveryTimer;
        };
 
        struct DiscoveryHandlerCtx {
                BLEBridgedDeviceProvider *mProvider;
                bt_gatt_dm *mDiscoveryData;
        };
 
public:
        using DeviceConnectedCallback = CHIP_ERROR (*)(bool success, void *context);
        using ScanDoneCallback = void (*)(ScanResult &result, void *context);
        using ConnectionSecurityRequestCallback = void (*)(void *context);
 
        struct ConnectionSecurityRequest {
                ConnectionSecurityRequestCallback mCallback;
                void *mContext;
        };
 
        CHIP_ERROR Init(const bt_uuid **serviceUuids, uint8_t serviceUuidsCount);
 
        CHIP_ERROR Scan(ScanDoneCallback callback, void *context, uint32_t scanTimeoutMs = kScanTimeoutMs);
 
        CHIP_ERROR StopScan();
 
        CHIP_ERROR Connect(BLEBridgedDeviceProvider *provider, ConnectionSecurityRequest *request = nullptr);
 
        CHIP_ERROR Reconnect(BLEBridgedDeviceProvider *provider);
 
        BLEBridgedDeviceProvider *FindBLEProvider(bt_addr_le_t address);
 
        CHIP_ERROR AddBLEProvider(BLEBridgedDeviceProvider *provider);
 
        CHIP_ERROR RemoveBLEProvider(bt_addr_le_t address);
 
        CHIP_ERROR GetScannedDeviceAddress(bt_addr_le_t *address, uint8_t index);
 
        CHIP_ERROR GetScannedDeviceUuid(uint16_t &uuid, uint8_t index);
 
        void Recover(BLEBridgedDeviceProvider *provider) { mRecovery.NotifyProviderToRecover(provider); }
 
        void RegisterStateCallback(StateChangedCallback callback) { mStateChangedCb = callback; }
 
        CHIP_ERROR PrepareFilterForUuid();
        CHIP_ERROR PrepareFilterForAddress(bt_addr_le_t *addr);
 
        /* Public static callbacks for Bluetooth LE connection handling. */
        static void FilterMatch(bt_scan_device_info *device_info, bt_scan_filter_match *filter_match, bool connectable);
        static void ScanTimeoutCallback(k_timer *timer);
        static void ScanTimeoutHandle(intptr_t context);
        static void ConnectionHandler(bt_conn *conn, uint8_t conn_err);
        static void DisconnectionHandler(bt_conn *conn, uint8_t reason);
        static void DiscoveryCompletedHandler(bt_gatt_dm *dm, void *context);
        static void DiscoveryNotFound(bt_conn *conn, void *context);
        static void DiscoveryError(bt_conn *conn, int err, void *context);
        static int StartGattDiscovery(bt_conn *conn, BLEBridgedDeviceProvider *provider);
#ifdef CONFIG_BRIDGE_FORCE_BT_CONNECTION_PARAMS
        static bool ParamChangeRequestHandler(struct bt_conn *conn, struct bt_le_conn_param *param);
#endif
 
#ifdef CONFIG_BT_SMP
        static void SecurityChangedHandler(struct bt_conn *conn, bt_security_t level, enum bt_security_err err);
        static void AuthenticationCancel(struct bt_conn *conn);
        static void PasskeyEntry(struct bt_conn *conn);
        static void PairingComplete(struct bt_conn *conn, bool bonded);
        static void PairingFailed(struct bt_conn *conn, enum bt_security_err reason);
 
        void SetPincode(bt_addr_le_t addr, unsigned int pincode);
#endif /* CONFIG_BT_SMP */
 
        static BLEConnectivityManager &Instance()
        {
                static BLEConnectivityManager sInstance;
                return sInstance;
        }
        static void ReScanCallback(ScanResult &result, void *context);
 
private:
        bt_le_conn_param *GetScannedDeviceConnParams(bt_addr_le_t address);
        State GetCurrentState();
        void UpdateStateFlag(State state, bool enabled);
        void UpdateRecovery();
 
        StateChangedCallback mStateChangedCb = nullptr;
        uint8_t mStateBitmask = 0;
        bool mScanActive;
        k_timer mScanTimer;
        uint8_t mScannedDevicesCounter;
        uint8_t mConnectedProvidersCounter;
        ScannedDevice mScannedDevices[kMaxScannedDevices];
        ScanResult mScanResult;
        BLEBridgedDeviceProvider *mConnectedProviders[kMaxConnectedDevices];
        bt_uuid *mServicesUuid[kMaxServiceUuids];
        uint8_t mServicesUuidCount;
        ScanDoneCallback mScanDoneCallback;
        void *mScanDoneCallbackContext;
#ifdef CONFIG_BT_SMP
        ConnectionSecurityRequest mConnectionSecurityRequest;
#endif /* CONFIG_BT_SMP */
        Recovery mRecovery;
};
 
} /* namespace Nrf */