@josuelmm/capacitor-background-geolocation 1.0.0

package/android/src/main/java/com/marianhello/bgloc/service/LocationServiceInfo.java

@@ -0,0 +1,6 @@
+package com.marianhello.bgloc.service;
+
+public interface LocationServiceInfo {
+    boolean isStarted();
+    boolean isBound();
+}

package/android/src/main/java/com/marianhello/bgloc/service/LocationServiceInfoImpl.java

@@ -0,0 +1,41 @@
+package com.marianhello.bgloc.service;
+
+import android.app.ActivityManager;
+import android.content.Context;
+
+public class LocationServiceInfoImpl implements LocationServiceInfo {
+    private Context mContext;
+
+    public LocationServiceInfoImpl(Context context) {
+        mContext = context;
+    }
+
+    @Override
+    public boolean isStarted() {
+        ActivityManager.RunningServiceInfo info = getRunningServiceInfo();
+        if (info != null) {
+            return info.started;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isBound() {
+        ActivityManager.RunningServiceInfo info = getRunningServiceInfo();
+        if (info != null) {
+            return info.clientCount > 0;
+        }
+        return false;
+    }
+
+    public ActivityManager.RunningServiceInfo getRunningServiceInfo() {
+        String serviceName = LocationServiceImpl.class.getName();
+        ActivityManager manager = (ActivityManager) mContext.getSystemService(Context.ACTIVITY_SERVICE);
+        for (ActivityManager.RunningServiceInfo info : manager.getRunningServices(Integer.MAX_VALUE)) {
+            if (serviceName.equals(info.service.getClassName())) {
+                return info;
+            }
+        }
+        return null;
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/service/LocationServiceIntentBuilder.java

@@ -0,0 +1,203 @@
+/*
+ * Copyright 2017 R3BL LLC.
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more contributor
+ * license agreements. See the NOTICE file distributed with this work for additional
+ * information regarding copyright ownership. The ASF licenses this file to you under
+ * the Apache License, Version 2.0 (the "License"); you may not use this file except
+ * in compliance with the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed
+ * under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+ * CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ */
+
+package com.marianhello.bgloc.service;
+
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.Parcelable;
+import androidx.annotation.IntDef;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+// CommandId enumeration
+// more info - http://blog.shamanland.com/2016/02/int-string-enum.html
+@IntDef({
+        CommandId.INVALID,
+        CommandId.START,
+        CommandId.START_FOREGROUND_SERVICE,
+        CommandId.STOP,
+        CommandId.STOP_FOREGROUND,
+        CommandId.START_FOREGROUND,
+        CommandId.CONFIGURE,
+        CommandId.REGISTER_HEADLESS_TASK,
+        CommandId.START_HEADLESS_TASK,
+        CommandId.STOP_HEADLESS_TASK
+})
+@Retention(RetentionPolicy.SOURCE)
+@interface CommandId {
+    int INVALID = -1;
+    int START = 0;
+    int START_FOREGROUND_SERVICE = 1;
+    int STOP = 2;
+    int STOP_FOREGROUND = 3;
+    int START_FOREGROUND = 4;
+    int CONFIGURE = 5;
+    int REGISTER_HEADLESS_TASK = 6;
+    int START_HEADLESS_TASK = 7;
+    int STOP_HEADLESS_TASK = 8;
+}
+
+public class LocationServiceIntentBuilder {
+
+    private static final String KEY_MESSAGE = "msg";
+    private static final String KEY_COMMAND = "cmd";
+
+    private Context mContext;
+    private String mMessage;
+    private Command mCommand;
+
+    public static class Command {
+        private static final String KEY_COMMAND_ID = "cmd_id";
+        private static final String KEY_COMMAND_ARGUMENT = "cmd_arg";
+        private static final String KEY_COMMAND_ARGUMENT_TYPE = "cmd_arg_type";
+        private static final int ARGUMENT_TYPE_MISSING = 0;
+        private static final int ARGUMENT_TYPE_STRING = 1;
+        private static final int ARGUMENT_TYPE_PARCELABLE = 2;
+
+        private final @CommandId int mCommandId;
+        private Parcelable mParcelableArg;
+        private String mStringArg;
+        private int mArgType = 0;
+
+        public Command(int id) {
+            this.mCommandId = id;
+        }
+
+        public Command(int id, String argument) {
+            mCommandId = id;
+            mStringArg = argument;
+            mArgType = ARGUMENT_TYPE_STRING;
+        }
+
+        public Command(int id, Parcelable argument) {
+            mCommandId = id;
+            mParcelableArg = argument;
+            mArgType = ARGUMENT_TYPE_PARCELABLE;
+        }
+
+        public int getId() {
+            return mCommandId;
+        }
+
+        public Object getArgument() {
+            switch (mArgType) {
+                case ARGUMENT_TYPE_STRING:
+                    return mStringArg;
+                case ARGUMENT_TYPE_PARCELABLE:
+                    return mParcelableArg;
+                default:
+                    return null;
+            }
+        }
+
+        public Bundle toBundle() {
+            Bundle bundle = new Bundle();
+            bundle.putInt(KEY_COMMAND_ID, mCommandId);
+
+            if (mStringArg != null) {
+                bundle.putInt(KEY_COMMAND_ARGUMENT_TYPE, ARGUMENT_TYPE_STRING);
+                bundle.putString(KEY_COMMAND_ARGUMENT, mStringArg);
+            } else if (mParcelableArg != null) {
+                bundle.putInt(KEY_COMMAND_ARGUMENT_TYPE, ARGUMENT_TYPE_PARCELABLE);
+                bundle.putParcelable(KEY_COMMAND_ARGUMENT, mParcelableArg);
+            } else {
+                bundle.putInt(KEY_COMMAND_ARGUMENT_TYPE, ARGUMENT_TYPE_MISSING);
+            }
+
+            return bundle;
+        }
+
+        public static Command from(Bundle bundle) {
+            @CommandId int commandId =  bundle.getInt(KEY_COMMAND_ID);
+            int argumentType = bundle.getInt(KEY_COMMAND_ARGUMENT_TYPE);
+
+            if (argumentType == ARGUMENT_TYPE_STRING) {
+                return new Command(commandId, bundle.getString(KEY_COMMAND_ARGUMENT));
+            } else if (argumentType == ARGUMENT_TYPE_PARCELABLE) {
+                // Important: don't remove Parcelable cast
+                // required for Java 1.8 compatibility
+                return new Command(commandId, (Parcelable) bundle.getParcelable(KEY_COMMAND_ARGUMENT));
+            }
+
+            return new Command(commandId);
+        }
+    }
+
+    public static LocationServiceIntentBuilder getInstance(Context context) {
+        return new LocationServiceIntentBuilder(context);
+    }
+
+    public LocationServiceIntentBuilder(Context context) {
+        mContext = context;
+    }
+
+    public LocationServiceIntentBuilder setMessage(String message) {
+        mMessage = message;
+        return this;
+    }
+
+    /**
+     * @param commandId Don't use {@link CommandId#INVALID} as a param. If you do then this method does
+     *     nothing.
+     */
+    public LocationServiceIntentBuilder setCommand(@CommandId int commandId) {
+        mCommand = new Command(commandId);
+        return this;
+    }
+
+    public LocationServiceIntentBuilder setCommand(@CommandId int commandId, String arg) {
+        mCommand = new Command(commandId, arg);
+        return this;
+    }
+
+    public LocationServiceIntentBuilder setCommand(@CommandId int commandId, Parcelable arg) {
+        mCommand = new Command(commandId, arg);
+        return this;
+    }
+
+    public Intent build() {
+        assert mContext != null : "Context can not be null!";
+        Intent intent = new Intent(mContext, LocationServiceImpl.class);
+        if (mCommand != null) {
+            intent.putExtra(KEY_COMMAND, mCommand.toBundle());
+        }
+        if (mMessage != null) {
+            intent.putExtra(KEY_MESSAGE, mMessage);
+        }
+        return intent;
+    }
+
+    public static boolean containsCommand(Intent intent) {
+        return intent.hasExtra(KEY_COMMAND);
+    }
+
+    public static boolean containsMessage(Intent intent) {
+        return intent.hasExtra(KEY_MESSAGE);
+    }
+
+    public static Command getCommand(Intent intent) {
+        Bundle bundle = intent.getBundleExtra(KEY_COMMAND);
+        return Command.from(bundle);
+    }
+
+    public static String getMessage(Intent intent) {
+        return intent.getStringExtra(KEY_MESSAGE);
+    }
+} //end class LocationServiceIntentBuilder

package/android/src/main/java/com/marianhello/bgloc/service/LocationServiceProxy.java

@@ -0,0 +1,156 @@
+package com.marianhello.bgloc.service;
+
+import android.Manifest;
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.core.content.ContextCompat;
+
+import com.marianhello.bgloc.Config;
+
+public class LocationServiceProxy implements LocationService, LocationServiceInfo {
+    private static final String TAG = LocationServiceProxy.class.getSimpleName();
+    private final Context mContext;
+    private final LocationServiceIntentBuilder mIntentBuilder;
+
+    public LocationServiceProxy(Context context) {
+        mContext = context;
+        mIntentBuilder = new LocationServiceIntentBuilder(context);
+    }
+
+    @Override
+    public void configure(Config config) {
+        // do not start service if it was not already started
+        // FIXES:
+        // https://github.com/mauron85/react-native-background-geolocation/issues/360
+        // https://github.com/mauron85/cordova-plugin-background-geolocation/issues/551
+        // https://github.com/mauron85/cordova-plugin-background-geolocation/issues/552
+        if (!isStarted()) { return; }
+
+        Intent intent = mIntentBuilder
+                .setCommand(CommandId.CONFIGURE, config)
+                .build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void registerHeadlessTask(String taskRunnerClass) {
+        Intent intent = mIntentBuilder
+                .setCommand(CommandId.REGISTER_HEADLESS_TASK, taskRunnerClass)
+                .build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void startHeadlessTask() {
+        if (!isStarted()) { return; }
+
+        Intent intent = mIntentBuilder
+                .setCommand(CommandId.START_HEADLESS_TASK)
+                .build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void stopHeadlessTask() {
+        if (!isStarted()) { return; }
+
+        Intent intent = mIntentBuilder
+                .setCommand(CommandId.STOP_HEADLESS_TASK)
+                .build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void executeProviderCommand(int command, int arg) {
+        // TODO
+    }
+
+    @Override
+    public void start() {
+        Intent intent = mIntentBuilder.setCommand(CommandId.START).build();
+//        intent.addFlags(Intent.FLAG_FROM_BACKGROUND);
+        // start service to keep service running even if no clients are bound to it
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void startForegroundService() {
+        Intent intent = mIntentBuilder.setCommand(CommandId.START_FOREGROUND_SERVICE).build();
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            if (!hasLocationPermission()) {
+                // Do NOT fall back to startService(): would create a non-foreground service that crashes
+                // on first location update. Caller must request the permission first.
+                Log.w(TAG, "Cannot start foreground service: ACCESS_FINE_LOCATION/COARSE_LOCATION not granted");
+                return;
+            }
+            // Note: ACCESS_BACKGROUND_LOCATION is only required when the service is started from
+            // background (e.g. BootCompletedReceiver). When called from foreground, the OS allows
+            // a location-typed FGS to run with only fine/coarse location and inherit "while-in-use".
+            try {
+                mContext.startForegroundService(intent);
+            } catch (Exception e) {
+                // Android 12+ may throw ForegroundServiceStartNotAllowedException.
+                Log.e(TAG, "startForegroundService blocked: " + e.getClass().getSimpleName() + ": " + e.getMessage(), e);
+            }
+        } else {
+            mContext.startService(intent);
+        }
+    }
+
+    private boolean hasLocationPermission() {
+        // v4.5.1 — ContextCompat handles API < 23 safely.
+        return ContextCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED
+                || ContextCompat.checkSelfPermission(mContext, Manifest.permission.ACCESS_COARSE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+    }
+
+    @Override
+    public void stop() {
+        if (!isStarted()) { return; }
+
+        Intent intent = mIntentBuilder.setCommand(CommandId.STOP).build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void stopForeground() {
+        if (!isStarted()) { return; }
+
+        Intent intent = mIntentBuilder.setCommand(CommandId.STOP_FOREGROUND).build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public void startForeground() {
+        if (!isStarted()) { return; }
+
+        Intent intent = mIntentBuilder.setCommand(CommandId.START_FOREGROUND).build();
+        executeIntentCommand(intent);
+    }
+
+    @Override
+    public boolean isStarted() {
+        LocationServiceInfo serviceInfo = new LocationServiceInfoImpl(mContext);
+        return serviceInfo.isStarted();
+    }
+
+    public boolean isRunning() {
+        if (isStarted()) {
+            return LocationServiceImpl.isRunning();
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isBound() {
+        LocationServiceInfo serviceInfo = new LocationServiceInfoImpl(mContext);
+        return serviceInfo.isBound();
+    }
+
+    private void executeIntentCommand(Intent intent) {
+        mContext.startService(intent);
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sync/AccountHelper.java

@@ -0,0 +1,39 @@
+package com.marianhello.bgloc.sync;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.content.Context;
+
+/**
+ * Created by finch on 19/07/16.
+ */
+public class AccountHelper {
+    /**
+     * Create a new dummy account for the sync adapter
+     *
+     * @param context The application context
+     */
+    public static android.accounts.Account CreateSyncAccount(Context context, String accountName, String accountType) {
+        Account account = new Account(accountName, accountType);
+        // Get an instance of the Android account manager
+        AccountManager accountManager =  (AccountManager) context.getSystemService(Context.ACCOUNT_SERVICE);
+        /*
+         * Add the account and account type, no password or user data
+         * If successful, return the Account object, otherwise report an error.
+         */
+        if (accountManager.addAccountExplicitly(account, null, null)) {
+            /*
+             * If you don't set android:syncable="true" in
+             * in your <provider> element in the manifest,
+             * then call context.setIsSyncable(account, AUTHORITY, 1)
+             * here.
+             */
+        } else {
+            /*
+             * The account exists or some other error occurred. Log this, report it,
+             * or handle it internally.
+             */
+        }
+        return account;
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sync/Authenticator.java

@@ -0,0 +1,68 @@
+package com.marianhello.bgloc.sync;
+
+import android.accounts.AbstractAccountAuthenticator;
+import android.accounts.Account;
+import android.accounts.AccountAuthenticatorResponse;
+import android.accounts.NetworkErrorException;
+import android.content.Context;
+import android.os.Bundle;
+
+public class Authenticator extends AbstractAccountAuthenticator {
+    // Simple constructor
+    public Authenticator(Context context) {
+        super(context);
+    }
+    // Editing properties is not supported
+    @Override
+    public Bundle editProperties(
+            AccountAuthenticatorResponse r, String s) {
+        throw new UnsupportedOperationException();
+    }
+    // Don't add additional accounts
+    @Override
+    public Bundle addAccount(
+            AccountAuthenticatorResponse r,
+            String s,
+            String s2,
+            String[] strings,
+            Bundle bundle) throws NetworkErrorException {
+        return null;
+    }
+    // Ignore attempts to confirm credentials
+    @Override
+    public Bundle confirmCredentials(
+            AccountAuthenticatorResponse r,
+            Account account,
+            Bundle bundle) throws NetworkErrorException {
+        return null;
+    }
+    // Getting an authentication token is not supported
+    @Override
+    public Bundle getAuthToken(
+            AccountAuthenticatorResponse r,
+            Account account,
+            String s,
+            Bundle bundle) throws NetworkErrorException {
+        throw new UnsupportedOperationException();
+    }
+    // Getting a label for the auth token is not supported
+    @Override
+    public String getAuthTokenLabel(String s) {
+        throw new UnsupportedOperationException();
+    }
+    // Updating user credentials is not supported
+    @Override
+    public Bundle updateCredentials(
+            AccountAuthenticatorResponse r,
+            Account account,
+            String s, Bundle bundle) throws NetworkErrorException {
+        throw new UnsupportedOperationException();
+    }
+    // Checking features for the account is not supported
+    @Override
+    public Bundle hasFeatures(
+            AccountAuthenticatorResponse r,
+            Account account, String[] strings) throws NetworkErrorException {
+        throw new UnsupportedOperationException();
+    }
+}

package/android/src/main/java/com/marianhello/bgloc/sync/AuthenticatorService.java

@@ -0,0 +1,28 @@
+package com.marianhello.bgloc.sync;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+
+public class AuthenticatorService extends Service {
+
+    private Authenticator mAuthenticator;
+
+    public AuthenticatorService() {
+    }
+
+    @Override
+    public void onCreate() {
+        // Create a new authenticator object
+        mAuthenticator = new Authenticator(this);
+    }
+
+    /*
+     * When the system binds to this Service to make the RPC call
+     * return the authenticator's IBinder.
+     */
+    @Override
+    public IBinder onBind(Intent intent) {
+        return mAuthenticator.getIBinder();
+    }
+}