@josuelmm/capacitor-background-geolocation 1.0.0

package/android/src/main/java/com/marianhello/logging/LoggerManager.java

@@ -0,0 +1,70 @@
+package com.marianhello.logging;
+
+import java.io.File;
+
+import ch.qos.logback.classic.Level;
+import ch.qos.logback.classic.Logger;
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.android.LogcatAppender;
+import ch.qos.logback.classic.android.SQLiteAppender;
+import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
+import ch.qos.logback.classic.spi.ILoggingEvent;
+import ch.qos.logback.core.Appender;
+import ch.qos.logback.core.rolling.RollingFileAppender;
+import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
+import ch.qos.logback.core.util.StatusPrinter;
+
+public class LoggerManager {
+
+    public static final String SQLITE_APPENDER_NAME = "sqlite";
+
+    static {
+        // reset the default context (which may already have been initialized)
+        // since we want to reconfigure it
+        LoggerContext context = (LoggerContext) org.slf4j.LoggerFactory.getILoggerFactory();
+        context.reset();
+        // Disable class packaging data
+        // @see https://github.com/tony19/logback-android/issues/171
+        context.setPackagingDataEnabled(false);
+
+        PatternLayoutEncoder encoder = new PatternLayoutEncoder();
+        encoder.setContext(context);
+        encoder.setPattern("%msg");
+        encoder.start();
+
+        LogcatAppender logcatAppender = new LogcatAppender();
+        logcatAppender.setContext(context);
+        logcatAppender.setEncoder(encoder);
+        logcatAppender.start();
+
+        ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) org.slf4j.LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+        root.setLevel(Level.TRACE);
+        root.addAppender(logcatAppender);
+    }
+
+    public static void enableDBLogging() {
+        ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) org.slf4j.LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+        if (root.getAppender(SQLITE_APPENDER_NAME) == null) {
+            LoggerContext context = (LoggerContext) org.slf4j.LoggerFactory.getILoggerFactory();
+            SQLiteAppender appender = new SQLiteAppender();
+            appender.setName(SQLITE_APPENDER_NAME);
+            appender.setMaxHistory("7 days"); //keep 7 days' worth of history
+            appender.setContext(context);
+            appender.start();
+            root.addAppender(appender);
+        }
+    }
+
+    public static void disableDBLogging() {
+        ch.qos.logback.classic.Logger root = (ch.qos.logback.classic.Logger) org.slf4j.LoggerFactory.getLogger(Logger.ROOT_LOGGER_NAME);
+        Appender<ILoggingEvent> appender = root.getAppender(SQLITE_APPENDER_NAME);
+        if (appender != null) {
+            appender.stop();
+            root.detachAppender(appender);
+        }
+    }
+
+    public static org.slf4j.Logger getLogger(Class forClass) {
+        return org.slf4j.LoggerFactory.getLogger(forClass);
+    }
+}

package/android/src/main/java/com/marianhello/logging/UncaughtExceptionLogger.java

@@ -0,0 +1,36 @@
+package com.marianhello.logging;
+
+import android.content.Context;
+
+public class UncaughtExceptionLogger implements Thread.UncaughtExceptionHandler {
+    private static volatile boolean mIsCrashing = false;
+    private static Thread.UncaughtExceptionHandler sDefaultHandler;
+
+    private org.slf4j.Logger logger;
+
+    public UncaughtExceptionLogger(Context context) {
+        logger = LoggerManager.getLogger(UncaughtExceptionLogger.class);
+    }
+
+    @Override
+    public void uncaughtException(Thread thread, Throwable throwable) {
+        // prevent accidental loop
+        if(mIsCrashing){
+            return;
+        }
+
+        mIsCrashing = true;
+        logger.error("FATAL EXCEPTION: {}", thread.getName(), throwable);
+        if (sDefaultHandler != null) {
+            sDefaultHandler.uncaughtException(thread, throwable);
+        }
+    }
+
+    public static void register(Context context) {
+        Thread.UncaughtExceptionHandler defaultHandler = Thread.getDefaultUncaughtExceptionHandler();
+        if (!(defaultHandler instanceof UncaughtExceptionLogger)) {
+            sDefaultHandler = defaultHandler;
+            Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionLogger(context));
+        }
+    }
+}

package/android/src/main/java/com/marianhello/utils/CloneHelper.java

@@ -0,0 +1,22 @@
+package com.marianhello.utils;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class CloneHelper {
+    public static <K,V> HashMap<K, V> deepCopy(HashMap<K, V> original)
+    {
+        if (original == null) {
+            return null;
+        }
+
+        HashMap<K, V> copy = new HashMap();
+
+        //iterate over the map copying values into new map
+        for(Map.Entry<K, V> entry : original.entrySet()) {
+            copy.put(entry.getKey(),  entry.getValue());
+        }
+
+        return copy;
+    }
+}

package/android/src/main/java/com/marianhello/utils/Convert.java

