update the android sdk, implement ios cache + align api

tompsota · tompsota · commit adf5475a429d · 2026-02-10T11:34:49.000+01:00
diff --git a/android/build.gradle b/android/build.gradle
@@ -105,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:18.0.1"
+  implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:18.0.2"
 }
 
 if (isNewArchitectureEnabled()) {
diff --git a/android/src/main/java/com/freeraspreactnative/FreeraspReactNativeModule.kt b/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
@@ -244,8 +245,32 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     externalId: String, promise: Promise
   ) {
     try {
-      Talsec.storeExternalId(reactContext, externalId)
-      promise.resolve("OK - Store external ID")
+      when (val result = Talsec.storeExternalId(reactContext, externalId)) {
+        is ExternalIdResult.Error -> {
+          promise.reject(
+            "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",
diff --git a/android/src/main/java/com/freeraspreactnative/dispatchers/ExecutionStateDispatcher.kt b/android/src/main/java/com/freeraspreactnative/dispatchers/ExecutionStateDispatcher.kt
@@ -27,10 +27,12 @@ internal class ExecutionStateDispatcher {
   }
 
   private fun flushCache(registeredListener: WrapperExecutionStateListener) {
-    synchronized(cache) {
-      cache.forEach { registeredListener.raspExecutionStateChanged(it) }
+    val events = synchronized(cache) {
+      val snapshot = cache.toSet()
       cache.clear()
+      snapshot
     }
+    events.forEach { registeredListener.raspExecutionStateChanged(it) }
   }
 }
 
diff --git a/android/src/main/java/com/freeraspreactnative/dispatchers/ThreatDispatcher.kt b/android/src/main/java/com/freeraspreactnative/dispatchers/ThreatDispatcher.kt
@@ -41,15 +41,20 @@ internal class ThreatDispatcher {
   }
 
   private fun flushCache(registeredListener: WrapperThreatListener) {
-    synchronized(threatCache) {
-      threatCache.forEach { registeredListener.threatDetected(it) }
+    val threats = synchronized(threatCache) {
+      val snapshot = threatCache.toSet()
       threatCache.clear()
+      snapshot
     }
-    synchronized(malwareCache) {
-      if (malwareCache.isNotEmpty()) {
-        registeredListener.malwareDetected(malwareCache.toMutableList())
-        malwareCache.clear()
-      }
+    threats.forEach { registeredListener.threatDetected(it) }
+
+    val malware = synchronized(malwareCache) {
+      val snapshot = malwareCache.toMutableList()
+      malwareCache.clear()
+      snapshot
+    }
+    if (malware.isNotEmpty()) {
+      registeredListener.malwareDetected(malware)
     }
   }
 }
diff --git a/example/src/DemoApp.tsx b/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,
diff --git a/freerasp-react-native.podspec b/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"
   
diff --git a/ios/FreeraspReactNative.m b/ios/FreeraspReactNative.m
@@ -15,6 +15,9 @@ @interface RCT_EXTERN_MODULE(FreeraspReactNative, RCTEventEmitter)
                   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 @@ @interface RCT_EXTERN_MODULE(FreeraspReactNative, RCTEventEmitter)
 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
diff --git a/ios/FreeraspReactNative.swift b/ios/FreeraspReactNative.swift
@@ -11,6 +11,30 @@ class FreeraspReactNative: RCTEventEmitter {
         FreeraspReactNative.shared = self
     }
 
+    @objc(addListener:)
+    override func addListener(_ eventName: String!) {
+        super.addListener(eventName)
+        if eventName == EventIdentifiers.threatChannelName {
+            ThreatDispatcher.shared.listener = { [weak self] threat in
+                self?.dispatchThreatEvent(threat: threat)
+            }
+        } else if eventName == EventIdentifiers.raspExecutionStateChannelName {
+            ExecutionStateDispatcher.shared.listener = { [weak self] event in
+                self?.dispatchRaspExecutionStateEvent(event: event)
+            }
+        }
+    }
+
+    @objc(removeListenerForEvent:withResolver:withRejecter:)
+    func removeListenerForEvent(eventName: String, resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) -> Void {
+        if eventName == EventIdentifiers.threatChannelName {
+            ThreatDispatcher.shared.listener = nil
+        } else if eventName == EventIdentifiers.raspExecutionStateChannelName {
+            ExecutionStateDispatcher.shared.listener = nil
+        }
+        resolve("Listener unregistered")
+    }
+
     @objc(talsecStart:withResolver:withRejecter:)
     func talsecStart(options: NSDictionary, resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) -> Void {
         do {
@@ -72,12 +96,18 @@ class FreeraspReactNative: RCTEventEmitter {
         resolve("OK - Store external ID")
     }
 
+    @objc(removeExternalId:withRejecter:)
+    private func removeExternalId(resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) -> Void {
+        UserDefaults.standard.removeObject(forKey: "app.talsec.externalid")
+        resolve("OK - External ID removed")
+    }
+
     /**
      * Method to setup the message passing between native and React Native
      */
     @objc(getThreatChannelData:withRejecter:)
     private func getThreatChannelData(resolve: RCTPromiseResolveBlock, rejecter reject: RCTPromiseRejectBlock) -> Void {
-        resolve([EventIdentifiers.threatChannelName, EventIdentifiers.threatChannelKey])
+        resolve([EventIdentifiers.threatChannelName, EventIdentifiers.threatChannelKey, "0"])
     }
   
     /**
@@ -88,16 +118,16 @@ class FreeraspReactNative: RCTEventEmitter {
       resolve([EventIdentifiers.raspExecutionStateChannelName, EventIdentifiers.raspExecutionStateChannelKey])
     }
 
-    func dispatchEvent(securityThreat: SecurityThreat) -> Void {
+    func dispatchThreatEvent(threat: SecurityThreat) {
         FreeraspReactNative.shared!.sendEvent(withName: EventIdentifiers.threatChannelName, body: [
-          EventIdentifiers.threatChannelKey: securityThreat.callbackIdentifier,
+            EventIdentifiers.threatChannelKey: threat.callbackIdentifier
         ])
     }
   
-    func dispatchRaspExecutionStateEvent(event: RaspExecutionStates) -> Void {
-      FreeraspReactNative.shared!.sendEvent(withName: EventIdentifiers.raspExecutionStateChannelName, body: [
-        EventIdentifiers.raspExecutionStateChannelKey: event.callbackIdentifier,
-      ])
+    func dispatchRaspExecutionStateEvent(event: RaspExecutionStates) {
+        FreeraspReactNative.shared!.sendEvent(withName: EventIdentifiers.raspExecutionStateChannelName, body: [
+            EventIdentifiers.raspExecutionStateChannelKey: event.callbackIdentifier,
+        ])
     }
 
     /**
@@ -139,12 +169,11 @@ extension SecurityThreatCenter: @retroactive SecurityThreatHandler, @retroactive
         if (securityThreat.rawValue == "passcodeChange") {
             return
         }
-        FreeraspReactNative.shared!.dispatchEvent(securityThreat: securityThreat)
+        ThreatDispatcher.shared.dispatch(threat: securityThreat)
     }
   
     public func onAllChecksFinished() {
-      
-      FreeraspReactNative.shared!.dispatchRaspExecutionStateEvent(event: RaspExecutionStates.allChecksFinished)
+        ExecutionStateDispatcher.shared.dispatch(event: RaspExecutionStates.allChecksFinished)
     }
 }
 
diff --git a/ios/dispatchers/ExecutionStateDispatcher.swift b/ios/dispatchers/ExecutionStateDispatcher.swift
@@ -0,0 +1,35 @@
+import Foundation
+
+class ExecutionStateDispatcher {
+    static let shared = ExecutionStateDispatcher()
+    private var cache: Set<RaspExecutionStates> = []
+    private let lock = NSLock()
+    
+    var listener: ((RaspExecutionStates) -> Void)? {
+        didSet {
+            if listener != nil {
+                flushCache()
+            }
+        }
+    }
+
+    func dispatch(event: RaspExecutionStates) {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        if let listener = listener {
+            listener(event)
+        } else {
+            cache.insert(event)
+        }
+    }
+
+    private func flushCache() {
+        lock.lock()
+        let events = cache
+        cache.removeAll()
+        lock.unlock()
+        
+        events.forEach { listener?($0) }
+    }
+}
diff --git a/ios/dispatchers/ThreatDispatcher.swift b/ios/dispatchers/ThreatDispatcher.swift
@@ -0,0 +1,36 @@
+import Foundation
+import TalsecRuntime
+
+class ThreatDispatcher {
+    static let shared = ThreatDispatcher()
+    private var threatCache: Set<SecurityThreat> = []
+    private let lock = NSLock()
+    
+    var listener: ((SecurityThreat) -> Void)? {
+        didSet {
+            if listener != nil {
+                flushCache()
+            }
+        }
+    }
+
+    func dispatch(threat: SecurityThreat) {
+        lock.lock()
+        defer { lock.unlock() }
+        
+        if let listener = listener {
+            listener(threat)
+        } else {
+            threatCache.insert(threat)
+        }
+    }
+
+    private func flushCache() {
+        lock.lock()
+        let threats = threatCache
+        threatCache.removeAll()
+        lock.unlock()
+        
+        threats.forEach { listener?($0) }
+    }
+}
diff --git a/src/api/methods/native.ts b/src/api/methods/native.ts
@@ -25,6 +25,10 @@ export const storeExternalId = (data: string): Promise<string> => {
   return FreeraspReactNative.storeExternalId(data);
 };
 
+export const removeExternalId = (): Promise<string> => {
+  return FreeraspReactNative.removeExternalId();
+};
+
 export const getAppIcon = (packageName: string): Promise<string> => {
   if (Platform.OS === 'ios') {
     return Promise.reject(
diff --git a/src/channels/threat.ts b/src/channels/threat.ts
@@ -18,9 +18,8 @@ export const getThreatIdentifiers = async (): Promise<number[]> => {
 export const getThreatChannelData = async (): Promise<
   [string, string, string]
 > => {
-  const dataLength = Platform.OS === 'ios' ? 2 : 3;
   const data = await FreeraspReactNative.getThreatChannelData();
-  if (data.length !== dataLength || !itemsHaveType(data, 'string')) {
+  if (data.length !== 3 || !itemsHaveType(data, 'string')) {
     onInvalidCallback();
   }
   return data;

Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ dependencies {`
`105`	`105`	`implementation "com.facebook.react:react-native:$react_native_version"`
`106`	`106`	`implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"`
`107`	`107`	`implementation "org.jetbrains.kotlinx:kotlinx-serialization-json:1.4.1"`
`108`		`- implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:18.0.1"`
	`108`	`+ implementation "com.aheaditec.talsec.security:TalsecSecurity-Community-ReactNative:18.0.2"`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`if (isNewArchitectureEnabled()) {`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,12 @@ internal class ExecutionStateDispatcher {`
`27`	`27`	`}`
`28`	`28`
`29`	`29`	`private fun flushCache(registeredListener: WrapperExecutionStateListener) {`
`30`		`- synchronized(cache) {`
`31`		`- cache.forEach { registeredListener.raspExecutionStateChanged(it) }`
	`30`	`+ val events = synchronized(cache) {`
	`31`	`+ val snapshot = cache.toSet()`
`32`	`32`	`cache.clear()`
	`33`	`+ snapshot`
`33`	`34`	`}`
	`35`	`+ events.forEach { registeredListener.raspExecutionStateChanged(it) }`
`34`	`36`	`}`
`35`	`37`	`}`
`36`	`38`
Original file line number	Diff line number	Diff line change
`@@ -41,15 +41,20 @@ internal class ThreatDispatcher {`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`private fun flushCache(registeredListener: WrapperThreatListener) {`
`44`		`- synchronized(threatCache) {`
`45`		`- threatCache.forEach { registeredListener.threatDetected(it) }`
	`44`	`+ val threats = synchronized(threatCache) {`
	`45`	`+ val snapshot = threatCache.toSet()`
`46`	`46`	`threatCache.clear()`
	`47`	`+ snapshot`
`47`	`48`	`}`
`48`		`- synchronized(malwareCache) {`
`49`		`- if (malwareCache.isNotEmpty()) {`
`50`		`- registeredListener.malwareDetected(malwareCache.toMutableList())`
`51`		`- malwareCache.clear()`
`52`		`- }`
	`49`	`+ threats.forEach { registeredListener.threatDetected(it) }`
	`50`	`+`
	`51`	`+ val malware = synchronized(malwareCache) {`
	`52`	`+ val snapshot = malwareCache.toMutableList()`
	`53`	`+ malwareCache.clear()`
	`54`	`+ snapshot`
	`55`	`+ }`
	`56`	`+ if (malware.isNotEmpty()) {`
	`57`	`+ registeredListener.malwareDetected(malware)`
`53`	`58`	`}`
`54`	`59`	`}`
`55`	`60`	`}`