freerasp-react-native 4.3.1 → 4.4.0

package/CHANGELOG.md

@@ -5,6 +5,66 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [4.4.0] - 2026-02-06
+
+- Android SDK version: 18.0.1
+- iOS SDK version: 6.13.0
+
+### React Native
+
+#### Added
+
+- Added cache for freeRASP callbacks when listener is not registered with the app
+- Added API for `automation` callback into `ThreatEventActions` (Android only)
+
+#### Fixed
+
+- Prevent multiple registration of the freeRASP listeners on the native side
+
+#### Changed
+
+- Updated compile and target SDK versions to 36 on Android
+- Higher compileSdk from [rootProject, plugin] is now used in build.gradle on Android
+
+### Android
+
+#### Added
+
+- Added support for `KernelSU` to the existing root detection capabilities
+- Added support for `HMA` to the existing root detection capabilities
+- Added new malware detection capabilities
+- Added `onAutomationDetected()` callback to `ThreatDetected` interface
+  - We are introducing a new capability, detecting whether the device is being automated using tools like Appium
+- Added value restrictions to `externalId`
+  - Method `storeExternalId()` now returns `ExternalIdResult`, which indicates `Success` or `Error` when `externalId` violates restrictions
+
+#### Fixed
+
+- Fixed exception handling for the KeyStore `getEntry` operation
+- Fixed issue in `ScreenProtector` concerning the `onScreenRecordingDetected` invocations
+- Merged internal shared libraries into a single one, reducing the final APK size
+- Fixed bug related to key storing in keystore type detection (hw-backed keystore check)
+- Fixed manifest queries merge
+
+#### Changed
+
+- Removed unused library `tmlib`
+- Refactoring of signature verification code
+- Updated compile and target API to 36
+- Improved root detection capabilities
+- Detection of wireless ADB added to ADB detections
+
+## [4.3.2] - 2026-01-03
+
+- Android SDK version: 17.0.1
+- iOS SDK version: 6.13.0
+
+### React Native
+
+#### Fixed
+
+- Resolved potential NullPointerException when execution state events are being sent 
+
 ## [4.3.1] - 2025-12-16
 
 - Android SDK version: 17.0.1

package/android/build.gradle

@@ -44,8 +44,14 @@ def getDefault(name) {
   return project.properties["FreeraspReactNative_" + name]
 }
 
