Integrating UXCam in your app is really simple and takes less than 5 minutes.

Follow the steps below to start capturing the user experience.


iOS Integration Documentation

CocoaPods Integration

Step 1: Integration

You’ll need to have CocoaPods installed. If you haven’t already, see this page for installation details. Once you have installed CocoaPods, Create a file called ‘Podfile’ containing this:

platform :ios, '8.0'
pod 'UXCam'
or add
pod 'UXCam'
to your existing podfile. Then from your Terminal, type the following commands:
$ pod install
Now open the XCode Workspace generated and complete Step 2: 'Start UXCam'.

Step 2: Start UXCam

// Import the UXCam Agent header at the top of your AppDelegate.m:
#import <UXCam/UXCam.h>

// Add this call as the first line of your application:didFinishLaunchingWithOptions: method
[UXCam startWithKey:@"App-key from UXCam"];
// Import the UXCam Agent header at the top of your AppDelegate
import UXCam

// Add this call as the first line of your application:didFinishLaunchingWithOptions: method
UXCam.startWithKey("App-key from UXCam")

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Manual Integration

Step 1: Integration

(a): Download

Download latest SDK.

(b): Integration

Unzip the downloaded file and drag the "UXCam.framework" from the downloaded UXCam folder into your Xcode project (dropping it onto your Project in the Project Navigator window). When prompted, select "Copy items into destination..." and "Create folder references...".

Then, add these following libraries to your Linker settings. Click on your Project in the Project Navigator window, under Targets select your app, and click the Build Phases tab. Open the "Link Binary with Libraries" list. Click the plus sign (+) and add :-
- AVFoundation
- CoreGraphics
- CoreMedia
- CoreVideo
- MobileCoreServices
- QuartzCore
- SystemConfiguration

(c) Add $(OTHER_LDFLAGS) -ObjC to your linker flag

Select your project under the PROJECT heading in the Project Navigator, then select the Build Settings tab.

Scroll to Other Linker Flags and Set the value of the Other Linker Flags build setting to $(OTHER_LDFLAGS) -ObjC

Step 2: Start UXCam

// Import the UXCam Agent header at the top of your AppDelegate.m:
#import <UXCam/UXCam.h>

// Add this call as the first line of your application:didFinishLaunchingWithOptions: method
[UXCam startWithKey:@"App-key from UXCam"];
// Import the UXCam Agent header at the top of your AppDelegate
import UXCam

// Add this call as the first line of your application:didFinishLaunchingWithOptions: method
UXCam.startWithKey("App-key from UXCam")

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Android Integration Documentation

Gradle Integration

Step 1: Gradle Integration

In module's build.gradle file add:

repositories {
	maven{
	    url 'http://sdk.uxcam.com/android/'
	}
}
dependencies {
	compile 'com.uxcam:uxcam:2.6.2@aar'
}

Step 2:

In every activity that is an entry point to your app add
import com.uxcam.UXCam;
and add UXCam.startWithKey("App-key from UXCam"); inside onCreate method.
UXCam.startWithKey("App-key from UXCam");
* Entry activities are usually those who have a custom <intent-filter> element in the AndroidManifest.xml file.

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Sample Code
Your entry point activity should be like below:

import com.uxcam.UXCam;
public class SampleActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        UXCam.startWithKey("App-key from UXCam");
    }
}
Try using our sample apps from GitHub
Note: If you are using ProGuard*​

Add the following line in Proguard rules for compilation:
-keep class com.uxcam.** { *; }
-dontwarn com.uxcam.**

AAR Integration

Step 1: AAR Integration

(a): Download

Download latest SDK.

(b): Integration

i) Add the uxcam-2.6.2.aar file to the "libs" folder of your Android project.

ii) In module's build.gradle file add:

repositories {
    flatDir {
        dirs 'libs'
    }
}
dependencies {
    compile(name: 'uxcam-2.6.2', ext: 'aar')
}

Step 2:

In every activity that is an entry point to your app * add
import com.uxcam.UXCam;
and add UXCam.startWithKey("App-key from UXCam"); inside onCreate method.
UXCam.startWithKey("App-key from UXCam");
* Entry activities are usually those who have a custom <intent-filter> element in the AndroidManifest.xml file.

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Sample Code
Your entry point activity should be like below:

import com.uxcam.UXCam;
public class SampleActivity extends Activity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        UXCam.startWithKey("App-key from UXCam");
    }
}
Try using our sample apps from GitHub
Note: If you are using ProGuard*​

Add the following line in Proguard rules for compilation:
-keep class com.uxcam.** { *; }
-dontwarn com.uxcam.**

JAR Integration

Step 1: Integration

(a): Download

Download latest SDK.

(b): Integration

i) Add the uxcam-2.6.2.jar file to the "libs" folder of your Android project.

ii) In module's build.gradle file add:

dependencies {
	compile files('libs/uxcam-2.6.2.jar')
}

Step 2: Edit AndroidManifest.xml

(a): Make sure the following permissions are present:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>

(b): Add following services inside your application tag:

<service android:name="com.uxcam.service.HttpPostService"/>

Step 3:

In every activity that is an entry point to your app add
import com.uxcam.UXCam;
and add UXCam.startWithKey("App-key from UXCam"); inside onCreate method.
UXCam.startWithKey("App-key from UXCam");
* Entry activities are usually those who have a custom <intent-filter> element in the AndroidManifest.xml file.

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Sample Code
Your entry point activity should be like below:

import com.uxcam.UXCam;
	public class SampleActivity extends Activity {
		@Override
		protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		UXCam.startWithKey("App-key from UXCam");
	}
}
Try using our sample apps from GitHub
Note: If you are using ProGuard*​

Add the following line in Proguard rules for compilation:
-keep class com.uxcam.** { *; }
-dontwarn com.uxcam.**

Eclipse Integration

Step 1: Eclipse Integration

(a): Download

Download latest SDK.

(b): Integration

i) Add the uxcam-2.6.2.jar file to the "libs" folder of your Android project.

(c): Add uxcam-2.6.2.jar to your build path:

Right-click on your Android project → Properties→ Java Build Path→ Libraries→ Add Jars→ navigate to libs/uxcam-2.6.2.jar

Step 2:Edit AndroidManifest.xml

(a): Make sure the following permissions are present:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

(b): Add following services inside your application tag:

<service android:name="com.uxcam.service.HttpPostService"/>

Step 3:

In every activity that is an entry point to your app add
import com.uxcam.UXCam;
and add UXCam.startWithKey("App-key from UXCam"); inside onCreate method.
UXCam.startWithKey("App-key from UXCam");
* Entry activities are usually those who have a custom <intent-filter> element in the AndroidManifest.xml file.

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Sample Code
Your entry point activity should be like below:

import com.uxcam.UXCam;
	public class SampleActivity extends Activity {
		@Override
		protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		UXCam.startWithKey("App-key from UXCam");
	}
}
Try using our sample apps from GitHub
Note: If you are using ProGuard*​

Add the following line in Proguard rules for compilation:
-keep class com.uxcam.** { *; }
-dontwarn com.uxcam.**

Other Integrations

Step 1: Integration on Other IDE's

(a): Download

Download latest SDK.

(b): Integration

Add dependencies for downloaded UXCam library file.

Step 2: Edit AndroidManifest.xml

(a): Make sure the following permissions are present:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

(b): Add following services inside your application tag:

<service android:name="com.uxcam.service.HttpPostService"/>

Step 3:

In every activity that is an entry point to your app add
import com.uxcam.UXCam;
and add UXCam.startWithKey("App-key from UXCam"); inside onCreate method.
UXCam.startWithKey("App-key from UXCam");
* Entry activities are usually those who have a custom <intent-filter> element in the AndroidManifest.xml file.

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Sample Code
Your entry point activity should be like below:

import com.uxcam.UXCam;
	public class SampleActivity extends Activity {
		@Override
		protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		UXCam.startWithKey("App-key from UXCam");
	}
}
Try using our sample apps from GitHub
Note: If you are using ProGuard*​

