feat(android): add session sync callback (#1281)

* feat(android): add SRSyncCallback

* feat: implement and test syncCallback CP side

* feat(example): use SRSyncCallback in example app

* ci: fix tests

* fix: export session data type

* fix(example): use session data type

* fix(android):remove data modifier

* fix(android): add property modifiers

* fix(android): update test case

* fix: enhance test case

* fix: update session data type

* fix: add more session metadata to setSyncCallback

* fix: update syncCallback test

* feat: add launchType to session metadata for setSyncCallback

* fix: import type

* fix: assert evaluate sync returns correct value

* fix: import type

* fix: cleanup

* chore: update js doc

* fix: typo

* fix: follow interface naming convention

* fix: update type

* fix: refactor syncCallback

* fix: default syncing session to true

* fix: convert network logs to readable array

* chore: add discriptive comment

* chore: use readable map for session metadata

* fix: setSyncCallback should sync in case of exception

* fix: move SessionMetadata to models

* fix: update SessionMetadata type import

* fix: report bug e2e test

---------

Co-authored-by: Ahmed Elrefaey <[email protected]>

Author: kholood-ea

android/native.gradle

@@ -1,5 +1,5 @@
 project.ext.instabug = [
-    version: '13.3.0'
+    version: '13.3.0.6212131-SNAPSHOT',
 ]
 
 dependencies {

android/src/main/java/com/instabug/reactlibrary/ArgsRegistry.java

@@ -15,6 +15,7 @@
 import com.instabug.library.invocation.InstabugInvocationEvent;
 import com.instabug.library.invocation.util.InstabugFloatingButtonEdge;
 import com.instabug.library.invocation.util.InstabugVideoRecordingButtonPosition;
+import com.instabug.library.sessionreplay.model.SessionMetadata;
 import com.instabug.library.ui.onboarding.WelcomeMessage;
 
 import java.util.ArrayList;
@@ -58,6 +59,7 @@ static Map<String, Object> getAll() {
             putAll(nonFatalExceptionLevel);
             putAll(locales);
             putAll(placeholders);
+            putAll(launchType);
         }};
     }
 
@@ -238,4 +240,19 @@ static Map<String, Object> getAll() {
         put("team", Key.CHATS_TEAM_STRING_NAME);
         put("insufficientContentMessage", Key.COMMENT_FIELD_INSUFFICIENT_CONTENT);
     }};
+
+    public static ArgsMap<String> launchType = new ArgsMap<String>() {{
+        put("cold", SessionMetadata.LaunchType.COLD);
+        put("hot",SessionMetadata.LaunchType.HOT );
+        put("warm",SessionMetadata.LaunchType.WARM );
+    }};
+    
+// Temporary workaround to be removed in future release
+// This is used for mapping native `LaunchType` values into React Native enum values.
+    public static HashMap<String,String> launchTypeReversed = new HashMap<String,String>() {{
+        put(SessionMetadata.LaunchType.COLD,"cold");
+        put(SessionMetadata.LaunchType.HOT,"hot" );
+        put(SessionMetadata.LaunchType.WARM,"warm" );
+    }};
+
 }

android/src/main/java/com/instabug/reactlibrary/Constants.java

@@ -9,4 +9,6 @@ final class Constants {
 
     final static String IBG_ON_NEW_MESSAGE_HANDLER = "IBGonNewMessageHandler";
     final static String IBG_ON_NEW_REPLY_RECEIVED_CALLBACK = "IBGOnNewReplyReceivedCallback";
+    final static String IBG_SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION = "IBGSessionReplayOnSyncCallback";
+
 }

android/src/main/java/com/instabug/reactlibrary/RNInstabugSessionReplayModule.java

@@ -1,24 +1,44 @@
 package com.instabug.reactlibrary;
 
+
+import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 
+import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.Promise;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
-import com.instabug.chat.Replies;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
 import com.instabug.library.OnSessionReplayLinkReady;
+import com.instabug.library.SessionSyncListener;
 import com.instabug.library.sessionreplay.SessionReplay;
+import com.instabug.library.sessionreplay.model.SessionMetadata;
+import com.instabug.reactlibrary.utils.EventEmitterModule;
 import com.instabug.reactlibrary.utils.MainThreadHandler;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
 
 import javax.annotation.Nonnull;
 
-public class RNInstabugSessionReplayModule extends ReactContextBaseJavaModule {
+public class RNInstabugSessionReplayModule extends EventEmitterModule {
 
     public RNInstabugSessionReplayModule(ReactApplicationContext reactApplicationContext) {
         super(reactApplicationContext);
     }
 
+    @ReactMethod
+    public void addListener(String event) {
+        super.addListener(event);
+    }
+
+    @ReactMethod
+    public void removeListeners(Integer count) {
+        super.removeListeners(count);
+    }
+
     @Nonnull
     @Override
     public String getName() {
@@ -79,7 +99,7 @@ public void run() {
                     e.printStackTrace();
                 }
             }
-        });
+        });  
     }
 
     @ReactMethod
