Getting Started with Subscribing

import MillicastSDK

let session = AVAudioSession.sharedInstance()
try session.setCategory(
    .playback,
    mode: .videoChat,
    options: [.mixWithOthers, .allowBluetooth, .allowBluetoothA2DP]
)
try session.setActive(true)

let subscriber = MCSubscriber()

let subscriberDelegate = YourSubscriberDelegate() // where the `YourSubscriberDelegate` is a type that you implement, that conforms to `MCSubscriberDelegate` 
let subscriber = MCSubscriber(delegate: subscriberDelegate)

let credentials = MCSubscriberCredentials()
credentials.streamName =  "STREAM_NAME"; // The name of the stream you want to subscribe to
credentials.accountId = "ACCOUNT_ID"; // The ID of your Dolby.io Real-time Streaming account
credentials.apiUrl = "https://director.millicast.com/api/director/subscribe"; // The subscribe API URL

try await subscriber.setCredentials(credentials)

let connectionOptions = MCConnectionOptions()
// Set to `true` if you would like the SDK to reconnect to stream on a connection error; for example - when the network is lost and later restored.
connectionOptions.autoReconnect = true

try await subscriber.connect(with: connectionOptions)

let subscriberOptions = MCClientOptions()
// The main source that will be received by the default media stream
subscriberOptions.pinnedSourceId = "MySource";
// Enables audio multiplexing and denotes the number of audio tracks to receive
// as Voice Activity Detection (VAD) multiplexed audio
subscriberOptions.multiplexedAudioTrack = 3;
// Audio streams that should not be included in the multiplex, for
// example your own audio stream
subscriberOptions.excludedSourceId = [ "excluded" ]
// Delay in milliseconds to configure how frequently would you like to receive the
// stream statistics
subscriberOptions.statsDelayMs = 5000

try await subscriber.subscribe(with: subscriberOptions)

// `sourceIdToVideoTrackDictionary` is used to retain the video tracks returned by the SDK. This helps setup listeners on track or to enable/disable tracks at a later point in time.
var sourceIdToVideoTrackDictionary: [String: MCRTSRemoteVideoTrack] = [:]

// `sourceIdToAudioTrackDictionary` is used to retain the audio tracks returned by the SDK. This helps setup listeners on track or to enable/disable tracks at a later point in time.
var sourceIdToAudioTrackDictionary: [String: MCRTSRemoteAudioTrack] = [:]

// `sourceIdToRendererDictionary` is used to retain renderer used to enable a video track. The renderers can later be used to display video views on the user interface.
var sourceIdToRendererDictionary: [String: MCRTSRemoteAudioTrack] = [:]

for await track in subscriber.rtsRemoteTrackAdded() {
  if let videoTrack = track.asVideo() {
    // Each video track has a one to one relationship to each renderer.
    // Multiview scenarios require instantiating multiple renderers, one for each track.
    let renderer = MCCMSampleBufferVideoRenderer()
    try await videoTrack.enable(renderer: renderer)
    // Save the renderer and video track
    sourceIdToRendererDictionary[videoTrack.sourceId] = renderer
    sourceIdToVideoTrackDictionary[videoTrack.sourceId] = videoTrack
  } else if let audioTrack = track.asAudio() {
    // Enable an audio track.
    try await audioTrack.enable()
    sourceIdToVideoTrackDictionary[audioTrack.sourceId] = audioTrack
  }
}

subscriber.rtsRemoteTrackAddedPublisher
  .sink { track in
    Task {
      if let videoTrack = track.asVideo() {
        // Each video track has a one to one relationship to each renderer.
        // Multiview scenarios require instantiating multiple renderers, one for each track.
        let renderer = MCCMSampleBufferVideoRenderer()
        try await videoTrack.enable(renderer: renderer)
        // Save the renderer and video track
        sourceIdToRendererDictionary[videoTrack.sourceId] = renderer
        sourceIdToVideoTrackDictionary[videoTrack.sourceId] = videoTrack
      } else if let audioTrack = track.asAudio() {
        // Enable an audio track.
        try await audioTrack.enable()
        sourceIdToAudioTrackDictionary[audioTrack.sourceId] = audioTrack
      }
    }
  }

for await activity in videoTrack.activity() {
  switch activity {
  case .inactive:
    // Optional.
    // The SDK automatically restores the state of the track when it transitions to `active` from an `inactive` state.
    // You can optionally disable the video track when it becomes inactive. This step is optional. This gives you control on when to enable the track when it comes back active.
    try await videoTrack.disable()

  case .active:
    // Optional.
    // If you choose to disable a track when it became inactive, you have to enable the video track back after it is active again.
    // At any point in time when you wish to start receive video from the track, call -
    try await videoTrack.enable(renderer: renderer)
  }
}

for await activity in audioTrack.activity() {
  switch activity {
  case .inactive:
    // Optional.
    // The SDK automatically restores the state of the track when it transitions to `active` from an `inactive` state. You can optionally disable the audio track when it becomes inactive, so that the responsibility is on you to enable the track when it becomes active.
    try await audioTrack.disable()

  case .active:
    // Optional.
    // At any point in time where you wish to play audio from the track, call -
    try await audioTrack.enable()
  }
}

for await layerEvent in videoTrack.layers() {
    // If your application requires to select a specific layer based on an application logic -
    // Re-enable the track by passing in the layer that you want to select from the list.
    let selectedLayer = layerEvent.layers[0]
    try await videoTrack.enable(renderer: renderer, layer: selectedLayer)
}

for await state in subscriber.websocketState() {
  // Log or handle the state change
}

for await state in subscriber.peerConnectionState() {
  // Log or handle the state change
}

struct VideoView: View {
  private let renderer: MCCMSampleBufferVideoRenderer

  // Important: The renderer passed in for display should be the one that is used to enable a video track.
  init(renderer: MCCMSampleBufferVideoRenderer) {
    self.renderer = renderer
  }

  var body: some View {
    MCVideoSwiftUIView(renderer: .sampleBuffer(renderer))
  }
}

let renderer = MCAcceleratedVideoRenderer()
let videoView = MCAcceleratedVideoUIView(frame: view.bounds, renderer: renderer)
view.addSubview(videoView)

await subscriber.enableStats(true)

for await statsReport in subscriber.statsReport() {
    // Parse the stats report for logging or display on to the user interface
}

for await error in subscriber.httpError() {
  // Handle http error
}

subscriber.httpErrorPublisher()
  .sink { error in
      // Handle http error
  }

for await error in subscriber.signalingError() {
  // Handle signalling error
}

subscriber.signalingErrorPublisher()
  .sink { error in
  // Handle signalling error
  }

try await subscriber.unsubscribe()
try await subscriber.disconnect()

// Clear the stored tracks and renderers
sourceIdToVideoTrackDictionary.removeAll()
sourceIdToAudioTrackDictionary.removeAll()
sourceIdToRendererDictionary.removeAll()