+def getMaxVersion(name) {
+  def rootVersion = rootProject.ext.has(name) ? rootProject.ext.get(name).toInteger() : 0
+  def pluginVersion = getIntegerDefault(name)
+  return Math.max(rootVersion, pluginVersion)
+}
+
 android {
-  compileSdkVersion getIntegerDefault("compileSdkVersion")
+  compileSdk getMaxVersion("compileSdk")
 
   defaultConfig {
     minSdkVersion getIntegerDefault("minSdkVersion")
@@ -99,7 +105,7 @@ dependencies {
   implementation "com.facebook.react:react-native:$react_native_version"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
   implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1"
-  implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:17.0.1"
+  implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:18.0.2"
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -1,6 +1,6 @@
 FreeraspReactNative_kotlinVersion=2.1.0
 FreeraspReactNative_minSdkVersion=23
-FreeraspReactNative_targetSdkVersion=35
-FreeraspReactNative_compileSdkVersion=35
+FreeraspReactNative_targetSdkVersion=36
+FreeraspReactNative_compileSdk=36
 FreeraspReactNative_ndkversion=21.4.7075529
 FreeraspReactNative_reactNativeVersion=+

package/android/src/main/java/com/freeraspreactnative/FreeraspReactNativeModule.kt

@@ -4,6 +4,7 @@ import android.os.Build
 import android.os.Handler
 import android.os.HandlerThread
 import android.os.Looper
+import com.aheaditec.talsec_security.security.api.ExternalIdResult
 import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
 import com.aheaditec.talsec_security.security.api.Talsec
 import com.aheaditec.talsec_security.security.api.TalsecConfig
@@ -22,6 +23,8 @@ import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.freeraspreactnative.events.BaseRaspEvent
 import com.freeraspreactnative.events.RaspExecutionStateEvent
 import com.freeraspreactnative.events.ThreatEvent
+import com.freeraspreactnative.interfaces.PluginExecutionStateListener
+import com.freeraspreactnative.interfaces.PluginThreatListener
 import com.freeraspreactnative.utils.Utils
 import com.freeraspreactnative.utils.getArraySafe
 import com.freeraspreactnative.utils.getBooleanSafe
@@ -33,7 +36,6 @@ import com.freeraspreactnative.utils.toEncodedWritableArray
 class FreeraspReactNativeModule(private val reactContext: ReactApplicationContext) :
   ReactContextBaseJavaModule(reactContext) {
 
-  private val listener = ThreatListener(FreeraspThreatHandler, FreeraspThreatHandler, FreeraspThreatHandler)
   private val lifecycleListener = object : LifecycleEventListener {
     override fun onHostResume() {
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
@@ -57,8 +59,8 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
   }
 
   init {
-    appReactContext = reactContext
     reactContext.addLifecycleEventListener(lifecycleListener)
+    initializeEventKeys()
   }
 
   @ReactMethod
@@ -68,8 +70,7 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
 
     try {
       val config = buildTalsecConfig(options)
-      FreeraspThreatHandler.listener = ThreatListener
-      listener.registerListener(reactContext)
+      PluginThreatHandler.registerListener(reactContext)
       runOnUiThread {
         Talsec.start(reactContext, config, TalsecMode.BACKGROUND)
         mainHandler.post {
@@ -89,6 +90,12 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     }
   }
 
+  // Trigger lazy initialization of the freeRASP events
+  private fun initializeEventKeys() {
+    ThreatEvent.ALL_EVENTS
+    RaspExecutionStateEvent.ALL_EVENTS
+  }
+
   /**
    * Method to get the random identifiers of callbacks
    */
@@ -140,13 +147,30 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
   }
 
   @ReactMethod
-  fun addListener(@Suppress("UNUSED_PARAMETER") eventName: String) {
-    // Set up any upstream listeners or background tasks as necessary
+  fun addListener(eventName: String) {
+    if (eventName == ThreatEvent.CHANNEL_NAME) {
+      PluginThreatHandler.threatDispatcher.listener = PluginListener(reactContext)
+    }
+    if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {
+      PluginThreatHandler.executionStateDispatcher.listener = PluginListener(reactContext)
+    }
   }
 
   @ReactMethod
   fun removeListeners(@Suppress("UNUSED_PARAMETER") count: Int) {
-    // Remove upstream listeners, stop unnecessary background tasks
+    // built-in RN method, however it does not suit us as it just tells
+    // number of un-registered listeners, so we use `removeListenerForEvent`
+  }
+
+  @ReactMethod
+  fun removeListenerForEvent(eventName: String, promise: Promise) {
+    if (eventName == ThreatEvent.CHANNEL_NAME) {
+      PluginThreatHandler.threatDispatcher.listener = null
+    }
+    if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {
+      PluginThreatHandler.executionStateDispatcher.listener = null
+    }
+    promise.resolve("Listener unregistered")
   }
 
   /**
@@ -211,17 +235,41 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
 
   @ReactMethod
   fun storeExternalId(
-      externalId: String, promise: Promise
+    externalId: String, promise: Promise
   ) {
-      try {
-          Talsec.storeExternalId(reactContext, externalId)
-          promise.resolve("OK - Store external ID")
-      } catch (e: Exception) {
+    try {
+      when (val result = Talsec.storeExternalId(reactContext, externalId)) {
+        is ExternalIdResult.Error -> {
           promise.reject(
-              "NativePluginError",
-              "Error during storeExternalId operation in Talsec Native Plugin"
+            "ExternalIdError",
+            "Setting up External ID failed - ${result.errorMsg}"
           )
+        }
+
+        is ExternalIdResult.Success -> {
+          promise.resolve("OK - Store external ID")
+          return
+        }
       }
+    } catch (e: Exception) {
+      promise.reject(
+        "NativePluginError",
+        "Error during storeExternalId operation in Talsec Native Plugin"
+      )
+    }
+  }
+
+  @ReactMethod
+  fun removeExternalId(promise: Promise) {
+    try {
+      Talsec.removeExternalId(reactContext)
+      promise.resolve("OK - External ID removed")
+    } catch (e: Exception) {
+      promise.reject(
+        "NativePluginError",
+        "Error during storeExternalId operation in Talsec Native Plugin"
+      )
+    }
   }
 
   private fun buildTalsecConfig(config: ReadableMap): TalsecConfig {
@@ -253,11 +301,9 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     private val backgroundHandler = Handler(backgroundHandlerThread.looper)
     private val mainHandler = Handler(Looper.getMainLooper())
 
-    private lateinit var appReactContext: ReactApplicationContext
-
     internal var talsecStarted = false
 
-    private fun notifyEvent(event: BaseRaspEvent) {
+    private fun notifyEvent(event: BaseRaspEvent, appReactContext: ReactApplicationContext) {
       val params = Arguments.createMap()
       params.putInt(event.channelKey, event.value)
       appReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
@@ -267,7 +313,7 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     /**
      * Sends malware detected event to React Native
      */
-    private fun notifyMalware(suspiciousApps: MutableList<SuspiciousAppInfo>) {
+    private fun notifyMalware(suspiciousApps: MutableList<SuspiciousAppInfo>, appReactContext: ReactApplicationContext) {
       // Perform the malware encoding on a background thread
       backgroundHandler.post {
 
@@ -287,17 +333,17 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     }
   }
 
-  internal object ThreatListener : FreeraspThreatHandler.TalsecReactNative {
+  internal class PluginListener(private val reactContext: ReactApplicationContext) : PluginThreatListener, PluginExecutionStateListener {
     override fun threatDetected(threatEventType: ThreatEvent) {
-      notifyEvent(threatEventType)
+      notifyEvent(threatEventType, reactContext)
     }
 
     override fun malwareDetected(suspiciousApps: MutableList<SuspiciousAppInfo>) {
-      notifyMalware(suspiciousApps)
+      notifyMalware(suspiciousApps, reactContext)
     }
 
     override fun raspExecutionStateChanged(event: RaspExecutionStateEvent) {
-      notifyEvent(event)
+      notifyEvent(event, reactContext)
     }
   }
 }

package/android/src/main/java/com/freeraspreactnative/PluginThreatHandler.kt

@@ -0,0 +1,121 @@
+package com.freeraspreactnative
+
+import android.content.Context
+import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
+import com.aheaditec.talsec_security.security.api.ThreatListener
+import com.freeraspreactnative.dispatchers.ExecutionStateDispatcher
+import com.freeraspreactnative.dispatchers.ThreatDispatcher
+import com.freeraspreactnative.events.RaspExecutionStateEvent
+import com.freeraspreactnative.events.ThreatEvent
+
+internal object PluginThreatHandler {
+
+  internal val threatDispatcher = ThreatDispatcher()
+  internal val executionStateDispatcher = ExecutionStateDispatcher()
+
+  private val threatDetected = object : ThreatListener.ThreatDetected() {
+
+    override fun onRootDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)
+    }
+
+    override fun onDebuggerDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.Debug)
+    }
+
+    override fun onEmulatorDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.Simulator)
+    }
+
+    override fun onTamperDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)
+    }
+
+    override fun onUntrustedInstallationSourceDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)
+    }
+
+    override fun onHookDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.Hooks)
+    }
+
+    override fun onDeviceBindingDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)
+    }
+
+    override fun onObfuscationIssuesDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)
+    }
+
+    override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {
+      threatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())
+    }
+
+    override fun onScreenshotDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.Screenshot)
+    }
+
+    override fun onScreenRecordingDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)
+    }
+
+    override fun onMultiInstanceDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)
+    }
+
+    override fun onUnsecureWifiDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)
+    }
+
+    override fun onTimeSpoofingDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)
+    }
+
+    override fun onLocationSpoofingDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)
+    }
+
+    override fun onAutomationDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.Automation)
+    }
+  }
+
+  private val deviceState = object : ThreatListener.DeviceState() {
+
+    override fun onUnlockedDeviceDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.Passcode)
+    }
+
+    override fun onHardwareBackedKeystoreNotAvailableDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)
+    }
+
+    override fun onDeveloperModeDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.DevMode)
+    }
+
+    override fun onADBEnabledDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)
+    }
+
+    override fun onSystemVPNDetected() {
+      threatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)
+    }
+  }
+
+  private val raspExecutionState = object : ThreatListener.RaspExecutionState() {
+    override fun onAllChecksFinished() {
+      executionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)
+    }
+  }
+
+  private val internalListener = ThreatListener(threatDetected, deviceState, raspExecutionState)
+
+  internal fun registerListener(context: Context) {
+    internalListener.registerListener(context)
+  }
+
+  internal fun unregisterListener(context: Context) {
+    internalListener.unregisterListener(context)
+  }
+}

