connectivity_manager.hpp

// SPDX-License-Identifier: Apache-2.0
// Copyright 2020 - 2024 Pionix GmbH and Contributors to EVerest
 
#pragma once
 
#include <ocpp/common/websocket/websocket.hpp>
#include <ocpp/v2/messages/SetNetworkProfile.hpp>
#include <ocpp/v2/ocpp_types.hpp>
 
#include <functional>
#include <future>
#include <optional>
namespace ocpp {
namespace v2 {
 
class DeviceModel;
 
using WebsocketConnectionCallback = std::function<void(
    int configuration_slot, const NetworkConnectionProfile& network_connection_profile, OcppProtocolVersion version)>;
using WebsocketConnectionFailedCallback = std::function<void(ConnectionFailedReason reason)>;
using ConfigureNetworkConnectionProfileCallback = std::function<std::future<ConfigNetworkResult>(
    const int32_t configuration_slot, const NetworkConnectionProfile& network_connection_profile)>;
 
class ConnectivityManagerInterface {
public:
    virtual ~ConnectivityManagerInterface() {
    }
    virtual void set_websocket_authorization_key(const std::string& authorization_key) = 0;
 
    virtual void set_websocket_connection_options(const WebsocketConnectionOptions& connection_options) = 0;
 
    virtual void set_websocket_connection_options_without_reconnect() = 0;
 
    virtual void set_websocket_connected_callback(WebsocketConnectionCallback callback) = 0;
 
    virtual void set_websocket_disconnected_callback(WebsocketConnectionCallback callback) = 0;
 
    virtual void set_websocket_connection_failed_callback(WebsocketConnectionFailedCallback callback) = 0;
 
    virtual void
    set_configure_network_connection_profile_callback(ConfigureNetworkConnectionProfileCallback callback) = 0;
 
    virtual std::optional<NetworkConnectionProfile>
    get_network_connection_profile(const int32_t configuration_slot) const = 0;
 
    virtual std::optional<int32_t> get_priority_from_configuration_slot(const int configuration_slot) const = 0;
 
    virtual const std::vector<int>& get_network_connection_slots() const = 0;
 
    virtual bool is_websocket_connected() = 0;
 
    virtual void connect(std::optional<int32_t> network_profile_slot = std::nullopt) = 0;
 
    virtual void disconnect() = 0;
 
    virtual bool send_to_websocket(const std::string& message) = 0;
 
    virtual void on_network_disconnected(OCPPInterfaceEnum ocpp_interface) = 0;
 
    virtual void on_charging_station_certificate_changed() = 0;
 
    virtual void confirm_successful_connection() = 0;
};
 
class ConnectivityManager : public ConnectivityManagerInterface {
private:
    DeviceModel& device_model;
    std::shared_ptr<EvseSecurity> evse_security;
    std::shared_ptr<MessageLogging> logging;
    std::unique_ptr<Websocket> websocket;
    std::function<void(const std::string& message)> message_callback;
    std::optional<WebsocketConnectionCallback> websocket_connected_callback;
    std::optional<WebsocketConnectionCallback> websocket_disconnected_callback;
    std::optional<WebsocketConnectionFailedCallback> websocket_connection_failed_callback;
    std::optional<ConfigureNetworkConnectionProfileCallback> configure_network_connection_profile_callback;
 
    Everest::SteadyTimer websocket_timer;
    std::optional<int32_t> pending_configuration_slot;
    bool wants_to_be_connected;
    int32_t active_network_configuration_priority;
    int last_known_security_level;
    std::vector<SetNetworkProfileRequest> cached_network_connection_profiles;
    std::vector<int32_t> network_connection_slots;
    OcppProtocolVersion connected_ocpp_version;
 
public:
    ConnectivityManager(DeviceModel& device_model, std::shared_ptr<EvseSecurity> evse_security,
                        std::shared_ptr<MessageLogging> logging,
                        const std::function<void(const std::string& message)>& message_callback);
 
    void set_websocket_authorization_key(const std::string& authorization_key) override;
    void set_websocket_connection_options(const WebsocketConnectionOptions& connection_options) override;
    void set_websocket_connection_options_without_reconnect() override;
    void set_websocket_connected_callback(WebsocketConnectionCallback callback) override;
    void set_websocket_disconnected_callback(WebsocketConnectionCallback callback) override;
    void set_websocket_connection_failed_callback(WebsocketConnectionFailedCallback callback) override;
    void set_configure_network_connection_profile_callback(ConfigureNetworkConnectionProfileCallback callback) override;
    std::optional<NetworkConnectionProfile>
    get_network_connection_profile(const int32_t configuration_slot) const override;
    std::optional<int32_t> get_priority_from_configuration_slot(const int configuration_slot) const override;
    const std::vector<int>& get_network_connection_slots() const override;
    bool is_websocket_connected() override;
    void connect(std::optional<int32_t> network_profile_slot = std::nullopt) override;
    void disconnect() override;
    bool send_to_websocket(const std::string& message) override;
    void on_network_disconnected(OCPPInterfaceEnum ocpp_interface) override;
    void on_charging_station_certificate_changed() override;
    void confirm_successful_connection() override;
 
private:
    void try_connect_websocket();
 
    std::optional<WebsocketConnectionOptions> get_ws_connection_options(const int32_t configuration_slot);
 
    std::optional<ConfigNetworkResult>
    handle_configure_network_connection_profile_callback(int slot, const NetworkConnectionProfile& profile);
 
    void on_websocket_connected(OcppProtocolVersion protocol);
 
    void on_websocket_disconnected();
 
    void on_websocket_stopped_connecting(ocpp::WebsocketCloseReason reason);
 
    int get_active_network_configuration_slot() const;
 
    int get_configuration_slot_from_priority(const int priority);
 
    int get_next_configuration_slot(int32_t configuration_slot);
 
    void cache_network_connection_profiles();
 
    void check_cache_for_invalid_security_profiles();
 
    void remove_network_connection_profiles_below_actual_security_profile();
};
 
} // namespace v2
} // namespace ocpp