@dewakoding/capacitor-mock-location 1.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2024 DewaKoding
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,179 @@
+# @dewakoding/capacitor-mock-location
+
+Capacitor plugin to detect mock or fake GPS locations on Android devices. Built by DewaKoding.
+
+## Overview
+
+This plugin helps you detect when users are using fake GPS applications to spoof their location. It's useful for apps that require accurate location data, such as attendance systems, location-based services, or tracking applications.
+
+## Installation
+
+```bash
+npm install @dewakoding/capacitor-mock-location
+```
+
+or with yarn:
+
+```bash
+yarn add @dewakoding/capacitor-mock-location
+```
+
+Then sync Capacitor:
+
+```bash
+npx cap sync
+```
+
+## Usage
+
+```typescript
+import { MockLocation } from '@dewakoding/capacitor-mock-location'
+
+const { isMock } = await MockLocation.checkMockLocation()
+
+if (isMock) {
+  console.log('Mock location detected')
+  // Handle mock location case
+} else {
+  console.log('Location is valid')
+  // Proceed with location-based operations
+}
+```
+
+### Example: Check before check-in
+
+```typescript
+import { MockLocation } from '@dewakoding/capacitor-mock-location'
+import { Geolocation } from '@capacitor/geolocation'
+
+async function handleCheckIn() {
+  // Check for mock location first
+  const { isMock } = await MockLocation.checkMockLocation()
+  
+  if (isMock) {
+    alert('Fake GPS detected. Please disable fake GPS apps.')
+    return
+  }
+  
+  // Get actual location
+  const position = await Geolocation.getCurrentPosition()
+  
+  // Continue with check-in process
+}
+```
+
+## API
+
+### checkMockLocation()
+
+Checks if the device is currently using a mock or fake GPS location.
+
+**Returns:** `Promise<{ isMock: boolean }>`
+
+- `isMock`: `true` if mock location is detected, `false` otherwise
+
+## How It Works
+
+The plugin uses multiple detection methods based on standard Android APIs:
+
+1. Checks if the current location is from a mock provider using `isFromMockProvider()` (Android 6.0+)
+2. Scans for providers containing "mock" or "test" keywords in LocationManager
+3. Checks if common fake GPS applications are installed on the device
+
+**Note:** This implementation uses publicly available Android APIs. The code structure and implementation approach are original work by DewaKoding.
+
+## Android Setup
+
+### Permissions
+
+Make sure your `AndroidManifest.xml` includes location permissions:
+
+```xml
+<uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+<uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+```
+
+### Auto-Registration
+
+The plugin uses `@CapacitorPlugin` annotation, so it will be auto-registered by Capacitor. No manual registration in MainActivity is required.
+
+### Build & Run
+
+```bash
+npm run cap:sync
+npm run cap:run:android
+```
+
+## Platform Support
+
+- Android: Fully supported
+- iOS: Not yet implemented (returns `false`)
+- Web: Not applicable (returns `false`)
+
+## Testing
+
+### Test with Fake GPS App
+
+1. Install a fake GPS app (e.g., "Fake GPS Location" from Play Store)
+2. Enable mock location in the fake GPS app
+3. Set the desired location
+4. Open your app
+5. Call `checkMockLocation()`
+6. Should return `{ isMock: true }`
+
+### Test with Real Location
+
+1. Make sure no fake GPS apps are active
+2. Open your app
+3. Call `checkMockLocation()`
+4. Should return `{ isMock: false }`
+
+## Troubleshooting
+
+### Plugin not detected
+
+1. Make sure you've run `npx cap sync`
+2. Rebuild the Android app
+3. Check logcat for errors
+4. Verify the package name in the Java file is correct
+
+### Build errors
+
+1. Make sure the Java file uses the correct package: `com.dewakoding.capacitor.mocklocation`
+2. Check if there are duplicate plugins with the same name
+3. Make sure Capacitor version is compatible (^8.0.0)
+
+### Mock location not detected
+
+1. Some sophisticated fake GPS apps may not be detected
+2. Make sure the fake GPS app is active and being used
+3. Try restarting the app after enabling fake GPS
+
+## Limitations
+
+Detection is not 100% accurate. Some sophisticated fake GPS applications may not be detected. The plugin checks for common fake GPS apps, but new applications may not be in the detection list.
+
+## Development
+
+Build the plugin:
+
+```bash
+npm run build
+```
+
+Watch mode:
+
+```bash
+npm run watch
+```
+
+## License
+
+MIT License - Copyright (c) 2026 DewaKoding
+
+## Author
+
+**DewaKoding**
+
+- Website: https://dewakoding.com
+- Email: halodewakoding@gmail.com

package/android/build.gradle

