bridge_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 "binding/binding_handler.h"
#include "bridge_util.h"
#include "util/finite_map.h"
#include "bridged_device_data_provider.h"
#include "matter_bridged_device.h"
 
namespace Nrf
{
 
class BridgeManager {
public:
        static constexpr uint8_t kMaxBridgedDevices = CHIP_DEVICE_CONFIG_DYNAMIC_ENDPOINT_COUNT;
        static constexpr uint8_t kMaxBridgedDevicesPerProvider = CONFIG_BRIDGE_MAX_BRIDGED_DEVICES_NUMBER_PER_PROVIDER;
        static constexpr chip::EndpointId kAggregatorEndpointId = CONFIG_BRIDGE_AGGREGATOR_ENDPOINT_ID;
 
        using LoadStoredBridgedDevicesCallback = CHIP_ERROR (*)();
 
        CHIP_ERROR Init(LoadStoredBridgedDevicesCallback loadStoredBridgedDevicesCb);
 
        CHIP_ERROR AddBridgedDevices(MatterBridgedDevice *devices[], BridgedDeviceDataProvider *dataProvider,
                                     uint8_t deviceListSize, uint8_t devicesPairIndexes[]);
 
        CHIP_ERROR AddBridgedDevices(MatterBridgedDevice *devices[], BridgedDeviceDataProvider *dataProvider,
                                     uint8_t deviceListSize, uint8_t devicesPairIndexes[], uint16_t endpointIds[]);
 
        CHIP_ERROR RemoveBridgedDevice(uint16_t endpoint, uint8_t &devicesPairIndex);
 
        CHIP_ERROR GetDevicesIndexes(uint8_t *indexes, uint8_t maxSize, uint8_t &count)
        {
                if (!indexes) {
                        return CHIP_ERROR_INVALID_ARGUMENT;
                }
 
                if (maxSize < mDevicesIndexesCounter) {
                        return CHIP_ERROR_BUFFER_TOO_SMALL;
                }
 
                memcpy(indexes, mDevicesIndexes, mDevicesIndexesCounter);
                count = mDevicesIndexesCounter;
                return CHIP_NO_ERROR;
        }
 
        BridgedDeviceDataProvider *GetProvider(chip::EndpointId endpoint, uint16_t &deviceType);
 
        const char *GetNodeLabel(chip::EndpointId endpoint);
 
        static CHIP_ERROR HandleRead(uint16_t index, chip::ClusterId clusterId,
                                     const EmberAfAttributeMetadata *attributeMetadata, uint8_t *buffer,
                                     uint16_t maxReadLength);
        static CHIP_ERROR HandleWrite(uint16_t index, chip::ClusterId clusterId,
                                      const EmberAfAttributeMetadata *attributeMetadata, uint8_t *buffer);
        static void HandleUpdate(BridgedDeviceDataProvider &dataProvider, chip::ClusterId clusterId,
                                 chip::AttributeId attributeId, void *data, size_t dataSize);
        static void HandleCommand(BridgedDeviceDataProvider &dataProvider, chip::ClusterId clusterId,
                                  chip::CommandId commandId, Nrf::Matter::BindingHandler::InvokeCommand invokeCommand);
 
        static BridgeManager &Instance()
        {
                static BridgeManager sInstance;
                return sInstance;
        }
 
private:
        struct BridgedDevicePair {
                BridgedDevicePair() : mDevice(nullptr), mProvider(nullptr) {}
                BridgedDevicePair(MatterBridgedDevice *device, BridgedDeviceDataProvider *dataProvider)
                        : mDevice(device), mProvider(dataProvider)
                {
                }
 
                ~BridgedDevicePair()
                {
                        chip::Platform::Delete(mDevice);
                        chip::Platform::Delete(mProvider);
                        mDevice = nullptr;
                        mProvider = nullptr;
                }
 
                /* Disable copy semantics and implement move semantics. */
                BridgedDevicePair(const BridgedDevicePair &other) = delete;
                BridgedDevicePair &operator=(const BridgedDevicePair &other) = delete;
 
                BridgedDevicePair(BridgedDevicePair &&other)
                {
                        mDevice = other.mDevice;
                        mProvider = other.mProvider;
 
                        other.mDevice = nullptr;
                        other.mProvider = nullptr;
                }
 
                BridgedDevicePair &operator=(BridgedDevicePair &&other)
                {
                        if (this != &other) {
                                this->~BridgedDevicePair();
                                mDevice = other.mDevice;
                                mProvider = other.mProvider;
                                other.mDevice = nullptr;
                                other.mProvider = nullptr;
                        }
                        return *this;
                }
 
                operator bool() const { return mDevice || mProvider; }
                bool operator==(const BridgedDevicePair &other)
                {
                        return (mDevice == other.mDevice) || (mProvider == other.mProvider);
                }
 
                MatterBridgedDevice *mDevice;
                BridgedDeviceDataProvider *mProvider;
        };
 
        static constexpr uint8_t kMaxDataProviders = CONFIG_BRIDGE_MAX_BRIDGED_DEVICES_NUMBER;
 
        using DeviceMap = FiniteMap<uint16_t, BridgedDevicePair, kMaxBridgedDevices>;
 
        CHIP_ERROR AddSingleDevice(MatterBridgedDevice *device, BridgedDeviceDataProvider *dataProvider,
                                   chip::Optional<uint8_t> &devicesPairIndex, uint16_t endpointId);
        CHIP_ERROR SafelyRemoveDevice(uint8_t index);
 
        CHIP_ERROR DoAddBridgedDevices(MatterBridgedDevice *devices[], BridgedDeviceDataProvider *dataProvider,
                                       uint8_t deviceListSize, uint8_t devicesPairIndexes[], uint16_t endpointIds[],
                                       chip::Optional<uint8_t> indexes[]);
 
        CHIP_ERROR AddDevices(MatterBridgedDevice *devices[], BridgedDeviceDataProvider *dataProvider,
                              uint8_t deviceListSize, chip::Optional<uint8_t> devicesPairIndexes[],
                              uint16_t endpointIds[]);
 
        CHIP_ERROR CreateEndpoint(uint8_t index, uint16_t endpointId);
 
        DeviceMap mDevicesMap;
        uint16_t mNumberOfProviders{ 0 };
        uint8_t mDevicesIndexes[BridgeManager::kMaxBridgedDevices] = { 0 };
        uint8_t mDevicesIndexesCounter;
 
        chip::EndpointId mFirstDynamicEndpointId;
        chip::EndpointId mCurrentDynamicEndpointId;
        bool mIsInitialized = false;
};
 
} /* namespace Nrf */