Native Module iOS

How to Create a Native Module in iOS

This detailed guide explains how to create a native module for the iOS platform within a React Native application. The process follows the step-by-step instructions from the official documentation.

1. Open the iOS Project in Xcode

First, open the iOS project of your React Native application in Xcode. You can find the iOS project in the folder: YourApp/ios/your-app-name.xcworkspace.

Using Xcode helps in quickly identifying issues, such as syntax errors, and provides powerful tools for iOS development.

2. Create the Native Module

Create a file named CafSmartAuthBridgeModule.swift in the directory ios/. This file will contain the class that implements the native module.

Key Functions of the CafSmartAuthBridgeModule Class

• requiresMainQueueSetup: Indicates whether the module needs to be set up on the main queue. Returns true.

• supportedEvents: Returns the list of events that the module can emit to React Native.

• build: Creates and configures an instance of the CafSmartAuthSdk using the provided parameters.

• emitEvent: Emits events from the native side to React Native.

• setupListener: Sets up a listener to monitor the status of authentication operations.

• startSmartAuth: A method exposed to React Native to initiate smart authentication.

Example Implementation of the CafSmartAuthBridgeModule.swift File

import Foundation
import React
import CafSmartAuth

private struct CafSmartAuthBridgeEvents {
  static let cafSmartAuthSuccessEvent: String = "CafSmartAuth_Success"
  static let cafSmartAuthPendingEvent: String = "CafSmartAuth_Pending"
  static let cafSmartAuthErrorEvent: String = "CafSmartAuth_Error"
  static let cafSmartAuthCancelEvent: String = "CafSmartAuth_Cancel"
  static let cafSmartAuthLoadingEvent: String = "CafSmartAuth_Loading"
  static let cafSmartAuthLoadedEvent: String = "CafSmartAuth_Loaded"
}

internal struct CafFaceAuthenticationSettingsModel: Decodable {
  let loadingScreen: Bool?
  let filter: Int?
}

internal struct CafSmartAuthBridgeSettingsModel: Decodable {
  let stage: Int?
  let faceAuthenticationSettings: CafFaceAuthenticationSettingsModel?
}

private struct CafMutableDictionaries {
  static let isAuthorized: String = "isAuthorized"
  static let attestation: String = "attestation"
  static let message: String = "message"
}

@objc(CafSmartAuthBridgeModule)
class CafSmartAuthBridgeModule: RCTEventEmitter {
  private var smartAuth: CafSmartAuthSdk?
  
  @objc
  override static func requiresMainQueueSetup() -> Bool {
    return true
  }
  
  override func supportedEvents() -> [String]! {
    return [
      CafSmartAuthBridgeEvents.cafSmartAuthSuccessEvent,
      CafSmartAuthBridgeEvents.cafSmartAuthPendingEvent,
      CafSmartAuthBridgeEvents.cafSmartAuthErrorEvent,
      CafSmartAuthBridgeEvents.cafSmartAuthCancelEvent,
      CafSmartAuthBridgeEvents.cafSmartAuthLoadingEvent,
      CafSmartAuthBridgeEvents.cafSmartAuthLoadedEvent
    ]
  }
  
  private func build(
    mfaToken: String,
    faceAuthToken: String,
    settings: CafSmartAuthBridgeSettingsModel
  ) -> CafSmartAuthSdk {
    let builder = CafSmartAuthSdk.CafBuilder(mobileToken: mfaToken)
    
    if let stage = settings.stage, let cafStage = CAFStage(rawValue: stage) {
      _ = builder.setStage(cafStage)
    }
    
    let filter: CafFilterStyle = {
      if let faceSettings = settings.faceAuthenticationSettings, faceSettings.filter == 0 {
        return .natural
      }
      return .lineDrawing
    }()
    
    _ = builder.setLivenessSettings(
      CafFaceLivenessSettings(
        faceLivenessToken: faceAuthToken,
        useLoadingScreen: settings.faceAuthenticationSettings?.loadingScreen ?? false,
        filter: filter
      )
    )
    
    return builder.build()
  }
  
  private func emitEvent(name: String, data: Any) {
    self.sendEvent(withName: name, body: data)
  }
  