@@ -97,6 +117,85 @@ public void onSessionReplayLinkReady(@Nullable String link) {
             }
         });
 
+    }
+
+    public ReadableMap getSessionMetadataMap(SessionMetadata sessionMetadata){
+        WritableMap params = Arguments.createMap();
+        params.putString("appVersion",sessionMetadata.getAppVersion());
+        params.putString("OS",sessionMetadata.getOs());
+        params.putString("device",sessionMetadata.getDevice());
+        params.putDouble("sessionDurationInSeconds",(double)sessionMetadata.getSessionDurationInSeconds());
+        params.putBoolean("hasLinkToAppReview",sessionMetadata.getLinkedToReview());
+        params.putString("launchType",ArgsRegistry.launchTypeReversed.get(sessionMetadata.getLaunchType()) );
+        params.putDouble("launchDuration", sessionMetadata.getLaunchDuration());
+        params.putArray("networkLogs",getNetworkLogsArray(sessionMetadata.getNetworkLogs()));
+
+//                              TODO:Add rest of sessionMetadata
+//                            params.putDouble("bugsCount", ??);
+//                            params.putDouble("fatalCrashCount",??);
+//                            params.putDouble("oomCrashCount",??);
+        return params;
+    }
+
+    public ReadableArray getNetworkLogsArray(List<SessionMetadata.NetworkLog> networkLogList ){
+        WritableArray networkLogs = Arguments.createArray();
+
+        for (SessionMetadata.NetworkLog log : networkLogList) {
+            WritableMap networkLog = Arguments.createMap();
+            networkLog.putString("url", log.getUrl());
+            networkLog.putDouble("duration", log.getDuration());
+            networkLog.putInt("statusCode", log.getStatusCode());
+
+            networkLogs.pushMap(networkLog);
+        }
+
+        return networkLogs;
+    }
+
+    private boolean shouldSync = true;
+    private CountDownLatch latch;
+    @ReactMethod
+    public void setSyncCallback() {
+        MainThreadHandler.runOnMainThread(new Runnable() {
+            @Override
+            public void run() {
+                try {
+                    SessionReplay.setSyncCallback(new SessionSyncListener() {
+                        @Override
+                        public boolean onSessionReadyToSync(@NonNull SessionMetadata sessionMetadata) {
+
+                            sendEvent(Constants.IBG_SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION,getSessionMetadataMap(sessionMetadata));
 
+                            latch = new CountDownLatch(1);
+
+                            try {
+                                latch.await();
+                            } catch (InterruptedException e) {
+                                e.printStackTrace();
+                                return true;
+                            }
+
+                            return shouldSync;
+                        }
+                    });
+                }
+                catch(Exception e){
+                    e.printStackTrace();
+                }
+
+            }
+        });
     }
+
+    @ReactMethod
+    public void evaluateSync(boolean result) {
+        shouldSync = result;
+        
+        if (latch != null) {
+            latch.countDown();
+        }
+    }
+
+
+
 }

android/src/test/java/com/instabug/reactlibrary/RNInstabugSessionReplayModuleTest.java

@@ -1,40 +1,44 @@
 package com.instabug.reactlibrary;
 
+import static junit.framework.TestCase.assertEquals;
+import static junit.framework.TestCase.assertTrue;
+
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Matchers.any;
 import static org.mockito.Mockito.doAnswer;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.mockConstruction;
 import static org.mockito.Mockito.mockStatic;
-import static org.mockito.Mockito.timeout;
-import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import android.os.Handler;
 import android.os.Looper;
 
 import com.facebook.react.bridge.Arguments;
-import com.facebook.react.bridge.JavaOnlyArray;
+import com.facebook.react.bridge.JavaOnlyMap;
 import com.facebook.react.bridge.Promise;
-import com.facebook.react.bridge.ReadableArray;
-import com.facebook.react.bridge.WritableArray;
-import com.instabug.chat.Replies;
-import com.instabug.featuresrequest.ActionType;
-import com.instabug.featuresrequest.FeatureRequests;
-import com.instabug.library.Feature;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.WritableMap;
 import com.instabug.library.OnSessionReplayLinkReady;
+import com.instabug.library.SessionSyncListener;
 import com.instabug.library.sessionreplay.SessionReplay;
+import com.instabug.library.sessionreplay.model.SessionMetadata;
 import com.instabug.reactlibrary.utils.MainThreadHandler;
 
 import org.junit.After;
 import org.junit.Before;
 import org.junit.Test;
