client.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include <optional>
#include <quicr/common.h>
#include <quicr/config.h>
#include <quicr/detail/attributes.h>
#include <quicr/detail/transport.h>
#include <quicr/publish_fetch_handler.h>
#include <quicr/track_name.h>
 
namespace quicr {
    using namespace quicr;

    class Client : public Transport
    {
      protected:
        Client(const ClientConfig& cfg)
          : Transport(cfg, std::make_shared<ThreadedTickService>(cfg.tick_service_sleep_delay_us))
        {
        }
 
      public:
        ~Client() = default;
 
        static std::shared_ptr<Client> Create(const ClientConfig& cfg)
        {
            return std::shared_ptr<Client>(new Client(cfg));
        }

        Status Connect();

        Status Disconnect();
 
        // --BEGIN CALLBACKS ----------------------------------------------------------------------------------

        virtual void ServerSetupReceived(const ServerSetupAttributes& server_setup_attributes);

        virtual void AnnounceStatusChanged(const TrackNamespace& track_namespace, const PublishAnnounceStatus status);

        virtual void AnnounceReceived(const TrackNamespace& track_namespace,
                                      const PublishAnnounceAttributes& announce_attributes);

        virtual void UnannounceReceived(const TrackNamespace& track_namespace);

        virtual void SubscribeAnnouncesStatusChanged(const TrackNamespace& track_namespace,
                                                     std::optional<messages::SubscribeNamespaceErrorCode> error_code,
                                                     std::optional<messages::ReasonPhrase> reason);

        virtual void UnpublishedSubscribeReceived(const FullTrackName& track_full_name,
                                                  const messages::SubscribeAttributes& subscribe_attributes);

        virtual void ResolveSubscribe(ConnectionHandle connection_handle,
                                      uint64_t request_id,
                                      uint64_t track_alias,
                                      const SubscribeResponse& subscribe_response);

        bool FetchReceived(quicr::ConnectionHandle connection_handle,
                           uint64_t request_id,
                           const quicr::FullTrackName& track_full_name,
                           const quicr::messages::FetchAttributes& attributes) override;

        void BindFetchTrack(TransportConnId conn_id, std::shared_ptr<PublishFetchHandler> track_handler);

        void UnbindFetchTrack(ConnectionHandle conn_id, const std::shared_ptr<PublishFetchHandler>& track_handler);

        void MetricsSampled(const ConnectionMetrics& metrics) override;

        // --END OF CALLBACKS ----------------------------------------------------------------------------------

        PublishAnnounceStatus GetAnnounceStatus(const TrackNamespace& track_namespace);

        void SubscribeTrack(std::shared_ptr<SubscribeTrackHandler> track_handler)
        {
            if (connection_handle_) {
                Transport::SubscribeTrack(*connection_handle_, std::move(track_handler));
            }
        }

        virtual uint64_t RequestTrackStatus(const FullTrackName& track_full_name,
                                            const messages::SubscribeAttributes& subscribe_attributes = {})
        {
            if (connection_handle_) {
                return Transport::RequestTrackStatus(*connection_handle_, track_full_name, subscribe_attributes);
            }
            return 0;
        }

        void UnsubscribeTrack(std::shared_ptr<SubscribeTrackHandler> track_handler)
        {
            if (connection_handle_) {
                Transport::UnsubscribeTrack(*connection_handle_, std::move(track_handler));
            }
        }

        void PublishAnnounce(const TrackNamespace& track_namespace);

        void PublishUnannounce(const TrackNamespace& track_namespace);

        void SubscribeAnnounces(const TrackNamespace& prefix_namespace)
        {
            if (!connection_handle_) {
                return;
            }
 
            SendSubscribeAnnounces(*connection_handle_, prefix_namespace);
        }

        void UnsubscribeAnnounces(const TrackNamespace& prefix_namespace)
        {
            if (!connection_handle_) {
                return;
            }
 
            SendUnsubscribeAnnounces(*connection_handle_, prefix_namespace);
        }

        void PublishTrack(std::shared_ptr<PublishTrackHandler> track_handler)
        {
            if (connection_handle_) {
                Transport::PublishTrack(*connection_handle_, std::move(track_handler));
            }
        }

        void UnpublishTrack(std::shared_ptr<PublishTrackHandler> track_handler)
        {
            if (connection_handle_) {
                Transport::UnpublishTrack(*connection_handle_, std::move(track_handler));
            }
        }

        void FetchTrack(std::shared_ptr<FetchTrackHandler> track_handler)
        {
            if (connection_handle_.has_value()) {
                Transport::FetchTrack(connection_handle_.value(), std::move(track_handler));
            }
        }

        void CancelFetchTrack(std::shared_ptr<FetchTrackHandler> track_handler)
        {
            if (connection_handle_.has_value()) {
                Transport::CancelFetchTrack(connection_handle_.value(), std::move(track_handler));
            }
        }

        std::optional<ConnectionHandle> GetConnectionHandle() const { return connection_handle_; }
 
      private:
        bool ProcessCtrlMessage(ConnectionContext& conn_ctx, BytesSpan stream_buffer) override;
        PublishTrackHandler::PublishObjectStatus SendFetchObject(PublishFetchHandler& track_handler,
                                                                 uint8_t priority,
                                                                 uint32_t ttl,
                                                                 bool stream_header_needed,
                                                                 uint64_t group_id,
                                                                 uint64_t subgroup_id,
                                                                 uint64_t object_id,
                                                                 std::optional<Extensions> extensions,
                                                                 BytesSpan data) const;
 
        void SetConnectionHandle(ConnectionHandle connection_handle) override
        {
            connection_handle_ = connection_handle;
        }
 
        void SetStatus(Status status)
        {
            status_ = status;
            StatusChanged(status);
        }
 
        std::optional<ConnectionHandle> connection_handle_; 
    };
 
} // namespace quicr