diff --git a/android/app/src/main/AndroidManifest.xml b/android/app/src/main/AndroidManifest.xml
index 29935f0..7dd12df 100644
--- a/android/app/src/main/AndroidManifest.xml
+++ b/android/app/src/main/AndroidManifest.xml
@@ -37,14 +37,6 @@
                 android:resource="@xml/file_paths"></meta-data>
         </provider>
 
-        <!-- ADD THIS SERVICE DECLARATION -->
-        <service
-            android:name="com.capacitor.backgroundrunner.RunnerService"
-            android:enabled="true"
-            android:exported="false"
-            android:foregroundServiceType="location" />
-        <!-- END OF SERVICE DECLARATION -->
-
 
     </application>
 
diff --git a/android/app/src/main/java/com/ouji/factory/myapp/AppSecurity.java b/android/app/src/main/java/com/ouji/factory/myapp/AppSecurity.java
new file mode 100644
index 0000000..e687ecd
--- /dev/null
+++ b/android/app/src/main/java/com/ouji/factory/myapp/AppSecurity.java
@@ -0,0 +1,29 @@
+package com.ouji.factory.myapp;
+
+import android.content.pm.ApplicationInfo;
+import android.content.pm.PackageManager;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import org.json.JSONArray;
+
+import java.util.List;
+
+@CapacitorPlugin(name = "AppSecurity")
+public class AppSecurity extends Plugin {
+
+    @PluginMethod
+    public void getInstalledApps(PluginCall call) {
+        PackageManager pm = getContext().getPackageManager();
+        List<ApplicationInfo> packages = pm.getInstalledApplications(PackageManager.GET_META_DATA);
+        JSONArray appPackages = new JSONArray();
+        for (ApplicationInfo packageInfo : packages) {
+            appPackages.put(packageInfo.packageName);
+        }
+        JSObject ret = new JSObject();
+        ret.put("packages", appPackages);
+        call.resolve(ret);
+    }
+}
diff --git a/android/app/src/main/java/com/ouji/factory/myapp/MainActivity.java b/android/app/src/main/java/com/ouji/factory/myapp/MainActivity.java
index 4815c1e..ee7dfc0 100644
--- a/android/app/src/main/java/com/ouji/factory/myapp/MainActivity.java
+++ b/android/app/src/main/java/com/ouji/factory/myapp/MainActivity.java
@@ -6,13 +6,16 @@ import android.view.WindowManager;
 import androidx.core.view.WindowCompat;
 import androidx.core.view.WindowInsetsControllerCompat;
 import com.getcapacitor.BridgeActivity;
+import com.getcapacitor.Plugin;
+
+import java.util.ArrayList;
 
 public class MainActivity extends BridgeActivity {
 
     @Override
     public void onCreate(Bundle savedInstanceState) {
+        registerPlugin(AppSecurity.class);
         super.onCreate(savedInstanceState);
-
         // Configure window for proper native behavior
         setupNativeWindow();
     }
diff --git a/backend/server.js b/backend/server.js
index 1856f45..281436c 100644
--- a/backend/server.js
+++ b/backend/server.js
@@ -1102,6 +1102,18 @@ const geofence = polygon([
     }
   })
 
+  // Get App Blacklist Endpoint
+  app.get('/api/security/app-blacklist', authenticateJWT, async (req, res) => {
+    try {
+      const [rows] = await db.execute('SELECT package_name FROM app_blacklist');
+      const packageNames = rows.map(row => row.package_name);
+      res.json(packageNames);
+    } catch (error) {
+      console.error('Get app blacklist error:', error);
+      res.status(500).json({ message: 'Database error fetching app blacklist.' });
+    }
+  });
+
   // --- Server Start ---
   const httpPort = process.env.HTTP_PORT || 3000
   const httpsPort = process.env.HTTPS_PORT || 3443
diff --git a/src/App.vue b/src/App.vue
index d574609..fd0823d 100644
--- a/src/App.vue
+++ b/src/App.vue
@@ -1,12 +1,20 @@
 <template>
   <div class="min-h-screen bg-gray-100 text-gray-900">
+    <!-- App Blocker Overlay -->
+    <div v-if="isBlocked" class="blocker-overlay">
+      <div class="blocker-content">
+        <h1 class="blocker-title">Application Blocked</h1>
+        <p class="blocker-message">{{ blockMessage }}</p>
+      </div>
+    </div>
+
     <!-- Mobile-native layout without top bar -->
