Merge pull request #42 from LPK98/isira

Add background running applications and improve crash safety

Author: iSiRaH

app.config.js

@@ -27,6 +27,9 @@ export default {
 
     ios: {
       supportsTablet: true,
+      config: {
+        googleMapsApiKey: process.env.GOOGLE_MAPS_API_KEY,
+      },
       infoPlist: {
         NSLocationWhenInUseUsageDescription:
           "This app uses your location to show nearby places and reports.",
@@ -56,6 +59,11 @@ export default {
         "FOREGROUND_SERVICE",
         "FOREGROUND_SERVICE_LOCATION",
       ],
+      config: {
+        googleMaps: {
+          apiKey: process.env.GOOGLE_MAPS_API_KEY,
+        },
+      },
       package: "com.anonymous.CrimelinkAnalyzer_app",
       jsEngine: "hermes",
     },

app/(screens)/SafetyZone.tsx

@@ -1,5 +1,6 @@
 import OverlayButton from "@/src/components/UI/OverlayButton";
 import Searchbar from "@/src/components/UI/Searchbar";
+import { appConfig } from "@/src/constants/appConfig";
 import { images } from "@/src/constants/images";
 import { getCrimeLocations } from "@/src/services/safetyzoneService";
 import { useTheme } from "@/src/theme/ThemeProvider";
@@ -18,7 +19,7 @@ import {
   View,
   useWindowDimensions,
 } from "react-native";
-import MapView, { Marker, Region } from "react-native-maps";
+import MapView, { Marker, PROVIDER_GOOGLE, Region } from "react-native-maps";
 import {
   SafeAreaView,
   useSafeAreaInsets,
@@ -88,6 +89,7 @@ const SafetyZone = () => {
   const [region, setRegion] = useState<Region | null>(null);
   const [isFullScreen, setIsFullScreen] = useState(false);
   const [crimeLocations, setCrimeLocations] = useState<CrimeLocationType[]>([]);
+  const hasGoogleMapsApiKey = Boolean(appConfig.googleMapsApiKey?.trim());
 
   useEffect(() => {
     const loadLocation = async () => {
@@ -265,56 +267,69 @@ const SafetyZone = () => {
                 },
               ]}
             >
-              <MapView
-                ref={mapRef}
-                style={styles.map}
-                provider="google"
-                region={region}
-                onMapReady={() => onMapReady(mapRef)}
-                onRegionChangeComplete={(nextRegion) => {
-                  if (isAnimatingRef.current) return;
-                  setRegion(nextRegion);
-                }}
-                showsUserLocation={true}
-                showsMyLocationButton={false}
-                minZoomLevel={6}
-                maxZoomLevel={18}
-              >
-                {crimeLocations.map((loc, index) => (
-                  <Marker
-                    key={`${loc.latitude}-${loc.longitude}-${index}`}
-                    coordinate={{
-                      latitude: loc.latitude,
-                      longitude: loc.longitude,
+              {hasGoogleMapsApiKey ? (
+                <>
+                  <MapView
+                    ref={mapRef}
+                    style={styles.map}
+                    provider={PROVIDER_GOOGLE}
+                    region={region}
+                    onMapReady={() => onMapReady(mapRef)}
+                    onRegionChangeComplete={(nextRegion) => {
+                      if (isAnimatingRef.current) return;
+                      setRegion(nextRegion);
                     }}
-                    title={loc.crimeType}
-                  />
-                ))}
-              </MapView>
-
-              <View style={styles.mapActions} pointerEvents="box-none">
-                <OverlayButton
-                  icon="fullscreen"
-                  iconColor="#ffffff"
-                  size={24}
-                  onPress={() => setIsFullScreen((v) => !v)}
-                />
-                <OverlayButton
-                  icon="add"
-                  size={24}
-                  onPress={() => zoom("in")}
-                />
-                <OverlayButton
-                  icon="remove"
-                  size={24}
-                  onPress={() => zoom("out")}
-                />
-                <OverlayButton
-                  icon="my-location"
-                  size={24}
-                  onPress={myLocation}
-                />
-              </View>
+                    showsUserLocation={true}
+                    showsMyLocationButton={false}
+                    minZoomLevel={6}
+                    maxZoomLevel={18}
+                  >
+                    {crimeLocations.map((loc, index) => (
+                      <Marker
+                        key={`${loc.latitude}-${loc.longitude}-${index}`}
+                        coordinate={{
+                          latitude: loc.latitude,
+                          longitude: loc.longitude,
+                        }}
+                        title={loc.crimeType}
+                      />
+                    ))}
+                  </MapView>
+
+                  <View style={styles.mapActions} pointerEvents="box-none">
+                    <OverlayButton
+                      icon="fullscreen"
+                      iconColor="#ffffff"
+                      size={24}
+                      onPress={() => setIsFullScreen((v) => !v)}
+                    />
+                    <OverlayButton
+                      icon="add"
+                      size={24}
+                      onPress={() => zoom("in")}
+                    />
+                    <OverlayButton
+                      icon="remove"
+                      size={24}
+                      onPress={() => zoom("out")}
+                    />
+                    <OverlayButton
+                      icon="my-location"
+                      size={24}
+                      onPress={myLocation}
+                    />
+                  </View>
+                </>
+              ) : (
+                <View style={styles.mapUnavailable}>
+                  <Text
+                    style={[styles.mapUnavailableText, { color: colors.text }]}
+                  >
+                    Google Maps API key is missing. Set GOOGLE_MAPS_API_KEY for
+                    this EAS profile.
+                  </Text>
+                </View>
+              )}
             </View>
           </View>
 
@@ -351,7 +366,7 @@ const SafetyZone = () => {
         </View>
       </ImageBackground>
 
-      {isFullScreen && (
+      {isFullScreen && hasGoogleMapsApiKey && (
         <View
           style={[
             styles.fullScreenOverlay,
@@ -362,7 +377,7 @@ const SafetyZone = () => {
           <MapView
             ref={fullMapRef}
             style={{ flex: 1 }}
-            provider="google"
+            provider={PROVIDER_GOOGLE}
             region={region}
             onMapReady={() => onMapReady(fullMapRef)}
             onRegionChangeComplete={(r) => {
@@ -485,6 +500,18 @@ const styles = StyleSheet.create({
     flex: 1,
     width: "100%",
   },
+  mapUnavailable: {
+    flex: 1,
+    alignItems: "center",
+    justifyContent: "center",
+    paddingHorizontal: 20,
+  },
+  mapUnavailableText: {
+    fontSize: 14,
+    fontWeight: "600",
+    textAlign: "center",
+    lineHeight: 20,
+  },
   mapActions: {
     position: "absolute",
     top: 10,

app/_layout.tsx

@@ -3,6 +3,8 @@ import { router, Stack, usePathname } from "expo-router";
 import React, { useEffect } from "react";
 import AuthProvider from "../src/context/AuthContext";
 import { useAuth } from "../src/hooks/useAuth";
+import { bootstrapLocationTracking } from "../src/services/location/locationBootstrap";
+import "../src/services/location/locationTracker";
 import "./global.css";
 
 function Guard({ children }: { children: React.ReactNode }) {
@@ -20,6 +22,12 @@ function Guard({ children }: { children: React.ReactNode }) {
     }
   }, [user, loading, pathname]);
 
+  useEffect(() => {
+    if (loading) return;
+
+    void bootstrapLocationTracking();
+  }, [loading]);
+
   return <>{children}</>;
 }
 

src/components/UI/Searchbar.tsx

@@ -1,15 +1,18 @@
+import { useTheme } from "@/src/theme/ThemeProvider";
 import React from "react";
 import { TextInput, View } from "react-native";
 
 const Searchbar = () => {
+  const { colors } = useTheme();
+
   return (
     <View style={{ padding: 10 }}>
       <TextInput
         placeholder="🔍  Search location or sector..."
         className="bg-white rounded-lg p-2 w-full"
         style={{
           fontSize: 16,
-          color: "black",
+          color: colors.white,
           paddingHorizontal: 12,
           borderRadius: 30,
           paddingVertical: 10,

src/services/location/locationBootstrap.ts

@@ -0,0 +1,34 @@
+import { isDutyTrackingEnabled } from "@/src/auth/auth";
+import { initLocationDB } from "@/src/services/location/locationDB";
+import {
+  isTrackingActive,
+  startTracking,
+  stopTracking,
+} from "@/src/services/location/locationTracker";
+
+let hasBootstrappedLocationTracking = false;
+
+export async function bootstrapLocationTracking() {
+  if (hasBootstrappedLocationTracking) return;
+
+  hasBootstrappedLocationTracking = true;
+
+  initLocationDB();
+
+  const dutyTrackingEnabled = await isDutyTrackingEnabled();
+  const trackingActive = await isTrackingActive();
+
+  if (dutyTrackingEnabled && !trackingActive) {
+    try {
+      await startTracking();
+    } catch (error) {
+      // Startup should not crash if permissions are missing; user can re-enable from Duty toggle.
+      console.warn("[LOCATION] Failed to resume tracking on app start:", error);
+    }
+    return;
+  }
+
+  if (!dutyTrackingEnabled && trackingActive) {
+    await stopTracking();
+  }
+}

src/services/location/locationTracker.ts

@@ -20,38 +20,48 @@ function createLocationPermissionError(code: string, message: string) {
   return error;
 }
 
-TaskManager.defineTask(TASK_NAME, async ({ data, error }) => {
-  console.log("[LOCATION] Background task triggered"); //REMOVE: for testing
-  if (error) {
-    console.error("[LOCATION] Task error", error); //REMOVE: for testing
-    return;
-  }
-
-  const location = (data as any)?.locations?.[0];
-  if (!location) return;
-
-  const { latitude, longitude, accuracy, speed, heading } = location.coords;
-
-  if (accuracy != null && accuracy > 50) return;
+if (!TaskManager.isTaskDefined(TASK_NAME)) {
+  TaskManager.defineTask(TASK_NAME, async ({ data, error }) => {
+    console.log("[LOCATION] Background task triggered"); //REMOVE: for testing
+    if (error) {
+      console.error("[LOCATION] Task error", error); //REMOVE: for testing
+      return;
+    }
 
-  addPendingLocation({
-    id: Crypto.randomUUID(),
-    ts: new Date(location.timestamp).toISOString(),
-    latitude,
-    longitude,
-    accuracyM: accuracy ?? null,
-    speedMps: speed ?? null,
-    headingDeg: heading ?? null,
-    provider: "gps",
-    meta: JSON.stringify({ battery: null }),
+    const location = (data as any)?.locations?.[0];
+    if (!location) return;
+
+    const { latitude, longitude, accuracy, speed, heading } = location.coords;
+
+    if (accuracy != null && accuracy > 50) return;
+
+    addPendingLocation({
+      id: Crypto.randomUUID(),
+      ts: new Date(location.timestamp).toISOString(),
+      latitude,
+      longitude,
+      accuracyM: accuracy ?? null,
+      speedMps: speed ?? null,
+      headingDeg: heading ?? null,
+      provider: "gps",
+      meta: JSON.stringify({ battery: null }),
+    });
+
+    try {
+      await removePendingLocations();
+    } catch {}
+    const count = countPendingLocations(); //REMOVE:for testing
+    console.log("[LOCATION] Pending rows in SQLite:", count);
   });
+}
+
+export function getTrackingTaskName() {
+  return TASK_NAME;
+}
 
-  try {
-    await removePendingLocations();
-  } catch {}
-  const count = countPendingLocations(); //REMOVE:for testing
-  console.log("[LOCATION] Pending rows in SQLite:", count);
-});
+export async function isTrackingActive() {
+  return Location.hasStartedLocationUpdatesAsync(TASK_NAME);
+}
 
 export async function startTracking() {
   const isBackgroundLocationAvailable =
@@ -103,7 +113,7 @@ export async function startTracking() {
     );
   }
 
-  const hasStarted = await Location.hasStartedLocationUpdatesAsync(TASK_NAME);
+  const hasStarted = await isTrackingActive();
   console.log("[LOCATION] Already started:", hasStarted); //REMOVE: for testing
   if (hasStarted) return;
 
@@ -113,11 +123,21 @@ export async function startTracking() {
     distanceInterval: 15,
     showsBackgroundLocationIndicator: true,
     pausesUpdatesAutomatically: false,
+    ...(Platform.OS === "android"
+      ? {
+          foregroundService: {
+            notificationTitle: "Duty tracking active",
+            notificationBody:
+              "Crime Link Analyzer is collecting location while you are on duty.",
+            notificationColor: "#0B57D0",
+          },
+        }
+      : {}),
   });
 }
 
 export async function stopTracking() {
-  const hasStarted = await Location.hasStartedLocationUpdatesAsync(TASK_NAME);
+  const hasStarted = await isTrackingActive();
   if (!hasStarted) return;
 
   await Location.stopLocationUpdatesAsync(TASK_NAME);