Build a Meeting SDK for iOS app

// If you are using Objective-C, delete the following lines of code from your AppDelegate.m file.
#pragma mark - UISceneSession lifecycle
- (UISceneConfiguration *)application:(UIApplication *)application configurationForConnectingSceneSession:(UISceneSession *)connectingSceneSession options:(UISceneConnectionOptions *)options {
    return [[UISceneConfiguration alloc] initWithName:@"Default Configuration" sessionRole:connectingSceneSession.role];
}
- (void)application:(UIApplication *)application didDiscardSceneSessions:(NSSet<UISceneSession *> *) sceneSessions {
}

// If you are using Swift, delete the following lines of code from your AppDelegate.swift file.
// MARK: UISceneSession Lifecycle
func application(_ application: UIApplication, configurationForConnecting connectingSceneSession: UISceneSession, options: UIScene.ConnectionOptions) -> UISceneConfiguration {
    // Called when a new scene session is being created.
    // Use this method to select a configuration to create the new scene with.
    return UISceneConfiguration(name: "Default Configuration", sessionRole: connectingSceneSession.role)
}
func application(_ application: UIApplication, didDiscardSceneSessions sceneSessions: Set<UISceneSession>) {
    // Called when the user discards a scene session.
    // If any sessions were discarded while the application was not running, this will be called shortly after application:didFinishLaunchingWithOptions.
    // Use this method to release any resources that were specific to the discarded scenes, as they will not return.
}

#import <UIKit/UIKit.h>
@interface AppDelegate : UIResponder <UIApplicationDelegate>
// 1. Add UIWindow
@property (strong, nonatomic) UIWindow *window;
@end

#import <MobileRTC/MobileRTC.h>

// Provide JWT Token for authorization of SDK initialization.
- (void)setupSDK:(NSString *)jwtToken {
    MobileRTCSDKInitContext *context = [[MobileRTCSDKInitContext alloc] init];
    context.domain = @"zoom.us";
    context.enableLog = YES;
// Initialize the SDK
    BOOL sdkInitSuc = [[MobileRTC sharedRTC] initialize:context];
    if (sdkInitSuc) {
       // Get Auth Service
        MobileRTCAuthService *authService = [[MobileRTC sharedRTC] getAuthService];
        if (authService) {
       // Set up Auth Service
            authService.jwtToken = jwtToken;
            authService.delegate = self;
        // Call Authentication function to authenticate the SDK
            [authService sdkAuth];
        }
    }
}

#import <UIKit/UIKit.h>
// 1. Import Meeting SDK library
#import <MobileRTC/MobileRTC.h>
// 2. Declare that AppDelegate conforms to MobileRTCAuthDelegate
@interface AppDelegate : UIResponder <UIApplicationDelegate, MobileRTCAuthDelegate>
// 3. Call setUpSDK method.
-(void)setupSDK:(NSString *)jwtToken;
@property (strong, nonatomic) UIWindow *window;
@end

#import "ViewController.h"
#import <MobileRTC/MobileRTC.h>
@interface AppDelegate()
@end
@implementation AppDelegate
- (void)setupSDK:(NSString *)jwtToken {
    MobileRTCSDKInitContext *context = [[MobileRTCSDKInitContext alloc] init];
    context.domain = @"zoom.us";
    context.enableLog = YES;
    BOOL sdkInitSuc = [[MobileRTC sharedRTC] initialize:context];
    if (sdkInitSuc) {
        MobileRTCAuthService *authService = [[MobileRTC sharedRTC] getAuthService];
                if (authService) {
            authService.jwtToken = jwtToken;
           // Set the authService delegate.
            authService.delegate = self;
            [authService sdkAuth];
        }
    }
}
// Include MobileRTCAuthDelegate methods
#pragma mark - MobileRTCAuthDelegate
/**
* To monitor the status and catch errors that might occur during the authorization process, implement the onMobileRTCAuthReturn method
*/
- (void)onMobileRTCAuthReturn:(MobileRTCAuthError)returnValue {
    switch (returnValue) {
        case MobileRTCAuthError_Success:
            NSLog(@"SDK successfully initialized.");
            break;
        case MobileRTCAuthError_TokenWrong:
            NSLog(@"Client JWT Token Authentication is invalid.");
            break;
        default:
            NSLog(@"SDK Authorization failed with MobileRTCAuthError: %u", returnValue);
    }
}

- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
/*
  Obtain your JWT Token and paste it here.
Your JWT Token should NEVER be publicly accessible. Only use the JWT Token for testing this demo app. For your production level application, generate a JWT using the Client Keys and Secret on the server side instead of storing it directly on the Client.
*/
    [self @""]; // TODO: Enter your JWT token here
    return YES;
}

#import <UIKit/UIKit.h>
#import <MobileRTC/MobileRTC.h>
@interface AppDelegate : UIResponder <UIApplicationDelegate, MobileRTCAuthDelegate>
-(void)setupSDK:(NSString *)jwtToken;
@property (strong, nonatomic) UIWindow *window;

