react-native-ux-cam 5.4.16 → 6.0.0

package/src/UXCam.js

@@ -0,0 +1,343 @@
+import { Platform, NativeModules, findNodeHandle, NativeEventEmitter } from 'react-native'
+
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+const UXCamBridge = isTurboModuleEnabled ? require("./NativeRNUxcam").default : NativeModules.RNUxcam;
+
+const RNUxcam_VerifyEvent_Name = 'UXCam_Verification_Event';
+
+// Capture the platform we are running on
+const platform = Platform.OS;
+const platformIOS = platform === "ios" ? true : false;
+const platformAndroid = platform === "android" ? true : false;
+
+export default class UXCam {
+    
+    static startWithConfiguration(configuration) {
+        UXCamBridge.startWithConfiguration(configuration);
+    }
+
+    static startWithKey(userAppKey) {
+        const configuration = { "userAppKey": userAppKey };
+        UXCam.startWithConfiguration(configuration);
+    }
+
+    static applyOcclusion(occlusion) {
+        UXCamBridge.applyOcclusion(occlusion);
+    }
+
+    static removeOcclusion(occlusion) {
+        UXCamBridge.removeOcclusion(occlusion);
+    }
+
+    static addVerificationListener(status) {
+        const emitter = new NativeEventEmitter(UXCamBridge);
+        return emitter.addListener(RNUxcam_VerifyEvent_Name, status)
+    }
+
+    /**
+    *  This will opt this device into session recordings
+    *  - any current session will be stopped and a new session will be started with the last settings passed to `startWithKey`
+    */
+    static optInOverall() {
+        UXCamBridge.optInOverall();
+    }
+
+    /**
+    *  This will cancel any current session recording and opt this device out of future session recordings until `optInOverall` is called
+    *  @note The default is to opt-in to session recordings, but not to screen recordings, and the defaults will be reset if the user un-installs and re-installs the app
+    */
+    static optOutOverall() {
+        UXCamBridge.optOutOverall();
+    }
+
+    /**
+    *  This will opt this device back into session recordings
+    */
+    static optIntoSchematicRecordings() {
+        if (platformIOS) {
+            UXCamBridge.optIntoSchematicRecordings();
+        }
+    }
+
+    /**
+     *  This will opt this device out of schematic recordings for future sessions
+     *  - any current session will be stopped and restarted with the last settings passed to `startWithKey`
+     */
+    static optOutOfSchematicRecordings() {
+        if (platformIOS) {
+            UXCamBridge.optOutOfSchematicRecordings();
+        }
+    }
+
+    /**
+     *  Returns the opt-in status of this device
+     *  @return `true` if the device is opted in to session recordings, `false` otherwise. The default is `false`.
+     */
+    static optInOverallStatus() {
+        return UXCamBridge.optInOverallStatus();
+    }
+
+    /** Returns the opt-in status of this device for schematic recordings
+     *  @returns `true` if the device is opted in to schematic recordings, `false` otherwise. The default is `false`.
+     *  @note Use in conjunction with optInOverallStatus to control the overall recording status for the device
+     */
+    static optInSchematicRecordingStatus() {
+        if (platformIOS) {
+            return UXCamBridge.optInSchematicRecordingStatus();
+        } else {
+            // Just return the general status for Android which doesn't currently split status between session data and video
+            return UXCamBridge.optInOverallStatus();
+        }
+    }
+
+    /**
+    *  @brief Android only.
+    *  This will opt this device into video recording for future sessions.
+    */
+    static optIntoVideoRecording() {
+        if (platformAndroid) {
+            UXCamBridge.optIntoVideoRecording();
+        } else if (platformIOS) {
+            UXCamBridge.optIntoSchematicRecordings();
+        }
+    }
+
+    /**
+    *  @brief Android only.
+    *  This will opt this device out of video recording for future sessions.
+    */
+    static optOutOfVideoRecording() {
+        if (platformAndroid) {
+            UXCamBridge.optOutOfVideoRecording();
+        } else if (platformIOS) {
+            UXCamBridge.optOutOfSchematicRecordings();
+        }
+    }
+
+    /**
+     * @brief Android only.
+     *  Returns the opt-in video status of this device
+     *  @return `true` if the device is opted in for video recordings, `false` otherwise.
+     */
+    static optInVideoRecordingStatus() {
+        if (platformAndroid) {
+            return UXCamBridge.optInVideoRecordingStatus();
+        } else if (platformIOS) {
+            return UXCamBridge.optInSchematicRecordingStatus();
+        }
+        return false;
+    }
+
+    /**
+    * Starts a new session after the {@link #stopSessionAndUploadData()} method has been called.
+    * This happens automatically when the app returns from background.
+    */
+    static startNewSession() {
+        UXCamBridge.startNewSession();
+    }
+
+    /**
+     * Stop current uxcam session and send captured data to server.<br>
+     * Use this to start sending the data on UXCam server without the app going into the background.<br>
+     * This starts an asynchronous process and returns immediately.
+     */
+    static stopSessionAndUploadData() {
+        UXCamBridge.stopSessionAndUploadData();
+    }
+
+    /**
+     *  Cancels the recording of the current session and discards the data
+     *
+     * @note A new session will start as normal when the app nexts come out of the background (depending on the state of the MultiSessionRecord flag), or if you call `startNewSession`
+    */
+    static cancelCurrentSession() {
+        UXCamBridge.cancelCurrentSession();
+    }
+
+    /**
+     *  Returns a URL path that shows the current session when it compeletes
+     *
+     *  @note This can be used for tying in the current session with other analytics systems
+     *
+     *  @return url path for current session or nil if no verified session is active
+     */
+    static async urlForCurrentSession() {
+        return UXCamBridge.urlForCurrentSession();
+    }
+
+    /**
+     *  Returns a URL path for showing all the current users sessions
+     *
+     *  @note This can be used for tying in the current user with other analytics systems
+     *
+     *  @return url path for user session or nil if no verified session is active
+     */
+    static async urlForCurrentUser() {
+        return UXCamBridge.urlForCurrentUser();
+    }
+
+    /**
+     *  @brief IOS only. Uploads sessions that were pending to be uploaded
+     *
+     *  Sessions can be in the Pending state if UXCam was unable to upload them at the end of the last session. Normally they will be sent at the end of the next session.
+     */
+    static uploadPendingSession() {
+        return UXCamBridge.uploadPendingSession();
+    }
+
+    /**
+     *  @brief Returns how many sessions are waiting to be uploaded
+     *
+     *  Sessions can be in the Pending state if UXCam was unable to upload them at the end of the last session. Normally they will be sent at the end of the next session.
+     */
+    static pendingSessionCount() {
+        return UXCamBridge.pendingSessionCount();
+    }
+
+    /**
+     *  @brief Deletes any sessions that are awaiting upload
+     *  @note Advanced use only. This is not needed for most developers. This can't be called until UXCam startWithKey: has completed
+     */
+    static deletePendingUploads() {
+        UXCamBridge.deletePendingUploads();
+    }
+
+    /**
+     *  By default UXCam will end a session immediately when your app goes into the background. But if you are switching over to another app for authorisation, or some other short action, and want the session to continue when the user comes back to your app then call this method with a value of `true` before switching away to the other app.
+     *  UXCam will pause the current session as your app goes into the background and then continue the session when your app resumes. If your app doesn't resume within a couple of minutes the original session will be closed as normal and a new session will start when your app eventually is resumed.
+     *  @param duration Set time to wait in `milliseconds` before finishing the session.
+     */
+    static allowShortBreakForAnotherApp(duration) {
+        if (typeof duration == 'boolean') {
+            UXCamBridge.allowShortBreakForAnotherApp(duration);
+        } else if (typeof duration == 'number') {
+            UXCamBridge.allowShortBreakForAnotherAppInMillis(duration);
+        }
+        
+    }
+
+    /**
+     *  @brief Resume after short break. Only used in android, does nothing on iOS
+     */
+    static resumeShortBreakForAnotherApp() {
+        UXCamBridge.resumeShortBreakForAnotherApp();
+    }
+
+    /**
+    *  Returns the current recording status
+    *
+    *  @return `true` if the session is being recorded
+    */
+    static isRecording() {
+        return UXCamBridge.isRecording();
+    }
+
+    /**
+     * Pause the screen recording
+     */
+    static pauseScreenRecording() {
+        UXCamBridge.pauseScreenRecording();
+    }
+
+    /**
+     *  Resumes a paused session - will cancel any remaining pause time and resume screen recording
+     */
+    static resumeScreenRecording() {
+        UXCamBridge.resumeScreenRecording();
+    }
+
+    /**
+        UXCam normally captures the view controller name automatically but in cases where it this is not sufficient (such as in OpenGL applications)
+        or where you would like to set a different unique name, use this function to set the name.
+    
+        @parameter screenName Name to apply to the current screen in the session video
+    */
+    static tagScreenName(screenName) {
+        UXCamBridge.tagScreenName(screenName);
+    }
+
+    /**
+        Insert a general event, with associated properties, into the timeline - stores the event with the timestamp when it was added.
+     
+        @parameter eventName Name of the event to attach to the session recording at the current time
+        @parameter properties An Object of properties to associate with this event
+     
+        @note Only number and string property types are supported to a maximum count of 100 and maximum size per entry of 1KiB
+     */
+    static logEvent(eventName, properties) {
+        UXCamBridge.logEvent(eventName, properties);
+    }
+
+     /**
+     UXCam uses a unique number to tag a device.
+     You can set a user identity for a device allowing you to more easily search for it on the dashboard and review their sessions further.
+     
+     @parameters userIdentity String to apply to this user (device) in this recording session
+     */
+     static setUserIdentity(userIdentity) {
+        UXCamBridge.setUserIdentity(userIdentity);
+    }
+
+    /**
+     Add a key/value property for this user
+     
+     @parameter propertyName Name of the property to attach to the user
+     @parameter value A value to associate with this property
+     
+     @note Only number and string value types are supported to a maximum size per entry of 1KiB
+     */
+     static setUserProperty(propertyName, value) {
+        if (typeof value == 'number') {
+            UXCamBridge.setUserProperty(propertyName, value.toString());
+        } else if (typeof value == 'string') {
+            UXCamBridge.setUserProperty(propertyName, value);
+        }
+    }
+
+    /**
+     Add a single key/value property to this session
+     
+     @parameter propertyName Name of the property to attach to the session recording
+     @parameter value A value to associate with this property
+     
+     @note Only number and string value types are supported to a maximum size per entry of 1KiB
+     */
+    static setSessionProperty(propertyName, value) {
+        if (typeof value == 'number') {
+            UXCamBridge.setSessionProperty(propertyName, value.toString());
+        } else if (typeof value == 'string') {
+            UXCamBridge.setSessionProperty(propertyName, value);
+        }
+    }
+
+    static occludeAllTextFields(occludeAll) {
+        UXCamBridge.occludeAllTextFields(occludeAll);
+    }
+
+    static occludeSensitiveScreen(hideScreen, hideGestures) {
+        if (typeof hideGestures !== "undefined") {
+            UXCamBridge.occludeSensitiveScreen(hideScreen, hideGestures);
+        } else {
+            UXCamBridge.occludeSensitiveScreen(hideScreen, true);
+        }
+    }
+
+    static occludeSensitiveView(sensitiveView) {
+        if (sensitiveView) {
+            UXCamBridge.occludeSensitiveView(findNodeHandle(sensitiveView), false);
+        }
+    }
+
+    static occludeSensitiveViewWithoutGesture(sensitiveView) {
+        if (sensitiveView) {
+            UXCamBridge.occludeSensitiveView(findNodeHandle(sensitiveView), true);
+        }
+    }
+
+    static unOccludeSensitiveView(view) {
+        if (view) {
+            UXCamBridge.unOccludeSensitiveView(findNodeHandle(view));
+        }
+    }
+
+}