Add the following line in Proguard rules for compilation:
-keep class com.uxcam.** { *; }
-dontwarn com.uxcam.**

Phonegap Integration

Step 1: Integration with PhoneGap/Cordova

cordova plugin add cordova-uxcam
or
phonegap plugin add cordova-uxcam

Step 2: Start UXCam

Call this method on deviceready
UXCam.startWithKey("App-key from UXCam");

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Xamarin Integration

Step 1: Download Xamarin component

For reference on including a component into your project look here.

Step 2: Start UXCam

// a) Import the UXCam agent header at the top of your AppDelegate.m:

  using Com.UXCam;

// b) Add this call as the first line of your application: didFinishLaunchingWithOptions: method

  UXCam.StartWithKey("App-key from UXCam");


// Edit AndroidManifest.xml

// a) Make sure the following permissions are present:

<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />

// b) Add following services inside your application tag:

<service android:name="com.uxcam.service.HttpPostService"/>

//In every activity that is an entry point to your app add

Using Com.UXCam;

// and add UXCam.startApplicationWithKey("App-key") inside onCreate method.

UXCam.startWithKey("App-key from UXCam");

// Entry activities are usually those who have a custom <intent-filter> element in the AndroidManifest.xml file.

Sample Code
Your entry point activity should be like below:

using Com.UXCam;
namespace SampleApp
{
    public class MainActivity : Activity
    {
        protected override void OnCreate (Bundle bundle)
        {
            base.OnCreate (bundle);
            // Set our view from the "main" layout resource
            SetContentView (Resource.Layout.Main);

            UXCam.startWithKey("App-key from UXCam");
        }
    }
}

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Appcelerator Integration

Step 1: Download the latest Appcelerator module for UXCam from Appcelerator Marketplace

(a): Download

Download latest Appcelerator module for UXCam

(b): Register the module

Register UXCam module within your application by editing tiapp.xml and adding UXCam module.

//Example:

<modules>
    <module version="0.1">com.uxcam</module>
</modules>

// Upon running the project, the compiler will combine your module along with its dependencies and assets into the application.

Step 2: Use the module

//In your app.js file add the following:

var UXCam = require('com.uxcam');

// Add the following line after the window is initialized

UXCam.startWithKey("App-key from UXCam");

That completes the integration process.
Your session will be shown on the dashboard within few seconds, after the app goes in the background. You can optionally use the API for customization such ​as identify users​ from your database with UXCam, ​tag sessions, or ​hide sensitive views.

Unity Integration

UXCam currently supports Unity on iOS only. Follow steps from iOS to integrate Unity.

API Reference

startWithKey
Starts the UXCam application to ping the server, get the settings configurations and start capturing the data according to the configuration. Use startWithKey with appVariantIdentifier parameter to separate Debug and Release builds

// Parameters
// applicationKey: An NSString object that contains the applicationKey received from UXCam.com after creating an account

//appVariantIdentifier: This string is added to the app bundle ID and name to differentiate builds of the same app on the UXCam dashboard - useful for seperating Debug and Release builds - pass nil for default values

+ (void) startWithKey:(NSString*) applicationKey;

+ (void) startWithKey:(NSString*)userAPIKey
appVariantIdentifier:(NSString*)appVariant;
// Parameters
// UXCamKey: String that contains the application Key received from UXCam.com after creating account

// buildIdentifier: This string is added to the app bundle ID and name to differentiate builds of the same app on the UXCam dashboard - useful for seperating Debug and Release builds

UXCam.startWithKey(UXCamKey);

UXCam.startWithKey(UXCamKey, buildIdentifier);
// Parameters
// UXCamKey: String that contains the application Key received from UXCam.com after creating account

UXCam.StartWithKey(UXCamKey);

stopApplicationAndUploadData (optional)
Stops the UXCam application and sends captured data to the server. Use this to start sending the data on UXCam server without the app going on background.

+ (void) stopApplicationAndUploadData;
UXCam.stopApplicationAndUploadData();
UXCam.StopApplicationAndUploadData();

occludeSensitiveView (optional)
Hide views that contains sensitive information or you do not want recording on.