#import "AppDelegate.h"
#import "ViewController.h"
#import <MobileRTC/MobileRTC.h>
@interface AppDelegate()
@end
@implementation AppDelegate
- (BOOL)application:(UIApplication *)application didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
    // Obtain your JWT Token and paste it here.
    // Your JWT Token should NEVER be publicly accessible. Only use the JWT Token for testing this demo app.
    // For your production level application, you must generate a JWT using the Client Key and Secret on the server side instead of storing it directly on the client.
    [self setupSDK:@"";] // TODO: Enter your JWT token here
    return YES;
}
/**
* Initialize the SDK with your credentials. This is required before joining
*/
- (void)setupSDK:(NSString *)jwtToken {
    MobileRTCSDKInitContext *context = [[MobileRTCSDKInitContext alloc] init];
    context.domain = @"zoom.us";
    context.enableLog = YES;
    BOOL sdkInitSuc = [[MobileRTC sharedRTC] initialize:context];
    if (sdkInitSuc) {
        MobileRTCAuthService *authService = [[MobileRTC sharedRTC] getAuthService];
        if (authService) {
            authService.jwtToken = jwtToken;
            authService.delegate = self;
            [authService sdkAuth];
        }
    }
}
#pragma mark - MobileRTCAuthDelegate
- (void)onMobileRTCAuthReturn:(MobileRTCAuthError)returnValue {
    switch (returnValue) {
        case MobileRTCAuthError_Success:
            NSLog(@"SDK successfully initialized.");
            break;
        case MobileRTCAuthError_TokenWrong:
            NSLog(@"Client JWT Token authentication is invalid.");
            break;
        default:
            NSLog(@"SDK Authorization failed with MobileRTCAuthError: %u", returnValue);
    }
}
@end

import UIKit
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
// 1. Add UIWindow
var window: UIWindow?
func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    return true
    }
}

import MobileRTC

// Your JWT Token should NEVER be publicly accessible.
let jwtToken = ""
// Create a method that handles the initialization and authentication of the SDK
func setupSDK(jwtToken: String) {
    let context = MobileRTCSDKInitContext()
    context.domain = "zoom.us"
    context.enableLog = true
    let sdkInitializedSuccessfully = MobileRTC.shared().initialize(context)
    if sdkInitializedSuccessfully == true, let authorizationService = MobileRTC.shared().getAuthService() {
        authorizationService.jwtToken = jwtToken
        authorizationService.sdkAuth()
    }
}

if sdkInitializedSuccessfully == true, let authorizationService = MobileRTC.shared().getAuthService() {
            authorizationService.jwtToken = jwtToken
// Set the delegate
            authorizationService.delegate = self
            authorizationService.sdkAuth()
}
// MARK: - MobileRTCAuthDelegate
// Conform AppDelegate to MobileRTCAuthDelegate.
// MobileRTCAuthDelegate listens to authorization events like SDK authorization, user login, etc.
extension AppDelegate: MobileRTCAuthDelegate {
    // Result of calling sdkAuth(). MobileRTCAuthError_Success represents a successful authorization.
    func onMobileRTCAuthReturn(_ returnValue: MobileRTCAuthError) {
        switch returnValue {
        case MobileRTCAuthError_Success:
            print("SDK successfully initialized.")
        case MobileRTCAuthError_TokenWrong:
            assertionFailure("JWT Token Authentication is invalid.")
        default:
            assertionFailure("SDK Authorization failed with MobileRTCAuthError: \(returnValue).")
        }
    }
}

func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
	setupSDK(jwtToken: jwtToken)
	return true
}

import UIKit
import MobileRTC
@UIApplicationMain
class AppDelegate: UIResponder, UIApplicationDelegate {
    // Your JWT Token should NEVER be publicly accessible.
    // We are hardcoding these values here for demonstration purposes only.
    // For your production app, generate a JWT on the server side instead of storing it directly on the Client.
    let jwtToken = ""
    var window: UIWindow?
    func application(_ application: UIApplication, didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
        setupSDK(jwtToken: jwtToken)
        return true
    }
    /// setupSDK Creates, initializes, and authorizes an instance of the Meeting SDK. Call this before calling any other SDK functions.
    /// - Parameters:
    ///   - jwtToken: A valid generated JWT.
    func setupSDK(jwtToken: String) {
        // Create a MobileRTCSDKInitContext. This class contains attributes for determining how the SDK will be used. You must supply the context with a domain.
        let context = MobileRTCSDKInitContext()
        // The domain we will use is zoom.us
        context.domain = "zoom.us"
        // Turns on SDK logging. This is optional.
        context.enableLog = true
        // Call initialize(_ context: MobileRTCSDKInitContext) to create an instance of the Zoom SDK. Without initialization, the SDK will not be operational. This call will return true if the SDK was initialized successfully.
        let sdkInitializedSuccessfully = MobileRTC.shared().initialize(context)
        // Check if initialization was successful. Obtain a MobileRTCAuthService, this is for supplying credentials to the SDK for authorization.
        if sdkInitializedSuccessfully == true, let authorizationService = MobileRTC.shared().getAuthService() {
// Supply the SDK with a JWT.
            authorizationService.jwtToken = jwtToken
            // Assign AppDelegate to be a MobileRTCAuthDelegate to listen for authorization callbacks.
            authorizationService.delegate = self
            // Call sdkAuth to perform authorization.
            authorizationService.sdkAuth()
        }
    }
}
// MARK: - MobileRTCAuthDelegate
// Conform AppDelegate to MobileRTCAuthDelegate.
// MobileRTCAuthDelegate listens to authorization events like SDK authorization, user login, etc.
extension AppDelegate: MobileRTCAuthDelegate {
    // Result of calling sdkAuth(). MobileRTCAuthError_Success represents a successful authorization.
    func onMobileRTCAuthReturn(_ returnValue: MobileRTCAuthError) {
        switch returnValue {
        case MobileRTCAuthError_Success:
            print("SDK successfully initialized.")
        case MobileRTCAuthError_TokenWrong:
            assertionFailure("JWT Token Authentication is invalid.")
        default:
            assertionFailure("SDK Authorization failed with MobileRTCAuthError: \(returnValue).")
        }
    }
  }