+import org.mockito.MockedConstruction;
 import org.mockito.MockedStatic;
 import org.mockito.Mockito;
 import org.mockito.invocation.InvocationOnMock;
 import org.mockito.stubbing.Answer;
 
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 
 public class RNInstabugSessionReplayModuleTest {
@@ -44,8 +48,8 @@ public class RNInstabugSessionReplayModuleTest {
 
     // Mock Objects
     private MockedStatic<Looper> mockLooper;
-    private MockedStatic <MainThreadHandler> mockMainThreadHandler;
-    private MockedStatic <SessionReplay> mockSessionReplay;
+    private MockedStatic<MainThreadHandler> mockMainThreadHandler;
+    private MockedStatic<SessionReplay> mockSessionReplay;
 
     @Before
     public void mockMainThreadHandler() throws Exception {
@@ -107,7 +111,7 @@ public void testSetInstabugLogsEnabled() {
     @Test
     public void testGetSessionReplayLink() {
         Promise promise = mock(Promise.class);
-        String link="instabug link";
+        String link = "instabug link";
 
         mockSessionReplay.when(() -> SessionReplay.getSessionReplayLink(any())).thenAnswer(
                 invocation -> {
@@ -136,5 +140,40 @@ public void testSetUserStepsEnabled() {
         mockSessionReplay.verifyNoMoreInteractions();
     }
 
+    @Test
+    public void testSetSyncCallback() throws Exception  {
+            MockedStatic<Arguments> mockArguments = mockStatic(Arguments.class);
+            MockedConstruction<CountDownLatch> mockCountDownLatch = mockConstruction(CountDownLatch.class);
+            RNInstabugSessionReplayModule SRModule = spy(new RNInstabugSessionReplayModule(mock(ReactApplicationContext.class)));
+
+            final boolean shouldSync = true;
+            final AtomicBoolean actual = new AtomicBoolean();
+
+            mockArguments.when(Arguments::createMap).thenReturn(new JavaOnlyMap());
+
+            mockSessionReplay.when(() -> SessionReplay.setSyncCallback(any(SessionSyncListener.class)))
+                    .thenAnswer((invocation) -> {
+                        SessionSyncListener listener = (SessionSyncListener) invocation.getArguments()[0];
+                        SessionMetadata metadata = mock(SessionMetadata.class);
+                        actual.set(listener.onSessionReadyToSync(metadata));
+                        return null;
+                    });
+
+            doAnswer((invocation) -> {
+                SRModule.evaluateSync(shouldSync);
+                return null;
+            }).when(SRModule).sendEvent(eq(Constants.IBG_SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION), any());
+
+            WritableMap params = Arguments.createMap();
+
+            SRModule.setSyncCallback();
+
+            assertEquals(shouldSync, actual.get());
+            verify(SRModule).sendEvent(Constants.IBG_SESSION_REPLAY_ON_SYNC_CALLBACK_INVOCATION, params);
+            mockSessionReplay.verify(() -> SessionReplay.setSyncCallback(any(SessionSyncListener.class)));
+
+            mockArguments.close();
+            mockCountDownLatch.close();
+    }
 
 }

examples/default/e2e/reportBug.e2e.ts

@@ -14,7 +14,9 @@ it('reports a bug', async () => {
   await waitFor(floatingButton).toBeVisible().withTimeout(30000);
   await floatingButton.tap();
 
-  await getElement('reportBugMenuItem').tap();
+  const reportBugMenuItemButton = getElement('reportBugMenuItem');
+  await waitFor(reportBugMenuItemButton).toBeVisible().withTimeout(30000);
+  await reportBugMenuItemButton.tap();
 
   await getElement('emailField').typeText(mockData.email);
   await getElement('commentField').typeText(mockData.bugComment);

examples/default/src/App.tsx

@@ -8,7 +8,10 @@ import Instabug, {
   InvocationEvent,
   LogLevel,
   ReproStepsMode,
+  SessionReplay,
+  LaunchType,
 } from 'instabug-reactnative';
+import type { SessionMetadata } from 'instabug-reactnative';
 import { NativeBaseProvider } from 'native-base';
 
 import { RootTabNavigator } from './navigation/RootTab';
@@ -20,8 +23,24 @@ import { QueryClient, QueryClientProvider } from 'react-query';
 const queryClient = new QueryClient();
 
 export const App: React.FC = () => {
+  const shouldSyncSession = (data: SessionMetadata) => {
+    if (data.launchType === LaunchType.cold) {
+      return true;
+    }
+    if (data.sessionDurationInSeconds > 20) {
+      return true;
+    }
+    if (data.OS === 'OS Level 34') {
+      return true;
+    }
+    return false;
+  };
+
   const navigationRef = useNavigationContainerRef();
+
   useEffect(() => {
+    SessionReplay.setSyncCallback((data) => shouldSyncSession(data));
+
     Instabug.init({
       token: 'deb1910a7342814af4e4c9210c786f35',
       invocationEvents: [InvocationEvent.floatingButton],

src/index.ts

@@ -14,6 +14,7 @@ import * as Replies from './modules/Replies';
 import type { Survey } from './modules/Surveys';
 import * as Surveys from './modules/Surveys';
 import * as SessionReplay from './modules/SessionReplay';
+import type { SessionMetadata } from './models/SessionMetadata';
 
 export * from './utils/Enums';
 export {
@@ -28,6 +29,6 @@ export {
   Replies,
   Surveys,
 };
-export type { InstabugConfig, Survey, NetworkData, NetworkDataObfuscationHandler };
+export type { InstabugConfig, Survey, NetworkData, NetworkDataObfuscationHandler, SessionMetadata };
 
 export default Instabug;