  private func setupListener() -> CafVerifyPolicyListener {
    return { result in
      switch result {
      case .onSuccess(let response):
        self.emitEvent(
          name: CafSmartAuthBridgeEvents.cafSmartAuthSuccessEvent,
          data: [
            CafMutableDictionaries.isAuthorized: response.isAuthorized,
            CafMutableDictionaries.attestation: response.attestation
          ]
        )
        self.smartAuth = nil
        
      case .onPending(let response):
        self.emitEvent(
          name: CafSmartAuthBridgeEvents.cafSmartAuthPendingEvent,
          data: [
            CafMutableDictionaries.isAuthorized: response.isAuthorized,
            CafMutableDictionaries.attestation: response.attestation
          ]
        )
        
      case .onError(let error):
        self.emitEvent(
          name: CafSmartAuthBridgeEvents.cafSmartAuthErrorEvent,
          data: [CafMutableDictionaries.message: error.localizedDescription]
        )
        self.smartAuth = nil
        
      case .onCanceled(_):
        self.emitEvent(
          name: CafSmartAuthBridgeEvents.cafSmartAuthCancelEvent,
          data: true
        )
        self.smartAuth = nil
        
      case .onLoading:
        self.emitEvent(name: CafSmartAuthBridgeEvents.cafSmartAuthLoadingEvent, data: true)
        
      case .onLoaded:
        self.emitEvent(name: CafSmartAuthBridgeEvents.cafSmartAuthLoadedEvent, data: true)
      }
    }
  }
  
  @objc(startSmartAuth:livenessToken:personId:policyId:settings:)
  func startSmartAuth(mfaToken: String, faceAuthToken: String, personId: String, policyId: String, settings: String) {
    DispatchQueue.main.async {
      self.smartAuth = self.build(
        mfaToken: mfaToken, faceAuthToken: faceAuthToken, settings: CafSmartAuthBridgeSettings().parseJson(settings: settings)!
      )
      
      self.smartAuth?.verifyPolicy(personID: personId, policyId: policyId, listener: self.setupListener())
    }
  }
}

3. Create the CafSmartAuthBridgeSettings.swift File

This file will handle the interpretation of data sent from React Native to the native module.

Example Implementation:

internal class CafSmartAuthBridgeSettings {
  internal func parseJson(settings: String) -> CafSmartAuthBridgeSettingsModel? {
    guard let data = settings.data(using: .utf8) else {
      return nil
    }
    
    do {
      let decoder = JSONDecoder()
      let parsedSettings = try decoder.decode(CafSmartAuthBridgeSettingsModel.self, from: data)
      
      return parsedSettings
    } catch {
      return nil
    }
  }
}

4. Register the Native Module

Create the main header and implementation files for the custom native module. Create a new file named CafSmartAuthBridge.h.

Example Implementation:

#import <React/RCTBridgeModule.h>

@interface CafSmartAuthBridgeModule : NSObject <RCTBridgeModule>

@end

To make the native module recognizable by React Native, create the file CafSmartAuthBridge.mm in the same directory:

Example Implementation:

#import <Foundation/Foundation.h>
#import <React/RCTBridgeModule.h>
#import <React/RCTEventEmitter.h>

@interface RCT_EXTERN_MODULE(CafSmartAuthBridgeModule, RCTEventEmitter)
RCT_EXTERN_METHOD(startSmartAuth:(NSString *)mfaToken livenessToken:(NSString *)livenessToken personId:(NSString *)personId policyId:(NSString *)policyId settings:(NSString *)settings)
@end

5. Create the Bridging Header for Swift and Objective-C

Whenever you mix Swift and Objective-C in an iOS project, a bridging header file is required. This file allows Swift to access functionalities implemented in Objective-C, including React Native APIs.

In the same directory as the Swift file, create the file CafSmartAuthBridge-Bridging-Header.h.

Example Implementation of the Bridging Header File

#import <React/RCTBridgeModule.h>
#import <React/RCTEventEmitter.h>

Configuration Steps

1. Ensure the CafSmartAuthBridge-Bridging-Header.h file is included in the Objective-C Bridging Header field in Build Settings (Build Settings > Swift Compiler - General > Objective-C Bridging Header).

2. Provide the relative path to the file, e.g.,

   YourApp/ios/YourApp/CafSmartAuthBridge-Bridging-Header.h