feat: make dispatchers singletons

tompsota · tompsota · commit 3d7c0361db1e · 2026-03-16T03:50:20.000+01:00
diff --git a/android/src/main/java/com/freeraspreactnative/FreeraspReactNativeModule.kt b/android/src/main/java/com/freeraspreactnative/FreeraspReactNativeModule.kt
@@ -20,6 +20,8 @@ import com.facebook.react.bridge.UiThreadUtil.runOnUiThread
 import com.facebook.react.bridge.WritableArray
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.freeraspreactnative.dispatchers.ExecutionStateDispatcher
+import com.freeraspreactnative.dispatchers.ThreatDispatcher
 import com.freeraspreactnative.events.RaspExecutionStateEvent
 import com.freeraspreactnative.events.ThreatEvent
 import com.freeraspreactnative.interfaces.PluginExecutionStateListener
@@ -37,22 +39,22 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
 
   private val lifecycleListener = object : LifecycleEventListener {
     override fun onHostResume() {
-      PluginThreatHandler.threatDispatcher.onResume()
-      PluginThreatHandler.executionStateDispatcher.onResume()
+      ThreatDispatcher.onResume()
+      ExecutionStateDispatcher.onResume()
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
         reactContext.currentActivity?.let { ScreenProtector.register(it) }
       }
     }
 
     override fun onHostPause() {
-      PluginThreatHandler.threatDispatcher.onPause()
-      PluginThreatHandler.executionStateDispatcher.onPause()
+      ThreatDispatcher.onPause()
+      ExecutionStateDispatcher.onPause()
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
         reactContext.currentActivity?.let { ScreenProtector.unregister(it) }
       }
       if (reactContext.currentActivity?.isFinishing == true) {
-        PluginThreatHandler.threatDispatcher.unregisterListener()
-        PluginThreatHandler.executionStateDispatcher.unregisterListener()
+        ThreatDispatcher.unregisterListener()
+        ExecutionStateDispatcher.unregisterListener()
         PluginThreatHandler.unregisterSDKListener(reactContext)
       }
     }
@@ -66,10 +68,11 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
     return NAME
   }
 
-  init {
+  override fun initialize() {
     reactContext.addLifecycleEventListener(lifecycleListener)
     initializeEventKeys()
-    PluginThreatHandler.initializeDispatchers(PluginListener(reactContext))
+    PluginThreatHandler.initializePluginListener(PluginListener(reactContext))
+    super.initialize()
   }
 
   @ReactMethod
@@ -162,10 +165,10 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
   @ReactMethod
   fun addListener(eventName: String) {
     if (eventName == ThreatEvent.CHANNEL_NAME) {
-      PluginThreatHandler.threatDispatcher.registerListener()
+      ThreatDispatcher.registerListener(PluginListener(reactContext))
     }
     if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {
-      PluginThreatHandler.executionStateDispatcher.registerListener()
+      ExecutionStateDispatcher.registerListener(PluginListener(reactContext))
     }
   }
 
@@ -178,10 +181,10 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex
   @ReactMethod
   fun removeListenerForEvent(eventName: String, promise: Promise) {
     if (eventName == ThreatEvent.CHANNEL_NAME) {
-      PluginThreatHandler.threatDispatcher.unregisterListener()
+      ThreatDispatcher.unregisterListener()
     }
     if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {
-      PluginThreatHandler.executionStateDispatcher.unregisterListener()
+      ExecutionStateDispatcher.unregisterListener()
     }
     promise.resolve("Listener unregistered")
   }
diff --git a/android/src/main/java/com/freeraspreactnative/PluginThreatHandler.kt b/android/src/main/java/com/freeraspreactnative/PluginThreatHandler.kt
@@ -10,107 +10,104 @@ import com.freeraspreactnative.events.ThreatEvent
 
 internal object PluginThreatHandler {
 
-  internal lateinit var threatDispatcher: ThreatDispatcher
-  internal lateinit var executionStateDispatcher: ExecutionStateDispatcher
-
-  fun initializeDispatchers(listener: FreeraspReactNativeModule.PluginListener) {
-    threatDispatcher = ThreatDispatcher(listener)
-    executionStateDispatcher = ExecutionStateDispatcher(listener)
+  fun initializePluginListener(listener: FreeraspReactNativeModule.PluginListener) {
+    ThreatDispatcher.listener = listener
+    ExecutionStateDispatcher.listener = listener
   }
 
   private val threatDetected = object : ThreatListener.ThreatDetected() {
 
     override fun onRootDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)
     }
 
     override fun onDebuggerDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Debug)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Debug)
     }
 
     override fun onEmulatorDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Simulator)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Simulator)
     }
 
     override fun onTamperDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)
     }
 
     override fun onUntrustedInstallationSourceDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)
     }
 
     override fun onHookDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Hooks)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Hooks)
     }
 
     override fun onDeviceBindingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)
     }
 
     override fun onObfuscationIssuesDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)
     }
 
     override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {
-      threatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())
+      ThreatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())
     }
 
     override fun onScreenshotDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Screenshot)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Screenshot)
     }
 
     override fun onScreenRecordingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)
     }
 
     override fun onMultiInstanceDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)
     }
 
     override fun onUnsecureWifiDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)
     }
 
     override fun onTimeSpoofingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)
     }
 
     override fun onLocationSpoofingDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)
     }
 
     override fun onAutomationDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Automation)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Automation)
     }
   }
 
   private val deviceState = object : ThreatListener.DeviceState() {
 
     override fun onUnlockedDeviceDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.Passcode)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.Passcode)
     }
 
     override fun onHardwareBackedKeystoreNotAvailableDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)
     }
 
     override fun onDeveloperModeDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.DevMode)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.DevMode)
     }
 
     override fun onADBEnabledDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)
     }
 
     override fun onSystemVPNDetected() {
-      threatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)
+      ThreatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)
     }
   }
 
   private val raspExecutionState = object : ThreatListener.RaspExecutionState() {
     override fun onAllChecksFinished() {
-      executionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)
+      ExecutionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)
     }
   }
 
