Guide de migration Twilio (iOS)

import UIKit
import OpenTok

// Replace with your Application ID
var kApplicationId = ""
// Replace with your generated session ID
var kSessionId = ""
// Replace with your generated token
var kToken = ""

let twimlParamTo = "to"
let connectOptions: TVOConnectOptions = TVOConnectOptions(accessToken: accessToken) { (builder) in
            builder.params = [twimlParamTo : “{to}”]
        }
TwilioVoice.connect(with: connectOptions, delegate: self)

class ViewController: UIViewController
   var session: OTSession?

override func viewDidLoad() {
   super.viewDidLoad()
   connectToAnOpenTokSession()
}

func connectToAnOpenTokSession() {
    // Important: Please note that your Application ID is your API key.
    session = OTSession(apiKey: kApplicationId, sessionId: kSessionId, delegate: self)
    var error: OTError?
    session?.connect(withToken: kToken, error: &error)
    if error != nil {
        print(error!)
    }
}

// MARK: TVOCallDelegate
func callDidStartRinging(_ call: TVOCall) {
        NSLog("callDidStartRinging:")
}
func callDidConnect(_ call: TVOCall) {
        NSLog("callDidConnect:")
}
func call(_ call: TVOCall, isReconnectingWithError error: Error) {
        NSLog("call:isReconnectingWithError:")
}
func callDidReconnect(_ call: TVOCall) {
        NSLog("callDidReconnect:")
}
func call(_ call: TVOCall, didFailToConnectWithError error: Error) {
        NSLog("Call failed to connect: \(error.localizedDescription)")
}
func call(_ call: TVOCall, didDisconnectWithError error: Error?) {
        NSLog("Call disconnected")
}

// MARK: - OTSessionDelegate callbacks
extension ViewController: OTSessionDelegate {
   func sessionDidConnect(_ session: OTSession) {
       print("The client connected to the Vonage Video API session.")
   }
   func sessionDidDisconnect(_ session: OTSession) {
       print("The client disconnected from the Vonage Video API session.")
   }
   func session(_ session: OTSession, didFailWithError error: OTError) {
       print("The client failed to connect to the Vonage Video API session: \(error).")
   }
   func session(_ session: OTSession, streamCreated stream: OTStream) {
       print("A stream was created in the session.")
   }
   func session(_ session: OTSession, streamDestroyed stream: OTStream) {
       print("A stream was destroyed in the session.")
   }
}

class ViewController: UIViewController, OTSessionDelegate {
   var session: OTSession?
   var publisher: OTPublisher?

func sessionDidConnect(_ session: OTSession) {
    print("The client connected to the OpenTok session.")
    let settings = OTPublisherSettings()
    guard let publisher = OTPublisher(delegate: self, settings: settings) else {
        Return
    }
    var error: OTError?
    session.publish(publisher, error: &error)
    guard error == nil else {
        print(error!)
        Return
    }
    guard let publisherView = publisher.view else {
        Return
    }
    let screenBounds = UIScreen.main.bounds
    publisherView.frame = CGRect(x: screenBounds.width - 150 - 20, y: screenBounds.height - 150 - 20, width: 150, height: 150)
    view.addSubview(publisherView)
}

// MARK: - OTPublisherDelegate callbacks
extension ViewController: OTPublisherDelegate {
   func publisher(_ publisher: OTPublisherKit, didFailWithError error: OTError) {
       print("The publisher failed: \(error)")
   }
}

participant?.unpublishVideoTrack(cameraManager.track)
self.cameraManager = nil

// This will only stop publishing Video to the session. You can still see your local preview

    publisher.publishVideo = false
// This will only stop publishing all media (audio and video) to the session. You can still see your local preview
    var error: OTError?
    session.unpublish(publisher, error: &error)
    guard error == nil else {
        print(error!)
        Return
    }

func participantDidConnect(room: Room, participant: RemoteParticipant) {
    print ("Participant \(participant.identity) has joined Room \(room.name)")

    // Set the delegate of the remote participant to receive callbacks
    participant.delegate = self
}

func participantDidDisconnect(room: Room, participant: RemoteParticipant) {
    print ("Participant \(participant.identity) has left Room \(room.name)")
}

 func didSubscribeToVideoTrack(videoTrack: RemoteVideoTrack,
                              publication: RemoteVideoTrackPublication,
                              participant: RemoteParticipant) {

    print("Participant \(participant.identity) added a video track.")
    if let remoteView = VideoView.init(frame: self.view.bounds,
                                       delegate:self) {
        videoTrack.addRenderer(remoteView)
        self.view.addSubview(remoteView)
        self.remoteView = remoteView
    }
}

class ViewController: UIViewController {
   var session: OTSession?
   var publisher: OTPublisher?
   var subscriber: OTSubscriber?

func session(_ session: OTSession, streamCreated stream: OTStream) {
    subscriber = OTSubscriber(stream: stream, delegate: self)
    guard let subscriber = subscriber else {
        return
    }


    var error: OTError?
    session.subscribe(subscriber, error: &error)
    guard error == nil else {
        print(error!)
        return
    }


    guard let subscriberView = subscriber.view else {
        return
    }
    subscriberView.frame = UIScreen.main.bounds
    view.insertSubview(subscriberView, at: 0)
}


// MARK: - OTSubscriberDelegate callbacks
extension ViewController: OTSubscriberDelegate {
   public func subscriberDidConnect(toStream subscriber: OTSubscriberKit) {
       print("The subscriber did connect to the stream.")
   }


   public func subscriber(_ subscriber: OTSubscriberKit, didFailWithError error: OTError) {
       print("The subscriber failed to connect to the stream.")
   }
}

guard let micTrack = LocalAudioTrack(options: nil, enabled: true, name: TrackName.mic) else {
           return
}
participant?.unpublishAudioTrack(micTrack)

publisher.publishAudio = false

guard let micTrack = LocalAudioTrack(options: nil, enabled: true, name: TrackName.mic) else {
           return
}
participant?.publishAudioTrack(micTrack)

publisher.publishAudio = true

func sendChatMessage(message: String) {
    var error: OTError?
    session.signal(withType: "chat", string: message, connection: nil, error: &error)
    if let error {
        print(error)
    }
}

func session(_ session: OTSession, receivedSignalType type: String?, from connection: OTConnection?, with string: String?) {
        print("Received signal type \(type) with message \(string)")
    }

// To disconnect from a Room, we call:
room?.disconnect()

// This results in a callback to RoomDelegate#roomDidDisconnect(room: Room, error: Error?)

// MARK: RoomDelegate

func roomDidDisconnect(room: Room, error: Error?) {
    print("Disconnected from room \(room.name)")
}

var error: OTError?
session?.disconnect(&error)
if error != nil {
    print(error!)
}

// MARK: OTSessionDelegate

func sessionDidDisconnect(_ session: OTSession) {
print("The client disconnected to the OpenTok session.")
}