@josuelmm/capacitor-background-geolocation 1.0.0

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

@@ -0,0 +1,311 @@
+package com.marianhello.bgloc.sync;
+
+import android.content.ContentProviderOperation;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.JsonWriter;
+
+import com.marianhello.bgloc.ResourceResolver;
+import com.marianhello.bgloc.data.AbstractLocationTemplate;
+import com.marianhello.bgloc.data.ArrayListLocationTemplate;
+import com.marianhello.bgloc.data.BackgroundLocation;
+import com.marianhello.bgloc.data.HashMapLocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplate;
+import com.marianhello.bgloc.data.LocationTemplateFactory;
+import com.marianhello.bgloc.data.provider.LocationContentProvider;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract;
+import com.marianhello.bgloc.data.sqlite.SQLiteLocationContract.LocationEntry;
+import com.marianhello.bgloc.data.sqlite.SQLiteOpenHelper;
+import com.marianhello.logging.LoggerManager;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.UnsupportedEncodingException;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Created by finch on 20/07/16.
+ */
+public class BatchManager {
+    private Context context;
+    private org.slf4j.Logger logger;
+
+    public BatchManager(Context context) {
+        logger = LoggerManager.getLogger(BatchManager.class);
+        this.context = context;
+    }
+
+    private Uri getLocationContentUri() {
+        ResourceResolver resourceResolver = ResourceResolver.newInstance(context);
+        String authority = resourceResolver.getAuthority();
+        return LocationContentProvider.getContentUri(authority);
+    }
+
+    private File createBatchFromTemplate(Long batchStartMillis, Integer syncThreshold, LocationTemplate template) throws IOException {
+        logger.info("Creating batch {}", batchStartMillis);
+
+        ContentResolver resolver = context.getContentResolver();
+        Uri contentUri = getLocationContentUri();
+
+        String whereClause = TextUtils.join("", new String[]{
+                LocationEntry.COLUMN_NAME_STATUS + " = ? AND ( ",
+                LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " IS NULL OR ",
+                LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " < ? )",
+        });
+        String[] whereArgs = {
+                String.valueOf(BackgroundLocation.SYNC_PENDING),
+                String.valueOf(batchStartMillis)
+        };
+
+        Cursor cursor = null;
+        LocationWriter writer = null;
+        FileOutputStream fs = null;
+        File file = null;
+        boolean batchReturned = false;
+
+        try {
+            cursor = resolver.query(
+                    contentUri,
+                    null,
+                    whereClause,
+                    whereArgs,
+                    LocationEntry.COLUMN_NAME_TIME + " ASC"
+
+            );
+
+            if (cursor == null) {
+                logger.warn("ContentResolver.query returned null, cannot create batch");
+                return null;
+            }
+
+            int threshold = (syncThreshold != null && syncThreshold >= 0) ? syncThreshold : 1;
+            if (cursor.getCount() < threshold) {
+                return null;
+            }
+            // Never create or send an empty batch (e.g. forceSync with 0 pending locations)
+            if (cursor.getCount() == 0) {
+                logger.info("No pending locations to sync, skipping batch creation");
+                return null;
+            }
+
+            file = File.createTempFile("locations", ".json");
+            fs = new FileOutputStream(file);
+            writer = new LocationWriter(fs, template);
+
+            writer.beginArray();
+            while (cursor.moveToNext()) {
+                BackgroundLocation location = BackgroundLocation.fromCursor(cursor);
+                writer.write(location);
+            }
+
+            writer.endArray();
+            writer.close();
+            writer = null;
+            fs.close();
+            fs = null;
+
+            // set batchStartMillis for all synced locations
+            ContentValues values = new ContentValues();
+            values.put(LocationEntry.COLUMN_NAME_BATCH_START_MILLIS, batchStartMillis);
+            resolver.update(contentUri, values, whereClause, whereArgs);
+
+            logger.info("Batch file: {} created successfully", file.getName());
+
+            batchReturned = true;
+            return file;
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+            if (writer != null) {
+                try {
+                    writer.close();
+                } catch (IOException e) {
+                    logger.debug("Error closing LocationWriter: {}", e.getMessage());
+                }
+            }
+            if (fs != null) {
+                try {
+                    fs.close();
+                } catch (IOException e) {
+                    logger.debug("Error closing FileOutputStream: {}", e.getMessage());
+                }
+            }
+            // if we threw before returning the file, delete temp file to avoid leaving garbage
+            if (!batchReturned && file != null && file.exists() && !file.delete()) {
+                logger.warn("Could not delete temp batch file: {}", file.getAbsolutePath());
+            }
+        }
+    }
+
+    public File createBatch(Long batchStartMillis, Integer syncThreshold, LocationTemplate template) throws IOException {
+        LocationTemplate tpl;
+        if (template != null) {
+            tpl = template;
+        } else {
+            tpl = LocationTemplateFactory.getDefault();
+        }
+        return createBatchFromTemplate(batchStartMillis, syncThreshold, tpl);
+    }
+
+    public File createBatch(Long batchStartMillis, Integer syncThreshold) throws IOException {
+        return createBatch(batchStartMillis, syncThreshold, null);
+    }
+
+
+    public void setBatchCompleted(Long batchId) {
+        ContentResolver resolver = context.getApplicationContext().getContentResolver();
+        Uri contentUri = getLocationContentUri();
+
+        String whereClause = LocationEntry.COLUMN_NAME_BATCH_START_MILLIS + " = ?";
+        String[] whereArgs = { String.valueOf(batchId) };
+
+        ContentValues values = new ContentValues();
+        values.put(LocationEntry.COLUMN_NAME_STATUS, BackgroundLocation.DELETED);
+        resolver.update(contentUri, values, whereClause, whereArgs);
+    }
+
+    private static class LocationTemplateWriter {
+        private BackgroundLocation location;
+        private JsonWriter writer;
+
+        public LocationTemplateWriter(JsonWriter writer, BackgroundLocation location) {
+            this.writer = writer;
+            this.location = location;
+        }
+
+        private void writeValue(Object value) throws IOException {
+            if (value == null || value == JSONObject.NULL) {
+                writer.nullValue();
+            } else if (value instanceof String ) {
+                writer.value((String) value);
+            } else if (value instanceof Map) {
+                writeMap((Map) value);
+            } else if (value instanceof List) {
+                writeList((List) value);
+            // v4.5.1 — handle JSONArray / JSONObject so that placeholders that resolve to
+            // structured data (@events → JSONArray of events) are written as real JSON arrays /
+            // objects, not as escaped strings. Without this, a fix coming out of the sync queue
+            // serialised "events" as "[{\"type\":\"hardBrake\"}]" literal.
+            } else if (value instanceof org.json.JSONArray) {
+                writeJsonArray((org.json.JSONArray) value);
+            } else if (value instanceof org.json.JSONObject) {
+                writeJsonObject((org.json.JSONObject) value);
+            } else if (Integer.class.isInstance(value)) {
+                writer.value((Integer) value);
+            } else if (Double.class.isInstance(value)) {
+                writer.value((Double) value);
+            } else if (Float.class.isInstance(value)) {
+                writer.value((Float) value);
+            } else if (Long.class.isInstance(value)) {
+                writer.value((Long) value);
+            } else if (Boolean.class.isInstance(value)) {
+                writer.value((Boolean) value);
+            } else {
+                writer.value(String.valueOf(value));
+            }
+        }
+
+        private void writeJsonArray(org.json.JSONArray arr) throws IOException {
+            writer.beginArray();
+            for (int i = 0; i < arr.length(); i++) {
+                Object v = arr.opt(i);
+                writeValue(v == null ? JSONObject.NULL : v);
+            }
+            writer.endArray();
+        }
+
+        private void writeJsonObject(org.json.JSONObject obj) throws IOException {
+            writer.beginObject();
+            Iterator<String> keys = obj.keys();
+            while (keys.hasNext()) {
+                String k = keys.next();
+                writer.name(k);
+                writeValue(obj.opt(k));
+            }
+            writer.endObject();
+        }
+
+        /** v4.5.1 — resolve a template string. If it is a placeholder ("@foo") and the location
+         *  has no value, return JSONObject.NULL so the writer emits `null` instead of the literal
+         *  "@foo" string. */
+        private Object resolveTemplateValue(Object value) {
+            if (value instanceof String) {
+                String s = (String) value;
+                Object resolved = location.getValueForKey(s);
+                if (resolved != null) return resolved;
+                if (s.startsWith("@")) return JSONObject.NULL;
+            }
+            return value;
+        }
+
+        public void writeMap(Map values) throws IOException {
+            writer.beginObject();
+            Iterator<?> it = values.entrySet().iterator();
+            while (it.hasNext()) {
+                Map.Entry<String, Object> pair = (Map.Entry) it.next();
+                String key = pair.getKey();
+                Object value = pair.getValue();
+                writer.name(key);
+                writeValue(resolveTemplateValue(value));
+            }
+            writer.endObject();
+        }
+
+        public void writeList(List values) throws IOException {
+            writer.beginArray();
+            Iterator<?> it = values.iterator();
+            while (it.hasNext()) {
+                Object value = it.next();
+                writeValue(resolveTemplateValue(value));
+            }
+            writer.endArray();
+        }
+    }
+
+    private static class LocationWriter {
+        private JsonWriter writer = null;
+        private LocationTemplate template;
+
+        public LocationWriter(FileOutputStream fos, LocationTemplate template) throws IOException {
+            writer = new JsonWriter(new OutputStreamWriter(fos, "UTF-8"));
+            this.template = template;
+        }
+
+        public void beginArray() throws IOException {
+            writer.beginArray();
+        }
+
+        public void endArray() throws IOException {
+            writer.endArray();
+        }
+
+        public void close() throws IOException {
+            writer.close();
+        }
+
+        public void write(BackgroundLocation location) throws IOException {
+            LocationTemplateWriter writer = new LocationTemplateWriter(this.writer, location);
+            if (template instanceof HashMapLocationTemplate) {
+                HashMapLocationTemplate hashTemplate = (HashMapLocationTemplate) template;
+                writer.writeMap(hashTemplate.toMap());
+            } else if (template instanceof ArrayListLocationTemplate) {
+                ArrayListLocationTemplate listTemplate = (ArrayListLocationTemplate) template;
+                writer.writeList(listTemplate.toList());
+            }
+        }
+    }
+}

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

