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 
        };
 
      protected:
        SubscribeTrackHandler(const FullTrackName& full_track_name,
                              messages::ObjectPriority priority,
                              messages::GroupOrder group_order,
                              messages::FilterType filter_type)
          : BaseTrackHandler(full_track_name)
          , priority_(priority)
          , group_order_(group_order)
          , filter_type_(filter_type)
        {
        }
 
      public:
        static std::shared_ptr<SubscribeTrackHandler> Create(
          const FullTrackName& full_track_name,
          messages::ObjectPriority priority,
          messages::GroupOrder group_order = messages::GroupOrder::kAscending,
          messages::FilterType filter_type = messages::FilterType::kLatestObject)
        {
            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::ObjectPriority 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::GroupId> GetLatestGroupID() const noexcept { return latest_group_id_; }
        constexpr std::optional<messages::ObjectId> GetLatestObjectID() const noexcept { return latest_object_id_; }
 
        constexpr void SetLatestGroupID(messages::GroupId new_id) noexcept { latest_group_id_ = new_id; }
        constexpr void SetLatestObjectID(messages::ObjectId new_id) noexcept { latest_object_id_ = new_id; }
 
        // --------------------------------------------------------------------------
        // 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) {}
 
        void RequestNewGroup() noexcept;
 
 
        SubscribeTrackMetrics subscribe_track_metrics_;
 
        std::function<void(messages::SubscribeId, messages::TrackAlias)> new_group_request_callback_;
 
      protected:
        void SetStatus(Status status) noexcept
        {
            status_ = status;
            StatusChanged(status);
        }
 
      private:
        Status status_{ Status::kNotSubscribed };
        messages::ObjectPriority priority_;
        messages::GroupOrder group_order_;
        messages::FilterType filter_type_;
        StreamBuffer<uint8_t> stream_buffer_;
        uint64_t current_stream_id_{ 0 };
        std::optional<messages::GroupId> latest_group_id_;
        std::optional<messages::ObjectId> latest_object_id_;
 
        friend class Transport;
        friend class Client;
        friend class Server;
    };
 
} // namespace moq