Getting Started with Publishing

import MillicastSDK

// Configure the audio session for capturing
let session = AVAudioSession.sharedInstance()
try session.setCategory(
    .playAndRecord,
    mode: .videoChat,
    options: [.mixWithOthers, .allowBluetooth, .allowBluetoothA2DP]
)
try session.setActive(true)

// Create an audio track
var audioTrack : MCAudioTrack? = nil
if
    let audioSources = MCMedia.getAudioSources(), // Get an array of audio sources
    !audioSources.isEmpty // There is at least one audio source
{
    // Choose the preferred audio source and start capturing
    let audioSource = audioSources[0]
    audioTrack = audioSource.startCapture() as? MCAudioTrack
}

// Create a video track
var videoTrack : MCVideoTrack? = nil
if
    let videoSources = MCMedia.getVideoSources(), // Get an array of available video sources
    !videoSources.isEmpty // There is at least one video source
{
    // Choose the preferred video source
    let videoSource = videoSources[0];

    // Get capabilities of the available video sources, such as
    // width, height, and frame rate of the video sources
    guard let capabilities = videoSource.getCapabilities() else {
        fatalError("No capability is available!") // In production replace with a throw
    }

    let capability = capabilities[0]; // Get the first capability
    videoSource.setCapability(capability);

    // Start video recording and create a video track
    videoTrack = videoSource.startCapture() as? MCVideoTrack
}

let publisher = MCPublisher()

let publisherDelegate = YourPublisherDelegate() // where the `YourPublisherDelegate` is a type that you implement, that conforms to `MCPublisherDelegate` 
let publisher = MCPublisher(delegate: publisherDelegate)

// Get the credentials structure from your publisher instance, fill it in,
// and set the modified credentials
let credentials = MCPublisherCredentials()
credentials.streamName = "streamName"; // The name of the stream you want to publish
credentials.token = "aefea56153765316754fe"; // The publishing token
credentials.apiUrl
    = "https://director.millicast.com/api/director/publish"; // The publish API URL

do {
  try await publisher.setCredentials(credentials);
} catch MCGenericError.noCredentials {
  // You have provided incomplete credentials
  // such as an empty streamName, token, or url
}

await publisher.addTrack(with: audioTrack)
await publisher.addTrack(with: videoTrack)

let publisherOptions = MCClientOptions()

// Get a list of supported codecs
if let audioCodecs = MCMedia.getSupportedAudioCodecs() {
    // Choose the preferred audio codec
    publisherOptions.audioCodec = audioCodecs[0]

} else {
    print("No audio codecs available!") // In production, replace it with proper error handling
}

if let videoCodecs = MCMedia.getSupportedVideoCodecs() {
    // Choose the preferred video codec
    publisherOptions.videoCodec = videoCodecs[0]

} else {
    print("No video codecs available!") // In production, replace it with proper error handling
}

// To use multi-source, set a source ID of the publisher and
// enable discontinuous transmission
publisherOptions.sourceId = "MySource"
publisherOptions.dtx = true

// Enable stereo
publisherOptions.stereo = true

do {
  try await publisher.connect()
  // using publisherOptions from step 2.4
  try await publisher.publish(with: publisherOptions)
} catch MCGenericError.restAPIError {
  // Handle invalid credentials passed to the publisher
}

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

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

for await activity in publisher.activity() {
  case .inactive:
    // TODO: Received when the last viewer of your stream goes inactive
    break
  case .active:
    // TODO: Received when the first viewer starts viewing your stream
    break
}

for await viewerCount in publisher.viewerCount() {
  // use the `viewerCount` for displaying on the UI
}

await publisher.enableStats(true)

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

let connectionOptions = MCConnectionOptions()
connectionOptions.autoReconnect = false

do {
  try await publisher.connect(with: connectionOptions)
} catch error {
  //...
}

Task {
  for await state in publisher.state() {
    if case .connectionError(let status, let reason) = state {
      try await publisher.disconnect()
    }
  }
}

do {
  try await publisher.connect(with: connectionOptions)
} catch MCAsyncOperationCancelledError.aborted {
  // The operation has been aborted by the disconnect call above
}

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

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

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

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

// Stop publishing your content
try await publisher.unpublish()

// Clears all tracks added to the publisher.
await publisher.clearTracks()

// Disconnect the millicast service
try await publisher.disconnect()