fix: BackgroundFlushPolicy doesn't flush the Application Backgrounded…

packages/core/src/__tests__/internal/handleAppStateChange.test.ts

@@ -61,7 +61,7 @@
 
     expect(appStateChangeListener).toBeDefined();
 
     appStateChangeListener!(to);
     // Since the calls to process lifecycle events are not awaitable we have to await for ticks here
     await new Promise(process.nextTick);
     await new Promise(process.nextTick);
@@ -163,7 +163,7 @@
     // @ts-ignore
     expect(client.appState).toBe('background');
 
-    expect(mockPlugin.execute).not.toHaveBeenCalled();
+    expect(mockPlugin.execute).toHaveBeenCalledTimes(1);
   });
 
   it('sends an event when unknown => inactive', async () => {
@@ -173,6 +173,6 @@
     // @ts-ignore
     expect(client.appState).toBe('inactive');
 
-    expect(mockPlugin.execute).not.toHaveBeenCalled();
+    expect(mockPlugin.execute).toHaveBeenCalledTimes(1);
   });
 });

packages/core/src/analytics.ts

@@ -718,8 +718,8 @@ export class SegmentClient {
         void this.process(event);
         this.logger.info('TRACK (Application Opened) event saved', event);
       } else if (
-        this.appState === 'active' &&
-        ['inactive', 'background'].includes(nextAppState)
+        (this.appState === 'active' || this.appState === 'unknown') && // Check if appState is 'active' or 'unknown' //redundant condition need to check without this
+        ['inactive', 'background'].includes(nextAppState) // Check if next app state is 'inactive' or 'background'
       ) {
         const event = createTrackEvent({
           event: 'Application Backgrounded',

packages/core/src/flushPolicies/__tests__/background-flush-policy.test.ts

@@ -2,6 +2,14 @@ import { AppState, AppStateStatus } from 'react-native';
 import { BackgroundFlushPolicy } from '../background-flush-policy';
 
 describe('BackgroundFlushPolicy', () => {
+  beforeEach(() => {
+    jest.useFakeTimers(); // Mock timers
+  });
+
+  afterEach(() => {
+    jest.useRealTimers(); // Restore real timers
+  });
+
   it('triggers a flush when reaching limit', () => {
     let updateCallback = (_val: AppStateStatus) => {
       return;
@@ -14,22 +22,29 @@ describe('BackgroundFlushPolicy', () => {
         return { remove: jest.fn() };
       });
 
+    AppState.currentState = 'active';
     const policy = new BackgroundFlushPolicy();
     policy.start();
     const observer = jest.fn();
 
     policy.shouldFlush.onChange(observer);
 
     expect(addSpy).toHaveBeenCalledTimes(1);
+    updateCallback('inactive');
+    jest.advanceTimersByTime(2000);
+
+    console.log('Observer calls:', observer.mock.calls);
+    expect(observer).toHaveBeenCalledWith(true);
+    observer.mockClear();
 
     updateCallback('background');
+    jest.advanceTimersByTime(2000); // Simulate timer triggering
     expect(observer).toHaveBeenCalledWith(true);
     observer.mockClear();
 
     updateCallback('active');
+    jest.advanceTimersByTime(2000);
     expect(observer).not.toHaveBeenCalled();
-
-    updateCallback('inactive');
-    expect(observer).toHaveBeenCalledWith(true);
+    observer.mockClear();
   });
 });

packages/core/src/flushPolicies/background-flush-policy.ts

@@ -18,18 +18,24 @@ export class BackgroundFlushPolicy extends FlushPolicyBase {
       'change',
       (nextAppState) => {
         if (
-          this.appState === 'active' &&
+          ['active', 'inactive'].includes(this.appState) &&
           ['inactive', 'background'].includes(nextAppState)
         ) {
-          // When the app goes into the background we will trigger a flush
-          this.shouldFlush.value = true;
+          setTimeout(() => {
+            this.shouldFlush.value = true;
+          }, 2000);
         }
+        this.appState = nextAppState;
       }
     );
   }
 
   onEvent(_event: SegmentEvent): void {
-    // Nothing to do
+    //if ('event' in _event && _event.event === 'Application Backgrounded') {
+    // setTimeout(() => {
+    //   this.shouldFlush.value = true;
+    // }, 2000);
+    // }
   }
 
   end(): void {