iOS SDK Version Comparison

import PhenixSdk
 
let pcastExpressOptions = PhenixPCastExpressFactory.createPCastExpressOptionsBuilder()
    .withBackendUri("https://example.yourdomain.com/phenix/")
    .buildPCastExpressOptions()
 
let pcastExpress = PhenixPCastExpressFactory.createPCastExpress(pcastExpressOptions)

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
 
let userMediaConstraints = PhenixUserMediaOptions()
userMediaConstraints.video.enabled = true
userMediaConstraints.video.capabilityConstraints[PhenixDeviceCapability.facingMode.rawValue] =
    [PhenixDeviceConstraint.initWith(PhenixFacingMode.user)]
userMediaConstraints.audio.enabled = true
userMediaConstraints.audio.capabilityConstraints[PhenixDeviceCapability.audioEchoCancelationMode.rawValue] =
    [PhenixDeviceConstraint.initWith(PhenixAudioEchoCancelationMode.on)]
 
let publishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withCapabilities(["real-time"])
    .withMediaConstraints(userMediaConstraints)
    .buildPublishOptions()
 
pcastExpress.publish(publishOptions) { (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?) in
  if status == .ok {
    // Do something with publisher
  } else {
    // Handle error
  }
}
 
 
// Create a publisher with an automatically started preview renderer
let renderLayer: CALayer = ...  // previously obtained
let publishOptionsWithPreview = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withCapabilities(["real-time"])
    .withMediaConstraints(userMediaConstraints)
    .withPreviewRenderer(renderLayer)
    .buildPublishOptions()
 
pcastExpress.publish(withPreview: publishOptionsWithPreview) {
    (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?, preview: PhenixRenderer?) in
  if status == .ok {
    // Do something with publisher and preview renderer
  } else {
    // Handle error
  }
}

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
 
let publishRemoteOptions = PhenixPCastExpressFactory.createPublishRemoteOptionsBuilder()
    .withStreamUri("http://mycdn.example.com/mystream.mp4")
    .withCapabilities([""])
    .buildPublishRemoteOptions()
 
pcastExpress.publishRemote(publishRemoteOptions) { (status: PhenixRequestStatus, publisher: PhenixExpressPublisher?) in
  if status == .ok {
    // Do something with publisher
  } else {
    // Handle error
  }
}

import PhenixSdk
 
let pcastExpress: PhenixPCastExpress = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
let subscribeOptions = PhenixPCastExpressFactory.createSubscribeOptionsBuilder()
    .withStreamId("us-west#us-west1-b.zzzzzzzz.20000000.xxxxxxxx")
    .withCapabilities(["real-time"])
    .withRenderer(renderLayer)
    .buildSubscribeOptions()
 
pcastExpress.subscribe(subscribeOptions) { (status: PhenixRequestStatus, subscriber: PhenixExpressSubscriber?, renderer: PhenixRenderer?) in
  if status == .ok {
    // Do something with subscriber
 
    if let renderer = renderer {
      // Returned if `withRenderer...` option was enabled - Do something with renderer
    }
  } else {
    // Handle error
  }
}

import PhenixSdk
 
let monitorOptions = PhenixPCastExpressFactory.createMonitorOptionsBuilder().buildMonitorOptions();
 
let subscribeOptions = PhenixPCastExpressFactory.createSubscribeOptionsBuilder()
    .withStreamId("us-west#us-west1-b.zzzzzzzz.20000000.xxxxxxxx")
    .withStreamToken("DIGEST:eyJhc...")
    .withMonitor({ (status: PhenixRequestStatus, retry: PhenixOptionalAction?) in
          // Stream failed to setup, check if retry is a possibility:
          if let retry = retry, retry.isPresent() {
            if determineWhetherToRetry() {
              retry.perform()
            } else {
              // Not technically necessary, but here for clarity
              retry.dismiss()
            }
          }
        },
        { (reason: PhenixStreamEndedReason, description: String?, retry: PhenixOptionalAction?) in
          // Stream has ended, check if due to failure
          if let retry = retry, retry.isPresent() {
            if reason == .failed {
              retry.perform()
            } else {
              // Not technically necessary, but here for clarity
              retry.dismiss()
            }
          }
        },
        monitorOptions)
    .buildSubscribeOptions()

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
    })

import PhenixSdk
 
let pcastExpressOptions = PhenixPCastExpressFactory.createPCastExpressOptionsBuilder()
    .withAuthenticationToken("DIGEST:eyJhc...")
    .buildPCastExpressOptions()
 
let roomExpressOptions = PhenixRoomExpressFactory.createRoomExpressOptionsBuilder()
    .withPCastExpressOptions(pcastExpressOptions)
    .buildRoomExpressOptions()
 
