@josuelmm/capacitor-background-geolocation 1.0.0

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,83 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    SPDX-License-Identifier: Apache-2.0
+    Copyright (c) 2026 JosueLMM
+
+    Mirrors the Cordova `android/common/src/main/AndroidManifest.xml` from the
+    upstream plugin (`com.marianhello.bgloc`) so the copied native core works
+    unchanged. ACCESS_BACKGROUND_LOCATION is intentionally NOT declared here;
+    consumer apps that want the "Allow all the time" tier must opt in by
+    declaring it in their own AndroidManifest.
+-->
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools">
+
+    <uses-feature android:name="android.hardware.location" android:required="false" />
+
+    <uses-permission android:name="android.permission.INTERNET" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
+    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_LOCATION_EXTRA_COMMANDS" />
+    <uses-permission android:name="com.google.android.gms.permission.ACTIVITY_RECOGNITION" />
+    <uses-permission android:name="android.permission.ACTIVITY_RECOGNITION" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
+    <uses-permission android:name="android.permission.READ_SYNC_SETTINGS" />
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
+    <uses-permission android:name="android.permission.AUTHENTICATE_ACCOUNTS" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE_LOCATION" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+
+    <application>
+        <!-- Foreground location service (the core implementation). -->
+        <service
+            android:name="com.marianhello.bgloc.service.LocationServiceImpl"
+            android:enabled="true"
+            android:exported="false"
+            android:foregroundServiceType="location" />
+
+        <!-- SyncAdapter (runs in its own :sync process to honor Android's sync framework). -->
+        <service
+            android:name="com.marianhello.bgloc.sync.SyncService"
+            android:exported="true"
+            android:process=":sync">
+            <intent-filter>
+                <action android:name="android.content.SyncAdapter" />
+            </intent-filter>
+            <meta-data
+                android:name="android.content.SyncAdapter"
+                android:resource="@xml/syncadapter" />
+        </service>
+
+        <!-- Account authenticator stub required by the sync framework. -->
+        <service
+            android:name="com.marianhello.bgloc.sync.AuthenticatorService"
+            android:exported="false">
+            <intent-filter>
+                <action android:name="android.accounts.AccountAuthenticator" />
+            </intent-filter>
+            <meta-data
+                android:name="android.accounts.AccountAuthenticator"
+                android:resource="@xml/authenticator" />
+        </service>
+
+        <!-- Local content provider backing the location queue. -->
+        <provider
+            android:name="com.marianhello.bgloc.data.provider.LocationContentProvider"
+            android:authorities="@string/plugin_bgloc_content_authority"
+            android:exported="false"
+            android:syncable="true" />
+
+        <!-- Restart the service after device reboot when `startOnBoot` is enabled. -->
+        <receiver
+            android:name="com.marianhello.bgloc.BootCompletedReceiver"
+            android:enabled="true"
+            android:exported="true">
+            <intent-filter>
+                <action android:name="android.intent.action.BOOT_COMPLETED" />
+            </intent-filter>
+        </receiver>
+    </application>
+</manifest>

package/android/src/main/java/com/evgenii/jsevaluator/HandlerWrapper.java

@@ -0,0 +1,18 @@
+package com.evgenii.jsevaluator;
+
+import android.os.Handler;
+
+import com.evgenii.jsevaluator.interfaces.HandlerWrapperInterface;
+
+public class HandlerWrapper implements HandlerWrapperInterface {
+	private final Handler mHandler;
+
+	public HandlerWrapper() {
+		mHandler = new Handler();
+	}
+
+	@Override
+	public void post(Runnable r) {
+		mHandler.post(r);
+	}
+}

package/android/src/main/java/com/evgenii/jsevaluator/JavaScriptInterface.java

@@ -0,0 +1,22 @@
+package com.evgenii.jsevaluator;
+
+import android.webkit.JavascriptInterface;
+
+import com.evgenii.jsevaluator.interfaces.CallJavaResultInterface;
+
+/**
+ * Passed in addJavascriptInterface of WebView to allow web views's JS execute
+ * Java code
+ */
+public class JavaScriptInterface {
+	private final CallJavaResultInterface mCallJavaResultInterface;
+
+	public JavaScriptInterface(CallJavaResultInterface callJavaResult) {
+		mCallJavaResultInterface = callJavaResult;
+	}
+
+	@JavascriptInterface
+	public void returnResultToJava(String value) {
+		mCallJavaResultInterface.jsCallFinished(value);
+	}
+}

package/android/src/main/java/com/evgenii/jsevaluator/JsEvaluator.java

@@ -0,0 +1,133 @@
+package com.evgenii.jsevaluator;
+
+import android.content.Context;
+import androidx.annotation.VisibleForTesting;
+import android.webkit.WebView;
+
+import com.evgenii.jsevaluator.interfaces.CallJavaResultInterface;
+import com.evgenii.jsevaluator.interfaces.HandlerWrapperInterface;
+import com.evgenii.jsevaluator.interfaces.JsCallback;
+import com.evgenii.jsevaluator.interfaces.JsEvaluatorInterface;
+import com.evgenii.jsevaluator.interfaces.WebViewWrapperInterface;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+public class JsEvaluator implements CallJavaResultInterface, JsEvaluatorInterface {
+	public final static String JS_NAMESPACE = "evgeniiJsEvaluator";
+	private final static String JS_ERROR_PREFIX = "evgeniiJsEvaluatorException";
+
+	public static String escapeCarriageReturn(String str) {
+		return str.replace("\r", "\\r");
+	}
+
+	public static String escapeClosingScript(String str) {
+		return str.replace("</", "<\\/");
+	}
+
+	public static String escapeNewLines(String str) {
+		return str.replace("\n", "\\n");
+	}
+
+	public static String escapeSingleQuotes(String str) {
+		return str.replace("'", "\\'");
+	}
+
+	public static String escapeSlash(String str) {
+		return str.replace("\\", "\\\\");
+	}
+
+	public static String getJsForEval(String jsCode) {
+		jsCode = escapeSlash(jsCode);
+		jsCode = escapeSingleQuotes(jsCode);
+		jsCode = escapeClosingScript(jsCode);
+		jsCode = escapeNewLines(jsCode);
+		jsCode = escapeCarriageReturn(jsCode);
+
+		return String.format("%s.returnResultToJava(eval('try{%s}catch(e){\"%s\"+e}'));",
+						JS_NAMESPACE, jsCode, JS_ERROR_PREFIX);
+	}
+
+	protected WebViewWrapperInterface mWebViewWrapper;
+
+	private final Context mContext;
+
+	private AtomicReference<JsCallback> callback = new AtomicReference<JsCallback>(null);
+
+	private HandlerWrapperInterface mHandler = new HandlerWrapper();
+
+	public JsEvaluator(Context context) {
+		mContext = context;
+	}
+
+	@Override
+	public void callFunction(String jsCode, JsCallback resultCallback, String name, Object... args) {
+		jsCode += "; " + JsFunctionCallFormatter.toString(name, args);
+		evaluate(jsCode, resultCallback);
+	}
+
+	@Override
+	public void evaluate(String jsCode) {
+		evaluate(jsCode, null);
+	}
+
+	@Override
+	public void evaluate(String jsCode, JsCallback resultCallback) {
+		final String js = JsEvaluator.getJsForEval(jsCode);
+        this.callback.set(resultCallback);
+		getWebViewWrapper().loadJavaScript(js);
+	}
+
+	// Destroys the web view in order to free the memory.
+	// The web view can not be accessed after is has been destroyed.
+	// To check open the page in Chrome: chrome://inspect/#devices
+	public void destroy() {
+		getWebViewWrapper().destroy();
+	}
+
+	// Returns the WebView object
+	public WebView getWebView() {
+		return getWebViewWrapper().getWebView();
+	}
+
+	public WebViewWrapperInterface getWebViewWrapper() {
+		if (mWebViewWrapper == null) {
+			mWebViewWrapper = new WebViewWrapper(mContext, this);
+		}
+		return mWebViewWrapper;
+	}
+
+	@Override
+	public void jsCallFinished(final String value) {
+		final JsCallback callbackLocal = callback.getAndSet(null);
+		if (callbackLocal == null) {
+			return;
+		}
+
+		mHandler.post(new Runnable() {
+			@Override
+			public void run() {
+				if(value!=null && value.startsWith(JS_ERROR_PREFIX)) {
+					callbackLocal.onError(value.substring(JS_ERROR_PREFIX.length()));
+				} else {
+					callbackLocal.onResult(value);
+				}
+			}
+		});
+	}
+
+	@VisibleForTesting
+	public void setHandler(HandlerWrapperInterface handlerWrapperInterface) {
+		mHandler = handlerWrapperInterface;
+	}
+
+	@VisibleForTesting
+	public void setWebViewWrapper(WebViewWrapperInterface webViewWrapper) {
+		mWebViewWrapper = webViewWrapper;
+	}
+
+	@VisibleForTesting
+	public JsCallback getCallback() {
+		return callback.get();
+	}
+
+}

package/android/src/main/java/com/evgenii/jsevaluator/JsFunctionCallFormatter.java

@@ -0,0 +1,37 @@
+package com.evgenii.jsevaluator;
+
+public class JsFunctionCallFormatter {
+	public static String paramToString(Object param) {
+		String str = "";
+		if (param instanceof String) {
+			str = (String) param;
+			str = str.replace("\\", "\\\\");
+			str = str.replace("\"", "\\\"");
+			str = str.replace("\n", "\\n");
+			str = String.format("\"%s\"", str);
+		} else {
+			try {
+				@SuppressWarnings("unused")
+				final double d = Double.parseDouble(param.toString());
+				str = param.toString();
+			} catch (final NumberFormatException nfe) {
+			}
+		}
+
+		return str;
+	}
+
+	public static String toString(String functionName, Object... args) {
+		final StringBuilder paramsStr = new StringBuilder();
+
+		for (final Object param : args) {
+			if (paramsStr.length() > 0) {
+				paramsStr.append(", ");
+			}
+
+			paramsStr.append(paramToString(param));
+		}
+
+		return String.format("%s(%s)", functionName, paramsStr);
+	}
+}

package/android/src/main/java/com/evgenii/jsevaluator/WebViewWrapper.java

@@ -0,0 +1,71 @@
+package com.evgenii.jsevaluator;
+
+import java.io.UnsupportedEncodingException;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.os.Build;
+import android.util.Base64;
+import android.webkit.WebSettings;
+import android.webkit.WebView;
+
+import com.evgenii.jsevaluator.interfaces.CallJavaResultInterface;
+import com.evgenii.jsevaluator.interfaces.WebViewWrapperInterface;
+
+@SuppressLint("SetJavaScriptEnabled")
+public class WebViewWrapper implements WebViewWrapperInterface {
+	protected WebView mWebView;
+
+	public WebViewWrapper(Context context, CallJavaResultInterface callJavaResult) {
+		mWebView = new WebView(context);
+
+		// web view will not draw anything - turn on optimizations
+		mWebView.setWillNotDraw(true);
+
+		final WebSettings webSettings = mWebView.getSettings();
+		webSettings.setJavaScriptEnabled(true);
+		webSettings.setDefaultTextEncodingName("utf-8");
+		final JavaScriptInterface jsInterface = new JavaScriptInterface(callJavaResult);
+		mWebView.addJavascriptInterface(jsInterface, JsEvaluator.JS_NAMESPACE);
+	}
+
+	@Override
+	public void loadJavaScript(String javascript) {
+		byte[] data;
+		try {
+			javascript = "<script>" + javascript + "</script>";
+			data = javascript.getBytes("UTF-8");
+			final String base64 = Base64.encodeToString(data, Base64.DEFAULT);
+			mWebView.loadUrl("data:text/html;charset=utf-8;base64," + base64);
+		} catch (final UnsupportedEncodingException e) {
+			e.printStackTrace();
+		}
+	}
+
+	// Destroys the web view in order to free the memory
+	// The web view can not be accessed after is has been destroyed
+    // To check open the page in Chrome: chrome://inspect/#devices
+	public void destroy() {
+		if(mWebView != null) {
+			mWebView.removeJavascriptInterface(JsEvaluator.JS_NAMESPACE);
+			mWebView.loadUrl("about:blank");
+			mWebView.stopLoading();
+
+			if (Build.VERSION.SDK_INT < Build.VERSION_CODES.KITKAT) {
+				mWebView.freeMemory();
+			}
+
+			mWebView.clearHistory();
+			mWebView.removeAllViews();
+			mWebView.destroyDrawingCache();
+			mWebView.destroy();
+
+			mWebView = null;
+		}
+	}
+
+	// Returns the WebView object
+	public WebView getWebView() {
+		return mWebView;
+	}
+}

package/android/src/main/java/com/evgenii/jsevaluator/interfaces/CallJavaResultInterface.java

@@ -0,0 +1,8 @@
+package com.evgenii.jsevaluator.interfaces;
+
+/**
+ * Used in JavaScriptInterface to interact with JsRunner
+ */
+public interface CallJavaResultInterface {
+	public void jsCallFinished(String value);
+}

package/android/src/main/java/com/evgenii/jsevaluator/interfaces/HandlerWrapperInterface.java

@@ -0,0 +1,5 @@
+package com.evgenii.jsevaluator.interfaces;
+
+public interface HandlerWrapperInterface {
+	public void post(Runnable r);
+}

package/android/src/main/java/com/evgenii/jsevaluator/interfaces/JsCallback.java

@@ -0,0 +1,10 @@
+package com.evgenii.jsevaluator.interfaces;
+
+/**
+ * Interface for passing code that will be executed after the JS has finished
+ */
+
+public interface JsCallback {
+	public abstract void onResult(String value);
+	public abstract void onError(String errorMessage);
+}

package/android/src/main/java/com/evgenii/jsevaluator/interfaces/JsEvaluatorInterface.java

@@ -0,0 +1,18 @@
+package com.evgenii.jsevaluator.interfaces;
+
+import android.webkit.WebView;
+
+public interface JsEvaluatorInterface {
+	public void callFunction(String jsCode, JsCallback resultCallback, String name, Object... args);
+
+	public void evaluate(String jsCode);
+
+	public void evaluate(String jsCode, JsCallback resultCallback);
+
+	// Destroys the web view in order to free the memory.
+	// The web view can not be accessed after is has been destroyed.
+	public void destroy();
+
+	// Returns the WebView object
+	public WebView getWebView();
+}

package/android/src/main/java/com/evgenii/jsevaluator/interfaces/WebViewWrapperInterface.java

@@ -0,0 +1,14 @@
+package com.evgenii.jsevaluator.interfaces;
+
+import android.webkit.WebView;
+
+public interface WebViewWrapperInterface {
+	public void loadJavaScript(String javascript);
+
+	// Destroys the web view in order to free the memory.
+	// The web view can not be accessed after is has been destroyed.
+	public void destroy();
+
+	// Returns the WebView object
+	public WebView getWebView();
+}