Channel Express - Deprecated

import PhenixSdk
 
let pcastExpressOptions = PhenixPCastExpressFactory.createPCastExpressOptionsBuilder()
    .withAuthenticationToken("DIGEST:eyJhc...")
    .buildPCastExpressOptions()
 
let roomExpressOptions = PhenixRoomExpressFactory.createRoomExpressOptionsBuilder()
    .withPCastExpressOptions(pcastExpressOptions)
    .buildRoomExpressOptions()
 
let channelExpressOptions = PhenixChannelExpressFactory.createChannelExpressOptionsBuilder()
    .withRoomExpressOptions(roomExpressOptions)
    .buildChannelExpressOptions()
 
let channelExpress = PhenixChannelExpressFactory.createChannelExpress(channelExpressOptions)

import PhenixSdk
 
let channelExpress: PhenixChannelExpress = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
// Just an example (you can omit renderer options if defaults are ok)
let rendererOptions = PhenixRendererOptions()
options.aspectRatioMode = .letterbox
 
let joinRoomOptions = PhenixRoomExpressFactory.createJoinRoomOptionsBuilder()
    .withRoomAlias("MyAwesomeChannel")
    .buildJoinRoomOptions()
 
let joinChannelOptions = PhenixChannelExpressFactory.createJoinChannelOptionsBuilder()
    .withJoinRoomOptions(joinRoomOptions)
    .withStreamToken("DIGEST:eyJhc...")
    .withStreamSelectionStrategy(.mostRecent)
    .withRenderer(renderLayer)
    .withRendererOptions(rendererOptions)
    .buildJoinChannelOptions()
 
channelExpress.joinChannel(
    joinChannelOptions,
    { [weak self] (requestStatus: PhenixRequestStatus, roomService: PhenixRoomService?) in
      guard requestStatus == .ok, let strongSelf = self else {
        // Handle channel join error
        return
      }
 
      // Important: Store room service reference, otherwise we will leave channel again immediately:
      strongSelf.currentRoomService = roomService
    },
    { [weak self]
        (requestStatus: PhenixRequestStatus,
         expressSubscriber: PhenixExpressSubscriber?,
         renderer: PhenixRenderer?) in
      guard let strongSelf = self else {
        return
      }
      if (requestStatus == .ok) {
        // Successfully subscribed to a stream. No need to hold on to any references
      } else if (requestStatus == .noStreamPlaying) {
        // No stream playing in channel, update UI accordingy
      } else {
        // We failed to subscribe and retry attempts must have failed
      }
    });

import PhenixSdk
 
let channelExpress: PhenixChannelExpress = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
// Using ChannelOptions means that the channel may or may not already exist.
// If the channel ID is known in advance, it is recommended to use `withChannelId` instead
// of `withChannelOptions` when assembling the `PhenixPublishToChannelOptions` below
let channelOptions = PhenixRoomServiceFactory.createChannelOptionsBuilder()
    .withName("MyAwesomeChannel")
    // Not required but if it is provided we will use this as the alias instead
    // of pre-generating one for you:
    .withAlias("MyAwesomeChannelAlias")
    .buildChannelOptions()
 
// Example constraints. Audio and video are enabled by default
let mediaConstraints = PhenixUserMediaOptions()
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.facingMode.rawValue] =
    [PhenixDeviceConstraint.initWith(.user)]
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.frameRate.rawValue] =
    [PhenixDeviceConstraint.initWith(15)]
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.height.rawValue] =
    [PhenixDeviceConstraint.initWith(720)]
mediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.width.rawValue] =
    [PhenixDeviceConstraint.initWith(1280)]
 
mediaConstraints.audio.capabilityConstraints[PhenixDeviceCapability.audioEchoCancelationMode.rawValue] =
    [PhenixDeviceConstraint.initWith(PhenixAudioEchoCancelationMode.on)]
 
let publishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withStreamToken("DIGEST:eyJhc...")
    .withMediaConstraints(mediaConstraints)
    .withPreviewRenderer(renderLayer)
    .buildPublishOptions()
 
let publishToChannelOptions = PhenixChannelExpressFactory.createPublishToChannelOptionsBuilder()
    .withChannelOptions(channelOptions)
    .withPublishOptions(publishOptions)
    .buildPublishToChannelOptions()
 
channelExpress.publish(
    toChannel: publishToChannelOptions,
    withPreviewCallback: { [weak self] (
        status: PhenixRequestStatus,
        roomService: PhenixRoomService?,
        publisher: PhenixExpressPublisher?,
        previewRenderer: PhenixRenderer?) in
      guard status == .ok, let strongSelf = self else {
        // Handle channel publish error
        return
      }
 
      // Important: Store publisher reference, otherwise we will stop publishing again immediately:
      strongSelf.currentPublisher = publisher
    })
 
// OR (without a preview):
 
channelExpress.publish(
    toChannel: publishToChannelOptions,
    withCallback: { [weak self] (
        status: PhenixRequestStatus,
        roomService: PhenixRoomService?,
        publisher: PhenixExpressPublisher?) in
      guard status == .ok, let strongSelf = self else {
        // Handle channel publish error
        return
      }
 
      // Important: Store publisher reference, otherwise we will stop publishing again immediately:
      strongSelf.currentPublisher = publisher
    })

import PhenixSdk
 
let channelExpress: PhenixChannelExpress = ...  // previously obtained
 
let channelOptions = PhenixRoomServiceFactory.createChannelOptionsBuilder()
    .withName("MyAwesomeChannel")
    .withAlias("MyAwesomeChannelAlias")  // Not required but if it is provided we will use this as the alias instead
                                         // of pre-generating one for you.
    .buildChannelOptions()
 
channelExpress.createChannel(
    channelOptions,
    { (status: PhenixRequestStatus, channel: PhenixImmutableRoom?) in
      guard status == .ok else {
        // Handle room create error
        return
      }
 
      // use `channel` to e.g. join
    })