@@ -0,0 +1,31 @@
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+android {
+    namespace "com.dewakoding.capacitor.mocklocation"
+    compileSdk rootProject.ext.compileSdkVersion
+
+    defaultConfig {
+        minSdkVersion rootProject.ext.minSdkVersion
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_21
+        targetCompatibility JavaVersion.VERSION_21
+    }
+
+    kotlinOptions {
+        jvmTarget = '21'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation project(':capacitor-android')
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:1.9.24"
+}
+

package/android/src/main/java/com/dewakoding/capacitor/mocklocation/MockLocationPlugin.kt

@@ -0,0 +1,160 @@
+package com.dewakoding.capacitor.mocklocation
+
+import android.content.Context
+import android.location.Location
+import android.location.LocationManager
+import android.os.Build
+import android.provider.Settings
+import com.getcapacitor.JSObject
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+
+/**
+ * DewaKoding Capacitor Plugin - Mock Location Detection
+ *
+ * Plugin to detect mock/fake GPS location on Android devices.
+ *
+ * This plugin uses multiple detection methods:
+ * 1. Check if location is from mock provider (Android 6.0+)
+ * 2. Check for mock/test providers in LocationManager
+ * 3. Check for common fake GPS apps installed on device
+ *
+ * @author DewaKoding
+ * @version 1.0.0
+ */
+@CapacitorPlugin(name = "MockLocation")
+class MockLocationPlugin : Plugin() {
+
+    @PluginMethod
+    fun checkMockLocation(call: PluginCall) {
+        try {
+            val isMock = isMockLocationEnabled()
+
+            val ret = JSObject()
+            ret.put("isMock", isMock)
+            call.resolve(ret)
+        } catch (e: Exception) {
+            call.reject("Error checking mock location: ${e.message}", e)
+        }
+    }
+
+    /**
+     * Detects if mock location is enabled using multiple methods
+     *
+     * @return true if mock location is detected, false otherwise
+     */
+    private fun isMockLocationEnabled(): Boolean {
+        val context = context
+
+        // Method 1: Check if "Allow mock locations" is enabled in Developer Options
+        // This only works for Android 5.1 and below
+        if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.LOLLIPOP_MR1) {
+            return Settings.Secure.getInt(
+                context.contentResolver,
+                Settings.Secure.ALLOW_MOCK_LOCATION,
+                0
+            ) != 0
+        } else {
+            // For Android 6.0 and above, ALLOW_MOCK_LOCATION is deprecated
+            // We need to use alternative methods
+            return try {
+                val locationManager = context.getSystemService(Context.LOCATION_SERVICE) as? LocationManager
+                    ?: return false
+
+                // Method 2: Check if last known location is from mock provider
+                val location = getLastKnownLocation(locationManager)
+                if (location?.isFromMockProvider == true) {
+                    return true
+                }
+
+                // Method 3: Check for mock/test providers
+                if (hasMockProvider(locationManager)) {
+                    return true
+                }
+
+                // Method 4: Check for common fake GPS apps
+                if (hasFakeGpsAppInstalled(context)) {
+                    return true
+                }
+
+                false
+            } catch (e: Exception) {
+                // If any error occurs, assume not mock (fail-safe)
+                false
+            }
+        }
+    }
+
+    /**
+     * Get last known location from GPS or Network provider
+     */
+    private fun getLastKnownLocation(locationManager: LocationManager): Location? {
+        return try {
+            var location: Location? = null
+            if (locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)) {
+                location = locationManager.getLastKnownLocation(LocationManager.GPS_PROVIDER)
+            }
+            if (location == null && locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER)) {
+                location = locationManager.getLastKnownLocation(LocationManager.NETWORK_PROVIDER)
+            }
+            location
+        } catch (e: SecurityException) {
+            // Location permission not granted
+            null
+        }
+    }
+
+    /**
+     * Check if LocationManager has any mock or test providers
+     */
+    private fun hasMockProvider(locationManager: LocationManager): Boolean {
+        return try {
+            val providers = locationManager.allProviders
+            providers.any { provider ->
+                val lowerProvider = provider.lowercase()
+                lowerProvider.contains("mock") || lowerProvider.contains("test")
+            }
+        } catch (e: Exception) {
+            // Ignore errors
+            false
+        }
+    }
+
+    /**
+     * Check if common fake GPS apps are installed on the device
+     *
+     * List of commonly used fake GPS applications
+     */
+    private fun hasFakeGpsAppInstalled(context: Context): Boolean {
+        val mockLocationApps = arrayOf(
+            "com.lexa.fakegps",
+            "com.blogspot.newapphorizons.fakegps",
+            "com.incorporateapps.fakegps.free",
+            "com.androidsx.fakegps",
+            "com.cygery.rejsekort.developer",
+            "com.doctormobile.locationfake",
+            "com.lerist.fakelocation",
+            "com.github.android_apps.mock_location",
+            "ru.gavrikov.mocklocations",
+            "com.henrythompson.fakegps",
+            "com.evezzon.fakegps",
+            "com.blogspot.newapphorizons.fakegps",
+            "com.incorporateapps.fakegps.free"
+        )
+
+        val pm = context.packageManager
+        return mockLocationApps.any { packageName ->
+            try {
+                pm.getPackageInfo(packageName, 0)
+                // If we can get package info, the app is installed
+                true
+            } catch (e: android.content.pm.PackageManager.NameNotFoundException) {
+                // App not installed, continue
+                false
+            }
+        }
+    }
+}
+

