subscribe_track_handler.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) 2024 Cisco Systems
// SPDX-License-Identifier: BSD-2-Clause
 
#pragma once
 
#include <quicr/detail/base_track_handler.h>
#include <quicr/detail/messages.h>
#include <quicr/detail/stream_buffer.h>
#include <quicr/metrics.h>
 
namespace quicr {

    class SubscribeTrackHandler : public BaseTrackHandler
    {
      public:
        enum class Error : uint8_t
        {
            kOk = 0,
            kNotAuthorized,
            kNotSubscribed,
            kNoData
        };

        enum class Status : uint8_t
        {
            kOk = 0,
            kNotConnected,
            kError,
            kNotAuthorized,
            kNotSubscribed,
            kPendingResponse,
            kSendingUnsubscribe, 
            kPaused,
            kNewGroupRequested,
        };

        struct JoiningFetch
        {
            const messages::SubscriberPriority priority;
            const messages::GroupOrder group_order;
            const messages::Parameters parameters;
            const messages::GroupId joining_start;
            const bool absolute;
        };
 
      protected:
        SubscribeTrackHandler(const FullTrackName& full_track_name,
                              messages::SubscriberPriority priority,
                              messages::GroupOrder group_order,
                              messages::FilterType filter_type,
                              const std::optional<JoiningFetch>& joining_fetch = std::nullopt,
                              bool publisher_initiated = false)
          : BaseTrackHandler(full_track_name)
          , priority_(priority)
          , group_order_(group_order)
          , filter_type_(filter_type)
          , joining_fetch_(publisher_initiated ? std::nullopt : joining_fetch)
          , publisher_initiated_(publisher_initiated)
        {
        }
 
      public:
        static std::shared_ptr<SubscribeTrackHandler> Create(
          const FullTrackName& full_track_name,
          messages::SubscriberPriority priority,
          messages::GroupOrder group_order = messages::GroupOrder::kAscending,
          messages::FilterType filter_type = messages::FilterType::kLargestObject)
        {
            return std::shared_ptr<SubscribeTrackHandler>(
              new SubscribeTrackHandler(full_track_name, priority, group_order, filter_type));
        }

        constexpr Status GetStatus() const noexcept { return status_; }

        void SetPriority(uint8_t priority) noexcept { priority_ = priority; }

        constexpr messages::SubscriberPriority GetPriority() const noexcept { return priority_; }

 
        constexpr messages::GroupOrder GetGroupOrder() const noexcept { return group_order_; }

 
        constexpr messages::FilterType GetFilterType() const noexcept { return filter_type_; }
 
        constexpr std::optional<messages::Location> GetLatestLocation() const noexcept { return latest_location_; }
 
        constexpr void SetLatestLocation(messages::Location new_location) noexcept { latest_location_ = new_location; }

        std::optional<JoiningFetch> GetJoiningFetch() const noexcept { return joining_fetch_; }

        void SetTrackAlias(uint64_t track_alias) { track_alias_ = track_alias; }

        std::optional<uint64_t> GetTrackAlias() const noexcept { return track_alias_; }

        void SetReceivedTrackAlias(uint64_t track_alias) { received_track_alias_ = track_alias; }

        std::optional<uint64_t> GetReceivedTrackAlias() const noexcept { return received_track_alias_; }

        void Pause() noexcept;

        void Resume() noexcept;

        void RequestNewGroup() noexcept;
 
        std::chrono::milliseconds GetDeliveryTimeout() const noexcept { return delivery_timeout_; }
 
        void SetDeliveryTimeout(std::chrono::milliseconds timeout) noexcept { delivery_timeout_ = timeout; }
 
        // --------------------------------------------------------------------------
        // Public Virtual API callback event methods
        // --------------------------------------------------------------------------

        virtual void ObjectReceived([[maybe_unused]] const ObjectHeaders& object_headers,
                                    [[maybe_unused]] BytesSpan data);

        virtual void StreamDataRecv(bool is_start,
                                    uint64_t stream_id,
                                    std::shared_ptr<const std::vector<uint8_t>> data);

        virtual void DgramDataRecv(std::shared_ptr<const std::vector<uint8_t>> data);

        virtual void PartialObjectReceived([[maybe_unused]] const ObjectHeaders& object_headers,
                                           [[maybe_unused]] BytesSpan data)
        {
        }

        virtual void StatusChanged([[maybe_unused]] Status status) {}

        virtual void MetricsSampled([[maybe_unused]] const SubscribeTrackMetrics& metrics) {}


        bool IsPublisherInitiated() const noexcept { return publisher_initiated_; }

        SubscribeTrackMetrics subscribe_track_metrics_;
 
      protected:
        void SetStatus(Status status) noexcept
        {
            status_ = status;
            StatusChanged(status);
        }
 
        StreamBuffer<uint8_t> stream_buffer_;
 
        uint64_t next_object_id_{ 0 };
        uint64_t current_group_id_{ 0 };
        bool sent_first_object_{ false };
 
      private:
        Status status_{ Status::kNotSubscribed };
        messages::SubscriberPriority priority_;
        messages::GroupOrder group_order_;
        messages::FilterType filter_type_;
        uint64_t current_stream_id_{ 0 };
        std::optional<messages::Location> latest_location_;
        std::optional<JoiningFetch> joining_fetch_;
        std::optional<uint64_t> track_alias_;
        std::optional<uint64_t> received_track_alias_; 
        std::chrono::milliseconds delivery_timeout_{ 0 };
 
        bool publisher_initiated_{ false };
 
        friend class Transport;
        friend class Client;
        friend class Server;
    };
 
} // namespace moq