@smile_identity/react-native 10.1.1 → 10.1.3-rc.1

package/android/gradle.properties

@@ -3,4 +3,4 @@ SmileId_minSdkVersion=21
 SmileId_targetSdkVersion=34
 SmileId_compileSdkVersion=34
 SmileId_ndkversion=21.4.7075529
-SmileId_androidVersion=10.1.4
+SmileId_androidVersion=10.2.2

package/android/src/main/java/com/smileidentity/react/SmileIdModule.kt

@@ -1,23 +1,40 @@
 package com.smileidentity.react
 
+import android.util.Log
+import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableArray
 import com.smileidentity.SmileID
 import com.smileidentity.SmileIDCrashReporting
 import com.smileidentity.SmileIdSpec
+import com.smileidentity.models.AuthenticationResponse
+import com.smileidentity.models.BiometricKycJobStatusResponse
+import com.smileidentity.models.DocumentVerificationJobStatusResponse
+import com.smileidentity.models.EnhancedDocumentVerificationJobStatusResponse
+import com.smileidentity.models.EnhancedKycAsyncResponse
 import com.smileidentity.models.EnhancedKycRequest
+import com.smileidentity.models.EnhancedKycResponse
+import com.smileidentity.models.PrepUploadResponse
+import com.smileidentity.models.ProductsConfigResponse
+import com.smileidentity.models.ServicesResponse
+import com.smileidentity.models.SmartSelfieJobStatusResponse
+import com.smileidentity.models.ValidDocumentsResponse
 import com.smileidentity.networking.pollBiometricKycJobStatus
 import com.smileidentity.networking.pollDocumentVerificationJobStatus
 import com.smileidentity.networking.pollEnhancedDocumentVerificationJobStatus
 import com.smileidentity.networking.pollSmartSelfieJobStatus
 import com.smileidentity.react.utils.getIntOrDefault
 import com.smileidentity.react.utils.getStringOrDefault
+import com.smileidentity.results.SmartSelfieResult
+import java.net.URL
 import kotlinx.coroutines.CoroutineExceptionHandler
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.last
 import kotlinx.coroutines.flow.map
 import kotlinx.coroutines.flow.single
 import kotlinx.coroutines.launch
@@ -39,56 +56,127 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
     promise.resolve(null)
   }
 
+  @ReactMethod
+  override fun setEnvironment(useSandBox: Boolean, promise: Promise) {
+    SmileID.setEnvironment(useSandbox = useSandBox)
+    promise.resolve(null)
+  }
+
+  @ReactMethod
+  override fun setCallbackUrl(callbackUrl: String, promise: Promise) {
+    SmileID.setCallbackUrl(callbackUrl = URL(callbackUrl))
+    promise.resolve(null)
+  }
+
   @ReactMethod
   override fun disableCrashReporting(promise: Promise) {
     SmileIDCrashReporting.disable()
   }
 