@@ -0,0 +1,56 @@
+/*
+ * Kindly taken from
+ * http://stackoverflow.com/questions/1590831/safely-casting-long-to-int-in-java
+ */
+
+package com.marianhello.utils;
+
+import org.json.JSONArray;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+public class Convert {
+
+  public static int safeLongToInt(long l) {
+    if (l < Integer.MIN_VALUE || l > Integer.MAX_VALUE) {
+      throw new IllegalArgumentException
+        (l + " cannot be cast to int without changing its value.");
+    }
+    return (int) l;
+  }
+
+  public static Map<String, Object> toMap(JSONObject jsonobj)  throws JSONException {
+    Map<String, Object> map = new HashMap<String, Object>();
+    Iterator<String> keys = jsonobj.keys();
+    while(keys.hasNext()) {
+      String key = keys.next();
+      Object value = jsonobj.get(key);
+      if (value instanceof JSONArray) {
+        value = toList((JSONArray) value);
+      } else if (value instanceof JSONObject) {
+        value = toMap((JSONObject) value);
+      }
+      map.put(key, value);
+    }   return map;
+  }
+
+  public static List<Object> toList(JSONArray array) throws JSONException {
+    List<Object> list = new ArrayList<Object>();
+    for(int i = 0; i < array.length(); i++) {
+      Object value = array.get(i);
+      if (value instanceof JSONArray) {
+        value = toList((JSONArray) value);
+      }
+      else if (value instanceof JSONObject) {
+        value = toMap((JSONObject) value);
+      }
+      list.add(value);
+    }   return list;
+  }
+}

package/android/src/main/java/com/marianhello/utils/TextUtils.java

@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2006 The Android Open Source Project
+ *
+ * Licensed 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.utils;
+
+
+import java.util.Iterator;
+
+public class TextUtils {
+    private static final String TAG = "TextUtils";
+
+    /**
+     * Returns a string containing the tokens joined by delimiters.
+     * @param tokens an array objects to be joined. Strings will be formed from
+     *     the objects by calling object.toString().
+     */
+    public static String join(CharSequence delimiter, Object[] tokens) {
+        StringBuilder sb = new StringBuilder();
+        boolean firstTime = true;
+        for (Object token: tokens) {
+            if (firstTime) {
+                firstTime = false;
+            } else {
+                sb.append(delimiter);
+            }
+            sb.append(token);
+        }
+        return sb.toString();
+    }
+
+    /**
+     * Returns a string containing the tokens joined by delimiters.
+     * @param tokens an array objects to be joined. Strings will be formed from
+     *     the objects by calling object.toString().
+     */
+    public static String join(CharSequence delimiter, Iterable tokens) {
+        StringBuilder sb = new StringBuilder();
+        Iterator<?> it = tokens.iterator();
+        if (it.hasNext()) {
+            sb.append(it.next());
+            while (it.hasNext()) {
+                sb.append(delimiter);
+                sb.append(it.next());
+            }
+        }
+        return sb.toString();
+    }
+
+    public static String removeLastChar(String str, String lastChar) {
+        if (str == null) {
+            return null;
+        }
+        int indexOfLastChar = str.length() - 1;
+        if (lastChar == null || str.substring(indexOfLastChar).equals(lastChar)) {
+            return str.substring(0, indexOfLastChar);
+        }
+        return str;
+    }
+}

package/android/src/main/java/com/marianhello/utils/ToneGenerator.java

@@ -0,0 +1,68 @@
+package com.marianhello.utils;
+
+import com.marianhello.logging.LoggerManager;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+
+/**
+ * Created by finch on 27.11.2017.
+ */
+
+public class ToneGenerator {
+    public class Tone {
+        public static final int BEEP = android.media.ToneGenerator.TONE_PROP_BEEP;
+        public static final int BEEP_BEEP_BEEP = android.media.ToneGenerator.TONE_CDMA_CONFIRM;
+        public static final int LONG_BEEP = android.media.ToneGenerator.TONE_CDMA_ABBR_ALERT;
+        public static final int DOODLY_DOO = android.media.ToneGenerator.TONE_CDMA_ALERT_NETWORK_LITE;
+        public static final int CHIRP_CHIRP_CHIRP = android.media.ToneGenerator.TONE_CDMA_ALERT_CALL_GUARD;
+        public static final int DIALTONE = android.media.ToneGenerator.TONE_SUP_RINGTONE;
+    };
+
+    private int mStreamType;
+    private int mVolume;
+    private final ScheduledExecutorService mExecutor;
+    private org.slf4j.Logger logger;
+
+    public ToneGenerator(int streamType, int volume) {
+        mStreamType = streamType;
+        mVolume = volume;
+        mExecutor = Executors.newScheduledThreadPool(1);
+        logger = LoggerManager.getLogger(getClass());
+    }
+
+    public void release() {
+        mExecutor.shutdown();
+        try {
+            if (!mExecutor.awaitTermination(1, TimeUnit.SECONDS)) {
+                mExecutor.shutdownNow();
+            }
+        } catch (InterruptedException e) {
+            mExecutor.shutdownNow();
+        }
+    }
+
+    public void startTone(final int toneType, final int durationMs) {
+        final android.media.ToneGenerator toneGenerator = new android.media.ToneGenerator(mStreamType, mVolume);
+        mExecutor.execute(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    toneGenerator.startTone(toneType, durationMs);
+                } catch (Exception e) {
+                    logger.debug("Exception while playing tone: {}", e.getMessage());
+                }
+            }
+        });
+        mExecutor.schedule(new Runnable() {
+            public void run() {
+                try {
+                    toneGenerator.release();
+                } catch (Exception e) {
+                    logger.debug("Exception while playing tone: {}", e.getMessage());
+                }
+            }
+        }, durationMs,  TimeUnit.MILLISECONDS);
+    }
+}

