alerte-secours/as-app
3
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

fix(headless-task): wip

Browse source
This commit is contained in:
devthejo 2025-06-22 11:18:59 +02:00
parent ac84ae707b
commit 6c290f21b4
7 changed files with 890 additions and 32 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
app.config.js
View file

@ -10,7 +10,8 @@ let config = {
version,
updates: {
url: "https://expo-updates.alertesecours.fr/api/manifest?project=alerte-secours&channel=release",
enabled: true,
// enabled: true,
enabled: false, // DEBUGGING
checkAutomatically: "ON_ERROR_RECOVERY",
fallbackToCacheTimeout: 0,
codeSigningCertificate: "./keys/certificate.pem",

376
index.js
View file

@ -18,6 +18,8 @@ import { onBackgroundEvent as notificationBackgroundEvent } from "~/notification
import onMessageReceived from "~/notifications/onMessageReceived";
import { createLogger } from "~/lib/logger";
import * as Sentry from "@sentry/react-native";
import AsyncStorage from "@react-native-async-storage/async-storage";
// setup notification, this have to stay in index.js
notifee.onBackgroundEvent(notificationBackgroundEvent);
@ -28,73 +30,423 @@ messaging().setBackgroundMessageHandler(onMessageReceived);
// the environment is set up appropriately
registerRootComponent(App);
// Constants for persistence
const LAST_SYNC_TIME_KEY = "@geolocation_last_sync_time";
// const FORCE_SYNC_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
const FORCE_SYNC_INTERVAL = 60 * 1000; // DEBUGGING
// Helper functions for persisting sync time
const getLastSyncTime = async () => {
try {
const value = await AsyncStorage.getItem(LAST_SYNC_TIME_KEY);
return value ? parseInt(value, 10) : Date.now();
} catch (error) {
Sentry.captureException(error, {
tags: { module: "headless-task", operation: "get-last-sync-time" },
});
return Date.now();
}
};
const setLastSyncTime = async (time) => {
try {
await AsyncStorage.setItem(LAST_SYNC_TIME_KEY, time.toString());
} catch (error) {
Sentry.captureException(error, {
tags: { module: "headless-task", operation: "set-last-sync-time" },
});
}
};
// this have to stay in index.js, see also https://github.com/transistorsoft/react-native-background-geolocation/wiki/Android-Headless-Mode
const getCurrentPosition = () => {
return new Promise((resolve) => {
// Add timeout protection
const timeout = setTimeout(() => {
resolve({ code: -1, message: "getCurrentPosition timeout" });
}, 15000); // 15 second timeout
BackgroundGeolocation.getCurrentPosition(
{
samples: 1,
persist: true,
extras: { background: true },
timeout: 10, // 10 second timeout in the plugin itself
},
(location) => {
clearTimeout(timeout);
resolve(location);
},
(error) => {
clearTimeout(timeout);
resolve(error);
},
);
});
};
const FORCE_SYNC_INTERVAL = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
let lastSyncTime = Date.now();
const geolocBgLogger = createLogger({
service: "background-geolocation",
task: "headless",
});
const HeadlessTask = async (event) => {
const { name, params } = event;
geolocBgLogger.info("HeadlessTask event received", { name, params });
// Add timeout protection for the entire headless task
const taskTimeout = setTimeout(() => {
geolocBgLogger.error("HeadlessTask timeout", { event });
Sentry.captureException(new Error("HeadlessTask timeout"), {
tags: {
module: "background-geolocation",
operation: "headless-task-timeout",
eventName: event?.name,
},
});
}, 60000); // 60 second timeout
let transaction;
try {
// Validate event structure
if (!event || typeof event !== "object") {
throw new Error("Invalid event object received");
}
const { name, params } = event;
if (!name || typeof name !== "string") {
throw new Error("Invalid event name received");
}
// Start Sentry transaction for the entire HeadlessTask
transaction = Sentry.startTransaction({
name: "headless-task",
op: "background-task",
data: { eventName: name },
});
Sentry.getCurrentScope().setSpan(transaction);
// Add initial breadcrumb
Sentry.addBreadcrumb({
message: "HeadlessTask started",
category: "headless-task",
level: "info",
data: {
eventName: name,
params: params ? JSON.stringify(params) : null,
timestamp: Date.now(),
},
});
geolocBgLogger.info("HeadlessTask event received", { name, params });
switch (name) {
case "heartbeat":
// Check if we need to force a sync
// Add breadcrumb for heartbeat event
Sentry.addBreadcrumb({
message: "Heartbeat event received",
category: "headless-task",
level: "info",
timestamp: Date.now() / 1000,
});
// Get persisted last sync time
const lastSyncTime = await getLastSyncTime();
const now = Date.now();
const timeSinceLastSync = now - lastSyncTime;
// Add context about sync timing
Sentry.setContext("sync-timing", {
lastSyncTime: new Date(lastSyncTime).toISOString(),
currentTime: new Date(now).toISOString(),
timeSinceLastSync: timeSinceLastSync,
timeSinceLastSyncHours: (
timeSinceLastSync /
(1000 * 60 * 60)
).toFixed(2),
needsForceSync: timeSinceLastSync >= FORCE_SYNC_INTERVAL,
});
Sentry.addBreadcrumb({
message: "Sync timing calculated",
category: "headless-task",
level: "info",
data: {
timeSinceLastSyncHours: (
timeSinceLastSync /
(1000 * 60 * 60)
).toFixed(2),
needsForceSync: timeSinceLastSync >= FORCE_SYNC_INTERVAL,
},
});
// Get current position
const locationSpan = transaction.startChild({
op: "get-current-position",
description: "Getting current position",
});
const location = await getCurrentPosition();
locationSpan.finish();
const isLocationError = location && location.code !== undefined;
Sentry.addBreadcrumb({
message: "getCurrentPosition completed",
category: "headless-task",
level: isLocationError ? "warning" : "info",
data: {
success: !isLocationError,
error: isLocationError ? location : undefined,
coords: !isLocationError ? location?.coords : undefined,
},
});
geolocBgLogger.debug("getCurrentPosition result", { location });
if (timeSinceLastSync >= FORCE_SYNC_INTERVAL) {
geolocBgLogger.info("Forcing location sync after 24h");
Sentry.addBreadcrumb({
message: "Force sync triggered",
category: "headless-task",
level: "info",
data: {
timeSinceLastSyncHours: (
timeSinceLastSync /
(1000 * 60 * 60)
).toFixed(2),
},
});
try {
// Get pending records count before sync with timeout
const pendingCount = await Promise.race([
BackgroundGeolocation.getCount(),
new Promise((_, reject) =>
setTimeout(() => reject(new Error("getCount timeout")), 10000),
),
]);
Sentry.addBreadcrumb({
message: "Pending records count",
category: "headless-task",
level: "info",
data: { pendingCount },
});
// Change pace to ensure location updates with timeout
const paceSpan = transaction.startChild({
op: "change-pace",
description: "Changing pace to true",
});
await Promise.race([
BackgroundGeolocation.changePace(true),
new Promise((_, reject) =>
setTimeout(
() => reject(new Error("changePace timeout")),
10000,
),
),
]);
paceSpan.finish();
Sentry.addBreadcrumb({
message: "changePace completed",
category: "headless-task",
level: "info",
});
// Perform sync with timeout
const syncSpan = transaction.startChild({
op: "sync-locations",
description: "Syncing locations",
});
const syncResult = await Promise.race([
BackgroundGeolocation.sync(),
new Promise((_, reject) =>
setTimeout(() => reject(new Error("sync timeout")), 20000),
),
]);
syncSpan.finish();
Sentry.addBreadcrumb({
message: "Sync completed successfully",
category: "headless-task",
level: "info",
data: {
syncResult: Array.isArray(syncResult)
? `${syncResult.length} records`
: "completed",
},
});
// Update last sync time after successful sync
await BackgroundGeolocation.changePace(true);
await BackgroundGeolocation.sync();
lastSyncTime = now;
await setLastSyncTime(now);
Sentry.addBreadcrumb({
message: "Last sync time updated",
category: "headless-task",
level: "info",
data: { newSyncTime: new Date(now).toISOString() },
});
} catch (syncError) {
Sentry.captureException(syncError, {
tags: {
module: "headless-task",
operation: "force-sync",
eventName: name,
},
contexts: {
syncAttempt: {
timeSinceLastSync: timeSinceLastSync,
lastSyncTime: new Date(lastSyncTime).toISOString(),
},
},
});
geolocBgLogger.error("Force sync failed", { error: syncError });
}
} else {
Sentry.addBreadcrumb({
message: "Force sync not needed",
category: "headless-task",
level: "info",
data: {
timeSinceLastSyncHours: (
timeSinceLastSync /
(1000 * 60 * 60)
).toFixed(2),
nextSyncInHours: (
(FORCE_SYNC_INTERVAL - timeSinceLastSync) /
(1000 * 60 * 60)
).toFixed(2),
},
});
}
break;
case "location":
// Validate location parameters
if (!params || typeof params !== "object") {
geolocBgLogger.warn("Invalid location params", { params });
break;
}
Sentry.addBreadcrumb({
message: "Location update received",
category: "headless-task",
level: "info",
data: {
coords: params.location?.coords,
activity: params.location?.activity,
hasLocation: !!params.location,
},
});
geolocBgLogger.debug("Location update received", {
location: params.location,
});
break;
case "http":
// Validate HTTP parameters
if (!params || typeof params !== "object" || !params.response) {
geolocBgLogger.warn("Invalid HTTP params", { params });
break;
}
const httpStatus = params.response?.status;
const isHttpSuccess = httpStatus === 200;
Sentry.addBreadcrumb({
message: "HTTP response received",
category: "headless-task",
level: isHttpSuccess ? "info" : "warning",
data: {
status: httpStatus,
success: params.response?.success,
hasResponse: !!params.response,
},
});
geolocBgLogger.debug("HTTP response received", {
response: params.response,
});
// Update last sync time on successful HTTP response
if (params.response?.status === 200) {
lastSyncTime = Date.now();
if (isHttpSuccess) {
try {
const now = Date.now();
await setLastSyncTime(now);
Sentry.addBreadcrumb({
message: "Last sync time updated (HTTP success)",
category: "headless-task",
level: "info",
data: { newSyncTime: new Date(now).toISOString() },
});
} catch (syncTimeError) {
geolocBgLogger.error("Failed to update sync time", {
error: syncTimeError,
});
Sentry.captureException(syncTimeError, {
tags: {
module: "headless-task",
operation: "update-sync-time-http",
},
});
}
}
break;
default:
Sentry.addBreadcrumb({
message: "Unknown event type",
category: "headless-task",
level: "warning",
data: { eventName: name },
});
}
// Finish transaction successfully
if (transaction) {
transaction.setStatus("ok");
}
} catch (error) {
geolocBgLogger.error("HeadlessTask error", { error });
// Capture any unexpected errors
Sentry.captureException(error, {
tags: {
module: "headless-task",
eventName: event?.name || "unknown",
},
});
geolocBgLogger.error("HeadlessTask error", { error, event });
// Mark transaction as failed
if (transaction) {
transaction.setStatus("internal_error");
}
} finally {
// Clear the timeout
clearTimeout(taskTimeout);
// Always finish the transaction
if (transaction) {
transaction.finish();
}
geolocBgLogger.debug("HeadlessTask completed", { event: event?.name });
}
};
let headlessTaskRegistered = false;
if (!headlessTaskRegistered) {
BackgroundGeolocation.registerHeadlessTask(HeadlessTask);
headlessTaskRegistered = true;
}

1
package.json
View file

@ -174,6 +174,7 @@
"react-native-app-link": "^1.0.1",
"react-native-background-fetch": "^4.2.7",
"react-native-background-geolocation": "^4.18.6",
"react-native-battery-optimization-check": "^1.0.8",
"react-native-contact-pick": "^0.1.2",
"react-native-country-picker-modal": "^2.0.0",
"react-native-device-country": "^1.0.5",

80
src/containers/PermissionWizard/HeroMode.js
View file

@ -2,6 +2,10 @@ import React, { useState, useCallback, useEffect } from "react";
import { View, StyleSheet, Image, ScrollView, Platform } from "react-native";
import { Title } from "react-native-paper";
import { Ionicons, Entypo } from "@expo/vector-icons";
import {
RequestDisableOptimization,
BatteryOptEnabled,
} from "react-native-battery-optimization-check";
import {
permissionsActions,
usePermissionsState,
@ -30,6 +34,9 @@ const HeroMode = () => {
const [requesting, setRequesting] = useState(false);
const [hasAttempted, setHasAttempted] = useState(false);
const [hasRetried, setHasRetried] = useState(false);
const [batteryOptimizationEnabled, setBatteryOptimizationEnabled] =
useState(null);
const [batteryOptAttempted, setBatteryOptAttempted] = useState(false);
const permissions = usePermissionsState(["locationBackground", "motion"]);
const theme = useTheme();
@ -60,8 +67,24 @@ const HeroMode = () => {
const locationGranted = await requestPermissionLocationBackground();
permissionsActions.setLocationBackground(locationGranted);
// If both granted, move to success
if (locationGranted && motionGranted) {
// Check and request battery optimization disable (Android only)
let batteryOptDisabled = true;
if (Platform.OS === "android") {
try {
const isEnabled = await BatteryOptEnabled();
setBatteryOptimizationEnabled(isEnabled);
if (isEnabled) {
RequestDisableOptimization();
batteryOptDisabled = false;
}
setBatteryOptAttempted(true);
} catch (error) {
console.error("Error checking battery optimization:", error);
}
}
// If all permissions granted and battery optimization handled, move to success
if (locationGranted && motionGranted && batteryOptDisabled) {
permissionWizardActions.setHeroPermissionsGranted(true);
permissionWizardActions.setCurrentStep("success");
}
@ -73,11 +96,23 @@ const HeroMode = () => {
}, []);
const handleRetry = useCallback(async () => {
// Re-check battery optimization status before retrying
if (Platform.OS === "android") {
try {
const isEnabled = await BatteryOptEnabled();
setBatteryOptimizationEnabled(isEnabled);
} catch (error) {
console.error("Error re-checking battery optimization:", error);
}
}
await handleRequestPermissions();
setHasRetried(true);
}, [handleRequestPermissions]);
const allGranted = permissions.locationBackground && permissions.motion;
const allGranted =
permissions.locationBackground &&
permissions.motion &&
(Platform.OS === "ios" || !batteryOptimizationEnabled);
useEffect(() => {
if (hasAttempted && allGranted) {
@ -99,6 +134,15 @@ const HeroMode = () => {
"Sans la localisation en arrière-plan, vous ne pourrez pas être alerté des situations d'urgence à proximité lorsque l'application est fermée.",
);
}
if (
Platform.OS === "android" &&
batteryOptimizationEnabled &&
batteryOptAttempted
) {
warnings.push(
"L'optimisation de la batterie est encore activée. L'application pourrait ne pas fonctionner correctement en arrière-plan.",
);
}
return warnings.length > 0 ? (
<View style={styles.warningsContainer}>
{warnings.map((warning, index) => (
@ -140,6 +184,22 @@ const HeroMode = () => {
version d'Android)
</Text>
</View>
{batteryOptimizationEnabled && batteryOptAttempted && (
<View style={styles.androidWarningSteps}>
<Text style={styles.androidWarningText}>
Pour désactiver l'optimisation de la batterie :
</Text>
<Text style={styles.androidWarningStep}>
4. Recherchez "Batterie" ou "Optimisation de la batterie"
</Text>
<Text style={styles.androidWarningStep}>
5. Trouvez cette application dans la liste
</Text>
<Text style={styles.androidWarningStep}>
6. Sélectionnez "Ne pas optimiser" ou "Désactiver l'optimisation"
</Text>
</View>
)}
<CustomButton
mode="outlined"
onPress={openSettings}
@ -295,6 +355,20 @@ const HeroMode = () => {
donnée de mouvement n'est stockée ni transmise.
</Text>
</View>
{Platform.OS === "android" && (
<View style={styles.permissionItem}>
<Ionicons
name="battery-charging"
size={24}
style={styles.icon}
/>
<Text style={styles.permissionText}>
Optimisation de la batterie : désactiver l'optimisation de
la batterie pour cette application afin qu'elle puisse
fonctionner correctement en arrière-plan.
</Text>
</View>
)}
</View>
</View>

104
src/location/trackLocation.js
View file

@ -4,6 +4,7 @@ import { createLogger } from "~/lib/logger";
import { BACKGROUND_SCOPES } from "~/lib/logger/scopes";
import jwtDecode from "jwt-decode";
import { initEmulatorMode } from "./emulatorService";
import * as Sentry from "@sentry/react-native";
import throttle from "lodash.throttle";
@ -32,6 +33,7 @@ const config = {
locationAuthorizationRequest: "Always",
stopOnTerminate: false,
startOnBoot: true,
heartbeatInterval: 60, // DEBUGGING
// Force the plugin to start aggressively
foregroundService: true,
notification: {
@ -167,6 +169,20 @@ export default async function trackLocation() {
activity: location.activity,
battery: location.battery,
});
// Add Sentry breadcrumb for location updates
Sentry.addBreadcrumb({
message: "Location update in trackLocation",
category: "geolocation",
level: "info",
data: {
coords: location.coords,
activity: location.activity?.type,
battery: location.battery?.level,
isMoving: location.isMoving,
},
});
if (
location.coords &&
location.coords.latitude &&
@ -203,6 +219,20 @@ export default async function trackLocation() {
response?.request?.headers || "Headers not available in response",
});
// Add Sentry breadcrumb for HTTP responses
Sentry.addBreadcrumb({
message: "Background geolocation HTTP response",
category: "geolocation-http",
level: response?.status === 200 ? "info" : "warning",
data: {
status: response?.status,
success: response?.success,
url: response?.url,
isSync: response?.isSync,
recordCount: response?.count,
},
});
// Log the current auth token for comparison
const { userToken } = getAuthState();
locationLogger.debug("Current auth state token", {
@ -216,6 +246,11 @@ export default async function trackLocation() {
case 410:
// Token expired, logout
locationLogger.info("Auth token expired (410), logging out");
Sentry.addBreadcrumb({
message: "Auth token expired - logging out",
category: "geolocation-auth",
level: "warning",
});
authActions.logout();
break;
case 401:
@ -233,6 +268,16 @@ export default async function trackLocation() {
errorMessage: errorBody?.error?.message,
errorPath: errorBody?.error?.errors?.[0]?.path,
});
Sentry.addBreadcrumb({
message: "Unauthorized - refreshing token",
category: "geolocation-auth",
level: "warning",
data: {
errorType: errorBody?.error?.type,
errorMessage: errorBody?.error?.message,
},
});
} catch (e) {
locationLogger.debug("Failed to parse error response", {
error: e.message,
@ -291,8 +336,21 @@ export default async function trackLocation() {
const count = await BackgroundGeolocation.getCount();
locationLogger.debug("Pending location records", { count });
Sentry.addBreadcrumb({
message: "Checking pending location records",
category: "geolocation",
level: "info",
data: { pendingCount: count },
});
if (count > 0) {
locationLogger.info(`Found ${count} pending records, forcing sync`);
const transaction = Sentry.startTransaction({
name: "force-sync-pending-records",
op: "geolocation-sync",
});
try {
const { userToken } = getAuthState();
const state = await BackgroundGeolocation.getState();
@ -301,18 +359,64 @@ export default async function trackLocation() {
locationLogger.debug("Forced sync result", {
recordsCount: records?.length || 0,
});
Sentry.addBreadcrumb({
message: "Forced sync completed",
category: "geolocation",
level: "info",
data: {
recordsCount: records?.length || 0,
hadToken: true,
wasEnabled: true,
},
});
transaction.setStatus("ok");
} else {
Sentry.addBreadcrumb({
message: "Forced sync skipped",
category: "geolocation",
level: "warning",
data: {
hasToken: !!userToken,
isEnabled: state.enabled,
},
});
transaction.setStatus("cancelled");
}
} catch (error) {
locationLogger.error("Forced sync failed", {
error: error,
stack: error.stack,
});
Sentry.captureException(error, {
tags: {
module: "track-location",
operation: "force-sync-pending",
},
contexts: {
pendingRecords: { count },
},
});
transaction.setStatus("internal_error");
} finally {
transaction.finish();
}
}
} catch (error) {
locationLogger.error("Failed to get pending records count", {
error: error.message,
});
Sentry.captureException(error, {
tags: {
module: "track-location",
operation: "check-pending-records",
},
});
}
}

337
src/notifications/autoCancelExpired.js
View file

@ -1,17 +1,186 @@
import notifee from "@notifee/react-native";
import BackgroundFetch from "react-native-background-fetch";
import * as Sentry from "@sentry/react-native";
import useMount from "~/hooks/useMount";
import { createLogger } from "~/lib/logger";
const logger = createLogger({
service: "notifications",
task: "auto-cancel-expired",
});
// Background task to cancel expired notifications
const backgroundTask = async () => {
const notifications = await notifee.getDisplayedNotifications();
const currentTime = Math.round(new Date() / 1000);
for (const notification of notifications) {
const expires = notification.data?.expires;
if (expires && expires < currentTime) {
await notifee.cancelNotification(notification.id);
const transaction = Sentry.startTransaction({
name: "auto-cancel-expired-notifications",
op: "background-task",
});
Sentry.getCurrentScope().setSpan(transaction);
try {
logger.info("Starting auto-cancel expired notifications task");
Sentry.addBreadcrumb({
message: "Auto-cancel task started",
category: "notifications",
level: "info",
});
// Get displayed notifications with timeout protection
const getNotificationsSpan = transaction.startChild({
op: "get-displayed-notifications",
description: "Getting displayed notifications",
});
let notifications;
try {
// Add timeout protection for the API call
notifications = await Promise.race([
notifee.getDisplayedNotifications(),
new Promise((_, reject) =>
setTimeout(
() => reject(new Error("Timeout getting notifications")),
10000,
),
),
]);
getNotificationsSpan.setStatus("ok");
} catch (error) {
getNotificationsSpan.setStatus("internal_error");
throw error;
} finally {
getNotificationsSpan.finish();
}
if (!Array.isArray(notifications)) {
logger.warn("No notifications array received", { notifications });
Sentry.addBreadcrumb({
message: "No notifications array received",
category: "notifications",
level: "warning",
});
return;
}
const currentTime = Math.round(new Date() / 1000);
let cancelledCount = 0;
let errorCount = 0;
logger.info("Processing notifications", {
totalNotifications: notifications.length,
currentTime,
});
Sentry.addBreadcrumb({
message: "Processing notifications",
category: "notifications",
level: "info",
data: {
totalNotifications: notifications.length,
currentTime,
},
});
// Process notifications with individual error handling
for (const notification of notifications) {
try {
if (!notification || !notification.id) {
logger.warn("Invalid notification object", { notification });
continue;
}
const expires = notification.data?.expires;
if (!expires) {
continue; // Skip notifications without expiry
}
if (typeof expires !== "number" || expires < currentTime) {
logger.debug("Cancelling expired notification", {
notificationId: notification.id,
expires,
currentTime,
expired: expires < currentTime,
});
// Cancel notification with timeout protection
await Promise.race([
notifee.cancelNotification(notification.id),
new Promise((_, reject) =>
setTimeout(
() => reject(new Error("Timeout cancelling notification")),
5000,
),
),
]);
cancelledCount++;
Sentry.addBreadcrumb({
message: "Notification cancelled",
category: "notifications",
level: "info",
data: {
notificationId: notification.id,
expires,
},
});
}
} catch (notificationError) {
errorCount++;
logger.error("Failed to process notification", {
error: notificationError,
notificationId: notification?.id,
});
Sentry.captureException(notificationError, {
tags: {
module: "auto-cancel-expired",
operation: "cancel-notification",
},
contexts: {
notification: {
id: notification?.id,
expires: notification?.data?.expires,
},
},
});
}
}
logger.info("Auto-cancel task completed", {
totalNotifications: notifications.length,
cancelledCount,
errorCount,
});
Sentry.addBreadcrumb({
message: "Auto-cancel task completed",
category: "notifications",
level: "info",
data: {
totalNotifications: notifications.length,
cancelledCount,
errorCount,
},
});
transaction.setStatus("ok");
} catch (error) {
logger.error("Auto-cancel task failed", { error });
Sentry.captureException(error, {
tags: {
module: "auto-cancel-expired",
operation: "background-task",
},
});
transaction.setStatus("internal_error");
throw error; // Re-throw to be handled by caller
} finally {
transaction.finish();
}
};
@ -27,12 +196,61 @@ export const useAutoCancelExpired = () => {
enableHeadless: true,
},
async (taskId) => {
console.log("[BackgroundFetch] taskId:", taskId);
logger.info("BackgroundFetch task started", { taskId });
try {
await backgroundTask();
logger.info("BackgroundFetch task completed successfully", {
taskId,
});
} catch (error) {
logger.error("BackgroundFetch task failed", { taskId, error });
Sentry.captureException(error, {
tags: {
module: "auto-cancel-expired",
operation: "background-fetch-task",
taskId,
},
});
} finally {
// CRITICAL: Always call finish, even on error
try {
if (taskId) {
BackgroundFetch.finish(taskId);
logger.debug("BackgroundFetch task finished", { taskId });
} else {
logger.error("Cannot finish BackgroundFetch task - no taskId");
}
} catch (finishError) {
// This is a critical error - the native side might be in a bad state
logger.error("CRITICAL: BackgroundFetch.finish() failed", {
taskId,
error: finishError,
});
Sentry.captureException(finishError, {
tags: {
module: "auto-cancel-expired",
operation: "background-fetch-finish",
critical: true,
},
contexts: {
task: { taskId },
},
});
}
}
},
(error) => {
console.log("[BackgroundFetch] failed to start", error);
logger.error("BackgroundFetch failed to start", { error });
Sentry.captureException(error, {
tags: {
module: "auto-cancel-expired",
operation: "background-fetch-configure",
},
});
},
);
return () => {
@ -43,7 +261,104 @@ export const useAutoCancelExpired = () => {
// Register headless task
BackgroundFetch.registerHeadlessTask(async (event) => {
const taskId = event.taskId;
await backgroundTask();
BackgroundFetch.finish(taskId);
const taskId = event?.taskId;
logger.info("Headless task started", { taskId, event });
// Add timeout protection for the entire headless task
const taskTimeout = setTimeout(() => {
logger.error("Headless task timeout", { taskId });
Sentry.captureException(new Error("Headless task timeout"), {
tags: {
module: "auto-cancel-expired",
operation: "headless-task-timeout",
taskId,
},
});
// Force finish the task to prevent native side hanging
try {
if (taskId) {
BackgroundFetch.finish(taskId);
logger.debug("Headless task force-finished due to timeout", { taskId });
}
} catch (finishError) {
logger.error("CRITICAL: Failed to force-finish timed out headless task", {
taskId,
error: finishError,
});
Sentry.captureException(finishError, {
tags: {
module: "auto-cancel-expired",
operation: "headless-task-timeout-finish",
critical: true,
},
contexts: {
task: { taskId },
},
});
}
}, 30000); // 30 second timeout
try {
if (!taskId) {
throw new Error("No taskId provided in headless task event");
}
await backgroundTask();
logger.info("Headless task completed successfully", { taskId });
} catch (error) {
logger.error("Headless task failed", { taskId, error });
Sentry.captureException(error, {
tags: {
module: "auto-cancel-expired",
operation: "headless-task",
taskId,
},
contexts: {
event: {
taskId,
eventData: JSON.stringify(event),
},
},
});
} finally {
// Clear the timeout
clearTimeout(taskTimeout);
// CRITICAL: Always call finish, even on error
try {
if (taskId) {
BackgroundFetch.finish(taskId);
logger.debug("Headless task finished", { taskId });
} else {
logger.error("Cannot finish headless task - no taskId", { event });
}
} catch (finishError) {
// This is a critical error - the native side might be in a bad state
logger.error(
"CRITICAL: BackgroundFetch.finish() failed in headless task",
{
taskId,
error: finishError,
event,
},
);
Sentry.captureException(finishError, {
tags: {
module: "auto-cancel-expired",
operation: "headless-task-finish",
critical: true,
},
contexts: {
task: { taskId },
event: { eventData: JSON.stringify(event) },
},
});
}
}
});

11
yarn.lock
View file

@ -6565,6 +6565,7 @@ __metadata:
react-native-app-link: "npm:^1.0.1"
react-native-background-fetch: "npm:^4.2.7"
react-native-background-geolocation: "npm:^4.18.6"
react-native-battery-optimization-check: "npm:^1.0.8"
react-native-clean-project: "npm:^4.0.3"
react-native-contact-pick: "npm:^0.1.2"
react-native-country-picker-modal: "npm:^2.0.0"
@ -15978,6 +15979,16 @@ __metadata:
languageName: node
linkType: hard
"react-native-battery-optimization-check@npm:^1.0.8":
version: 1.0.8
resolution: "react-native-battery-optimization-check@npm:1.0.8"
peerDependencies:
react: "*"
react-native: ">=0.63.3"
checksum: 10/e79219cc9e9a7521b5dda2cf2f0b806f5f510aca7c62d8d654c84b07a829b19063fe4839bcedd90a5574b6c28b20a3388f0a62e1d9912310e77e5919521a563f
languageName: node
linkType: hard
"react-native-clean-project@npm:^4.0.3":
version: 4.0.3
resolution: "react-native-clean-project@npm:4.0.3"