let roomExpress = PhenixRoomExpressFactory.createRoomExpress(roomExpressOptions)

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ...  // previously obtained
 
let joinRoomOptions = PhenixRoomExpressFactory.createJoinRoomOptionsBuilder()
    .withRoomAlias("myRoom42")
    .withCapabilities(["streaming"])
    .buildJoinRoomOptions()
 
roomExpress.joinRoom(joinRoomOptions, { (status: PhenixRequestStatus, roomService: PhenixRoomService?) in
    if status == .ok {
      // Hold on to roomService reference for as long as you wish to stay in the room
    } else {
      // Handle error
    }
  })
 
// With optional member update notification:
roomExpress.joinRoom(
    joinRoomOptions,
    { (status: PhenixRequestStatus, roomService: PhenixRoomService?) in
      if status == .ok {
        // Hold on to roomService reference for as long as you wish to stay in the room
      } else {
        // Handle error
      }
    },
    { (members: [PhenixMember]?) in
      // Do something with room members
    })

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ... // previously obtained
let room: PhenixImmutableRoom = ...  // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
// Just an example showing how to get a stream from a member.
// In a real-world app you would want to subscribe to the room-members-observable on the room
// to receive updates when the list of members changes, and then subscribe to the streams-observable
// on each member to access their streams.
let member = room.getObservableMembers().getValue()[0] as! PhenixMember
let memberStream = member.getObservableStreams().getValue[0] as! PhenixStream
 
let options = PhenixRoomExpressFactory.createSubscribeToMemberStreamOptionsBuilder()
    .withRenderer(renderLayer)
    .buildSubscribeToMemberStreamOptions()
 
roomExpress.subscribe(
    toMemberStream: memberStream,
    options,
    { [weak self] (
        status: PhenixRequestStatus,
        subscriber: PhenixExpressSubscriber?,
        renderer: PhenixRenderer?) in
      guard status == .ok, let strongSelf = self else {
        // Handle subscribe error
        return
      }
 
      // Important: Store subscriber reference, otherwise we will stop subscription immediately:
      strongSelf.currentSubscriber = subscriber
    })

import PhenixSdk
 
let roomExpress: PhenixRoomExpress = ... // previously obtained
let renderLayer: CALayer = ...  // previously obtained
 
let mediaConstraints = PhenixUserMediaOptions()
// Customize constraints if needed
 
let localPublishOptions = PhenixPCastExpressFactory.createPublishOptionsBuilder()
    .withCapabilities(["hd", "streaming"])
    .withMediaConstraints(mediaConstraints)
    .withPreviewRenderer(renderLayer)
    .buildPublishOptions()
 
let roomOptions = PhenixRoomServiceFactory.createRoomOptionsBuilder()
    .withName("MyAwesomeRoom")
    .buildRoomOptions()
 
let localPublishToRoomOptions = PhenixRoomExpressFactory.createPublishToRoomOptionsBuilder()
    .withStreamType(.user)
    .withMemberRole(.participant)
    .withRoomOptions(roomOptions)
    .withPublishOptions(localPublishOptions)
    .buildPublishToRoomOptions()
 
roomExpress.publish(
    toRoom: localPublishToRoomOptions,
    withCallback: { [weak self] (
        status: PhenixRequestStatus,
        roomService: PhenixRoomService?,
        publisher: PhenixExpressPublisher?) in
      guard status == .ok, let strongSelf = self else {
        // Handle publish error
        return
      }
 
      // Important: Store publisher reference, otherwise we will stop publisher immediately:
      strongSelf.currentPublisher = publisher
    })
 
 
// OR for a remote stream:
let remotePublishOptions = PhenixPCastExpressFactory.createPublishRemoteOptionsBuilder()
    .withStreamUri("http://example.com/mystream.mp4")
    .buildPublishRemoteOptions()
 
let remotePublishToRoomOptions = PhenixRoomExpressFactory.createPublishToRoomOptionsBuilder()
    .withStreamType(.user)
    .withMemberRole(.participant)
    .withRoomOptions(roomOptions)
    .withPublishRemoteOptions(remotePublishOptions)
    .buildPublishToRoomOptions()
 
// Remaining code is the same as for local stream
 

@import PhenixSdk;
 
// Generated via EdgeAuth library
NSString* authenticationToken = ...;
// Previously initialized
id<PhenixPCast> pcast = ...;
 