@@ -0,0 +1,148 @@
+package com.marianhello.bgloc.sync;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.BitmapFactory;
+import android.graphics.Color;
+import android.os.Build;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationCompat;
+
+import com.marianhello.bgloc.ResourceResolver;
+import com.marianhello.logging.LoggerManager;
+
+public class NotificationHelper {
+    public static final String SERVICE_CHANNEL_ID = "bglocservice";
+    // https://github.com/nishkarsh/android-permissions/blob/master/src/main/java/com/intentfilter/androidpermissions/services/NotificationService.java#L15
+    public static final String ANDROID_PERMISSIONS_CHANNEL_ID = "android-permissions";
+
+    public static final String SYNC_CHANNEL_ID = "syncservice";
+    public static final String SYNC_CHANNEL_NAME = "Sync Service";
+    public static final String SYNC_CHANNEL_DESCRIPTION = "Shows sync progress";
+
+    public static class NotificationFactory {
+        private Context mContext;
+        private ResourceResolver mResolver;
+
+        private org.slf4j.Logger logger;
+
+        public NotificationFactory(Context context) {
+            mContext = context;
+            mResolver = ResourceResolver.newInstance(context);
+            logger =  LoggerManager.getLogger(NotificationFactory.class);
+        }
+
+        private Integer parseNotificationIconColor(String color) {
+            int iconColor = 0;
+            if (color != null) {
+                try {
+                    iconColor = Color.parseColor(color);
+                } catch (IllegalArgumentException e) {
+                    logger.error("Couldn't parse color from android options");
+                }
+            }
+            return iconColor;
+        }
+
+        public Notification getNotification(String title, String text, String largeIcon, String smallIcon, String color) {
+            Context appContext = mContext.getApplicationContext();
+
+            // Build a Notification required for running service in foreground.
+            NotificationCompat.Builder builder = new NotificationCompat.Builder(mContext, NotificationHelper.SERVICE_CHANNEL_ID);
+
+            builder.setContentTitle(title);
+            builder.setContentText(text);
+            builder.setOngoing(true);
+            if (smallIcon != null && !smallIcon.isEmpty()) {
+                builder.setSmallIcon(mResolver.getDrawable(smallIcon));
+            } else {
+                builder.setSmallIcon(android.R.drawable.ic_menu_mylocation);
+            }
+            if (largeIcon != null && !largeIcon.isEmpty()) {
+                int largeIconId = mResolver.getDrawable(largeIcon);
+                if (largeIconId == 0) {
+                    logger.warn("The resource " + largeIcon + " was not found in the drawable folder. Please include it when building the app.");
+                }
+                builder.setLargeIcon(BitmapFactory.decodeResource(appContext.getResources(), largeIconId));
+            }
+            if (color != null && !color.isEmpty()) {
+                builder.setColor(this.parseNotificationIconColor(color));
+            }
+
+            // Add an onclick handler to the notification
+            String packageName = appContext.getPackageName();
+            Intent launchIntent = appContext.getPackageManager().getLaunchIntentForPackage(packageName);
+            if (launchIntent != null) {
+                // NOTICE: testing apps might not have registered launch intent
+                launchIntent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT | Intent.FLAG_ACTIVITY_SINGLE_TOP);
+                int flags = Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+                        ? PendingIntent.FLAG_CANCEL_CURRENT | PendingIntent.FLAG_IMMUTABLE
+                        : PendingIntent.FLAG_CANCEL_CURRENT;
+                PendingIntent contentIntent = PendingIntent.getActivity(appContext, 0, launchIntent, flags);
+                builder.setContentIntent(contentIntent);
+            }
+
+            Notification notification = builder.build();
+            notification.flags |= Notification.FLAG_ONGOING_EVENT | Notification.FLAG_FOREGROUND_SERVICE | Notification.FLAG_NO_CLEAR;
+
+            return notification;
+        }
+    }
+
+    public static void registerAllChannels(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            String appName = ResourceResolver.newInstance(context).getString(("app_name"));
+            // Create the NotificationChannel, but only on API 26+ because
+            // the NotificationChannel class is new and not in the support library
+            android.app.NotificationManager notificationManager = (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(createServiceChannel(appName));
+            notificationManager.createNotificationChannel(createSyncChannel());
+            notificationManager.createNotificationChannel(createAndroidPermissionsChannel(appName));
+        }
+    }
+
+    public static void registerServiceChannel(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            String appName = ResourceResolver.newInstance(context).getString(("app_name"));
+            // Create the NotificationChannel, but only on API 26+ because
+            // the NotificationChannel class is new and not in the support library
+            android.app.NotificationManager notificationManager = (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(createServiceChannel(appName));
+        }
+    }
+
+    public static void registerSyncChannel(Context context) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            // Create the NotificationChannel, but only on API 26+ because
+            // the NotificationChannel class is new and not in the support library
+            android.app.NotificationManager notificationManager = (android.app.NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+            notificationManager.createNotificationChannel(createSyncChannel());
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static NotificationChannel createServiceChannel(CharSequence name) {
+        NotificationChannel channel = new NotificationChannel(SERVICE_CHANNEL_ID, name, android.app.NotificationManager.IMPORTANCE_LOW);
+        channel.enableVibration(false);
+        return channel;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static NotificationChannel createSyncChannel(){
+        NotificationChannel channel = new NotificationChannel(SYNC_CHANNEL_ID, SYNC_CHANNEL_NAME, NotificationManager.IMPORTANCE_LOW);
+        channel.setDescription(SYNC_CHANNEL_DESCRIPTION);
+        channel.enableVibration(false);
+        return channel;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    public static NotificationChannel createAndroidPermissionsChannel(CharSequence name ){
+        NotificationChannel channel = new NotificationChannel(ANDROID_PERMISSIONS_CHANNEL_ID, name, NotificationManager.IMPORTANCE_HIGH);
+        channel.enableVibration(false);
+        return channel;
+    }
+}