react-native-nitro-background-geolocation 0.1.0

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

@@ -0,0 +1,203 @@
+package com.marianhello.logging;
+
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteException;
+
+import ru.andremoniy.sqlbuilder.SqlExpression;
+import ru.andremoniy.sqlbuilder.SqlSelectStatement;
+
+import org.slf4j.event.Level;
+
+import java.io.File;
+import java.sql.SQLException;
+import java.util.ArrayList;
+import java.util.Collection;
+
+import ch.qos.logback.classic.LoggerContext;
+import ch.qos.logback.classic.db.names.ColumnName;
+import ch.qos.logback.classic.db.names.DBNameResolver;
+import ch.qos.logback.classic.db.names.DefaultDBNameResolver;
+import ch.qos.logback.classic.db.names.TableName;
+import ch.qos.logback.core.CoreConstants;
+// CommonPathUtil was removed in logback-android 2.x; use direct path construction instead
+
+public class DBLogReader {
+
+    public static final String DB_FILENAME = "logback.db";
+
+    private DefaultDBNameResolver mDbNameResolver;
+    private SQLiteDatabase mDatabase;
+
+    public static class QueryBuilder {
+        DBNameResolver mDbNameResolver;
+
+        public QueryBuilder() {
+            mDbNameResolver = new DefaultDBNameResolver();
+        }
+
+        public QueryBuilder(DBNameResolver dbNameResolver) {
+            mDbNameResolver = dbNameResolver;
+        }
+
+        /**
+         * Generate array of levels that are same or above provided level
+         *
+         * @param level
+         * @return array of levels that are same or above level
+         */
+        private Object[] aboveLevel(Level level) {
+            ArrayList<String> levels = new ArrayList();
+            for (Level l : Level.values()) {
+                if (level.compareTo(l) >= 0) {
+                    levels.add(l.toString());
+                }
+            }
+            return levels.toArray();
+        }
+
+        public String buildStackTraceQuery(int eventId) {
+            SqlSelectStatement builder = new SqlSelectStatement();
+            builder.column(mDbNameResolver.getColumnName(ColumnName.TRACE_LINE));
+            builder.from(mDbNameResolver.getTableName(TableName.LOGGING_EVENT_EXCEPTION));
+            builder.where(mDbNameResolver.getColumnName(ColumnName.I), SqlExpression.SqlOperatorEqualTo, Integer.valueOf(eventId));
+            builder.orderBy(mDbNameResolver.getColumnName(ColumnName.I));
+
+            return builder.statement();
+        }
+
+        public String buildQuery(int limit, int fromLogEntryId, Level minLevel) {
+            SqlSelectStatement builder = new SqlSelectStatement();
+            builder.columns(new String[]{
+                    mDbNameResolver.getColumnName(ColumnName.EVENT_ID),
+                    mDbNameResolver.getColumnName(ColumnName.TIMESTMP),
+                    mDbNameResolver.getColumnName(ColumnName.FORMATTED_MESSAGE),
+                    mDbNameResolver.getColumnName(ColumnName.LOGGER_NAME),
+                    mDbNameResolver.getColumnName(ColumnName.LEVEL_STRING),
+            });
+            builder.from(mDbNameResolver.getTableName(TableName.LOGGING_EVENT));
+            builder.where(mDbNameResolver.getColumnName(ColumnName.LEVEL_STRING), SqlExpression.SqlOperatorIn, aboveLevel(minLevel));
+            if (fromLogEntryId > 0) {
+                if (limit >= 0) {
+                    builder.where(mDbNameResolver.getColumnName(ColumnName.EVENT_ID), SqlExpression.SqlOperatorLessThan, fromLogEntryId);
+                } else {
+                    builder.where(mDbNameResolver.getColumnName(ColumnName.EVENT_ID), SqlExpression.SqlOperatorGreaterThan, fromLogEntryId);
+                }
+            }
+            if (limit < 0) {
+                builder.orderBy(mDbNameResolver.getColumnName(ColumnName.TIMESTMP));
+                builder.orderBy(mDbNameResolver.getColumnName(ColumnName.EVENT_ID));
+            } else {
+                builder.orderBy(mDbNameResolver.getColumnName(ColumnName.TIMESTMP), true);
+                builder.orderBy(mDbNameResolver.getColumnName(ColumnName.EVENT_ID), true);
+            }
+            builder.limit(limit);
+
+            return builder.statement();
+        }
+    }
+
+    public Collection<LogEntry> getEntries(int limit, int fromLogEntryId, Level minLevel) {
+        try {
+            return getDbEntries(limit, fromLogEntryId, minLevel);
+        } catch (SQLException e) {
+            e.printStackTrace();
+        }
+
+        return null;
+    }
+
+    private SQLiteDatabase openDatabase() throws SQLException {
+        if (mDatabase != null && mDatabase.isOpen()) {
+            return mDatabase;
+        }
+
+        String packageName = null;
+        LoggerContext context = (LoggerContext) org.slf4j.LoggerFactory.getILoggerFactory();
+
+        if (context != null) {
+            packageName = context.getProperty(CoreConstants.PACKAGE_NAME_KEY);
+        }
+
+        if (packageName == null || packageName.length() == 0) {
+            throw new SQLException("Cannot open database without package name");
+        }
+
+        try {
+            File dbfile = new File("/data/data/" + packageName + "/databases", DB_FILENAME);
+            mDatabase = SQLiteDatabase.openDatabase(dbfile.getPath(), null, SQLiteDatabase.OPEN_READONLY);
+        } catch (SQLiteException e) {
+            throw new SQLException("Cannot open database", e);
+        }
+
+        return mDatabase;
+    }
+
+    private DefaultDBNameResolver getDbNameResolver() {
+        if (mDbNameResolver != null) {
+            return mDbNameResolver;
+        }
+
+        mDbNameResolver = new DefaultDBNameResolver();
+        return mDbNameResolver;
+    }
+
+    private Collection<String> getStackTrace(int logEntryId) throws SQLException {
+        Collection<String> stackTrace = new ArrayList();
+        SQLiteDatabase db = openDatabase();
+        Cursor cursor = null;
+
+        try {
+            DefaultDBNameResolver dbNameResolver = getDbNameResolver();
+            QueryBuilder qb = new QueryBuilder(dbNameResolver);
+            cursor = mDatabase.rawQuery(qb.buildStackTraceQuery(logEntryId), new String[] {});
+            while (cursor.moveToNext()) {
+                stackTrace.add(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.TRACE_LINE))));
+            }
+        } catch (SQLiteException e) {
+            throw new SQLException("Cannot retrieve log entries", e);
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        return stackTrace;
+    }
+
+    private Collection<LogEntry> getDbEntries(int limit, int fromLogEntryId, Level minLevel) throws SQLException {
+        Collection<LogEntry> entries = new ArrayList<LogEntry>();
+        SQLiteDatabase db = openDatabase();
+        Cursor cursor = null;
+
+        try {
+            DefaultDBNameResolver dbNameResolver = getDbNameResolver();
+            QueryBuilder qb = new QueryBuilder(dbNameResolver);
+            cursor = db.rawQuery(qb.buildQuery(limit, fromLogEntryId, minLevel), new String[] {});
+            while (cursor.moveToNext()) {
+                LogEntry entry = new LogEntry();
+                entry.setContext(0);
+                entry.setId(cursor.getInt(cursor.getColumnIndex(mDbNameResolver.getColumnName(ColumnName.EVENT_ID))));
+                entry.setLevel(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.LEVEL_STRING))));
+                entry.setMessage(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.FORMATTED_MESSAGE))));
+                entry.setTimestamp(cursor.getLong(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.TIMESTMP))));
+                entry.setLoggerName(cursor.getString(cursor.getColumnIndex(dbNameResolver.getColumnName(ColumnName.LOGGER_NAME))));
+                if ("ERROR".equals(entry.getLevel())) {
+                    entry.setStackTrace(getStackTrace(entry.getId()));
+                }
+                entries.add(entry);
+            }
+        } catch (SQLiteException e) {
+            throw new SQLException("Cannot retrieve log entries", e);
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            if (db != null) {
+                db.close();
+            }
+        }
+
+        return entries;
+    }
+}

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

