@convivainc/conviva-react-native-appanalytics 0.1.2 → 0.1.4

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 
 # Changelog
+
+## 0.1.4 (05/JAN/2024)
+- Supports the Auto Detection of ScreenView navigation if the application uses the [NavigationContainer](https://reactnavigation.org/docs/5.x/hello-react-navigation)(for react native version 5 and above) or [AppNavigator](https://reactnavigation.org/docs/4.x/hello-react-navigation)(for react native version below 5)<br>
+ *Note:Please refer to [ScreenView Auto-Detection](https://github.com/Conviva/conviva-react-native-appanalytics?tab=readme-ov-file#auto-detect-screenview-events-for-tracking-screen-navigation) for more details*
+  
+## 0.1.3 (12/DEC/2023)
+* Supports the Auto Detection of "buttonText" style for the User Click of Button, TouchableHighlight, TouchableOpacity, TouchableWithoutFeedback and TouchableNativeFeedback Components<br>
+*This feature needs the Android App SDK version of [0.8.0](https://github.com/Conviva/conviva-android-appanalytics)*
+
 ## 0.1.2 (01/MAY/2023)
 * Supports the inclusion of the latest Android/iOS Native sensor always in the Android/iOS Bridge going forward
 * Fixes the issue of App Name being incorrect for iOS Bridge
@@ -13,4 +22,4 @@
 * Fixes the issue of optional Network Config argument being mandatory
 
 ## 0.0.1 (02/APR/2023)
-* Initial version of the Conviva React Native Sensor
+* Initial version of the Conviva React Native Sensor

package/README.md

@@ -53,6 +53,47 @@ let pageViewEvent = {'pageUrl' : 'https://allpopulated.com',
 tracker.trackPageViewEvent(pageViewEvent);
 ```
 
+## Auto detect ScreenView Events for tracking screen navigation.
+For React Navigation versions 5 and above, to autocapture screenviews, wrap withReactNavigationAutotrack(autocaptureNavigationTrack) around the NavigationContainer:
+
+```js
+
+import {
+  withReactNavigationAutotrack,
+  autocaptureNavigationTrack
+} from '@convivainc/conviva-react-native-appanalytics';
+
+
+const ConvivaNavigationContainer = 
+withReactNavigationAutotrack(autocaptureNavigationTrack)(NavigationContainer);
+
+
+<ConvivaNavigationContainer>
+    <Tab.Navigator>
+      <Tab.Screen name="Home" component={HomeScreen} />
+      <Tab.Screen name="Settings" component={SettingsScreen}/> 
+    </Tab.Navigator>
+</ConvivaNavigationContainer>
+```
+
+For React Navigation versions below 5, wrap the AppContainer (the result of a call to React Navigation’s createAppContainer() method) with withReactNavigationAutotrack(autocaptureNavigationTrack)
+```js
+
+let AppNavigator = createStackNavigator(
+  {
+    Home: { screen: HomeScreen },
+    Settings: { screen: SettingsScreen }
+  },
+  {
+    initialRouteName: 'HomeScreen'
+  }
+)
+
+let App = withReactNavigationAutotrack(autocaptureNavigationTrack)(AppNavigator);
+
+```
+
+
 ## Custom event tracking to track your application specific events and state changes
 Use trackCustomEvent() API to track all kinds of events. This API provides 2 fields to describe the tracked events.
 

package/RNConvivaAppAnalytics.podspec

@@ -20,5 +20,5 @@ Pod::Spec.new do |s|
   s.requires_arc = true
 
   s.dependency "React-Core"
-  s.dependency "ConvivaAppAnalytics", ">= 0.2.12"
+  s.dependency "ConvivaAppAnalytics", ">= 0.2.18"
 end

package/android/.gradle/buildOutputCleanup/cache.properties

@@ -0,0 +1,2 @@
+#Mon Dec 18 17:16:15 IST 2023
+gradle.version=7.5

package/android/.gradle/config.properties

@@ -0,0 +1,2 @@
+#Mon Dec 18 17:16:12 IST 2023
+java.home=/private/var/folders/k4/74893875541dtbxdz44z6zbr0000gn/T/AppTranslocation/4A54960E-0028-414A-AF27-0F092C67D374/d/Android Studio.app/Contents/jbr/Contents/Home

package/android/.idea/compiler.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="CompilerConfiguration">
+    <bytecodeTargetLevel target="11" />
+  </component>
+</project>

package/android/.idea/gradle.xml

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="GradleMigrationSettings" migrationVersion="1" />
+  <component name="GradleSettings">
+    <option name="linkedExternalProjectsSettings">
+      <GradleProjectSettings>
+        <option name="testRunner" value="GRADLE" />
+        <option name="externalProjectPath" value="$PROJECT_DIR$" />
+        <option name="gradleJvm" value="Embedded JDK" />
+        <option name="modules">
+          <set>
+            <option value="$PROJECT_DIR$" />
+          </set>
+        </option>
+        <option name="resolveExternalAnnotations" value="false" />
+      </GradleProjectSettings>
+    </option>
+  </component>
+</project>

package/android/.idea/migrations.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectMigrations">
+    <option name="MigrateToGradleLocalJavaHome">
+      <set>
+        <option value="$PROJECT_DIR$" />
+      </set>
+    </option>
+  </component>
+</project>

package/android/.idea/misc.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ExternalStorageConfigurationManager" enabled="true" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_11" project-jdk-name="11" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/build/classes" />
+  </component>
+  <component name="ProjectType">
+    <option name="id" value="Android" />
+  </component>
+</project>

package/android/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

package/android/build.gradle

@@ -16,12 +16,12 @@ buildscript {
 apply plugin: "com.android.library"
 
 android {
-    compileSdkVersion safeExtGet('compileSdkVersion', 30)
-    buildToolsVersion safeExtGet('buildToolsVersion', '28.0.3')
+    compileSdkVersion safeExtGet('compileSdkVersion', 33)
+    buildToolsVersion safeExtGet('buildToolsVersion', '30.0.2')
 
     defaultConfig {
         minSdkVersion safeExtGet('minSdkVersion', 21)
-        targetSdkVersion safeExtGet('targetSdkVersion', 30)
+        targetSdkVersion safeExtGet('targetSdkVersion', 33)
         versionCode 1
         versionName "1.0"
     }

package/android/local.properties

@@ -0,0 +1,8 @@
+## This file must *NOT* be checked into Version Control Systems,
+# as it contains information specific to your local configuration.
+#
+# Location of the SDK. This is only used by Gradle.
+# For customization when using a Version Control System, please read the
+# header note.
+#Mon Dec 18 17:16:12 IST 2023
+sdk.dir=/Users/sramachandra/Library/Android/sdk

package/android/src/main/java/com/conviva/react/apptracker/RNConvivaTrackerModule.java

@@ -11,6 +11,7 @@ import com.conviva.apptracker.configuration.SessionConfiguration;
 import com.conviva.apptracker.configuration.SubjectConfiguration;
 import com.conviva.apptracker.configuration.TrackerConfiguration;
 import com.conviva.apptracker.controller.TrackerController;
+import com.conviva.apptracker.event.ButtonClick;
 import com.conviva.apptracker.event.ConsentGranted;
 import com.conviva.apptracker.event.ConsentWithdrawn;
 import com.conviva.apptracker.event.DeepLinkReceived;
@@ -190,7 +191,8 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void removeAllTrackers(Promise promise) {
         try {
-            ConvivaAppAnalytics.removeAllTrackers();
+            // commented out deprecated methods
+            // ConvivaAppAnalytics.removeAllTrackers();
             promise.resolve(true);
 
         } catch (Throwable t) {
@@ -488,14 +490,32 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     }
 
     @ReactMethod
-    public void removeGlobalContexts(ReadableMap details, Promise promise) {
+    public void trackClickEvent(ReadableMap details, Promise promise) {
         try {
             String namespace = details.getString("tracker");
-            String tag = details.getString("removeTag");
-
+            ReadableMap eventMap = details.getMap("eventData");
             TrackerController trackerController = getTracker(namespace);
 
-            trackerController.getGlobalContexts().remove(tag);
+            ButtonClick event = EventUtil.createButtonClickEvent(eventMap);
+            trackerController.track(event);
+
+            promise.resolve(true);
+
+        } catch (Throwable t) {
+            promise.reject("ERROR", t.getMessage());
+        }
+    }
+
+    @ReactMethod
+    public void removeGlobalContexts(ReadableMap details, Promise promise) {
+        try {
+            // commented out deprecated methods            
+            // String namespace = details.getString("tracker");
+            // String tag = details.getString("removeTag");
+
+            // TrackerController trackerController = getTracker(namespace);
+
+            // trackerController.getGlobalContexts().remove(tag);
             promise.resolve(true);
 
         } catch (Throwable t) {
@@ -506,22 +526,23 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void addGlobalContexts(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            ReadableMap gcArg = details.getMap("addGlobalContext");
+            // commented out deprecated methods   
+            // String namespace = details.getString("tracker");
+            // ReadableMap gcArg = details.getMap("addGlobalContext");
 
-            String tag = gcArg.getString("tag");
-            ReadableArray globalContexts = gcArg.getArray("globalContexts");
+            // String tag = gcArg.getString("tag");
+            // ReadableArray globalContexts = gcArg.getArray("globalContexts");
 
-            List<SelfDescribingJson> staticContexts = new ArrayList<>();
-            for (int i = 0; i < globalContexts.size(); i++) {
-                SelfDescribingJson gContext = EventUtil.createSelfDescribingJson(globalContexts.getMap(i));
-                staticContexts.add(gContext);
-            }
-            GlobalContext gcStatic = new GlobalContext(staticContexts);
+            // List<SelfDescribingJson> staticContexts = new ArrayList<>();
+            // for (int i = 0; i < globalContexts.size(); i++) {
+            //     SelfDescribingJson gContext = EventUtil.createSelfDescribingJson(globalContexts.getMap(i));
+            //     staticContexts.add(gContext);
+            // }
+            // GlobalContext gcStatic = new GlobalContext(staticContexts);
 
-            TrackerController trackerController = getTracker(namespace);
+            // TrackerController trackerController = getTracker(namespace);
 
-            trackerController.getGlobalContexts().add(tag, gcStatic);
+            // trackerController.getGlobalContexts().add(tag, gcStatic);
             promise.resolve(true);
 
         } catch (Throwable t) {
@@ -722,11 +743,13 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getSessionUserId(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            TrackerController trackerController = getTracker(namespace);
+            // commented out deprecated methods
+            // String namespace = details.getString("tracker");
+            // TrackerController trackerController = getTracker(namespace);
 
-            String suid = trackerController.getSession().getUserId();
-            promise.resolve(suid);
+            // String suid = trackerController.getSession().getUserId();
+            // promise.resolve(suid);
+            promise.resolve(true);
         } catch (Throwable t) {
             promise.reject("ERROR", t.getMessage());
         }
@@ -735,11 +758,13 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getSessionId(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            TrackerController trackerController = getTracker(namespace);
+            // commented out deprecated methods
+            // String namespace = details.getString("tracker");
+            // TrackerController trackerController = getTracker(namespace);
 
-            String sid = trackerController.getSession().getSessionId();
-            promise.resolve(sid);
+            // String sid = trackerController.getSession().getSessionId();
+            // promise.resolve(sid);
+            promise.resolve(true);
         } catch (Throwable t) {
             promise.reject("ERROR", t.getMessage());
         }
@@ -748,11 +773,13 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getSessionIndex(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            TrackerController trackerController = getTracker(namespace);
+            // commented out deprecated methods
+            // String namespace = details.getString("tracker");
+            // TrackerController trackerController = getTracker(namespace);
 
-            int sidx = trackerController.getSession().getSessionIndex();
-            promise.resolve(sidx);
+            // int sidx = trackerController.getSession().getSessionIndex();
+            // promise.resolve(sidx);
+            promise.resolve(true);
         } catch (Throwable t) {
             promise.reject("ERROR", t.getMessage());
         }
@@ -761,11 +788,13 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getIsInBackground(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            TrackerController trackerController = getTracker(namespace);
+            // commented out deprecated methods
+            // String namespace = details.getString("tracker");
+            // TrackerController trackerController = getTracker(namespace);
 
-            boolean isInBg = trackerController.getSession().isInBackground();
-            promise.resolve(isInBg);
+            // boolean isInBg = trackerController.getSession().isInBackground();
+            // promise.resolve(isInBg);
+            promise.resolve(true);
         } catch (Throwable t) {
             promise.reject("ERROR", t.getMessage());
         }
@@ -774,11 +803,13 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getBackgroundIndex(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            TrackerController trackerController = getTracker(namespace);
+            // commented out deprecated methods
+            // String namespace = details.getString("tracker");
+            // TrackerController trackerController = getTracker(namespace);
 
-            int bgIdx = trackerController.getSession().getBackgroundIndex();
-            promise.resolve(bgIdx);
+            // int bgIdx = trackerController.getSession().getBackgroundIndex();
+            // promise.resolve(bgIdx);
+            promise.resolve(true);
         } catch (Throwable t) {
             promise.reject("ERROR", t.getMessage());
         }
@@ -787,11 +818,13 @@ public class RNConvivaTrackerModule extends ReactContextBaseJavaModule {
     @ReactMethod
     public void getForegroundIndex(ReadableMap details, Promise promise) {
         try {
-            String namespace = details.getString("tracker");
-            TrackerController trackerController = getTracker(namespace);
+            // commented out deprecated methods
+            // String namespace = details.getString("tracker");
+            // TrackerController trackerController = getTracker(namespace);
 
-            int fgIdx = trackerController.getSession().getForegroundIndex();
-            promise.resolve(fgIdx);
+            // int fgIdx = trackerController.getSession().getForegroundIndex();
+            // promise.resolve(fgIdx);
+            promise.resolve(true);
         } catch (Throwable t) {
             promise.reject("ERROR", t.getMessage());
         }

package/android/src/main/java/com/conviva/react/apptracker/util/EventUtil.java

@@ -2,6 +2,7 @@ package com.conviva.react.apptracker.util;
 
 import androidx.annotation.NonNull;
 
+import com.conviva.apptracker.event.ButtonClick;
 import com.conviva.apptracker.event.ConsentGranted;
 import com.conviva.apptracker.event.ConsentWithdrawn;
 import com.conviva.apptracker.event.DeepLinkReceived;
@@ -336,4 +337,10 @@ public class EventUtil {
 
         return event;
     }
+
+    public static ButtonClick createButtonClickEvent(ReadableMap argmap) {
+        ButtonClick event = ButtonClick.buildClickEvent(argmap.toHashMap());
+        Objects.requireNonNull(event, "atleast one attribute should be available");
+        return event;
+    }
 }

package/android/src/main/java/com/conviva/react/apptracker/util/TrackerVersion.java

@@ -4,6 +4,6 @@ import com.conviva.react.apptracker.BuildConfig;
 
 public class TrackerVersion {
 
-    public final static String RN_CONVIVA_TRACKER_VERSION = "rn-0.1.2";
+    public final static String RN_CONVIVA_TRACKER_VERSION = "rn-0.1.4";
 
 }

package/conviva-react-native-appanalytics.d.ts

@@ -1,3 +1,5 @@
+import * as react from 'react';
+
 /**
  * HttpMethod type
  */
@@ -800,6 +802,12 @@ type ReactNativeTracker = {
      * @returns {Promise<number | undefined>}
      */
     readonly getForegroundIndex: () => Promise<number | undefined>;
+    /**
+    * Tracks a click event
+    *
+    * @param eventData - The user click event properties
+    */
+    readonly trackClickEvent: (eventData: any) => Promise<void>;
 };
 
 /**
@@ -817,6 +825,8 @@ declare function getWebViewCallback(): (message: {
     };
 }) => void;
 
+declare function withReactNavigationAutotrack(track: any): (AppContainer: any) => React.ForwardRefExoticComponent<React.RefAttributes<any>>;
+
 /**
  * Creates a React Native Tracker object
  *
@@ -838,5 +848,11 @@ declare function removeTracker(trackerNamespace: string): Promise<boolean>;
  * @returns - A boolean promise
  */
 declare function removeAllTrackers(): Promise<boolean>;
+declare const autocaptureNavigationTrack: (...args: any[]) => any;
+
+declare const _default: {
+    convivaTouchableAutoTrack: (TouchableComponent: any) => react.ForwardRefExoticComponent<react.RefAttributes<any>>;
+    withReactNavigationAutotrack: (AppContainer: any) => react.ForwardRefExoticComponent<react.RefAttributes<any>>;
+};
 
-export { Basis, BufferOption, ConsentDocument, ConsentGrantedProps, ConsentWithdrawnProps, DeepLinkReceivedProps, DevicePlatform, EcommerceItem, EcommerceTransactionProps, EmitterConfiguration, EventContext, GCConfiguration, GdprConfiguration, GlobalContext, HttpMethod, LogLevel, MessageNotificationProps, NetworkConfiguration, PageViewProps, ReactNativeTracker, ScreenSize, ScreenViewProps, SelfDescribing, SessionConfiguration, StructuredProps, SubjectConfiguration, TimingProps, TrackerConfiguration, TrackerControllerConfiguration, Trigger, createTracker, getWebViewCallback, removeAllTrackers, removeTracker };
+export { Basis, BufferOption, ConsentDocument, ConsentGrantedProps, ConsentWithdrawnProps, DeepLinkReceivedProps, DevicePlatform, EcommerceItem, EcommerceTransactionProps, EmitterConfiguration, EventContext, GCConfiguration, GdprConfiguration, GlobalContext, HttpMethod, LogLevel, MessageNotificationProps, NetworkConfiguration, PageViewProps, ReactNativeTracker, ScreenSize, ScreenViewProps, SelfDescribing, SessionConfiguration, StructuredProps, SubjectConfiguration, TimingProps, TrackerConfiguration, TrackerControllerConfiguration, Trigger, autocaptureNavigationTrack, createTracker, _default as default, getWebViewCallback, removeAllTrackers, removeTracker, withReactNavigationAutotrack };

package/conviva-react-native-appanalytics.js

@@ -1,4 +1,8 @@
 import { NativeModules } from 'react-native';
+import * as React from 'react';
+import React__default from 'react';
+import hoistNonReactStatic from 'hoist-non-react-statics';
+import * as _ from 'lodash';
 
 /*
  * Copyright (c) 2020-2023 Snowplow Analytics Ltd. All rights reserved.
@@ -124,6 +128,7 @@ const logMessages = {
     deepLinkReq: 'deepLinkReceived event requires the url parameter to be set',
     messageNotificationReq: 'messageNotification event requires title, body, and trigger parameters to be set',
     trackCustomEvent: 'trackCustomEvent event requires name and data',
+    trackClickEvent: 'click event requires atleast one attribute',
     // custom tags contexts
     setCustomTags: 'setCustomTags requires tags',
     clearCustomTags: 'clearCustomTags requires tag keys',
@@ -761,7 +766,7 @@ function trackScreenViewEvent$1(namespace, argmap, contexts = []) {
         contexts: contexts
     }))
         .catch((error) => {
-        throw new Error(`${logMessages.trackScreenView} ${error.message}`);
+        throw new Error(`Conviva ${logMessages.trackScreenView} ${error.message}`);
     });
 }
 /**
@@ -1025,6 +1030,22 @@ function clearAllCustomTags$1(namespace, contexts = []) {
         throw new Error(`${logMessages.clearAllCustomTags} ${error.message}`);
     });
 }
+/**
+ * Track user click event
+ *
+ * @param namespace {string} - the tracker namespace
+ * @param eventData {any}- the user click data
+ * @returns {Promise}
+ */
+function trackClickEvent$1(namespace, eventData) {
+    return RNConvivaTracker.trackClickEvent({
+        tracker: namespace,
+        eventData: eventData
+    })
+        .catch((error) => {
+        throw new Error(`${logMessages.trackClickEvent} ${error.message}`);
+    });
+}
 
 /*
  * Copyright (c) 2020-2023 Snowplow Analytics Ltd. All rights reserved.
@@ -1656,6 +1677,17 @@ function getForegroundIndex(namespace) {
             .resolve(RNConvivaTracker.getForegroundIndex({ tracker: namespace }));
     };
 }
+/**
+ * Returns a function to track click event.
+ *
+ * @param namespace {string} - The tracker namespace
+ * @returns - A function to track click event
+ */
+function trackClickEvent(namespace) {
+    return function (eventData) {
+        return trackClickEvent$1(namespace, eventData);
+    };
+}
 
 /*
  * Copyright (c) 2020-2023 Snowplow Analytics Ltd. All rights reserved.
@@ -1727,6 +1759,304 @@ function getWebViewCallback() {
     };
 }
 
+const logError = (message, error, quiet = false) => {
+    const logger = quiet ? console.log : console.warn;
+    if (error instanceof Error) {
+        // KLUDGE: These properties don't show up if you `console.warn` the error object directly.
+        logger(message, {
+            name: error.name,
+            message: error.message,
+            stack: error.stack,
+        });
+    }
+    else {
+        logger(message, {
+            message: String(error),
+        });
+    }
+};
+const handleError = (fn, name = null, quiet = false) => {
+    return (...args) => {
+        try {
+            return fn(...args);
+        }
+        catch (e) {
+            logError(name ? `Conviva: ${name} failed with an error.` : 'Conviva SDK encountered an error while tracking.', e, quiet);
+        }
+    };
+};
+
+const getComponentDisplayName = WrappedComponent => {
+    return WrappedComponent.displayName || WrappedComponent.name || 'Component';
+};
+
+const getCompTargetText = (comp) => {
+    return getTargetText(getReactInternalFiber(comp));
+};
+const getReactInternalFiber = (comp) => {
+    return comp._reactInternals || comp._reactInternalFiber || comp._fiber || comp._internalFiberInstanceHandleDEV;
+};
+const getTargetText = fiberNode => {
+    if (fiberNode.type === 'RCTText') {
+        return fiberNode.memoizedProps.children;
+    }
+    // In some cases, target text may not be within an 'RCTText' component. This has only been
+    // observed in unit tests with Enzyme, but may still be a possibility in real RN apps.
+    if (fiberNode.memoizedProps &&
+        typeof fiberNode.memoizedProps.children === 'string') {
+        return fiberNode.memoizedProps.children;
+    }
+    if (fiberNode.child === null) {
+        return '';
+    }
+    const children = [];
+    let currChild = fiberNode.child;
+    while (currChild) {
+        children.push(currChild);
+        currChild = currChild.sibling;
+    }
+    let targetText = '';
+    children.forEach(child => {
+        targetText = (targetText + ' ' + getTargetText(child)).trim();
+    });
+    return targetText;
+};
+
+var __rest = (undefined) || function (s, e) {
+    var t = {};
+    for (var p in s)
+        if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+            t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, q = Object.getOwnPropertySymbols(s); i < q.length; i++) {
+            if (e.indexOf(q[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, q[i]))
+                t[p[i]] = s[q[i]];
+        }
+    return t;
+};
+const convivaAutotrackPress = trackHandler => (_eventType, componentThis, _event) => {
+    if (componentThis) {
+        let data = { "elementId": componentThis.id, "elementClasses": componentThis.displayName, "elementType": componentThis.elementType, "elementText": getCompTargetText(componentThis) };
+        // console.log("trackHandler data",data);
+        trackHandler(data);
+    }
+};
+const convivaTouchableAutoTrack = (track) => TouchableComponent => {
+    class ConvivaTouchableAutoTrack extends React.Component {
+        render() {
+            const _a = this.props, { forwardedRef, onPress, onLongPress } = _a, rest = __rest(_a, ["forwardedRef", "onPress", "onLongPress"]);
+            return (React.createElement(TouchableComponent, Object.assign({ ref: forwardedRef, onPress: e => {
+                    handleError(convivaAutotrackPress(track))('touchableHandlePress', this, e);
+                    onPress && onPress(e);
+                }, onLongPress: e => {
+                    handleError(convivaAutotrackPress(track))('touchableHandleLongPress', this, e);
+                    onLongPress && onLongPress(e);
+                } }, rest), this.props.children));
+        }
+    }
+    ConvivaTouchableAutoTrack.displayName = `convivaTouchableAutoTrack(${getComponentDisplayName(TouchableComponent)})`;
+    // console.log("ConvivaTouchableAutoTrack.displayName",ConvivaTouchableAutoTrack.displayName);
+    const forwardRefHoc = React.forwardRef((props, ref) => {
+        return React.createElement(ConvivaTouchableAutoTrack, Object.assign({}, props, { forwardedRef: ref }));
+    });
+    hoistNonReactStatic(forwardRefHoc, TouchableComponent);
+    return forwardRefHoc;
+};
+
+class DisplayNameTest {
+    render() { }
+}
+let warningGiven = false;
+const checkDisplayNamePlugin = () => {
+    // @ts-ignore
+    if (!DisplayNameTest.displayName && !warningGiven) {
+        console.warn('Conviva: Display names are not available');
+        warningGiven = true;
+    }
+};
+
+class NavigationUtil {
+    // :TODO: (jmtaber129): Add typing for this ref.
+    static convivaNavRef;
+    static setNavigationRef(ref) {
+        this.convivaNavRef = ref;
+    }
+    static getScreenPropsForCurrentRoute() {
+        let rootState = null;
+        if (this.convivaNavRef && this.convivaNavRef.state && this.convivaNavRef.state.nav) {
+            rootState = this.convivaNavRef.state.nav;
+        }
+        else if (this.convivaNavRef && this.convivaNavRef.getRootState) {
+            rootState = this.convivaNavRef.getRootState();
+        }
+        if (rootState == null) {
+            return null;
+        }
+        const routeProps = this.getActiveRouteProps(rootState);
+        if (routeProps) {
+            return routeProps;
+        }
+        return null;
+    }
+    static isHocEnabled() {
+        return !!this.convivaNavRef;
+    }
+    // :TODO: (jmtaber129): Add type for navigationState.
+    static getActiveRouteProps(navigationState) {
+        const paths = this.getActiveRouteNames(navigationState);
+        return {
+            screen_path: paths.join('::'),
+            screen_name: paths[paths.length - 1],
+        };
+    }
+    // Returns an array of route names, with the root name first, and the most nested name last.
+    static getActiveRouteNames(navigationState) {
+        const route = navigationState.routes[navigationState.index];
+        // Dive into nested navigators.
+        let paths;
+        if (route.routes) {
+            paths = this.getActiveRouteNames(route);
+        }
+        else if (route.state && route.state.routes) {
+            paths = this.getActiveRouteNames(route.state);
+        }
+        const routeName = route.routeName || route.name;
+        if (paths) {
+            return [routeName].concat(paths);
+        }
+        return [routeName];
+    }
+}
+
+const version = "0.22.6";
+
+const { Platform } = require('react-native');
+let reactNativeVersionString = null;
+if (Platform && Platform.constants && Platform.constants.reactNativeVersion) {
+    const { major, minor, patch } = Platform.constants.reactNativeVersion;
+    reactNativeVersionString = `${major}.${minor}.${patch}`;
+}
+const getMetadataProps = () => {
+    return {
+        source_version: version,
+        is_using_react_navigation_hoc: NavigationUtil.isHocEnabled(),
+        react_native_version: reactNativeVersionString,
+    };
+};
+
+const getContextualProps = () => {
+    return _.merge({}, getMetadataProps(), { name: NavigationUtil.getScreenPropsForCurrentRoute()?.screen_name
+        // , id:NavigationUtil.getScreenPropsForCurrentRoute()?.screen_path
+    });
+};
+
+// const EVENT_TYPE = 'react_navigation_screenview';
+// const INITIAL_ROUTE_TYPE = 'Conviva_Navigation/INITIAL';
+const withReactNavigationAutotrack = track => AppContainer => {
+    const wrapperObject = {};
+    const existingWrapper = wrapperObject.__convivaWrapper;
+    if (existingWrapper) {
+        return existingWrapper;
+    }
+    const captureOldNavigationStateChange = handleError((prev, next) => {
+        const { screen_path: prevScreenRoute } = NavigationUtil.getActiveRouteProps(prev);
+        const { screen_path: nextScreenRoute } = NavigationUtil.getActiveRouteProps(next);
+        if (prevScreenRoute !== nextScreenRoute) {
+            track({
+                ...getContextualProps(),
+            });
+        }
+    }, 'Navigation event capture', true);
+    class ConvivaNavigationWrapper extends React__default.Component {
+        constructor(props) {
+            super(props);
+            this.topLevelNavigator = null;
+            this.currentPath = null;
+        }
+        setRef(ref, value) {
+            if (typeof ref === 'function') {
+                ref(value);
+            }
+            else if (ref !== null) {
+                ref.current = value;
+            }
+        }
+        captureStateChange = handleError(state => {
+            const { screen_path: nextPath } = NavigationUtil.getActiveRouteProps(state);
+            if (nextPath !== this.currentPath) {
+                track({
+                    previousName: this.currentPath || "",
+                    ...getContextualProps()
+                });
+            }
+            this.currentPath = nextPath;
+        }, 'Navigation event capture', true);
+        captureOnReady = handleError(() => {
+            if (this.topLevelNavigator.getRootState) {
+                this.trackInitialRouteForState(this.topLevelNavigator.getRootState());
+                const { screen_path: currentPath } = NavigationUtil.getActiveRouteProps(this.topLevelNavigator.getRootState());
+                this.currentPath = currentPath;
+            }
+        }, 'Navigation event capture', true);
+        trackInitialRouteForState(_) {
+            // const { screen_path: initialPageviewPath } = NavigationUtil.getActiveRouteProps(navigationState);
+            track({
+                ...getContextualProps()
+            });
+        }
+        render() {
+            try {
+                return this._render();
+            }
+            catch (e) {
+                logError('Conviva: Failed to render React Navigation wrapper.', e);
+                const { forwardedRef, ...rest } = this.props;
+                return React__default.createElement(AppContainer, { ref: forwardedRef, ...rest });
+            }
+        }
+        _render() {
+            const { forwardedRef, onNavigationStateChange, onStateChange, onReady, ...rest } = this.props;
+            return React__default.createElement(AppContainer, {
+                ref: handleError((navigatorRef) => {
+                    this.setRef(forwardedRef, navigatorRef);
+                    NavigationUtil.setNavigationRef(navigatorRef);
+                    if (this.topLevelNavigator !== navigatorRef &&
+                        navigatorRef !== null) {
+                        this.topLevelNavigator = navigatorRef;
+                        if (this.topLevelNavigator.state) {
+                            this.trackInitialRouteForState(this.topLevelNavigator.state.nav);
+                        }
+                    }
+                }, 'Navigation event capture', true),
+                onReady: (...args) => {
+                    this.captureOnReady();
+                    if (typeof onReady === 'function') {
+                        onReady(...args);
+                    }
+                },
+                onStateChange: (...args) => {
+                    this.captureStateChange(...args);
+                    if (typeof onStateChange === 'function') {
+                        onStateChange(...args);
+                    }
+                },
+                onNavigationStateChange: (...args) => {
+                    captureOldNavigationStateChange(...args);
+                    if (typeof onNavigationStateChange === 'function') {
+                        onNavigationStateChange(...args);
+                    }
+                },
+                ...rest,
+            }, this.props.children);
+        }
+    }
+    ConvivaNavigationWrapper.displayName = `withReactNavigationAutotrack(${getComponentDisplayName(AppContainer)})`;
+    wrapperObject.__convivaWrapper = React__default.forwardRef((props, ref) => {
+        return React__default.createElement(ConvivaNavigationWrapper, { ...props, forwardedRef: ref });
+    });
+    return wrapperObject.__convivaWrapper;
+};
+
 /*
  * Copyright (c) 2020-2023 Snowplow Analytics Ltd. All rights reserved.
  *
@@ -1772,6 +2102,7 @@ controllerConfig = {}) {
     const trackDeepLinkReceivedEvent$1 = mkMethod(trackDeepLinkReceivedEvent(namespace));
     const trackMessageNotificationEvent$1 = mkMethod(trackMessageNotificationEvent(namespace));
     const trackCustomEvent$1 = mkMethod(trackCustomEvent(namespace));
+    const trackClickEvent$1 = mkMethod(trackClickEvent(namespace));
     // custom tags contexts
     const setCustomTags$1 = mkMethod(setCustomTags(namespace));
     const setCustomTagsWithCategory$1 = mkMethod(setCustomTagsWithCategory(namespace));
@@ -1834,6 +2165,7 @@ controllerConfig = {}) {
         getIsInBackground: getIsInBackground$1,
         getBackgroundIndex: getBackgroundIndex$1,
         getForegroundIndex: getForegroundIndex$1,
+        trackClickEvent: trackClickEvent$1,
     });
 }
 /**
@@ -1855,6 +2187,18 @@ function removeAllTrackers() {
     return removeAllTrackers$1()
         .catch((e) => errorHandler(e));
 }
+const autocaptureNavigationTrack = handleError((payload) => {
+    checkDisplayNamePlugin();
+    trackScreenViewEvent('CAT')(payload).catch((e) => errorHandler(e));
+}, 'Event autocapture', true);
+const autocaptureTrack = handleError((payload) => {
+    checkDisplayNamePlugin();
+    trackClickEvent('CAT')(payload).catch((e) => errorHandler(e));
+}, 'Event autocapture', true);
+var index = {
+    convivaTouchableAutoTrack: convivaTouchableAutoTrack(autocaptureTrack),
+    withReactNavigationAutotrack: withReactNavigationAutotrack(autocaptureNavigationTrack)
+};
 
-export { createTracker, getWebViewCallback, removeAllTrackers, removeTracker };
+export { autocaptureNavigationTrack, createTracker, index as default, getWebViewCallback, removeAllTrackers, removeTracker, withReactNavigationAutotrack };
 //# sourceMappingURL=conviva-react-native-appanalytics.js.map

package/instrumentation/index.js

@@ -0,0 +1,66 @@
+const t = require('babel-types');
+const template = require('babel-template');
+
+const convivaLibImport = template(`(
+  require('@convivainc/conviva-react-native-appanalytics').default || {
+    HIGHER_ORDER_COMP: (Component) => Component,
+  }
+)`);
+
+const createHigherOrderComponent = template(`
+  const COMPONENT_ID = HIGHER_ORDER_COMP_CALL_EXPRESSION;
+`);
+
+const ALLOWED_TOUCHABLE_COMPONENTS = [
+  'TouchableOpacity',
+  'TouchableNativeFeedback',
+  'TouchableWithoutFeedback',
+  'TouchableHighlight',
+];
+
+const replaceWithTouchableAutoTrackHigherOrderComponent = path => {
+  
+  if (!ALLOWED_TOUCHABLE_COMPONENTS.includes(path.node.id.name)) {
+    return;
+  }
+  // console.log("replaceWithTouchableAutoTrackHigherOrderComponent++");
+
+  const equivalentExpression = t.classExpression(
+    path.node.id,
+    path.node.superClass,
+    path.node.body,
+    path.node.decorators || []
+  );
+
+  const hocID = t.identifier('convivaTouchableAutoTrack');
+
+  const convivaImport = convivaLibImport({
+    HIGHER_ORDER_COMP: hocID,
+  });
+
+  const autotrackExpression = t.callExpression(
+    t.memberExpression(convivaImport.expression, hocID),
+    [equivalentExpression]
+  );
+
+  const replacement = createHigherOrderComponent({
+    COMPONENT_ID: path.node.id,
+    HIGHER_ORDER_COMP_CALL_EXPRESSION: autotrackExpression,
+  });
+
+  path.replaceWith(replacement);
+
+  // console.log("replaceWithTouchableAutoTrackHigherOrderComponent--");
+};
+
+function transform(babel) {
+  return {
+    visitor: {
+      ClassDeclaration(path) {
+        replaceWithTouchableAutoTrackHigherOrderComponent(path);
+      },
+    },
+  };
+}
+
+module.exports = transform;

package/ios/RNConvivaAppAnalytics.m

@@ -45,7 +45,7 @@
 #import <ConvivaAppAnalytics/CATEcommerce.h>
 #import <ConvivaAppAnalytics/CATDeepLinkReceived.h>
 #import <ConvivaAppAnalytics/CATMessageNotification.h>
-
+#import <Foundation/NSObject.h>
 
 @implementation RNConvivaTracker
 
@@ -242,6 +242,17 @@ RCT_EXPORT_METHOD(trackScreenViewEvent:
     id<CATTrackerController> trackerController = [self trackerByNamespace:namespace];
 
     if (trackerController != nil) {
+        
+        BOOL trackScreenView = NO;
+        if([(NSObject*)trackerController respondsToSelector:@selector(screenViewAutotracking)]) {
+            trackScreenView = [(NSObject*)trackerController performSelector:@selector(screenViewAutotracking)];
+        }
+        
+        if(!trackScreenView) {
+            resolve(@YES);
+            return;
+        }
+
         NSDictionary *argmap = [details objectForKey:@"eventData"];
         NSArray<NSDictionary *> *contexts = [details objectForKey:@"contexts"];
 
@@ -1048,4 +1059,61 @@ RCT_EXPORT_METHOD(getForegroundIndex:
     return [namespace isEqual:[NSNull null]] ? [CATAppAnalytics defaultTracker] : [CATAppAnalytics trackerByNamespace:namespace];
 }
 
+RCT_EXPORT_METHOD(trackClickEvent:
+                  (NSDictionary *)details
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject) {
+    
+    NSString *namespace = [details objectForKey:@"tracker"];
+
+    id<CATTrackerController> trackerController = [self trackerByNamespace:namespace];
+
+    if (trackerController != nil) {
+       
+        NSDictionary *eventData = [details objectForKey:@"eventData"];
+        
+        if(nil != eventData && 0 < eventData.count){
+            
+            NSMutableDictionary *data = [NSMutableDictionary new];
+            
+            NSString *elementType = eventData[@"elementType"] ?: @"";
+            if(0 < elementType.length){
+                data[@"elementType"] = elementType;
+            }
+            
+            NSString *elementId = eventData[@"elementId"] ?: @"";
+            if(0 < elementId.length){
+                data[@"elementId"] = elementId;
+            }
+            
+            NSString *elementName = eventData[@"elementName"] ?: @"";
+            if(0 < elementName.length){
+                data[@"elementName"] = elementName;
+            }
+            
+            NSString *elementClasses = eventData[@"elementClasses"] ?: @"";
+            if(0 < elementClasses.length){
+                data[@"elementClasses"] = elementClasses;
+            }
+            
+            NSString *elementText = eventData[@"elementText"]  ?: @"";
+            if(0 < elementText.length){
+                data[@"elementText"] = elementText;
+            }
+            
+            NSString *elementValue = eventData[@"elementValue"] ?: @"";
+            if(0 < elementValue.length){
+                data[@"elementValue"] = elementValue;
+            }
+            
+            [[NSNotificationCenter defaultCenter] postNotificationName:@"kCATNotificationButtonClick" object:nil userInfo:data];
+        }
+        
+        resolve(@(YES));
+    } else {
+        NSError* error = [NSError errorWithDomain:@"ConvivaAppAnalytics" code:200 userInfo:nil];
+        reject(@"ERROR", @"tracker with given namespace not found", error);
+    }
+}
+
 @end

package/ios/Util/RNTrackerVersion.m

@@ -22,6 +22,6 @@
 
 @implementation RNTrackerVersion
 
-NSString * const kRNTrackerVersion = @"rn-0.1.2";
+NSString * const kRNTrackerVersion = @"rn-0.1.4";
 
 @end

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@convivainc/conviva-react-native-appanalytics",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Conviva React Native Application Analytics Library",
   "main": "conviva-react-native-appanalytics.js",
   "repository": {