capacitor-enable-gps-plugin 0.1.0

package/README.md

@@ -0,0 +1,45 @@
+# capacitor-enable-gps-plugin
+
+Capacitor plugin for asking Android users to enable GPS/location services.
+
+The Android implementation uses Google Play Services `SettingsClient` to show the native location settings resolution dialog when possible. If the dialog cannot be shown, it opens the Android location settings screen and resolves with the current enabled state when the user returns.
+
+## Install
+
+```bash
+npm install ./capacitor-enable-gps-plugin
+npx cap sync android
+```
+
+## Usage
+
+```ts
+import { EnableGps } from 'capacitor-enable-gps-plugin';
+
+const current = await EnableGps.isEnabled();
+
+if (!current.enabled) {
+  const result = await EnableGps.requestEnable({
+    highAccuracy: true,
+    alwaysShow: true,
+  });
+
+  console.log('Location enabled:', result.enabled);
+}
+```
+
+## API
+
+```ts
+isEnabled() => Promise<{ enabled: boolean }>
+requestEnable(options?: {
+  highAccuracy?: boolean;
+  alwaysShow?: boolean;
+}) => Promise<{ enabled: boolean }>
+```
+
+## Notes
+
+- Android only: iOS does not provide the same app-triggered GPS enable dialog.
+- This plugin checks whether either the GPS or network location provider is enabled.
+- Android permissions are declared in the plugin manifest, but your app should still request runtime location permission separately before reading location.

package/android/build.gradle

@@ -0,0 +1,44 @@
+ext {
+    junitVersion = project.hasProperty('junitVersion') ? rootProject.ext.junitVersion : '4.13.2'
+    androidxAppCompatVersion = project.hasProperty('androidxAppCompatVersion') ? rootProject.ext.androidxAppCompatVersion : '1.7.0'
+    googlePlayServicesLocationVersion = project.hasProperty('googlePlayServicesLocationVersion') ? rootProject.ext.googlePlayServicesLocationVersion : '21.3.0'
+}
+
+buildscript {
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:8.7.2'
+    }
+}
+
+apply plugin: 'com.android.library'
+
+android {
+    namespace 'com.example.enablegps'
+    compileSdk project.hasProperty('compileSdkVersion') ? rootProject.ext.compileSdkVersion : 35
+
+    defaultConfig {
+        minSdkVersion project.hasProperty('minSdkVersion') ? rootProject.ext.minSdkVersion : 23
+        targetSdkVersion project.hasProperty('targetSdkVersion') ? rootProject.ext.targetSdkVersion : 35
+        versionCode 1
+        versionName '0.1.0'
+        testInstrumentationRunner 'androidx.test.runner.AndroidJUnitRunner'
+        consumerProguardFiles 'consumer-rules.pro'
+    }
+}
+
+repositories {
+    google()
+    mavenCentral()
+}
+
+dependencies {
+    implementation fileTree(dir: 'libs', include: ['*.jar'])
+    implementation project(':capacitor-android')
+    implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
+    implementation "com.google.android.gms:play-services-location:$googlePlayServicesLocationVersion"
+    testImplementation "junit:junit:$junitVersion"
+}

package/android/consumer-rules.pro

@@ -0,0 +1 @@
+

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+</manifest>

package/android/src/main/java/com/example/enablegps/EnableGpsPlugin.java