package/src/UXCamOcclusion.tsx

@@ -0,0 +1,29 @@
+
+import { Occlusion, OcclusionType } from "./types";
+
+export class UXBlur implements Occlusion {
+    readonly type: OcclusionType;
+    constructor() {
+        this.type = OcclusionType.Blur;
+    }
+
+    blurRadius?: number;
+    hideGestures?: boolean;
+}
+
+export class UXOverlay implements Occlusion {
+    readonly type: OcclusionType;
+    constructor() {
+        this.type = OcclusionType.Overlay;
+    }
+
+    color?: number;
+    hideGestures?: boolean;
+}
+
+export class UXOcclueAllTextFields implements Occlusion {
+    readonly type: OcclusionType;
+    constructor() {
+        this.type = OcclusionType.OccludeAllTextFields;
+    }
+}

package/{index.d.ts → src/index.d.ts}

@@ -1,5 +1,7 @@
 import { EmitterSubscription } from "react-native";
-import UXCamOcclusion from "./UXCamOcclusion";
+import { Configuration, Occlusion } from "./types";
+
+export * from './types';
 
 export default class UXCam {
     /**
@@ -8,7 +10,7 @@ export default class UXCam {
      *  @brief Start the UXCam session
      *  @parameter configuration   The configuration to identify your UXCam app - find appKey in the UXCam dashboard for your account 
      */
-    static startWithConfiguration: (configuration: UXCamConfiguration) => void;
+    static startWithConfiguration: (configuration: Configuration) => void;
 
     /**
      *  @deprecated Use {@link #startWithConfiguration(configuration)} instead to start new session
@@ -16,28 +18,18 @@ export default class UXCam {
      *  @brief Start the UXCam session
      *  @parameter userAppKey   The key to identify your UXCam app - find it in the UXCam dashboard for your account 
      */
-     static startWithKey: (appKey: string) => void;
-
-    /**
-     * Returns configuration object for current session
-     */
-    static configurationForUXCam: () => Promise<UXCamConfiguration | undefined | null>;
-   
-    /**
-     * Update current configuration with different values
-     */
-    static updateConfiguration: (configuration: UXCamConfiguration) => void;
+     static startWithKey: (userAppKey: string) => void;
 
     /**
      * Apply manual occlusion to screens in the app. 
      * This will be applied to all the screens until it is not removed manually again using {@link #removeOcclusion(occlusion)} method
      */
-    static applyOcclusion: (occlusion: UXCamOcclusion) => void;
+    static applyOcclusion: (occlusion: Occlusion) => void;
 
     /**
      * Remove manual occlusion from the app that was applied using {@link #applyOcclusion(occlusion)} method
      */
-    static removeOcclusion: (occlusion: UXCamOcclusion) => void;
+    static removeOcclusion: (occlusion: Occlusion) => void;
     /**
      * Starts a new session after the {@link #stopSessionAndUploadData()} method has been called.
      * This happens automatically when the app returns from background.
@@ -78,16 +70,7 @@ export default class UXCam {
         @parameter hideScreen Set `true` to hide the screen from the recording, `false` to start recording the screen contents again
         @parameter hideGesture Set `true` to hide the gestures in the screen from the recording, `false` to start recording the gestures in the screen again
     */
-    static occludeSensitiveScreen: (hideScreen: boolean, hideGesture?: boolean) => void;
-
-    /**
-        Hide / un-hide all UITextField views on the screen
-     
-        Call this when you want to hide the contents of all UITextFields from the screen capture. Default is `false`.
-     
-        @parameter occludeAll Set `true` to hide all UITextField views on the screen in the recording, `false` to stop occluding them from the screen recording.
-     */
-    static occludeAllTextView: () => void;
+    static occludeSensitiveScreen: (hideScreen: boolean, hideGestures?: boolean) => void;
 
     /**
         Hide / un-hide all UITextField views on the screen
@@ -134,7 +117,7 @@ export default class UXCam {
      
         @note Only number and string property types are supported to a maximum count of 100 and maximum size per entry of 1KiB
      */
-    static logEvent: (eventName: string, properties?: any) => void;
+    static logEvent: (eventName: string, properties?: Object) => void;
 
     /**
         UXCam verification listener that returns success/failure status. TRUE status means the session was successfully verified and started.
@@ -142,14 +125,6 @@ export default class UXCam {
      */
     static addVerificationListener: (status: (status: { success: boolean })=>void) => EmitterSubscription;
 
-	/**
- 	*  @brief Call this before calling startWithKey to disable UXCam from capturing sessions that crash
- 	*
- 	*  @param disable `true` to disable crash capture
- 	*  @note By default crash handling is enabled.
- 	*/
-	static disableCrashHandling: (disable: boolean) => void;
-
     /**
      *  Returns the current recording status
      *
@@ -260,19 +235,6 @@ export default class UXCam {
      */
     static resumeShortBreakForAnotherApp: () => void;
 
-    /**
-     *  Get whether UXCam is set to automatically record a new session when the app resumes from the background
-    */
-    static getMultiSessionRecord: () => boolean;
-
-    /**
-     *  Set whether to record multiple sessions or not
-     *
-     *  @parameter multiSessionRecord `true` to record a new session automatically when the device comes out of the background. If `false` then a single session is recorded, when stopped (either programmatically with `stopApplicationAndUploadData` or by the app going to the background) then no more sessions are recorded until `startWithKey` is called again).
-     *  @note The default setting is to record a new session each time a device comes out of the background. This flag can be set to `false` to stop that. You can also set this with the appropriate startWithKey: variant. (This will be reset each time startWithKey is called)
-    */
-    static setMultiSessionRecord: (multiSessionRecord: boolean) => void;
-
     /**
      *  @brief Deletes any sessions that are awaiting upload
      *  @note Advanced use only. This is not needed for most developers. This can't be called until UXCam startWithKey: has completed
@@ -324,87 +286,4 @@ export default class UXCam {
         @parameter screenName Name to apply to the current screen in the session video
     */
     static tagScreenName: (screenName: string) => void;
-
-    /**
-        Enable / disable the automatic tagging of screen names
-        
-        @note By default UXCam will tag new screen names automatically. You can override this using the `tagScreenName` method or use this method to disable the automatic tagging.
-    
-        @parameters autoScreenTagging Set to `true` to enable automatic screen name tagging (the default) or `false` to disable it
-    */
-    static setAutomaticScreenNameTagging: (autoScreenTagging: boolean) => void;
-
-    /**
-        Add a name to the list of screens names that wont be added to the timeline in automatic screen name tagging mode
-    
-        This will not impact gesture or action recording - just that the timeline on the dashboard will not contain an entry for this screen name if it appears after this call.
-        Use this if you have view controllers that are presented but which are not primary user interaction screens to make your dashboard timeline easier to understand.
-    
-        @param screenName A name to add to the list of screens to ignore
-    
-        @note This is a convenience method for `addScreenNamesToIgnore([nameToIgnore])`
-    */
-    static addScreenNameToIgnore: (screenName: string) => void;
-
-    /**
-        Add a list of names to the list of screens names that wont be added to the timeline in automatic screen name tagging mode
-    
-        This will not impact gesture or action recording - just that the timeline on the dashboard will not contain an entry for any of the screens in this list encountered after this call.
-        Use this if you have view controllers that are presented but which are not primary user interaction screens to make your dashboard timeline easier to understand.
-    
-        @param screenNames A list of screen names to add to the ignore list
-    */
-    static addScreenNamesToIgnore: (screenNames: string[]) => void;
-
-    /**
-        Remove the a name from the list of screens to be ignored in automatic screen name tagging mode
-
-        @param screenName The name to remove from the list of ignored screens
-        @note This is a convenience method for `removeScreenNamesToIgnore([nameToRemove])`
-    */
-    static removeScreenNameToIgnore: (screenName: string) => void;
-
-    /**
-        Remove the a list of names from the list of screens to be ignored in automatic screen name tagging mode
-    
-        @param screenNames A list of names to remove from the ignore list
-    */
-    static removeScreenNamesToIgnore: (screenNames: string[]) => void;
-
-    // Remove all entries from the list of screen names to be ignored in automatic screen name tagging mode
-    static removeAllScreenNamesToIgnore: () => void;
-
-    // Get the list of screen names that are being ignored in automatic screen name tagging mode
-    static screenNamesBeingIgnored: () => string[];
-
-    /**
-        Set the token to be used to send push notifications to the app
-        @param token Push notification token
-    */
-    static setPushNotificationToken: (token: string) => void;
-
-    /** 
-        Send a report of a problem your app encountered to be displayed in the dashboard
-        @param eventName Name of the problem event
-        @param properties Properties object associated with the event
-        @note Only number and string property types are supported to a maximum count of 100 and maximum size per entry of 1KiB
-    */
-    static reportBugEvent: (eventName: string, properties?: any) => void;
-
-    /** 
-        Enable/Disable advanced gesture recognition like swipe and pinch gestures.
-        @param enable Set `true` to enable or `false` to disable before `startWithKey`. Default is `true`.
-        @note Disable this on iOS if you are having problems with swipes or other gestures being interrupted while recording sessions.
-    */
-    static enableAdvancedGestureRecognizers: (enable: boolean) => void;
-}
-
-export interface UXCamConfiguration {
-    userAppKey: string;
-    enableMultiSessionRecord?: boolean;
-    enableCrashHandling?: boolean;
-    enableAutomaticScreenNameTagging?: boolean;
-    enableAdvancedGestureRecognition?: boolean;
-    enableNetworkLogging?: boolean;
-    occlusions?: UXCamOcclusion[];
 }

package/src/index.js

@@ -0,0 +1,3 @@
+
+// @flow
+export default require("./UXCam").default;

package/src/types.ts

@@ -0,0 +1,19 @@
+export interface Configuration {
+    userAppKey: string;
+    enableMultiSessionRecord?: boolean;
+    enableCrashHandling?: boolean;
+    enableAutomaticScreenNameTagging?: boolean;
+    enableAdvancedGestureRecognition?: boolean;
+    enableNetworkLogging?: boolean;
+    occlusions?: Occlusion[];
+}
+
+export enum OcclusionType {
+    OccludeAllTextFields = 1,
+    Overlay = 2,
+    Blur = 3
+}
+
+export interface Occlusion {
+    readonly type: OcclusionType;
+}