room_event_types.h

/*
 * Copyright 2025 LiveKit
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an “AS IS” BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdint>
#include <map>
#include <memory>
#include <optional>
#include <string>
#include <vector>
 
#include "livekit/video_codec.h"
 
namespace livekit {
 
// Forward declarations to avoid pulling in heavy headers.
class Track;
class Participant;
class RemoteParticipant;
class RemoteDataTrack;
class LocalTrackPublication;
class RemoteTrackPublication;
class TrackPublication;
 
enum class TrackSource;
 
enum class ConnectionQuality {
  Poor = 0,
  Good,
  Excellent,
  Lost,
};
 
enum class ConnectionState {
  Disconnected = 0,
  Connected,
  Reconnecting,
};
 
enum class DataPacketKind {
  Lossy,
  Reliable,
};
 
enum class EncryptionState {
  New = 0,
  Ok,
  EncryptionFailed,
  DecryptionFailed,
  MissingKey,
  KeyRatcheted,
  InternalError,
};
 
enum class DisconnectReason {
  Unknown = 0,
  ClientInitiated,
  DuplicateIdentity,
  ServerShutdown,
  ParticipantRemoved,
  RoomDeleted,
  StateMismatch,
  JoinFailure,
  Migration,
  SignalClose,
  RoomClosed,
  UserUnavailable,
  UserRejected,
  SipTrunkFailure,
  ConnectionTimeout,
  MediaFailure,
  AgentError
};
 
struct UserPacketData {
  std::vector<std::uint8_t> data;
 
  std::optional<std::string> topic;
};
 
struct SipDtmfData {
  std::uint32_t code = 0;
 
  std::optional<std::string> digit;
};
 
struct RoomInfoData {
  std::optional<std::string> sid;
 
  std::string name;
 
  std::string metadata;
 
  std::uint64_t lossy_dc_buffered_amount_low_threshold = 0;
 
  std::uint64_t reliable_dc_buffered_amount_low_threshold = 0;
 
  std::uint32_t empty_timeout = 0;
 
  std::uint32_t departure_timeout = 0;
 
  std::uint32_t max_participants = 0;
 
  std::int64_t creation_time = 0;
 
  std::uint32_t num_participants = 0;
 
  std::uint32_t num_publishers = 0;
 
  bool active_recording = false;
};
 
struct AttributeEntry {
  std::string key;
 
  std::string value;
 
  AttributeEntry() = default;
 
  AttributeEntry(std::string k, std::string v) : key(std::move(k)), value(std::move(v)) {}
};
 
struct DataStreamHeaderData {
  std::string stream_id;
 
  std::int64_t timestamp = 0;
 
  std::string mime_type;
 
  std::string topic;
 
  std::optional<std::uint64_t> total_length;
 
  std::map<std::string, std::string> attributes;
 
  enum class ContentType {
    None,
    Text,
    Byte,
  } content_type = ContentType::None;
 
  enum class OperationType {
    Create = 0,
    Update = 1,
    Delete = 2,
    Reaction = 3,
  };
 
  std::optional<OperationType> operation_type;
 
  std::optional<int> version;
 
  std::optional<std::string> reply_to_stream_id;
 
  std::vector<std::string> attached_stream_ids;
 
  std::optional<bool> generated;
 
  std::optional<std::string> name;
};
 
struct DataStreamChunkData {
  std::string stream_id;
 
  std::uint64_t chunk_index = 0;
 
  std::vector<std::uint8_t> content;
 
  std::optional<int> version;
 
  std::vector<std::uint8_t> iv;
};
 
struct DataStreamTrailerData {
  std::string stream_id;
 
  std::string reason;
 
  std::map<std::string, std::string> attributes;
};
 
struct VideoEncodingOptions {
  std::uint64_t max_bitrate = 0;
 
  double max_framerate = 0.0;
};
 
struct AudioEncodingOptions {
  std::uint64_t max_bitrate = 0;
};
 
enum class VideoEncoderBackend {
  Auto = 0,
  Software = 1,
  Hardware = 2,
  Nvenc = 3,
  Vaapi = 4,
  VideoToolbox = 5,
  PreEncoded = 6,
};
 
enum class DegradationPreference {
  Balanced = 0,
  MaintainFramerate = 1,
  MaintainResolution = 2,
  MaintainFramerateAndResolution = 4,
};
 
struct FrameMetadataFeatures {
  bool user_timestamp = false;
 
  bool frame_id = false;
 
  bool user_data = false;
};
 
using PacketTrailerFeatures [[deprecated("PacketTrailerFeatures is deprecated; use FrameMetadataFeatures instead")]] =
    FrameMetadataFeatures;
 
struct TrackPublishOptions {
  std::optional<VideoEncodingOptions> video_encoding;
 
  std::optional<AudioEncodingOptions> audio_encoding;
 
  std::optional<VideoCodec> video_codec;
 
  std::optional<bool> dtx;
 
  std::optional<bool> red;
 
  std::optional<bool> simulcast;
 
  std::optional<TrackSource> source;
 
  std::optional<std::string> stream;
 
  std::optional<bool> preconnect_buffer;
 
  std::optional<FrameMetadataFeatures> frame_metadata_features;
 
  [[deprecated("TrackPublishOptions::packet_trailer_features is deprecated; use frame_metadata_features instead")]]
  FrameMetadataFeatures packet_trailer_features{};
 
  std::optional<DegradationPreference> degradation_preference;
 
  std::optional<VideoEncoderBackend> video_encoder;
};
 
// ---------------------------------------------------------
// Event structs – public representations of RoomEvent.*
// ---------------------------------------------------------
 
struct ParticipantConnectedEvent {
  RemoteParticipant* participant = nullptr;
};
 
struct ParticipantDisconnectedEvent {
  RemoteParticipant* participant = nullptr;
 
  DisconnectReason reason = DisconnectReason::Unknown;
};
 
struct LocalTrackPublishedEvent {
  std::shared_ptr<LocalTrackPublication> publication;
 
  std::shared_ptr<Track> track;
};
 
struct LocalTrackUnpublishedEvent {
  std::shared_ptr<LocalTrackPublication> publication;
};
 
struct LocalTrackSubscribedEvent {
  std::shared_ptr<Track> track;
};
 
struct TrackPublishedEvent {
  std::shared_ptr<RemoteTrackPublication> publication;
 
  RemoteParticipant* participant = nullptr;
};
 
struct TrackUnpublishedEvent {
  std::shared_ptr<RemoteTrackPublication> publication;
 
  RemoteParticipant* participant = nullptr;
};
 
struct TrackSubscribedEvent {
  std::shared_ptr<Track> track;
 
  std::shared_ptr<RemoteTrackPublication> publication;
 
  RemoteParticipant* participant = nullptr;
};
 
struct TrackUnsubscribedEvent {
  std::shared_ptr<Track> track;
 
  std::shared_ptr<RemoteTrackPublication> publication;
 
  RemoteParticipant* participant = nullptr;
};
 
struct TrackSubscriptionFailedEvent {
  RemoteParticipant* participant = nullptr;
 
  std::string track_sid;
 
  std::string error;
};
 
struct TrackMutedEvent {
  Participant* participant = nullptr;
 
  std::shared_ptr<TrackPublication> publication;
};
 
struct TrackUnmutedEvent {
  Participant* participant = nullptr;
 
  std::shared_ptr<TrackPublication> publication;
};
 
struct ActiveSpeakersChangedEvent {
  std::vector<Participant*> speakers;
};
 
struct RoomMetadataChangedEvent {
  std::string old_metadata;
 
  std::string new_metadata;
};
 
struct RoomSidChangedEvent {
  std::string sid;
};
 
struct ParticipantMetadataChangedEvent {
  Participant* participant = nullptr;
 
  std::string old_metadata;
 
  std::string new_metadata;
};
 
struct ParticipantNameChangedEvent {
  Participant* participant = nullptr;
 
  std::string old_name;
 
  std::string new_name;
};
 
struct ParticipantAttributesChangedEvent {
  Participant* participant = nullptr;
 
  std::vector<AttributeEntry> changed_attributes;
};
 
struct ParticipantEncryptionStatusChangedEvent {
  Participant* participant = nullptr;
 
  bool is_encrypted = false;
};
 
struct ConnectionQualityChangedEvent {
  Participant* participant = nullptr;
 
  ConnectionQuality quality = ConnectionQuality::Good;
};
 
struct UserDataPacketEvent {
  std::vector<std::uint8_t> data;
 
  DataPacketKind kind = DataPacketKind::Reliable;
 
  RemoteParticipant* participant = nullptr;
 
  std::string topic;
};
 
struct SipDtmfReceivedEvent {
  int code = 0;
 
  std::string digit;
 
  RemoteParticipant* participant = nullptr;
};
 
struct ConnectionStateChangedEvent {
  ConnectionState state = ConnectionState::Disconnected;
};
 
struct DisconnectedEvent {
  DisconnectReason reason = DisconnectReason::Unknown;
};
 
struct ReconnectingEvent {};
 
struct ReconnectedEvent {};
 
struct TokenRefreshedEvent {
  std::string token;
};
 
struct RoomEosEvent {};
 
struct DataStreamHeaderReceivedEvent {
  std::string participant_identity;
 
  DataStreamHeaderData header;
};
 
struct DataStreamChunkReceivedEvent {
  std::string participant_identity;
 
  DataStreamChunkData chunk;
};
 
struct DataStreamTrailerReceivedEvent {
  std::string participant_identity;
 
  DataStreamTrailerData trailer;
};
 
struct DataChannelBufferedAmountLowThresholdChangedEvent {
  DataPacketKind kind = DataPacketKind::Reliable;
 
  std::uint64_t threshold = 0;
};
 
struct ByteStreamOpenedEvent {
  std::uint64_t reader_handle = 0;
 
  std::string participant_identity;
};
 
struct TextStreamOpenedEvent {
  std::uint64_t reader_handle = 0;
 
  std::string participant_identity;
};
 
struct RoomUpdatedEvent {
  RoomInfoData info;
};
 
struct RoomMovedEvent {
  RoomInfoData info;
};
 
struct ParticipantsUpdatedEvent {
  std::vector<Participant*> participants;
};
 
struct E2eeStateChangedEvent {
  Participant* participant = nullptr;
 
  EncryptionState state = EncryptionState::New;
};
 
struct DataTrackPublishedEvent {
  std::shared_ptr<RemoteDataTrack> track;
};
 
struct DataTrackUnpublishedEvent {
  std::string sid;
};
 
} // namespace livekit