@josuelmm/capacitor-background-geolocation 1.0.0

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

@@ -0,0 +1,301 @@
+package com.marianhello.bgloc.sync;
+
+import android.accounts.Account;
+import android.app.NotificationManager;
+import android.content.AbstractThreadedSyncAdapter;
+import android.content.ContentProviderClient;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SyncResult;
+import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
+import androidx.core.app.NotificationCompat;
+import androidx.localbroadcastmanager.content.LocalBroadcastManager;
+
+import com.marianhello.bgloc.Config;
+import com.marianhello.bgloc.HttpPostService;
+import com.marianhello.bgloc.data.ConfigurationDAO;
+import com.marianhello.bgloc.data.DAOFactory;
+import com.marianhello.bgloc.service.LocationServiceImpl;
+import com.marianhello.logging.LoggerManager;
+
+import org.json.JSONException;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+
+/**
+ * Handle the transfer of data between a server and an
+ * app, using the Android sync adapter framework.
+ */
+public class SyncAdapter extends AbstractThreadedSyncAdapter implements HttpPostService.UploadingProgressListener {
+
+    private static final int NOTIFICATION_ID = 666;
+
+    ContentResolver contentResolver;
+    private ConfigurationDAO configDAO;
+    private NotificationManager notificationManager;
+    private BatchManager batchManager;
+    private boolean notificationsEnabled = true;
+    private volatile Config currentSyncConfig;
+
+    private org.slf4j.Logger logger;
+
+    /**
+     * Set up the sync adapter
+     */
+    public SyncAdapter(Context context, boolean autoInitialize) {
+        this(context, autoInitialize, false);
+    }
+
+
+    /**
+     * Set up the sync adapter. This form of the
+     * constructor maintains compatibility with Android 3.0
+     * and later platform versions
+     */
+    public SyncAdapter(
+            Context context,
+            boolean autoInitialize,
+            boolean allowParallelSyncs) {
+
+        super(context, autoInitialize);
+        logger = LoggerManager.getLogger(SyncAdapter.class);
+
+        /*
+         * If your app uses a content resolver, get an instance of it
+         * from the incoming Context
+         */
+        contentResolver = context.getContentResolver();
+        configDAO = DAOFactory.createConfigurationDAO(context);
+        batchManager = new BatchManager(this.getContext());
+        notificationManager = (NotificationManager) getContext().getSystemService(Context.NOTIFICATION_SERVICE);
+
+        NotificationHelper.registerSyncChannel(context);
+    }
+
+    /*
+     * Specify the code you want to run in the sync adapter. The entire
+     * sync adapter runs in a background thread, so you don't have to set
+     * up your own background processing.
+     */
+    @Override
+    public void onPerformSync(
+            Account account,
+            Bundle extras,
+            String authority,
+            ContentProviderClient provider,
+            SyncResult syncResult) {
+
+        Config config = null;
+        try {
+            config = configDAO.retrieveConfiguration();
+        } catch (JSONException e) {
+            logger.error("Error retrieving config: {}", e.getMessage());
+            syncResult.stats.numParseExceptions++;
+            return;
+        }
+
+        if (config == null || !config.hasValidSyncUrl() || !Boolean.TRUE.equals(config.getSyncEnabled())) {
+            if (config == null) {
+                logger.warn("Sync skipped: no config");
+            } else if (!Boolean.TRUE.equals(config.getSyncEnabled())) {
+                logger.info("Sync skipped: sync disabled in config");
+            }
+            return;
+        }
+
+        //noinspection ConstantConditions
+        notificationsEnabled = !config.hasNotificationsEnabled() || config.getNotificationsEnabled();
+        currentSyncConfig = config;
+
+        Long batchStartMillis = System.currentTimeMillis();
+        boolean isForced = (extras != null) && extras.getBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, false);
+        Integer configThreshold = config.getSyncThreshold();
+        int syncThreshold = isForced ? 0 : (configThreshold != null ? configThreshold : 100);
+        logger.debug("Sync request isForced: {}, batchId: {}, syncThreshold: {}, config: {}", isForced, batchStartMillis, syncThreshold, config.toString());
+
+        File file = null;
+        try {
+            file = batchManager.createBatch(batchStartMillis, syncThreshold, config.getTemplate());
+        } catch (IOException e) {
+            logger.error("Failed to create batch: {}", e.getMessage());
+            syncResult.stats.numIoExceptions++;
+            return;
+        }
+
+        if (file == null) {
+            logger.info("Nothing to sync");
+            return;
+        }
+
+        logger.info("Syncing startAt: {}", batchStartMillis);
+        String url = config.getSyncUrl();
+        HashMap<String, String> httpHeaders = new HashMap<String, String>();
+        if (config.getHttpHeaders() != null) {
+            httpHeaders.putAll(config.getHttpHeaders());
+        }
+        httpHeaders.put("x-batch-id", String.valueOf(batchStartMillis));
+
+        // For URL templating in sync mode we can only resolve static queryParams keys; per-location
+        // placeholders (like {lat}) cannot apply to a multi-location batch. If the user wants per-location
+        // URL substitution they should use httpMode="single" + url= ... (real-time) or syncMode="single".
+        String resolvedUrl = com.marianhello.bgloc.http.UrlTemplateResolver.resolve(url, null, config.getQueryParams());
+        String syncMethod = config.getSyncHttpMethod();
+        if (uploadLocations(file, resolvedUrl, httpHeaders, syncMethod)) {
+            logger.info("Batch sync successful");
+            batchManager.setBatchCompleted(batchStartMillis);
+            if (file.delete()) {
+                logger.info("Batch file has been deleted: {}", file.getAbsolutePath());
+            } else {
+                logger.warn("Batch file has not been deleted: {}", file.getAbsolutePath());
+            }
+        } else {
+            logger.warn("Batch sync failed due server error");
+            syncResult.stats.numIoExceptions++;
+        }
+    }
+
+    private boolean uploadLocations(File file, String url, HashMap httpHeaders, String method) {
+        NotificationCompat.Builder builder = null;
+
+        if (notificationsEnabled) {
+            builder = new NotificationCompat.Builder(getContext(), NotificationHelper.SYNC_CHANNEL_ID);
+            builder.setOngoing(true);
+            builder.setContentTitle(currentSyncConfig.getNotificationSyncTitle());
+            builder.setContentText(currentSyncConfig.getNotificationSyncText());
+            builder.setSmallIcon(android.R.drawable.ic_dialog_info);
+            notificationManager.notify(NOTIFICATION_ID, builder.build());
+        }
+
+        // v3.5 Phase 4: emit syncStart event.
+        Bundle syncStart = new Bundle();
+        syncStart.putInt("action", LocationServiceImpl.MSG_ON_SYNC_START);
+        broadcastMessage(syncStart);
+
+        // Count locations being uploaded (best-effort, API-21+ safe).
+        int locationsAttempted = 0;
+        java.io.FileInputStream fis = null;
+        try {
+            fis = new java.io.FileInputStream(file);
+            java.io.ByteArrayOutputStream baos = new java.io.ByteArrayOutputStream();
+            byte[] buf = new byte[4096];
+            int n;
+            while ((n = fis.read(buf)) > 0) baos.write(buf, 0, n);
+            org.json.JSONArray arr = new org.json.JSONArray(new String(baos.toByteArray(), "UTF-8"));
+            locationsAttempted = arr.length();
+        } catch (Throwable ignored) { /* best-effort; emit 0 if we cannot read */
+        } finally {
+            if (fis != null) try { fis.close(); } catch (Exception ignored) {}
+        }
+
+        try {
+            int responseCode = HttpPostService.postJSONFile(url, file, httpHeaders, this, method);
+
+            // All 2xx statuses are okay
+            boolean isStatusOkay = responseCode >= 200 && responseCode < 300;
+
+            if (responseCode == 285) {
+                // Okay, but we don't need to continue sending these
+
+                logger.debug("Location was sent to the server, and received an \"HTTP 285 Updates Not Required\"");
+
+                Bundle bundle = new Bundle();
+                bundle.putInt("action", LocationServiceImpl.MSG_ON_ABORT_REQUESTED);
+                broadcastMessage(bundle);
+            }
+
+            if (responseCode == 401) {
+                Bundle bundle = new Bundle();
+                bundle.putInt("action", LocationServiceImpl.MSG_ON_HTTP_AUTHORIZATION);
+                broadcastMessage(bundle);
+            }
+
+            if (builder != null) {
+                if (isStatusOkay) {
+                    builder.setContentText(currentSyncConfig.getNotificationSyncCompletedText());
+                } else {
+                    builder.setContentText(currentSyncConfig.getNotificationSyncFailedText() + " (HTTP " + responseCode + ")");
+                }
+            }
+
+            if (!isStatusOkay) {
+                logger.warn("Batch sync failed: server returned HTTP {} (check server logs or sync URL)", responseCode);
+                Bundle errBundle = new Bundle();
+                errBundle.putInt("action", LocationServiceImpl.MSG_ON_SYNC_ERROR);
+                errBundle.putInt("httpStatus", responseCode);
+                errBundle.putString("message", "HTTP " + responseCode);
+                broadcastMessage(errBundle);
+            } else {
+                Bundle okBundle = new Bundle();
+                okBundle.putInt("action", LocationServiceImpl.MSG_ON_SYNC_SUCCESS);
+                okBundle.putInt("sent", locationsAttempted);
+                broadcastMessage(okBundle);
+            }
+
+            return isStatusOkay;
+        } catch (IOException e) {
+            String errMsg = e.getMessage() != null ? e.getMessage() : e.getClass().getSimpleName();
+            logger.warn("Error uploading locations (network/IO): {}", errMsg);
+
+            if (builder != null) {
+                builder.setContentText(currentSyncConfig.getNotificationSyncFailedText() + ": " + errMsg);
+            }
+            Bundle errBundle = new Bundle();
+            errBundle.putInt("action", LocationServiceImpl.MSG_ON_SYNC_ERROR);
+            errBundle.putInt("httpStatus", 0);
+            errBundle.putString("message", errMsg);
+            broadcastMessage(errBundle);
+        } finally {
+            logger.info("Syncing endAt: {}", System.currentTimeMillis());
+
+            if (builder != null) {
+                builder.setOngoing(false);
+                builder.setProgress(0, 0, false);
+                builder.setAutoCancel(true);
+                notificationManager.notify(NOTIFICATION_ID, builder.build());
+
+                Handler h = new Handler(Looper.getMainLooper());
+                long delayInMilliseconds = 5000;
+                h.postDelayed(new Runnable() {
+                    public void run() {
+                        logger.info("Notification cancelledAt: {}", System.currentTimeMillis());
+                        notificationManager.cancel(NOTIFICATION_ID);
+                    }
+                }, delayInMilliseconds);
+            }
+        }
+
+        return false;
+    }
+
+    public void onProgress(int progress) {
+        logger.debug("Syncing progress: {} updatedAt: {}", progress, System.currentTimeMillis());
+
+        Config c = currentSyncConfig;
+        if (notificationsEnabled && c != null) {
+            NotificationCompat.Builder builder = new NotificationCompat.Builder(getContext(), NotificationHelper.SYNC_CHANNEL_ID);
+            builder.setOngoing(true);
+            builder.setContentTitle(c.getNotificationSyncTitle());
+            builder.setContentText(c.getNotificationSyncText());
+            builder.setSmallIcon(android.R.drawable.ic_dialog_info);
+            builder.setProgress(100, progress, false);
+            notificationManager.notify(NOTIFICATION_ID, builder.build());
+        }
+
+        // v3.5 Phase 4: forward progress percentage to JS via syncProgress event.
+        Bundle progBundle = new Bundle();
+        progBundle.putInt("action", LocationServiceImpl.MSG_ON_SYNC_PROGRESS);
+        progBundle.putInt("progress", progress);
+        broadcastMessage(progBundle);
+    }
+
+    private void broadcastMessage(Bundle bundle) {
+        Intent intent = new Intent(LocationServiceImpl.ACTION_BROADCAST);
+        intent.putExtras(bundle);
+        LocalBroadcastManager.getInstance(getContext().getApplicationContext()).sendBroadcast(intent);
+    }
+}

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