@@ -0,0 +1,118 @@
+package com.example.enablegps;
+
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.IntentSender;
+import android.location.LocationManager;
+import android.provider.Settings;
+
+import androidx.activity.result.ActivityResult;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.ActivityCallback;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.google.android.gms.common.api.ResolvableApiException;
+import com.google.android.gms.location.LocationRequest;
+import com.google.android.gms.location.LocationServices;
+import com.google.android.gms.location.LocationSettingsRequest;
+import com.google.android.gms.location.Priority;
+
+@CapacitorPlugin(name = "EnableGps")
+public class EnableGpsPlugin extends Plugin {
+
+    @PluginMethod
+    public void isEnabled(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("enabled", isLocationEnabled());
+        call.resolve(result);
+    }
+
+    @PluginMethod
+    public void requestEnable(PluginCall call) {
+        Activity activity = getActivity();
+        if (activity == null) {
+            call.reject("Activity is not available");
+            return;
+        }
+
+        if (isLocationEnabled()) {
+            resolveEnabled(call);
+            return;
+        }
+
+        boolean highAccuracy = call.getBoolean("highAccuracy", true);
+        boolean alwaysShow = call.getBoolean("alwaysShow", true);
+
+        int priority = highAccuracy
+            ? Priority.PRIORITY_HIGH_ACCURACY
+            : Priority.PRIORITY_BALANCED_POWER_ACCURACY;
+
+        LocationRequest locationRequest = new LocationRequest.Builder(priority, 10000L)
+            .setMinUpdateIntervalMillis(5000L)
+            .build();
+
+        LocationSettingsRequest request = new LocationSettingsRequest.Builder()
+            .addLocationRequest(locationRequest)
+            .setAlwaysShow(alwaysShow)
+            .build();
+
+        LocationServices.getSettingsClient(activity)
+            .checkLocationSettings(request)
+            .addOnSuccessListener(response -> resolveEnabled(call))
+            .addOnFailureListener(error -> {
+                if (error instanceof ResolvableApiException) {
+                    try {
+                        IntentSender intentSender = ((ResolvableApiException) error).getResolution().getIntentSender();
+                        startIntentSenderForResult(call, intentSender, "enableGpsResult");
+                    } catch (IntentSender.SendIntentException sendError) {
+                        openLocationSettings(call);
+                    }
+                } else {
+                    openLocationSettings(call);
+                }
+            });
+    }
+
+    @ActivityCallback
+    private void enableGpsResult(PluginCall call, ActivityResult result) {
+        if (call == null) {
+            return;
+        }
+
+        resolveEnabled(call);
+    }
+
+    @ActivityCallback
+    private void locationSettingsResult(PluginCall call, ActivityResult result) {
+        if (call == null) {
+            return;
+        }
+
+        resolveEnabled(call);
+    }
+
+    private void openLocationSettings(PluginCall call) {
+        Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+        startActivityForResult(call, intent, "locationSettingsResult");
+    }
+
+    private void resolveEnabled(PluginCall call) {
+        JSObject result = new JSObject();
+        result.put("enabled", isLocationEnabled());
+        call.resolve(result);
+    }
+
+    private boolean isLocationEnabled() {
+        LocationManager locationManager = (LocationManager) getContext().getSystemService(Context.LOCATION_SERVICE);
+        if (locationManager == null) {
+            return false;
+        }
+
+        return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
+            || locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
+    }
+}

package/dist/esm/definitions.d.ts

