Swift

Construction de l'interface d'appel

Pour pouvoir appeler, vous devrez créer un nouveau contrôleur de vue pour l'interface appelante. Dans le menu Xcode, sélectionnez File > New > File.... Choisir un Classe Cocoa TouchNommez-le CallViewController avec une sous-classe de UIViewController et la langue de Swift.

Cela créera un nouveau fichier appelé CallViewController, à l'importation supérieure VonageClientSDKVoice.

import UIKit
import VonageClientSDKVoice

L'interface d'appel aura besoin de :

A UIButton pour lancer un appel
A UIButton pour mettre fin à un appel
A UILabel pour afficher les mises à jour d'état

Ouvrir CallViewController.swift et l'ajouter par programme.

class CallViewController: UIViewController {
    
    let callButton = UIButton(type: .system)
    let hangUpButton = UIButton(type: .system)
    let statusLabel = UILabel()
    
    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    
    override func viewDidLoad() {
        super.viewDidLoad()
        view.backgroundColor = .systemBackground
        
        callButton.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(callButton)
        
        hangUpButton.setTitle("Hang up", for: .normal)
        hangUpButton.translatesAutoresizingMaskIntoConstraints = false
        
        setHangUpButtonHidden(true)
        view.addSubview(hangUpButton)
        
        setStatusLabelText("Ready to receive call...")
        statusLabel.textAlignment = .center
        statusLabel.translatesAutoresizingMaskIntoConstraints = false
        view.addSubview(statusLabel)
        
        NSLayoutConstraint.activate([
            callButton.centerYAnchor.constraint(equalTo: view.centerYAnchor),
            callButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            callButton.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
            callButton.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20),
            
            hangUpButton.topAnchor.constraint(equalTo: callButton.bottomAnchor, constant: 20),
            hangUpButton.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            hangUpButton.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
            hangUpButton.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20),
            
            statusLabel.topAnchor.constraint(equalTo: hangUpButton.bottomAnchor, constant: 20),
            statusLabel.centerXAnchor.constraint(equalTo: view.centerXAnchor),
            statusLabel.leadingAnchor.constraint(equalTo: view.leadingAnchor, constant: 20),
            statusLabel.trailingAnchor.constraint(equalTo: view.trailingAnchor, constant: -20)
        ])
    }
    
    private func setHangUpButtonHidden(_ isHidden: Bool) {
        DispatchQueue.main.async { [weak self] in
            guard let self else { return }
            self.hangUpButton.isHidden = isHidden
            self.callButton.isHidden = !self.hangUpButton.isHidden
        }
    }
    
    private func setStatusLabelText(_ text: String?) {
        DispatchQueue.main.async { [weak self] in
            guard let self else { return }
            self.statusLabel.text = text
        }
    }
}

Il existe deux fonctions d'aide setHangUpButtonHidden et setStatusLabelText pour éviter la répétition de l'appel DispatchQueue.main.async car la modification de l'état des éléments de l'interface utilisateur doit être effectuée sur le fil d'exécution principal, comme l'exige la norme UIKit. Les setHangUpButtonHidden permet de faire basculer la visibilité de l'élément hangUpButton car elle ne doit être visible que pendant un appel actif.

Présentation de la `CallViewController`

Maintenant que l'interface d'appel est construite, vous devez présenter le contrôleur de vue à partir de l'écran de connexion que vous avez construit plus tôt. Vous aurez besoin d'informations sur l'utilisateur connecté et d'un objet client authentifié à transmettre entre les deux contrôleurs de vue, en CallViewController.swift ajouter ce qui suit.

class CallViewController: UIViewController {
    ...
    let user: User
    let client: VGVoiceClient
    
    var callID: String?
    
    init(user: User, client: VGVoiceClient) {
        self.user = user
        self.client = client
        super.init(nibName: nil, bundle: nil)
    }

    required init?(coder: NSCoder) {
        fatalError("init(coder:) has not been implemented")
    }
    ...

Cela permet de définir un initialisateur personnalisé pour la classe qui possède une fonction User.type et VGVoiceClient.type en tant que paramètres, qui est ensuite stockée dans la base de données locale de la user et client propriétés. Maintenant que vous disposez des informations sur l'utilisateur, vous pouvez utiliser la fonction callButton pour indiquer qui l'utilisateur va appeler, en viewDidLoad ajouter ce qui suit.

navigationItem.leftBarButtonItem = UIBarButtonItem(
    title: "Logout", 
    style: .done, 
    target: self,
    action: #selector(self.logout)
)
callButton.setTitle("Call \(user.callPartnerName)", for: .normal)

Il définit le titre du contrôleur de vue et crée un bouton de déconnexion dans la barre de navigation. Ajoutez l'élément logout à la fin de la fonction CallViewController.swift

class CallViewController: UIViewController {
    ...

    @objc func logout() {
        client.deleteSession { error in
            if error == nil {
                DispatchQueue.main.async { [weak self] in
                    self?.dismiss(animated: true, completion: nil)
                }
            }
        }
    }

    ...
}

Vous êtes maintenant prêt à présenter l'interface d'appel ainsi que les informations relatives à l'utilisateur. Pour ce faire, vous devez modifier le fichier login dans la fonction ViewController.swift fichier.

func login() {
    guard let user = self.user else { return }
    let config = VGClientConfig(region: .US)
    config.enableWebsocketInvites = true
    client.setConfig(config)
    client.createSession(user.jwt) { error, sessionId in
        DispatchQueue.main.async { [weak self] in
            guard let self else { return }
            if error == nil {
                let navigationController = UINavigationController(rootViewController: CallViewController(user: user, client: self.client))
                navigationController.modalPresentationStyle = .overFullScreen
                self.present(navigationController, animated: true, completion: nil)
            } else {
                self.connectionStatusLabel.text = error?.localizedDescription
            }
        }
    }
}

Si l'utilisateur se connecte avec succès, un CallViewController sera présenté avec les données de l'utilisateur nécessaires.

Construire et faire fonctionner

Exécutez à nouveau le projet (Cmd + R) pour le lancer dans le simulateur. Si vous vous connectez avec l'un des utilisateurs, vous verrez l'interface d'appel