diff --git a/android/src/main/java/com/freeraspreactnative/dispatchers/ExecutionStateDispatcher.kt b/android/src/main/java/com/freeraspreactnative/dispatchers/ExecutionStateDispatcher.kt
@@ -3,13 +3,15 @@ package com.freeraspreactnative.dispatchers
 import com.freeraspreactnative.events.RaspExecutionStateEvent
 import com.freeraspreactnative.interfaces.PluginExecutionStateListener
 
-internal class ExecutionStateDispatcher(private val listener: PluginExecutionStateListener) {
+internal object ExecutionStateDispatcher {
+  lateinit var listener: PluginExecutionStateListener
   private val cache = mutableSetOf<RaspExecutionStateEvent>()
 
   private var isAppInForeground = false
   private var isListenerRegistered = false
 
-  fun registerListener() {
+  fun registerListener(newListener: PluginExecutionStateListener) {
+    listener = newListener
     isListenerRegistered = true
     isAppInForeground = true
     flushCache()
diff --git a/android/src/main/java/com/freeraspreactnative/dispatchers/ThreatDispatcher.kt b/android/src/main/java/com/freeraspreactnative/dispatchers/ThreatDispatcher.kt
@@ -4,14 +4,16 @@ import com.aheaditec.talsec_security.security.api.SuspiciousAppInfo
 import com.freeraspreactnative.events.ThreatEvent
 import com.freeraspreactnative.interfaces.PluginThreatListener
 
-internal class ThreatDispatcher(private val listener: PluginThreatListener) {
+internal object ThreatDispatcher {
+  lateinit var listener: PluginThreatListener
   private val threatCache = mutableSetOf<ThreatEvent>()
   private val malwareCache = mutableSetOf<SuspiciousAppInfo>()
 
   private var isAppInForeground = false
   private var isListenerRegistered = false
 
-  fun registerListener() {
+  fun registerListener(newListener: PluginThreatListener) {
+    listener = newListener
     isListenerRegistered = true
     isAppInForeground = true
     flushCache()

Original file line number	Diff line number	Diff line change
`@@ -20,6 +20,8 @@ import com.facebook.react.bridge.UiThreadUtil.runOnUiThread`
`20`	`20`	`import com.facebook.react.bridge.WritableArray`
`21`	`21`	`import com.facebook.react.bridge.WritableMap`
`22`	`22`	`import com.facebook.react.modules.core.DeviceEventManagerModule`
	`23`	`+import com.freeraspreactnative.dispatchers.ExecutionStateDispatcher`
	`24`	`+import com.freeraspreactnative.dispatchers.ThreatDispatcher`
`23`	`25`	`import com.freeraspreactnative.events.RaspExecutionStateEvent`
`24`	`26`	`import com.freeraspreactnative.events.ThreatEvent`
`25`	`27`	`import com.freeraspreactnative.interfaces.PluginExecutionStateListener`
`@@ -37,22 +39,22 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex`
`37`	`39`
`38`	`40`	`private val lifecycleListener = object : LifecycleEventListener {`
`39`	`41`	`override fun onHostResume() {`
`40`		`- PluginThreatHandler.threatDispatcher.onResume()`
`41`		`- PluginThreatHandler.executionStateDispatcher.onResume()`
	`42`	`+ ThreatDispatcher.onResume()`
	`43`	`+ ExecutionStateDispatcher.onResume()`
`42`	`44`	`if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {`
`43`	`45`	`reactContext.currentActivity?.let { ScreenProtector.register(it) }`
`44`	`46`	`}`
`45`	`47`	`}`
`46`	`48`
`47`	`49`	`override fun onHostPause() {`
`48`		`- PluginThreatHandler.threatDispatcher.onPause()`
`49`		`- PluginThreatHandler.executionStateDispatcher.onPause()`
	`50`	`+ ThreatDispatcher.onPause()`
	`51`	`+ ExecutionStateDispatcher.onPause()`
`50`	`52`	`if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {`
`51`	`53`	`reactContext.currentActivity?.let { ScreenProtector.unregister(it) }`
`52`	`54`	`}`
`53`	`55`	`if (reactContext.currentActivity?.isFinishing == true) {`
`54`		`- PluginThreatHandler.threatDispatcher.unregisterListener()`
`55`		`- PluginThreatHandler.executionStateDispatcher.unregisterListener()`
	`56`	`+ ThreatDispatcher.unregisterListener()`
	`57`	`+ ExecutionStateDispatcher.unregisterListener()`
`56`	`58`	`PluginThreatHandler.unregisterSDKListener(reactContext)`
`57`	`59`	`}`
`58`	`60`	`}`
`@@ -66,10 +68,11 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex`
`66`	`68`	`return NAME`
`67`	`69`	`}`
`68`	`70`
`69`		`- init {`
	`71`	`+ override fun initialize() {`
`70`	`72`	`reactContext.addLifecycleEventListener(lifecycleListener)`
`71`	`73`	`initializeEventKeys()`
`72`		`- PluginThreatHandler.initializeDispatchers(PluginListener(reactContext))`
	`74`	`+ PluginThreatHandler.initializePluginListener(PluginListener(reactContext))`
	`75`	`+ super.initialize()`
`73`	`76`	`}`
`74`	`77`
`75`	`78`	`@ReactMethod`
`@@ -162,10 +165,10 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex`
`162`	`165`	`@ReactMethod`
`163`	`166`	`fun addListener(eventName: String) {`
`164`	`167`	`if (eventName == ThreatEvent.CHANNEL_NAME) {`
`165`		`- PluginThreatHandler.threatDispatcher.registerListener()`
	`168`	`+ ThreatDispatcher.registerListener(PluginListener(reactContext))`
`166`	`169`	`}`
`167`	`170`	`if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {`
`168`		`- PluginThreatHandler.executionStateDispatcher.registerListener()`
	`171`	`+ ExecutionStateDispatcher.registerListener(PluginListener(reactContext))`
`169`	`172`	`}`
`170`	`173`	`}`
`171`	`174`
`@@ -178,10 +181,10 @@ class FreeraspReactNativeModule(private val reactContext: ReactApplicationContex`
`178`	`181`	`@ReactMethod`
`179`	`182`	`fun removeListenerForEvent(eventName: String, promise: Promise) {`
`180`	`183`	`if (eventName == ThreatEvent.CHANNEL_NAME) {`
`181`		`- PluginThreatHandler.threatDispatcher.unregisterListener()`
	`184`	`+ ThreatDispatcher.unregisterListener()`
`182`	`185`	`}`
`183`	`186`	`if (eventName == RaspExecutionStateEvent.CHANNEL_NAME) {`
`184`		`- PluginThreatHandler.executionStateDispatcher.unregisterListener()`
	`187`	`+ ExecutionStateDispatcher.unregisterListener()`
`185`	`188`	`}`
`186`	`189`	`promise.resolve("Listener unregistered")`
`187`	`190`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,107 +10,104 @@ import com.freeraspreactnative.events.ThreatEvent`
`10`	`10`
`11`	`11`	`internal object PluginThreatHandler {`
`12`	`12`
`13`		`- internal lateinit var threatDispatcher: ThreatDispatcher`
`14`		`- internal lateinit var executionStateDispatcher: ExecutionStateDispatcher`
`15`		`-`
`16`		`- fun initializeDispatchers(listener: FreeraspReactNativeModule.PluginListener) {`
`17`		`- threatDispatcher = ThreatDispatcher(listener)`
`18`		`- executionStateDispatcher = ExecutionStateDispatcher(listener)`
	`13`	`+ fun initializePluginListener(listener: FreeraspReactNativeModule.PluginListener) {`
	`14`	`+ ThreatDispatcher.listener = listener`
	`15`	`+ ExecutionStateDispatcher.listener = listener`
`19`	`16`	`}`
`20`	`17`
`21`	`18`	`private val threatDetected = object : ThreatListener.ThreatDetected() {`
`22`	`19`
`23`	`20`	`override fun onRootDetected() {`
`24`		`- threatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)`
	`21`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.PrivilegedAccess)`
`25`	`22`	`}`
`26`	`23`
`27`	`24`	`override fun onDebuggerDetected() {`
`28`		`- threatDispatcher.dispatchThreat(ThreatEvent.Debug)`
	`25`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.Debug)`
`29`	`26`	`}`
`30`	`27`
`31`	`28`	`override fun onEmulatorDetected() {`
`32`		`- threatDispatcher.dispatchThreat(ThreatEvent.Simulator)`
	`29`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.Simulator)`
`33`	`30`	`}`
`34`	`31`
`35`	`32`	`override fun onTamperDetected() {`
`36`		`- threatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)`
	`33`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.AppIntegrity)`
`37`	`34`	`}`
`38`	`35`
`39`	`36`	`override fun onUntrustedInstallationSourceDetected() {`
`40`		`- threatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)`
	`37`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.UnofficialStore)`
`41`	`38`	`}`
`42`	`39`
`43`	`40`	`override fun onHookDetected() {`
`44`		`- threatDispatcher.dispatchThreat(ThreatEvent.Hooks)`
	`41`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.Hooks)`
`45`	`42`	`}`
`46`	`43`
`47`	`44`	`override fun onDeviceBindingDetected() {`
`48`		`- threatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)`
	`45`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.DeviceBinding)`
`49`	`46`	`}`
`50`	`47`
`51`	`48`	`override fun onObfuscationIssuesDetected() {`
`52`		`- threatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)`
	`49`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.ObfuscationIssues)`
`53`	`50`	`}`
`54`	`51`
`55`	`52`	`override fun onMalwareDetected(suspiciousAppInfos: MutableList<SuspiciousAppInfo>) {`
`56`		`- threatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())`
	`53`	`+ ThreatDispatcher.dispatchMalware(suspiciousAppInfos ?: mutableListOf())`
`57`	`54`	`}`
`58`	`55`
`59`	`56`	`override fun onScreenshotDetected() {`
`60`		`- threatDispatcher.dispatchThreat(ThreatEvent.Screenshot)`
	`57`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.Screenshot)`
`61`	`58`	`}`
`62`	`59`
`63`	`60`	`override fun onScreenRecordingDetected() {`
`64`		`- threatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)`
	`61`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.ScreenRecording)`
`65`	`62`	`}`
`66`	`63`
`67`	`64`	`override fun onMultiInstanceDetected() {`
`68`		`- threatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)`
	`65`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.MultiInstance)`
`69`	`66`	`}`
`70`	`67`
`71`	`68`	`override fun onUnsecureWifiDetected() {`
`72`		`- threatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)`
	`69`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.UnsecureWifi)`
`73`	`70`	`}`
`74`	`71`
`75`	`72`	`override fun onTimeSpoofingDetected() {`
`76`		`- threatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)`
	`73`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.TimeSpoofing)`