-    <main class="safe-area-main">
+    <main class="safe-area-main" v-if="!isBlocked">
       <RouterView />
     </main>
 
     <!-- Bottom Navigation (only show for worker routes) -->
-    <BottomNavigation v-if="showBottomNav" />
+    <BottomNavigation v-if="showBottomNav && !isBlocked" />
   </div>
 </template>
 
@@ -27,6 +35,8 @@ const router = useRouter()
 const route = useRoute()
 
 const isLoggedIn = ref(false)
+const isBlocked = ref(false)
+const blockMessage = ref('')
 
 
 // Show bottom navigation only for worker routes
@@ -102,6 +112,9 @@ watch(
 )
 
 onMounted(async () => {
+  // Add app blocked event listener
+  window.addEventListener('app-blocked', handleAppBlocked)
+
   // Initialize SafeArea plugin for proper safe area handling
   if (Capacitor.isNativePlatform()) {
     try {
@@ -179,8 +192,14 @@ onMounted(async () => {
   }
 })
 
+const handleAppBlocked = (event) => {
+  isBlocked.value = true
+  blockMessage.value = event.detail.message
+}
+
 onBeforeUnmount(() => {
   // Clean up listeners
+  window.removeEventListener('app-blocked', handleAppBlocked)
   if (Capacitor.isNativePlatform()) {
     App.removeAllListeners()
   }
@@ -188,6 +207,36 @@ onBeforeUnmount(() => {
 </script>
 
 <style scoped>
+.blocker-overlay {
+  position: fixed;
+  top: 0;
+  left: 0;
+  width: 100%;
+  height: 100%;
+  background-color: rgba(0, 0, 0, 0.9);
+  display: flex;
+  justify-content: center;
+  align-items: center;
+  z-index: 9999;
+  color: white;
+  text-align: center;
+  padding: 20px;
+}
+
+.blocker-content {
+  max-width: 80%;
+}
+
+.blocker-title {
+  font-size: 1.5rem;
+  font-weight: bold;
+  margin-bottom: 1rem;
+}
+
+.blocker-message {
+  font-size: 1rem;
+}
+
 .safe-area-main {
   /* Use full viewport height minus bottom navigation */
   min-height: calc(100vh - 4rem);
diff --git a/src/services/antiSpoofingService.js b/src/services/antiSpoofingService.js
index d75221c..e856c14 100644
--- a/src/services/antiSpoofingService.js
+++ b/src/services/antiSpoofingService.js
@@ -1,69 +1,22 @@
-import { Device } from '@capacitor/device'
-import { AppLauncher } from '@capacitor/app-launcher'
 import { Capacitor } from '@capacitor/core'
 import { apiFetch } from '@/api.js'
 
+// Since we are using a custom plugin, we need to define it for Capacitor
+import { registerPlugin } from '@capacitor/core';
+const AppSecurity = registerPlugin('AppSecurity');
+
+
 class AntiSpoofingService {
   constructor() {
     this.isNative = Capacitor.isNativePlatform()
-    this.lastAppScanTime = null
-    this.scanInterval = 24 * 60 * 60 * 1000 // 24 hours in milliseconds
-
-    // Known GPS spoofing/mocking applications
+    this.blacklistCache = null
+    this.blacklistCacheTime = null
     this.gpsSpooferBlacklist = [
-      // Popular GPS spoofing apps
+      // Fallback list
       'com.lexa.fakegps',
       'com.incorporateapps.fakegps.fre',
       'com.blogspot.newapphorizons.fakegps',
       'com.theappninjas.gpsjoystick',
-      'com.fakegps.mock',
-      'com.mock.location.app',
-      'com.fakegps.location',
-      'com.gpsemulator',
-      'com.locationspoofer',
-      'com.fakegps.pro',
-      'com.mock.gps.location',
-      'com.gps.mock.location',
-      'com.fake.location.spoofer',
-      'com.location.faker',
-      'com.gps.faker',
-      'com.mock.location.faker',
-      'com.location.mock.gps',
-      'com.gps.location.faker',
-      'com.fake.gps.location.spoofer',
-      'com.location.spoofer.gps',
-
-      // Developer/testing tools that can mock location
-      'com.android.development',
-      'com.android.development_settings',
-      'com.android.settings.development',
-
-      // Root detection bypass tools (often used with GPS spoofing)
-      'com.topjohnwu.magisk',
-      'com.noshufou.android.su',
-      'com.koushikdutta.superuser',
-      'com.zachspong.temprootremovejb',
-      'com.ramdroid.appquarantine',
-      'com.devadvance.rootcloak',
-      'com.devadvance.rootcloakplus',
-      'de.robv.android.xposed.installer',
-      'com.saurik.substrate',
-      'com.amphoras.hidemyroot',
-      'com.amphoras.hidemyrootadfree',
-      'com.formyhm.hiderootPremium',
-      'me.phh.superuser',
-      'eu.chainfire.supersu',
-      'com.kingouser.com',
-      'com.android.vending.billing.InAppBillingService.LOCK',
-      'com.android.vending.billing.InAppBillingService.LACK',
-
-      // Location simulation apps
-      'com.hola.mocklocation',
-      'com.lexa.fakegps.route',
-      'com.fakegps.mock.location.app',
-      'com.mock.location.app.free',
-      'com.location.mock.free',
-      'com.gps.mock.free'
     ]
   }
 
@@ -73,383 +26,68 @@ class AntiSpoofingService {
   async initialize() {
     if (!this.isNative) {
       console.warn('Anti-spoofing detection is only available on native platforms')
-      return false
+      return
+    }
+    console.log('Anti-spoofing service initialized')
+    // Perform a check on initialization
+    this.performSecurityCheck()
+  }
+
+  /**
+   * Fetch blacklist from server with caching
+   */
+  async fetchBlacklistFromServer() {
+    const now = new Date().getTime()
+    // Cache for 1 hour
+    if (this.blacklistCache && this.blacklistCacheTime && now - this.blacklistCacheTime < 3600 * 1000) {
+      return this.blacklistCache
     }
 
     try {
-      console.log('Anti-spoofing service initialized')
-      return true
+      const blacklist = await apiFetch('/api/security/app-blacklist')
+      this.blacklistCache = blacklist
+      this.blacklistCacheTime = now
+      return blacklist
     } catch (error) {
-      console.error('Failed to initialize anti-spoofing service:', error)
-      return false
+      console.error('Failed to fetch blacklist from server, using fallback:', error)
+      return this.gpsSpooferBlacklist
     }
   }
 
   /**
    * Perform comprehensive security check
    */
-  
   async performSecurityCheck() {
+    if (!this.isNative) {
+      return
+    }
+    console.log('Performing security check...')
     try {
-      const results = {
-        timestamp: new Date().toISOString(),
-        deviceInfo: await this.getDeviceInfo(),
-        suspiciousApps: await this.detectSuspiciousApps(),
-        locationSettings: await this.checkLocationSettings(),
-        developerOptions: await this.checkDeveloperOptionsEnabled(),
-        riskLevel: 'low'
+      const blacklist = await this.fetchBlacklistFromServer()
+      console.log('Blacklist:', blacklist)
+      const result = await AppSecurity.getInstalledApps()
+      const installedApps = result.packages
+      console.log('Installed apps:', installedApps)
+
+      for (const appPackage of installedApps) {
+        if (blacklist.includes(appPackage)) {
+          console.warn(`Blacklisted app detected: ${appPackage}`)
+          const event = new CustomEvent('app-blocked', {
+            detail: {
+              appName: appPackage,
+              message: `For security reasons, the application cannot be used while ${appPackage} is installed.`,
+            },
+          })
+          window.dispatchEvent(event)
+          // Stop checking after finding one blacklisted app
+          return
+        }
       }
-
-      // Calculate risk level
-      results.riskLevel = this.calculateRiskLevel(results)
-
-      // Send results to server
-      this.lastAppScanTime = new Date()
-      const finalResults = results; // Capture results before potential async operation
-
-      // Send results to server (fire and forget)
-      void this.sendSecurityCheckToServer(finalResults);
-
-      return finalResults
     } catch (error) {
       console.error('Security check failed:', error)
-      throw error
     }
   }
-
-  /**
-   * Get device information
-   */
-  async getDeviceInfo() {
-    try {
-      const deviceInfo = await Device.getInfo()
-      const deviceId = await Device.getId()
-
-      return {
-        platform: deviceInfo.platform,
-        model: deviceInfo.model,
-        manufacturer: deviceInfo.manufacturer,
-        osVersion: deviceInfo.osVersion,
-        appVersion: deviceInfo.appVersion,
-        deviceId: deviceId.identifier,
-        isVirtual: deviceInfo.isVirtual || false,
-        webViewVersion: deviceInfo.webViewVersion
-      }
-    } catch (error) {
-      console.error('Failed to get device info:', error)
-      return null
-    }
-  }
-
-  /**
-   * Detect suspicious apps that might be used for GPS spoofing
-   */
-  async detectSuspiciousApps() {
-    try {
-      // Note: Due to Android security restrictions, we cannot directly get a list of installed apps
-      // Instead, we'll check if specific known spoofing apps can be launched
-      const suspiciousApps = []
-
-      for (const packageName of this.gpsSpooferBlacklist) {
-        try {
-          // Try to check if the app can be opened (indicates it's installed)
-          const canOpen = await AppLauncher.canOpenUrl({ url: `${packageName}://` })
-
-          if (canOpen.value) {
-            suspiciousApps.push({
-              packageName: packageName,
-              detected: true,
-              method: 'url_scheme_check'
-            })
-          }
-        } catch {
-          // App not found or cannot be checked - this is expected for most apps
-          continue
-        }
-      }
-
-      // Additional checks for common spoofing indicators
-      const additionalChecks = await this.performAdditionalSpoofingChecks()
-
-      return {
-        suspiciousApps: suspiciousApps,
-        additionalChecks: additionalChecks,
-        totalSuspiciousApps: suspiciousApps.length
-      }
-    } catch (error) {
-      console.error('Failed to detect suspicious apps:', error)
-      return {
-        suspiciousApps: [],
-        additionalChecks: {},
-        totalSuspiciousApps: 0,
-        error: error.message
-      }
-    }
-  }
-
-  /**
-   * Perform additional spoofing detection checks
-   */
-  async performAdditionalSpoofingChecks() {
-    const checks = {}
-
-    try {
-      // Check if mock location is enabled (Android specific)
-      // This would require a custom native plugin to properly detect
-      checks.mockLocationEnabled = await this.checkMockLocationEnabled()
-
-      // Check for root indicators
-      checks.rootIndicators = await this.checkRootIndicators()
-
-      // Check for developer options
-      checks.developerOptionsEnabled = await this.checkDeveloperOptionsEnabled()
-
-      return checks
-    } catch (error) {
-      console.error('Additional spoofing checks failed:', error)
-      return { error: error.message }
-    }
-  }
-
-  /**
-   * Check if mock location is enabled (placeholder - requires native implementation)
-   */
-  async checkMockLocationEnabled() {
-    // This would require a custom Capacitor plugin to properly implement
-    // For now, we'll return a placeholder
-    return {
-      enabled: false,
-      method: 'placeholder',
-      note: 'Requires custom native plugin for accurate detection'
-    }
-  }
-
-  /**
-   * Check for root indicators
-   */
-  async checkRootIndicators() {
-    const indicators = []
-
-    try {
-      // Check for common root-related package names
-      const rootPackages = [
-        'com.topjohnwu.magisk',
-        'com.noshufou.android.su',
-        'com.koushikdutta.superuser',
-        'eu.chainfire.supersu'
-      ]
-
-      for (const packageName of rootPackages) {
-        try {
-          const canOpen = await AppLauncher.canOpenUrl({ url: `${packageName}://` })
-          if (canOpen.value) {
-            indicators.push(packageName)
-          }
-        } catch {
-          // Expected for most devices
-          continue
-        }
-      }
-
-      return {
-        detected: indicators.length > 0,
-        indicators: indicators,
-        count: indicators.length
-      }
-    } catch (error) {
-      console.error('Root detection failed:', error)
-      return { detected: false, error: error.message }
-    }
-  }
-
-  /**
-   * Check if developer options are enabled (placeholder)
-   */
-  async checkDeveloperOptionsEnabled() {
-    // This would require a custom native plugin to properly detect
-    return {
-      enabled: false,
-      method: 'placeholder',
-      note: 'Requires custom native plugin for accurate detection'
-    }
-  }
-
-  /**
-   * Check location settings
-   */
-  async checkLocationSettings() {
-    try {
-      // This would ideally check location provider settings
-      // For now, we'll return basic information
-      return {
-        locationEnabled: true, // Placeholder
-        highAccuracyEnabled: true, // Placeholder
-        method: 'placeholder',
-        note: 'Requires enhanced location permission checks'
-      }
-    } catch (error) {
-      console.error('Location settings check failed:', error)
-      return { error: error.message }
-    }
-  }
-
-  /**
-   * Calculate risk level based on security check results
-   */
-  calculateRiskLevel(results) {
-    let riskScore = 0
-
-    // Suspicious apps detected
-    if (results.suspiciousApps && results.suspiciousApps.totalSuspiciousApps > 0) {
-      riskScore += results.suspiciousApps.totalSuspiciousApps * 10
-    }
-
-    // Root indicators
-    if (results.suspiciousApps && results.suspiciousApps.additionalChecks &&
-        results.suspiciousApps.additionalChecks.rootIndicators &&
-        results.suspiciousApps.additionalChecks.rootIndicators.detected) {
-      riskScore += 20
-    }
-
-    // Virtual device
-    if (results.deviceInfo && results.deviceInfo.isVirtual) {
-      riskScore += 15
-    }
-
-    // Developer options enabled
-    if (results.developerOptions && results.developerOptions.enabled) {
-      riskScore += 10
-    }
-
-    // Mock location enabled
-    if (results.locationSettings && results.locationSettings.mockLocationEnabled) {
-      riskScore += 25
-    }
-
-    // Determine risk level
-    if (riskScore >= 30) {
-      return 'high'
-    } else if (riskScore >= 15) {
-      return 'medium'
-    } else {
-      return 'low'
-    }
-  }
-
-  /**
-   * Send security check results to server
-   */
-  async sendSecurityCheckToServer(results) {
-    try {
-      const userId = localStorage.getItem('userId') || sessionStorage.getItem('userId')
-
-      if (!userId) {
-        console.warn('No user ID available for security check')
-        return
-      }
-
-      const securityData = {
-        userId: userId,
-        timestamp: results.timestamp,
-        deviceInfo: results.deviceInfo,
-        securityCheck: {
-          suspiciousApps: results.suspiciousApps,
-          locationSettings: results.locationSettings,
-          developerOptions: results.developerOptions,
-          riskLevel: results.riskLevel
-        }
-      }
-
-      await apiFetch('/api/security/check', {
-        method: 'POST',
-        body: JSON.stringify(securityData)
-      })
-
-      console.log('Security check sent to server successfully')
-
-    } catch (error) {
-      console.error('Failed to send security check to server:', error)
-      // Store for retry later
-      this.storeSecurityCheckForRetry(results)
-    }
-  }
-
-  /**
-   * Store security check for retry
-   */
-  storeSecurityCheckForRetry(results) {
-    try {
-      const pendingChecks = JSON.parse(localStorage.getItem('pendingSecurityChecks') || '[]')
-      pendingChecks.push({
-        results,
-        timestamp: Date.now()
-      })
-
-      // Keep only last 10 pending checks
-      if (pendingChecks.length > 10) {
-        pendingChecks.splice(0, pendingChecks.length - 10)
-      }
-
-      localStorage.setItem('pendingSecurityChecks', JSON.stringify(pendingChecks))
-    } catch (error) {
-      console.error('Failed to store security check for retry:', error)
-    }
-  }
-
-  /**
-   * Retry pending security checks
-   */
-  async retryPendingSecurityChecks() {
-    try {
-      const pendingChecks = JSON.parse(localStorage.getItem('pendingSecurityChecks') || '[]')
-
-      if (pendingChecks.length === 0) {
-        return
-      }
-
-      console.log(`Retrying ${pendingChecks.length} pending security checks`)
-
-      for (const pendingCheck of pendingChecks) {
-        await this.sendSecurityCheckToServer(pendingCheck.results).catch(error => {
-          console.error('Failed to retry security check:', error)
-        })
-      }
-
-      // Clear successfully sent checks
-      localStorage.removeItem('pendingSecurityChecks')
-
-    } catch (error) {
-      console.error('Failed to retry pending security checks:', error)
-    }
-  }
-
-  /**
-   * Check if security scan is needed
-   */
-  shouldPerformSecurityCheck() {
-    if (!this.lastAppScanTime) {
-      return true
-    }
-
-    const timeSinceLastScan = Date.now() - this.lastAppScanTime.getTime()
-    return timeSinceLastScan >= this.scanInterval
-  }
-
-  /**
-   * Get the last security check time
-   */
-  getLastSecurityCheckTime() {
-    return this.lastAppScanTime
-  }
-
-  /**
-   * Force a security check regardless of timing
-   */
-  async forceSecurityCheck() {
-    return await this.performSecurityCheck()
-  }
 }
 
-// Create and export a singleton instance
 export const antiSpoofingService = new AntiSpoofingService()
 export default antiSpoofingService
diff --git a/src/services/backgroundLocationService.js b/src/services/backgroundLocationService.js
index a590a67..7516319 100644
--- a/src/services/backgroundLocationService.js
+++ b/src/services/backgroundLocationService.js
@@ -13,7 +13,7 @@ class BackgroundLocationService {
     this.isClockedIn = false
 
     // Core intervals - 30 minutes for production (2 minutes for testing)
-    this.locationUpdateInterval = 2 * 60 * 1000 // 2 minutes for testing
+    this.locationUpdateInterval = 30 * 60 * 1000 // 2 minutes for testing
 
     // Essential timers
     this.periodicUpdateTimer = null
@@ -69,17 +69,7 @@ class BackgroundLocationService {
             stale: false,
             distanceFilter: 50,
             backgroundMessage: messages.message,
-            backgroundTitle: messages.title,
-            enableHighAccuracy: false,
-            interval: this.locationUpdateInterval,
-            fastestInterval: 5 * 60 * 1000,
-            saveBatteryOnBackground: true,
-            notificationTitle: messages.title,
-            notificationText: messages.message,
-            notificationIconColor: "#0066CC",
-            pauseLocationUpdatesAutomatically: false,
-            allowsBackgroundLocationUpdates: true,
-            desiredAccuracy: 100
+            backgroundTitle: messages.title
           },
           (location, error) => {
             if (error) {
diff --git a/src/services/nativeServicesManager.js b/src/services/nativeServicesManager.js
index 6741726..18219e1 100644
--- a/src/services/nativeServicesManager.js
+++ b/src/services/nativeServicesManager.js
@@ -91,10 +91,8 @@ class NativeServicesManager {
 
       // Perform initial security check
       try {
-        if (this.services.antiSpoofing.shouldPerformSecurityCheck()) {
-          console.log('Performing initial security check...')
-          await this.services.antiSpoofing.performSecurityCheck()
-        }
+        console.log('Performing initial security check...')
+        await this.services.antiSpoofing.performSecurityCheck()
       } catch (securityError) {
         console.error('Failed to perform security check:', securityError)
         // Continue with other services
@@ -148,9 +146,7 @@ class NativeServicesManager {
     // Security check every 24 hours
     this.securityCheckInterval = setInterval(async () => {
       try {
-        if (this.services.antiSpoofing.shouldPerformSecurityCheck()) {
-          await this.services.antiSpoofing.performSecurityCheck()
-        }
+        await this.services.antiSpoofing.performSecurityCheck()
       } catch (error) {
         console.error('Periodic security check failed:', error)
       }
@@ -161,7 +157,6 @@ class NativeServicesManager {
     this.retryInterval = setInterval(async () => {
       try {
         await this.services.location.syncPendingLocationData()
-        await this.services.antiSpoofing.retryPendingSecurityChecks()
       } catch (error) {
         console.error('Retry operations failed:', error)
       }
@@ -225,7 +220,6 @@ class NativeServicesManager {
 
       // Retry any pending operations
       await this.services.location.syncPendingLocationData()
-      await this.services.antiSpoofing.retryPendingSecurityChecks()
     } catch (error) {
       console.error('OPTIMIZED: Failed to handle app foreground:', error)
     }
@@ -264,7 +258,7 @@ class NativeServicesManager {
         },
         antiSpoofing: {
           initialized: true,
-          lastCheck: this.services.antiSpoofing.getLastSecurityCheckTime()
+          lastCheck: null // Simplified
         },
         deviceUuid: {
           initialized: true,
@@ -278,7 +272,7 @@ class NativeServicesManager {
    * Force security check
    */
   async forceSecurityCheck() {
-    return await this.services.antiSpoofing.forceSecurityCheck()
+    return await this.services.antiSpoofing.performSecurityCheck()
   }
 
   /**