package/android/src/main/java/com/freeraspreactnative/dispatchers/ExecutionStateDispatcher.kt

@@ -0,0 +1,38 @@
+package com.freeraspreactnative.dispatchers
+
+import com.freeraspreactnative.events.RaspExecutionStateEvent
+import com.freeraspreactnative.interfaces.PluginExecutionStateListener
+
+internal class ExecutionStateDispatcher {
+  private val cache = mutableSetOf<RaspExecutionStateEvent>()
+
+  var listener: PluginExecutionStateListener? = null
+    set(value) {
+      field = value
+      if (value != null) {
+        flushCache(value)
+      }
+    }
+
+  fun dispatch(event: RaspExecutionStateEvent) {
+    val currentListener = listener
+    if (currentListener != null) {
+      currentListener.raspExecutionStateChanged(event)
+    } else {
+      synchronized(cache) {
+        val checkedListener = listener
+        checkedListener?.raspExecutionStateChanged(event) ?: cache.add(event)
+      }
+    }
+  }
+
+  private fun flushCache(registeredListener: PluginExecutionStateListener) {
+    val events = synchronized(cache) {
+      val snapshot = cache.toSet()
+      cache.clear()
+      snapshot
+    }
+    events.forEach { registeredListener.raspExecutionStateChanged(it) }
+  }
+}
+