`77`	`74`	`}`
`78`	`75`
`79`	`76`	`override fun onLocationSpoofingDetected() {`
`80`		`- threatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)`
	`77`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.LocationSpoofing)`
`81`	`78`	`}`
`82`	`79`
`83`	`80`	`override fun onAutomationDetected() {`
`84`		`- threatDispatcher.dispatchThreat(ThreatEvent.Automation)`
	`81`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.Automation)`
`85`	`82`	`}`
`86`	`83`	`}`
`87`	`84`
`88`	`85`	`private val deviceState = object : ThreatListener.DeviceState() {`
`89`	`86`
`90`	`87`	`override fun onUnlockedDeviceDetected() {`
`91`		`- threatDispatcher.dispatchThreat(ThreatEvent.Passcode)`
	`88`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.Passcode)`
`92`	`89`	`}`
`93`	`90`
`94`	`91`	`override fun onHardwareBackedKeystoreNotAvailableDetected() {`
`95`		`- threatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)`
	`92`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.SecureHardwareNotAvailable)`
`96`	`93`	`}`
`97`	`94`
`98`	`95`	`override fun onDeveloperModeDetected() {`
`99`		`- threatDispatcher.dispatchThreat(ThreatEvent.DevMode)`
	`96`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.DevMode)`
`100`	`97`	`}`
`101`	`98`
`102`	`99`	`override fun onADBEnabledDetected() {`
`103`		`- threatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)`
	`100`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.ADBEnabled)`
`104`	`101`	`}`
`105`	`102`
`106`	`103`	`override fun onSystemVPNDetected() {`
`107`		`- threatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)`
	`104`	`+ ThreatDispatcher.dispatchThreat(ThreatEvent.SystemVPN)`
`108`	`105`	`}`
`109`	`106`	`}`
`110`	`107`
`111`	`108`	`private val raspExecutionState = object : ThreatListener.RaspExecutionState() {`
`112`	`109`	`override fun onAllChecksFinished() {`
`113`		`- executionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)`
	`110`	`+ ExecutionStateDispatcher.dispatch(RaspExecutionStateEvent.AllChecksFinished)`
`114`	`111`	`}`
`115`	`112`	`}`
`116`	`113`