// Parameters
// sensitiveView: A UIView object that contains senstive information

+(void) occludeSensitiveView:(UIView*)sensitiveView;
// Parameters
// sensitiveView: A View object that contains sensitive information

UXCam.occludeSensitiveView(sensitiveView);
// Parameters
// sensitiveView: A View object that contains sensitive information

UXCam.OccludeSensitiveView(sensitiveView);

occludeSensitiveScreen (optional)
Hides / un-hides screen that contains sensitive information or you do not want recording on. Call once with 'true' to start hiding the screen and later with 'false' to record normal contents again.

// Parameters
// occlude: true to start hiding or false to stop hiding

+ (void) occludeSensitiveScreen:(BOOL) occlude;
// Parameters
// occlude: true to start hiding or false to stop hiding

UXCam.occludeSensitiveScreen(boolean occlude);
// Parameters
// occlude: true to start hiding or false to stop hiding

UXCam.OccludeSensitiveScreen(boolean occlude);

tagScreenName (optional)
UXCam captures the view controller name automatically but in case where it doesn’t (such as in OpenGL) or you would like to set a different unique name, use this function.

// Parameters
// screenName: An NSString object of the name of the screen as required.

+(void) tagScreenName:(NSString*)screenName;
// Parameters
// screenName: The name of the screen as required.

UXCam.tagScreenName("screenName");
// Parameters
// screenName: The name of the screen as required.

UXCam.TagScreenName("screenName");

tagUsersName (optional)
UXCam uses a unique number to tag a device. You can tag a device allowing you to search for it on the dashboard and review their session further.

// Parameters
// userName: An NSString object of the tag of device

+(void) tagUsersName:(NSString*) userName;
// Parameters
// userName: The name of the tag of device

UXCam.tagUsersName("userName");
// Parameters
// userName: The name of the tag of device

UXCam.TagUsersName("userName");

markUserAsFavorite (optional)
You can mark a user specifically if certain condition are met making them a good user for further testing. You can then filter these users and perform further test.

+(void) markUserAsFavorite;
UXCam.markUserAsFavorite();
UXCam.MarkUserAsFavorite();

addTagWithProperties (optional)
Insert a general tag, with associated properties, into the timeline - stores the tag with the timestamp when it was added.

//Parameters
// tag: A tag to attach to the session recording at the current time
// properties: (Optional) An NSDictionary of properties to associate with this tag

+ (void) addTag:(NSString*)tag withProperties:(NSDictionary*)properties;
//Parameters
// tag : A tag to attach to the session recording at the current time
// properties : Map<String, String> of properties to associate with this tag

Map<String, String> properties = new HashMap<>();

properties.put("property1", "value1");

UXCam.addTagWithProperties("Tag", properties);
//Parameters
// tag : A tag to attach to the session recording at the current time
// properties : Map<String, String> of properties to associate with this tag

Map<String, String> properties = new HashMap<>();

properties.put("property1", "value1");

UXCam.AddTagWithProperties("Tag", properties);

urlForCurrentUser (optional)
This returns a URL path for showing all the current users sessions. 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
*/

+ (NSString*) urlForCurrentUser;
//@return url path for user session or null if no verified session is active

UXCam.urlForCurrentUser();
//@return url path for user session or null if no verified session is active

UXCam.UrlForCurrentUser();

urlForCurrentSession (optional)
This returns a URL path that shows the current session when it completes. This can be used for tying in the current user with other analytics systems.

/*
*  @return url path for current session or nil if no verified session is active
*/

+ (NSString*) urlForCurrentSession;
// @return url path for current session or null if no verified session is active

UXCam.urlForCurrentSession();
// @return url path for current session or null if no verified session is active

UXCam.UrlForCurrentSession();

setGoogleMapFragment (optional)
Record google map v2

// Parameters
// mapFragment: MapFragment object to be recorded
// supportMapFragment: SupportMapFragment object to be recorded

UXCam.setGoogleMapFragment(MapFragment mapFragment);

//or

UXCam.setGoogleMapFragment(SupportMapFragment supportMapFragment);