[pcast start:
    authenticationToken:
    ^(id<PhenixPCast> pcast, PhenixRequestStatus status, NSString* sessionId) {
        if (status == PhenixRequestStatusOk) {
            NSLog(@"PCast started...");
        } else {
            NSLog(@"Failed to start PCast...");
        }
    }:
    ^(id<PhenixPCast> pcast) {
        NSLog(@"We are online...");
    }:
    ^(id<PhenixPCast> pcast) {
        NSLog(@"We are offline...");
    }];

@import PhenixSdk;
 
// Previously initialized and started
id<PhenixPCast> pcast = ...;
 
PhenixUserMediaOptions* gumOptions = [PhenixUserMediaOptions new]
 
// Customize options if desired
gumOptions.video.capabilityConstraints
    [[NSNumber numberWithInteger:PhenixDeviceCapabilityFacingMode]] =
    @[ [PhenixDeviceConstraint initWithFacingMode:PhenixFacingModeUser] ];
gumOptions.video.capabilityConstraints
    [[NSNumber numberWithInteger: PhenixDeviceCapabilityFlashMode]] =
    @[ [PhenixDeviceConstraint initWithFlashMode:PhenixFlashModeAlwaysOff] ];
gumOptions.video.capabilityConstraints
    [[NSNumber numberWithInteger: PhenixDeviceCapabilityHeight]] =
    @[ [PhenixDeviceConstraint initWithDouble:720:PhenixConstraintTypeExact] ];
gumOptions.video.capabilityConstraints
    [[NSNumber numberWithInteger: PhenixDeviceCapabilityWidth]] =
    @[ [PhenixDeviceConstraint initWithDouble:800:PhenixConstraintTypeMin],
       [PhenixDeviceConstraint initWithDouble:1500:PhenixConstraintTypeMax] ];
gumOptions.audio.enabled = NO;
 
[pcast getUserMedia:
    gumOptions:
    ^(id<PhenixPCast> pcast,
      PhenixRequestStatus status,
      id<PhenixUserMediaStream> userMediaStream) {
        // Check status and store 'userMediaStream'
    }];

@import PhenixSdk;
 
// Previously obtained via 'getUserMedia'
id<PhenixUserMediaStream> userMediaStream = ...;
 
// Previously initialized and used with 'getUserMedia'
PhenixUserMediaOptions* gumOptions;
 
[gumOptions.video.capabilityConstraints
    [[NSNumber numberWithInteger:PhenixDeviceCapabilityFacingMode]][0]
        updateFacingMode:PhenixFacingModeEnvironment];
gumOptions.video.capabilityConstraints
    [[NSNumber numberWithInteger:PhenixDeviceCapabilityFlashMode]][0]
        updateFlashMode: PhenixFlashModeAlwaysOn];
 
[userMediaStream applyOptions:gumOptions];

import PhenixSdk
 
let pcast: PhenixPCast = ...  // previously obtained
let roomService = PhenixRoomServiceFactory.createRoomService(pcast)!

import PhenixSdk
 
let roomService: PhenixRoomService = ...  // previously obtained
 
// Either provide alias or roomId, other can be nil or empty
let roomId = "us-central#demo#exampleRoomId"
let alias: String? = nil
 
roomService.getRoomInfo(
    roomId,
    alias,
    { (roomService: PhenixRoomService?, status: PhenixRequestStatus, room: PhenixRoom?) in
      if status == .ok {
        // Do something with room
      } else {
        // Handle error
      }
    })

import PhenixSdk
 
let roomService: PhenixRoomService = ...  // previously obtained
 
let roomName = "My Room Name"
let description = "Deep thoughts only"
 
let roomOptions = PhenixRoomServiceFactory.createRoomOptionsBuilder()
    .withName(roomName)
    .withDescription(description)
    .withType(.multiPartyChat)
    .buildRoomOptions()
 
roomService.createRoom(
    roomOptions,
    { (roomService: PhenixRoomService?, status: PhenixRequestStatus, room: PhenixRoom?) in
      if status == .ok {
        // Do something with room
      } else {
        // Handle error
      }
    })

import PhenixSdk
 
let roomService: PhenixRoomService = ...  // previously obtained
 
// Need to provide either room ID or alias (other can be nil)
let roomId: String? = nil
let alias = "exampleRoom"
 
roomService.joinRoom(
    roomId,
    alias,
    { (roomService: PhenixRoomService?, status: PhenixRequestStatus, room: PhenixRoom?) in
      if status == .ok {
        // Do something with room
      } else {
        // Handle error
      }
    })

import PhenixSdk
 
let roomService: PhenixRoomService = ...  // previously obtained
 
roomService.destroyRoom({ (roomService: PhenixRoomService?, status: PhenixRequestStatus) in
    if status == .ok {
      // Successfully destroyed room, no action required
    } else {
      // Handle error
    }
  })