@@ -0,0 +1,68 @@
+package com.marianhello.bgloc.sync;
+
+import android.accounts.Account;
+import android.app.Service;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.os.Bundle;
+import android.os.IBinder;
+
+/**
+ * Define a Service that returns an IBinder for the
+ * sync adapter class, allowing the sync adapter framework to call
+ * onPerformSync().
+ */
+public class SyncService extends Service {
+    // Storage for an instance of the sync adapter
+    private static SyncAdapter sSyncAdapter = null;
+    // Object to use as a thread-safe lock
+    private static final Object sSyncAdapterLock = new Object();
+
+    /**
+     * Instantiate the sync adapter object.
+     */
+    @Override
+    public void onCreate() {
+        /*
+         * Create the sync adapter as a singleton.
+         * Set the sync adapter as syncable
+         * Disallow parallel syncs
+         */
+        synchronized (sSyncAdapterLock) {
+            if (sSyncAdapter == null) {
+                sSyncAdapter = new SyncAdapter(getApplicationContext(), true);
+            }
+        }
+    }
+
+    /**
+     * Return an object that allows the system to invoke
+     * the sync adapter.
+     *
+     */
+    @Override
+    public IBinder onBind(Intent intent) {
+        /*
+         * Get the object that allows external processes
+         * to call onPerformSync(). The object is created
+         * in the base class code when the SyncAdapter
+         * constructors call super()
+         */
+        return sSyncAdapter.getSyncAdapterBinder();
+    }
+
+    public static void sync(Account account, String authority, boolean manual) {
+        // Pass the settings flags by inserting them in a bundle
+        Bundle settingsBundle = new Bundle();
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_MANUAL, manual);
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_EXPEDITED, manual);
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_DO_NOT_RETRY, false);
+        settingsBundle.putBoolean(ContentResolver.SYNC_EXTRAS_UPLOAD, true);
+
+        /*
+         * Request the sync for the default account, authority, and
+         * manual sync settings
+         */
+        ContentResolver.requestSync(account, authority, settingsBundle);
+    }
+}

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

@@ -0,0 +1,208 @@
+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;
+// NOTE: logback-android 2.x / 3.x dropped `ch.qos.logback.core.android.CommonPathUtil`.
+// The dropped util only computed `/data/data/<pkg>/databases`, so we inline that
+// path below. Adjusted from the upstream `mauron85/cordova-plugin-background-geolocation`
+// source for Capacitor 8+ compatibility. Apache-2.0.
+
+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 {
+            // Android stores app-private databases at `/data/data/<package>/databases`.
+            File dbDir = new File("/data/data/" + packageName + "/databases");
+            File dbfile = new File(dbDir, 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;
+    }
+}