Test Integration: X Only

import StreamLayer

func initStreamLayerSDK() {
    StreamLayer.initSDK(with: /** REPLACE_WITH_YOUR_SDK_KEY **/)
    
    // following lines disable advanced SDK features
    StreamLayer.config.phoneContactsSyncEnabled = false
    StreamLayer.config.isUserProfileOverlayHidden = true
    StreamLayer.config.notificationsMode = [.vote, .promotion, .twitter]
    StreamLayer.config.tooltipsEnabled = false
}

import StreamLayer

class StreamLayerViewController: UIViewController {

  // blank reference view
  private let overlayReferenceView = UIView()

  // ..

  private lazy var overlayVC = StreamLayer.createOverlay(
    overlayReferenceView, // overlayView will use this as reference inside streamlayer SDK to know where to draw overlays
    overlayDelegate: self // you can designate a separate delegate, but for the simplicity of it we use the same VC
  )

  // ...

  override func viewDidLoad() {
    super.viewDidLoad()

    // reference view that is added to view hierarchy, must be on the same level with overlayViewController
    view.addSubview(overlayReferenceView)

    // add overlay ViewController into the hierarchy
    // this is where the UI integration takes place
    overlayVC.willMove(toParent: self)
    addChild(overlayVC)
    view.addSubview(overlayVC.view)
    overlayVC.didMove(toParent: self)
  }   

  // make sure to not store references outside creating VC as it will prevent streamlayer SDK from cleaning up
  deinit {
    StreamLayer.removeOverlay()
  }

class StreamLayerViewController: UIViewController {
  // ... keep all the code from step 3 and add/alter the rest
  private let videoPlayer = UIViewController() // just for illustration purposes, we assume you already have your own setup in an actual ViewController
  
  // helper to access interface orientation
  private var windowInterfaceOrientation: UIInterfaceOrientation? {
    return UIApplication.shared.windows.first?.windowScene?.interfaceOrientation
  }

  enum Constants {
    static let demoEventID: String = "demo"
  }
  
  override func viewDidLoad() {
    // ... your existing code
  }
  
  override func viewWillAppear(_ animated: Bool) {
    super.viewWillAppear(animated)

    StreamLayer.createSession(for: Constants.demoEventID)
    
    // used in single feature integrations - hides launch button and who's watching indicator
    StreamLayer.hideLaunchButton(true)
    StreamLayer.hideLaunchControls(true)
  }
  
  override func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
    super.viewWillTransition(to: size, with: coordinator)
        
    coordinator.animate(alongsideTransition: { (context) in
      guard let windowInterfaceOrientation = self.windowInterfaceOrientation else { return }      
      if windowInterfaceOrientation.isLandscape {
        horizontalOrientation()
      } else {
        verticalOrientation()
      }
    })
  }
}
 
private extension StreamLayerViewController {
  func setupConstraints(_ orientation: OrientationState) {
    switch orientation {
    case .horizontalLeft, .horizontalRight:
      horizontalOrientation()
    default:
      verticalOrientation()
    }
  }
  
  /// Portrait.
  /// Roughly 1/3 of the screen is taken up by video player, remainder is useful content + overlay button
  /// Overlays slide from the bottom
  func verticalOrientation() {    
    overlayReferenceView.slr_snp.remakeConstraints { [unowned videoPlayer] in
      $0.bottom.left.right.equalToSuperview()
      $0.top.equalTo(videoPlayer.view.slr_snp.bottom).offset(-40)
    }
    
    overlayVC.view.slr_snp.remakeConstraints { [unowned videoPlayer] in
      $0.top.equalTo(videoPlayer.view.slr_snp.bottom).offset(-40)
      $0.left.right.bottom.equalTo(0)
    }
  }
  
  /// Landscape
  /// Everything is taken up by video player & button is visible
  /// Overlays slide from the left
  func horizontalOrientation() {    
    overlayReferenceView.slr_snp.remakeConstraints { [unowned view] in
      $0.left.top.bottom.equalToSuperview()
      
      // you can adjust these settings and have a bigger/smaller overlay if desired, but these
      // are the "ideal" settings
      if #available(iOS 11, *) {
        $0.right.equalTo(view.safeAreaLayoutGuide.slr_snp.left).offset(300 + 40)
      } else {
        $0.right.equalTo(view.slr_snp.left).offset(300 + 40)
      }
    }

    // view controller covers the whole screen, will forward touches unless they land in overlayView 
    overlayVC.view.slr_snp.remakeConstraints { [unowned view] in
      $0.edges.equalTo(view)
    }
  }
}

// these are delegate methods that allow for greater control over streamlayer SDK
// blank implementation is provided
extension StreamLayerViewController: SLROverlayDelegate {
  func overlayOpened() {
    // will fire when streamlayer overlay is opened
  }
  
  func overlayClosed() {
    // will fire when streamlayer overlay is closed
  }
  
  func requestAudioDucking() {
    // react by setting relative audio of your audio sources to a lower %
  }
  
  func disableAudioDucking() {
    // react by setting relative audio to your previous setting
  }
  
  func prepareAudioSession(for type: SLRAudioSessionType) {
    // used when watch party is enabled
  }
  
  func disableAudioSession(for type: SLRAudioSessionType) {
    // used when watch party is enabled
  }

  func shareInviteMessage() -> String {
    // will be used for generating invite messages
    return ""
  }
  
  func waveMessage() -> String {
    return ""
  }

  func switchStream(to streamId: String) {
    
  }

  func playVideo() {
    
  }
  
  func pauseVideo() {
    
  }

  func getVideoPlayerContainer() -> SLRVideoPlayerOverlayContainer? {
    return nil
  }
}

class StreamLayerViewController: UIViewController {
    
  // ... existing code

  private lazy var twitterButton: UIButton = {
    let button = UIButton()
    button.setImage(UIImage(named: "twitter_icon"), for: .normal) // use your image or we can provide one
    button.translatesAutoresizingMaskIntoConstraints = false
    button.addTarget(self, action: #selector(twitterButtonTapped), for: .touchUpInside)
    return button
  }()
  
  // ... constraints
  
  override func viewDidLoad() {
    // ... existing code
    
    view.addSubview(twitterButton)
    twitterButton.slr_snp.makeConstraints {
      // you can change this to your desired settings
      $0.height.width.equalTo(32.0)
      $0.trailing.equalToSuperview().inset(20.0)
      $0.bottom.equalTo(view.safeAreaLayoutGuide).inset(20.0)
    }

    // existing overlayVC code - button will be below it
    overlayVC.willMove(toParent: self)
    addChild(overlayVC)
    view.addSubview(overlayVC.view)
    overlayVC.didMove(toParent: self)
  }
  
  // this will open the twitter overlay
  @objc func twitterButtonTapped() {
    StreamLayer.showOverlay(overlayType: .twitter)
  }  
}