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/transport.h>
#include <quicr/track_name.h>
 
namespace quicr {
    using namespace quicr;
 
    class Client : public Transport
    {
      public:
        Client(const ClientConfig& cfg)
          : Transport(cfg, std::make_shared<ThreadedTickService>())
        {
        }
 
        ~Client() = default;
 
        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::SubscribeAnnouncesErrorCode> error_code,
                                                     std::optional<messages::ReasonPhrase> reason);
 
        virtual void UnpublishedSubscribeReceived(const FullTrackName& track_full_name,
                                                  const SubscribeAttributes& subscribe_attributes);
 
        virtual void ResolveSubscribe(ConnectionHandle connection_handle,
                                      uint64_t subscribe_id,
                                      const SubscribeResponse& subscribe_response);
 
        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));
            }
        }
 
        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;
 
        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