+@ReactMethod
+  override fun setAllowOfflineMode(allowOfflineMode: Boolean, promise: Promise) {
+    SmileID.setAllowOfflineMode(allowOfflineMode)
+    promise.resolve(null)
+  }
+
+@ReactMethod
+  override fun submitJob(jobId: String, promise: Promise) = launch(
+    work = { SmileID.submitJob(jobId) },
+    clazz = Unit::class.java,
+    promise = promise
+  )
+
+@ReactMethod
+  override fun getUnsubmittedJobs(promise: Promise) {
+    try {
+      val writableArray: WritableArray = Arguments.createArray()
+      SmileID.getUnsubmittedJobs().forEach {
+        writableArray.pushString(it)
+      }
+      promise.resolve(writableArray)
+    } catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+
+@ReactMethod
+  override fun getSubmittedJobs(promise: Promise) {
+    try {
+      val writableArray: WritableArray = Arguments.createArray()
+      SmileID.getSubmittedJobs().forEach {
+        writableArray.pushString(it)
+      }
+      promise.resolve(writableArray)
+    } catch (e: Exception) {
+      promise.reject(e)
+    }
+  }
+
+@ReactMethod
+  override fun cleanup(jobId: String, promise: Promise) {
+    try {
+      SmileID.cleanup(jobId)
+      promise.resolve(null)
+    } catch (e: Exception) {
+      promise.resolve(e)
+    }
+  }
+
   @ReactMethod
   override fun authenticate(request: ReadableMap, promise: Promise) = launch(
-    work = { SmileID.api.authenticate(request = request.toAuthenticationRequest()) },
+    work = {
+      SmileID.api.authenticate(request = request.toAuthenticationRequest())
+    },
+    clazz = AuthenticationResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun prepUpload(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.prepUpload(request = request.toPrepUploadRequest()) },
+    clazz = PrepUploadResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun upload(url: String, request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.upload(url, request.toUploadRequest()) },
+    clazz = Unit::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun doEnhancedKyc(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.doEnhancedKyc(request = request.toEnhancedKycRequest()) },
+    clazz = EnhancedKycResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun doEnhancedKycAsync(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.doEnhancedKycAsync(request = request.toEnhancedKycRequest()) },
+    clazz = EnhancedKycAsyncResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun getSmartSelfieJobStatus(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.getSmartSelfieJobStatus(request = request.toJobStatusRequest()) },
+    clazz = SmartSelfieJobStatusResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun getDocumentVerificationJobStatus(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.getDocumentVerificationJobStatus(request = request.toJobStatusRequest()) },
+    clazz = DocumentVerificationJobStatusResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun getBiometricKycJobStatus(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.getBiometricKycJobStatus(request = request.toJobStatusRequest()) },
+    clazz = BiometricKycJobStatusResponse::class.java,
     promise = promise
   )
 
@@ -96,24 +184,28 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
   override fun getEnhancedDocumentVerificationJobStatus(request: ReadableMap, promise: Promise) =
     launch(
       work = { SmileID.api.getEnhancedDocumentVerificationJobStatus(request = request.toJobStatusRequest()) },
+      clazz = EnhancedDocumentVerificationJobStatusResponse::class.java,
       promise = promise
     )
 
   @ReactMethod
   override fun getProductsConfig(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.getProductsConfig(request = request.toProductsConfigRequest()) },
+    clazz = ProductsConfigResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun getValidDocuments(request: ReadableMap, promise: Promise) = launch(
     work = { SmileID.api.getValidDocuments(request = request.toProductsConfigRequest()) },
+    clazz = ValidDocumentsResponse::class.java,
     promise = promise
   )
 
   @ReactMethod
   override fun getServices(promise: Promise) = launch(
     work = { SmileID.api.getServices() },
+    clazz = ServicesResponse::class.java,
     promise = promise
   )
 
@@ -134,6 +226,7 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
         numAttempts = numAttempts.toLong(),
       )
     },
+    clazz = SmartSelfieJobStatusResponse::class.java,
     promise = promise
   )
 
@@ -154,6 +247,7 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
         numAttempts = numAttempts.toLong(),
       )
     },
+    clazz = DocumentVerificationJobStatusResponse::class.java,
     promise = promise
   )
 
@@ -174,6 +268,7 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
         numAttempts = numAttempts.toLong(),
       )
     },
+    clazz = BiometricKycJobStatusResponse::class.java,
     promise = promise
   )
 
@@ -195,6 +290,7 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
           numAttempts = numAttempts.toLong(),
         )
       },
+      clazz = EnhancedDocumentVerificationJobStatusResponse::class.java,
       promise = promise
     )
 
@@ -208,8 +304,10 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
       val response =
         withContext(Dispatchers.IO) {
           apiCall(request, interval.milliseconds, numAttempts.toInt())
-            .map { it }
-            .single()
+            .map {
+              it
+            }
+            .last()
         }
       response
     } catch (e: Exception) {
@@ -217,16 +315,33 @@ class SmileIdModule internal constructor(context: ReactApplicationContext) :
     }
   }
 
