Skip to content

Job application tracker and AI-powered job search assistant. Helps job seekers manage their search journey with AI resume review, job matching, task logging, and application analytics, all while keeping your data private.

Make activity timer banner global

Khuram Niazcc8eb36a157c
diff --git a/__tests__/ActivitiesContainer.spec.tsx b/__tests__/ActivitiesContainer.spec.tsx
index 84a9f7a..282d3b7 100644
--- a/__tests__/ActivitiesContainer.spec.tsx
+++ b/__tests__/ActivitiesContainer.spec.tsx
@@ -1,4 +1,5 @@
import ActivitiesContainer from "@/components/activities/ActivitiesContainer";
+import { ActivityProvider } from "@/context/ActivityContext";
import "@testing-library/jest-dom";
import { screen, render, waitFor, act } from "@testing-library/react";
import userEvent from "@testing-library/user-event";
@@ -128,7 +129,11 @@ describe("ActivitiesContainer Search Functionality", () => {
});
const renderComponent = () => {
- return render(<ActivitiesContainer />);
+ return render(
+ <ActivityProvider>
+ <ActivitiesContainer />
+ </ActivityProvider>
+ );
};
describe("Search Input", () => {
diff --git a/__tests__/TasksContainer.spec.tsx b/__tests__/TasksContainer.spec.tsx
index 7860316..53049f3 100644
--- a/__tests__/TasksContainer.spec.tsx
+++ b/__tests__/TasksContainer.spec.tsx
@@ -11,6 +11,7 @@ import {
} from "@/actions/task.actions";
import { Task } from "@/models/task.model";
import { useRouter } from "next/navigation";
+import { useActivity } from "@/context/ActivityContext";
jest.mock("next-auth", () => {
const mockAuth = jest.fn();
@@ -54,6 +55,12 @@ jest.mock("next/navigation", () => ({
useRouter: jest.fn(),
}));
+jest.mock("@/context/ActivityContext", () => ({
+ useActivity: jest.fn(() => ({
+ refreshCurrentActivity: jest.fn(),
+ })),
+}));
+
global.ResizeObserver = jest.fn().mockImplementation(() => ({
observe: jest.fn(),
unobserve: jest.fn(),
@@ -93,6 +100,8 @@ describe("TasksContainer Component", () => {
prefetch: jest.fn(),
};
+ const mockRefreshCurrentActivity = jest.fn();
+
const mockActivityTypes = [
{
id: "type-1",
@@ -162,6 +171,9 @@ describe("TasksContainer Component", () => {
beforeEach(() => {
jest.clearAllMocks();
(useRouter as jest.Mock).mockReturnValue(mockRouter);
+ (useActivity as jest.Mock).mockReturnValue({
+ refreshCurrentActivity: mockRefreshCurrentActivity,
+ });
});
describe("Initial Load", () => {
@@ -436,7 +448,7 @@ describe("TasksContainer Component", () => {
await waitFor(() => {
expect(startActivityFromTask).toHaveBeenCalledWith("task-1");
- expect(mockRouter.push).toHaveBeenCalledWith("/dashboard/activities");
+ expect(mockRefreshCurrentActivity).toHaveBeenCalled();
});
});
@@ -451,7 +463,7 @@ describe("TasksContainer Component", () => {
await waitFor(() => {
expect(startActivityFromTask).toHaveBeenCalledWith("task-1");
- expect(mockRouter.push).not.toHaveBeenCalled();
+ expect(mockRefreshCurrentActivity).not.toHaveBeenCalled();
});
});
});
diff --git a/__tests__/TasksPageClient.spec.tsx b/__tests__/TasksPageClient.spec.tsx
index 7681df7..b01a51b 100644
--- a/__tests__/TasksPageClient.spec.tsx
+++ b/__tests__/TasksPageClient.spec.tsx
@@ -49,6 +49,12 @@ jest.mock("next/navigation", () => ({
}),
}));
+jest.mock("@/context/ActivityContext", () => ({
+ useActivity: jest.fn(() => ({
+ refreshCurrentActivity: jest.fn(),
+ })),
+}));
+
global.ResizeObserver = jest.fn().mockImplementation(() => ({
observe: jest.fn(),
unobserve: jest.fn(),
diff --git a/src/actions/activity.actions.ts b/src/actions/activity.actions.ts
index 56355d1..ddd55f9 100644
--- a/src/actions/activity.actions.ts
+++ b/src/actions/activity.actions.ts
@@ -187,6 +187,21 @@ export const startActivityById = async (
throw new Error("Not authenticated");
}
+ // Check for existing active activity to prevent concurrent activities
+ const existingActive = await prisma.activity.findFirst({
+ where: {
+ userId: user.id,
+ endTime: null,
+ },
+ });
+
+ if (existingActive) {
+ return {
+ success: false,
+ message: "An activity is already in progress. Stop it before starting a new one.",
+ };
+ }
+
const activity = await prisma.activity.findFirst({
where: {
id: activityId,
@@ -249,7 +264,7 @@ export const stopActivityById = async (
});
return { activity, success: true };
} catch (error) {
- const msg = "Failed to start activity. ";
+ const msg = "Failed to stop activity. ";
return handleError(error, msg);
}
};
diff --git a/src/app/dashboard/layout.tsx b/src/app/dashboard/layout.tsx
index 99853d5..300c4fe 100644
--- a/src/app/dashboard/layout.tsx
+++ b/src/app/dashboard/layout.tsx
@@ -1,6 +1,8 @@
import Header from "@/components/Header";
import Sidebar from "@/components/Sidebar";
import { Toaster } from "@/components/ui/toaster";
+import { ActivityProvider } from "@/context/ActivityContext";
+import { GlobalActivityBanner } from "@/components/activities/GlobalActivityBanner";
export default function RootLayout({
children,
@@ -8,15 +10,18 @@ export default function RootLayout({
children: React.ReactNode;
}>) {
return (
- <div className="flex min-h-screen w-full flex-col bg-muted/40">
- <Sidebar />
- <div className="flex flex-1 flex-col sm:gap-4 sm:py-4 sm:pl-14">
- <Header />
- <main className="flex-1 md:block lg:grid items-start gap-4 p-4 sm:px-6 sm:py-0 md:gap-4 lg:grid-cols-3 xl:grid-cols-3">
- {children}
- </main>
- <Toaster />
+ <ActivityProvider>
+ <div className="flex min-h-screen w-full flex-col bg-muted/40">
+ <Sidebar />
+ <div className="flex flex-1 flex-col sm:gap-4 sm:py-4 sm:pl-14">
+ <Header />
+ <GlobalActivityBanner />
+ <main className="flex-1 md:block lg:grid items-start gap-4 p-4 sm:px-6 sm:py-0 md:gap-4 lg:grid-cols-3 xl:grid-cols-3">
+ {children}
+ </main>
+ <Toaster />
+ </div>
</div>
- </div>
+ </ActivityProvider>
);
}
diff --git a/src/components/activities/ActivitiesContainer.tsx b/src/components/activities/ActivitiesContainer.tsx
index 728dfa3..8e855b1 100644
--- a/src/components/activities/ActivitiesContainer.tsx
+++ b/src/components/activities/ActivitiesContainer.tsx
@@ -13,46 +13,31 @@ import {
DialogTrigger,
} from "../ui/dialog";
import { ActivityForm } from "./ActivityForm";
-import {
- getActivitiesList,
- getCurrentActivity,
- startActivityById,
- stopActivityById,
-} from "@/actions/activity.actions";
-import { Activity, ActivityType } from "@/models/activity.model";
+import { getActivitiesList } from "@/actions/activity.actions";
+import { Activity } from "@/models/activity.model";
import { toast } from "../ui/use-toast";
import Loading from "../Loading";
-import { ActivityBanner } from "./ActivityBanner";
-import { differenceInMinutes } from "date-fns";
import { APP_CONSTANTS } from "@/lib/constants";
import { RecordsPerPageSelector } from "../RecordsPerPageSelector";
import { RecordsCount } from "../RecordsCount";
+import { useActivity } from "@/context/ActivityContext";
function ActivitiesContainer() {
const [activityFormOpen, setActivityFormOpen] = useState<boolean>(false);
const [activitiesList, setActivitiesList] = useState<Activity[]>([]);
- const [currentActivity, setCurrentActivity] = useState<Activity>();
- const [timeElapsed, setTimeElapsed] = useState<number>(0);
- const timerRef = useRef<NodeJS.Timeout | null>(null);
const [page, setPage] = useState<number>(1);
const [totalActivities, setTotalActivities] = useState<number>(0);
const [loading, setLoading] = useState(false);
const [recordsPerPage, setRecordsPerPage] = useState<number>(
- APP_CONSTANTS.RECORDS_PER_PAGE,
+ APP_CONSTANTS.RECORDS_PER_PAGE
);
const [searchTerm, setSearchTerm] = useState("");
const hasSearched = useRef(false);
- const closeActivityForm = () => setActivityFormOpen(false);
+ const { currentActivity, startActivity } = useActivity();
+ const prevActivityRef = useRef<Activity | undefined>(undefined);
- const stopTimer = useCallback(() => {
- // Clear the timer and reset elapsed time
- if (timerRef.current) {
- clearInterval(timerRef.current);
- timerRef.current = null;
- }
- setTimeElapsed(0);
- }, []);
+ const closeActivityForm = () => setActivityFormOpen(false);
const loadActivities = useCallback(
async (page: number, limit: number, search?: string) => {
@@ -91,118 +76,24 @@ function ActivitiesContainer() {
await loadActivities(1, recordsPerPage, searchTerm || undefined);
}, [loadActivities, recordsPerPage, searchTerm]);
- const stopActivity = useCallback(
- async (autoStop: boolean = false) => {
- if (!currentActivity) return;
- const now = new Date();
- const maxDurationMinutes =
- APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS / (1000 * 60);
- const duration = Math.min(
- differenceInMinutes(now, currentActivity.startTime),
- maxDurationMinutes
- );
- const { success, message } = await stopActivityById(
- currentActivity.id!,
- now,
- duration
- );
- if (success) {
- stopTimer();
- setCurrentActivity(undefined);
- reloadActivities();
- toast({
- variant: "success",
- description: autoStop
- ? `Activity auto-stopped after reaching maximum duration of ${
- maxDurationMinutes / 60
- } hours`
- : "Activity stopped successfully",
- });
- } else {
- toast({
- variant: "destructive",
- title: "Error!",
- description: message,
- });
- }
- },
- [currentActivity, reloadActivities, stopTimer]
- );
-
- const startTimer = useCallback(
- (startTime: number) => {
- const initialElapsed = Date.now() - startTime;
-
- // Check if the initial elapsed time already exceeds the MAX duration
- if (initialElapsed >= APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS) {
- setTimeout(() => stopActivity(true), 0);
- return;
- }
-
- stopTimer(); // Clear any existing timer to avoid duplicates
- setTimeElapsed(initialElapsed);
-
- // Start the interval timer
- timerRef.current = setInterval(() => {
- setTimeElapsed((prev) => {
- const newElapsed = prev + 1000;
- if (newElapsed >= APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS) {
- clearInterval(timerRef.current!);
- timerRef.current = null;
- setTimeout(() => stopActivity(true), 0);
- return APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS;
- }
- return newElapsed;
- });
- }, 1000);
- },
- [stopActivity, stopTimer]
- );
-
- const startActivity = async (activityId: string) => {
- const { newActivity, success, message } = await startActivityById(
- activityId
- );
- if (success && newActivity) {
- setCurrentActivity(newActivity as Activity);
- // startTimer(newActivity.startTime); // this happens in useeffect upon currentActivity change
- toast({
- variant: "success",
- description: "Activity started successfully",
- });
- } else {
- toast({
- variant: "destructive",
- title: "Error!",
- description: message,
- });
+ const handleStartActivity = async (activityId: string) => {
+ const success = await startActivity(activityId);
+ if (success) {
+ reloadActivities();
}
};
- const fetchActiveActivity = useCallback(async () => {
- const { activity, success } = await getCurrentActivity();
- if (success && activity) {
- setCurrentActivity(activity);
- startTimer(activity.startTime.getTime());
- }
- }, [startTimer]);
-
useEffect(() => {
- const init = async () => {
- await Promise.all([loadActivities(1, recordsPerPage), fetchActiveActivity()]);
- };
- init();
- return () => {
- stopTimer(); // Cleanup the timer on unmount
- };
- // eslint-disable-next-line react-hooks/exhaustive-deps
- }, [recordsPerPage]);
+ loadActivities(1, recordsPerPage);
+ }, [loadActivities, recordsPerPage]);
+ // Reload activities when an activity is stopped (via global banner or otherwise)
useEffect(() => {
- if (currentActivity) {
- startTimer(currentActivity.startTime.getTime());
+ if (prevActivityRef.current && !currentActivity) {
+ reloadActivities();
}
- }, [currentActivity, startTimer]);
+ prevActivityRef.current = currentActivity;
+ }, [currentActivity, reloadActivities]);
// Debounced search effect
useEffect(() => {
@@ -234,50 +125,41 @@ function ActivitiesContainer() {
/>
</div>
<Dialog open={activityFormOpen} onOpenChange={setActivityFormOpen}>
- <DialogTrigger asChild>
- <Button
- size="sm"
- variant="outline"
- className="h-8 gap-1"
- data-testid="add-activity-btn"
- >
- <PlusCircle className="h-3.5 w-3.5" />
- <span className="sr-only sm:not-sr-only sm:whitespace-nowrap">
- Add Activity
- </span>
- </Button>
- </DialogTrigger>
- <DialogContent className="sm:max-w-[725px] max-h-[90vh] overflow-y-auto">
- <DialogHeader>
- <DialogTitle>Add New Activity</DialogTitle>
- </DialogHeader>
- <div className="p-4">
- <ActivityForm
- onClose={closeActivityForm}
- reloadActivities={reloadActivities}
- />
- </div>
- </DialogContent>
+ <DialogTrigger asChild>
+ <Button
+ size="sm"
+ variant="outline"
+ className="h-8 gap-1"
+ data-testid="add-activity-btn"
+ >
+ <PlusCircle className="h-3.5 w-3.5" />
+ <span className="sr-only sm:not-sr-only sm:whitespace-nowrap">
+ Add Activity
+ </span>
+ </Button>
+ </DialogTrigger>
+ <DialogContent className="sm:max-w-[725px] max-h-[90vh] overflow-y-auto">
+ <DialogHeader>
+ <DialogTitle>Add New Activity</DialogTitle>
+ </DialogHeader>
+ <div className="p-4">
+ <ActivityForm
+ onClose={closeActivityForm}
+ reloadActivities={reloadActivities}
+ />
+ </div>
+ </DialogContent>
</Dialog>
</div>
</CardHeader>
<CardContent>
{loading && <Loading />}
- {currentActivity && (
- <ActivityBanner
- message={`${
- (currentActivity.activityType as ActivityType)?.label
- } - ${currentActivity.activityName}`}
- onStopActivity={stopActivity}
- elapsedTime={timeElapsed}
- />
- )}
{activitiesList.length > 0 && (
<>
<ActivitiesTable
activities={activitiesList}
reloadActivities={reloadActivities}
- onStartActivity={startActivity}
+ onStartActivity={handleStartActivity}
activityExist={Boolean(currentActivity)}
/>
<div className="flex items-center justify-between mt-4">
@@ -300,7 +182,9 @@ function ActivitiesContainer() {
<Button
size="sm"
variant="outline"
- onClick={() => loadActivities(page + 1, recordsPerPage, searchTerm || undefined)}
+ onClick={() =>
+ loadActivities(page + 1, recordsPerPage, searchTerm || undefined)
+ }
disabled={loading}
className="btn btn-primary"
>
diff --git a/src/components/activities/ActivityBanner.tsx b/src/components/activities/ActivityBanner.tsx
index 3abcdb2..4dfca51 100644
--- a/src/components/activities/ActivityBanner.tsx
+++ b/src/components/activities/ActivityBanner.tsx
@@ -37,9 +37,9 @@ export function ActivityBanner({
return (
<div
className={cn(
- "flex items-center gap-3 px-4 py-3 border rounded-lg mb-4",
+ "flex items-center gap-3 px-4 py-1 border rounded-lg",
variantStyles[variant],
- className
+ className,
)}
>
<div className="flex-shrink-0">{variantIcons[variant]}</div>
@@ -56,7 +56,7 @@ export function ActivityBanner({
"focus:ring-yellow-500": variant === "warning",
"focus:ring-red-500": variant === "error",
"focus:ring-blue-500": variant === "info",
- }
+ },
)}
onClick={() => onStopActivity(false)}
>
diff --git a/src/components/activities/GlobalActivityBanner.tsx b/src/components/activities/GlobalActivityBanner.tsx
new file mode 100644
index 0000000..40f9699
--- /dev/null
+++ b/src/components/activities/GlobalActivityBanner.tsx
@@ -0,0 +1,23 @@
+"use client";
+import { useActivity } from "@/context/ActivityContext";
+import { ActivityBanner } from "./ActivityBanner";
+import { ActivityType } from "@/models/activity.model";
+
+export function GlobalActivityBanner() {
+ const { currentActivity, timeElapsed, stopActivity } = useActivity();
+
+ if (!currentActivity) return null;
+
+ const activityType = currentActivity.activityType as ActivityType;
+ const message = `${activityType?.label || "Activity"} - ${currentActivity.activityName}`;
+
+ return (
+ <div className="px-4 sm:px-6">
+ <ActivityBanner
+ message={message}
+ onStopActivity={stopActivity}
+ elapsedTime={timeElapsed}
+ />
+ </div>
+ );
+}
diff --git a/src/components/tasks/TasksContainer.tsx b/src/components/tasks/TasksContainer.tsx
index 4c39287..a8f96a2 100644
--- a/src/components/tasks/TasksContainer.tsx
+++ b/src/components/tasks/TasksContainer.tsx
@@ -41,10 +41,10 @@ import {
} from "../ui/dropdown-menu";
import { APP_CONSTANTS } from "@/lib/constants";
import Loading from "../Loading";
-import { useRouter } from "next/navigation";
import TasksTable from "./TasksTable";
import { TaskForm } from "./TaskForm";
import { ActivityType } from "@/models/activity.model";
+import { useActivity } from "@/context/ActivityContext";
type TasksContainerProps = {
activityTypes: ActivityType[];
@@ -61,7 +61,7 @@ function TasksContainer({
onFilterChange,
onTasksChanged,
}: TasksContainerProps) {
- const router = useRouter();
+ const { refreshCurrentActivity } = useActivity();
const [tasks, setTasks] = useState<Task[]>([]);
const [page, setPage] = useState(1);
const [totalTasks, setTotalTasks] = useState(0);
@@ -176,11 +176,11 @@ function TasksContainer({
const onStartActivity = async (taskId: string) => {
const { success, message } = await startActivityFromTask(taskId);
if (success) {
+ await refreshCurrentActivity();
toast({
variant: "success",
description: "Activity started from task",
});
- router.push("/dashboard/activities");
} else {
toast({
variant: "destructive",
diff --git a/src/context/ActivityContext.tsx b/src/context/ActivityContext.tsx
new file mode 100644
index 0000000..a57ddeb
--- /dev/null
+++ b/src/context/ActivityContext.tsx
@@ -0,0 +1,236 @@
+"use client";
+import {
+ createContext,
+ useContext,
+ useState,
+ useCallback,
+ useRef,
+ useEffect,
+ ReactNode,
+} from "react";
+import { differenceInMilliseconds, differenceInMinutes } from "date-fns";
+import {
+ getCurrentActivity,
+ startActivityById,
+ stopActivityById,
+} from "@/actions/activity.actions";
+import { Activity, ActivityType } from "@/models/activity.model";
+import { toast } from "@/components/ui/use-toast";
+import { APP_CONSTANTS } from "@/lib/constants";
+
+interface ActivityContextType {
+ currentActivity: Activity | undefined;
+ timeElapsed: number;
+ isLoading: boolean;
+ startActivity: (activityId: string) => Promise<boolean>;
+ stopActivity: (autoStop?: boolean) => Promise<boolean>;
+ refreshCurrentActivity: () => Promise<void>;
+}
+
+const ActivityContext = createContext<ActivityContextType | undefined>(
+ undefined
+);
+
+export function ActivityProvider({ children }: { children: ReactNode }) {
+ const [currentActivity, setCurrentActivity] = useState<Activity>();
+ const [timeElapsed, setTimeElapsed] = useState<number>(0);
+ const [isLoading, setIsLoading] = useState(false);
+ const timerRef = useRef<NodeJS.Timeout | null>(null);
+ const startTimeRef = useRef<number | null>(null);
+ const isMountedRef = useRef(true);
+
+ const stopTimer = useCallback(() => {
+ if (timerRef.current) {
+ clearInterval(timerRef.current);
+ timerRef.current = null;
+ }
+ startTimeRef.current = null;
+ setTimeElapsed(0);
+ }, []);
+
+ const startTimer = useCallback((startTime: Date) => {
+ stopTimer();
+
+ const startMs = startTime.getTime();
+ startTimeRef.current = startMs;
+ const now = Date.now();
+ const initialElapsed = differenceInMilliseconds(now, startMs);
+
+ if (initialElapsed >= APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS) {
+ return false; // Signal that auto-stop is needed
+ }
+
+ setTimeElapsed(initialElapsed);
+
+ timerRef.current = setInterval(() => {
+ if (!startTimeRef.current) return;
+
+ // Calculate elapsed from actual start time to avoid drift
+ const elapsed = differenceInMilliseconds(Date.now(), startTimeRef.current);
+
+ if (elapsed >= APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS) {
+ setTimeElapsed(APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS);
+ if (timerRef.current) {
+ clearInterval(timerRef.current);
+ timerRef.current = null;
+ }
+ return;
+ }
+
+ setTimeElapsed(elapsed);
+ }, 1000);
+
+ return true; // Timer started successfully
+ }, [stopTimer]);
+
+ const stopActivity = useCallback(
+ async (autoStop: boolean = false): Promise<boolean> => {
+ if (!currentActivity) return false;
+
+ const now = new Date();
+ const maxDurationMinutes =
+ APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS / (1000 * 60);
+ const duration = Math.min(
+ differenceInMinutes(now, currentActivity.startTime),
+ maxDurationMinutes
+ );
+
+ const { success, message } = await stopActivityById(
+ currentActivity.id!,
+ now,
+ duration
+ );
+
+ if (!isMountedRef.current) return success;
+
+ if (success) {
+ stopTimer();
+ setCurrentActivity(undefined);
+ toast({
+ variant: "success",
+ description: autoStop
+ ? `Activity auto-stopped after reaching maximum duration of ${maxDurationMinutes / 60} hours`
+ : "Activity stopped successfully",
+ });
+ return true;
+ } else {
+ toast({
+ variant: "destructive",
+ title: "Error!",
+ description: message,
+ });
+ return false;
+ }
+ },
+ [currentActivity, stopTimer]
+ );
+
+ const startActivity = useCallback(
+ async (activityId: string): Promise<boolean> => {
+ setIsLoading(true);
+ const { newActivity, success, message } = await startActivityById(activityId);
+
+ if (!isMountedRef.current) {
+ setIsLoading(false);
+ return success;
+ }
+
+ if (success && newActivity) {
+ setCurrentActivity(newActivity as Activity);
+ toast({
+ variant: "success",
+ description: "Activity started successfully",
+ });
+ setIsLoading(false);
+ return true;
+ } else {
+ toast({
+ variant: "destructive",
+ title: "Error!",
+ description: message,
+ });
+ setIsLoading(false);
+ return false;
+ }
+ },
+ []
+ );
+
+ const refreshCurrentActivity = useCallback(async () => {
+ const { activity, success } = await getCurrentActivity();
+ if (!isMountedRef.current) return;
+
+ if (success && activity) {
+ setCurrentActivity(activity);
+ } else {
+ setCurrentActivity(undefined);
+ stopTimer();
+ }
+ }, [stopTimer]);
+
+ // Handle timer when currentActivity changes
+ useEffect(() => {
+ if (currentActivity) {
+ const timerStarted = startTimer(currentActivity.startTime);
+ if (!timerStarted) {
+ // Activity exceeded max duration, auto-stop it
+ stopActivity(true);
+ }
+ } else {
+ stopTimer();
+ }
+ }, [currentActivity, startTimer, stopTimer, stopActivity]);
+
+ // Handle visibility change to sync timer when tab becomes visible
+ useEffect(() => {
+ const handleVisibilityChange = () => {
+ if (document.visibilityState === "visible" && currentActivity && startTimeRef.current) {
+ const elapsed = differenceInMilliseconds(Date.now(), startTimeRef.current);
+ if (elapsed >= APP_CONSTANTS.ACTIVITY_MAX_DURATION_MS) {
+ stopActivity(true);
+ } else {
+ setTimeElapsed(elapsed);
+ }
+ }
+ };
+
+ document.addEventListener("visibilitychange", handleVisibilityChange);
+ return () => {
+ document.removeEventListener("visibilitychange", handleVisibilityChange);
+ };
+ }, [currentActivity, stopActivity]);
+
+ // Fetch current activity on mount and cleanup
+ useEffect(() => {
+ isMountedRef.current = true;
+ refreshCurrentActivity();
+
+ return () => {
+ isMountedRef.current = false;
+ stopTimer();
+ };
+ }, [refreshCurrentActivity, stopTimer]);
+
+ return (
+ <ActivityContext.Provider
+ value={{
+ currentActivity,
+ timeElapsed,
+ isLoading,
+ startActivity,
+ stopActivity,
+ refreshCurrentActivity,
+ }}
+ >
+ {children}
+ </ActivityContext.Provider>
+ );
+}
+
+export function useActivity() {
+ const context = useContext(ActivityContext);
+ if (context === undefined) {
+ throw new Error("useActivity must be used within an ActivityProvider");
+ }
+ return context;
+}