package/android/src/main/java/org/apache/commons/io/Charsets.java

@@ -0,0 +1,153 @@
+/*
+ * 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 org.apache.commons.io;
+
+import java.nio.charset.Charset;
+import java.nio.charset.UnsupportedCharsetException;
+
+/**
+ * Charsets required of every implementation of the Java platform.
+ *
+ * From the Java documentation <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">
+ * Standard charsets</a>:
+ * <p>
+ * <cite>Every implementation of the Java platform is required to support the following character encodings. Consult the
+ * release documentation for your implementation to see if any other encodings are supported. Consult the release
+ * documentation for your implementation to see if any other encodings are supported. </cite>
+ * </p>
+ *
+ * <ul>
+ * <li><code>US-ASCII</code><br/>
+ * Seven-bit ASCII, a.k.a. ISO646-US, a.k.a. the Basic Latin block of the Unicode character set.</li>
+ * <li><code>ISO-8859-1</code><br/>
+ * ISO Latin Alphabet No. 1, a.k.a. ISO-LATIN-1.</li>
+ * <li><code>UTF-8</code><br/>
+ * Eight-bit Unicode Transformation Format.</li>
+ * <li><code>UTF-16BE</code><br/>
+ * Sixteen-bit Unicode Transformation Format, big-endian byte order.</li>
+ * <li><code>UTF-16LE</code><br/>
+ * Sixteen-bit Unicode Transformation Format, little-endian byte order.</li>
+ * <li><code>UTF-16</code><br/>
+ * Sixteen-bit Unicode Transformation Format, byte order specified by a mandatory initial byte-order mark (either order
+ * accepted on input, big-endian used on output.)</li>
+ * </ul>
+ *
+ * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+ * @since 2.3
+ * @version $Id: Charsets.java 1311751 2012-04-10 14:26:21Z ggregory $
+ */
+public class Charsets {
+    //
+    // This class should only contain Charset instances for required encodings. This guarantees that it will load
+    // correctly and without delay on all Java platforms.
+    //
+
+    /**
+     * Returns the given Charset or the default Charset if the given Charset is null.
+     *
+     * @param charset
+     *            A charset or null.
+     * @return the given Charset or the default Charset if the given Charset is null
+     */
+    public static Charset toCharset(Charset charset) {
+        return charset == null ? Charset.defaultCharset() : charset;
+    }
+
+    /**
+     * Returns a Charset for the named charset. If the name is null, return the default Charset.
+     *
+     * @param charset
+     *            The name of the requested charset, may be null.
+     * @return a Charset for the named charset
+     * @throws UnsupportedCharsetException
+     *             If the named charset is unavailable
+     */
+    public static Charset toCharset(String charset) {
+        return charset == null ? Charset.defaultCharset() : Charset.forName(charset);
+    }
+
+    /**
+     * CharEncodingISO Latin Alphabet No. 1, a.k.a. ISO-LATIN-1. </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final Charset ISO_8859_1 = Charset.forName("ISO-8859-1");
+
+    /**
+     * <p>
+     * Seven-bit ASCII, also known as ISO646-US, also known as the Basic Latin block of the Unicode character set.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final Charset US_ASCII = Charset.forName("US-ASCII");
+
+    /**
+     * <p>
+     * Sixteen-bit Unicode Transformation Format, The byte order specified by a mandatory initial byte-order mark
+     * (either order accepted on input, big-endian used on output)
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final Charset UTF_16 = Charset.forName("UTF-16");
+
+    /**
+     * <p>
+     * Sixteen-bit Unicode Transformation Format, big-endian byte order.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final Charset UTF_16BE = Charset.forName("UTF-16BE");
+
+    /**
+     * <p>
+     * Sixteen-bit Unicode Transformation Format, little-endian byte order.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final Charset UTF_16LE = Charset.forName("UTF-16LE");
+
+    /**
+     * <p>
+     * Eight-bit Unicode Transformation Format.
+     * </p>
+     * <p>
+     * Every implementation of the Java platform is required to support this character encoding.
+     * </p>
+     *
+     * @see <a href="http://docs.oracle.com/javase/6/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
+     */
+    public static final Charset UTF_8 = Charset.forName("UTF-8");
+}