capacitor-freerasp 2.3.0 → 2.4.1

package/CHANGELOG.md

@@ -5,6 +5,65 @@ 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).
 
+## [2.4.1] - 2026-02-13
+
+- Android SDK version: 18.0.2
+- iOS SDK version: 6.13.0
+
+### Capacitor
+
+#### Fixed
+
+- Resolved potential NullPointerException when execution state events are being sent 
+
+## [2.4.0] - 2026-02-13
+
+- Android SDK version: 18.0.2
+- iOS SDK version: 6.13.0
+
+### Capacitor
+
+#### 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
+
+### 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
+
 ## [2.3.0] - 2025-12-15
 
 - Android SDK version: 17.0.1

package/CapacitorFreerasp.podspec

@@ -10,7 +10,11 @@ Pod::Spec.new do |s|
   s.homepage = package['repository']['url']
   s.author = package['author']
   s.source = { :git => package['repository']['url'], :tag => s.version.to_s }
-  s.source_files = 'ios/Plugin/models/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/utils/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/*.{swift,h,m,c,cc,mm,cpp}', 'ios/Plugin/TalsecRuntime.xcframework'
+  s.source_files = 'ios/Plugin/models/*.{swift,h,m,c,cc,mm,cpp}', 
+                   'ios/Plugin/utils/*.{swift,h,m,c,cc,mm,cpp}', 
+                   'ios/Plugin/dispatchers/*.{swift,h,m,c,cc,mm,cpp}', 
+                   'ios/Plugin/*.{swift,h,m,c,cc,mm,cpp}', 
+                   'ios/Plugin/TalsecRuntime.xcframework'
   s.ios.deployment_target  = '13.0'
   s.dependency 'Capacitor'
   s.swift_version = '5.1'

package/android/build.gradle