+  private fun <T> toJson(result: T, clazz: Class<T>): String {
+    val adapter = SmileID.moshi.adapter(clazz)
+    return adapter.toJson(result)
+  }
+
+
   private fun <T> launch(
     work: suspend () -> T,
+    clazz: Class<T>,
     promise: Promise,
     scope: CoroutineScope = CoroutineScope(Dispatchers.IO)
   ) {
     val handler = CoroutineExceptionHandler { _, throwable ->
-      promise.reject(throwable.message)
+      promise.reject(throwable)
     }
     scope.launch(handler) {
-      promise.resolve(Result.success(work()))
+      try {
+        val result = work()
+        if (clazz == Unit::class.java) {
+          promise.resolve(null)
+        } else {
+          val jsonResult = toJson(result, clazz)
+          promise.resolve(jsonResult)
+        }
+      } catch (e: Exception) {
+        promise.reject(e)
+      }
     }
   }
 

package/android/src/main/java/com/smileidentity/react/SmileIdPackage.kt

@@ -36,7 +36,7 @@ class SmileIdPackage : TurboReactPackage() {
   override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
     return ReactModuleInfoProvider {
       val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
+
       moduleInfos[SmileIdModule.NAME] = ReactModuleInfo(
         SmileIdModule.NAME,
         SmileIdModule.NAME,
@@ -44,7 +44,7 @@ class SmileIdPackage : TurboReactPackage() {
         false,  // needsEagerInit
         true,  // hasConstants
         false,  // isCxxModule
-        isTurboModule // isTurboModule
+        false // isTurboModule
       )
       moduleInfos
     }

package/android/src/oldarch/SmileIdSpec.kt

@@ -10,6 +10,20 @@ abstract class SmileIdSpec internal constructor(context: ReactApplicationContext
 
   abstract fun initialize(useSandBox: Boolean ,promise: Promise)
 
+  abstract fun setEnvironment(useSandbox: Boolean, promise: Promise)
+
+  abstract fun setCallbackUrl(callbackUrl: String, promise: Promise)
+
+  abstract fun setAllowOfflineMode(allowOfflineMode: Boolean ,promise: Promise)
+
+  abstract fun submitJob(jobId: String ,promise: Promise)
+
+  abstract fun getUnsubmittedJobs(promise: Promise)
+
+  abstract fun getSubmittedJobs(promise: Promise)
+
+  abstract fun cleanup(jobId: String ,promise: Promise)
+
   abstract fun disableCrashReporting(promise: Promise)
 
   abstract fun authenticate(request: ReadableMap, promise: Promise)

package/ios/RNSmileID.mm

@@ -2,6 +2,13 @@
 
 @interface RCT_EXTERN_MODULE(RNSmileID, NSObject)
 RCT_EXTERN_METHOD(initialize:(BOOL)useSandBox withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setEnvironment:(BOOL)useSandBox withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setCallbackUrl:(NSString)callbackUrl withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(setAllowOfflineMode:(BOOL)allowOfflineMode withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(submitJob:(NSString *)jobId withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getUnsubmittedJobs:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(getSubmittedJobs:(RCTPromiseResolveBlock)resolve rejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(cleanup:(NSString *)jobId withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(authenticate:(NSDictionary *)request withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(prepUpload:(NSDictionary *)request withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(upload:(NSString *)url request:(NSDictionary *)request withResolver:(RCTPromiseResolveBlock)resolve withRejecter:(RCTPromiseRejectBlock)reject)

package/ios/RNSmileID.swift

@@ -1,16 +1,71 @@
-import Combine
 import SmileID
 
 @objc(RNSmileID)
 class RNSmileID: NSObject {
-    private var cancellables = Set<AnyCancellable>()
-
     @objc(initialize:withResolver:withRejecter:)
     func initialize(useSandBox: Bool, resolve: @escaping RCTPromiseResolveBlock, reject _: @escaping RCTPromiseRejectBlock) {
         SmileID.initialize(useSandbox: useSandBox)
         resolve(nil)
     }
 
+    @objc(setEnvironment:withResolver:withRejecter:)
+    func setEnvironment(useSandBox: Bool, resolve: @escaping RCTPromiseResolveBlock, reject _: @escaping RCTPromiseRejectBlock) {
+        SmileID.setEnvironment(useSandbox: useSandBox)
+        resolve(nil)
+    }
+
+    @objc(setCallbackUrl:withResolver:withRejecter:)
+    func setCallbackUrl(callbackUrl: String, resolve: @escaping RCTPromiseResolveBlock, reject _: @escaping RCTPromiseRejectBlock) {
+        SmileID.setCallbackUrl(url: URL(string: callbackUrl))
+        resolve(nil)
+    }
+
+    @objc(setAllowOfflineMode:withResolver:withRejecter:)
+    func setAllowOfflineMode(allowOfflineMode: Bool, resolve: @escaping RCTPromiseResolveBlock, reject _: @escaping RCTPromiseRejectBlock) {
+        SmileID.setAllowOfflineMode(allowOfflineMode: allowOfflineMode)
+        resolve(nil)
+    }
+
+    @objc(submitJob:withResolver:withRejecter:)
+    func submitJob(jobId: String, resolve: @escaping RCTPromiseResolveBlock, reject : @escaping RCTPromiseRejectBlock) {
+        do {
+            try SmileID.submitJob(jobId: jobId)
+            resolve(nil)
+        } catch let error as NSError {
+            reject("Error", error.localizedDescription, error)
+        }
+    }
+
+    @objc(getSubmittedJobs:withRejecter:)
+    func getSubmittedJobs(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let jobs: [String] =  SmileID.getUnsubmittedJobs()
+            resolve(jobs)
+        } catch let error as NSError {
+            reject("Error", error.localizedDescription, error)
+        }
+    }
+
+    @objc(getUnsubmittedJobs:withRejecter:)
+    func getUnsubmittedJobs(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
+        do {
+            let jobs: [String] =  SmileID.getUnsubmittedJobs()
+            resolve(jobs)
+        } catch let error as NSError {
+            reject("Error", error.localizedDescription, error)
+        }
+    }
+
+    @objc(cleanup:withResolver:withRejecter:)
+    func cleanup(jobId: String, resolve: @escaping RCTPromiseResolveBlock, reject : @escaping RCTPromiseRejectBlock) {
+        do {
+            try SmileID.cleanup(jobId: jobId)
+            resolve(nil)
+        } catch let error as NSError {
+            reject("Error", error.localizedDescription, error)
+        }
+    }
+
     @objc(authenticate:withResolver:withRejecter:)
     func authenticate(request: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         guard let authenticationRequest = request.toAuthenticationRequest() else {
@@ -18,12 +73,14 @@ class RNSmileID: NSObject {
             return
         }
 
-        SmileID.api.authenticate(request: authenticationRequest)
-            .sink(receiveCompletion: { completion in
-                self.handleCompletion(completion, reject: reject)
-            }, receiveValue: { response in
+        Task {
+            do {
+                let response = try await SmileID.api.authenticate(request: authenticationRequest)
                 self.resolveResponse(response, resolve: resolve, reject: reject)
-            }).store(in: &cancellables)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(prepUpload:withResolver:withRejecter:)
@@ -33,11 +90,14 @@ class RNSmileID: NSObject {
             return
         }
 
-        SmileID.api.prepUpload(request: prepUploadRequest)
-            .sink(
-                receiveCompletion: { completion in self.handleCompletion(completion, reject: reject) },
-                receiveValue: { response in self.resolveResponse(response, resolve: resolve, reject: reject)
-                }).store(in: &cancellables)
+        Task {
+            do {
+                let response = try await SmileID.api.prepUpload(request: prepUploadRequest)
+                self.resolveResponse(response, resolve: resolve, reject: reject)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(upload:request:withResolver:withRejecter:)
@@ -57,10 +117,14 @@ class RNSmileID: NSObject {
             return
         }
 
-        SmileID.api.upload(zip: zipData, to: url)
-            .sink(receiveCompletion: { completion in self.handleCompletion(completion, reject: reject) },
-                  receiveValue: { _ in resolve(nil) }) // Assuming no response to return
-            .store(in: &cancellables)
+        Task {
+            do {
+                try await SmileID.api.upload(zip: zipData, to: url)
+                resolve(nil)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(doEnhancedKyc:withResolver:withRejecter:)
@@ -111,23 +175,19 @@ class RNSmileID: NSObject {
             signature: signature
         )
 
-        SmileID.api.doEnhancedKyc(request: request)
-            .sink(receiveCompletion: { completion in
-                switch completion {
-                case let .failure(error):
-                    reject("Error", error.localizedDescription, error)
-                case .finished:
-                    break
-                }
-            }, receiveValue: { response in
+        Task {
+            do {
+                let response = try await SmileID.api.doEnhancedKyc(request: request)
                 let encoder = JSONEncoder()
                 guard let jsonData = try? encoder.encode(response) else {
-                    reject("Error", "doEnhancedKyc encoding error ",
-                           SmileIDError.unknown("doEnhancedKyc encoding error "))
-                    return
+                    throw SmileIDError.unknown("doEnhancedKyc encoding error")
                 }
-                resolve(["result": String(data: jsonData, encoding: .utf8)!]) // Assuming you have a method to convert response to a dictionary
-            }).store(in: &cancellables)
+                // Assuming you have a method to convert response to a dictionary
+                resolve(["result": String(data: jsonData, encoding: .utf8)!])
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(doEnhancedKycAsync:withResolver:withRejecter:)
@@ -178,23 +238,19 @@ class RNSmileID: NSObject {
             signature: signature
         )
 
-        SmileID.api.doEnhancedKycAsync(request: request)
-            .sink(receiveCompletion: { completion in
-                switch completion {
-                case let .failure(error):
-                    reject("Error", error.localizedDescription, error)
-                case .finished:
-                    break
-                }
-            }, receiveValue: { response in
-                let encoder = JSONEncoder()
-                guard let jsonData = try? encoder.encode(response) else {
-                    reject("Error", "doEnhancedKyc encoding error ",
-                           SmileIDError.unknown("doEnhancedKyc encoding error "))
-                    return
-                }
-                resolve(["result": String(data: jsonData, encoding: .utf8)!]) // Assuming you have a method to convert response to a dictionary
-            }).store(in: &cancellables)
+        Task {
+          do {
+              let response = try await SmileID.api.doEnhancedKycAsync(request: request)
+              let encoder = JSONEncoder()
+              guard let jsonData = try? encoder.encode(response) else {
+                  throw SmileIDError.unknown("doEnhancedKyc encoding error")
+              }
+              // Assuming you have a method to convert response to a dictionary
+              resolve(["result": String(data: jsonData, encoding: .utf8)!])
+          } catch {
+              reject("Error", error.localizedDescription, error)
+          }
+        }
     }
 
     @objc(getSmartSelfieJobStatus:withResolver:withRejecter:)
@@ -224,11 +280,14 @@ class RNSmileID: NSObject {
             return
         }
 
-        SmileID.api.getProductsConfig(request: productsConfigRequest)
-            .sink(
-                receiveCompletion: { completion in self.handleCompletion(completion, reject: reject) },
-                receiveValue: { response in self.resolveResponse(response, resolve: resolve, reject: reject)
-                }).store(in: &cancellables)
+        Task {
+            do {
+                let response = try await SmileID.api.getProductsConfig(request: productsConfigRequest)
+                self.resolveResponse(response, resolve: resolve, reject: reject)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(getValidDocuments:withResolver:withRejecter:)
@@ -238,18 +297,26 @@ class RNSmileID: NSObject {
             return
         }
 
-        SmileID.api.getValidDocuments(request: validDocumentsRequest)
-            .sink(receiveCompletion: { completion in self.handleCompletion(completion, reject: reject) },
-                  receiveValue: { response in self.resolveResponse(response, resolve: resolve, reject: reject) })
-            .store(in: &cancellables)
+        Task {
+            do {
+                let response = try await SmileID.api.getValidDocuments(request: validDocumentsRequest)
+                self.resolveResponse(response, resolve: resolve, reject: reject)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(getServicesWithResolver:withRejecter:)
     func getServices(resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
-        SmileID.api.getServices()
-            .sink(receiveCompletion: { completion in self.handleCompletion(completion, reject: reject) },
-                  receiveValue: { response in self.resolveResponse(response, resolve: resolve, reject: reject) })
-            .store(in: &cancellables)
+        Task {
+            do {
+                let response = try await SmileID.api.getServices()
+                self.resolveResponse(response, resolve: resolve, reject: reject)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(getJobStatus:withResolver:withRejecter:)
@@ -259,10 +326,14 @@ class RNSmileID: NSObject {
             return
         }
 
-        SmileID.api.getJobStatus(request: jobStatusRequest)
-            .sink(receiveCompletion: { completion in self.handleCompletion(completion, reject: reject) },
-                  receiveValue: { response in self.resolveResponse(response, resolve: resolve, reject: reject) })
-            .store(in: &cancellables)
+        Task {
+            do {
+                let response = try await SmileID.api.getJobStatus(request: jobStatusRequest)
+                self.resolveResponse(response, resolve: resolve, reject: reject)
+            } catch {
+                reject("Error", error.localizedDescription, error)
+            }
+        }
     }
 
     @objc(pollSmartSelfieJobStatus:withResolver:withRejecter:)
@@ -374,7 +445,7 @@ class RNSmileID: NSObject {
     }
 
     func pollJobStatus<RequestType, ResponseType: Encodable>(
-        apiCall: @escaping (RequestType, TimeInterval, Int) -> AnyPublisher<ResponseType, Error>,
+        apiCall: @escaping (RequestType, TimeInterval, Int) async throws -> ResponseType,
         request: RequestType,
         interval: Int64,
         numAttempts: Int64,
@@ -387,18 +458,14 @@ class RNSmileID: NSObject {
             return
         }
 
-        apiCall(request, timeInterval, numAttemptsInt)
-            .sink(receiveCompletion: { status in
-                switch status {
-                case .failure(let error):
-                    reject("ApiCallFailure", "API call failed with error: \(error.localizedDescription)", error)
-                case .finished:
-                    break
-                }
-            }, receiveValue: { [self] response in
-                resolveResponse(response, resolve: resolve, reject: reject)
-            })
-            .store(in: &cancellables)
+        Task {
+            do {
+                let response = try await apiCall(request, timeInterval, numAttemptsInt)
+                self.resolveResponse(response, resolve: resolve, reject: reject)
+            } catch {
+                reject("ApiCallFailure", "API call failed with error: \(error.localizedDescription)", error)
+            }
+        }
     }
 
 
@@ -407,15 +474,6 @@ class RNSmileID: NSObject {
         return TimeInterval(seconds)
     }
 
-    private func handleCompletion(_ completion: Subscribers.Completion<Error>, reject: @escaping RCTPromiseRejectBlock) {
-        switch completion {
-        case let .failure(error):
-            reject("Error", error.localizedDescription, error)
-        case .finished:
-            break
-        }
-    }
-
     private func resolveResponse<T: Encodable>(_ response: T, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         let encoder = JSONEncoder()
         guard let jsonData = try? encoder.encode(response) else {