@@ -0,0 +1,99 @@
+package com.marianhello.logging;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.util.Collection;
+
+public class LogEntry {
+    private Integer id;
+    private Integer context;
+    private String level;
+    private String message;
+    private Long timestamp;
+    private String loggerName;
+    private Collection<String> stackTrace;
+
+    public Integer getId() {
+        return id;
+    }
+
+    public void setId(Integer id) {
+        this.id = id;
+    }
+
+    public Integer getContext() {
+        return context;
+    }
+
+    public void setContext(Integer context) {
+        this.context = context;
+    }
+
+    public String getLevel() {
+        return level;
+    }
+
+    public void setLevel(String level) {
+        this.level = level;
+    }
+
+    public String getMessage() {
+        return message;
+    }
+
+    public void setMessage(String message) {
+        this.message = message;
+    }
+
+    public Long getTimestamp() {
+        return timestamp;
+    }
+
+    public void setTimestamp(Long timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public String getLoggerName() {
+        return loggerName;
+    }
+
+    public void setLoggerName(String loggerName) {
+        this.loggerName = loggerName;
+    }
+
+    public boolean hasStackTrace() {
+        return stackTrace != null;
+    }
+
+    public String getStackTrace() {
+        if (this.stackTrace == null) {
+            return null;
+        }
+
+        StringBuilder stackTraceBuilder = new StringBuilder();
+        for (String traceLine : this.stackTrace) {
+            stackTraceBuilder.append(traceLine).append("\n");
+        }
+        return stackTraceBuilder.toString();
+    }
+
+    public void setStackTrace(Collection<String> stackTrace) {
+        this.stackTrace = stackTrace;
+    }
+
+    public JSONObject toJSONObject() throws JSONException {
+        JSONObject json = new JSONObject();
+        json.put("id", this.id);
+        json.put("context", this.context);
+        json.put("level", this.level);
+        json.put("message", this.message);
+        json.put("timestamp", this.timestamp);
+        json.put("logger", this.loggerName);
+        if (hasStackTrace()) {
+            json.put("stackTrace", this.getStackTrace());
+        }
+
+        return json;
+    }
+}

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);
+    }
+}