package/android/src/main/java/com/freeraspreactnative/dispatchers/ThreatDispatcher.kt

@@ -0,0 +1,61 @@
+package com.freeraspreactnative.dispatchers
+
+import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
+import com.freeraspreactnative.events.ThreatEvent
+import com.freeraspreactnative.interfaces.PluginThreatListener
+
+internal class ThreatDispatcher {
+  private val threatCache = mutableSetOf<ThreatEvent>()
+  private val malwareCache = mutableSetOf<SuspiciousAppInfo>()
+
+  var listener: PluginThreatListener? = null
+    set(value) {
+      field = value
+      if (value != null) {
+        flushCache(value)
+      }
+    }
+
+  fun dispatchThreat(event: ThreatEvent) {
+    val currentListener = listener
+    if (currentListener != null) {
+      currentListener.threatDetected(event)
+    } else {
+      synchronized(threatCache) {
+        val checkedListener = listener
+        checkedListener?.threatDetected(event) ?: threatCache.add(event)
+      }
+    }
+  }
+
+  fun dispatchMalware(apps: MutableList<SuspiciousAppInfo>) {
+    val currentListener = listener
+    if (currentListener != null) {
+      currentListener.malwareDetected(apps)
+    } else {
+      synchronized(malwareCache) {
+        val checkedListener = listener
+        checkedListener?.malwareDetected(apps) ?: malwareCache.addAll(apps)
+      }
+    }
+  }
+
+  private fun flushCache(registeredListener: PluginThreatListener) {
+    val threats = synchronized(threatCache) {
+      val snapshot = threatCache.toSet()
+      threatCache.clear()
+      snapshot
+    }
+    threats.forEach { registeredListener.threatDetected(it) }
+
+    val malware = synchronized(malwareCache) {
+      val snapshot = malwareCache.toMutableList()
+      malwareCache.clear()
+      snapshot
+    }
+    if (malware.isNotEmpty()) {
+      registeredListener.malwareDetected(malware)
+    }
+  }
+}
+

package/android/src/main/java/com/freeraspreactnative/events/ThreatEvent.kt

@@ -34,6 +34,7 @@ internal sealed class ThreatEvent(override val value: Int) : BaseRaspEvent {
   data object TimeSpoofing : ThreatEvent(RandomGenerator.next())
   data object LocationSpoofing : ThreatEvent(RandomGenerator.next())
   data object UnsecureWifi : ThreatEvent(RandomGenerator.next())
+  data object Automation : ThreatEvent(RandomGenerator.next())
 
   companion object {
     internal val CHANNEL_NAME = RandomGenerator.next().toString()
@@ -61,7 +62,8 @@ internal sealed class ThreatEvent(override val value: Int) : BaseRaspEvent {
         MultiInstance,
         TimeSpoofing,
         LocationSpoofing,
-        UnsecureWifi
+        UnsecureWifi,
+        Automation
       ).map { it.value })
   }
 }

package/android/src/main/java/com/freeraspreactnative/interfaces/PluginExecutionStateListener.kt

@@ -0,0 +1,7 @@
+package com.freeraspreactnative.interfaces
+
+import com.freeraspreactnative.events.RaspExecutionStateEvent
+
+internal interface PluginExecutionStateListener {
+  fun raspExecutionStateChanged(event: RaspExecutionStateEvent)
+}

package/android/src/main/java/com/freeraspreactnative/interfaces/PluginThreatListener.kt

@@ -0,0 +1,9 @@
+package com.freeraspreactnative.interfaces
+
+import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
+import com.freeraspreactnative.events.ThreatEvent
+
+internal interface PluginThreatListener {
+  fun threatDetected(threatEventType: ThreatEvent)
+  fun malwareDetected(suspiciousApps: MutableList<SuspiciousAppInfo>)
+}

package/example/src/App.tsx