@@ -27,10 +27,10 @@ apply plugin: 'kotlinx-serialization'
 
 android {
     namespace "com.aheaditec.freerasp"
-    compileSdk 35
+    compileSdk Math.max(36, project.hasProperty('rootProject.ext.compileSdk') ? rootProject.ext.compileSdk as int : 36)
     defaultConfig {
         minSdkVersion 23
-        targetSdkVersion 35
+        targetSdkVersion 36
         versionCode 1
         versionName "1.0"
         testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
@@ -76,5 +76,5 @@ dependencies {
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"
     
-    implementation 'com.aheaditec.talsec.security:TalsecSecurity-Community-Capacitor:17.0.1'
+    implementation 'com.aheaditec.talsec.security:TalsecSecurity-Community-Capacitor:18.0.2'
 }

package/android/src/main/java/com/aheaditec/freerasp/FreeraspPlugin.kt

@@ -1,5 +1,6 @@
 package com.aheaditec.freerasp
 
+import android.content.Context
 import android.os.Build
 import android.os.Handler
 import android.os.HandlerThread
@@ -11,10 +12,11 @@ import com.aheaditec.freerasp.utils.toEncodedJSArray
 import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
 import com.aheaditec.talsec_security.security.api.Talsec
 import com.aheaditec.talsec_security.security.api.TalsecConfig
-import com.aheaditec.talsec_security.security.api.ThreatListener
 import com.aheaditec.freerasp.events.BaseRaspEvent
 import com.aheaditec.freerasp.events.RaspExecutionStateEvent
 import com.aheaditec.freerasp.events.ThreatEvent
+import com.aheaditec.freerasp.interfaces.PluginExecutionStateListener
+import com.aheaditec.freerasp.interfaces.PluginThreatListener
 import com.getcapacitor.JSObject
 import com.getcapacitor.Plugin
 import com.getcapacitor.PluginCall
@@ -22,13 +24,18 @@ import com.getcapacitor.PluginMethod
 import com.getcapacitor.annotation.CapacitorPlugin
 import org.json.JSONArray
 
+typealias CapacitorCallback = (String, JSObject) -> Unit
+
 @CapacitorPlugin(name = "Freerasp")
 class FreeraspPlugin : Plugin() {
 
-    private val threatHandler = TalsecThreatHandler(this)
-    private val listener = ThreatListener(threatHandler, threatHandler, threatHandler)
     private var registered = true
 
+    override fun load() {
+        initializeEventKeys()
+        super.load()
+    }
+
     @PluginMethod
     fun talsecStart(call: PluginCall) {
         val config = call.getObject("config")
@@ -38,7 +45,15 @@ class FreeraspPlugin : Plugin() {
         }
         try {
             val talsecConfig = buildTalsecConfigThrowing(config)
-            listener.registerListener(context)
+
+            val pluginCallback: CapacitorCallback = { eventName, data ->
+                notifyListeners(eventName, data, true)
+            }
+
+            PluginThreatHandler.threatDispatcher.listener = PluginListener(context, pluginCallback)
+            PluginThreatHandler.executionStateDispatcher.listener = PluginListener(context, pluginCallback)
+            PluginThreatHandler.registerListener(context)
+
             bridge.activity.runOnUiThread {
                 Talsec.start(context, talsecConfig)
                 mainHandler.post {
@@ -70,8 +85,10 @@ class FreeraspPlugin : Plugin() {
     override fun handleOnPause() {
         super.handleOnPause()
         if (activity.isFinishing) {
-            listener.unregisterListener(context)
+            PluginThreatHandler.unregisterListener(context)
             registered = false
+            PluginThreatHandler.threatDispatcher.listener = null
+            PluginThreatHandler.executionStateDispatcher.listener = null
         }
     }
 
@@ -79,7 +96,7 @@ class FreeraspPlugin : Plugin() {
         super.handleOnResume()
         if (!registered) {
             registered = true
-            listener.registerListener(context)
+            PluginThreatHandler.registerListener(context)
         }
     }
 
@@ -95,6 +112,12 @@ class FreeraspPlugin : Plugin() {
         backgroundHandlerThread.quitSafely()
     }
 
+    // Trigger lazy initialization of the freeRASP events
+    private fun initializeEventKeys() {
+        ThreatEvent.ALL_EVENTS
+        RaspExecutionStateEvent.ALL_EVENTS
+    }
+
     /**
      * Method to get the random identifiers of callbacks
      */
@@ -129,15 +152,15 @@ class FreeraspPlugin : Plugin() {
      * Method to setup the execution state message passing between native and Capacitor
      * @return list of [CHANNEL_NAME, CHANNEL_KEY]
      */
-     @PluginMethod
-     fun getRaspExecutionStateChannelData(call: PluginCall) {
+    @PluginMethod
+    fun getRaspExecutionStateChannelData(call: PluginCall) {
         val channelData = JSONArray(
             (listOf(
                 RaspExecutionStateEvent.CHANNEL_NAME, RaspExecutionStateEvent.CHANNEL_KEY
             ))
         )
         call.resolve(JSObject().put("ids", channelData))
-     }
+    }
 
     /**
      * We never send an invalid callback over our channel.
@@ -253,21 +276,17 @@ class FreeraspPlugin : Plugin() {
         }
     }
 
-    internal fun notifyListeners(event: BaseRaspEvent) {
-        notifyListeners(event.channelName, JSObject().put(event.channelKey, event.value), true)
-    }
-
-    internal fun notifyMalware(suspiciousApps: MutableList<SuspiciousAppInfo>) {
-        // Perform the malware encoding on a background thread
-        backgroundHandler.post {
-
-            val encodedSuspiciousApps = suspiciousApps.toEncodedJSArray(context)
-            mainHandler.post {
-                val params = JSObject()
-                    .put(ThreatEvent.CHANNEL_KEY, ThreatEvent.Malware.value)
-                    .put(ThreatEvent.MALWARE_CHANNEL_KEY, encodedSuspiciousApps)
-                notifyListeners(ThreatEvent.CHANNEL_NAME, params, true)
-            }
+    @PluginMethod
+    fun removeExternalId(call: PluginCall) {
+        try {
+            Talsec.removeExternalId(context)
+            call.resolve(JSObject().put("result", true))
+        } catch (e: Exception) {
+            call.reject(
+                "Error during removeExternalId operation in freeRASP Native Plugin",
+                "NativePluginError"
+            )
+            return
         }
     }
 
@@ -298,5 +317,49 @@ class FreeraspPlugin : Plugin() {
         private val mainHandler = Handler(Looper.getMainLooper())
 
         internal var talsecStarted = false
+
+        internal fun notifyEvent(
+            event: BaseRaspEvent,
+            notifyListenersCallback: CapacitorCallback
+        ) {
+            val params = JSObject().put(event.channelKey, event.value)
+            notifyListenersCallback(event.channelName, params)
+        }
+
+        internal fun notifyMalware(
+            suspiciousApps: MutableList<SuspiciousAppInfo>,
+            context: Context,
+            notifyListenersCallback: CapacitorCallback
+        ) {
+            // Perform the malware encoding on a background thread
+            backgroundHandler.post {
+
+                val encodedSuspiciousApps = suspiciousApps.toEncodedJSArray(context)
+                mainHandler.post {
+                    val params = JSObject()
+                        .put(ThreatEvent.CHANNEL_KEY, ThreatEvent.Malware.value)
+                        .put(ThreatEvent.MALWARE_CHANNEL_KEY, encodedSuspiciousApps)
+                    notifyListenersCallback.invoke(ThreatEvent.CHANNEL_NAME, params)
+                }
+
+            }
+        }
+    }
+
+    internal class PluginListener(
+        private val context: Context,
+        private val pluginCallback: CapacitorCallback
+    ) : PluginThreatListener, PluginExecutionStateListener {
+        override fun threatDetected(threatEventType: ThreatEvent) {
+            notifyEvent(threatEventType, pluginCallback)
+        }
+
+        override fun malwareDetected(suspiciousApps: MutableList<SuspiciousAppInfo>) {
+            notifyMalware(suspiciousApps, context, pluginCallback)
+        }
+
+        override fun raspExecutionStateChanged(event: RaspExecutionStateEvent) {
+            notifyEvent(event, pluginCallback)
+        }
     }
 }

package/android/src/main/java/com/aheaditec/freerasp/PluginThreatHandler.kt

@@ -0,0 +1,121 @@
+package com.aheaditec.freerasp
+
+import android.content.Context
+import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
+import com.aheaditec.talsec_security.security.api.ThreatListener
+import com.aheaditec.freerasp.dispatchers.ExecutionStateDispatcher
+import com.aheaditec.freerasp.dispatchers.ThreatDispatcher
+import com.aheaditec.freerasp.events.RaspExecutionStateEvent
+import com.aheaditec.freerasp.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/aheaditec/freerasp/dispatchers/ExecutionStateDispatcher.kt

@@ -0,0 +1,38 @@
+package com.aheaditec.freerasp.dispatchers
+
+import com.aheaditec.freerasp.events.RaspExecutionStateEvent
+import com.aheaditec.freerasp.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 checkedListener = synchronized(cache) {
+            val currentListener = listener
+            if (currentListener != null) {
+                currentListener
+            } else {
+                cache.add(event)
+                null
+            }
+        }
+        checkedListener?.raspExecutionStateChanged(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/aheaditec/freerasp/dispatchers/ThreatDispatcher.kt

@@ -0,0 +1,62 @@
+package com.aheaditec.freerasp.dispatchers
+
+import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
+import com.aheaditec.freerasp.events.ThreatEvent
+import com.aheaditec.freerasp.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 checkedListener = synchronized(threatCache) {
+            val currentListener = listener
+            if (currentListener != null) {
+                currentListener
+            } else {
+                threatCache.add(event)
+                null
+            }
+        }
+        checkedListener?.threatDetected(event)
+    }
+
+    fun dispatchMalware(apps: MutableList<SuspiciousAppInfo>) {
+        val checkedListener = synchronized(malwareCache) {
+            val currentListener = listener
+            if (currentListener != null) {
+                currentListener
+            } else {
+                malwareCache.addAll(apps)
+                null
+            }
+        }
+        checkedListener?.malwareDetected(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/aheaditec/freerasp/events/ThreatEvent.kt

@@ -34,6 +34,7 @@ internal sealed class ThreatEvent(override val value: Int) : BaseRaspEvent {
     object TimeSpoofing : ThreatEvent(RandomGenerator.next())
     object LocationSpoofing : ThreatEvent(RandomGenerator.next())
     object UnsecureWifi : ThreatEvent(RandomGenerator.next())
+    object Automation : ThreatEvent(RandomGenerator.next())
 
     companion object {
 
@@ -62,7 +63,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/aheaditec/freerasp/interfaces/PluginExecutionStateListener.kt

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

package/android/src/main/java/com/aheaditec/freerasp/interfaces/PluginThreatListener.kt

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

package/dist/esm/api/listeners/raspExecutionState.d.ts

@@ -1,2 +1,3 @@
 import type { RaspExecutionStateEventActions } from '../../types/types';
 export declare const registerRaspExecutionStateListener: (config: RaspExecutionStateEventActions) => Promise<void>;
+export declare const removeRaspExecutionStateListener: () => Promise<void>;

package/dist/esm/api/listeners/raspExecutionState.js

@@ -2,10 +2,20 @@ import { getRaspExecutionStateChannelData, prepareRaspExecutionStateMapping } fr
 import { RaspExecutionState } from '../../models/raspExecutionState';
 import { onInvalidCallback } from '../methods/native';
 import { Talsec } from '../nativeModules';
+let eventsListener = null;
+let isInitializing = false;
 export const registerRaspExecutionStateListener = async (config) => {
+    if (isInitializing) {
+        return;
+    }
+    isInitializing = true;
+    if (eventsListener) {
+        await eventsListener.remove();
+        eventsListener = null;
+    }
     const [channel, key] = await getRaspExecutionStateChannelData();
     await prepareRaspExecutionStateMapping();
-    await Talsec.addListener(channel, async (event) => {
+    eventsListener = await Talsec.addListener(channel, async (event) => {
         var _a;
         if (event[key] == undefined) {
             onInvalidCallback();
@@ -19,5 +29,12 @@ export const registerRaspExecutionStateListener = async (config) => {
                 break;
         }
     });
+    isInitializing = false;
+};
+export const removeRaspExecutionStateListener = async () => {
+    if (eventsListener) {
+        await eventsListener.remove();
+        eventsListener = null;
+    }
 };
 //# sourceMappingURL=raspExecutionState.js.map

package/dist/esm/api/listeners/raspExecutionState.js.map

@@ -1 +1 @@
-{"version":3,"file":"raspExecutionState.js","sourceRoot":"","sources":["../../../../src/api/listeners/raspExecutionState.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gCAAgC,EAAE,gCAAgC,EAAE,MAAM,mCAAmC,CAAC;AACvH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,MAAM,CAAC,MAAM,kCAAkC,GAAG,KAAK,EAAE,MAAsC,EAAiB,EAAE;IAChH,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,MAAM,gCAAgC,EAAE,CAAC;IAChE,MAAM,gCAAgC,EAAE,CAAC;IAEzC,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,KAAU,EAAE,EAAE;;QACrD,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,SAAS,EAAE,CAAC;YAC5B,iBAAiB,EAAE,CAAC;QACtB,CAAC;QACD,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YACnB,KAAK,kBAAkB,CAAC,iBAAiB,CAAC,KAAK;gBAC7C,MAAA,MAAM,CAAC,iBAAiB,sDAAI,CAAC;gBAC7B,MAAM;YACR;gBACE,iBAAiB,EAAE,CAAC;gBACpB,MAAM;QACV,CAAC;IACH,CAAC,CAAC,CAAC;AACL,CAAC,CAAC","sourcesContent":["import { getRaspExecutionStateChannelData, prepareRaspExecutionStateMapping } from '../../channels/raspExecutionState';\nimport { RaspExecutionState } from '../../models/raspExecutionState';\nimport type { RaspExecutionStateEventActions } from '../../types/types';\nimport { onInvalidCallback } from '../methods/native';\nimport { Talsec } from '../nativeModules';\n\nexport const registerRaspExecutionStateListener = async (config: RaspExecutionStateEventActions): Promise<void> => {\n  const [channel, key] = await getRaspExecutionStateChannelData();\n  await prepareRaspExecutionStateMapping();\n\n  await Talsec.addListener(channel, async (event: any) => {\n    if (event[key] == undefined) {\n      onInvalidCallback();\n    }\n    switch (event[key]) {\n      case RaspExecutionState.AllChecksFinished.value:\n        config.allChecksFinished?.();\n        break;\n      default:\n        onInvalidCallback();\n        break;\n    }\n  });\n};\n"]}
+{"version":3,"file":"raspExecutionState.js","sourceRoot":"","sources":["../../../../src/api/listeners/raspExecutionState.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gCAAgC,EAAE,gCAAgC,EAAE,MAAM,mCAAmC,CAAC;AACvH,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,OAAO,EAAE,iBAAiB,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAE1C,IAAI,cAAc,GAAgC,IAAI,CAAC;AACvD,IAAI,cAAc,GAAG,KAAK,CAAC;AAE3B,MAAM,CAAC,MAAM,kCAAkC,GAAG,KAAK,EAAE,MAAsC,EAAiB,EAAE;IAChH,IAAI,cAAc,EAAE,CAAC;QACnB,OAAO;IACT,CAAC;IACD,cAAc,GAAG,IAAI,CAAC;IAEtB,IAAI,cAAc,EAAE,CAAC;QACnB,MAAM,cAAc,CAAC,MAAM,EAAE,CAAC;QAC9B,cAAc,GAAG,IAAI,CAAC;IACxB,CAAC;IAED,MAAM,CAAC,OAAO,EAAE,GAAG,CAAC,GAAG,MAAM,gCAAgC,EAAE,CAAC;IAChE,MAAM,gCAAgC,EAAE,CAAC;IAEzC,cAAc,GAAG,MAAM,MAAM,CAAC,WAAW,CAAC,OAAO,EAAE,KAAK,EAAE,KAAU,EAAE,EAAE;;QACtE,IAAI,KAAK,CAAC,GAAG,CAAC,IAAI,SAAS,EAAE,CAAC;YAC5B,iBAAiB,EAAE,CAAC;QACtB,CAAC;QACD,QAAQ,KAAK,CAAC,GAAG,CAAC,EAAE,CAAC;YACnB,KAAK,kBAAkB,CAAC,iBAAiB,CAAC,KAAK;gBAC7C,MAAA,MAAM,CAAC,iBAAiB,sDAAI,CAAC;gBAC7B,MAAM;YACR;gBACE,iBAAiB,EAAE,CAAC;gBACpB,MAAM;QACV,CAAC;IACH,CAAC,CAAC,CAAC;IACH,cAAc,GAAG,KAAK,CAAC;AACzB,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,gCAAgC,GAAG,KAAK,IAAmB,EAAE;IACxE,IAAI,cAAc,EAAE,CAAC;QACnB,MAAM,cAAc,CAAC,MAAM,EAAE,CAAC;QAC9B,cAAc,GAAG,IAAI,CAAC;IACxB,CAAC;AACH,CAAC,CAAC","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\nimport { getRaspExecutionStateChannelData, prepareRaspExecutionStateMapping } from '../../channels/raspExecutionState';\nimport { RaspExecutionState } from '../../models/raspExecutionState';\nimport type { RaspExecutionStateEventActions } from '../../types/types';\nimport { onInvalidCallback } from '../methods/native';\nimport { Talsec } from '../nativeModules';\n\nlet eventsListener: PluginListenerHandle | null = null;\nlet isInitializing = false;\n\nexport const registerRaspExecutionStateListener = async (config: RaspExecutionStateEventActions): Promise<void> => {\n  if (isInitializing) {\n    return;\n  }\n  isInitializing = true;\n\n  if (eventsListener) {\n    await eventsListener.remove();\n    eventsListener = null;\n  }\n\n  const [channel, key] = await getRaspExecutionStateChannelData();\n  await prepareRaspExecutionStateMapping();\n\n  eventsListener = await Talsec.addListener(channel, async (event: any) => {\n    if (event[key] == undefined) {\n      onInvalidCallback();\n    }\n    switch (event[key]) {\n      case RaspExecutionState.AllChecksFinished.value:\n        config.allChecksFinished?.();\n        break;\n      default:\n        onInvalidCallback();\n        break;\n    }\n  });\n  isInitializing = false;\n};\n\nexport const removeRaspExecutionStateListener = async (): Promise<void> => {\n  if (eventsListener) {\n    await eventsListener.remove();\n    eventsListener = null;\n  }\n};\n"]}

package/dist/esm/api/listeners/threat.d.ts

@@ -1,2 +1,3 @@
 import type { ThreatEventActions } from '../../types/types';
 export declare const registerThreatListener: (config: ThreatEventActions) => Promise<void>;
+export declare const removeThreatListener: () => Promise<void>;

package/dist/esm/api/listeners/threat.js

@@ -3,11 +3,21 @@ import { Threat } from '../../models/threat';
 import { parseMalwareData } from '../../utils/malware';
 import { onInvalidCallback } from '../methods/native';
 import { Talsec } from '../nativeModules';
+let eventsListener = null;
+let isInitializing = false;
 export const registerThreatListener = async (config) => {
+    if (isInitializing) {
+        return;
+    }
+    isInitializing = true;
+    if (eventsListener) {
+        await eventsListener.remove();
+        eventsListener = null;
+    }
     const [channel, key, malwareKey] = await getThreatChannelData();
     await prepareThreatMapping();
-    await Talsec.addListener(channel, async (event) => {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
+    eventsListener = await Talsec.addListener(channel, async (event) => {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w, _x;
         if (event[key] == undefined) {
             onInvalidCallback();
         }
@@ -75,10 +85,20 @@ export const registerThreatListener = async (config) => {
             case Threat.UnsecureWifi.value:
                 (_w = config.unsecureWifi) === null || _w === void 0 ? void 0 : _w.call(config);
                 break;
+            case Threat.Automation.value:
+                (_x = config.automation) === null || _x === void 0 ? void 0 : _x.call(config);
+                break;
             default:
                 onInvalidCallback();
                 break;
         }
     });
+    isInitializing = false;
+};
+export const removeThreatListener = async () => {
+    if (eventsListener) {
+        await eventsListener.remove();
+        eventsListener = null;
+    }
 };
 //# sourceMappingURL=threat.js.map