@@ -0,0 +1,32 @@
+export interface RequestEnableOptions {
+    /**
+     * Ask Android for high accuracy location settings.
+     *
+     * Defaults to true.
+     */
+    highAccuracy?: boolean;
+    /**
+     * Whether Android should show the resolution dialog even if it was recently shown.
+     *
+     * Defaults to true.
+     */
+    alwaysShow?: boolean;
+}
+export interface GpsEnabledResult {
+    enabled: boolean;
+}
+export interface EnableGpsPlugin {
+    /**
+     * Returns whether Android location providers are currently enabled.
+     */
+    isEnabled(): Promise<GpsEnabledResult>;
+    /**
+     * Requests that the user enable Android location/GPS services.
+     *
+     * On Android this shows the Google Play Services location settings resolution
+     * dialog when available. On web/iOS this resolves to the current unsupported
+     * implementation state.
+     */
+    requestEnable(options?: RequestEnableOptions): Promise<GpsEnabledResult>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/esm/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;IAEvB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,OAAO,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,SAAS,IAAI,OAAO,CAAC,gBAAgB,CAAC,CAAC;IAEvC;;;;;;OAMG;IACH,aAAa,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAAC;CAC1E"}

package/dist/esm/definitions.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+import type { EnableGpsPlugin } from './definitions';
+declare const EnableGps: EnableGpsPlugin;
+export * from './definitions';
+export { EnableGps };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAErD,QAAA,MAAM,SAAS,iBAEb,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,SAAS,EAAE,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+import { registerPlugin } from '@capacitor/core';
+const EnableGps = registerPlugin('EnableGps', {
+    web: () => import('./web').then(m => new m.EnableGpsWeb()),
+});
+export * from './definitions';
+export { EnableGps };

package/dist/esm/web.d.ts

@@ -0,0 +1,7 @@
+import { WebPlugin } from '@capacitor/core';
+import type { EnableGpsPlugin, GpsEnabledResult, RequestEnableOptions } from './definitions';
+export declare class EnableGpsWeb extends WebPlugin implements EnableGpsPlugin {
+    isEnabled(): Promise<GpsEnabledResult>;
+    requestEnable(_options?: RequestEnableOptions): Promise<GpsEnabledResult>;
+}
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,MAAM,eAAe,CAAC;AAE7F,qBAAa,YAAa,SAAQ,SAAU,YAAW,eAAe;IAC9D,SAAS,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAItC,aAAa,CAAC,QAAQ,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,gBAAgB,CAAC;CAGhF"}

package/dist/esm/web.js

@@ -0,0 +1,9 @@
+import { WebPlugin } from '@capacitor/core';
+export class EnableGpsWeb extends WebPlugin {
+    async isEnabled() {
+        return { enabled: false };
+    }
+    async requestEnable(_options) {
+        return { enabled: false };
+    }
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "capacitor-enable-gps-plugin",
+  "version": "0.1.0",
+  "description": "Capacitor plugin for requesting users to enable Android GPS/location services.",
+  "type": "module",
+  "main": "dist/esm/index.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "files": [
+    "android",
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "clean": "rimraf dist",
+    "verify": "npm run build"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "gps",
+    "location",
+    "android"
+  ],
+  "author": "",
+  "license": "MIT",
+  "peerDependencies": {
+    "@capacitor/core": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@capacitor/core": "^7.0.0",
+    "rimraf": "^6.0.1",
+    "typescript": "^5.5.0"
+  },
+  "capacitor": {
+    "android": {
+      "src": "android"
+    }
+  }
+}

package/src/definitions.ts

@@ -0,0 +1,35 @@
+export interface RequestEnableOptions {
+  /**
+   * Ask Android for high accuracy location settings.
+   *
+   * Defaults to true.
+   */
+  highAccuracy?: boolean;
+
+  /**
+   * Whether Android should show the resolution dialog even if it was recently shown.
+   *
+   * Defaults to true.
+   */
+  alwaysShow?: boolean;
+}
+
+export interface GpsEnabledResult {
+  enabled: boolean;
+}
+
+export interface EnableGpsPlugin {
+  /**
+   * Returns whether Android location providers are currently enabled.
+   */
+  isEnabled(): Promise<GpsEnabledResult>;
+
+  /**
+   * Requests that the user enable Android location/GPS services.
+   *
+   * On Android this shows the Google Play Services location settings resolution
+   * dialog when available. On web/iOS this resolves to the current unsupported
+   * implementation state.
+   */
+  requestEnable(options?: RequestEnableOptions): Promise<GpsEnabledResult>;
+}

package/src/index.ts

@@ -0,0 +1,10 @@
+import { registerPlugin } from '@capacitor/core';
+
+import type { EnableGpsPlugin } from './definitions';
+
+const EnableGps = registerPlugin<EnableGpsPlugin>('EnableGps', {
+  web: () => import('./web').then(m => new m.EnableGpsWeb()),
+});
+
+export * from './definitions';
+export { EnableGps };

package/src/web.ts

@@ -0,0 +1,13 @@
+import { WebPlugin } from '@capacitor/core';
+
+import type { EnableGpsPlugin, GpsEnabledResult, RequestEnableOptions } from './definitions';
+
+export class EnableGpsWeb extends WebPlugin implements EnableGpsPlugin {
+  async isEnabled(): Promise<GpsEnabledResult> {
+    return { enabled: false };
+  }
+
+  async requestEnable(_options?: RequestEnableOptions): Promise<GpsEnabledResult> {
+    return { enabled: false };
+  }
+}