@@ -251,6 +251,16 @@ const App = () => {
         )
       );
     },
+    // Android only
+    automation: () => {
+      setAppChecks((currentState) =>
+        currentState.map((threat) =>
+          threat.name === 'Automation'
+            ? { ...threat, status: 'nok' }
+            : threat
+        )
+      );
+    },
   };
 
   const raspExecutionStateActions = {

package/example/src/DemoApp.tsx

@@ -21,6 +21,7 @@ import {
   blockScreenCapture,
   type SuspiciousAppInfo,
   storeExternalId,
+  removeExternalId,
 } from 'freerasp-react-native';
 import {
   ALERT_TYPE,
@@ -84,6 +85,24 @@ export const DemoApp: React.FC<{
     }
   };
 
+  const handleModalRemove = async () => {
+    setModalVisible(false);
+    try {
+      await removeExternalId();
+      Toast.show({
+        type: ALERT_TYPE.SUCCESS,
+        title: 'Success',
+        textBody: 'External ID removed',
+      });
+    } catch (error: any) {
+      Toast.show({
+        type: ALERT_TYPE.WARNING,
+        title: 'Warning',
+        textBody: 'External ID not removed',
+      });
+    }
+  };
+
   const handleModalDismiss = () => {
     setModalVisible(false);
   };
@@ -140,6 +159,11 @@ export const DemoApp: React.FC<{
                           onPress={handleModalSend}>
                           <Text style={styles.modalText}>Send</Text>
                         </TouchableOpacity>
+                        <TouchableOpacity
+                          style={styles.removeButton}
+                          onPress={handleModalRemove}>
+                          <Text style={styles.modalText}>Remove</Text>
+                        </TouchableOpacity>
                         <TouchableOpacity
                           style={styles.dismissButton}
                           onPress={handleModalDismiss}>
@@ -346,6 +370,14 @@ const styles = StyleSheet.create({
     marginRight: 10,
     alignItems: 'center',
   },
+  removeButton: {
+    backgroundColor: '#FF9800',
+    padding: 10,
+    borderRadius: 5,
+    flex: 1,
+    marginRight: 10,
+    alignItems: 'center',
+  },
   dismissButton: {
     backgroundColor: '#f44336',
     padding: 10,

package/example/src/checks.ts

@@ -24,4 +24,5 @@ export const androidChecks = [
   { name: 'Time Spoofing', status: 'ok' },
   { name: 'Location Spoofing', status: 'ok' },
   { name: 'Unsecure Wifi', status: 'ok' },
+  { name: 'Automation', status: 'ok' },
 ];

package/freerasp-react-native.podspec

@@ -14,7 +14,11 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => "11.0" }
   s.source       = { :git => "https://github.com/talsec/freerasp-react-native.git", :tag => "#{s.version}" }
 
-  s.source_files = 'ios/models/*.{h,m,mm,swift}', 'ios/utils/*.{h,m,mm,swift}', 'ios/*.{h,m,mm,swift}', 'ios/TalsecRuntime.xcframework'
+  s.source_files = 'ios/models/*.{h,m,mm,swift}', 
+                   'ios/utils/*.{h,m,mm,swift}', 
+                   'ios/dispatchers/*.{h,m,mm,swift}', 
+                   'ios/*.{h,m,mm,swift}', 
+                   'ios/TalsecRuntime.xcframework'
   s.xcconfig = { 'OTHER_LDFLAGS' => '-framework TalsecRuntime' }
   s.ios.vendored_frameworks = "ios/TalsecRuntime.xcframework"
   

package/ios/FreeraspReactNative.m

@@ -15,6 +15,9 @@ RCT_EXTERN_METHOD(getRaspExecutionStateChannelData:(RCTPromiseResolveBlock)resol
                   withRejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(getRaspExecutionStateIdentifiers:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(removeListenerForEvent:(NSString *)eventName
+                  withResolver:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(blockScreenCapture:(BOOL)enable
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
@@ -23,6 +26,8 @@ RCT_EXTERN_METHOD(isScreenCaptureBlocked:(RCTPromiseResolveBlock)resolve
 RCT_EXTERN_METHOD(storeExternalId:(NSString *)externalId
                   withResolver:(RCTPromiseResolveBlock)resolve
                   withRejecter:(RCTPromiseRejectBlock)reject)
+RCT_EXTERN_METHOD(removeExternalId:(RCTPromiseResolveBlock)resolve
+                  withRejecter:(RCTPromiseRejectBlock)reject)
 RCT_EXTERN_METHOD(onInvalidCallback)
 
 + (BOOL)requiresMainQueueSetup