Pixel.h

Go to the documentation of this file.

 
#pragma once
 
#include <functional>
#include <memory>
#include <algorithm>
#include <limits>
#include <string>
#include <vector>
#include <chrono>
#include <mutex>
#include <future>
#include "Systemic/Internal/GuardedList.h"
#include "ScannedPixel.h"
#include "MessageSerialization.h"
 
namespace Systemic::BluetoothLE
{
    class Peripheral;
    class Characteristic;
}
 
namespace Systemic::Pixels
{
    enum class PixelStatus
    {
        Disconnected,
        Connecting,
        Identifying,
        Ready,
        Disconnecting,
    };
 
    class Pixel;
 
#pragma warning(push)
#pragma warning(disable : 4100) // unreferenced formal parameter
 
    struct PixelDelegate
    {
        virtual void onStatusChanged(std::shared_ptr<Pixel> pixel, PixelStatus status) {}
        // TODO virtual void onNameChanged(std::shared_ptr<Pixel> pixel, std::wstring name) {}
 
        virtual void onFirmwareDateChanged(std::shared_ptr<Pixel> pixel, std::chrono::system_clock::time_point firmwareDate) {}
 
        virtual void onRssiChanged(std::shared_ptr<Pixel> pixel, int rssi) {}
 
        virtual void onBatteryLevelChanged(std::shared_ptr<Pixel> pixel, int batteryLevel) {}
 
        virtual void onChargingStateChanged(std::shared_ptr<Pixel> pixel, bool isCharging) {}
 
        virtual void onRollStateChanged(std::shared_ptr<Pixel> pixel, PixelRollState state, int face) {}
 
        virtual void onRolled(std::shared_ptr<Pixel> pixel, int face) {}
 
        virtual void onMessageReceived(std::shared_ptr<Pixel> pixel, std::shared_ptr<const Messages::PixelMessage> message) {}
    };
 
#pragma warning(pop)
 
    class Pixel : public std::enable_shared_from_this<Pixel>, public PixelInfo
    {
        using StatusCallback = std::function<void(PixelStatus)>;
        using MessageCallback = std::function<void(std::shared_ptr<const Messages::PixelMessage>)>;
 
        // Constant data
        const std::shared_ptr<Systemic::BluetoothLE::Peripheral> _peripheral;
        const std::shared_ptr<PixelDelegate> _delegate;
 
        // Mutable data
        ScannedPixelData _data;
        PixelStatus _status{};
        std::shared_ptr<Systemic::BluetoothLE::Characteristic> _notifyCharacteristic{};
        std::shared_ptr<Systemic::BluetoothLE::Characteristic> _writeCharacteristic{};
 
        // Mutex for modifying the above data
        std::recursive_mutex _mutex{};
 
        // Internal lists of status and message notifications
        GuardedList<StatusCallback> _internalStatusCbs;
        GuardedList<MessageCallback> _internalMsgCbs;
 
    public:
        enum class ConnectResult
        {
            Success,
 
            ConnectionFailed,
 
            Cancelled,
 
            IdentificationMismatch,
 
            IdentificationTimeout,
 
            SubscriptionError,
        };
 
        static std::shared_ptr<Pixel> create(
            bluetooth_address_t address,
            std::shared_ptr<PixelDelegate> delegate = nullptr)
        {
            return std::shared_ptr<Pixel>(new Pixel{ ScannedPixel{ ScannedPixelData{ address } }, delegate });
        }
 
        static std::shared_ptr<Pixel> create(
            const ScannedPixel& scannedPixel,
            std::shared_ptr<PixelDelegate> delegate = nullptr)
        {
            return std::shared_ptr<Pixel>(new Pixel{ scannedPixel, delegate });
        }
 
        virtual ~Pixel() = default;
 
        PixelStatus status() const
        {
            return _status;
        }
 
        bool isReady() const
        {
            return _status == PixelStatus::Ready;
        }
 
        virtual bluetooth_address_t systemId() const override
        {
            return _data.address;
        }
 
        virtual bluetooth_address_t address() const override
        {
            return _data.address;
        }
 
        virtual pixel_id_t pixelId() const override
        {
            return _data.pixelId;
        }
 
        virtual const std::wstring& name() const override
        {
            return _data.name;
        }
 
        virtual int ledCount() const override
        {
            return _data.ledCount;
        }
 
        virtual PixelDesignAndColor designAndColor() const override
        {
            return _data.designAndColor;
        }
 
        virtual Date firmwareDate() const override
        {
            return _data.firmwareDate;
        }
 