package/dist/definitions.d.ts

@@ -0,0 +1,34 @@
+/**
+ * DewaKoding Capacitor Mock Location Plugin
+ * Type definitions for the plugin interface
+ */
+export interface MockLocationPlugin {
+    /**
+     * Check if the device is using mock location
+     *
+     * This method checks if the device is using mock/fake GPS location
+     * using multiple detection methods:
+     * 1. Check if location is from mock provider (Android 6.0+)
+     * 2. Check for mock/test providers in LocationManager
+     * 3. Check for common fake GPS apps installed on device
+     *
+     * @returns Promise with isMock boolean indicating if mock location is detected
+     *
+     * @example
+     * ```typescript
+     * import { MockLocation } from '@dewakoding/capacitor-mock-location'
+     *
+     * const { isMock } = await MockLocation.checkMockLocation()
+     * if (isMock) {
+     *   console.log('Mock location detected!')
+     *   // Block action or show warning
+     * } else {
+     *   console.log('Location is valid')
+     *   // Proceed with location-based operations
+     * }
+     * ```
+     */
+    checkMockLocation(): Promise<{
+        isMock: boolean;
+    }>;
+}

package/dist/definitions.js

@@ -0,0 +1,5 @@
+/**
+ * DewaKoding Capacitor Mock Location Plugin
+ * Type definitions for the plugin interface
+ */
+export {};

package/dist/index.d.ts

@@ -0,0 +1,19 @@
+import type { MockLocationPlugin } from './definitions';
+/**
+ * DewaKoding Capacitor Mock Location Plugin
+ *
+ * Plugin to detect mock/fake GPS location on Android devices.
+ *
+ * @example
+ * ```typescript
+ * import { MockLocation } from '@dewakoding/capacitor-mock-location'
+ *
+ * const { isMock } = await MockLocation.checkMockLocation()
+ * if (isMock) {
+ *   console.log('Mock location detected!')
+ * }
+ * ```
+ */
+declare const MockLocation: MockLocationPlugin;
+export * from './definitions';
+export { MockLocation };

package/dist/index.js

@@ -0,0 +1,21 @@
+import { registerPlugin } from '@capacitor/core';
+/**
+ * DewaKoding Capacitor Mock Location Plugin
+ *
+ * Plugin to detect mock/fake GPS location on Android devices.
+ *
+ * @example
+ * ```typescript
+ * import { MockLocation } from '@dewakoding/capacitor-mock-location'
+ *
+ * const { isMock } = await MockLocation.checkMockLocation()
+ * if (isMock) {
+ *   console.log('Mock location detected!')
+ * }
+ * ```
+ */
+const MockLocation = registerPlugin('MockLocation', {
+    web: () => import('./web').then(m => new m.MockLocationWeb()),
+});
+export * from './definitions';
+export { MockLocation };

package/dist/web.d.ts

@@ -0,0 +1,13 @@
+import { WebPlugin } from '@capacitor/core';
+import type { MockLocationPlugin } from './definitions';
+/**
+ * Web implementation for DewaKoding Mock Location Plugin
+ *
+ * Web platform doesn't support mock location detection,
+ * so it always returns false (not mock)
+ */
+export declare class MockLocationWeb extends WebPlugin implements MockLocationPlugin {
+    checkMockLocation(): Promise<{
+        isMock: boolean;
+    }>;
+}

package/dist/web.js

@@ -0,0 +1,14 @@
+import { WebPlugin } from '@capacitor/core';
+/**
+ * Web implementation for DewaKoding Mock Location Plugin
+ *
+ * Web platform doesn't support mock location detection,
+ * so it always returns false (not mock)
+ */
+export class MockLocationWeb extends WebPlugin {
+    async checkMockLocation() {
+        // Web platform doesn't support mock location detection
+        // Return false as default (not mock)
+        return { isMock: false };
+    }
+}

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@dewakoding/capacitor-mock-location",
+  "version": "1.0.0",
+  "description": "DewaKoding Capacitor plugin to detect mock/fake GPS locations on Android devices",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "author": {
+    "name": "DewaKoding",
+    "email": "halodewakoding@gmail.com",
+    "url": "https://dewakoding.com"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dewakoding/capacitor-mock-location.git"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "mock-location",
+    "fake-gps",
+    "gps",
+    "location",
+    "dewakoding",
+    "android",
+    "security"
+  ],
+  "dependencies": {
+    "@capacitor/core": "^8.0.0"
+  },
+  "devDependencies": {
+    "typescript": "~5.9.0"
+  },
+  "files": [
+    "dist/",
+    "android/",
+    "ios/",
+    "README.md",
+    "LICENSE"
+  ],
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  }
+}
+