        virtual int rssi() const override
        {
            return _data.rssi;
        }
 
        virtual int batteryLevel() const override
        {
            return _data.batteryLevel;
        }
 
        virtual bool isCharging() const override
        {
            return _data.isCharging;
        }
 
        virtual PixelRollState rollState() const override
        {
            return _data.rollState;
        }
 
        virtual int currentFace() const override
        {
            return _data.currentFace;
        }
 
        std::future<ConnectResult> connectAsync();
 
        void disconnect();
 
        std::future<bool> sendMessageAsync(Messages::MessageType type, bool withoutAck = false)
        {
            std::vector<uint8_t> data{ static_cast<uint8_t>(type) };
            return sendMessageAsync(data, withoutAck);
        }
 
        template <typename T, std::enable_if_t<std::is_base_of_v<Messages::PixelMessage, T>, int> = 0>
        std::future<bool> sendMessageAsync(const T& message, bool withoutAck = false)
        {
            std::vector<uint8_t> data{};
            Messages::Serialization::serializeMessage(message, data);
            return sendMessageAsync(data, withoutAck);
        }
 
        template <class Rep, class Period>
        std::future<std::shared_ptr<const Messages::PixelMessage>> sendAndWaitForResponseAsync(
            Messages::MessageType type,
            Messages::MessageType responseType,
            std::chrono::duration<Rep, Period> timeout = std::chrono::seconds(5))
        {
            std::promise<std::shared_ptr<const Messages::PixelMessage>> responsePromise{};
 
            MessageCallback callback{ [&responseType, &responsePromise](auto msg)
                {
                    if (msg->type == responseType)
                    {
                        responsePromise.set_value(msg);
                    }
                } };
 
            const auto cbIndex = _internalMsgCbs.add(callback);
 
            const auto sendResult = co_await sendMessageAsync(type);
 
            std::shared_ptr<const Messages::PixelMessage> response{};
            if (sendResult)
            {
                auto respFuture = responsePromise.get_future();
                if (respFuture.wait_for(timeout) == std::future_status::ready)
                {
                    response = respFuture.get();
                }
            }
 
            _internalMsgCbs.remove(cbIndex);
 
            co_return response;
        }
 
        std::future<std::shared_ptr<const Messages::PixelMessage>> sendAndWaitForResponseAsync(
            Messages::MessageType type,
            Messages::MessageType responseType)
        {
            return sendAndWaitForResponseAsync(type, responseType, std::chrono::seconds(5));
        }
 
        template <class Rep, class Period>
        std::future<bool> reportRssiAsync(
            bool activate,
            std::chrono::duration<Rep, Period> minInterval)
        {
            Messages::RequestRssi msg{};
            msg.requestMode = activate ? Messages::TelemetryRequestMode::Automatic : Messages::TelemetryRequestMode::Off;
            down_cast(msg.minInterval, std::chrono::milliseconds{ minInterval }.count());
            return sendMessageAsync(msg);
        }
 
        std::future<bool> reportRssiAsync(bool activate = true)
        {
            return reportRssiAsync(activate, std::chrono::seconds(5));
        }
 
        std::future<bool> turnOffAsync();
 
        template <class Rep, class Period>
        std::future<bool> blinkAsync(
            std::chrono::duration<Rep, Period> duration,
            uint32_t rgbColor,
            int count = 1,
            float fade = 1)
        {
            Messages::Blink msg{};
            down_cast(msg.count, count);
            down_cast(msg.duration, std::chrono::milliseconds{ duration }.count());
            msg.color = rgbColor;
            msg.faceMask = 0xFFFF;
            down_cast(msg.fade, 255 * fade);
            msg.loop = 0;
            // TODO return sendAndWaitForResponseAsync(msg, Messages::MessageType::BlinkAck);
            return sendMessageAsync(msg);
        }
 
    private:
        Pixel(const ScannedPixel& scannedPixel, std::shared_ptr<PixelDelegate> delegate);
        bool updateStatus(PixelStatus expectedStatus, PixelStatus newStatus, PixelStatus* outLastStatus = nullptr);
        std::future<ConnectResult> internalSetupAsync();
        void onValueChanged(const std::vector<uint8_t>& data);
        void processMessage(const Messages::PixelMessage& message);
        std::future<bool> sendMessageAsync(const std::vector<uint8_t>& data, bool withoutAck = false);
 
        template <typename T1, typename T2>
        static T1 down_cast(T1& dst, T2 src)
        {
            return dst = static_cast<T1>(std::min<T2>(src, std::numeric_limits<T1>::max()));
        }
    };
}