From 49fbc0de17d4b40f5dfaf6e7ff0811a2e42c07eb Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Thu, 10 Mar 2016 14:04:27 +0100
Subject: [PATCH 01/37] Read abi and display

---
 .../main/java/com/adjust/sdk/DeviceInfo.java  | 20 +++++++++++
 .../java/com/adjust/sdk/PackageBuilder.java   |  2 ++
 .../main/java/com/adjust/sdk/Reflection.java  | 33 +++++++++++++++++++
 .../src/main/java/com/adjust/sdk/Util.java    |  8 +++++
 4 files changed, 63 insertions(+)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/DeviceInfo.java b/Adjust/adjust/src/main/java/com/adjust/sdk/DeviceInfo.java
index 7780dd5f9..a3dbcfbea 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/DeviceInfo.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/DeviceInfo.java
@@ -47,6 +47,8 @@ class DeviceInfo {
     String screenDensity;
     String displayWidth;
     String displayHeight;
+    String hardwareName;
+    String abi;
     Map<String, String> pluginKeys;
 
     DeviceInfo(Context context, String sdkPrefix) {
@@ -79,6 +81,8 @@ class DeviceInfo {
         pluginKeys = Util.getPluginKeys(context);
         macSha1 = getMacSha1(macAddress);
         macShortMd5 = getMacShortMd5(macAddress);
+        hardwareName = getHardwareName();
+        abi = getABI();
     }
 
     private String getMacAddress(Context context, boolean isGooglePlayServicesAvailable) {
@@ -150,6 +154,10 @@ private String getCountry(Locale locale) {
         return locale.getCountry();
     }
 
+    private String getHardwareName() {
+        return Build.DISPLAY;
+    }
+
     private String getScreenSize(int screenLayout) {
         int screenSize = screenLayout & Configuration.SCREENLAYOUT_SIZE_MASK;
 
@@ -261,4 +269,16 @@ private String getFacebookAttributionId(final Context context) {
             return null;
         }
     }
+
+    private String getABI() {
+        String[] SupportedABIS = Util.getSupportedAbis();
+
+        // SUPPORTED_ABIS is only supported in API level 21
+        // get CPU_ABI instead
+        if (SupportedABIS == null || SupportedABIS.length == 0) {
+            return Util.getCpuAbi();
+        }
+
+        return SupportedABIS[0];
+    }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
index 7791aae33..e8606567a 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
@@ -150,6 +150,8 @@ private void injectDeviceInfo(Map<String, String> parameters) {
         addString(parameters, "screen_density", deviceInfo.screenDensity);
         addString(parameters, "display_width", deviceInfo.displayWidth);
         addString(parameters, "display_height", deviceInfo.displayHeight);
+        addString(parameters, "hardware_name", deviceInfo.hardwareName);
+        addString(parameters, "cpu_type", deviceInfo.abi);
         fillPluginKeys(parameters);
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java
index 0d1979807..36d9c3f20 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java
@@ -91,6 +91,39 @@ private static boolean isConnectionResultSuccess(Integer statusCode) {
         }
     }
 
+    public static String[] getSupportedAbis() {
+        String[] supportedAbis = null;
+        try {
+            Class buildClass = forName("android.os.Build");
+
+            Field supportedAbisField = buildClass.getField("SUPPORTED_ABIS");
+
+            Object supportedAbisObject = supportedAbisField.get(null);
+
+            if (supportedAbisObject instanceof String[]) {
+                supportedAbis = (String[]) supportedAbisObject;
+            }
+        } catch (Exception e) {}
+
+        return supportedAbis;
+    }
+
+    public static String getCpuAbi() {
+        String cpuAbi = null;
+        try {
+            Class buildClass = forName("android.os.Build");
+
+            Field cpuAbiField = buildClass.getField("CPU_ABI");
+
+            Object cpuAbiObject = cpuAbiField.get(null);
+
+            if (cpuAbiObject instanceof String) {
+                cpuAbi = (String) cpuAbiObject;
+            }
+        }catch (Exception e) {}
+        return cpuAbi;
+    }
+
     public static Class forName(String className) {
         try {
             Class classObject = Class.forName(className);
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index 26b1c8229..6299e5a70 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -492,4 +492,12 @@ public static String convertToHex(final byte[] bytes) {
         final String formatString = "%0" + (bytes.length << 1) + "x";
         return String.format(Locale.US, formatString, bigInt);
     }
+
+    public static String[] getSupportedAbis() {
+        return Reflection.getSupportedAbis();
+    }
+
+    public static String getCpuAbi() {
+        return Reflection.getCpuAbi();
+    }
 }

From 3f648c889acb7884fa8ac058989a2ca1f79a5128 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Wed, 16 Mar 2016 17:12:58 +0100
Subject: [PATCH 02/37] Add service examples

---
 Adjust/example/src/main/AndroidManifest.xml   | 20 ++++--
 .../java/com/adjust/example/MainActivity.java |  9 ++-
 .../com/adjust/example/ServiceActivity.java   | 27 ++++++++
 .../com/adjust/example/ServiceExample.java    | 66 +++++++++++++++++++
 .../src/main/res/layout/activity_main.xml     | 14 ++++
 .../src/main/res/layout/activity_service.xml  | 29 ++++++++
 .../example/src/main/res/values/strings.xml   |  3 +
 7 files changed, 162 insertions(+), 6 deletions(-)
 create mode 100644 Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java
 create mode 100644 Adjust/example/src/main/java/com/adjust/example/ServiceExample.java
 create mode 100644 Adjust/example/src/main/res/layout/activity_service.xml

diff --git a/Adjust/example/src/main/AndroidManifest.xml b/Adjust/example/src/main/AndroidManifest.xml
index 3d6a3faa8..52c1ad0d5 100644
--- a/Adjust/example/src/main/AndroidManifest.xml
+++ b/Adjust/example/src/main/AndroidManifest.xml
@@ -11,7 +11,6 @@
         android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
         android:theme="@style/AppTheme">
-
         <receiver
             android:name="com.adjust.sdk.AdjustReferrerReceiver"
             android:exported="true">
@@ -27,17 +26,28 @@
             android:screenOrientation="portrait">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+
                 <category android:name="android.intent.category.LAUNCHER" />
             </intent-filter>
-
             <intent-filter>
                 <action android:name="android.intent.action.VIEW" />
+
                 <category android:name="android.intent.category.DEFAULT" />
                 <category android:name="android.intent.category.BROWSABLE" />
-                <!-- note that the leading "/" is required for pathPrefix
-                 Accepts URIs that begin with "example://”-->
+                <!--
+                 note that the leading "/" is required for pathPrefix
+                 Accepts URIs that begin with "example://”
+                -->
                 <data android:scheme="example" />
             </intent-filter>
         </activity>
+
+        <service
+            android:name=".ServiceExample"
+            android:enabled="true"
+            android:exported="true" />
+
+        <activity android:name=".ServiceActivity"></activity>
     </application>
-</manifest>
+
+</manifest>
\ No newline at end of file
diff --git a/Adjust/example/src/main/java/com/adjust/example/MainActivity.java b/Adjust/example/src/main/java/com/adjust/example/MainActivity.java
index 953ecef2d..466c4bec1 100644
--- a/Adjust/example/src/main/java/com/adjust/example/MainActivity.java
+++ b/Adjust/example/src/main/java/com/adjust/example/MainActivity.java
@@ -4,6 +4,7 @@
 import android.net.Uri;
 import android.os.Bundle;
 import android.support.v7.app.ActionBarActivity;
+import android.support.v7.app.AppCompatActivity;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
@@ -13,7 +14,7 @@
 import com.adjust.sdk.Adjust;
 import com.adjust.sdk.AdjustEvent;
 
-public class MainActivity extends ActionBarActivity {
+public class MainActivity extends AppCompatActivity {
     private static final String EVENT_TOKEN_SIMPLE      = "{YourEventToken}";
     private static final String EVENT_TOKEN_REVENUE     = "{YourEventToken}";
     private static final String EVENT_TOKEN_CALLBACK    = "{YourEventToken}";
@@ -122,4 +123,10 @@ public void onIsSDKEnabledClick(View v) {
                     Toast.LENGTH_SHORT).show();
         }
     }
+
+    public void onServiceActivityClick(View v) {
+        Intent intent = new Intent(this, ServiceActivity.class);
+        startActivity(intent);
+    }
+
 }
diff --git a/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java b/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java
new file mode 100644
index 000000000..8ffd068e8
--- /dev/null
+++ b/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java
@@ -0,0 +1,27 @@
+package com.adjust.example;
+
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.SystemClock;
+import android.support.v7.app.AppCompatActivity;
+import android.os.Bundle;
+import android.util.Log;
+import android.view.View;
+
+public class ServiceActivity extends AppCompatActivity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_service);
+    }
+
+    public void onServiceClick(View v) {
+        Intent intent = new Intent(this, ServiceExample.class);
+        startService(intent);
+    }
+
+    public void onReturnClick(View v) {
+        finish();
+    }
+}
diff --git a/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java b/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java
new file mode 100644
index 000000000..45d5e115e
--- /dev/null
+++ b/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java
@@ -0,0 +1,66 @@
+package com.adjust.example;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.AsyncTask;
+import android.os.IBinder;
+import android.os.SystemClock;
+import android.util.Log;
+
+import com.adjust.sdk.Adjust;
+import com.adjust.sdk.AdjustEvent;
+
+/**
+ * Created by pfms on 16/03/16.
+ */
+public class ServiceExample extends Service {
+    private static final String EVENT_TOKEN_BACKGROUND      = "{YourEventToken}";
+
+    public ServiceExample() {
+        super();
+        Log.d("example", "ServiceExample constructor");
+    }
+
+    @Override
+    public IBinder onBind(Intent intent) {
+        Log.d("example", "ServiceExample onBind");
+
+        return null;
+    }
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        Log.d("example", "ServiceExample onCreate");
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        int startDefaultOption = super.onStartCommand(intent, flags, startId);
+        Log.d("example", "ServiceExample onStartCommand");
+
+        new AsyncTask<Void,Void,Void>() {
+            @Override
+            protected Void doInBackground(Void... params) {
+                Log.d("example", "ServiceExample background sleeping");
+                SystemClock.sleep(3000);
+                Log.d("example", "ServiceExample background awake");
+
+                AdjustEvent event = new AdjustEvent(EVENT_TOKEN_BACKGROUND);
+                Adjust.trackEvent(event);
+
+                Log.d("example", "ServiceExample background event tracked");
+
+                return null;
+            }
+        }.execute();
+
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        Log.d("example", "ServiceExample onDestroy");
+    }
+}
diff --git a/Adjust/example/src/main/res/layout/activity_main.xml b/Adjust/example/src/main/res/layout/activity_main.xml
index 5801cda53..f6a9bfd80 100644
--- a/Adjust/example/src/main/res/layout/activity_main.xml
+++ b/Adjust/example/src/main/res/layout/activity_main.xml
@@ -100,4 +100,18 @@
         android:onClick="onIsSDKEnabledClick"
         android:text="@string/btn_is_sdk_enabled" />
 
+    <Button
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:text="@string/btn_service_activity"
+        android:id="@+id/btnServiceActivity"
+        android:layout_gravity="center_horizontal"
+        android:layout_weight="0.143"
+        android:layout_marginLeft="30dp"
+        android:layout_marginTop="5dp"
+        android:layout_marginRight="30dp"
+        android:layout_marginBottom="5dp"
+        android:onClick="onServiceActivityClick"
+        android:nestedScrollingEnabled="false" />
+
 </LinearLayout>
diff --git a/Adjust/example/src/main/res/layout/activity_service.xml b/Adjust/example/src/main/res/layout/activity_service.xml
new file mode 100644
index 000000000..2875286da
--- /dev/null
+++ b/Adjust/example/src/main/res/layout/activity_service.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:paddingBottom="@dimen/activity_vertical_margin"
+    android:paddingLeft="@dimen/activity_horizontal_margin"
+    android:paddingRight="@dimen/activity_horizontal_margin"
+    android:paddingTop="@dimen/activity_vertical_margin"
+    tools:context="com.adjust.example.ServiceActivity">
+
+    <Button
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/btn_return"
+        android:id="@+id/btnReturn"
+        android:layout_alignParentBottom="true"
+        android:layout_centerHorizontal="true"
+        android:onClick="onReturnClick" />
+
+    <Button
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:text="@string/btn_service"
+        android:id="@+id/btnService"
+        android:layout_alignParentTop="true"
+        android:layout_centerHorizontal="true"
+        android:onClick="onServiceClick" />
+</RelativeLayout>
diff --git a/Adjust/example/src/main/res/values/strings.xml b/Adjust/example/src/main/res/values/strings.xml
index f6977de2c..ab61c0c49 100644
--- a/Adjust/example/src/main/res/values/strings.xml
+++ b/Adjust/example/src/main/res/values/strings.xml
@@ -8,6 +8,9 @@
     <string name="btn_callback_event">Track callback event</string>
     <string name="btn_partner_event">Track partner event</string>
     <string name="btn_is_sdk_enabled">Is SDK enabled?</string>
+    <string name="btn_service_activity">Service Activity</string>
+    <string name="btn_return">Return</string>
+    <string name="btn_service">Service</string>
 
     <string name="txt_enable_sdk">Enable SDK</string>
     <string name="txt_disable_sdk">Disable SDK</string>

From 51720cda698104e03a6e45ea937ef92c35171f14 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Fri, 18 Mar 2016 17:31:52 +0100
Subject: [PATCH 03/37] Rename session timer to foreground

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 42 +++++++++----------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 64c22ad91..99bdfdc34 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -31,8 +31,8 @@
 
 public class ActivityHandler extends HandlerThread implements IActivityHandler {
 
-    private static long TIMER_INTERVAL;
-    private static long TIMER_START;
+    private static long FOREGROUND_TIMER_INTERVAL;
+    private static long FOREGROUND_TIMER_START;
     private static long SESSION_INTERVAL;
     private static long SUBSESSION_INTERVAL;
     private static final String TIME_TRAVEL = "Time travel!";
@@ -44,7 +44,7 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private IPackageHandler packageHandler;
     private ActivityState activityState;
     private ILogger logger;
-    private TimerCycle timer;
+    private TimerCycle foregroundTimer;
     private boolean enabled;
     private boolean offline;
 
@@ -338,9 +338,9 @@ private void updateHandlersStatus() {
         sessionHandler.sendMessage(message);
     }
 
-    private void timerFired() {
+    private void foregroundTimerFired() {
         Message message = Message.obtain();
-        message.arg1 = SessionHandler.TIMER_FIRED;
+        message.arg1 = SessionHandler.FOREGROUND_TIMER_FIRED;
         sessionHandler.sendMessage(message);
     }
 
@@ -354,7 +354,7 @@ private static final class SessionHandler extends Handler {
         private static final int DEEP_LINK = BASE_ADDRESS + 6;
         private static final int SEND_REFERRER = BASE_ADDRESS + 7;
         private static final int UPDATE_HANDLERS_STATUS = BASE_ADDRESS + 8;
-        private static final int TIMER_FIRED = BASE_ADDRESS + 9;
+        private static final int FOREGROUND_TIMER_FIRED = BASE_ADDRESS + 9;
         private static final int SESSION_TASKS = BASE_ADDRESS + 10;
         private static final int ATTRIBUTION_TASKS = BASE_ADDRESS + 11;
 
@@ -403,8 +403,8 @@ public void handleMessage(Message message) {
                 case UPDATE_HANDLERS_STATUS:
                     sessionHandler.updateHandlersStatusInternal();
                     break;
-                case TIMER_FIRED:
-                    sessionHandler.timerFiredInternal();
+                case FOREGROUND_TIMER_FIRED:
+                    sessionHandler.foregroundTimerFiredInternal();
                     break;
                 case SESSION_TASKS:
                     SessionResponseData sessionResponseData = (SessionResponseData) message.obj;
@@ -419,8 +419,8 @@ public void handleMessage(Message message) {
     }
 
     private void initInternal() {
-        TIMER_INTERVAL = AdjustFactory.getTimerInterval();
-        TIMER_START = AdjustFactory.getTimerStart();
+        FOREGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
+        FOREGROUND_TIMER_START = AdjustFactory.getTimerStart();
         SESSION_INTERVAL = AdjustFactory.getSessionInterval();
         SUBSESSION_INTERVAL = AdjustFactory.getSubsessionInterval();
 
@@ -460,12 +460,12 @@ private void initInternal() {
                 paused(),
                 adjustConfig.hasAttributionChangedListener());
 
-        timer = new TimerCycle(new Runnable() {
+        foregroundTimer = new TimerCycle(new Runnable() {
             @Override
             public void run() {
-                timerFired();
+                foregroundTimerFired();
             }
-        },TIMER_START, TIMER_INTERVAL);
+        }, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL);
     }
 
     private void startInternal() {
@@ -481,7 +481,7 @@ private void startInternal() {
 
         checkAttributionState();
 
-        startTimer();
+        startForegroundTimer();
     }
 
     private void processSession() {
@@ -550,7 +550,7 @@ private void checkAttributionState() {
     private void endInternal() {
         packageHandler.pauseSending();
         attributionHandler.pauseSending();
-        stopTimer();
+        stopForegroundTimer();
         if (updateActivityState(System.currentTimeMillis())) {
             writeActivityState();
         }
@@ -901,23 +901,23 @@ private void transferSessionPackage(long now) {
         packageHandler.sendFirstPackage();
     }
 
-    private void startTimer() {
+    private void startForegroundTimer() {
         // don't start the timer if it's disabled/offline
         if (paused()) {
             return;
         }
 
-        timer.start();
+        foregroundTimer.start();
     }
 
-    private void stopTimer() {
-        timer.suspend();
+    private void stopForegroundTimer() {
+        foregroundTimer.suspend();
     }
 
-    private void timerFiredInternal() {
+    private void foregroundTimerFiredInternal() {
         if (paused()) {
             // stop the timer cycle if it's disabled/offline
-            stopTimer();
+            stopForegroundTimer();
             return;
         }
 

From 4aa185af4302fe7001e22b6409c2f745fc401f65 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Fri, 18 Mar 2016 18:09:50 +0100
Subject: [PATCH 04/37] Send in the background

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 126 +++++++++++++++---
 .../java/com/adjust/sdk/AdjustConfig.java     |  12 +-
 .../java/com/adjust/sdk/AdjustFactory.java    |  12 +-
 .../java/com/adjust/sdk/AdjustInstance.java   |   4 +-
 .../com/adjust/sdk/AttributionHandler.java    |   8 +-
 .../java/com/adjust/sdk/IActivityHandler.java |   4 +-
 .../com/adjust/sdk/IAttributionHandler.java   |   2 +-
 .../java/com/adjust/sdk/IPackageHandler.java  |   2 +-
 .../java/com/adjust/sdk/PackageHandler.java   |   8 +-
 .../main/java/com/adjust/sdk/TimerOnce.java   |  22 ++-
 10 files changed, 153 insertions(+), 47 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 99bdfdc34..134a7f1c8 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -24,6 +24,8 @@
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
 
 import static com.adjust.sdk.Constants.ACTIVITY_STATE_FILENAME;
 import static com.adjust.sdk.Constants.ATTRIBUTION_FILENAME;
@@ -33,6 +35,7 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
 
     private static long FOREGROUND_TIMER_INTERVAL;
     private static long FOREGROUND_TIMER_START;
+    private static long BACKGROUND_TIMER_INTERVAL;
     private static long SESSION_INTERVAL;
     private static long SUBSESSION_INTERVAL;
     private static final String TIME_TRAVEL = "Time travel!";
@@ -45,8 +48,11 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private ActivityState activityState;
     private ILogger logger;
     private TimerCycle foregroundTimer;
+    private ScheduledExecutorService scheduler;
+    private TimerOnce backgroundTimer;
     private boolean enabled;
     private boolean offline;
+    private boolean background;
 
     private DeviceInfo deviceInfo;
     private AdjustConfig adjustConfig; // always valid after construction
@@ -61,6 +67,7 @@ private ActivityHandler(AdjustConfig adjustConfig) {
         logger = AdjustFactory.getLogger();
         sessionHandler = new SessionHandler(getLooper(), this);
         enabled = true;
+        background = true;
         init(adjustConfig);
 
         Message message = Message.obtain();
@@ -108,6 +115,11 @@ public static ActivityHandler getInstance(AdjustConfig adjustConfig) {
     }
 
     @Override
+    public void onResume() {
+        background = false;
+        trackSubsessionStart();
+    }
+
     public void trackSubsessionStart() {
         Message message = Message.obtain();
         message.arg1 = SessionHandler.START;
@@ -115,6 +127,11 @@ public void trackSubsessionStart() {
     }
 
     @Override
+    public void onPause() {
+        background = true;
+        trackSubsessionEnd();
+    }
+
     public void trackSubsessionEnd() {
         Message message = Message.obtain();
         message.arg1 = SessionHandler.END;
@@ -344,6 +361,12 @@ private void foregroundTimerFired() {
         sessionHandler.sendMessage(message);
     }
 
+    private void backgroundTimerFired() {
+        Message message = Message.obtain();
+        message.arg1 = SessionHandler.BACKGROUND_TIMER_FIRED;
+        sessionHandler.sendMessage(message);
+    }
+
     private static final class SessionHandler extends Handler {
         private static final int BASE_ADDRESS = 72630;
         private static final int INIT = BASE_ADDRESS + 1;
@@ -357,6 +380,7 @@ private static final class SessionHandler extends Handler {
         private static final int FOREGROUND_TIMER_FIRED = BASE_ADDRESS + 9;
         private static final int SESSION_TASKS = BASE_ADDRESS + 10;
         private static final int ATTRIBUTION_TASKS = BASE_ADDRESS + 11;
+        private static final int BACKGROUND_TIMER_FIRED = BASE_ADDRESS + 12;
 
         private final WeakReference<ActivityHandler> sessionHandlerReference;
 
@@ -414,6 +438,9 @@ public void handleMessage(Message message) {
                     AttributionResponseData attributionResponseData = (AttributionResponseData) message.obj;
                     sessionHandler.launchAttributionResponseTasksInternal(attributionResponseData);
                     break;
+                case BACKGROUND_TIMER_FIRED:
+                    sessionHandler.backgroundTimerFiredInternal();
+                    break;
             }
         }
     }
@@ -421,6 +448,7 @@ public void handleMessage(Message message) {
     private void initInternal() {
         FOREGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
         FOREGROUND_TIMER_START = AdjustFactory.getTimerStart();
+        BACKGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
         SESSION_INTERVAL = AdjustFactory.getSessionInterval();
         SUBSESSION_INTERVAL = AdjustFactory.getSubsessionInterval();
 
@@ -452,12 +480,12 @@ private void initInternal() {
         readAttribution();
         readActivityState();
 
-        packageHandler = AdjustFactory.getPackageHandler(this, adjustConfig.context, paused());
+        packageHandler = AdjustFactory.getPackageHandler(this, adjustConfig.context, toSend());
 
         ActivityPackage attributionPackage = getAttributionPackage();
         attributionHandler = AdjustFactory.getAttributionHandler(this,
                 attributionPackage,
-                paused(),
+                toSend(),
                 adjustConfig.hasAttributionChangedListener());
 
         foregroundTimer = new TimerCycle(new Runnable() {
@@ -466,6 +494,14 @@ public void run() {
                 foregroundTimerFired();
             }
         }, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL);
+
+        scheduler = Executors.newSingleThreadScheduledExecutor();
+        backgroundTimer = new TimerOnce(scheduler, new Runnable() {
+            @Override
+            public void run() {
+                backgroundTimerFired();
+            }
+        });
     }
 
     private void startInternal() {
@@ -475,6 +511,8 @@ private void startInternal() {
             return;
         }
 
+        stopBackgroundTimer();
+
         updateHandlersStatusInternal();
 
         processSession();
@@ -548,9 +586,19 @@ private void checkAttributionState() {
     }
 
     private void endInternal() {
-        packageHandler.pauseSending();
-        attributionHandler.pauseSending();
+        // stop foreground timer in any situation
         stopForegroundTimer();
+
+        // if it's offline, disabled
+        // or it can't send in the background
+        // -> pause sdk
+        if (paused() || !adjustConfig.sendInBackground) {
+            pauseSending();
+        } else {
+        // it it doesn't pause the sdk, it starts the background timer
+            startBackgroundTimer();
+        }
+
         if (updateActivityState(System.currentTimeMillis())) {
             writeActivityState();
         }
@@ -576,6 +624,11 @@ private void trackEventInternal(AdjustEvent event) {
             packageHandler.sendFirstPackage();
         }
 
+        // if it is in the background and it can send, start the background timer
+        if (adjustConfig.sendInBackground && background) {
+            startBackgroundTimer();
+        }
+
         writeActivityState();
     }
 
@@ -846,24 +899,21 @@ private boolean trySetAttribution(AdjustAttribution queryStringAttribution,
     }
 
     private void updateHandlersStatusInternal() {
-        updateAttributionHandlerStatus();
-        updatePackageHandlerStatus();
-    }
-
-    private void updateAttributionHandlerStatus() {
-        if (paused()) {
-            attributionHandler.pauseSending();
+        if (toSend()) {
+            resumeSending();
         } else {
-            attributionHandler.resumeSending();
+            pauseSending();
         }
     }
 
-    private void updatePackageHandlerStatus() {
-        if (paused()) {
-            packageHandler.pauseSending();
-        } else {
-            packageHandler.resumeSending();
-        }
+    private void pauseSending() {
+        attributionHandler.pauseSending();
+        packageHandler.pauseSending();
+    }
+
+    private void resumeSending() {
+        attributionHandler.resumeSending();
+        packageHandler.resumeSending();
     }
 
 
@@ -902,7 +952,7 @@ private void transferSessionPackage(long now) {
     }
 
     private void startForegroundTimer() {
-        // don't start the timer if it's disabled/offline
+        // don't start the timer if it's disabled or offline
         if (paused()) {
             return;
         }
@@ -929,6 +979,29 @@ private void foregroundTimerFiredInternal() {
         }
     }
 
+    private void startBackgroundTimer() {
+        // don't start the timer if it's disabled or offline
+        if (paused()) {
+            return;
+        }
+
+        // background timer already started
+        if (backgroundTimer.getFireIn() > 0) {
+            return;
+        }
+        logger.verbose("Background timer started");
+        backgroundTimer.startIn(BACKGROUND_TIMER_INTERVAL);
+    }
+
+    private void stopBackgroundTimer() {
+        backgroundTimer.cancel();
+    }
+
+    private void backgroundTimerFiredInternal() {
+        logger.debug("Background timer fired");
+        packageHandler.sendFirstPackage();
+    }
+
     private void readActivityState() {
         try {
             activityState = Util.readObject(adjustConfig.context, ACTIVITY_STATE_FILENAME, ACTIVITY_STATE_NAME, ActivityState.class);
@@ -980,4 +1053,19 @@ private boolean checkActivityState(ActivityState activityState) {
     private boolean paused() {
         return offline || !isEnabled();
     }
+
+    private boolean toSend() {
+        // if it's offline, disabled -> don't send
+        if (paused()) {
+            return false;
+        }
+
+        // has the option to send in the background -> is to send
+        if (adjustConfig.sendInBackground) {
+            return true;
+        }
+
+        // doesn't have the option -> depends on being on the background
+        return !background;
+    }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java
index f9132e4fd..2aa5f0f9a 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java
@@ -12,7 +12,7 @@ public class AdjustConfig {
     String processName;
     LogLevel logLevel;
     String sdkPrefix;
-    Boolean eventBufferingEnabled;
+    boolean eventBufferingEnabled;
     String defaultTracker;
     OnAttributionChangedListener onAttributionChangedListener;
     String referrer;
@@ -23,6 +23,7 @@ public class AdjustConfig {
     OnEventTrackingFailedListener onEventTrackingFailedListener;
     OnSessionTrackingSucceededListener onSessionTrackingSucceededListener;
     OnSessionTrackingFailedListener onSessionTrackingFailedListener;
+    boolean sendInBackground;
 
     public static final String ENVIRONMENT_SANDBOX = "sandbox";
     public static final String ENVIRONMENT_PRODUCTION = "production";
@@ -39,12 +40,21 @@ public AdjustConfig(Context context, String appToken, String environment) {
         // default values
         this.logLevel = LogLevel.INFO;
         this.eventBufferingEnabled = false;
+        this.sendInBackground = false;
     }
 
     public void setEventBufferingEnabled(Boolean eventBufferingEnabled) {
+        if (eventBufferingEnabled == null) {
+            this.eventBufferingEnabled = false;
+            return;
+        }
         this.eventBufferingEnabled = eventBufferingEnabled;
     }
 
+    public void setSendInBackground(boolean sendInBackground) {
+        this.sendInBackground = sendInBackground;
+    }
+
     public void setLogLevel(LogLevel logLevel) {
         this.logLevel = logLevel;
     }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
index 327af4f4c..f359602d0 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
@@ -22,11 +22,11 @@ public class AdjustFactory {
 
     public static IPackageHandler getPackageHandler(ActivityHandler activityHandler,
                                                     Context context,
-                                                    boolean startPaused) {
+                                                    boolean startsSending) {
         if (packageHandler == null) {
-            return new PackageHandler(activityHandler, context, startPaused);
+            return new PackageHandler(activityHandler, context, startsSending);
         }
-        packageHandler.init(activityHandler, context, startPaused);
+        packageHandler.init(activityHandler, context, startsSending);
         return packageHandler;
     }
 
@@ -84,12 +84,12 @@ public static IActivityHandler getActivityHandler(AdjustConfig config) {
 
     public static IAttributionHandler getAttributionHandler(IActivityHandler activityHandler,
                                                             ActivityPackage attributionPackage,
-                                                            boolean startPaused,
+                                                            boolean startsSending,
                                                             boolean hasListener) {
         if (attributionHandler == null) {
-            return new AttributionHandler(activityHandler, attributionPackage, startPaused, hasListener);
+            return new AttributionHandler(activityHandler, attributionPackage, startsSending, hasListener);
         }
-        attributionHandler.init(activityHandler, attributionPackage, startPaused, hasListener);
+        attributionHandler.init(activityHandler, attributionPackage, startsSending, hasListener);
         return attributionHandler;
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustInstance.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustInstance.java
index 1c4dea9d2..fac831993 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustInstance.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustInstance.java
@@ -34,12 +34,12 @@ public void trackEvent(AdjustEvent event) {
 
     public void onResume() {
         if (!checkActivityHandler()) return;
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
     }
 
     public void onPause() {
         if (!checkActivityHandler()) return;
-        activityHandler.trackSubsessionEnd();
+        activityHandler.onPause();
     }
 
     public void setEnabled(boolean enabled) {
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
index 34755c779..89e0a40f5 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
@@ -25,7 +25,7 @@ public class AttributionHandler implements IAttributionHandler {
 
     public AttributionHandler(IActivityHandler activityHandler,
                               ActivityPackage attributionPackage,
-                              boolean startPaused,
+                              boolean startsSending,
                               boolean hasListener) {
         scheduler = Executors.newSingleThreadScheduledExecutor();
         logger = AdjustFactory.getLogger();
@@ -41,17 +41,17 @@ public void run() {
             this.logger.error("Timer not initialized, attribution handler is disabled");
         }
 
-        init(activityHandler, attributionPackage, startPaused, hasListener);
+        init(activityHandler, attributionPackage, startsSending, hasListener);
     }
 
     @Override
     public void init(IActivityHandler activityHandler,
                      ActivityPackage attributionPackage,
-                     boolean startPaused,
+                     boolean startsSending,
                      boolean hasListener) {
         this.activityHandler = activityHandler;
         this.attributionPackage = attributionPackage;
-        this.paused = startPaused;
+        this.paused = !startsSending;
         this.hasListener = hasListener;
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java
index 589d1e85a..ed52a4cfd 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java
@@ -8,9 +8,9 @@
 public interface IActivityHandler {
     public void init(AdjustConfig config);
 
-    public void trackSubsessionStart();
+    public void onResume();
 
-    public void trackSubsessionEnd();
+    public void onPause();
 
     public void trackEvent(AdjustEvent event);
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IAttributionHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IAttributionHandler.java
index 3053a8710..91ddee11f 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IAttributionHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IAttributionHandler.java
@@ -6,7 +6,7 @@
 public interface IAttributionHandler {
     public void init(IActivityHandler activityHandler,
                      ActivityPackage attributionPackage,
-                     boolean startPaused,
+                     boolean startsSending,
                      boolean hasListener);
 
     public void getAttribution();
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
index 997fdb54d..a0799a6ac 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
@@ -3,7 +3,7 @@
 import android.content.Context;
 
 public interface IPackageHandler {
-    public void init(IActivityHandler activityHandler, Context context, boolean startPaused);
+    public void init(IActivityHandler activityHandler, Context context, boolean startsSending);
 
     public void addPackage(ActivityPackage pack);
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index de6e4e048..626c15652 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -36,14 +36,14 @@ public class PackageHandler extends HandlerThread implements IPackageHandler {
 
     public PackageHandler(IActivityHandler activityHandler,
                           Context context,
-                          boolean startPaused) {
+                          boolean startsSending) {
         super(Constants.LOGTAG, MIN_PRIORITY);
         setDaemon(true);
         start();
         this.internalHandler = new InternalHandler(getLooper(), this);
         this.logger = AdjustFactory.getLogger();
 
-        init(activityHandler, context, startPaused);
+        init(activityHandler, context, startsSending);
 
         Message message = Message.obtain();
         message.arg1 = InternalHandler.INIT;
@@ -51,10 +51,10 @@ public PackageHandler(IActivityHandler activityHandler,
     }
 
     @Override
-    public void init(IActivityHandler activityHandler, Context context, boolean startPaused) {
+    public void init(IActivityHandler activityHandler, Context context, boolean startsSending) {
         this.activityHandler = activityHandler;
         this.context = context;
-        this.paused = startPaused;
+        this.paused = !startsSending;
     }
 
     // add a package to the queue
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
index ce4e703d1..c4d8aa10b 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
@@ -1,6 +1,5 @@
 package com.adjust.sdk;
 
-import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.ScheduledFuture;
 import java.util.concurrent.TimeUnit;
@@ -12,20 +11,22 @@ public class TimerOnce {
     private ScheduledExecutorService scheduler;
     private ScheduledFuture waitingTask;
     private Runnable command;
-    private boolean isRunning;
 
     public TimerOnce(ScheduledExecutorService scheduler, Runnable command) {
         this.scheduler = scheduler;
         this.command = command;
-        this.isRunning = false;
     }
 
     public void startIn(long fireIn) {
         // cancel previous
-        if (waitingTask != null) {
-            waitingTask.cancel(false);
-        }
-        waitingTask = scheduler.schedule(command, fireIn, TimeUnit.MILLISECONDS);
+        cancel();
+        waitingTask = scheduler.schedule(new Runnable() {
+            @Override
+            public void run() {
+                command.run();
+                waitingTask = null;
+            }
+        }, fireIn, TimeUnit.MILLISECONDS);
     }
 
     public long getFireIn() {
@@ -34,4 +35,11 @@ public long getFireIn() {
         }
         return waitingTask.getDelay(TimeUnit.MILLISECONDS);
     }
+
+    public void cancel() {
+        if (waitingTask != null) {
+            waitingTask.cancel(false);
+        }
+        waitingTask = null;
+    }
 }

From 9e3d8a5dd4bcfc6e345ca66146065a4b4f55fd9b Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 22 Mar 2016 14:14:45 +0100
Subject: [PATCH 05/37] Add deeplink listener

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 27 ++++++++++++++++---
 .../java/com/adjust/sdk/AdjustConfig.java     |  5 ++++
 .../sdk/OnDeeplinkResponseListener.java       | 10 +++++++
 .../com/adjust/example/GlobalApplication.java | 14 ++++++++++
 4 files changed, 53 insertions(+), 3 deletions(-)
 create mode 100644 Adjust/adjust/src/main/java/com/adjust/sdk/OnDeeplinkResponseListener.java

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 134a7f1c8..466b16283 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -681,7 +681,7 @@ private void launchSessionResponseTasksInternal(SessionResponseData sessionRespo
         launchSessionResponseListener(sessionResponseData, handler);
 
         // if there is any, try to launch the deeplink
-        launchDeeplink(sessionResponseData, handler);
+        prepareDeeplink(sessionResponseData, handler);
     }
 
     private void launchSessionResponseListener(final SessionResponseData sessionResponseData, Handler handler) {
@@ -741,7 +741,7 @@ public void run() {
         handler.post(runnable);
     }
 
-    private void launchDeeplink(ResponseData responseData, Handler handler) {
+    private void prepareDeeplink(ResponseData responseData, final Handler handler) {
         if (responseData.jsonResponse == null) {
             return;
         }
@@ -752,7 +752,28 @@ private void launchDeeplink(ResponseData responseData, Handler handler) {
             return;
         }
 
-        Uri location = Uri.parse(deeplink);
+        final Uri location = Uri.parse(deeplink);
+
+        // there is no validation to be made by the user
+        if (adjustConfig.onDeeplinkResponseListener == null) {
+            launchDeeplink(location, handler, deeplink);
+            return;
+        }
+
+        // launch deeplink validation by user
+        Runnable runnable = new Runnable() {
+            @Override
+            public void run() {
+                boolean toLaunchDeeplink = adjustConfig.onDeeplinkResponseListener.launchReceivedDeeplink(location);
+                if (toLaunchDeeplink) {
+                    launchDeeplink(location, handler, deeplink);
+                }
+            }
+        };
+        handler.post(runnable);
+    }
+
+    private void launchDeeplink(final Uri location, Handler handler, final String deeplink) {
         final Intent mapIntent;
         if (adjustConfig.deepLinkComponent == null) {
             mapIntent = new Intent(Intent.ACTION_VIEW, location);
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java
index 2aa5f0f9a..742a0d8b0 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustConfig.java
@@ -23,6 +23,7 @@ public class AdjustConfig {
     OnEventTrackingFailedListener onEventTrackingFailedListener;
     OnSessionTrackingSucceededListener onSessionTrackingSucceededListener;
     OnSessionTrackingFailedListener onSessionTrackingFailedListener;
+    OnDeeplinkResponseListener onDeeplinkResponseListener;
     boolean sendInBackground;
 
     public static final String ENVIRONMENT_SANDBOX = "sandbox";
@@ -97,6 +98,10 @@ public void setOnSessionTrackingFailedListener(OnSessionTrackingFailedListener o
         this.onSessionTrackingFailedListener = onSessionTrackingFailedListener;
     }
 
+    public void setOnDeeplinkResponseListener(OnDeeplinkResponseListener onDeeplinkResponseListener) {
+        this.onDeeplinkResponseListener = onDeeplinkResponseListener;
+    }
+
     public boolean hasAttributionChangedListener() {
         return onAttributionChangedListener != null;
     }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/OnDeeplinkResponseListener.java b/Adjust/adjust/src/main/java/com/adjust/sdk/OnDeeplinkResponseListener.java
new file mode 100644
index 000000000..6075055ad
--- /dev/null
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/OnDeeplinkResponseListener.java
@@ -0,0 +1,10 @@
+package com.adjust.sdk;
+
+import android.net.Uri;
+
+/**
+ * Created by pfms on 22/03/16.
+ */
+public interface OnDeeplinkResponseListener {
+    boolean launchReceivedDeeplink(Uri deeplink);
+}
diff --git a/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java b/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
index 34cf07721..059147a3f 100644
--- a/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
+++ b/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
@@ -2,6 +2,7 @@
 
 import android.app.Activity;
 import android.app.Application;
+import android.net.Uri;
 import android.os.Bundle;
 import android.util.Log;
 
@@ -12,6 +13,7 @@
 import com.adjust.sdk.AdjustEventSuccess;
 import com.adjust.sdk.LogLevel;
 import com.adjust.sdk.OnAttributionChangedListener;
+import com.adjust.sdk.OnDeeplinkResponseListener;
 import com.adjust.sdk.OnEventTrackingFailedListener;
 import com.adjust.sdk.OnEventTrackingSucceededListener;
 import com.adjust.sdk.OnSessionTrackingFailedListener;
@@ -83,6 +85,18 @@ public void onFinishedSessionTrackingFailed(AdjustSessionFailure sessionFailureR
             }
         });
 
+        // evaluate deeplink to be launched
+        config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
+            @Override
+            public boolean launchReceivedDeeplink(Uri deeplink) {
+                if (deeplink.getPath().equals("")) {
+                    return false;
+                } else {
+                    return true;
+                }
+            }
+        });
+
         Adjust.onCreate(config);
 
         // register onResume and onPause events of all activities

From d23f810eb723001df1167e3c0998fc98b1a14470 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 22 Mar 2016 15:47:19 +0100
Subject: [PATCH 06/37] Prevent sdk start due to offline or disable

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 22 +++++++++++++------
 1 file changed, 15 insertions(+), 7 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 466b16283..a4e2aa5af 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -177,12 +177,16 @@ public void setEnabled(boolean enabled) {
         this.enabled = enabled;
 
         if (activityState == null) {
-            trackSubsessionStart();
-        } else {
-            activityState.enabled = enabled;
-            writeActivityState();
+            updateStatus(!enabled,
+                    "Package handler and attribution handler will start paused due to the disable of the SDK",
+                    "Package and attribution handler will still start paused due to the SDK being offline",
+                    "Package handler and attribution handler will start active due to be enabled");
+            return;
         }
 
+        activityState.enabled = enabled;
+        writeActivityState();
+
         updateStatus(!enabled,
                 "Pausing package handler and attribution handler to disable the SDK",
                 "Package and attribution handler remain paused due to the SDK is offline",
@@ -194,7 +198,7 @@ private void updateStatus(boolean pausingState, String pausingMessage,
     {
         if (pausingState) {
             logger.info(pausingMessage);
-            trackSubsessionEnd();
+            updateHandlersStatus();
             return;
         }
 
@@ -202,7 +206,7 @@ private void updateStatus(boolean pausingState, String pausingMessage,
             logger.info(remainsPausedMessage);
         } else {
             logger.info(unPausingMessage);
-            trackSubsessionStart();
+            updateHandlersStatus();
         }
     }
 
@@ -233,7 +237,11 @@ public void setOfflineMode(boolean offline) {
         this.offline = offline;
 
         if (activityState == null) {
-            trackSubsessionStart();
+            updateStatus(!enabled,
+                    "Package handler and attribution handler will start paused due to offline mode",
+                    "Package and attribution handler will still start paused due to the SDK being disabled",
+                    "Package handler and attribution handler will start active due to being online");
+            return;
         }
 
         updateStatus(offline,

From ed74f9d558bb7838d59e990f36f1648720eba9ee Mon Sep 17 00:00:00 2001
From: Esa McGavin <esa@adeven.com>
Date: Wed, 23 Mar 2016 15:33:36 +0100
Subject: [PATCH 07/37] Update ActivityHandler.java

@nonelse updated with the text i sent you
---
 .../java/com/adjust/sdk/ActivityHandler.java  | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index a4e2aa5af..7a5419bc7 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -178,9 +178,9 @@ public void setEnabled(boolean enabled) {
 
         if (activityState == null) {
             updateStatus(!enabled,
-                    "Package handler and attribution handler will start paused due to the disable of the SDK",
-                    "Package and attribution handler will still start paused due to the SDK being offline",
-                    "Package handler and attribution handler will start active due to be enabled");
+                    "Package handler and attribution handler will start as paused due to the SDK being disabled",
+                    "Package and attribution handler will still start as paused due to the SDK being offline",
+                    "Package handler and attribution handler will start as active due to the SDK being enabled");
             return;
         }
 
@@ -188,9 +188,9 @@ public void setEnabled(boolean enabled) {
         writeActivityState();
 
         updateStatus(!enabled,
-                "Pausing package handler and attribution handler to disable the SDK",
-                "Package and attribution handler remain paused due to the SDK is offline",
-                "Resuming package handler and attribution handler to enabled the SDK");
+                "Pausing package handler and attribution handler due to SDK being disabled",
+                "Package and attribution handler remain paused due to SDK being offline",
+                "Resuming package handler and attribution handler due to SDK being enabled");
     }
 
     private void updateStatus(boolean pausingState, String pausingMessage,
@@ -238,16 +238,16 @@ public void setOfflineMode(boolean offline) {
 
         if (activityState == null) {
             updateStatus(!enabled,
-                    "Package handler and attribution handler will start paused due to offline mode",
-                    "Package and attribution handler will still start paused due to the SDK being disabled",
-                    "Package handler and attribution handler will start active due to being online");
+                    "Package handler and attribution handler will start paused due to SDK being offline",
+                    "Package and attribution handler will still start as paused due to SDK being disabled",
+                    "Package handler and attribution handler will start as active due to SDK being online");
             return;
         }
 
         updateStatus(offline,
-                "Pausing package and attribution handler to put in offline mode",
-                "Package and attribution handler remain paused because the SDK is disabled",
-                "Resuming package handler and attribution handler to put in online mode");
+                "Pausing package and attribution handler to put SDK offline mode",
+                "Package and attribution handler remain paused due to SDK being disabled",
+                "Resuming package handler and attribution handler to put SDK in online mode");
     }
 
     @Override

From 22effd2bb1d92de1aef9a00fa45920aa70db1667 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 22 Mar 2016 16:32:18 +0100
Subject: [PATCH 08/37] Refactor internal state

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 96 +++++++++++++------
 .../java/com/adjust/sdk/IActivityHandler.java | 32 +++----
 2 files changed, 82 insertions(+), 46 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 7a5419bc7..1c3afc10b 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -50,15 +50,43 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private TimerCycle foregroundTimer;
     private ScheduledExecutorService scheduler;
     private TimerOnce backgroundTimer;
-    private boolean enabled;
-    private boolean offline;
-    private boolean background;
+    private InternalState internalState;
 
     private DeviceInfo deviceInfo;
     private AdjustConfig adjustConfig; // always valid after construction
     private AdjustAttribution attribution;
     private IAttributionHandler attributionHandler;
 
+    private class InternalState {
+        boolean enabled;
+        boolean offline;
+        boolean background;
+
+        boolean isEnabled() {
+            return enabled;
+        }
+
+        boolean isDisabled() {
+            return !enabled;
+        }
+
+        boolean isOffline() {
+            return offline;
+        }
+
+        boolean isOnline() {
+            return !offline;
+        }
+
+        boolean isBackground() {
+            return background;
+        }
+
+        boolean isForeground() {
+            return !background;
+        }
+    }
+
     private ActivityHandler(AdjustConfig adjustConfig) {
         super(LOGTAG, MIN_PRIORITY);
         setDaemon(true);
@@ -66,8 +94,14 @@ private ActivityHandler(AdjustConfig adjustConfig) {
 
         logger = AdjustFactory.getLogger();
         sessionHandler = new SessionHandler(getLooper(), this);
-        enabled = true;
-        background = true;
+        internalState = new InternalState();
+        // enabled by default
+        internalState.enabled = true;
+        // online by default
+        internalState.offline = false;
+        // in the background by default
+        internalState.background = true;
+
         init(adjustConfig);
 
         Message message = Message.obtain();
@@ -116,7 +150,7 @@ public static ActivityHandler getInstance(AdjustConfig adjustConfig) {
 
     @Override
     public void onResume() {
-        background = false;
+        internalState.background = false;
         trackSubsessionStart();
     }
 
@@ -128,7 +162,7 @@ public void trackSubsessionStart() {
 
     @Override
     public void onPause() {
-        background = true;
+        internalState.background = true;
         trackSubsessionEnd();
     }
 
@@ -169,12 +203,13 @@ public void finishedTrackingActivity(ResponseData responseData) {
 
     @Override
     public void setEnabled(boolean enabled) {
-        if (!hasChangedState(isEnabled(), enabled,
+        // compare with the saved or internal state
+        if (!hasChangedState(this.isEnabled(), enabled,
                 "Adjust already enabled", "Adjust already disabled")) {
             return;
         }
 
-        this.enabled = enabled;
+        internalState.enabled = enabled;
 
         if (activityState == null) {
             updateStatus(!enabled,
@@ -228,16 +263,17 @@ private boolean hasChangedState(boolean previousState, boolean newState,
 
     @Override
     public void setOfflineMode(boolean offline) {
-        if (!hasChangedState(this.offline, offline,
+        // compare with the internal state
+        if (!hasChangedState(internalState.isOffline(), offline,
                 "Adjust already in offline mode",
                 "Adjust already in online mode")) {
             return;
         }
 
-        this.offline = offline;
+        internalState.offline = offline;
 
         if (activityState == null) {
-            updateStatus(!enabled,
+            updateStatus(offline,
                     "Package handler and attribution handler will start paused due to SDK being offline",
                     "Package and attribution handler will still start as paused due to SDK being disabled",
                     "Package handler and attribution handler will start as active due to SDK being online");
@@ -255,7 +291,7 @@ public boolean isEnabled() {
         if (activityState != null) {
             return activityState.enabled;
         } else {
-            return enabled;
+            return internalState.isEnabled();
         }
     }
 
@@ -293,16 +329,6 @@ public void setAskingAttribution(boolean askingAttribution) {
         writeActivityState();
     }
 
-    @Override
-    public ActivityPackage getAttributionPackage() {
-        long now = System.currentTimeMillis();
-        PackageBuilder attributionBuilder = new PackageBuilder(adjustConfig,
-                deviceInfo,
-                activityState,
-                now);
-        return attributionBuilder.buildAttributionPackage();
-    }
-
     @Override
     public void sendReferrer(String referrer, long clickTime) {
         Message message = Message.obtain();
@@ -336,6 +362,18 @@ public void launchAttributionResponseTasks(AttributionResponseData attributionRe
         sessionHandler.sendMessage(message);
     }
 
+    public ActivityPackage getAttributionPackage() {
+        long now = System.currentTimeMillis();
+        PackageBuilder attributionBuilder = new PackageBuilder(adjustConfig,
+                deviceInfo,
+                activityState,
+                now);
+        return attributionBuilder.buildAttributionPackage();
+    }
+
+    public InternalState getInternalState() {
+        return internalState;
+    }
 
     private class UrlClickTime {
         Uri url;
@@ -540,7 +578,7 @@ private void processSession() {
 
             transferSessionPackage(now);
             activityState.resetSessionAttributes(now);
-            activityState.enabled = this.enabled;
+            activityState.enabled = internalState.isEnabled();
             writeActivityState();
             return;
         }
@@ -614,7 +652,7 @@ private void endInternal() {
 
     private void trackEventInternal(AdjustEvent event) {
         if (!checkActivityState(activityState)) return;
-        if (!isEnabled()) return;
+        if (!this.isEnabled()) return;
         if (!checkEvent(event)) return;
 
         long now = System.currentTimeMillis();
@@ -633,7 +671,7 @@ private void trackEventInternal(AdjustEvent event) {
         }
 
         // if it is in the background and it can send, start the background timer
-        if (adjustConfig.sendInBackground && background) {
+        if (adjustConfig.sendInBackground && internalState.isBackground()) {
             startBackgroundTimer();
         }
 
@@ -1080,7 +1118,7 @@ private boolean checkActivityState(ActivityState activityState) {
     }
 
     private boolean paused() {
-        return offline || !isEnabled();
+        return internalState.isOffline() || !this.isEnabled();
     }
 
     private boolean toSend() {
@@ -1094,7 +1132,7 @@ private boolean toSend() {
             return true;
         }
 
-        // doesn't have the option -> depends on being on the background
-        return !background;
+        // doesn't have the option -> depends on being on the background/foreground
+        return internalState.isForeground();
     }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java
index ed52a4cfd..8c7225dfa 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IActivityHandler.java
@@ -6,35 +6,33 @@
  * Created by pfms on 15/12/14.
  */
 public interface IActivityHandler {
-    public void init(AdjustConfig config);
+    void init(AdjustConfig config);
 
-    public void onResume();
+    void onResume();
 
-    public void onPause();
+    void onPause();
 
-    public void trackEvent(AdjustEvent event);
+    void trackEvent(AdjustEvent event);
 
-    public void finishedTrackingActivity(ResponseData responseData);
+    void finishedTrackingActivity(ResponseData responseData);
 
-    public void setEnabled(boolean enabled);
+    void setEnabled(boolean enabled);
 
-    public boolean isEnabled();
+    boolean isEnabled();
 
-    public void readOpenUrl(Uri url, long clickTime);
+    void readOpenUrl(Uri url, long clickTime);
 
-    public boolean updateAttribution(AdjustAttribution attribution);
+    boolean updateAttribution(AdjustAttribution attribution);
 
-    public void launchEventResponseTasks(EventResponseData eventResponseData);
+    void launchEventResponseTasks(EventResponseData eventResponseData);
 
-    public void launchSessionResponseTasks(SessionResponseData sessionResponseData);
+    void launchSessionResponseTasks(SessionResponseData sessionResponseData);
 
-    public void launchAttributionResponseTasks(AttributionResponseData attributionResponseData);
+    void launchAttributionResponseTasks(AttributionResponseData attributionResponseData);
 
-    public void sendReferrer(String referrer, long clickTime);
+    void sendReferrer(String referrer, long clickTime);
 
-    public void setOfflineMode(boolean enabled);
+    void setOfflineMode(boolean enabled);
 
-    public void setAskingAttribution(boolean askingAttribution);
-
-    public ActivityPackage getAttributionPackage();
+    void setAskingAttribution(boolean askingAttribution);
 }

From 6b04219c3978aa1c04942564bb11cfeca26723ae Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 22 Mar 2016 17:15:31 +0100
Subject: [PATCH 09/37] Read files in constructor

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 38 +++++++++++--------
 1 file changed, 22 insertions(+), 16 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 1c3afc10b..8b77ec92c 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -57,32 +57,32 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private AdjustAttribution attribution;
     private IAttributionHandler attributionHandler;
 
-    private class InternalState {
+    public class InternalState {
         boolean enabled;
         boolean offline;
         boolean background;
 
-        boolean isEnabled() {
+        public boolean isEnabled() {
             return enabled;
         }
 
-        boolean isDisabled() {
+        public boolean isDisabled() {
             return !enabled;
         }
 
-        boolean isOffline() {
+        public boolean isOffline() {
             return offline;
         }
 
-        boolean isOnline() {
+        public boolean isOnline() {
             return !offline;
         }
 
-        boolean isBackground() {
+        public boolean isBackground() {
             return background;
         }
 
-        boolean isForeground() {
+        public boolean isForeground() {
             return !background;
         }
     }
@@ -95,13 +95,23 @@ private ActivityHandler(AdjustConfig adjustConfig) {
         logger = AdjustFactory.getLogger();
         sessionHandler = new SessionHandler(getLooper(), this);
         internalState = new InternalState();
+
+        // read files to have sync values available
+        readAttribution(adjustConfig.context);
+        readActivityState(adjustConfig.context);
+
         // enabled by default
-        internalState.enabled = true;
+        if (activityState == null) {
+            internalState.enabled = true;
+        } else {
+            internalState.enabled = activityState.enabled;
+        }
         // online by default
         internalState.offline = false;
         // in the background by default
         internalState.background = true;
 
+
         init(adjustConfig);
 
         Message message = Message.obtain();
@@ -523,9 +533,6 @@ private void initInternal() {
             sendReferrer(adjustConfig.referrer, adjustConfig.referrerClickTime); // send to background queue to make sure that activityState is valid
         }
 
-        readAttribution();
-        readActivityState();
-
         packageHandler = AdjustFactory.getPackageHandler(this, adjustConfig.context, toSend());
 
         ActivityPackage attributionPackage = getAttributionPackage();
@@ -1065,22 +1072,21 @@ private void stopBackgroundTimer() {
     }
 
     private void backgroundTimerFiredInternal() {
-        logger.debug("Background timer fired");
         packageHandler.sendFirstPackage();
     }
 
-    private void readActivityState() {
+    private void readActivityState(Context context) {
         try {
-            activityState = Util.readObject(adjustConfig.context, ACTIVITY_STATE_FILENAME, ACTIVITY_STATE_NAME, ActivityState.class);
+            activityState = Util.readObject(context, ACTIVITY_STATE_FILENAME, ACTIVITY_STATE_NAME, ActivityState.class);
         } catch (Exception e) {
             logger.error("Failed to read %s file (%s)", ACTIVITY_STATE_NAME, e.getMessage());
             activityState = null;
         }
     }
 
-    private void readAttribution() {
+    private void readAttribution(Context context) {
         try {
-            attribution = Util.readObject(adjustConfig.context, ATTRIBUTION_FILENAME, ATTRIBUTION_NAME, AdjustAttribution.class);
+            attribution = Util.readObject(context, ATTRIBUTION_FILENAME, ATTRIBUTION_NAME, AdjustAttribution.class);
         } catch (Exception e) {
             logger.error("Failed to read %s file (%s)", ATTRIBUTION_NAME, e.getMessage());
             attribution = null;

From d15dbd0eac2a1cc5ae2058000659a36e8ffc8de6 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 22 Mar 2016 18:39:02 +0100
Subject: [PATCH 10/37] Send reftag and deeplink always

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 44 ++++++++++---------
 .../main/java/com/adjust/sdk/Constants.java   |  1 +
 .../java/com/adjust/sdk/PackageBuilder.java   |  2 +
 3 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 8b77ec92c..cf45d0223 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -860,12 +860,17 @@ public void run() {
     }
 
     private void sendReferrerInternal(String referrer, long clickTime) {
-        ActivityPackage clickPackage = buildQueryStringClickPackage(referrer,
-                Constants.REFTAG,
-                clickTime);
-        if (clickPackage == null) {
+        if (referrer == null || referrer.length() == 0 ) {
             return;
         }
+        PackageBuilder clickPackageBuilder = queryStringClickPackageBuilder(referrer);
+
+        if (clickPackageBuilder == null) {
+            return;
+        }
+
+        clickPackageBuilder.referrer = referrer;
+        ActivityPackage clickPackage = clickPackageBuilder.buildClickPackage(Constants.REFTAG, clickTime);
 
         packageHandler.addPackage(clickPackage);
         packageHandler.sendFirstPackage();
@@ -878,35 +883,36 @@ private void readOpenUrlInternal(Uri url, long clickTime) {
 
         String queryString = url.getQuery();
 
-        ActivityPackage clickPackage = buildQueryStringClickPackage(queryString, "deeplink", clickTime);
-        if (clickPackage == null) {
+        if (queryString == null && url.toString().length() > 0) {
+            queryString = "";
+        }
+
+        PackageBuilder clickPackageBuilder = queryStringClickPackageBuilder(queryString);
+        if (clickPackageBuilder == null) {
             return;
         }
 
+        clickPackageBuilder.deeplink = url.toString();
+        ActivityPackage clickPackage = clickPackageBuilder.buildClickPackage(Constants.DEEPLINK, clickTime);
+
         packageHandler.addPackage(clickPackage);
         packageHandler.sendFirstPackage();
     }
 
-    private ActivityPackage buildQueryStringClickPackage(String queryString, String source, long clickTime) {
+    private PackageBuilder queryStringClickPackageBuilder(String queryString) {
         if (queryString == null) {
             return null;
         }
 
         Map<String, String> queryStringParameters = new LinkedHashMap<String, String>();
         AdjustAttribution queryStringAttribution = new AdjustAttribution();
-        boolean hasAdjustTags = false;
 
-        logger.verbose("Reading query string (%s) from %s", queryString, source);
+        logger.verbose("Reading query string (%s)", queryString);
 
         String[] queryPairs = queryString.split("&");
-        for (String pair : queryPairs) {
-            if (readQueryString(pair, queryStringParameters, queryStringAttribution)) {
-                hasAdjustTags = true;
-            }
-        }
 
-        if (!hasAdjustTags) {
-            return null;
+        for (String pair : queryPairs) {
+            readQueryString(pair, queryStringParameters, queryStringAttribution);
         }
 
         String reftag = queryStringParameters.remove(Constants.REFTAG);
@@ -916,12 +922,8 @@ private ActivityPackage buildQueryStringClickPackage(String queryString, String
         builder.extraParameters = queryStringParameters;
         builder.attribution = queryStringAttribution;
         builder.reftag = reftag;
-        if (source == Constants.REFTAG) {
-            builder.referrer = queryString;
-        }
 
-        ActivityPackage clickPackage = builder.buildClickPackage(source, clickTime);
-        return clickPackage;
+        return builder;
     }
 
     private boolean readQueryString(String queryString,
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
index 4f8d0ce12..3879bdf36 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
@@ -30,6 +30,7 @@ public interface Constants {
     String CLIENT_SDK = "android4.6.0";
     String LOGTAG = "Adjust";
     String REFTAG = "reftag";
+    String DEEPLINK = "deeplink";
 
     String ACTIVITY_STATE_FILENAME = "AdjustIoActivityState";
     String ATTRIBUTION_FILENAME = "AdjustAttribution";
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
index e8606567a..97ca78111 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
@@ -28,6 +28,7 @@ class PackageBuilder {
     AdjustAttribution attribution;
     String reftag;
     String referrer;
+    String deeplink;
 
     private static ILogger logger = AdjustFactory.getLogger();
 
@@ -79,6 +80,7 @@ public ActivityPackage buildClickPackage(String source, long clickTime) {
         addString(parameters, "reftag", reftag);
         addMapJson(parameters, "params", extraParameters);
         addString(parameters, "referrer", referrer);
+        addString(parameters, "deeplink", deeplink);
         injectAttribution(parameters);
 
         ActivityPackage clickPackage = getDefaultActivityPackage(ActivityKind.CLICK);

From 8cdc3b79c3788ca53f1490c82d1e055cff189c7c Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Thu, 31 Mar 2016 13:25:44 +0200
Subject: [PATCH 11/37] Refactor timer and logs

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 22 +++++++++-----
 .../com/adjust/sdk/AttributionHandler.java    |  3 +-
 .../java/com/adjust/sdk/PackageHandler.java   |  2 ++
 .../main/java/com/adjust/sdk/TimerCycle.java  | 29 ++++++++++++++++---
 .../main/java/com/adjust/sdk/TimerOnce.java   | 22 ++++++++++++--
 .../src/main/java/com/adjust/sdk/Util.java    |  2 +-
 6 files changed, 63 insertions(+), 17 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index cf45d0223..7954b965e 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -42,6 +42,8 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private static final String ADJUST_PREFIX = "adjust_";
     private static final String ACTIVITY_STATE_NAME = "Activity state";
     private static final String ATTRIBUTION_NAME = "Attribution";
+    private static final String FOREGROUND_TIMER_NAME = "Foreground timer";
+    private static final String BACKGROUND_TIMER_NAME = "Background timer";
 
     private SessionHandler sessionHandler;
     private IPackageHandler packageHandler;
@@ -165,6 +167,7 @@ public void onResume() {
     }
 
     public void trackSubsessionStart() {
+        logger.verbose("Subsession start");
         Message message = Message.obtain();
         message.arg1 = SessionHandler.START;
         sessionHandler.sendMessage(message);
@@ -177,6 +180,7 @@ public void onPause() {
     }
 
     public void trackSubsessionEnd() {
+        logger.verbose("Subsession end");
         Message message = Message.obtain();
         message.arg1 = SessionHandler.END;
         sessionHandler.sendMessage(message);
@@ -522,7 +526,9 @@ private void initInternal() {
 
         String playAdId = Util.getPlayAdId(adjustConfig.context);
         if (playAdId == null) {
-            logger.info("Unable to get Google Play Services Advertising ID at start time");
+            logger.warn("Unable to get Google Play Services Advertising ID at start time");
+        } else {
+            logger.debug("Google Play Services Advertising ID read correctly at start time");
         }
 
         if (adjustConfig.defaultTracker != null) {
@@ -546,7 +552,7 @@ private void initInternal() {
             public void run() {
                 foregroundTimerFired();
             }
-        }, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL);
+        }, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL, FOREGROUND_TIMER_NAME);
 
         scheduler = Executors.newSingleThreadScheduledExecutor();
         backgroundTimer = new TimerOnce(scheduler, new Runnable() {
@@ -554,7 +560,7 @@ public void run() {
             public void run() {
                 backgroundTimerFired();
             }
-        });
+        }, BACKGROUND_TIMER_NAME);
     }
 
     private void startInternal() {
@@ -615,11 +621,14 @@ private void processSession() {
             activityState.subsessionCount++;
             activityState.sessionLength += lastInterval;
             activityState.lastActivity = now;
-            writeActivityState();
-            logger.info("Started subsession %d of session %d",
+            logger.verbose("Started subsession %d of session %d",
                     activityState.subsessionCount,
                     activityState.sessionCount);
+            writeActivityState();
+            return;
         }
+
+        logger.verbose("Time span since last activity too short for a new subsession");
     }
 
     private void checkAttributionState() {
@@ -992,7 +1001,6 @@ private void resumeSending() {
         packageHandler.resumeSending();
     }
 
-
     private boolean updateActivityState(long now) {
         if (!checkActivityState(activityState)) { return false; }
 
@@ -1047,7 +1055,6 @@ private void foregroundTimerFiredInternal() {
             return;
         }
 
-        logger.debug("Session timer fired");
         packageHandler.sendFirstPackage();
 
         if (updateActivityState(System.currentTimeMillis())) {
@@ -1065,7 +1072,6 @@ private void startBackgroundTimer() {
         if (backgroundTimer.getFireIn() > 0) {
             return;
         }
-        logger.verbose("Background timer started");
         backgroundTimer.startIn(BACKGROUND_TIMER_INTERVAL);
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
index 89e0a40f5..5b65810bd 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
@@ -19,6 +19,7 @@ public class AttributionHandler implements IAttributionHandler {
     private ILogger logger;
     private ActivityPackage attributionPackage;
     private TimerOnce timer;
+    private static final String ATTRIBUTION_TIMER_NAME = "Attribution timer";
 
     private boolean paused;
     private boolean hasListener;
@@ -36,7 +37,7 @@ public AttributionHandler(IActivityHandler activityHandler,
                 public void run() {
                     getAttributionInternal();
                 }
-            });
+            }, ATTRIBUTION_TIMER_NAME);
         } else {
             this.logger.error("Timer not initialized, attribution handler is disabled");
         }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index 626c15652..a0bfc3bc4 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -89,6 +89,7 @@ public void sendNextPackage(ResponseData responseData) {
     @Override
     public void closeFirstPackage(ResponseData responseData) {
         isSending.set(false);
+        logger.verbose("Package handler can send");
 
         responseData.willRetry = true;
         activityHandler.finishedTrackingActivity(responseData);
@@ -190,6 +191,7 @@ private void sendNextInternal() {
         packageQueue.remove(0);
         writePackageQueue();
         isSending.set(false);
+        logger.verbose("Package handler can send");
         sendFirstInternal();
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java
index 97bb36874..387d0189c 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java
@@ -11,36 +11,57 @@
 public class TimerCycle {
     private ScheduledExecutorService scheduler;
     private ScheduledFuture waitingTask;
+    private String name;
     private Runnable command;
     private long initialDelay;
     private long cycleDelay;
     private boolean isPaused;
+    private ILogger logger;
 
-    public TimerCycle(Runnable command, long initialDelay, long cycleDelay) {
+    public TimerCycle(Runnable command, long initialDelay, long cycleDelay, String name) {
         this.scheduler = Executors.newSingleThreadScheduledExecutor();
 
+        this.name = name;
         this.command = command;
         this.initialDelay = initialDelay;
         this.cycleDelay = cycleDelay;
         this.isPaused = true;
+        this.logger = AdjustFactory.getLogger();
     }
 
     public void start() {
-        if (!isPaused) { return; }
+        if (!isPaused) {
+            logger.verbose("%s is already started", name);
+            return;
+        }
 
-        waitingTask = scheduler.scheduleWithFixedDelay(command, initialDelay, cycleDelay, TimeUnit.MILLISECONDS);
+        logger.verbose("%s starting in %d seconds and cycle every %d seconds", name, TimeUnit.MILLISECONDS.toSeconds(initialDelay), TimeUnit.MILLISECONDS.toSeconds(cycleDelay));
+
+        waitingTask = scheduler.scheduleWithFixedDelay(new Runnable() {
+            @Override
+            public void run() {
+                logger.verbose("%s fired", name);
+                command.run();
+            }
+        }, initialDelay, cycleDelay, TimeUnit.MILLISECONDS);
 
         isPaused = false;
     }
 
     public void suspend() {
-        if (isPaused) { return; }
+        if (isPaused) {
+            logger.verbose("%s is already suspended", name);
+            return;
+        }
 
         // get the remaining delay
         initialDelay = waitingTask.getDelay(TimeUnit.MILLISECONDS);
 
         // cancel the timer
         waitingTask.cancel(false);
+        waitingTask = null;
+
+        logger.verbose("%s suspended with %d seconds left", name, TimeUnit.MILLISECONDS.toSeconds(initialDelay));
 
         isPaused = true;
     }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
index c4d8aa10b..d34ed38dd 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
@@ -10,19 +10,27 @@
 public class TimerOnce {
     private ScheduledExecutorService scheduler;
     private ScheduledFuture waitingTask;
+    private String name;
     private Runnable command;
+    private ILogger logger;
 
-    public TimerOnce(ScheduledExecutorService scheduler, Runnable command) {
+    public TimerOnce(ScheduledExecutorService scheduler, Runnable command, String name) {
+        this.name = name;
         this.scheduler = scheduler;
         this.command = command;
+        this.logger = AdjustFactory.getLogger();
     }
 
     public void startIn(long fireIn) {
         // cancel previous
-        cancel();
+        cancel(false);
+
+        logger.verbose("%s starting. Launching in %d seconds", name, TimeUnit.MILLISECONDS.toSeconds(fireIn));
+
         waitingTask = scheduler.schedule(new Runnable() {
             @Override
             public void run() {
+                logger.verbose("%s fired", name);
                 command.run();
                 waitingTask = null;
             }
@@ -36,10 +44,18 @@ public long getFireIn() {
         return waitingTask.getDelay(TimeUnit.MILLISECONDS);
     }
 
-    public void cancel() {
+    private void cancel(boolean log) {
         if (waitingTask != null) {
             waitingTask.cancel(false);
         }
         waitingTask = null;
+
+        if (log) {
+            logger.verbose("%s canceled", name);
+        }
+    }
+
+    public void cancel() {
+        cancel(true);
     }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index 6299e5a70..18f3e78e7 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -160,7 +160,7 @@ public static <T> T readObject(Context context, String filename, String objectNa
                 getLogger().error("Failed to read %s object (%s)", objectName, e.getMessage());
             }
         } catch (FileNotFoundException e) {
-            getLogger().verbose("%s file not found", objectName);
+            getLogger().debug("%s file not found", objectName);
         } catch (Exception e) {
             getLogger().error("Failed to open %s file for reading (%s)", objectName, e);
         }

From ab223e517a64418e911ec292ad8a5686b0155f52 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Thu, 31 Mar 2016 15:10:37 +0200
Subject: [PATCH 12/37] Sdk click handler

---
 .../java/com/adjust/sdk/ActivityHandler.java  |  11 +-
 .../java/com/adjust/sdk/AdjustFactory.java    |  14 ++
 .../java/com/adjust/sdk/ISdkClickHandler.java |  11 ++
 .../java/com/adjust/sdk/PackageHandler.java   |   6 +-
 .../java/com/adjust/sdk/RequestHandler.java   |  12 +-
 .../java/com/adjust/sdk/SdkClickHandler.java  | 121 ++++++++++++++++++
 .../src/main/java/com/adjust/sdk/Util.java    |   8 ++
 7 files changed, 164 insertions(+), 19 deletions(-)
 create mode 100644 Adjust/adjust/src/main/java/com/adjust/sdk/ISdkClickHandler.java
 create mode 100644 Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 7954b965e..52856e427 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -58,6 +58,7 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private AdjustConfig adjustConfig; // always valid after construction
     private AdjustAttribution attribution;
     private IAttributionHandler attributionHandler;
+    private ISdkClickHandler sdkClickHandler;
 
     public class InternalState {
         boolean enabled;
@@ -547,6 +548,8 @@ private void initInternal() {
                 toSend(),
                 adjustConfig.hasAttributionChangedListener());
 
+        sdkClickHandler = AdjustFactory.getSdkClickHandler(toSend());
+
         foregroundTimer = new TimerCycle(new Runnable() {
             @Override
             public void run() {
@@ -881,8 +884,7 @@ private void sendReferrerInternal(String referrer, long clickTime) {
         clickPackageBuilder.referrer = referrer;
         ActivityPackage clickPackage = clickPackageBuilder.buildClickPackage(Constants.REFTAG, clickTime);
 
-        packageHandler.addPackage(clickPackage);
-        packageHandler.sendFirstPackage();
+        sdkClickHandler.sendSdkClick(clickPackage);
     }
 
     private void readOpenUrlInternal(Uri url, long clickTime) {
@@ -904,8 +906,7 @@ private void readOpenUrlInternal(Uri url, long clickTime) {
         clickPackageBuilder.deeplink = url.toString();
         ActivityPackage clickPackage = clickPackageBuilder.buildClickPackage(Constants.DEEPLINK, clickTime);
 
-        packageHandler.addPackage(clickPackage);
-        packageHandler.sendFirstPackage();
+        sdkClickHandler.sendSdkClick(clickPackage);
     }
 
     private PackageBuilder queryStringClickPackageBuilder(String queryString) {
@@ -994,11 +995,13 @@ private void updateHandlersStatusInternal() {
     private void pauseSending() {
         attributionHandler.pauseSending();
         packageHandler.pauseSending();
+        sdkClickHandler.pauseSending();
     }
 
     private void resumeSending() {
         attributionHandler.resumeSending();
         packageHandler.resumeSending();
+        sdkClickHandler.resumeSending();
     }
 
     private boolean updateActivityState(long now) {
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
index f359602d0..80036bd7f 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
@@ -14,6 +14,7 @@ public class AdjustFactory {
     private static IActivityHandler activityHandler = null;
     private static ILogger logger = null;
     private static HttpsURLConnection mockHttpsURLConnection = null;
+    private static ISdkClickHandler sdkClickHandler = null;
 
     private static long timerInterval = -1;
     private static long timerStart = -1;
@@ -101,6 +102,15 @@ public static HttpsURLConnection getHttpsURLConnection(URL url) throws IOExcepti
         return AdjustFactory.mockHttpsURLConnection;
     }
 
+    public static ISdkClickHandler getSdkClickHandler(boolean startsSending) {
+        if (sdkClickHandler == null) {
+            return new SdkClickHandler(startsSending);
+        }
+
+        sdkClickHandler.init(startsSending);
+        return sdkClickHandler;
+    }
+
     public static void setPackageHandler(IPackageHandler packageHandler) {
         AdjustFactory.packageHandler = packageHandler;
     }
@@ -140,4 +150,8 @@ public static void setAttributionHandler(IAttributionHandler attributionHandler)
     public static void setMockHttpsURLConnection(HttpsURLConnection mockHttpsURLConnection) {
         AdjustFactory.mockHttpsURLConnection = mockHttpsURLConnection;
     }
+
+    public static void setSdkClickHandler(ISdkClickHandler sdkClickHandler) {
+        AdjustFactory.sdkClickHandler = sdkClickHandler;
+    }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ISdkClickHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ISdkClickHandler.java
new file mode 100644
index 000000000..d3a05145d
--- /dev/null
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ISdkClickHandler.java
@@ -0,0 +1,11 @@
+package com.adjust.sdk;
+
+/**
+ * Created by pfms on 31/03/16.
+ */
+public interface ISdkClickHandler {
+    void init(boolean startsSending);
+    void pauseSending();
+    void resumeSending();
+    void sendSdkClick(ActivityPackage sdkClick);
+}
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index a0bfc3bc4..c467a572a 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -158,11 +158,7 @@ private void initInternal() {
     }
 
     private void addInternal(ActivityPackage newPackage) {
-        if (newPackage.getActivityKind().equals(ActivityKind.CLICK) && !packageQueue.isEmpty()) {
-            packageQueue.add(1, newPackage);
-        } else {
-            packageQueue.add(newPackage);
-        }
+        packageQueue.add(newPackage);
         logger.debug("Added package %d (%s)", packageQueue.size(), newPackage);
         logger.verbose("%s", newPackage.getExtendedString());
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
index ac898494a..a50257865 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
@@ -115,7 +115,7 @@ private void requestFinished(ResponseData responseData) throws JSONException {
     // close current package because it failed
     private void closePackage(ActivityPackage activityPackage, String message, Throwable throwable) {
         final String packageMessage = activityPackage.getFailureMessage();
-        final String reasonString = getReasonString(message, throwable);
+        final String reasonString = Util.getReasonString(message, throwable);
         String finalMessage = String.format("%s. (%s) Will retry later", packageMessage, reasonString);
         logger.error(finalMessage);
 
@@ -128,7 +128,7 @@ private void closePackage(ActivityPackage activityPackage, String message, Throw
     // send next package because the current package failed
     private void sendNextPackage(ActivityPackage activityPackage, String message, Throwable throwable) {
         final String failureMessage = activityPackage.getFailureMessage();
-        final String reasonString = getReasonString(message, throwable);
+        final String reasonString = Util.getReasonString(message, throwable);
         String finalMessage = String.format("%s. (%s)", failureMessage, reasonString);
         logger.error(finalMessage);
 
@@ -137,12 +137,4 @@ private void sendNextPackage(ActivityPackage activityPackage, String message, Th
 
         packageHandler.sendNextPackage(responseData);
     }
-
-    private String getReasonString(String message, Throwable throwable) {
-        if (throwable != null) {
-            return String.format(Locale.US, "%s: %s", message, throwable);
-        } else {
-            return String.format(Locale.US, "%s", message);
-        }
-    }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
new file mode 100644
index 000000000..db85a35e0
--- /dev/null
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
@@ -0,0 +1,121 @@
+package com.adjust.sdk;
+
+import android.os.Handler;
+import android.os.HandlerThread;
+import android.os.Looper;
+
+import java.io.IOException;
+import java.io.UnsupportedEncodingException;
+import java.net.SocketTimeoutException;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.net.ssl.HttpsURLConnection;
+
+/**
+ * Created by pfms on 31/03/16.
+ */
+public class SdkClickHandler extends HandlerThread implements ISdkClickHandler {
+    private final Handler internalHandler;
+    private ILogger logger;
+    private boolean paused;
+    private List<ActivityPackage> packageQueue;
+
+    public SdkClickHandler(boolean startsSending) {
+        super(Constants.LOGTAG, MIN_PRIORITY);
+        setDaemon(true);
+        start();
+
+        init(startsSending);
+        this.logger = AdjustFactory.getLogger();
+        this.internalHandler = new Handler(getLooper());
+    }
+
+    @Override
+    public void init(boolean startsSending) {
+        this.paused = !startsSending;
+        this.packageQueue = new ArrayList<ActivityPackage>();
+    }
+
+    @Override
+    public void pauseSending() {
+        paused = true;
+    }
+
+    @Override
+    public void resumeSending() {
+        paused = false;
+
+        sendNextSdkClick();
+    }
+
+    @Override
+    public void sendSdkClick(final ActivityPackage sdkClick) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                packageQueue.add(sdkClick);
+                logger.debug("Added sdk_click %d", packageQueue.size());
+                logger.verbose("%s", sdkClick.getExtendedString());
+                sendNextSdkClick();
+            }
+        });
+    }
+
+    private void sendNextSdkClick() {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                if (paused) {
+                    return;
+                }
+
+                if (packageQueue.isEmpty()) {
+                    return;
+                }
+
+                ActivityPackage sdkClickPackage = packageQueue.get(0);
+
+                sendSdkClickInternal(sdkClickPackage);
+
+                packageQueue.remove(0);
+                sendNextSdkClick();
+            }
+        });
+    }
+
+    private void sendSdkClickInternal(ActivityPackage sdkClickPackage) {
+        String targetURL = Constants.BASE_URL + sdkClickPackage.getPath();
+
+        try {
+            HttpsURLConnection connection = Util.createPOSTHttpsURLConnection(
+                    targetURL,
+                    sdkClickPackage.getClientSdk(),
+                    sdkClickPackage.getParameters());
+
+            ResponseData responseData = Util.readHttpResponse(connection, sdkClickPackage);
+
+            // retry
+            if (responseData.jsonResponse == null) {
+                sendSdkClick(sdkClickPackage);
+            }
+        } catch (UnsupportedEncodingException e) {
+            logErrorMessage(sdkClickPackage, "Sdk_click failed to encode parameters", e);
+        } catch (SocketTimeoutException e) {
+            logErrorMessage(sdkClickPackage, "Sdk_click request timed out. Will retry later", e);
+            retrySending(sdkClickPackage);
+        } catch (IOException e) {
+            logErrorMessage(sdkClickPackage, "Sdk_click request failed. Will retry later", e);
+            retrySending(sdkClickPackage);
+        } catch (Throwable e) {
+            logErrorMessage(sdkClickPackage, "Sdk_click runtime exception", e);
+        }
+    }
+
+    private void logErrorMessage(ActivityPackage sdkClickPackage, String message, Throwable throwable) {
+        final String packageMessage = sdkClickPackage.getFailureMessage();
+        final String reasonString = Util.getReasonString(message, throwable);
+        String finalMessage = String.format("%s. (%s)", packageMessage, reasonString);
+        logger.error(finalMessage);
+    }
+}
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index 18f3e78e7..149b8c1dc 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -500,4 +500,12 @@ public static String[] getSupportedAbis() {
     public static String getCpuAbi() {
         return Reflection.getCpuAbi();
     }
+
+    public static String getReasonString(String message, Throwable throwable) {
+        if (throwable != null) {
+            return String.format(Locale.US, "%s: %s", message, throwable);
+        } else {
+            return String.format(Locale.US, "%s", message);
+        }
+    }
 }

From 2b0dcd8c6a31096ea00adc54328943c1905e46a8 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Thu, 31 Mar 2016 15:59:36 +0200
Subject: [PATCH 13/37] Send queue size

---
 .../java/com/adjust/sdk/AdjustFactory.java    | 27 ++++++++---
 .../com/adjust/sdk/AttributionHandler.java    |  8 +++-
 .../java/com/adjust/sdk/IRequestHandler.java  |  2 +-
 .../java/com/adjust/sdk/PackageHandler.java   |  2 +-
 .../java/com/adjust/sdk/RequestHandler.java   | 11 +++--
 .../java/com/adjust/sdk/SdkClickHandler.java  | 10 ++++-
 .../src/main/java/com/adjust/sdk/Util.java    | 45 ++++++++++++-------
 7 files changed, 74 insertions(+), 31 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
index 80036bd7f..23fbadb6c 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
@@ -13,7 +13,7 @@ public class AdjustFactory {
     private static IAttributionHandler attributionHandler = null;
     private static IActivityHandler activityHandler = null;
     private static ILogger logger = null;
-    private static HttpsURLConnection mockHttpsURLConnection = null;
+    private static HttpsURLConnection httpsURLConnection = null;
     private static ISdkClickHandler sdkClickHandler = null;
 
     private static long timerInterval = -1;
@@ -21,6 +21,15 @@ public class AdjustFactory {
     private static long sessionInterval = -1;
     private static long subsessionInterval = -1;
 
+    public static class URLGetConnection {
+        HttpsURLConnection httpsURLConnection;
+        URL url;
+        URLGetConnection(HttpsURLConnection httpsURLConnection, URL url) {
+            this.httpsURLConnection = httpsURLConnection;
+            this.url = url;
+        }
+    }
+
     public static IPackageHandler getPackageHandler(ActivityHandler activityHandler,
                                                     Context context,
                                                     boolean startsSending) {
@@ -95,11 +104,19 @@ public static IAttributionHandler getAttributionHandler(IActivityHandler activit
     }
 
     public static HttpsURLConnection getHttpsURLConnection(URL url) throws IOException {
-        if (AdjustFactory.mockHttpsURLConnection == null) {
+        if (AdjustFactory.httpsURLConnection == null) {
             return (HttpsURLConnection)url.openConnection();
         }
 
-        return AdjustFactory.mockHttpsURLConnection;
+        return AdjustFactory.httpsURLConnection;
+    }
+
+    public static URLGetConnection getHttpsURLGetConnection(URL url) throws IOException {
+        if (AdjustFactory.httpsURLConnection == null) {
+            return new URLGetConnection((HttpsURLConnection)url.openConnection(), url);
+        }
+
+        return new URLGetConnection(AdjustFactory.httpsURLConnection, url);
     }
 
     public static ISdkClickHandler getSdkClickHandler(boolean startsSending) {
@@ -147,8 +164,8 @@ public static void setAttributionHandler(IAttributionHandler attributionHandler)
         AdjustFactory.attributionHandler = attributionHandler;
     }
 
-    public static void setMockHttpsURLConnection(HttpsURLConnection mockHttpsURLConnection) {
-        AdjustFactory.mockHttpsURLConnection = mockHttpsURLConnection;
+    public static void setHttpsURLConnection(HttpsURLConnection httpsURLConnection) {
+        AdjustFactory.httpsURLConnection = httpsURLConnection;
     }
 
     public static void setSdkClickHandler(ISdkClickHandler sdkClickHandler) {
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
index 5b65810bd..d8b880f3f 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
@@ -4,6 +4,7 @@
 
 import org.json.JSONObject;
 
+import java.net.URL;
 import java.util.Map;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
@@ -24,6 +25,8 @@ public class AttributionHandler implements IAttributionHandler {
     private boolean paused;
     private boolean hasListener;
 
+    public URL lastUrlUsed;
+
     public AttributionHandler(IActivityHandler activityHandler,
                               ActivityPackage attributionPackage,
                               boolean startsSending,
@@ -150,11 +153,12 @@ private void getAttributionInternal() {
         logger.verbose("%s", attributionPackage.getExtendedString());
 
         try {
-            HttpsURLConnection connection = Util.createGETHttpsURLConnection(
+            AdjustFactory.URLGetConnection urlGetConnection = Util.createGETHttpsURLConnection(
                     buildUri(attributionPackage.getPath(), attributionPackage.getParameters()).toString(),
                     attributionPackage.getClientSdk());
 
-            ResponseData responseData = Util.readHttpResponse(connection, attributionPackage);
+            ResponseData responseData = Util.readHttpResponse(urlGetConnection.httpsURLConnection, attributionPackage);
+            lastUrlUsed = urlGetConnection.url;
 
             if (!(responseData instanceof AttributionResponseData)) {
                 return;
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java
index be78e4b8e..705864578 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java
@@ -3,5 +3,5 @@
 public interface IRequestHandler {
     public void init(IPackageHandler packageHandler);
 
-    public void sendPackage(ActivityPackage pack);
+    public void sendPackage(ActivityPackage pack, int queueSize);
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index c467a572a..f5994bdd9 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -180,7 +180,7 @@ private void sendFirstInternal() {
         }
 
         ActivityPackage firstPackage = packageQueue.get(0);
-        requestHandler.sendPackage(firstPackage);
+        requestHandler.sendPackage(firstPackage, packageQueue.size() - 1);
     }
 
     private void sendNextInternal() {
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
index a50257865..e82f83521 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
@@ -45,9 +45,10 @@ public void init(IPackageHandler packageHandler) {
     }
 
     @Override
-    public void sendPackage(ActivityPackage pack) {
+    public void sendPackage(ActivityPackage pack, int queueSize) {
         Message message = Message.obtain();
         message.arg1 = InternalHandler.SEND;
+        message.arg2 = queueSize;
         message.obj = pack;
         internalHandler.sendMessage(message);
     }
@@ -74,20 +75,22 @@ public void handleMessage(Message message) {
             switch (message.arg1) {
                 case SEND:
                     ActivityPackage activityPackage = (ActivityPackage) message.obj;
-                    requestHandler.sendInternal(activityPackage);
+                    int queueSize = message.arg2;
+                    requestHandler.sendInternal(activityPackage, queueSize);
                     break;
             }
         }
     }
 
-    private void sendInternal(ActivityPackage activityPackage) {
+    private void sendInternal(ActivityPackage activityPackage, int queueSize) {
         String targetURL = Constants.BASE_URL + activityPackage.getPath();
 
         try {
             HttpsURLConnection connection = Util.createPOSTHttpsURLConnection(
                     targetURL,
                     activityPackage.getClientSdk(),
-                    activityPackage.getParameters());
+                    activityPackage.getParameters(),
+                    queueSize);
 
             ResponseData responseData = Util.readHttpResponse(connection, activityPackage);
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
index db85a35e0..23ba5774e 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
@@ -91,7 +91,8 @@ private void sendSdkClickInternal(ActivityPackage sdkClickPackage) {
             HttpsURLConnection connection = Util.createPOSTHttpsURLConnection(
                     targetURL,
                     sdkClickPackage.getClientSdk(),
-                    sdkClickPackage.getParameters());
+                    sdkClickPackage.getParameters(),
+                    packageQueue.size() - 1);
 
             ResponseData responseData = Util.readHttpResponse(connection, sdkClickPackage);
 
@@ -112,6 +113,13 @@ private void sendSdkClickInternal(ActivityPackage sdkClickPackage) {
         }
     }
 
+    private void retrySending(ActivityPackage sdkClickPackage) {
+        int retries = sdkClickPackage.increaseRetries();
+
+        logger.error("Retrying sdk_click package for the %d time", retries);
+        sendSdkClick(sdkClickPackage);
+    }
+
     private void logErrorMessage(ActivityPackage sdkClickPackage, String message, Throwable throwable) {
         final String packageMessage = sdkClickPackage.getFailureMessage();
         final String reasonString = Util.getReasonString(message, throwable);
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index 149b8c1dc..e8d853307 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -280,17 +280,29 @@ public static ResponseData readHttpResponse(HttpsURLConnection connection, Activ
         return responseData;
     }
 
-    public static HttpsURLConnection createGETHttpsURLConnection(String urlString, String clientSdk)
-            throws IOException {
-        HttpsURLConnection connection = createHttpsURLConnection(urlString, clientSdk);
+    public static AdjustFactory.URLGetConnection createGETHttpsURLConnection(String urlString, String clientSdk)
+            throws IOException
+    {
+        URL url = new URL(urlString);
+        AdjustFactory.URLGetConnection urlGetConnection = AdjustFactory.getHttpsURLGetConnection(url);
+
+        HttpsURLConnection connection = urlGetConnection.httpsURLConnection;
+        setDefaultHttpsUrlConnectionProperties(connection, clientSdk);
+
         connection.setRequestMethod("GET");
 
-        return connection;
+        return urlGetConnection;
     }
 
-    public static HttpsURLConnection createPOSTHttpsURLConnection(String urlString, String clientSdk, Map<String, String> parameters)
-            throws IOException {
-        HttpsURLConnection connection = createHttpsURLConnection(urlString, clientSdk);
+    public static HttpsURLConnection createPOSTHttpsURLConnection(String urlString, String clientSdk,
+                                                                  Map<String, String> parameters,
+                                                                  int queueSize)
+            throws IOException
+    {
+        URL url = new URL(urlString);
+        HttpsURLConnection connection = AdjustFactory.getHttpsURLConnection(url);
+
+        setDefaultHttpsUrlConnectionProperties(connection, clientSdk);
         connection.setRequestMethod("POST");
 
         connection.setUseCaches(false);
@@ -298,14 +310,14 @@ public static HttpsURLConnection createPOSTHttpsURLConnection(String urlString,
         connection.setDoOutput(true);
 
         DataOutputStream wr = new DataOutputStream(connection.getOutputStream());
-        wr.writeBytes(getPostDataString(parameters));
+        wr.writeBytes(getPostDataString(parameters, queueSize));
         wr.flush();
         wr.close();
 
         return connection;
     }
 
-    private static String getPostDataString(Map<String, String> body) throws UnsupportedEncodingException {
+    private static String getPostDataString(Map<String, String> body, int queueSize) throws UnsupportedEncodingException {
         StringBuilder result = new StringBuilder();
 
         for(Map.Entry<String, String> entry : body.entrySet()) {
@@ -329,20 +341,19 @@ private static String getPostDataString(Map<String, String> body) throws Unsuppo
         result.append("=");
         result.append(URLEncoder.encode(dateString, Constants.ENCODING));
 
-        return result.toString();
-    }
+        result.append("&");
+        result.append(URLEncoder.encode("queue_size", Constants.ENCODING));
+        result.append("=");
+        result.append(URLEncoder.encode("" + queueSize, Constants.ENCODING));
 
-    public static HttpsURLConnection createHttpsURLConnection(String urlString, String clientSdk)
-            throws IOException {
-        URL url = new URL(urlString);
 
-        HttpsURLConnection connection = AdjustFactory.getHttpsURLConnection(url);
+        return result.toString();
+    }
 
+    public static void setDefaultHttpsUrlConnectionProperties(HttpsURLConnection connection, String clientSdk) {
         connection.setRequestProperty("Client-SDK", clientSdk);
         connection.setConnectTimeout(Constants.ONE_MINUTE);
         connection.setReadTimeout(Constants.ONE_MINUTE);
-
-        return connection;
     }
 
     public static boolean checkPermission(Context context, String permission) {

From 395aa602afb231a51e0affccf69348b53df73f0d Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Thu, 31 Mar 2016 17:48:16 +0200
Subject: [PATCH 14/37] Add exponential backoff and jitter

---
 .../java/com/adjust/sdk/ActivityPackage.java  | 10 ++++
 .../java/com/adjust/sdk/AdjustFactory.java    | 24 +++++++++
 .../java/com/adjust/sdk/BackoffStrategy.java  | 49 +++++++++++++++++++
 .../main/java/com/adjust/sdk/Constants.java   |  2 +
 .../java/com/adjust/sdk/IPackageHandler.java  |  2 +-
 .../java/com/adjust/sdk/PackageHandler.java   | 24 ++++++++-
 .../java/com/adjust/sdk/RequestHandler.java   | 19 +++----
 .../java/com/adjust/sdk/SdkClickHandler.java  | 15 +++++-
 .../src/main/java/com/adjust/sdk/Util.java    | 23 +++++++++
 9 files changed, 152 insertions(+), 16 deletions(-)
 create mode 100644 Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityPackage.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityPackage.java
index 964f22a2b..aff2421c5 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityPackage.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityPackage.java
@@ -41,6 +41,8 @@ public class ActivityPackage implements Serializable {
     private ActivityKind activityKind = ActivityKind.UNKNOWN;
     private String suffix;
 
+    private int retries;
+
     public String getPath() {
         return path;
     }
@@ -77,6 +79,14 @@ public void setSuffix(String suffix) {
         this.suffix = suffix;
     }
 
+    public int getRetries() {
+        return retries;
+    }
+    public int increaseRetries() {
+        retries++;
+        return retries;
+    }
+
     public ActivityPackage(ActivityKind activityKind) {
         this.activityKind = activityKind;
     }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
index 23fbadb6c..b72b723f9 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
@@ -20,6 +20,8 @@ public class AdjustFactory {
     private static long timerStart = -1;
     private static long sessionInterval = -1;
     private static long subsessionInterval = -1;
+    private static BackoffStrategy sdkClickBackoffStrategy = null;
+    private static BackoffStrategy packageHandlerBackoffStrategy = null;
 
     public static class URLGetConnection {
         HttpsURLConnection httpsURLConnection;
@@ -84,6 +86,20 @@ public static long getSubsessionInterval() {
         return subsessionInterval;
     }
 
+    public static BackoffStrategy getSdkClickBackoffStrategy() {
+        if (sdkClickBackoffStrategy == null) {
+            return BackoffStrategy.SHORT_WAIT;
+        }
+        return sdkClickBackoffStrategy;
+    }
+
+    public static BackoffStrategy getPackageHandlerBackoffStrategy() {
+        if (packageHandlerBackoffStrategy == null) {
+            return BackoffStrategy.LONG_WAIT;
+        }
+        return packageHandlerBackoffStrategy;
+    }
+
     public static IActivityHandler getActivityHandler(AdjustConfig config) {
         if (activityHandler == null) {
             return ActivityHandler.getInstance(config);
@@ -156,6 +172,14 @@ public static void setSubsessionInterval(long subsessionInterval) {
         AdjustFactory.subsessionInterval = subsessionInterval;
     }
 
+    public static void setSdkClickBackoffStrategy(BackoffStrategy sdkClickBackoffStrategy) {
+        AdjustFactory.sdkClickBackoffStrategy = sdkClickBackoffStrategy;
+    }
+
+    public static void setPackageHandlerBackoffStrategy(BackoffStrategy packageHandlerBackoffStrategy) {
+        AdjustFactory.packageHandlerBackoffStrategy = packageHandlerBackoffStrategy;
+    }
+
     public static void setActivityHandler(IActivityHandler activityHandler) {
         AdjustFactory.activityHandler = activityHandler;
     }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java b/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
new file mode 100644
index 000000000..7237cc48a
--- /dev/null
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
@@ -0,0 +1,49 @@
+package com.adjust.sdk;
+
+/**
+ * Created by pfms on 06/04/16.
+ */
+public enum BackoffStrategy {
+    LONG_WAIT(1,                        // min retries
+            2 * Constants.ONE_MINUTE,   // milliseconds multiplier
+            24 * Constants.ONE_HOUR,    // max wait time
+            50,                         // min jitter multiplier
+            100),                       // max jitter multiplier
+
+    // 0.1-0.2, 0.2-0.4, 0.4-0.8, ... 1m
+    SHORT_WAIT(1,                   // min retries
+            200,                    // milliseconds multiplier
+            Constants.ONE_MINUTE,   // max wait time
+            50,                     // min jitter multiplier
+            100),                   // max jitter multiplier
+
+    TEST_WAIT(1,                    // min retries
+            200,                    // milliseconds multiplier
+            1000,                   // max wait time
+            50,                     // min jitter multiplier
+            100),                   // max jitter multiplier
+
+    NO_WAIT(100,                    // min retries
+            1,                      // milliseconds multiplier
+            Constants.ONE_SECOND,   // max wait time
+            1,                      // min jitter multiplier
+            1);                     // max jitter multiplier
+
+    int minRetries;
+    long milliSecondMultiplier;
+    long maxWait;
+    int minJitter;
+    int maxJitter;
+
+    BackoffStrategy(int minRetries,
+                    long milliSecondMultiplier,
+                    long maxWait,
+                    int minJitter,
+                    int maxJitter) {
+        this.minRetries = minRetries;
+        this.milliSecondMultiplier = milliSecondMultiplier;
+        this.maxWait = maxWait;
+        this.minJitter = minJitter;
+        this.maxJitter = maxJitter;
+    }
+}
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
index 3879bdf36..c2b67b3fc 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
@@ -20,9 +20,11 @@ public interface Constants {
     int ONE_SECOND = 1000;
     int ONE_MINUTE = 60 * ONE_SECOND;
     int THIRTY_MINUTES = 30 * ONE_MINUTE;
+    int ONE_HOUR = 2 * THIRTY_MINUTES;
 
     int CONNECTION_TIMEOUT = Constants.ONE_MINUTE;
     int SOCKET_TIMEOUT = Constants.ONE_MINUTE;
+    int MAX_WAIT_INTERVAL = Constants.ONE_MINUTE;
 
     String BASE_URL = "https://app.adjust.com";
     String SCHEME = "https";
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
index a0799a6ac..757814b78 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
@@ -11,7 +11,7 @@ public interface IPackageHandler {
 
     public void sendNextPackage(ResponseData responseData);
 
-    public void closeFirstPackage(ResponseData responseData);
+    public void closeFirstPackage(ResponseData responseData, ActivityPackage activityPackage);
 
     public void pauseSending();
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index f5994bdd9..1a4030bca 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -14,10 +14,14 @@
 import android.os.HandlerThread;
 import android.os.Looper;
 import android.os.Message;
+import android.os.SystemClock;
 
 import java.lang.ref.WeakReference;
+import java.text.DecimalFormat;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Random;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 // persistent
@@ -33,6 +37,7 @@ public class PackageHandler extends HandlerThread implements IPackageHandler {
     private boolean paused;
     private Context context;
     private ILogger logger;
+    private BackoffStrategy backoffStrategy;
 
     public PackageHandler(IActivityHandler activityHandler,
                           Context context,
@@ -42,6 +47,7 @@ public PackageHandler(IActivityHandler activityHandler,
         start();
         this.internalHandler = new InternalHandler(getLooper(), this);
         this.logger = AdjustFactory.getLogger();
+        this.backoffStrategy = AdjustFactory.getPackageHandlerBackoffStrategy();
 
         init(activityHandler, context, startsSending);
 
@@ -87,12 +93,26 @@ public void sendNextPackage(ResponseData responseData) {
 
     // close the package to retry in the future (after temporary failure)
     @Override
-    public void closeFirstPackage(ResponseData responseData) {
-        isSending.set(false);
+    public void closeFirstPackage(ResponseData responseData, ActivityPackage activityPackage) {
         logger.verbose("Package handler can send");
 
         responseData.willRetry = true;
         activityHandler.finishedTrackingActivity(responseData);
+
+        if (activityPackage != null) {
+            int retries = activityPackage.increaseRetries();
+
+            long waitTime = Util.getWaitingTime(retries, backoffStrategy);
+
+            DecimalFormat df = new DecimalFormat("#.#");
+            double waitTimeSeconds = waitTime / 1000.0;
+
+            logger.verbose("Sleeping for %s seconds before retrying the %d time", df.format(waitTimeSeconds), retries);
+            SystemClock.sleep(waitTime);
+        }
+
+        isSending.set(false);
+        sendFirstPackage();
     }
 
     // interrupt the sending loop after the current request has finished
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
index e82f83521..c06ab44ea 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
@@ -94,7 +94,13 @@ private void sendInternal(ActivityPackage activityPackage, int queueSize) {
 
             ResponseData responseData = Util.readHttpResponse(connection, activityPackage);
 
-            requestFinished(responseData);
+            if (responseData.jsonResponse == null) {
+                packageHandler.closeFirstPackage(responseData, activityPackage);
+                return;
+            }
+
+            packageHandler.sendNextPackage(responseData);
+
         } catch (UnsupportedEncodingException e) {
             sendNextPackage(activityPackage, "Failed to encode parameters", e);
         } catch (SocketTimeoutException e) {
@@ -106,15 +112,6 @@ private void sendInternal(ActivityPackage activityPackage, int queueSize) {
         }
     }
 
-    private void requestFinished(ResponseData responseData) throws JSONException {
-        if (responseData.jsonResponse == null) {
-            packageHandler.closeFirstPackage(responseData);
-            return;
-        }
-
-        packageHandler.sendNextPackage(responseData);
-    }
-
     // close current package because it failed
     private void closePackage(ActivityPackage activityPackage, String message, Throwable throwable) {
         final String packageMessage = activityPackage.getFailureMessage();
@@ -125,7 +122,7 @@ private void closePackage(ActivityPackage activityPackage, String message, Throw
         ResponseData responseData = ResponseData.buildResponseData(activityPackage);
         responseData.message = finalMessage;
 
-        packageHandler.closeFirstPackage(responseData);
+        packageHandler.closeFirstPackage(responseData, activityPackage);
     }
 
     // send next package because the current package failed
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
index 23ba5774e..6095e0135 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
@@ -3,12 +3,14 @@
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Looper;
+import android.os.SystemClock;
 
 import java.io.IOException;
 import java.io.UnsupportedEncodingException;
 import java.net.SocketTimeoutException;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.TimeUnit;
 
 import javax.net.ssl.HttpsURLConnection;
 
@@ -20,6 +22,7 @@ public class SdkClickHandler extends HandlerThread implements ISdkClickHandler {
     private ILogger logger;
     private boolean paused;
     private List<ActivityPackage> packageQueue;
+    private BackoffStrategy backoffStrategy;
 
     public SdkClickHandler(boolean startsSending) {
         super(Constants.LOGTAG, MIN_PRIORITY);
@@ -29,6 +32,7 @@ public SdkClickHandler(boolean startsSending) {
         init(startsSending);
         this.logger = AdjustFactory.getLogger();
         this.internalHandler = new Handler(getLooper());
+        this.backoffStrategy = AdjustFactory.getSdkClickBackoffStrategy();
     }
 
     @Override
@@ -76,6 +80,14 @@ public void run() {
 
                 ActivityPackage sdkClickPackage = packageQueue.get(0);
 
+                int retries = sdkClickPackage.getRetries();
+
+                if (retries > 0) {
+                    long waitTime = Util.getWaitingTime(retries, backoffStrategy);
+                    logger.verbose("Sleeping for %d seconds before retrying sdk_click for the %d time", TimeUnit.MILLISECONDS.toSeconds(waitTime), retries);
+                    SystemClock.sleep(waitTime);
+                }
+
                 sendSdkClickInternal(sdkClickPackage);
 
                 packageQueue.remove(0);
@@ -96,9 +108,8 @@ private void sendSdkClickInternal(ActivityPackage sdkClickPackage) {
 
             ResponseData responseData = Util.readHttpResponse(connection, sdkClickPackage);
 
-            // retry
             if (responseData.jsonResponse == null) {
-                sendSdkClick(sdkClickPackage);
+                retrySending(sdkClickPackage);
             }
         } catch (UnsupportedEncodingException e) {
             logErrorMessage(sdkClickPackage, "Sdk_click failed to encode parameters", e);
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index e8d853307..9bf8a168e 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -39,6 +39,7 @@
 import java.text.SimpleDateFormat;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Random;
 import java.util.UUID;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -519,4 +520,26 @@ public static String getReasonString(String message, Throwable throwable) {
             return String.format(Locale.US, "%s", message);
         }
     }
+
+    public static long getWaitingTime(int retries, BackoffStrategy backoffStrategy) {
+        if (retries < backoffStrategy.minRetries) {
+            return 0;
+        }
+        // start with base 0
+        int base = retries - backoffStrategy.minRetries;
+        // get the exponential Time from the base: 1, 2, 4, 8, 16, ... * times the multiplier
+        long exponentialTime = (((long) Math.pow(2, base)) * backoffStrategy.milliSecondMultiplier);
+        // limit the maximum allowed time to wait
+        long ceilingTime = Math.min(exponentialTime, backoffStrategy.maxWait);
+        Random random = new Random();
+        // add 1 to allow maximum value
+        int jitterFactorBase = random.nextInt(backoffStrategy.maxJitter - backoffStrategy.minJitter + 1);
+        int jitterFactorAdjusted = jitterFactorBase + backoffStrategy.minJitter;
+        double jitterFactor = jitterFactorAdjusted / 100.0;
+        // apply jitter factor
+        double waitingTime =  ceilingTime * jitterFactor;
+
+        // truncate to remove possible max value + 1
+        return (long)waitingTime;
+    }
 }

From 43f7604df54b42d0397117d831288d27b49f4235 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Fri, 1 Apr 2016 16:40:12 +0200
Subject: [PATCH 15/37] Replace custom inner Thread classes

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 228 ++++++------------
 .../java/com/adjust/sdk/IPackageHandler.java  |   2 +-
 .../java/com/adjust/sdk/IRequestHandler.java  |   2 +-
 .../java/com/adjust/sdk/PackageHandler.java   |  83 +++----
 .../java/com/adjust/sdk/RequestHandler.java   |  44 +---
 5 files changed, 116 insertions(+), 243 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 52856e427..5f784b102 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -45,7 +45,7 @@ public class ActivityHandler extends HandlerThread implements IActivityHandler {
     private static final String FOREGROUND_TIMER_NAME = "Foreground timer";
     private static final String BACKGROUND_TIMER_NAME = "Background timer";
 
-    private SessionHandler sessionHandler;
+    private Handler internalHandler;
     private IPackageHandler packageHandler;
     private ActivityState activityState;
     private ILogger logger;
@@ -96,7 +96,7 @@ private ActivityHandler(AdjustConfig adjustConfig) {
         start();
 
         logger = AdjustFactory.getLogger();
-        sessionHandler = new SessionHandler(getLooper(), this);
+        this.internalHandler = new Handler(getLooper());
         internalState = new InternalState();
 
         // read files to have sync values available
@@ -117,9 +117,12 @@ private ActivityHandler(AdjustConfig adjustConfig) {
 
         init(adjustConfig);
 
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.INIT;
-        sessionHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                initInternal();
+            }
+        });
     }
 
     @Override
@@ -169,9 +172,12 @@ public void onResume() {
 
     public void trackSubsessionStart() {
         logger.verbose("Subsession start");
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.START;
-        sessionHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                startInternal();
+            }
+        });
     }
 
     @Override
@@ -182,13 +188,16 @@ public void onPause() {
 
     public void trackSubsessionEnd() {
         logger.verbose("Subsession end");
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.END;
-        sessionHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                endInternal();
+            }
+        });
     }
 
     @Override
-    public void trackEvent(AdjustEvent event) {
+    public void trackEvent(final AdjustEvent event) {
         if (activityState == null) {
             logger.warn("Event triggered before first application launch.\n" +
                     "This will trigger the SDK start and an install without user interaction" +
@@ -196,10 +205,12 @@ public void trackEvent(AdjustEvent event) {
             trackSubsessionStart();
         }
 
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.EVENT;
-        message.obj = event;
-        sessionHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                trackEventInternal(event);
+            }
+        });
     }
 
     @Override
@@ -311,12 +322,13 @@ public boolean isEnabled() {
     }
 
     @Override
-    public void readOpenUrl(Uri url, long clickTime) {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.DEEP_LINK;
-        UrlClickTime urlClickTime = new UrlClickTime(url, clickTime);
-        message.obj = urlClickTime;
-        sessionHandler.sendMessage(message);
+    public void readOpenUrl(final Uri url, final long clickTime) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                readOpenUrlInternal(url, clickTime);
+            }
+        });
     }
 
     @Override
@@ -345,36 +357,43 @@ public void setAskingAttribution(boolean askingAttribution) {
     }
 
     @Override
-    public void sendReferrer(String referrer, long clickTime) {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.SEND_REFERRER;
-        ReferrerClickTime referrerClickTime = new ReferrerClickTime(referrer, clickTime);
-        message.obj = referrerClickTime;
-        sessionHandler.sendMessage(message);
+    public void sendReferrer(final String referrer, final long clickTime) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                sendReferrerInternal(referrer, clickTime);
+            }
+        });
     }
 
     @Override
-    public void launchEventResponseTasks(EventResponseData eventResponseData) {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.EVENT_TASKS;
-        message.obj = eventResponseData;
-        sessionHandler.sendMessage(message);
+    public void launchEventResponseTasks(final EventResponseData eventResponseData) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                launchEventResponseTasksInternal(eventResponseData);
+            }
+        });
     }
 
     @Override
-    public void launchSessionResponseTasks(SessionResponseData sessionResponseData) {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.SESSION_TASKS;
-        message.obj = sessionResponseData;
-        sessionHandler.sendMessage(message);
+    public void launchSessionResponseTasks(final SessionResponseData sessionResponseData) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                launchSessionResponseTasksInternal(sessionResponseData);
+            }
+        });
     }
 
     @Override
-    public void launchAttributionResponseTasks(AttributionResponseData attributionResponseData) {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.ATTRIBUTION_TASKS;
-        message.obj = attributionResponseData;
-        sessionHandler.sendMessage(message);
+    public void launchAttributionResponseTasks(final AttributionResponseData attributionResponseData) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                launchAttributionResponseTasksInternal(attributionResponseData);
+            }
+        });
     }
 
     public ActivityPackage getAttributionPackage() {
@@ -390,120 +409,31 @@ public InternalState getInternalState() {
         return internalState;
     }
 
-    private class UrlClickTime {
-        Uri url;
-        long clickTime;
-
-        UrlClickTime(Uri url, long clickTime) {
-            this.url = url;
-            this.clickTime = clickTime;
-        }
-    }
-
-    private class ReferrerClickTime {
-        String referrer;
-        long clickTime;
-
-        ReferrerClickTime(String referrer, long clickTime) {
-            this.referrer = referrer;
-            this.clickTime = clickTime;
-        }
-    }
-
     private void updateHandlersStatus() {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.UPDATE_HANDLERS_STATUS;
-        sessionHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                updateHandlersStatusInternal();
+            }
+        });
     }
 
     private void foregroundTimerFired() {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.FOREGROUND_TIMER_FIRED;
-        sessionHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                foregroundTimerFiredInternal();
+            }
+        });
     }
 
     private void backgroundTimerFired() {
-        Message message = Message.obtain();
-        message.arg1 = SessionHandler.BACKGROUND_TIMER_FIRED;
-        sessionHandler.sendMessage(message);
-    }
-
-    private static final class SessionHandler extends Handler {
-        private static final int BASE_ADDRESS = 72630;
-        private static final int INIT = BASE_ADDRESS + 1;
-        private static final int START = BASE_ADDRESS + 2;
-        private static final int END = BASE_ADDRESS + 3;
-        private static final int EVENT = BASE_ADDRESS + 4;
-        private static final int EVENT_TASKS = BASE_ADDRESS + 5;
-        private static final int DEEP_LINK = BASE_ADDRESS + 6;
-        private static final int SEND_REFERRER = BASE_ADDRESS + 7;
-        private static final int UPDATE_HANDLERS_STATUS = BASE_ADDRESS + 8;
-        private static final int FOREGROUND_TIMER_FIRED = BASE_ADDRESS + 9;
-        private static final int SESSION_TASKS = BASE_ADDRESS + 10;
-        private static final int ATTRIBUTION_TASKS = BASE_ADDRESS + 11;
-        private static final int BACKGROUND_TIMER_FIRED = BASE_ADDRESS + 12;
-
-        private final WeakReference<ActivityHandler> sessionHandlerReference;
-
-        protected SessionHandler(Looper looper, ActivityHandler sessionHandler) {
-            super(looper);
-            this.sessionHandlerReference = new WeakReference<ActivityHandler>(sessionHandler);
-        }
-
-        @Override
-        public void handleMessage(Message message) {
-            super.handleMessage(message);
-
-            ActivityHandler sessionHandler = sessionHandlerReference.get();
-            if (sessionHandler == null) {
-                return;
-            }
-
-            switch (message.arg1) {
-                case INIT:
-                    sessionHandler.initInternal();
-                    break;
-                case START:
-                    sessionHandler.startInternal();
-                    break;
-                case END:
-                    sessionHandler.endInternal();
-                    break;
-                case EVENT:
-                    AdjustEvent event = (AdjustEvent) message.obj;
-                    sessionHandler.trackEventInternal(event);
-                    break;
-                case EVENT_TASKS:
-                    EventResponseData eventResponseData = (EventResponseData) message.obj;
-                    sessionHandler.launchEventResponseTasksInternal(eventResponseData);
-                    break;
-                case DEEP_LINK:
-                    UrlClickTime urlClickTime = (UrlClickTime) message.obj;
-                    sessionHandler.readOpenUrlInternal(urlClickTime.url, urlClickTime.clickTime);
-                    break;
-                case SEND_REFERRER:
-                    ReferrerClickTime referrerClickTime = (ReferrerClickTime) message.obj;
-                    sessionHandler.sendReferrerInternal(referrerClickTime.referrer, referrerClickTime.clickTime);
-                    break;
-                case UPDATE_HANDLERS_STATUS:
-                    sessionHandler.updateHandlersStatusInternal();
-                    break;
-                case FOREGROUND_TIMER_FIRED:
-                    sessionHandler.foregroundTimerFiredInternal();
-                    break;
-                case SESSION_TASKS:
-                    SessionResponseData sessionResponseData = (SessionResponseData) message.obj;
-                    sessionHandler.launchSessionResponseTasksInternal(sessionResponseData);
-                    break;
-                case ATTRIBUTION_TASKS:
-                    AttributionResponseData attributionResponseData = (AttributionResponseData) message.obj;
-                    sessionHandler.launchAttributionResponseTasksInternal(attributionResponseData);
-                    break;
-                case BACKGROUND_TIMER_FIRED:
-                    sessionHandler.backgroundTimerFiredInternal();
-                    break;
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                backgroundTimerFiredInternal();
             }
-        }
+        });
     }
 
     private void initInternal() {
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
index 757814b78..149e07240 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IPackageHandler.java
@@ -5,7 +5,7 @@
 public interface IPackageHandler {
     public void init(IActivityHandler activityHandler, Context context, boolean startsSending);
 
-    public void addPackage(ActivityPackage pack);
+    public void addPackage(ActivityPackage activityPackage);
 
     public void sendFirstPackage();
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java
index 705864578..4a5611a43 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/IRequestHandler.java
@@ -3,5 +3,5 @@
 public interface IRequestHandler {
     public void init(IPackageHandler packageHandler);
 
-    public void sendPackage(ActivityPackage pack, int queueSize);
+    public void sendPackage(ActivityPackage activityPackage, int queueSize);
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index 1a4030bca..e7a1c454e 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -29,7 +29,7 @@ public class PackageHandler extends HandlerThread implements IPackageHandler {
     private static final String PACKAGE_QUEUE_FILENAME = "AdjustIoPackageQueue";
     private static final String PACKAGE_QUEUE_NAME = "Package queue";
 
-    private final InternalHandler internalHandler;
+    private Handler internalHandler;
     private IRequestHandler requestHandler;
     private IActivityHandler activityHandler;
     private List<ActivityPackage> packageQueue;
@@ -45,15 +45,18 @@ public PackageHandler(IActivityHandler activityHandler,
         super(Constants.LOGTAG, MIN_PRIORITY);
         setDaemon(true);
         start();
-        this.internalHandler = new InternalHandler(getLooper(), this);
+        this.internalHandler = new Handler(getLooper());
         this.logger = AdjustFactory.getLogger();
         this.backoffStrategy = AdjustFactory.getPackageHandlerBackoffStrategy();
 
         init(activityHandler, context, startsSending);
 
-        Message message = Message.obtain();
-        message.arg1 = InternalHandler.INIT;
-        internalHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                initInternal();
+            }
+        });
     }
 
     @Override
@@ -65,28 +68,36 @@ public void init(IActivityHandler activityHandler, Context context, boolean star
 
     // add a package to the queue
     @Override
-    public void addPackage(ActivityPackage pack) {
-        Message message = Message.obtain();
-        message.arg1 = InternalHandler.ADD;
-        message.obj = pack;
-        internalHandler.sendMessage(message);
+    public void addPackage(final ActivityPackage activityPackage) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                addInternal(activityPackage);
+            }
+        });
     }
 
     // try to send the oldest package
     @Override
     public void sendFirstPackage() {
-        Message message = Message.obtain();
-        message.arg1 = InternalHandler.SEND_FIRST;
-        internalHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                sendFirstInternal();
+            }
+        });
     }
 
     // remove oldest package and try to send the next one
     // (after success or possibly permanent failure)
     @Override
     public void sendNextPackage(ResponseData responseData) {
-        Message message = Message.obtain();
-        message.arg1 = InternalHandler.SEND_NEXT;
-        internalHandler.sendMessage(message);
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                sendNextInternal();
+            }
+        });
 
         activityHandler.finishedTrackingActivity(responseData);
     }
@@ -127,46 +138,6 @@ public void resumeSending() {
         paused = false;
     }
 
-    private static final class InternalHandler extends Handler {
-        private static final int INIT = 1;
-        private static final int ADD = 2;
-        private static final int SEND_NEXT = 3;
-        private static final int SEND_FIRST = 4;
-
-        private final WeakReference<PackageHandler> packageHandlerReference;
-
-        protected InternalHandler(Looper looper, PackageHandler packageHandler) {
-            super(looper);
-            this.packageHandlerReference = new WeakReference<PackageHandler>(packageHandler);
-        }
-
-        @Override
-        public void handleMessage(Message message) {
-            super.handleMessage(message);
-
-            PackageHandler packageHandler = packageHandlerReference.get();
-            if (packageHandler == null) {
-                return;
-            }
-
-            switch (message.arg1) {
-                case INIT:
-                    packageHandler.initInternal();
-                    break;
-                case ADD:
-                    ActivityPackage activityPackage = (ActivityPackage) message.obj;
-                    packageHandler.addInternal(activityPackage);
-                    break;
-                case SEND_FIRST:
-                    packageHandler.sendFirstInternal();
-                    break;
-                case SEND_NEXT:
-                    packageHandler.sendNextInternal();
-                    break;
-            }
-        }
-    }
-
     // internal methods run in dedicated queue thread
 
     private void initInternal() {
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
index c06ab44ea..bf9eb3dfc 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/RequestHandler.java
@@ -25,7 +25,7 @@
 import javax.net.ssl.HttpsURLConnection;
 
 public class RequestHandler extends HandlerThread implements IRequestHandler {
-    private InternalHandler internalHandler;
+    private Handler internalHandler;
     private IPackageHandler packageHandler;
     private ILogger logger;
 
@@ -35,7 +35,7 @@ public RequestHandler(IPackageHandler packageHandler) {
         start();
 
         this.logger = AdjustFactory.getLogger();
-        this.internalHandler = new InternalHandler(getLooper(), this);
+        this.internalHandler = new Handler(getLooper());
         init(packageHandler);
     }
 
@@ -45,41 +45,13 @@ public void init(IPackageHandler packageHandler) {
     }
 
     @Override
-    public void sendPackage(ActivityPackage pack, int queueSize) {
-        Message message = Message.obtain();
-        message.arg1 = InternalHandler.SEND;
-        message.arg2 = queueSize;
-        message.obj = pack;
-        internalHandler.sendMessage(message);
-    }
-
-    private static final class InternalHandler extends Handler {
-        private static final int SEND = 72400;
-
-        private final WeakReference<RequestHandler> requestHandlerReference;
-
-        protected InternalHandler(Looper looper, RequestHandler requestHandler) {
-            super(looper);
-            this.requestHandlerReference = new WeakReference<RequestHandler>(requestHandler);
-        }
-
-        @Override
-        public void handleMessage(Message message) {
-            super.handleMessage(message);
-
-            RequestHandler requestHandler = requestHandlerReference.get();
-            if (requestHandler == null) {
-                return;
+    public void sendPackage(final ActivityPackage activityPackage, final int queueSize) {
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                sendInternal(activityPackage, queueSize);
             }
-
-            switch (message.arg1) {
-                case SEND:
-                    ActivityPackage activityPackage = (ActivityPackage) message.obj;
-                    int queueSize = message.arg2;
-                    requestHandler.sendInternal(activityPackage, queueSize);
-                    break;
-            }
-        }
+        });
     }
 
     private void sendInternal(ActivityPackage activityPackage, int queueSize) {

From 37ea55626442227696ff6e748ce6457c7b7f4b34 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 4 Apr 2016 15:49:05 +0200
Subject: [PATCH 16/37] Send_at in attribution request

---
 .../src/main/java/com/adjust/sdk/ActivityHandler.java       | 6 +++++-
 .../src/main/java/com/adjust/sdk/AttributionHandler.java    | 5 +++++
 .../src/main/java/com/adjust/sdk/SdkClickHandler.java       | 2 +-
 3 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 5f784b102..27ff5140d 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -200,7 +200,7 @@ public void run() {
     public void trackEvent(final AdjustEvent event) {
         if (activityState == null) {
             logger.warn("Event triggered before first application launch.\n" +
-                    "This will trigger the SDK start and an install without user interaction" +
+                    "This will trigger the SDK start and an install without user interaction.\n" +
                     "Please check https://github.com/adjust/android_sdk#can-i-trigger-an-event-at-application-launch for more information.");
             trackSubsessionStart();
         }
@@ -257,14 +257,17 @@ public void setEnabled(boolean enabled) {
     private void updateStatus(boolean pausingState, String pausingMessage,
                               String remainsPausedMessage, String unPausingMessage)
     {
+        // it is changing from an active state to a pause state
         if (pausingState) {
             logger.info(pausingMessage);
             updateHandlersStatus();
             return;
         }
 
+        // it is remaining in a pause state
         if (paused()) {
             logger.info(remainsPausedMessage);
+        // it is changing from a pause state to an active state
         } else {
             logger.info(unPausingMessage);
             updateHandlersStatus();
@@ -315,6 +318,7 @@ public void setOfflineMode(boolean offline) {
     @Override
     public boolean isEnabled() {
         if (activityState != null) {
+            logger.warn("Returning enabled value before starting the sdk");
             return activityState.enabled;
         } else {
             return internalState.isEnabled();
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
index d8b880f3f..1a9832b40 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
@@ -182,6 +182,11 @@ private Uri buildUri(String path, Map<String, String> parameters) {
             uriBuilder.appendQueryParameter(entry.getKey(), entry.getValue());
         }
 
+        long now = System.currentTimeMillis();
+        String dateString = Util.dateFormat(now);
+
+        uriBuilder.appendQueryParameter("sent_at", dateString);
+
         return uriBuilder.build();
     }
 }
\ No newline at end of file
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
index 6095e0135..40422f9a7 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
@@ -18,7 +18,7 @@
  * Created by pfms on 31/03/16.
  */
 public class SdkClickHandler extends HandlerThread implements ISdkClickHandler {
-    private final Handler internalHandler;
+    private Handler internalHandler;
     private ILogger logger;
     private boolean paused;
     private List<ActivityPackage> packageQueue;

From 0354ad35198219841a60947c8c2cfb9191d6e691 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Wed, 6 Apr 2016 14:13:17 +0200
Subject: [PATCH 17/37] Refactor activity timers

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 31 +++++++++----------
 1 file changed, 15 insertions(+), 16 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 27ff5140d..245e0ff57 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -167,6 +167,11 @@ public static ActivityHandler getInstance(AdjustConfig adjustConfig) {
     @Override
     public void onResume() {
         internalState.background = false;
+
+        stopBackgroundTimer();
+
+        startForegroundTimer();
+
         trackSubsessionStart();
     }
 
@@ -183,6 +188,11 @@ public void run() {
     @Override
     public void onPause() {
         internalState.background = true;
+
+        stopForegroundTimer();
+
+        startBackgroundTimer();
+
         trackSubsessionEnd();
     }
 
@@ -507,15 +517,11 @@ private void startInternal() {
             return;
         }
 
-        stopBackgroundTimer();
-
         updateHandlersStatusInternal();
 
         processSession();
 
         checkAttributionState();
-
-        startForegroundTimer();
     }
 
     private void processSession() {
@@ -585,17 +591,9 @@ private void checkAttributionState() {
     }
 
     private void endInternal() {
-        // stop foreground timer in any situation
-        stopForegroundTimer();
-
-        // if it's offline, disabled
-        // or it can't send in the background
-        // -> pause sdk
-        if (paused() || !adjustConfig.sendInBackground) {
+        // pause sending if it's not allowed to send
+        if (!toSend()) {
             pauseSending();
-        } else {
-        // it it doesn't pause the sdk, it starts the background timer
-            startBackgroundTimer();
         }
 
         if (updateActivityState(System.currentTimeMillis())) {
@@ -1000,8 +998,8 @@ private void foregroundTimerFiredInternal() {
     }
 
     private void startBackgroundTimer() {
-        // don't start the timer if it's disabled or offline
-        if (paused()) {
+        // check if it can send in the background
+        if (!toSend()) {
             return;
         }
 
@@ -1009,6 +1007,7 @@ private void startBackgroundTimer() {
         if (backgroundTimer.getFireIn() > 0) {
             return;
         }
+
         backgroundTimer.startIn(BACKGROUND_TIMER_INTERVAL);
     }
 

From 2c09f2ce83b68ae5c7c470d2828396158b8ca181 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Wed, 6 Apr 2016 15:42:56 +0200
Subject: [PATCH 18/37] Send parameter if buffering is enabled

---
 Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
index 97ca78111..538405209 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageBuilder.java
@@ -173,6 +173,7 @@ private void injectConfig(Map<String, String> parameters) {
         addString(parameters, "gps_adid", playAdId);
         Boolean isTrackingEnabled = Util.isPlayTrackingEnabled(adjustConfig.context);
         addBoolean(parameters, "tracking_enabled", isTrackingEnabled);
+        addBoolean(parameters, "event_buffering_enabled", adjustConfig.eventBufferingEnabled);
     }
 
     private void injectActivityState(Map<String, String> parameters) {

From 9f01faa96747cbc936bbaf56258350559f1040ed Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Wed, 6 Apr 2016 15:43:47 +0200
Subject: [PATCH 19/37] Refactor Boolean

---
 Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java
index 36d9c3f20..618a28835 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Reflection.java
@@ -34,7 +34,9 @@ public static Boolean isPlayTrackingEnabled(Context context) {
 
             Boolean isLimitedTrackingEnabled = (Boolean) invokeInstanceMethod(AdvertisingInfoObject, "isLimitAdTrackingEnabled", null);
 
-            return !isLimitedTrackingEnabled;
+            Boolean isPlayTrackingEnabled = (isLimitedTrackingEnabled == null ? null : !isLimitedTrackingEnabled);
+
+            return isPlayTrackingEnabled;
         } catch (Throwable t) {
             return null;
         }

From fea4c1fca6bec9379b5f6314896762e8387d2607 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Wed, 6 Apr 2016 16:22:36 +0200
Subject: [PATCH 20/37] Update handler status and send

---
 .../src/main/java/com/adjust/sdk/ActivityHandler.java    | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 245e0ff57..5db752c97 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -270,7 +270,7 @@ private void updateStatus(boolean pausingState, String pausingMessage,
         // it is changing from an active state to a pause state
         if (pausingState) {
             logger.info(pausingMessage);
-            updateHandlersStatus();
+            updateHandlersStatusAndSend();
             return;
         }
 
@@ -280,7 +280,7 @@ private void updateStatus(boolean pausingState, String pausingMessage,
         // it is changing from a pause state to an active state
         } else {
             logger.info(unPausingMessage);
-            updateHandlersStatus();
+            updateHandlersStatusAndSend();
         }
     }
 
@@ -423,11 +423,14 @@ public InternalState getInternalState() {
         return internalState;
     }
 
-    private void updateHandlersStatus() {
+    private void updateHandlersStatusAndSend() {
         internalHandler.post(new Runnable() {
             @Override
             public void run() {
                 updateHandlersStatusInternal();
+                if (!adjustConfig.eventBufferingEnabled) {
+                    packageHandler.sendFirstPackage();
+                }
             }
         });
     }

From fa08a6177173585d8842e30d9cdf824bc514bf55 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 11 Apr 2016 10:58:00 +0200
Subject: [PATCH 21/37] Reorder timer init

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 82 ++++++++++---------
 1 file changed, 44 insertions(+), 38 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 5db752c97..63854819e 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -17,10 +17,7 @@
 import android.net.Uri;
 import android.os.Handler;
 import android.os.HandlerThread;
-import android.os.Looper;
-import android.os.Message;
 
-import java.lang.ref.WeakReference;
 import java.util.LinkedHashMap;
 import java.util.List;
 import java.util.Map;
@@ -95,7 +92,28 @@ private ActivityHandler(AdjustConfig adjustConfig) {
         setDaemon(true);
         start();
 
+        init(adjustConfig);
+
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                initInternal();
+            }
+        });
+    }
+
+    @Override
+    public void init(AdjustConfig adjustConfig) {
+        this.adjustConfig = adjustConfig;
+
         logger = AdjustFactory.getLogger();
+
+        if (AdjustConfig.ENVIRONMENT_PRODUCTION.equals(adjustConfig.environment)) {
+            logger.setLogLevel(LogLevel.ASSERT);
+        } else {
+            logger.setLogLevel(adjustConfig.logLevel);
+        }
+
         this.internalHandler = new Handler(getLooper());
         internalState = new InternalState();
 
@@ -114,20 +132,27 @@ private ActivityHandler(AdjustConfig adjustConfig) {
         // in the background by default
         internalState.background = true;
 
+        // get timer values
+        FOREGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
+        FOREGROUND_TIMER_START = AdjustFactory.getTimerStart();
+        BACKGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
 
-        init(adjustConfig);
-
-        internalHandler.post(new Runnable() {
+        // create foreground timer
+        foregroundTimer = new TimerCycle(new Runnable() {
             @Override
             public void run() {
-                initInternal();
+                foregroundTimerFired();
             }
-        });
-    }
+        }, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL, FOREGROUND_TIMER_NAME);
 
-    @Override
-    public void init(AdjustConfig adjustConfig) {
-        this.adjustConfig = adjustConfig;
+        // create background timer
+        scheduler = Executors.newSingleThreadScheduledExecutor();
+        backgroundTimer = new TimerOnce(scheduler, new Runnable() {
+            @Override
+            public void run() {
+                backgroundTimerFired();
+            }
+        }, BACKGROUND_TIMER_NAME);
     }
 
     public static ActivityHandler getInstance(AdjustConfig adjustConfig) {
@@ -328,7 +353,6 @@ public void setOfflineMode(boolean offline) {
     @Override
     public boolean isEnabled() {
         if (activityState != null) {
-            logger.warn("Returning enabled value before starting the sdk");
             return activityState.enabled;
         } else {
             return internalState.isEnabled();
@@ -454,20 +478,11 @@ public void run() {
     }
 
     private void initInternal() {
-        FOREGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
-        FOREGROUND_TIMER_START = AdjustFactory.getTimerStart();
-        BACKGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
         SESSION_INTERVAL = AdjustFactory.getSessionInterval();
         SUBSESSION_INTERVAL = AdjustFactory.getSubsessionInterval();
 
         deviceInfo = new DeviceInfo(adjustConfig.context, adjustConfig.sdkPrefix);
 
-        if (AdjustConfig.ENVIRONMENT_PRODUCTION.equals(adjustConfig.environment)) {
-            logger.setLogLevel(LogLevel.ASSERT);
-        } else {
-            logger.setLogLevel(adjustConfig.logLevel);
-        }
-
         if (adjustConfig.eventBufferingEnabled) {
             logger.info("Event buffering is enabled");
         }
@@ -475,8 +490,14 @@ private void initInternal() {
         String playAdId = Util.getPlayAdId(adjustConfig.context);
         if (playAdId == null) {
             logger.warn("Unable to get Google Play Services Advertising ID at start time");
+            if (deviceInfo.macSha1 == null &&
+                    deviceInfo.macShortMd5 == null &&
+                    deviceInfo.androidId == null)
+            {
+                logger.error("Unable to get any device id's. Please check if Proguard is correctly set with Adjust SDK");
+            }
         } else {
-            logger.debug("Google Play Services Advertising ID read correctly at start time");
+            logger.info("Google Play Services Advertising ID read correctly at start time");
         }
 
         if (adjustConfig.defaultTracker != null) {
@@ -496,21 +517,6 @@ private void initInternal() {
                 adjustConfig.hasAttributionChangedListener());
 
         sdkClickHandler = AdjustFactory.getSdkClickHandler(toSend());
-
-        foregroundTimer = new TimerCycle(new Runnable() {
-            @Override
-            public void run() {
-                foregroundTimerFired();
-            }
-        }, FOREGROUND_TIMER_START, FOREGROUND_TIMER_INTERVAL, FOREGROUND_TIMER_NAME);
-
-        scheduler = Executors.newSingleThreadScheduledExecutor();
-        backgroundTimer = new TimerOnce(scheduler, new Runnable() {
-            @Override
-            public void run() {
-                backgroundTimerFired();
-            }
-        }, BACKGROUND_TIMER_NAME);
     }
 
     private void startInternal() {

From 40cf37cff36a4b8e493867e074b925f59264c19f Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 11 Apr 2016 10:58:23 +0200
Subject: [PATCH 22/37] Update handler status and resume

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 20 ++++++++++---------
 .../java/com/adjust/sdk/AdjustFactory.java    |  2 +-
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 63854819e..ab6499fa7 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -451,10 +451,7 @@ private void updateHandlersStatusAndSend() {
         internalHandler.post(new Runnable() {
             @Override
             public void run() {
-                updateHandlersStatusInternal();
-                if (!adjustConfig.eventBufferingEnabled) {
-                    packageHandler.sendFirstPackage();
-                }
+                updateHandlersStatusAndSendInternal();
             }
         });
     }
@@ -526,7 +523,7 @@ private void startInternal() {
             return;
         }
 
-        updateHandlersStatusInternal();
+        updateHandlersStatusAndSendInternal();
 
         processSession();
 
@@ -925,11 +922,16 @@ private boolean trySetAttribution(AdjustAttribution queryStringAttribution,
         return false;
     }
 
-    private void updateHandlersStatusInternal() {
-        if (toSend()) {
-            resumeSending();
-        } else {
+    private void updateHandlersStatusAndSendInternal() {
+        if (!toSend()) {
             pauseSending();
+            return;
+        }
+
+        resumeSending();
+
+        if (!adjustConfig.eventBufferingEnabled) {
+            packageHandler.sendFirstPackage();
         }
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
index b72b723f9..aaffeb235 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AdjustFactory.java
@@ -67,7 +67,7 @@ public static long getTimerInterval() {
 
     public static long getTimerStart() {
         if (timerStart == -1) {
-            return 0;
+            return Constants.ONE_MINUTE;
         }
         return timerStart;
     }

From 6ff72237250549c91f5d7692e13282e25eb90e53 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 18 Apr 2016 16:23:06 +0200
Subject: [PATCH 23/37] Decimal format for seconds display

---
 .../src/main/java/com/adjust/sdk/AttributionHandler.java     | 5 ++++-
 .../adjust/src/main/java/com/adjust/sdk/PackageHandler.java  | 4 ++--
 Adjust/adjust/src/main/java/com/adjust/sdk/Util.java         | 2 ++
 3 files changed, 8 insertions(+), 3 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
index 1a9832b40..fde9bc26d 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/AttributionHandler.java
@@ -101,7 +101,10 @@ private void getAttribution(long delayInMilliseconds) {
         }
 
         if (delayInMilliseconds != 0) {
-            logger.debug("Waiting to query attribution in %d milliseconds", delayInMilliseconds);
+            double waitTimeSeconds = delayInMilliseconds / 1000.0;
+            String secondsString = Util.SecondsDisplayFormat.format(waitTimeSeconds);
+
+            logger.debug("Waiting to query attribution in %s seconds", secondsString);
         }
 
         // set the new time the timer will fire in
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index e7a1c454e..c7c9e2250 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -115,10 +115,10 @@ public void closeFirstPackage(ResponseData responseData, ActivityPackage activit
 
             long waitTime = Util.getWaitingTime(retries, backoffStrategy);
 
-            DecimalFormat df = new DecimalFormat("#.#");
             double waitTimeSeconds = waitTime / 1000.0;
+            String secondsString = Util.SecondsDisplayFormat.format(waitTimeSeconds);
 
-            logger.verbose("Sleeping for %s seconds before retrying the %d time", df.format(waitTimeSeconds), retries);
+            logger.verbose("Sleeping for %s seconds before retrying the %d time", secondsString, retries);
             SystemClock.sleep(waitTime);
         }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index 9bf8a168e..7178a9ffd 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -36,6 +36,7 @@
 import java.net.URL;
 import java.net.URLEncoder;
 import java.security.MessageDigest;
+import java.text.DecimalFormat;
 import java.text.SimpleDateFormat;
 import java.util.Locale;
 import java.util.Map;
@@ -58,6 +59,7 @@ public class Util {
     private static SimpleDateFormat dateFormat;
     private static final String DATE_FORMAT = "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'Z";
     private static final String fieldReadErrorMessage = "Unable to read '%s' field in migration device with message (%s)";
+    public static final DecimalFormat SecondsDisplayFormat = new DecimalFormat("0.0");
 
     private static ILogger getLogger() {
         return AdjustFactory.getLogger();

From 9e664819a7f33080fc3310887f4182c7ce281559 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 26 Apr 2016 10:30:33 -0700
Subject: [PATCH 24/37] Refac init

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 29 ++++++++++---------
 1 file changed, 15 insertions(+), 14 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index ab6499fa7..e16e4a371 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -94,20 +94,8 @@ private ActivityHandler(AdjustConfig adjustConfig) {
 
         init(adjustConfig);
 
-        internalHandler.post(new Runnable() {
-            @Override
-            public void run() {
-                initInternal();
-            }
-        });
-    }
-
-    @Override
-    public void init(AdjustConfig adjustConfig) {
-        this.adjustConfig = adjustConfig;
-
+        // init logger to be available everywhere
         logger = AdjustFactory.getLogger();
-
         if (AdjustConfig.ENVIRONMENT_PRODUCTION.equals(adjustConfig.environment)) {
             logger.setLogLevel(LogLevel.ASSERT);
         } else {
@@ -132,12 +120,20 @@ public void init(AdjustConfig adjustConfig) {
         // in the background by default
         internalState.background = true;
 
+        internalHandler.post(new Runnable() {
+            @Override
+            public void run() {
+                initInternal();
+            }
+        });
+
         // get timer values
         FOREGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
         FOREGROUND_TIMER_START = AdjustFactory.getTimerStart();
         BACKGROUND_TIMER_INTERVAL = AdjustFactory.getTimerInterval();
 
-        // create foreground timer
+        // initialize timers to be available in onResume/onPause
+        // after initInternal so that the handlers are initialized
         foregroundTimer = new TimerCycle(new Runnable() {
             @Override
             public void run() {
@@ -155,6 +151,11 @@ public void run() {
         }, BACKGROUND_TIMER_NAME);
     }
 
+    @Override
+    public void init(AdjustConfig adjustConfig) {
+        this.adjustConfig = adjustConfig;
+    }
+
     public static ActivityHandler getInstance(AdjustConfig adjustConfig) {
         if (adjustConfig == null) {
             AdjustFactory.getLogger().error("AdjustConfig missing");

From 2358e4e7adffdbdd2101b8ae31812b281d5796c3 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 26 Apr 2016 10:30:55 -0700
Subject: [PATCH 25/37] Move state check of track event

---
 .../main/java/com/adjust/sdk/ActivityHandler.java   | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index e16e4a371..c51b89a4f 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -234,16 +234,15 @@ public void run() {
 
     @Override
     public void trackEvent(final AdjustEvent event) {
-        if (activityState == null) {
-            logger.warn("Event triggered before first application launch.\n" +
-                    "This will trigger the SDK start and an install without user interaction.\n" +
-                    "Please check https://github.com/adjust/android_sdk#can-i-trigger-an-event-at-application-launch for more information.");
-            trackSubsessionStart();
-        }
-
         internalHandler.post(new Runnable() {
             @Override
             public void run() {
+                if (activityState == null) {
+                    logger.warn("Event triggered before first application launch.\n" +
+                            "This will trigger the SDK start and an install without user interaction.\n" +
+                            "Please check https://github.com/adjust/android_sdk#can-i-trigger-an-event-at-application-launch for more information.");
+                    startInternal();
+                }
                 trackEventInternal(event);
             }
         });

From c62e9a8e0716d65bb03a98322131305388b8dd0f Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 26 Apr 2016 10:33:45 -0700
Subject: [PATCH 26/37] Log and comment refac

---
 .../src/main/java/com/adjust/sdk/ActivityHandler.java |  6 +++++-
 .../src/main/java/com/adjust/sdk/PackageHandler.java  |  5 +++--
 .../src/main/java/com/adjust/sdk/SdkClickHandler.java | 10 +++++++---
 .../src/main/java/com/adjust/sdk/TimerCycle.java      | 11 +++++++++--
 .../src/main/java/com/adjust/sdk/TimerOnce.java       |  4 +++-
 Adjust/adjust/src/main/java/com/adjust/sdk/Util.java  |  2 --
 6 files changed, 27 insertions(+), 11 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index c51b89a4f..27f67bb94 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -270,6 +270,7 @@ public void setEnabled(boolean enabled) {
             return;
         }
 
+        // save new enabled state in internal state
         internalState.enabled = enabled;
 
         if (activityState == null) {
@@ -280,6 +281,7 @@ public void setEnabled(boolean enabled) {
             return;
         }
 
+        // save new enabled state in activity state
         activityState.enabled = enabled;
         writeActivityState();
 
@@ -923,6 +925,7 @@ private boolean trySetAttribution(AdjustAttribution queryStringAttribution,
     }
 
     private void updateHandlersStatusAndSendInternal() {
+        // check if it should stop sending
         if (!toSend()) {
             pauseSending();
             return;
@@ -930,6 +933,7 @@ private void updateHandlersStatusAndSendInternal() {
 
         resumeSending();
 
+        // try to send
         if (!adjustConfig.eventBufferingEnabled) {
             packageHandler.sendFirstPackage();
         }
@@ -1072,7 +1076,7 @@ private boolean checkEvent(AdjustEvent event) {
 
     private boolean checkActivityState(ActivityState activityState) {
         if (activityState == null) {
-            logger.error("Missing activity state.");
+            logger.error("Missing activity state");
             return false;
         }
         return true;
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
index c7c9e2250..a7e776dae 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/PackageHandler.java
@@ -105,8 +105,6 @@ public void run() {
     // close the package to retry in the future (after temporary failure)
     @Override
     public void closeFirstPackage(ResponseData responseData, ActivityPackage activityPackage) {
-        logger.verbose("Package handler can send");
-
         responseData.willRetry = true;
         activityHandler.finishedTrackingActivity(responseData);
 
@@ -122,7 +120,10 @@ public void closeFirstPackage(ResponseData responseData, ActivityPackage activit
             SystemClock.sleep(waitTime);
         }
 
+        logger.verbose("Package handler can send");
         isSending.set(false);
+
+        // Try to send the same package after sleeping
         sendFirstPackage();
     }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
index 40422f9a7..8cf53dd2d 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/SdkClickHandler.java
@@ -83,9 +83,13 @@ public void run() {
                 int retries = sdkClickPackage.getRetries();
 
                 if (retries > 0) {
-                    long waitTime = Util.getWaitingTime(retries, backoffStrategy);
-                    logger.verbose("Sleeping for %d seconds before retrying sdk_click for the %d time", TimeUnit.MILLISECONDS.toSeconds(waitTime), retries);
-                    SystemClock.sleep(waitTime);
+                    long waitTimeMilliSeconds = Util.getWaitingTime(retries, backoffStrategy);
+
+                    double waitTimeSeconds = waitTimeMilliSeconds / 1000.0;
+                    String secondsString = Util.SecondsDisplayFormat.format(waitTimeSeconds);
+
+                    logger.verbose("Sleeping for %s seconds before retrying sdk_click for the %d time", secondsString, retries);
+                    SystemClock.sleep(waitTimeMilliSeconds);
                 }
 
                 sendSdkClickInternal(sdkClickPackage);
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java
index 387d0189c..6e302b19e 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerCycle.java
@@ -15,6 +15,7 @@ public class TimerCycle {
     private Runnable command;
     private long initialDelay;
     private long cycleDelay;
+    private String cycleDelaySeconds;
     private boolean isPaused;
     private ILogger logger;
 
@@ -27,6 +28,8 @@ public TimerCycle(Runnable command, long initialDelay, long cycleDelay, String n
         this.cycleDelay = cycleDelay;
         this.isPaused = true;
         this.logger = AdjustFactory.getLogger();
+
+        this.cycleDelaySeconds = Util.SecondsDisplayFormat.format(cycleDelay / 1000.0);
     }
 
     public void start() {
@@ -35,7 +38,9 @@ public void start() {
             return;
         }
 
-        logger.verbose("%s starting in %d seconds and cycle every %d seconds", name, TimeUnit.MILLISECONDS.toSeconds(initialDelay), TimeUnit.MILLISECONDS.toSeconds(cycleDelay));
+        String initialDelaySeconds = Util.SecondsDisplayFormat.format(initialDelay / 1000.0);
+
+        logger.verbose("%s starting in %s seconds and cycle every %s seconds", name, initialDelaySeconds, cycleDelaySeconds);
 
         waitingTask = scheduler.scheduleWithFixedDelay(new Runnable() {
             @Override
@@ -61,7 +66,9 @@ public void suspend() {
         waitingTask.cancel(false);
         waitingTask = null;
 
-        logger.verbose("%s suspended with %d seconds left", name, TimeUnit.MILLISECONDS.toSeconds(initialDelay));
+        String initialDelaySeconds = Util.SecondsDisplayFormat.format(initialDelay / 1000.0);
+
+        logger.verbose("%s suspended with %s seconds left", name, initialDelaySeconds);
 
         isPaused = true;
     }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
index d34ed38dd..7fee60415 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/TimerOnce.java
@@ -25,7 +25,9 @@ public void startIn(long fireIn) {
         // cancel previous
         cancel(false);
 
-        logger.verbose("%s starting. Launching in %d seconds", name, TimeUnit.MILLISECONDS.toSeconds(fireIn));
+        String fireInSeconds = Util.SecondsDisplayFormat.format(fireIn / 1000.0);
+
+        logger.verbose("%s starting. Launching in %s seconds", name, fireInSeconds);
 
         waitingTask = scheduler.schedule(new Runnable() {
             @Override
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index 7178a9ffd..b1726a155 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -540,8 +540,6 @@ public static long getWaitingTime(int retries, BackoffStrategy backoffStrategy)
         double jitterFactor = jitterFactorAdjusted / 100.0;
         // apply jitter factor
         double waitingTime =  ceilingTime * jitterFactor;
-
-        // truncate to remove possible max value + 1
         return (long)waitingTime;
     }
 }

From 0b5b51a6e75fd3a93781b336a3a9ca1bca6d04ec Mon Sep 17 00:00:00 2001
From: Pedro Filipe <pedro@adeven.com>
Date: Fri, 29 Apr 2016 14:07:03 -0700
Subject: [PATCH 27/37] Update README.md

---
 README.md | 51 ++++++++++++++++++++++++++++++++++++++++++++++-----
 1 file changed, 46 insertions(+), 5 deletions(-)

diff --git a/README.md b/README.md
index 2386c418d..df9e4b2ca 100644
--- a/README.md
+++ b/README.md
@@ -433,7 +433,20 @@ config.setEventBufferingEnabled(true);
 Adjust.onCreate(config);
 ```
 
-### <a id="attribution_changed_listener"></a>15. Set listener for attribution changes
+### 15. Send in the background
+
+The default behaviour of the adjust SDK is to pause sending HTTP requests while the app is on the background.
+You can change this in your `AdjustConfig` instance:
+
+```java
+AdjustConfig config = new AdjustConfig(this, appToken, environment);
+
+config.setSendInBackground(true);
+
+Adjust.onCreate(config);
+```
+
+### <a id="attribution_changed_listener"></a>16. Set listener for attribution changes
 
 You can register a listener to be notified of tracker attribution changes. Due
 to the different sources considered for attribution, this information can not
@@ -478,7 +491,7 @@ parameter. Here is a quick summary of its properties:
 - `String creative` the creative grouping level of the current install.
 - `String clickLabel` the click label of the current install.
 
-### 16. Set listener for tracked events and sessions
+### 17. Set listener for tracked events and sessions
 
 You can register a listener to be notified when events or sessions are tracked.
 There are four listeners: one for tracking successful events, one for tracking failed events, one for tracking successful sessions and one for tracking failed sessions.
@@ -537,7 +550,35 @@ And both event and session failed objects also contain:
 
 - `boolean willRetry` indicates there will be an attempt to resend the package at a later time.
 
-### 17. Disable tracking
+### 18. Set listener for deferred deeplinks
+
+You can register a listener to be notified before a deferred deeplink is opened and decide if the adjust SDK will open it.
+With the `AdjustConfig` instance, before starting the SDK, add the anonymous listener:
+
+```java
+AdjustConfig config = new AdjustConfig(this, appToken, environment);
+
+// evaluate deeplink to be launched
+config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
+    @Override
+    public boolean launchReceivedDeeplink(Uri deeplink) {
+        // ...
+        if (allowAdjustSDKToOpenDeeplink(deeplink)) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+});
+
+Adjust.onCreate(config);
+```
+
+The listener function will be called after the SDK receives a deffered deeplink from ther server and before open it. 
+Within the listener function you have access to the deeplink and the boolean that you return determines if the SDK will launch the deeplink.
+You could, for example, not allow the SDK open the deeplink at the moment, save it, and open it yourself later.
+
+### 19. Disable tracking
 
 You can disable the adjust SDK from tracking any activities of the current
 device by calling `setEnabled` with parameter `false`. This setting is
@@ -551,7 +592,7 @@ You can check if the adjust SDK is currently enabled by calling the function
 `isEnabled`. It is always possible to activate the adjust SDK by invoking
 `setEnabled` with the enabled parameter as `true`.
 
-### 18. Offline mode
+### 20. Offline mode
 
 You can put the adjust SDK in offline mode to suspend transmission to our servers, 
 while retaining tracked data to be sent later. While in offline mode, all information is saved
@@ -571,7 +612,7 @@ Unlike disabling tracking, this setting is *not remembered*
 bettween sessions. This means that the SDK is in online mode whenever it is started,
 even if the app was terminated in offline mode.
 
-### 19. Device IDs
+### 21. Device IDs
 
 Certain services (such as Google Analytics) require you to coordinate Device and Client IDs in order to prevent duplicate reporting. 
 

From 894168aaf86d1007d6e65c7c6c6fcfb6431abcf4 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Fri, 29 Apr 2016 14:08:31 -0700
Subject: [PATCH 28/37] Update Play services version

---
 Adjust/example/build.gradle | 2 +-
 README.md                   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Adjust/example/build.gradle b/Adjust/example/build.gradle
index e8f314bc1..ee813ad1a 100644
--- a/Adjust/example/build.gradle
+++ b/Adjust/example/build.gradle
@@ -22,7 +22,7 @@ android {
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile 'com.android.support:appcompat-v7:23.1.0'
-    compile 'com.google.android.gms:play-services-analytics:8.3.0'
+    compile 'com.google.android.gms:play-services-analytics:8.4.0'
     // imported module
     compile project(":adjust")
     // running mvn package
diff --git a/README.md b/README.md
index df9e4b2ca..38c5c1191 100644
--- a/README.md
+++ b/README.md
@@ -67,7 +67,7 @@ these steps:
 following line:
 
     ```
-    compile 'com.google.android.gms:play-services-analytics:8.3.0'
+    compile 'com.google.android.gms:play-services-analytics:8.4.0'
     ```
 
     ![][gradle_gps]

From b587336720d5703ff4eca7a6fb414c69c3044167 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Fri, 29 Apr 2016 14:09:26 -0700
Subject: [PATCH 29/37] Edit example app

---
 .../java/com/adjust/example/GlobalApplication.java     |  9 ++++++---
 .../main/java/com/adjust/example/ServiceActivity.java  |  7 +++++++
 .../main/java/com/adjust/example/ServiceExample.java   | 10 ++++++++++
 3 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java b/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
index 059147a3f..3a39afd65 100644
--- a/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
+++ b/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
@@ -36,9 +36,6 @@ public void onCreate() {
         // change the log level
         config.setLogLevel(LogLevel.VERBOSE);
 
-        // enable event buffering
-        //config.setEventBufferingEnabled(true);
-
         // set default tracker
         //config.setDefaultTracker("{YourDefaultTracker}");
 
@@ -97,6 +94,12 @@ public boolean launchReceivedDeeplink(Uri deeplink) {
             }
         });
 
+        // allow to send in the background
+        config.setSendInBackground(true);
+
+        // enable event buffering
+        //config.setEventBufferingEnabled(true);
+
         Adjust.onCreate(config);
 
         // register onResume and onPause events of all activities
diff --git a/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java b/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java
index 8ffd068e8..cc629ed8f 100644
--- a/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java
+++ b/Adjust/example/src/main/java/com/adjust/example/ServiceActivity.java
@@ -1,6 +1,7 @@
 package com.adjust.example;
 
 import android.content.Intent;
+import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.SystemClock;
 import android.support.v7.app.AppCompatActivity;
@@ -8,12 +9,18 @@
 import android.util.Log;
 import android.view.View;
 
+import com.adjust.sdk.Adjust;
+
 public class ServiceActivity extends AppCompatActivity {
 
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_service);
+
+        Intent intent = getIntent();
+        Uri data = intent.getData();
+        Adjust.appWillOpenUrl(data);
     }
 
     public void onServiceClick(View v) {
diff --git a/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java b/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java
index 45d5e115e..d44ae35ff 100644
--- a/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java
+++ b/Adjust/example/src/main/java/com/adjust/example/ServiceExample.java
@@ -16,6 +16,8 @@
 public class ServiceExample extends Service {
     private static final String EVENT_TOKEN_BACKGROUND      = "{YourEventToken}";
 
+    private static boolean flip = true;
+
     public ServiceExample() {
         super();
         Log.d("example", "ServiceExample constructor");
@@ -39,6 +41,14 @@ public int onStartCommand(Intent intent, int flags, int startId) {
         int startDefaultOption = super.onStartCommand(intent, flags, startId);
         Log.d("example", "ServiceExample onStartCommand");
 
+        if (flip) {
+            Adjust.setEnabled(false);
+            flip = false;
+        } else {
+            Adjust.setEnabled(true);
+            flip = true;
+        }
+
         new AsyncTask<Void,Void,Void>() {
             @Override
             protected Void doInBackground(Void... params) {

From 4f3c4d6ecd567752c89b3936a5854c8a7508d5ad Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 2 May 2016 11:37:19 -0700
Subject: [PATCH 30/37] Refac launch deeplink

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 35 ++++++++-----------
 1 file changed, 15 insertions(+), 20 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index 27f67bb94..c9a887223 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -758,28 +758,25 @@ private void prepareDeeplink(ResponseData responseData, final Handler handler) {
         }
 
         final Uri location = Uri.parse(deeplink);
+        final Intent deeplinkIntent = createDeeplinkIntent(location);
 
-        // there is no validation to be made by the user
-        if (adjustConfig.onDeeplinkResponseListener == null) {
-            launchDeeplink(location, handler, deeplink);
-            return;
-        }
-
-        // launch deeplink validation by user
         Runnable runnable = new Runnable() {
             @Override
             public void run() {
-                boolean toLaunchDeeplink = adjustConfig.onDeeplinkResponseListener.launchReceivedDeeplink(location);
+                boolean toLaunchDeeplink = true;
+                if (adjustConfig.onDeeplinkResponseListener != null) {
+                    toLaunchDeeplink = adjustConfig.onDeeplinkResponseListener.launchReceivedDeeplink(location);
+                }
                 if (toLaunchDeeplink) {
-                    launchDeeplink(location, handler, deeplink);
+                    launchDeeplinkMain(deeplinkIntent, deeplink);
                 }
             }
         };
         handler.post(runnable);
     }
 
-    private void launchDeeplink(final Uri location, Handler handler, final String deeplink) {
-        final Intent mapIntent;
+    private Intent createDeeplinkIntent(Uri location) {
+        Intent mapIntent;
         if (adjustConfig.deepLinkComponent == null) {
             mapIntent = new Intent(Intent.ACTION_VIEW, location);
         } else {
@@ -789,9 +786,13 @@ private void launchDeeplink(final Uri location, Handler handler, final String de
 
         mapIntent.setPackage(adjustConfig.context.getPackageName());
 
+        return mapIntent;
+    }
+
+    private void launchDeeplinkMain(final Intent deeplinkIntent, final String deeplink) {
         // Verify it resolves
         PackageManager packageManager = adjustConfig.context.getPackageManager();
-        List<ResolveInfo> activities = packageManager.queryIntentActivities(mapIntent, 0);
+        List<ResolveInfo> activities = packageManager.queryIntentActivities(deeplinkIntent, 0);
         boolean isIntentSafe = activities.size() > 0;
 
         // Start an activity if it's safe
@@ -801,14 +802,8 @@ private void launchDeeplink(final Uri location, Handler handler, final String de
         }
 
         // add it to the handler queue
-        Runnable runnable = new Runnable() {
-            @Override
-            public void run() {
-                logger.info("Open deep link (%s)", deeplink);
-                adjustConfig.context.startActivity(mapIntent);
-            }
-        };
-        handler.post(runnable);
+        logger.info("Open deep link (%s)", deeplink);
+        adjustConfig.context.startActivity(deeplinkIntent);
     }
 
     private void sendReferrerInternal(String referrer, long clickTime) {

From bcc93ec8866344f0d97d7a73c5fbaed2a6a2984b Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 2 May 2016 11:51:12 -0700
Subject: [PATCH 31/37] Refac waiting time

---
 .../java/com/adjust/sdk/BackoffStrategy.java  | 32 +++++++++----------
 .../src/main/java/com/adjust/sdk/Util.java    | 25 +++++++++------
 2 files changed, 31 insertions(+), 26 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java b/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
index 7237cc48a..2fe3c9a18 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
@@ -7,43 +7,43 @@ public enum BackoffStrategy {
     LONG_WAIT(1,                        // min retries
             2 * Constants.ONE_MINUTE,   // milliseconds multiplier
             24 * Constants.ONE_HOUR,    // max wait time
-            50,                         // min jitter multiplier
-            100),                       // max jitter multiplier
+            0.5,                        // min jitter multiplier
+            1.0),                       // max jitter multiplier
 
-    // 0.1-0.2, 0.2-0.4, 0.4-0.8, ... 1m
+    // 0.1-0.2, 0.2-0.4, 0.4-0.8, ... 1h
     SHORT_WAIT(1,                   // min retries
             200,                    // milliseconds multiplier
             Constants.ONE_MINUTE,   // max wait time
-            50,                     // min jitter multiplier
-            100),                   // max jitter multiplier
+            0.5,                    // min jitter multiplier
+            1.0),                   // max jitter multiplier
 
     TEST_WAIT(1,                    // min retries
             200,                    // milliseconds multiplier
             1000,                   // max wait time
-            50,                     // min jitter multiplier
-            100),                   // max jitter multiplier
+            0.5,                    // min jitter multiplier
+            1.0),                   // max jitter multiplier
 
     NO_WAIT(100,                    // min retries
             1,                      // milliseconds multiplier
             Constants.ONE_SECOND,   // max wait time
-            1,                      // min jitter multiplier
-            1);                     // max jitter multiplier
+            1.0,                    // min jitter multiplier
+            1.0);                   // max jitter multiplier
 
-    int minRetries;
+    int minRetries; // retries before starting backoff
     long milliSecondMultiplier;
     long maxWait;
-    int minJitter;
-    int maxJitter;
+    double minRange;
+    double maxRange;
 
     BackoffStrategy(int minRetries,
                     long milliSecondMultiplier,
                     long maxWait,
-                    int minJitter,
-                    int maxJitter) {
+                    double minRange,
+                    double maxRange) {
         this.minRetries = minRetries;
         this.milliSecondMultiplier = milliSecondMultiplier;
         this.maxWait = maxWait;
-        this.minJitter = minJitter;
-        this.maxJitter = maxJitter;
+        this.minRange = minRange;
+        this.maxRange = maxRange;
     }
 }
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
index b1726a155..e0ae3faa0 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Util.java
@@ -527,19 +527,24 @@ public static long getWaitingTime(int retries, BackoffStrategy backoffStrategy)
         if (retries < backoffStrategy.minRetries) {
             return 0;
         }
-        // start with base 0
-        int base = retries - backoffStrategy.minRetries;
-        // get the exponential Time from the base: 1, 2, 4, 8, 16, ... * times the multiplier
-        long exponentialTime = (((long) Math.pow(2, base)) * backoffStrategy.milliSecondMultiplier);
+        // start with expon 0
+        int expon = retries - backoffStrategy.minRetries;
+        // get the exponential Time from the power of 2: 1, 2, 4, 8, 16, ... * times the multiplier
+        long exponentialTime = ((long) Math.pow(2, expon)) * backoffStrategy.milliSecondMultiplier;
         // limit the maximum allowed time to wait
         long ceilingTime = Math.min(exponentialTime, backoffStrategy.maxWait);
-        Random random = new Random();
-        // add 1 to allow maximum value
-        int jitterFactorBase = random.nextInt(backoffStrategy.maxJitter - backoffStrategy.minJitter + 1);
-        int jitterFactorAdjusted = jitterFactorBase + backoffStrategy.minJitter;
-        double jitterFactor = jitterFactorAdjusted / 100.0;
+        // get the random range
+        double randomDouble = randomInRange(backoffStrategy.minRange, backoffStrategy.maxRange);
         // apply jitter factor
-        double waitingTime =  ceilingTime * jitterFactor;
+        double waitingTime =  ceilingTime * randomDouble;
         return (long)waitingTime;
     }
+
+    private static double randomInRange(double minRange, double maxRange) {
+        Random random = new Random();
+        double range = maxRange - minRange;
+        double scaled = random.nextDouble() * range;
+        double shifted = scaled + minRange;
+        return shifted;
+    }
 }

From 8c5b716bd4b2f476c0b75032ea6c28dfe077376c Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 2 May 2016 11:51:39 -0700
Subject: [PATCH 32/37] Stop and start timers in background

---
 .../java/com/adjust/sdk/ActivityHandler.java  | 30 ++++++++-----------
 1 file changed, 12 insertions(+), 18 deletions(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
index c9a887223..4267fea72 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/ActivityHandler.java
@@ -194,18 +194,15 @@ public static ActivityHandler getInstance(AdjustConfig adjustConfig) {
     public void onResume() {
         internalState.background = false;
 
-        stopBackgroundTimer();
-
-        startForegroundTimer();
-
-        trackSubsessionStart();
-    }
-
-    public void trackSubsessionStart() {
-        logger.verbose("Subsession start");
         internalHandler.post(new Runnable() {
             @Override
             public void run() {
+                stopBackgroundTimer();
+
+                startForegroundTimer();
+
+                logger.verbose("Subsession start");
+
                 startInternal();
             }
         });
@@ -215,18 +212,15 @@ public void run() {
     public void onPause() {
         internalState.background = true;
 
-        stopForegroundTimer();
-
-        startBackgroundTimer();
-
-        trackSubsessionEnd();
-    }
-
-    public void trackSubsessionEnd() {
-        logger.verbose("Subsession end");
         internalHandler.post(new Runnable() {
             @Override
             public void run() {
+                stopForegroundTimer();
+
+                startBackgroundTimer();
+
+                logger.verbose("Subsession end");
+
                 endInternal();
             }
         });

From 973b4b67609e62354a8bc59db69cbb02281c0260 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Mon, 2 May 2016 11:57:24 -0700
Subject: [PATCH 33/37] Delay max wait time click handler

---
 Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java b/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
index 2fe3c9a18..d15cee922 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/BackoffStrategy.java
@@ -13,7 +13,7 @@ public enum BackoffStrategy {
     // 0.1-0.2, 0.2-0.4, 0.4-0.8, ... 1h
     SHORT_WAIT(1,                   // min retries
             200,                    // milliseconds multiplier
-            Constants.ONE_MINUTE,   // max wait time
+            Constants.ONE_HOUR,     // max wait time
             0.5,                    // min jitter multiplier
             1.0),                   // max jitter multiplier
 

From abb93df00ed183e3fee4ddf2353d704ca5bb20b5 Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 3 May 2016 11:37:29 -0700
Subject: [PATCH 34/37] Update libraries

---
 Adjust/build.gradle                                        | 2 +-
 Adjust/example/build.gradle                                | 2 +-
 .../main/java/com/adjust/example/GlobalApplication.java    | 7 ++-----
 3 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/Adjust/build.gradle b/Adjust/build.gradle
index a6fcfe1fe..f6e907312 100644
--- a/Adjust/build.gradle
+++ b/Adjust/build.gradle
@@ -5,7 +5,7 @@ buildscript {
         jcenter()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:1.5.0'
+        classpath 'com.android.tools.build:gradle:2.1.0'
 
         // NOTE: Do not place your application dependencies here; they belong
         // in the individual module build.gradle files
diff --git a/Adjust/example/build.gradle b/Adjust/example/build.gradle
index ee813ad1a..d756773f9 100644
--- a/Adjust/example/build.gradle
+++ b/Adjust/example/build.gradle
@@ -21,7 +21,7 @@ android {
 
 dependencies {
     compile fileTree(dir: 'libs', include: ['*.jar'])
-    compile 'com.android.support:appcompat-v7:23.1.0'
+    compile 'com.android.support:appcompat-v7:23.3.0'
     compile 'com.google.android.gms:play-services-analytics:8.4.0'
     // imported module
     compile project(":adjust")
diff --git a/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java b/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
index 3a39afd65..5c1780d1f 100644
--- a/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
+++ b/Adjust/example/src/main/java/com/adjust/example/GlobalApplication.java
@@ -86,11 +86,8 @@ public void onFinishedSessionTrackingFailed(AdjustSessionFailure sessionFailureR
         config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
             @Override
             public boolean launchReceivedDeeplink(Uri deeplink) {
-                if (deeplink.getPath().equals("")) {
-                    return false;
-                } else {
-                    return true;
-                }
+                Log.d("example", "deeplink to open: " + deeplink);
+                return true;
             }
         });
 

From 0597803f20d308bec1a330f4a9cc5d14e02d372d Mon Sep 17 00:00:00 2001
From: uerceg <ugljesa@adjust.com>
Date: Wed, 4 May 2016 00:01:41 +0200
Subject: [PATCH 35/37] Adjust enable/disable button text in onResume

---
 .../src/main/java/com/adjust/example/MainActivity.java   | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/Adjust/example/src/main/java/com/adjust/example/MainActivity.java b/Adjust/example/src/main/java/com/adjust/example/MainActivity.java
index 466c4bec1..657f8c59b 100644
--- a/Adjust/example/src/main/java/com/adjust/example/MainActivity.java
+++ b/Adjust/example/src/main/java/com/adjust/example/MainActivity.java
@@ -20,6 +20,8 @@ public class MainActivity extends AppCompatActivity {
     private static final String EVENT_TOKEN_CALLBACK    = "{YourEventToken}";
     private static final String EVENT_TOKEN_PARTNER     = "{YourEventToken}";
 
+    private Button btnEnableDisableSDK;
+
     @Override
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -30,7 +32,12 @@ protected void onCreate(Bundle savedInstanceState) {
         Adjust.appWillOpenUrl(data);
 
         // Adjust UI according to SDK state.
-        Button btnEnableDisableSDK = (Button)findViewById(R.id.btnEnableDisableSDK);
+        btnEnableDisableSDK = (Button)findViewById(R.id.btnEnableDisableSDK);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
 
         if (Adjust.isEnabled()) {
             btnEnableDisableSDK.setText(R.string.txt_disable_sdk);

From f68a42f9423dd4b1ec1cca844ee8915f2a5082fd Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 12 Apr 2016 11:40:58 +0200
Subject: [PATCH 36/37] Update tests

---
 Adjust/test/build.gradle                      |    1 +
 .../java/com/adjust/sdk/test/AssertUtil.java  |  100 +-
 .../adjust/sdk/test/MockActivityHandler.java  |   14 +-
 .../sdk/test/MockAttributionHandler.java      |    4 +-
 .../sdk/test/MockHttpsURLConnection.java      |   12 +-
 .../java/com/adjust/sdk/test/MockLogger.java  |   92 +-
 .../adjust/sdk/test/MockPackageHandler.java   |    9 +-
 .../adjust/sdk/test/MockRequestHandler.java   |    6 +-
 .../adjust/sdk/test/MockSdkClickHandler.java  |   41 +
 .../adjust/sdk/test/TestActivityHandler.java  | 1719 +++++++++++------
 .../adjust/sdk/test/TestActivityPackage.java  |   53 +-
 .../sdk/test/TestAttributionHandler.java      |   29 +-
 .../adjust/sdk/test/TestPackageHandler.java   |  155 +-
 .../adjust/sdk/test/TestRequestHandler.java   |   26 +-
 .../adjust/sdk/test/TestSdkClickHandler.java  |  318 +++
 15 files changed, 1895 insertions(+), 684 deletions(-)
 create mode 100644 Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockSdkClickHandler.java
 create mode 100644 Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestSdkClickHandler.java

diff --git a/Adjust/test/build.gradle b/Adjust/test/build.gradle
index f5e38ad7a..719d6da23 100644
--- a/Adjust/test/build.gradle
+++ b/Adjust/test/build.gradle
@@ -16,6 +16,7 @@ repositories {
 
 dependencies {
     compile 'com.google.code.gson:gson:2.4'
+    compile 'com.google.android.gms:play-services-analytics:8.4.0'
     compile fileTree(dir: 'libs', include: ['*.jar'])
     compile project(':adjust')
 }
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/AssertUtil.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/AssertUtil.java
index 85e06f1cc..c6638fb3c 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/AssertUtil.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/AssertUtil.java
@@ -21,99 +21,109 @@ public AssertUtil(MockLogger mockLogger) {
         this.mockLogger = mockLogger;
     }
 
-    public void test(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsTestMessage(String.format(Locale.US, message, parameters)));
+    public String test(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsTestMessage = mockLogger.containsTestMessage(String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsTestMessage.containsMessage);
+        return containsTestMessage.matchMessage;
     }
 
-    public void verbose(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsMessage(VERBOSE, String.format(Locale.US, message, parameters)));
+    public String verbose(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsVerboseMessage = mockLogger.containsMessage(VERBOSE, String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsVerboseMessage.containsMessage);
+        return containsVerboseMessage.matchMessage;
     }
 
-    public void debug(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsMessage(DEBUG, String.format(Locale.US, message, parameters)));
+    public String debug(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsDebugMessage = mockLogger.containsMessage(DEBUG, String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsDebugMessage.containsMessage);
+        return containsDebugMessage.matchMessage;
     }
 
-    public void info(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsMessage(INFO, String.format(Locale.US, message, parameters)));
+    public String info(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsInfoMessage = mockLogger.containsMessage(INFO, String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsInfoMessage.containsMessage);
+        return containsInfoMessage.matchMessage;
     }
 
-    public void warn(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsMessage(WARN, String.format(Locale.US, message, parameters)));
+    public String warn(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsWarnMessage = mockLogger.containsMessage(WARN, String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsWarnMessage.containsMessage);
+        return containsWarnMessage.matchMessage;
     }
 
-    public void error(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsMessage(ERROR, String.format(Locale.US, message, parameters)));
+    public String error(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsErrorMessage = mockLogger.containsMessage(ERROR, String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsErrorMessage.containsMessage);
+        return containsErrorMessage.matchMessage;
     }
 
-    public void Assert(String message, Object... parameters) {
-        Assert.assertTrue(mockLogger.toString(),
-                mockLogger.containsMessage(ASSERT, String.format(Locale.US, message, parameters)));
+    public String Assert(String message, Object... parameters) {
+        MockLogger.ContainsReturn containsAssertMessage = mockLogger.containsMessage(ASSERT, String.format(Locale.US, message, parameters));
+        Assert.assertTrue(mockLogger.toString(), containsAssertMessage.containsMessage);
+        return containsAssertMessage.matchMessage;
     }
 
     public void notInTest(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsTestMessage(message));
+        MockLogger.ContainsReturn containsTestMessage = mockLogger.containsTestMessage(String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsTestMessage.containsMessage);
     }
 
     public void notInVerbose(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsMessage(VERBOSE, String.format(Locale.US, message, parameters)));
+        MockLogger.ContainsReturn containsVerboseMessage = mockLogger.containsMessage(VERBOSE, String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsVerboseMessage.containsMessage);
     }
 
     public void notInDebug(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsMessage(DEBUG, String.format(Locale.US, message, parameters)));
+        MockLogger.ContainsReturn containsDebugMessage = mockLogger.containsMessage(DEBUG, String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsDebugMessage.containsMessage);
     }
 
     public void notInInfo(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsMessage(INFO, String.format(Locale.US, message, parameters)));
+        MockLogger.ContainsReturn containsInfoMessage = mockLogger.containsMessage(INFO, String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsInfoMessage.containsMessage);
     }
 
     public void notInWarn(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsMessage(WARN, String.format(Locale.US, message, parameters)));
+        MockLogger.ContainsReturn containsWarnMessage = mockLogger.containsMessage(WARN, String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsWarnMessage.containsMessage);
     }
 
     public void notInError(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsMessage(ERROR, String.format(Locale.US, message, parameters)));
+        MockLogger.ContainsReturn containsErrorMessage = mockLogger.containsMessage(ERROR, String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsErrorMessage.containsMessage);
     }
 
     public void notInAssert(String message, Object... parameters) {
-        Assert.assertFalse(mockLogger.toString(),
-                mockLogger.containsMessage(ASSERT, String.format(Locale.US, message, parameters)));
+        MockLogger.ContainsReturn containsAssertMessage = mockLogger.containsMessage(ASSERT, String.format(Locale.US, message, parameters));
+        Assert.assertFalse(mockLogger.toString(), containsAssertMessage.containsMessage);
     }
 
     public void isNull(Object object) {
-        Assert.assertNull(mockLogger.toString(),
-                object);
+        Assert.assertNull(mockLogger.toString(), object);
     }
 
     public void isNotNull(Object object) {
-        Assert.assertNotNull(mockLogger.toString(),
-                object);
+        Assert.assertNotNull(mockLogger.toString(), object);
     }
 
     public void isTrue(boolean value) {
-        Assert.assertTrue(mockLogger.toString(),
-                value);
+        Assert.assertTrue(mockLogger.toString(), value);
     }
 
     public void isFalse(boolean value) {
-        Assert.assertFalse(mockLogger.toString(),
-                value);
+        Assert.assertFalse(mockLogger.toString(), value);
     }
 
     public void isEqual(String expected, String actual) {
-        Assert.assertEquals(mockLogger.toString(),
-                expected, actual);
+        Assert.assertEquals(mockLogger.toString(), expected, actual);
+    }
+
+    public void isEqual(boolean expected, boolean actual) {
+        Assert.assertEquals(mockLogger.toString(), expected, actual);
+    }
+
+    public void isEqual(int expected, int actual) {
+        Assert.assertEquals(mockLogger.toString(), expected, actual);
     }
 
     public void fail() {
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockActivityHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockActivityHandler.java
index a8b08bf8e..47fd6cd21 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockActivityHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockActivityHandler.java
@@ -33,13 +33,13 @@ public void init(AdjustConfig config) {
     }
 
     @Override
-    public void trackSubsessionStart() {
-        testLogger.test(prefix + "trackSubsessionStart");
+    public void onResume() {
+        testLogger.test(prefix + "onResume");
     }
 
     @Override
-    public void trackSubsessionEnd() {
-        testLogger.test(prefix + "trackSubsessionEnd");
+    public void onPause() {
+        testLogger.test(prefix + "onPause");
     }
 
     @Override
@@ -107,10 +107,4 @@ public void setOfflineMode(boolean enabled) {
     public void setAskingAttribution(boolean askingAttribution) {
         testLogger.test(prefix + "setAskingAttribution, " + askingAttribution);
     }
-
-    @Override
-    public ActivityPackage getAttributionPackage() {
-        testLogger.test(prefix + "getAttributionPackage");
-        return null;
-    }
 }
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockAttributionHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockAttributionHandler.java
index 654ae2dae..81a8ee01e 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockAttributionHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockAttributionHandler.java
@@ -22,9 +22,9 @@ public MockAttributionHandler(MockLogger testLogger) {
     @Override
     public void init(IActivityHandler activityHandler,
                      ActivityPackage attributionPackage,
-                     boolean startPaused,
+                     boolean startsSending,
                      boolean hasListener) {
-        testLogger.test(prefix + "init, startPaused: " + startPaused +
+        testLogger.test(prefix + "init, startsSending: " + startsSending +
                 ", hasListener: " + hasListener);
         this.activityHandler = activityHandler;
         this.attributionPackage = attributionPackage;
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockHttpsURLConnection.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockHttpsURLConnection.java
index e4e799e55..b2e5cbbaa 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockHttpsURLConnection.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockHttpsURLConnection.java
@@ -29,6 +29,7 @@ public class MockHttpsURLConnection extends HttpsURLConnection {
     private ByteArrayOutputStream outputStream;
     public ResponseType responseType;
     public boolean timeout;
+    public Long waitingTime;
 
     protected MockHttpsURLConnection(URL url) {
         super(url);
@@ -46,6 +47,10 @@ public InputStream getInputStream() throws IOException {
             SystemClock.sleep(10000);
         }
 
+        if (waitingTime != null) {
+            SystemClock.sleep(waitingTime);
+        }
+
         if (responseType == ResponseType.CLIENT_PROTOCOL_EXCEPTION) {
             throw new IOException ("testResponseError");
         } else if (responseType == ResponseType.WRONG_JSON) {
@@ -272,7 +277,12 @@ public String getRequestProperty(String field) {
 
     public URL getURL() {
         testLogger.test(prefix + "getURL");
-        return null;
+        return this.url;
+    }
+
+    public void setURL(URL url) {
+        testLogger.test(prefix + "setURL, " + url);
+
     }
 
     public boolean getUseCaches() {
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockLogger.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockLogger.java
index 2b14647b0..e477fcb58 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockLogger.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockLogger.java
@@ -17,22 +17,38 @@ public class MockLogger implements ILogger {
 
     private StringBuffer logBuffer;
     private SparseArray<ArrayList<String>> logMap;
+    public static final int TEST_LEVEL = 6;
+    public static final int CHECK_LEVEL = 7;
+    private long startTime;
+    private long lastTime;
+
+    public class ContainsReturn {
+        boolean containsMessage;
+        String matchMessage;
+        ContainsReturn(boolean containsMessage, String matchMessage) {
+            this.containsMessage = containsMessage;
+            this.matchMessage = matchMessage;
+        }
+    }
 
     public MockLogger() {
         reset();
     }
 
     public void reset() {
+        startTime = System.currentTimeMillis();
+        lastTime = startTime;
+
         logBuffer = new StringBuffer();
-        logMap = new SparseArray<ArrayList<String>>(7);
-        logMap.put(LogLevel.ASSERT.getAndroidLogLevel(), new ArrayList<String>());
+        logMap = new SparseArray<ArrayList<String>>(8);
+        logMap.put(LogLevel.VERBOSE.getAndroidLogLevel(), new ArrayList<String>());
         logMap.put(LogLevel.DEBUG.getAndroidLogLevel(), new ArrayList<String>());
-        logMap.put(LogLevel.ERROR.getAndroidLogLevel(), new ArrayList<String>());
         logMap.put(LogLevel.INFO.getAndroidLogLevel(), new ArrayList<String>());
-        logMap.put(LogLevel.VERBOSE.getAndroidLogLevel(), new ArrayList<String>());
         logMap.put(LogLevel.WARN.getAndroidLogLevel(), new ArrayList<String>());
-        // logging test level == 1
-        logMap.put(1, new ArrayList<String>());
+        logMap.put(LogLevel.ERROR.getAndroidLogLevel(), new ArrayList<String>());
+        logMap.put(LogLevel.ASSERT.getAndroidLogLevel(), new ArrayList<String>());
+        logMap.put(TEST_LEVEL, new ArrayList<String>());
+        logMap.put(CHECK_LEVEL, new ArrayList<String>());
 
         test("Logger reset");
     }
@@ -54,18 +70,29 @@ public void setLogLevelString(String logLevelString) {
     }
 
     private void logMessage(String message, Integer iLoglevel, String messagePrefix, int priority) {
-        logBuffer.append(messagePrefix + message + System.getProperty("line.separator"));
-        Log.println(priority, LOGTAG, messagePrefix + message);
+        long now = System.currentTimeMillis();
+        long milliSecondsPassed = now - startTime;
+        long lastTimePassed = now - lastTime;
+        lastTime = now;
 
         List<String> prefixedList = logMap.get(iLoglevel);
         prefixedList.add(message);
+
+        String longMessage = String.format("%d %d %s %s", milliSecondsPassed, lastTimePassed, messagePrefix, message);
+        Log.println(priority, LOGTAG, longMessage);
+
+        String logBufferMessage = String.format("%s%s", longMessage, System.getProperty("line.separator"));
+        logBuffer.append(logBufferMessage);
+        //String sList = Arrays.toString(prefixedList.toArray());
+        //String logBufferList = String.format("In %s", sList);
+        //logBuffer.append(logBufferList);
     }
 
     @Override
     public void verbose(String message, Object... parameters) {
         logMessage(String.format(Locale.US, message, parameters),
                 LogLevel.VERBOSE.getAndroidLogLevel(),
-                "v ",
+                "v",
                 Log.VERBOSE);
     }
 
@@ -73,7 +100,7 @@ public void verbose(String message, Object... parameters) {
     public void debug(String message, Object... parameters) {
         logMessage(String.format(Locale.US, message, parameters),
                 LogLevel.DEBUG.getAndroidLogLevel(),
-                "d ",
+                "d",
                 Log.DEBUG);
     }
 
@@ -81,7 +108,7 @@ public void debug(String message, Object... parameters) {
     public void info(String message, Object... parameters) {
         logMessage(String.format(Locale.US, message, parameters),
                 LogLevel.INFO.getAndroidLogLevel(),
-                "i ",
+                "i",
                 Log.INFO);
     }
 
@@ -89,7 +116,7 @@ public void info(String message, Object... parameters) {
     public void warn(String message, Object... parameters) {
         logMessage(String.format(Locale.US, message, parameters),
                 LogLevel.WARN.getAndroidLogLevel(),
-                "w ",
+                "w",
                 Log.WARN);
     }
 
@@ -97,7 +124,7 @@ public void warn(String message, Object... parameters) {
     public void error(String message, Object... parameters) {
         logMessage(String.format(Locale.US, message, parameters),
                 LogLevel.ERROR.getAndroidLogLevel(),
-                "e ",
+                "e",
                 Log.ERROR);
     }
 
@@ -105,38 +132,53 @@ public void error(String message, Object... parameters) {
     public void Assert(String message, Object... parameters) {
         logMessage(String.format(Locale.US, message, parameters),
                 LogLevel.ASSERT.getAndroidLogLevel(),
-                "a ",
+                "a",
                 Log.ASSERT);
     }
 
     public void test(String message) {
-        logMessage(message, 1, "t ", Log.VERBOSE);
+        logMessage(message, TEST_LEVEL, "t", Log.VERBOSE);
     }
 
-    private Boolean mapContainsMessage(int level, String beginsWith) {
+    private void check(String message) {
+        logMessage(message, CHECK_LEVEL, "c", Log.VERBOSE);
+    }
+
+    private ContainsReturn mapContainsMessage(int level, String beginsWith) {
         ArrayList<String> list = logMap.get(level);
         @SuppressWarnings("unchecked")
-        ArrayList<String> listCopy = (ArrayList<String>) list.clone();
+        ArrayList<String> listCopy = new ArrayList<String>(list);
         String sList = Arrays.toString(list.toArray());
         for (String log : list) {
             listCopy.remove(0);
             if (log.startsWith(beginsWith)) {
-                //test(log + " found");
-                Log.println(Log.ASSERT, LOGTAG, String.format(Locale.US, "%s found", log));
+                String foundMessage = String.format(Locale.US, "%s found", log);
+                //Log.println(Log.ASSERT, LOGTAG, foundMessage);
+                check(foundMessage);
                 logMap.put(level, listCopy);
-                return true;
+                return new ContainsReturn(true, log);
             }
         }
-        Log.println(Log.ASSERT, LOGTAG, String.format(Locale.US, "%s does not contain %s", sList, beginsWith));
+        String notFoundMessage = String.format(Locale.US, "%s is not in %s", beginsWith, sList);
+        check(notFoundMessage);
+        //Log.println(Log.ASSERT, LOGTAG, notFoundMessage);
 
-        return false;
+        return new ContainsReturn(false, null);
     }
 
-    public Boolean containsMessage(LogLevel level, String beginsWith) {
+    public ContainsReturn containsMessage(LogLevel level, String beginsWith) {
         return mapContainsMessage(level.getAndroidLogLevel(), beginsWith);
     }
 
-    public Boolean containsTestMessage(String beginsWith) {
-        return mapContainsMessage(1, beginsWith);
+    public ContainsReturn containsTestMessage(String beginsWith) {
+        return mapContainsMessage(TEST_LEVEL, beginsWith);
+    }
+
+    public void printLogMap(int level) {
+        ArrayList<String> list = logMap.get(level);
+        String sList = Arrays.toString(list.toArray());
+
+        String message = String.format(Locale.US, "list level %d: %s", level, sList);
+        check(message);
     }
 }
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockPackageHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockPackageHandler.java
index bbb960ca4..5e8ef21b0 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockPackageHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockPackageHandler.java
@@ -23,8 +23,8 @@ public MockPackageHandler(MockLogger testLogger) {
     }
 
     @Override
-    public void init(IActivityHandler activityHandler, Context context, boolean startPaused) {
-        testLogger.test(prefix + "init, startPaused: " + startPaused);
+    public void init(IActivityHandler activityHandler, Context context, boolean startsSending) {
+        testLogger.test(prefix + "init, startsSending: " + startsSending);
         this.activityHandler = activityHandler;
         this.context = context;
     }
@@ -51,8 +51,9 @@ public void sendNextPackage(ResponseData responseData) {
     }
 
     @Override
-    public void closeFirstPackage(ResponseData responseData) {
-        testLogger.test(prefix + "closeFirstPackage, " + responseData);
+    public void closeFirstPackage(ResponseData responseData, ActivityPackage activityPackage) {
+        testLogger.test(prefix + "closeFirstPackage, responseData" + responseData);
+        testLogger.test(prefix + "closeFirstPackage, activityPackage" + activityPackage);
     }
 
     @Override
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockRequestHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockRequestHandler.java
index 0cdfa9132..9944b70a4 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockRequestHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockRequestHandler.java
@@ -20,8 +20,10 @@ public void init(IPackageHandler packageHandler) {
     }
 
     @Override
-    public void sendPackage(ActivityPackage pack) {
-        testLogger.test(prefix + "sendPackage, " + pack);
+    public void sendPackage(ActivityPackage activityPackage, int queueSize) {
+        testLogger.test(prefix + "sendPackage, activityPackage " + activityPackage);
+        testLogger.test(prefix + "sendPackage, queueSize " + queueSize);
+
         /*
         // respond successfully to the package handler
         if (packageHandler != null && !errorNextSend) {
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockSdkClickHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockSdkClickHandler.java
new file mode 100644
index 000000000..df4a65ba2
--- /dev/null
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/MockSdkClickHandler.java
@@ -0,0 +1,41 @@
+package com.adjust.sdk.test;
+
+import com.adjust.sdk.ActivityPackage;
+import com.adjust.sdk.ISdkClickHandler;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by pfms on 01/04/16.
+ */
+public class MockSdkClickHandler implements ISdkClickHandler {
+    private MockLogger testLogger;
+    private String prefix = "SdkClickHandler ";
+    List<ActivityPackage> queue;
+
+    public MockSdkClickHandler(MockLogger testLogger) {
+        this.testLogger = testLogger;
+        queue = new ArrayList<ActivityPackage>();
+    }
+    @Override
+    public void init(boolean startsSending) {
+        testLogger.test(prefix + "init, startsSending: " + startsSending);
+    }
+
+    @Override
+    public void pauseSending() {
+        testLogger.test(prefix + "pauseSending");
+    }
+
+    @Override
+    public void resumeSending() {
+        testLogger.test(prefix + "resumeSending");
+    }
+
+    @Override
+    public void sendSdkClick(ActivityPackage sdkClick) {
+        testLogger.test(prefix + "sendSdkClick");
+        queue.add(sdkClick);
+    }
+}
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityHandler.java
index 85d6bba20..3ca078b37 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityHandler.java
@@ -8,7 +8,9 @@
 import android.test.mock.MockContext;
 
 import com.adjust.sdk.ActivityHandler;
+import com.adjust.sdk.ActivityHandler.InternalState;
 import com.adjust.sdk.ActivityPackage;
+import com.adjust.sdk.Adjust;
 import com.adjust.sdk.AdjustAttribution;
 import com.adjust.sdk.AdjustConfig;
 import com.adjust.sdk.AdjustEvent;
@@ -23,6 +25,7 @@
 import com.adjust.sdk.EventResponseData;
 import com.adjust.sdk.LogLevel;
 import com.adjust.sdk.OnAttributionChangedListener;
+import com.adjust.sdk.OnDeeplinkResponseListener;
 import com.adjust.sdk.OnEventTrackingFailedListener;
 import com.adjust.sdk.OnEventTrackingSucceededListener;
 import com.adjust.sdk.OnSessionTrackingFailedListener;
@@ -38,6 +41,7 @@ public class TestActivityHandler extends ActivityInstrumentationTestCase2<UnitTe
     protected MockLogger mockLogger;
     protected MockPackageHandler mockPackageHandler;
     protected MockAttributionHandler mockAttributionHandler;
+    protected MockSdkClickHandler mockSdkClickHandler;
     protected UnitTestActivity activity;
     protected Context context;
     protected AssertUtil assertUtil;
@@ -56,11 +60,13 @@ protected void setUp() throws Exception {
         mockLogger = new MockLogger();
         mockPackageHandler = new MockPackageHandler(mockLogger);
         mockAttributionHandler = new MockAttributionHandler(mockLogger);
+        mockSdkClickHandler = new MockSdkClickHandler(mockLogger);
         assertUtil = new AssertUtil(mockLogger);
 
         AdjustFactory.setLogger(mockLogger);
         AdjustFactory.setPackageHandler(mockPackageHandler);
         AdjustFactory.setAttributionHandler(mockAttributionHandler);
+        AdjustFactory.setSdkClickHandler(mockSdkClickHandler);
 
         activity = getActivity();
         context = activity.getApplicationContext();
@@ -84,6 +90,7 @@ protected void tearDown() throws Exception {
 
         AdjustFactory.setPackageHandler(null);
         AdjustFactory.setAttributionHandler(null);
+        AdjustFactory.setSdkClickHandler(null);
         AdjustFactory.setLogger(null);
         AdjustFactory.setTimerInterval(-1);
         AdjustFactory.setTimerStart(-1);
@@ -99,18 +106,10 @@ public void testFirstSession() {
         mockLogger.Assert("TestActivityHandler testFirstSession");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig();
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(3000);
-
-        // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "INFO", false);
-
-        // test first session start
-        checkFirstSession();
+        ActivityHandler activityHandler = startAndCheckFirstSession(config);
 
         // checking the default values of the first session package
         // should only have one package
@@ -130,24 +129,31 @@ public void testEventsBuffered() {
         mockLogger.Assert("TestActivityHandler testEventsBuffered");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig(LogLevel.VERBOSE);
 
         // buffer events
         config.setEventBufferingEnabled(true);
 
-        // set verbose log level
-        config.setLogLevel(LogLevel.VERBOSE);
-
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
+        ActivityHandler activityHandler = getFirstActivityHandler(config, LogLevel.VERBOSE);
 
-        SystemClock.sleep(3000);
+        SystemClock.sleep(2000);
 
         // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "VERBOSE", true);
+        checkInitTests(
+                true,   // eventBuffering
+                null,   // defaultTracker
+                false);  // startsSending
+
+        startActivity(activityHandler);
+
+        SystemClock.sleep(2000);
+
+        SessionState newSessionState = new SessionState(SessionType.NEW_SESSION);
+        newSessionState.eventBufferingIsEnabled = true;
 
         // test first session start
-        checkFirstSession();
+        checkStartInternal(newSessionState);
 
         // create the first Event
         AdjustEvent firstEvent = new AdjustEvent("event1");
@@ -201,6 +207,9 @@ public void testEventsBuffered() {
         // and not sent to package handler
         assertUtil.notInTest("PackageHandler sendFirstPackage");
 
+        // does not fire background timer
+        assertUtil.notInVerbose("Background timer starting");
+
         // after tracking the event it should write the activity state
         assertUtil.debug("Wrote Activity state");
 
@@ -214,6 +223,9 @@ public void testEventsBuffered() {
         // and not sent to package handler
         assertUtil.notInTest("PackageHandler sendFirstPackage");
 
+        // does not fire background timer
+        assertUtil.notInVerbose("Background timer starting");
+
         // after tracking the event it should write the activity state
         assertUtil.debug("Wrote Activity state");
 
@@ -227,6 +239,9 @@ public void testEventsBuffered() {
         // and not sent to package handler
         assertUtil.notInTest("PackageHandler sendFirstPackage");
 
+        // does not fire background timer
+        assertUtil.notInVerbose("Background timer starting");
+
         // after tracking the event it should write the activity state
         assertUtil.debug("Wrote Activity state");
 
@@ -238,6 +253,7 @@ public void testEventsBuffered() {
 
         // create activity package test
         TestActivityPackage testFirstSessionPackage = new TestActivityPackage(firstSessionPackage);
+        testFirstSessionPackage.eventBufferingEnabled = true;
 
         // set first session
         testFirstSessionPackage.testSessionPackage(1);
@@ -255,6 +271,7 @@ public void testEventsBuffered() {
         testFirstEventPackage.currency = "EUR";
         testFirstEventPackage.callbackParams = "{\"keyCall\":\"valueCall2\",\"fooCall\":\"barCall\"}";
         testFirstEventPackage.partnerParams = "{\"keyPartner\":\"valuePartner2\",\"fooPartner\":\"barPartner\"}";
+        testFirstEventPackage.eventBufferingEnabled = true;
 
         // test first event
         testFirstEventPackage.testEventPackage("event1");
@@ -270,6 +287,7 @@ public void testEventsBuffered() {
         testSecondEventPackage.suffix = "(0.00000 USD, 'event2')";
         testSecondEventPackage.revenueString = "0.00000";
         testSecondEventPackage.currency = "USD";
+        testSecondEventPackage.eventBufferingEnabled = true;
 
         // test second event
         testSecondEventPackage.testEventPackage("event2");
@@ -283,6 +301,7 @@ public void testEventsBuffered() {
         // set event test parameters
         testThirdEventPackage.eventCount = "3";
         testThirdEventPackage.suffix = "'event3'";
+        testThirdEventPackage.eventBufferingEnabled = true;
 
         // test third event
         testThirdEventPackage.testEventPackage("event3");
@@ -293,20 +312,21 @@ public void testEventsNotBuffered() {
         mockLogger.Assert("TestActivityHandler testEventsNotBuffered");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
-
-        // set log level
-        config.setLogLevel(LogLevel.DEBUG);
+        AdjustConfig config = getConfig(LogLevel.DEBUG);
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
+        ActivityHandler activityHandler = getFirstActivityHandler(config, LogLevel.DEBUG);
 
-        SystemClock.sleep(3000);
+        SystemClock.sleep(2000);
 
         // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "DEBUG", false);
+        checkInitTests();
 
-        // test first session start
+        startActivity(activityHandler);
+
+        SystemClock.sleep(2000);
+
+        // test session
         checkFirstSession();
 
         // create the first Event
@@ -326,6 +346,9 @@ public void testEventsNotBuffered() {
         // and not buffered
         assertUtil.notInInfo("Buffered event");
 
+        // does not fire background timer
+        assertUtil.notInVerbose("Background timer starting");
+
         // after tracking the event it should write the activity state
         assertUtil.debug("Wrote Activity state");
     }
@@ -479,21 +502,10 @@ public int checkCallingOrSelfPermission(String permission) {
         assertUtil.notInInfo("Skipping initialization in background process");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
-
-        // set the log level
-        config.setLogLevel(LogLevel.WARN);
+        AdjustConfig config = getConfig(LogLevel.WARN);
 
         // create handler and start the first session
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(3000);
-
-        // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "WARN", false);
-
-        // test first session start
-        checkFirstSession();
+        ActivityHandler activityHandler = startAndCheckFirstSession(config, LogLevel.WARN);
 
         // track null event
         activityHandler.trackEvent(null);
@@ -516,49 +528,60 @@ public void testSessions() {
         AdjustFactory.setSubsessionInterval(1000);
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
-
-        // set verbose log level
-        config.setLogLevel(LogLevel.INFO);
+        AdjustConfig config = getConfig(LogLevel.INFO);
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(3000);
+        ActivityHandler activityHandler = startAndCheckFirstSession(config, LogLevel.INFO);
 
-        // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "INFO", false);
+        // end subsession
+        stopActivity(activityHandler);
 
-        // test first session start
-        checkFirstSession();
+        SystemClock.sleep(1000);
 
-        // trigger a new sub session session
-        activityHandler.trackSubsessionStart();
+        // test the end of the subsession
+        checkEndSession();
 
-        // and end it
-        activityHandler.trackSubsessionEnd();
+        startActivity(activityHandler);
 
-        SystemClock.sleep(5000);
+        SystemClock.sleep(1000);
 
         // test the new sub session
-        checkSubsession(1, 2, true);
+        SessionState secondSubsession = new SessionState(SessionType.NEW_SUBSESSION);
+        secondSubsession.subsessionCount = 2;
+        checkStartInternal(secondSubsession);
+
+        stopActivity(activityHandler);
+
+        SystemClock.sleep(5000);
 
         // test the end of the subsession
         checkEndSession();
 
         // trigger a new session
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
 
         SystemClock.sleep(1000);
 
         // new session
-        checkNewSession(false, 2, 0, true);
+        SessionState secondSession = new SessionState(SessionType.NEW_SESSION);
+        secondSession.sessionCount = 2;
+        secondSession.timerAlreadyStarted = true;
+        checkStartInternal(secondSession);
 
-        // end the session
-        activityHandler.trackSubsessionEnd();
+        // stop and start the activity with little interval
+        // so it won't trigger a sub session
+        stopActivity(activityHandler);
+        startActivity(activityHandler);
 
         SystemClock.sleep(1000);
 
+        // test the end of the subsession
+        checkEndSession(false, true, false);
+
+        // test non sub session
+        SessionState nonSessionState = new SessionState(SessionType.NONSESSION);
+        checkStartInternal(nonSessionState);
+
         // 2 session packages
         assertEquals(2, mockPackageHandler.queue.size());
 
@@ -592,59 +615,63 @@ public void testDisable() {
         AdjustFactory.setSubsessionInterval(1000);
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
-
-        // set log level
-        config.setLogLevel(LogLevel.ERROR);
+        AdjustConfig config = getConfig(LogLevel.ERROR);
 
         // start activity handler with config
-        ActivityHandler activityHandler = ActivityHandler.getInstance(config);
-
-        // check that is true by default
-        assertUtil.isTrue(activityHandler.isEnabled());
+        ActivityHandler activityHandler = getFirstActivityHandler(config, LogLevel.ERROR);
 
-        // disable sdk
+        // disable sdk while it has not started yet
         activityHandler.setEnabled(false);
 
         // check that it is disabled
         assertUtil.isFalse(activityHandler.isEnabled());
 
-        // not writing activity state because it did not had time to start
+        SystemClock.sleep(2000);
+
+        // not writing activity state because it set enable does not start the sdk
         assertUtil.notInDebug("Wrote Activity state");
 
         // check if message the disable of the SDK
-        assertUtil.info("Pausing package handler and attribution handler to disable the SDK");
+        assertUtil.info("Package handler and attribution handler will start as paused due to the SDK being disabled");
+
+        checkInitTests(false);
+
+        checkHandlerStatus(true);
+
+        // start the sdk
+        // foreground timer does not start because it's paused
+        startActivity(activityHandler);
 
-        // it's necessary to sleep the activity for a while after each handler call
-        // to let the internal queue act
         SystemClock.sleep(2000);
 
-        // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "ERROR", false);
+        SessionState sessionStartsPaused = new SessionState(SessionType.NEW_SESSION);
+        sessionStartsPaused.paused = true;
+        sessionStartsPaused.toSend = false;
+        sessionStartsPaused.foregroundTimerStarts = false;
+        sessionStartsPaused.foregroundTimerAlreadyStarted = false;
+
+        // check session that is paused
+        checkStartInternal(sessionStartsPaused);
 
-        // test first session start without attribution handler
-        checkFirstSession(true);
+        stopActivity(activityHandler);
+
+        SystemClock.sleep(1000);
 
         // test end session of disable
-        checkEndSession();
+        checkEndSession(true,   //pausing
+                        true,   // updateActivityState
+                        false); // eventBufferingEnabled
+
+
+        SystemClock.sleep(1000);
 
         // try to do activities while SDK disabled
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         activityHandler.trackEvent(new AdjustEvent("event1"));
 
         SystemClock.sleep(3000);
 
-        // check that timer was not executed
-        checkTimerIsFired(false);
-
-        // check that it did not resume
-        assertUtil.notInTest("PackageHandler resumeSending");
-
-        // check that it did not wrote activity state from new session or subsession
-        assertUtil.notInDebug("Wrote Activity state");
-
-        // check that it did not add any event package
-        assertUtil.notInTest("PackageHandler addPackage");
+        checkStartDisable();
 
         // only the first session package should be sent
         assertEquals(1, mockPackageHandler.queue.size());
@@ -653,13 +680,14 @@ public void testDisable() {
         activityHandler.setOfflineMode(true);
 
         // pausing due to offline mode
-        assertUtil.info("Pausing package and attribution handler to put in offline mode");
+        assertUtil.info("Pausing package and attribution handler to put SDK offline mode");
 
         // wait to update status
-        SystemClock.sleep(6000);
+        SystemClock.sleep(5000);
 
-        // test end session of offline
-        checkEndSession(false);
+        // after pausing, even when it's already paused
+        // tries to update the status
+        checkHandlerStatus(true);
 
         // re-enable the SDK
         activityHandler.setEnabled(true);
@@ -668,20 +696,33 @@ public void testDisable() {
         assertUtil.isTrue(activityHandler.isEnabled());
 
         // check message of SDK still paused
-        assertUtil.info("Package and attribution handler remain paused due to the SDK is offline");
+        assertUtil.info("Package and attribution handler remain paused due to SDK being offline");
 
-        activityHandler.trackSubsessionStart();
         SystemClock.sleep(1000);
 
-        checkNewSession(true, 2, 0);
+        // due to the fact it will remained paused,
+        // there is no need to try to update the status
+        checkHandlerStatus(null);
+
+        // start the sdk
+        // foreground timer does not start because it's offline
+        startActivity(activityHandler);
 
-        // and that the timer was not fired
-        checkTimerIsFired(false);
+        SystemClock.sleep(1000);
+
+        SessionState SecondPausedSession = new SessionState(SessionType.NEW_SESSION);
+        SecondPausedSession.toSend = false;
+        SecondPausedSession.paused = true;
+        SecondPausedSession.sessionCount = 2;
+        SecondPausedSession.timerAlreadyStarted = null;
+        SecondPausedSession.foregroundTimerStarts = false;
+        sessionStartsPaused.foregroundTimerAlreadyStarted = false;
+        checkStartInternal(SecondPausedSession);
 
         // track an event
         activityHandler.trackEvent(new AdjustEvent("event1"));
 
-        SystemClock.sleep(1000);
+        SystemClock.sleep(5000);
 
         // check that it did add the event package
         assertUtil.test("PackageHandler addPackage");
@@ -689,6 +730,9 @@ public void testDisable() {
         // and send it
         assertUtil.test("PackageHandler sendFirstPackage");
 
+        // does not fire background timer
+        assertUtil.notInVerbose("Background timer starting");
+
         // it should have the second session and the event
         assertEquals(3, mockPackageHandler.queue.size());
 
@@ -713,25 +757,34 @@ public void testDisable() {
         // test event
         testEventPackage.testEventPackage("event1");
 
+        // end the session
+        stopActivity(activityHandler);
+
+        SystemClock.sleep(1000);
+
+        checkEndSession();
+
         // put in online mode
         activityHandler.setOfflineMode(false);
 
         // message that is finally resuming
-        assertUtil.info("Resuming package handler and attribution handler to put in online mode");
+        assertUtil.info("Resuming package handler and attribution handler to put SDK in online mode");
 
-        SystemClock.sleep(6000);
+        SystemClock.sleep(1000);
 
-        // check status update
-        assertUtil.test("AttributionHandler resumeSending");
-        assertUtil.test("PackageHandler resumeSending");
+        // after un-pausing the sdk, tries to update the handlers
+        // it is still paused because it's on the background
+        checkHandlerStatus(true);
 
-        // track sub session
-        activityHandler.trackSubsessionStart();
+        startActivity(activityHandler);
 
         SystemClock.sleep(1000);
 
-        // test session not paused
-        checkNewSession(false, 3, 1, true);
+        SessionState ThirdSessionStarting = new SessionState(SessionType.NEW_SESSION);
+        ThirdSessionStarting.sessionCount = 3;
+        ThirdSessionStarting.eventCount = 1;
+        ThirdSessionStarting.timerAlreadyStarted = false;
+        checkStartInternal(ThirdSessionStarting);
     }
 
     public void testOpenUrl() {
@@ -739,21 +792,10 @@ public void testOpenUrl() {
         mockLogger.Assert("TestActivityHandler testOpenUrl");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
-
-        // set log level
-        config.setLogLevel(LogLevel.ASSERT);
+        AdjustConfig config = getConfig(LogLevel.ASSERT);
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(3000);
-
-        // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "ASSERT", false);
-
-        // test first session start
-        checkFirstSession();
+        ActivityHandler activityHandler = startAndCheckFirstSession(config, LogLevel.ASSERT);
 
         Uri attributions = Uri.parse("AdjustTests://example.com/path/inApp?adjust_tracker=trackerValue&other=stuff&adjust_campaign=campaignValue&adjust_adgroup=adgroupValue&adjust_creative=creativeValue");
         Uri extraParams = Uri.parse("AdjustTests://example.com/path/inApp?adjust_foo=bar&other=stuff&adjust_key=value");
@@ -780,17 +822,17 @@ public void testOpenUrl() {
         SystemClock.sleep(1000);
 
         // three click packages: attributions, extraParams and mixed
-        for (int i = 3; i > 0; i--) {
-            assertUtil.test("PackageHandler addPackage");
-            assertUtil.test("PackageHandler sendFirstPackage");
+        for (int i = 7; i > 0; i--) {
+            assertUtil.test("SdkClickHandler sendSdkClick");
         }
 
-        // checking the default values of the first session package
-        // 1 session + 3 click
-        assertEquals(4, mockPackageHandler.queue.size());
+        assertUtil.notInTest("SdkClickHandler sendSdkClick");
+
+        // 7 clicks
+        assertEquals(7, mockSdkClickHandler.queue.size());
 
         // get the click package
-        ActivityPackage attributionClickPackage = mockPackageHandler.queue.get(1);
+        ActivityPackage attributionClickPackage = mockSdkClickHandler.queue.get(0);
 
         // create activity package test
         TestActivityPackage testAttributionClickPackage = new TestActivityPackage(attributionClickPackage);
@@ -805,23 +847,27 @@ public void testOpenUrl() {
         // and set it
         testAttributionClickPackage.attribution = firstAttribution;
 
+        testAttributionClickPackage.deeplink = attributions.toString();
+
         // test the first deeplink
         testAttributionClickPackage.testClickPackage("deeplink");
 
         // get the click package
-        ActivityPackage extraParamsClickPackage = mockPackageHandler.queue.get(2);
+        ActivityPackage extraParamsClickPackage = mockSdkClickHandler.queue.get(1);
 
         // create activity package test
         TestActivityPackage testExtraParamsClickPackage = new TestActivityPackage(extraParamsClickPackage);
 
         // other deep link parameters
-        testExtraParamsClickPackage.deepLinkParameters = "{\"key\":\"value\",\"foo\":\"bar\"}";
+        testExtraParamsClickPackage.otherParameters = "{\"key\":\"value\",\"foo\":\"bar\"}";
+
+        testExtraParamsClickPackage.deeplink = extraParams.toString();
 
         // test the second deeplink
         testExtraParamsClickPackage.testClickPackage("deeplink");
 
         // get the click package
-        ActivityPackage mixedClickPackage = mockPackageHandler.queue.get(3);
+        ActivityPackage mixedClickPackage = mockSdkClickHandler.queue.get(2);
 
         // create activity package test
         TestActivityPackage testMixedClickPackage = new TestActivityPackage(mixedClickPackage);
@@ -836,10 +882,52 @@ public void testOpenUrl() {
         testMixedClickPackage.attribution = secondAttribution;
 
         // other deep link parameters
-        testMixedClickPackage.deepLinkParameters = "{\"foo\":\"bar\"}";
+        testMixedClickPackage.otherParameters = "{\"foo\":\"bar\"}";
+
+        testMixedClickPackage.deeplink = mixed.toString();
 
         // test the third deeplink
         testMixedClickPackage.testClickPackage("deeplink");
+
+        // get the click package
+        ActivityPackage emptyQueryStringClickPackage = mockSdkClickHandler.queue.get(3);
+
+        // create activity package test
+        TestActivityPackage testEmptyQueryStringClickPackage = new TestActivityPackage(emptyQueryStringClickPackage);
+
+        testEmptyQueryStringClickPackage.deeplink = emptyQueryString.toString();
+
+        testEmptyQueryStringClickPackage.testClickPackage("deeplink");
+
+        // get the click package
+        ActivityPackage singleClickPackage = mockSdkClickHandler.queue.get(4);
+
+        // create activity package test
+        TestActivityPackage testSingleClickPackage = new TestActivityPackage(singleClickPackage);
+
+        testSingleClickPackage.deeplink = single.toString();
+
+        testSingleClickPackage.testClickPackage("deeplink");
+
+        // get the click package
+        ActivityPackage prefixClickPackage = mockSdkClickHandler.queue.get(5);
+
+        // create activity package test
+        TestActivityPackage testPrefixClickPackage = new TestActivityPackage(prefixClickPackage);
+
+        testPrefixClickPackage.deeplink = prefix.toString();
+
+        testPrefixClickPackage.testClickPackage("deeplink");
+
+        // get the click package
+        ActivityPackage incompleteClickPackage = mockSdkClickHandler.queue.get(6);
+
+        // create activity package test
+        TestActivityPackage testIncompleteClickPackage = new TestActivityPackage(incompleteClickPackage );
+
+        testIncompleteClickPackage.deeplink = incomplete.toString();
+
+        testIncompleteClickPackage.testClickPackage("deeplink");
     }
 
     public void testAttributionDelegate() {
@@ -856,12 +944,9 @@ public void onAttributionChanged(AdjustAttribution attribution) {
             }
         });
 
-        checkFinishTasks(config,
-                true,   // attributionDelegatePresent
-                false,  // eventSuccessDelegatePresent
-                false,  // eventFailureDelegatePresent
-                false,  // sessionSuccessDelegatePresent
-                false); // sessionFailureDelegatePresent
+        DelegatesPresent attributionDelegatePresent = new DelegatesPresent();
+        attributionDelegatePresent.attributionDelegatePresent = true;
+        checkFinishTasks(config, attributionDelegatePresent);
     }
 
     public void testSuccessDelegates() {
@@ -885,12 +970,11 @@ public void onFinishedSessionTrackingSucceeded(AdjustSessionSuccess sessionSucce
             }
         });
 
-        checkFinishTasks(config,
-                false,  // attributionDelegatePresent
-                true,   // eventSuccessDelegatePresent
-                false,  // eventFailureDelegatePresent
-                true,   // sessionSuccessDelegatePresent
-                false); // sessionFailureDelegatePresent
+        DelegatesPresent successDelegatesPresent = new DelegatesPresent();
+        successDelegatesPresent.eventSuccessDelegatePresent = true;
+        successDelegatesPresent.sessionSuccessDelegatePresent = true;
+
+        checkFinishTasks(config, successDelegatesPresent);
     }
 
     public void testFailureDelegates() {
@@ -914,186 +998,138 @@ public void onFinishedSessionTrackingFailed(AdjustSessionFailure failureResponse
             }
         });
 
-        checkFinishTasks(config,
-                false,  // attributionDelegatePresent
-                false,  // eventSuccessDelegatePresent
-                true,   // eventFailureDelegatePresent
-                false,  // sessionSuccessDelegatePresent
-                true);  // sessionFailureDelegatePresent
+        DelegatesPresent failureDelegatesPresent = new DelegatesPresent();
+        failureDelegatesPresent.sessionFailureDelegatePresent = true;
+        failureDelegatesPresent.eventFailureDelegatePresent = true;
+
+        checkFinishTasks(config, failureDelegatesPresent);
     }
 
-    public void checkFinishTasks(AdjustConfig config,
-                                 boolean attributionDelegatePresent,
-                                 boolean eventSuccessDelegatePresent,
-                                 boolean eventFailureDelegatePresent,
-                                 boolean sessionSuccessDelegatePresent,
-                                 boolean sessionFailureDelegatePresent)
-    {
-        ActivityHandler activityHandler = getActivityHandler(config);
+    public void testLaunchDeepLink() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestActivityHandler testLaunchDeepLink");
 
-        activityHandler.trackSubsessionStart();
+        // create the config to start the session
+        AdjustConfig config = getConfig(LogLevel.VERBOSE, AdjustConfig.ENVIRONMENT_PRODUCTION, "123456789012", context);
 
-        SystemClock.sleep(3000);
+        // start activity handler with config
+        ActivityHandler activityHandler = getActivityHandler(config,
+                true, // startEnabled,
+                null, // readActivityState,
+                null, // readAttribution,
+                true, // isProductionEnvironment,
+                LogLevel.VERBOSE); // logLevel
 
-        checkInitAndFirstSession();
+        SystemClock.sleep(2000);
 
-        // test first session package
-        ActivityPackage firstSessionPackage = mockPackageHandler.queue.get(0);
+        checkInitTests(
+                false,  // eventBuffering
+                null,   // defaultTracker
+                false);  // startsSending
 
-        // create activity package test
-        TestActivityPackage testActivityPackage = new TestActivityPackage(firstSessionPackage);
+        startActivity(activityHandler);
 
-        testActivityPackage.needsResponseDetails =
-                attributionDelegatePresent ||
-                eventSuccessDelegatePresent ||
-                eventFailureDelegatePresent ||
-                sessionSuccessDelegatePresent ||
-                sessionFailureDelegatePresent;
+        SystemClock.sleep(2000);
 
-        // set first session
-        testActivityPackage.testSessionPackage(1);
+        // test first session start
+        checkFirstSession();
 
-        // simulate a successful session
-        SessionResponseData successSessionResponseData = (SessionResponseData)ResponseData.buildResponseData(firstSessionPackage);
-        successSessionResponseData.success = true;
+        ResponseData responseDataNull = null;
 
-        activityHandler.finishedTrackingActivity(successSessionResponseData);
+        //activityHandler.finishedTrackingActivity(responseDataNull);
         SystemClock.sleep(1000);
 
-        // attribution handler should always receive the session response
-        assertUtil.test("AttributionHandler checkSessionResponse");
-        // the first session does not trigger the event response delegate
-
-        assertUtil.notInDebug("Launching success event tracking listener");
-        assertUtil.notInDebug("Launching failed event tracking listener");
-
-        activityHandler.launchSessionResponseTasks(successSessionResponseData);
-        SystemClock.sleep(1000);
+        // if the response is null
+        assertUtil.notInTest("AttributionHandler checkAttribution");
+        assertUtil.notInError("Unable to open deep link");
+        assertUtil.notInInfo("Open deep link");
 
-        // if present, the first session triggers the success session delegate
-        if (sessionSuccessDelegatePresent) {
-            assertUtil.debug("Launching success session tracking listener");
-        } else {
-            assertUtil.notInDebug("Launching success session tracking delegate");
+        // set package handler to respond with a valid attribution
+        ResponseData wrongDeeplinkResponseData = ResponseData.buildResponseData(mockPackageHandler.queue.get(0));
+        try {
+            wrongDeeplinkResponseData.jsonResponse = new JSONObject("{ " +
+                    "\"deeplink\" :  \"wrongDeeplink://\" }");
+        } catch (JSONException e) {
+            fail(e.getMessage());
         }
-        // it doesn't trigger the failure session delegate
-        assertUtil.notInDebug("Launching failed session tracking listener");
 
-        // simulate a failure session
-        SessionResponseData failureSessionResponseData = (SessionResponseData)ResponseData.buildResponseData(firstSessionPackage);
-        failureSessionResponseData.success = false;
+        activityHandler.launchSessionResponseTasks((SessionResponseData) wrongDeeplinkResponseData);
+        SystemClock.sleep(2000);
 
-        activityHandler.launchSessionResponseTasks(failureSessionResponseData);
-        SystemClock.sleep(1000);
+        // check that it was unable to open the url
+        assertUtil.error("Unable to open deep link (wrongDeeplink://)");
 
-        // it doesn't trigger the success session delegate
-        assertUtil.notInDebug("Launching success session tracking listener");
+        // TODO add test that opens url
 
-        // if present, the first session triggers the failure session delegate
-        if (sessionFailureDelegatePresent) {
-            assertUtil.debug("Launching failed session tracking listener");
-        } else {
-            assertUtil.notInDebug("Launching failed session tracking listener");
-        }
+        // checking the default values of the first session package
+        // should only have one package
+        assertEquals(1, mockPackageHandler.queue.size());
 
-        // test success event response data
-        activityHandler.trackEvent(new AdjustEvent("abc123"));
-        SystemClock.sleep(1000);
+        ActivityPackage activityPackage = mockPackageHandler.queue.get(0);
 
-        ActivityPackage eventPackage = mockPackageHandler.queue.get(1);
-        EventResponseData eventSuccessResponseData = (EventResponseData)ResponseData.buildResponseData(eventPackage);
-        eventSuccessResponseData.success = true;
+        // create activity package test
+        TestActivityPackage testActivityPackage = new TestActivityPackage(activityPackage);
 
-        activityHandler.finishedTrackingActivity(eventSuccessResponseData);
-        SystemClock.sleep(1000);
+        testActivityPackage.environment = AdjustConfig.ENVIRONMENT_PRODUCTION;
 
-        // attribution handler should never receive the event response
-        assertUtil.notInTest("AttributionHandler checkSessionResponse");
+        // set first session
+        testActivityPackage.testSessionPackage(1);
+    }
 
-        // if present, the success event triggers the success event delegate
-        if (eventSuccessDelegatePresent) {
-            assertUtil.debug("Launching success event tracking listener");
-        } else {
-            assertUtil.notInDebug("Launching success event tracking listener");
-        }
-        // it doesn't trigger the failure event delegate
-        assertUtil.notInDebug("Launching failed event tracking listener");
+    public void testNotLaunchDeeplinkCallback() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestActivityHandler testNotLaunchDeeplinkCallback");
 
-        // test failure event response data
-        EventResponseData eventFailureResponseData = (EventResponseData)ResponseData.buildResponseData(eventPackage);
-        eventFailureResponseData.success = false;
+        // create the config to start the session
+        AdjustConfig config = getConfig();
 
-        activityHandler.finishedTrackingActivity(eventFailureResponseData);
-        SystemClock.sleep(1000);
+        config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
+            @Override
+            public boolean launchReceivedDeeplink(Uri deeplink) {
+                mockLogger.test("launchReceivedDeeplink, " + deeplink);
+                return false;
+            }
+        });
 
-        // attribution handler should never receive the event response
-        assertUtil.notInTest("AttributionHandler checkSessionResponse");
+        // start activity handler with config
+        ActivityHandler activityHandler = startAndCheckFirstSession(config);
 
-        // if present, the failure event triggers the failure event delegate
-        if (eventFailureDelegatePresent) {
-            assertUtil.debug("Launching failed event tracking listener");
-        } else {
-            assertUtil.notInDebug("Launching failed event tracking listener");
-        }
-        // it doesn't trigger the success event delegate
-        assertUtil.notInDebug("Launching success event tracking listener");
-
-        // test click
-        Uri attributions = Uri.parse("AdjustTests://example.com/path/inApp?adjust_tracker=trackerValue&other=stuff&adjust_campaign=campaignValue&adjust_adgroup=adgroupValue&adjust_creative=creativeValue");
-        long now = System.currentTimeMillis();
-
-        activityHandler.readOpenUrl(attributions, now);
-        SystemClock.sleep(1000);
-
-        assertUtil.test("PackageHandler addPackage");
-        assertUtil.test("PackageHandler sendFirstPackage");
+        // set package handler to respond with a valid attribution
+        ResponseData wrongDeeplinkResponseData = ResponseData.buildResponseData(mockPackageHandler.queue.get(0));
+        try {
+            wrongDeeplinkResponseData.jsonResponse = new JSONObject("{ " +
+                    "\"deeplink\" :  \"wrongDeeplink://\" }");
+        } catch (JSONException e) {
+            fail(e.getMessage());
+        }
 
-        // test sdk_click response data
-        ActivityPackage sdkClickPackage = mockPackageHandler.queue.get(2);
-        ClickResponseData clickResponseData = (ClickResponseData)ResponseData.buildResponseData(sdkClickPackage);
+        activityHandler.launchSessionResponseTasks((SessionResponseData) wrongDeeplinkResponseData);
+        SystemClock.sleep(2000);
 
-        activityHandler.finishedTrackingActivity(clickResponseData);
-        SystemClock.sleep(1000);
+        // callback called
+        assertUtil.test("launchReceivedDeeplink, wrongDeeplink://");
 
-        // attribution handler should never receive the click response
-        assertUtil.notInTest("AttributionHandler checkSessionResponse");
-        // it doesn't trigger the any event delegate
-        assertUtil.notInDebug("Launching success event tracking listener");
-        assertUtil.notInDebug("Launching failed event tracking listener");
+        // but deeplink not launched
+        assertUtil.notInError("Unable to open deep link");
     }
 
-    public void testLaunchDeepLink() {
+    public void testDeeplinkCallback() {
         // assert test name to read better in logcat
-        mockLogger.Assert("TestActivityHandler testLaunchDeepLink");
+        mockLogger.Assert("TestActivityHandler testDeeplinkCallback");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_PRODUCTION);
+        AdjustConfig config = getConfig();
 
-        // set verbose log level
-        config.setLogLevel(LogLevel.VERBOSE);
+        config.setOnDeeplinkResponseListener(new OnDeeplinkResponseListener() {
+            @Override
+            public boolean launchReceivedDeeplink(Uri deeplink) {
+                mockLogger.test("launchReceivedDeeplink, " + deeplink);
+                return true;
+            }
+        });
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        activityHandler.trackSubsessionStart();
-
-        SystemClock.sleep(3000);
-
-        // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_PRODUCTION, "ASSERT", false);
-
-        // test first session start
-        checkFirstSession();
-
-        ResponseData responseDataNull = null;
-
-        //activityHandler.finishedTrackingActivity(responseDataNull);
-        SystemClock.sleep(1000);
-
-        // if the response is null
-        assertUtil.notInTest("AttributionHandler checkAttribution");
-        assertUtil.notInError("Unable to open deep link");
-        assertUtil.notInInfo("Open deep link");
+        ActivityHandler activityHandler = startAndCheckFirstSession(config);
 
         // set package handler to respond with a valid attribution
         ResponseData wrongDeeplinkResponseData = ResponseData.buildResponseData(mockPackageHandler.queue.get(0));
@@ -1105,26 +1141,13 @@ public void testLaunchDeepLink() {
         }
 
         activityHandler.launchSessionResponseTasks((SessionResponseData) wrongDeeplinkResponseData);
-        SystemClock.sleep(3000);
-
-        // check that it was unable to open the url
-        assertUtil.error("Unable to open deep link (wrongDeeplink://)");
-
-        // TODO add test that opens url
-
-        // checking the default values of the first session package
-        // should only have one package
-        assertEquals(1, mockPackageHandler.queue.size());
-
-        ActivityPackage activityPackage = mockPackageHandler.queue.get(0);
-
-        // create activity package test
-        TestActivityPackage testActivityPackage = new TestActivityPackage(activityPackage);
+        SystemClock.sleep(2000);
 
-        testActivityPackage.environment = AdjustConfig.ENVIRONMENT_PRODUCTION;
+        // callback called
+        assertUtil.test("launchReceivedDeeplink, wrongDeeplink://");
 
-        // set first session
-        testActivityPackage.testSessionPackage(1);
+        // but deeplink not launched
+        assertUtil.error("Unable to open deep link");
     }
 
     public void testUpdateAttribution() {
@@ -1132,18 +1155,10 @@ public void testUpdateAttribution() {
         mockLogger.Assert("TestActivityHandler testUpdateAttribution");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig();
 
         // start activity handler with config
-        ActivityHandler firstActivityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(3000);
-
-        // test init values
-        checkInitTests();
-
-        // test first session start
-        checkFirstSession();
+        ActivityHandler firstActivityHandler = startAndCheckFirstSession(config);
 
         JSONObject nullJsonObject = null;
         AdjustAttribution nullAttribution = AdjustAttribution.fromJson(nullJsonObject);
@@ -1182,13 +1197,13 @@ public void testUpdateAttribution() {
         assertUtil.notInDebug("Wrote Attribution");
 
         // end session
-        firstActivityHandler.trackSubsessionEnd();
+        firstActivityHandler.onPause();
         SystemClock.sleep(1000);
 
         checkEndSession();
 
         // create the new config
-        config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        config = getConfig();
 
         config.setOnAttributionChangedListener(new OnAttributionChangedListener() {
             @Override
@@ -1197,14 +1212,26 @@ public void onAttributionChanged(AdjustAttribution attribution) {
             }
         });
 
-        ActivityHandler restartActivityHandler = getActivityHandler(config);
+        ActivityHandler restartActivityHandler = getActivityHandler (config,
+                true,               // startEnabled
+                "ec:0 sc:1 ssc:1",  // readActivityState
+                "tt:null tn:null net:null cam:null adg:null cre:null cl:null", // readAttribution
+                false,              // isProductionEnvironment
+                LogLevel.INFO);     // loglevel
 
-        SystemClock.sleep(3000);
+        SystemClock.sleep(2000);
 
         // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "INFO", false, "ec:0 sc:1 ssc:1", "tt:null tn:null net:null cam:null adg:null cre:null cl:null");
+        checkInitTests();
 
-        checkFirstSessionSubsession(2);
+        startActivity(restartActivityHandler);
+
+        SystemClock.sleep(2000);
+
+        SessionState firstRestart = new SessionState(SessionType.NEW_SUBSESSION);
+        firstRestart.subsessionCount = 2;
+        firstRestart.timerAlreadyStarted = false;
+        checkStartInternal(firstRestart);
 
         // check that it does not update the attribution after the restart
         assertUtil.isFalse(restartActivityHandler.updateAttribution(emptyAttribution));
@@ -1247,12 +1274,12 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         assertUtil.notInDebug("Wrote Attribution");
 
         // end session
-        restartActivityHandler.trackSubsessionEnd();
+        restartActivityHandler.onPause();
         SystemClock.sleep(1000);
 
         checkEndSession();
 
-        config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        config = getConfig();
 
         config.setOnAttributionChangedListener(new OnAttributionChangedListener() {
             @Override
@@ -1261,14 +1288,27 @@ public void onAttributionChanged(AdjustAttribution attribution) {
             }
         });
 
-        ActivityHandler secondRestartActivityHandler = getActivityHandler(config);
+        ActivityHandler secondRestartActivityHandler = getActivityHandler(config,
+                true,               // startEnabled
+                "ec:0 sc:1 ssc:2",  // readActivityState
+                "tt:ttValue tn:tnValue net:nValue cam:cpValue adg:aValue cre:ctValue cl:clValue",   // readAttribution
+                false,              // isProductionEnvironment
+                LogLevel.INFO);     // loglevel
 
-        SystemClock.sleep(3000);
+        SystemClock.sleep(2000);
 
         // test init values
-        checkInitTests(AdjustConfig.ENVIRONMENT_SANDBOX, "INFO", false, "ec:0 sc:1 ssc:2", "tt:ttValue tn:tnValue net:nValue cam:cpValue adg:aValue cre:ctValue cl:clValue");
+        checkInitTests();
+
+        startActivity(secondRestartActivityHandler);
+
+        SystemClock.sleep(2000);
+
+        SessionState secondRestart = new SessionState(SessionType.NEW_SUBSESSION);
+        secondRestart.subsessionCount = 3;
+        secondRestart.timerAlreadyStarted = false;
 
-        checkFirstSessionSubsession(3);
+        checkStartInternal(secondRestart);
 
         // check that it does not update the attribution after the restart
         assertUtil.isFalse(secondRestartActivityHandler.updateAttribution(firstAttribution));
@@ -1314,27 +1354,56 @@ public void testOfflineMode() {
         AdjustFactory.setSubsessionInterval(500);
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig();
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
+        ActivityHandler activityHandler = getFirstActivityHandler(config);
 
         // put SDK offline
         activityHandler.setOfflineMode(true);
 
-        SystemClock.sleep(3000);
+        InternalState internalState = activityHandler.getInternalState();
+
+        // check if it's offline before the sdk starts
+        assertUtil.isTrue(internalState.isOffline());
+
+        SystemClock.sleep(2000);
+
+        // not writing activity state because it set enable does not start the sdk
+        assertUtil.notInDebug("Wrote Activity state");
 
         // check if message the disable of the SDK
-        assertUtil.info("Pausing package and attribution handler to put in offline mode");
+        assertUtil.info("Package handler and attribution handler will start paused due to SDK being offline");
 
         // test init values
-        checkInitTests();
+        checkInitTests(false);
+
+        checkHandlerStatus(true);
+
+        // start the sdk
+        // foreground timer does not start because it's paused
+        startActivity(activityHandler);
+
+        SystemClock.sleep(2000);
 
         // test first session start
-        checkFirstSession(true);
+        SessionState firstSessionStartPaused = new SessionState(SessionType.NEW_SESSION);
+        firstSessionStartPaused.paused = true;
+        firstSessionStartPaused.toSend = false;
+        firstSessionStartPaused.foregroundTimerStarts = false;
+        firstSessionStartPaused.foregroundTimerAlreadyStarted = false;
 
-        // test end of session logs
-        checkEndSession();
+        // check session that is paused
+        checkStartInternal(firstSessionStartPaused);
+
+        stopActivity(activityHandler);
+
+        SystemClock.sleep(1000);
+
+        // test end session of disable
+        checkEndSession(true,   //pausing
+                false,   // updateActivityState
+                false); // eventBufferingEnabled
 
         // disable the SDK
         activityHandler.setEnabled(false);
@@ -1346,32 +1415,30 @@ public void testOfflineMode() {
         assertUtil.debug("Wrote Activity state: ec:0 sc:1 ssc:1");
 
         // check if message the disable of the SDK
-        assertUtil.info("Pausing package handler and attribution handler to disable the SDK");
+        assertUtil.info("Pausing package handler and attribution handler due to SDK being disabled");
 
         SystemClock.sleep(1000);
 
-        // test end session logs
-        checkEndSession(false);
+        checkHandlerStatus(true);
 
         // put SDK back online
         activityHandler.setOfflineMode(false);
 
-        assertUtil.info("Package and attribution handler remain paused because the SDK is disabled");
+        assertUtil.info("Package and attribution handler remain paused due to SDK being disabled");
 
         SystemClock.sleep(1000);
 
         // test the update status, still paused
-        assertUtil.notInTest("AttributionHandler pauseSending");
-        assertUtil.notInTest("PackageHandler pauseSending");
+        checkHandlerStatus(null);
 
         // try to do activities while SDK disabled
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         activityHandler.trackEvent(new AdjustEvent("event1"));
 
         SystemClock.sleep(3000);
 
         // check that timer was not executed
-        checkTimerIsFired(false);
+        checkForegroundTimerFired(false);
 
         // check that it did not wrote activity state from new session or subsession
         assertUtil.notInDebug("Wrote Activity state");
@@ -1379,16 +1446,36 @@ public void testOfflineMode() {
         // check that it did not add any package
         assertUtil.notInTest("PackageHandler addPackage");
 
+        // end the session
+        stopActivity(activityHandler);
+
+        SystemClock.sleep(1000);
+
+        checkEndSession(false);
+
         // enable the SDK again
         activityHandler.setEnabled(true);
 
         // check that is enabled
         assertUtil.isTrue(activityHandler.isEnabled());
 
+        assertUtil.debug("Wrote Activity state");
+
+        assertUtil.info("Resuming package handler and attribution handler due to SDK being enabled");
+
+        SystemClock.sleep(1000);
+
+        // it is still paused because it's on the background
+        checkHandlerStatus(true);
+
+        startActivity(activityHandler);
+
         SystemClock.sleep(1000);
 
+        SessionState secondSessionState = new SessionState(SessionType.NEW_SESSION);
+        secondSessionState.sessionCount = 2;
         // test that is not paused anymore
-        checkNewSession(false, 2, 0);
+        checkStartInternal(secondSessionState);
     }
 
     public void testSendReferrer() {
@@ -1396,18 +1483,10 @@ public void testSendReferrer() {
         mockLogger.Assert("TestActivityHandler testSendReferrer");
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig();
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(3000);
-
-        // test init values
-        checkInitTests();
-
-        // test first session start
-        checkFirstSession();
+        ActivityHandler activityHandler = startAndCheckFirstSession(config);
 
         long now = System.currentTimeMillis();
 
@@ -1437,21 +1516,18 @@ public void testSendReferrer() {
         activityHandler.sendReferrer(incomplete, now);
         SystemClock.sleep(1000);
 
-        // three click packages: reftag, extraParams and mixed
-        for (int i = 3; i > 0; i--) {
-            //assertUtil.test("AttributionHandler getAttribution");
-            assertUtil.test("PackageHandler addPackage");
-            assertUtil.test("PackageHandler sendFirstPackage");
+        // three click packages: reftag, extraParams, mixed, empty, single, prefix and incomplete
+        for (int i = 6; i > 0; i--) {
+            assertUtil.test("SdkClickHandler sendSdkClick");
         }
 
         // check that it did not send any other click package
-        assertUtil.notInTest("PackageHandler sendClickPackage");
+        assertUtil.notInTest("SdkClickHandler sendSdkClick");
 
-        // checking the default values of the first session package
-        // 1 session + 3 click
-        assertEquals(4, mockPackageHandler.queue.size());
+        // 6 click
+        assertEquals(6, mockSdkClickHandler.queue.size());
 
-        ActivityPackage reftagClickPackage = mockPackageHandler.queue.get(1);
+        ActivityPackage reftagClickPackage = mockSdkClickHandler.queue.get(0);
 
         TestActivityPackage reftagClickPackageTest = new TestActivityPackage(reftagClickPackage);
 
@@ -1461,13 +1537,13 @@ public void testSendReferrer() {
         reftagClickPackageTest.testClickPackage("reftag");
 
         // get the click package
-        ActivityPackage extraParamsClickPackage = mockPackageHandler.queue.get(2);
+        ActivityPackage extraParamsClickPackage = mockSdkClickHandler.queue.get(1);
 
         // create activity package test
         TestActivityPackage testExtraParamsClickPackage = new TestActivityPackage(extraParamsClickPackage);
 
         // other deep link parameters
-        testExtraParamsClickPackage.deepLinkParameters = "{\"key\":\"value\",\"foo\":\"bar\"}";
+        testExtraParamsClickPackage.otherParameters = "{\"key\":\"value\",\"foo\":\"bar\"}";
 
         testExtraParamsClickPackage.referrer = extraParams;
 
@@ -1475,7 +1551,7 @@ public void testSendReferrer() {
         testExtraParamsClickPackage.testClickPackage("reftag");
 
         // get the click package
-        ActivityPackage mixedClickPackage = mockPackageHandler.queue.get(3);
+        ActivityPackage mixedClickPackage = mockSdkClickHandler.queue.get(2);
 
         // create activity package test
         TestActivityPackage testMixedClickPackage = new TestActivityPackage(mixedClickPackage);
@@ -1484,10 +1560,40 @@ public void testSendReferrer() {
         testMixedClickPackage.referrer = mixed;
 
         // other deep link parameters
-        testMixedClickPackage.deepLinkParameters = "{\"foo\":\"bar\"}";
+        testMixedClickPackage.otherParameters = "{\"foo\":\"bar\"}";
 
         // test the third deeplink
         testMixedClickPackage.testClickPackage("reftag");
+
+        // get the click package
+        ActivityPackage singleClickPackage = mockSdkClickHandler.queue.get(3);
+
+        // create activity package test
+        TestActivityPackage testSingleClickPackage = new TestActivityPackage(singleClickPackage);
+
+        testSingleClickPackage.referrer = single;
+
+        testSingleClickPackage.testClickPackage("reftag");
+
+        // get the click package
+        ActivityPackage prefixClickPackage = mockSdkClickHandler.queue.get(4);
+
+        // create activity package test
+        TestActivityPackage testPrefixClickPackage = new TestActivityPackage(prefixClickPackage);
+
+        testPrefixClickPackage.referrer = prefix;
+
+        testPrefixClickPackage.testClickPackage("reftag");
+
+        // get the click package
+        ActivityPackage incompleteClickPackage = mockSdkClickHandler.queue.get(5);
+
+        // create activity package test
+        TestActivityPackage testIncompleteClickPackage = new TestActivityPackage(incompleteClickPackage);
+
+        testIncompleteClickPackage.referrer = incomplete;
+
+        testIncompleteClickPackage.testClickPackage("reftag");
     }
 
     public void testGetAttribution() {
@@ -1496,16 +1602,15 @@ public void testGetAttribution() {
 
         //AdjustFactory.setTimerStart(500);
         AdjustFactory.setSessionInterval(4000);
-        /***
-         * if (activityState.subsessionCount > 1) {
-         *     if (attribution == null || activityState.askingAttribution) {
-         *         getAttributionHandler().getAttribution();
-         *     }
-         * }
-         */
+
+        /// if (activityState.subsessionCount > 1) {
+        ///     if (attribution == null || activityState.askingAttribution) {
+        ///         getAttributionHandler().getAttribution();
+        ///     }
+        /// }
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig();
 
         config.setOnAttributionChangedListener(new OnAttributionChangedListener() {
             @Override
@@ -1515,23 +1620,26 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         });
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
+        ActivityHandler activityHandler = getFirstActivityHandler(config);
 
-        SystemClock.sleep(3000);
+        SystemClock.sleep(2000);
 
         // test init values
         checkInitTests();
 
+        startActivity(activityHandler);
+
+        SystemClock.sleep(2000);
+
         // subsession count is 1
         // attribution is null,
         // askingAttribution is false by default,
         // -> Not called
 
         // test first session start
-        checkFirstSession();
-
-        // test that get attribution wasn't called
-        assertUtil.notInTest("AttributionHandler getAttribution");
+        SessionState newSessionState = new SessionState(SessionType.NEW_SESSION);
+        newSessionState.getAttributionIsCalled = false;
+        checkStartInternal(newSessionState);
 
         // subsession count increased to 2
         // attribution is still null,
@@ -1539,10 +1647,10 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         // -> Called
 
         // trigger a new sub session
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(1, 2, true, true);
+        checkSubSession(1, 2, true);
 
         // subsession count increased to 3
         // attribution is still null,
@@ -1554,10 +1662,10 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         assertUtil.debug("Wrote Activity state: ec:0 sc:1 ssc:2");
 
         // trigger a new session
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(1, 3, true, true);
+        checkSubSession(1, 3, true);
 
         // subsession is reset to 1 with new session
         // attribution is still null,
@@ -1565,10 +1673,10 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         // -> Not called
 
         SystemClock.sleep(3000); // 5 seconds = 2 + 3
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(2, 1, true, false);
+        checkFurtherSessions(2, false);
 
         // subsession count increased to 2
         // attribution is set,
@@ -1598,20 +1706,20 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         assertUtil.debug("Wrote Attribution: tt:ttValue tn:tnValue net:nValue cam:cpValue adg:aValue cre:ctValue cl:clValue");
 
         // trigger a new sub session
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(2, 2, true, true);
+        checkSubSession(2, 2, true);
         // subsession count is reset to 1
         // attribution is set,
         // askingAttribution is set to true,
         // -> Not called
 
         SystemClock.sleep(3000); // 5 seconds = 2 + 3
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(3, 1, true, false);
+        checkFurtherSessions(3, false);
         // subsession increased to 2
         // attribution is set,
         // askingAttribution is set to false
@@ -1621,10 +1729,10 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         assertUtil.debug("Wrote Activity state: ec:0 sc:3 ssc:1");
 
         // trigger a new sub session
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(3, 2, true, false);
+        checkSubSession(3, 2, false);
 
         // subsession is reset to 1
         // attribution is set,
@@ -1632,207 +1740,519 @@ public void onAttributionChanged(AdjustAttribution attribution) {
         // -> Not called
 
         SystemClock.sleep(3000); // 5 seconds = 2 + 3
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(2000);
 
-        checkSubsession(4, 1, true, false);
+        checkFurtherSessions(4, false);
     }
 
-    public void testTimer() {
+    public void testForegroundTimer() {
         // assert test name to read better in logcat
-        mockLogger.Assert("TestActivityHandler testTimer");
+        mockLogger.Assert("TestActivityHandler testForegroundTimer");
 
         AdjustFactory.setTimerInterval(4000);
-        AdjustFactory.setTimerStart(0);
+        AdjustFactory.setTimerStart(4000);
 
         // create the config to start the session
-        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+        AdjustConfig config = getConfig();
 
         // start activity handler with config
-        ActivityHandler activityHandler = getActivityHandler(config);
-
-        SystemClock.sleep(2000);
-
-        // test init values
-        checkInitTests();
-
-        // test first session start
-        checkFirstSession();
+        ActivityHandler activityHandler = startAndCheckFirstSession(config);
 
         // wait enough to fire the first cycle
         SystemClock.sleep(3000);
 
-        checkTimerIsFired(true);
+        checkForegroundTimerFired(true);
 
         // end subsession to stop timer
-        activityHandler.trackSubsessionEnd();
+        activityHandler.onPause();
 
         // wait enough for a new cycle
         SystemClock.sleep(6000);
 
-        activityHandler.trackSubsessionStart();
+        // start a new session
+        activityHandler.onResume();
 
         SystemClock.sleep(1000);
 
-        checkTimerIsFired(false);
+        // check that not enough time passed to fire again
+        checkForegroundTimerFired(false);
     }
 
-    private void checkFirstSessionSubsession(int subsessionCount) {
-        checkSubsession(1, subsessionCount);
-    }
-
-    private void checkSubsession(int sessionCount,
-                                 int subsessionCount,
-                                 boolean timerAlreadyStarted,
-                                 boolean getAttributionIsCalled) {
-        checkSubsession(sessionCount, subsessionCount);
-
-        if (getAttributionIsCalled) {
-            assertUtil.test("AttributionHandler getAttribution");
-        } else {
-            assertUtil.notInTest("AttributionHandler getAttribution");
-        }
+    public void testSendBackground() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestActivityHandler testSendBackground");
 
-        checkTimerIsFired(!timerAlreadyStarted);
-    }
+        AdjustFactory.setTimerInterval(4000);
 
-    private void checkSubsession(int sessionCount, int subsessionCount, boolean timerAlreadyStarted) {
-        checkSubsession(sessionCount, subsessionCount);
+        // create the config to start the session
+        AdjustConfig config = getConfig();
 
-        checkTimerIsFired(!timerAlreadyStarted);
-    }
+        // enable send in the background
+        config.setSendInBackground(true);
 
-    private void checkSubsession(int sessionCount, int subsessionCount) {
-        // test the new sub session
-        assertUtil.test("PackageHandler resumeSending");
+        // create activity handler without starting
+        ActivityHandler activityHandler = getActivityHandler(config,
+                                            true,           // startEnabled
+                                            null,           // readActivityState
+                                            null,           // readAttribution
+                                            false,          // isProductionEnvironment
+                                            LogLevel.INFO); // logLevel
 
-        // save activity state
-        assertUtil.debug("Wrote Activity state: ec:0 sc:" + sessionCount + " ssc:" + subsessionCount);
+        SystemClock.sleep(2000);
 
-        if (subsessionCount > 1) {
-            // test the subsession message
-            assertUtil.info("Started subsession " + subsessionCount + " of session " + sessionCount);
-        } else {
-            // test the subsession message
-            assertUtil.notInInfo("Started subsession ");
-        }
-    }
+        // handlers start sending
+        checkInitTests(
+                false,   // eventBuffering
+                null,   // defaultTracker
+                true);  // startsSending
 
-    private void checkInitTests() {
-        checkInitTests("sandbox", "INFO", false, null, null);
-    }
+        startActivity(activityHandler);
 
-    private void checkInitTests(String environment, String logLevel, boolean eventBuffering) {
-        checkInitTests(environment, logLevel, eventBuffering, null, null);
-    }
+        SystemClock.sleep(2000);
 
-    private void checkInitTests(String environment, String logLevel, boolean eventBuffering,
-                                String readActivityState, String readAttribution) {
-        // check environment level
-        if (environment == "sandbox") {
-            assertUtil.Assert("SANDBOX: Adjust is running in Sandbox mode. Use this setting for testing. Don't forget to set the environment to `production` before publishing!");
-        } else if (environment == "production") {
-            assertUtil.Assert("PRODUCTION: Adjust is running in Production mode. Use this setting only for the build that you want to publish. Set the environment to `sandbox` if you want to test your app!");
-        } else {
-            fail();
-        }
+        // test session
+        checkFirstSession();
 
-        // check log level
-        assertUtil.test("MockLogger setLogLevel: " + logLevel);
+        // end subsession
+        // background timer starts
+        stopActivity(activityHandler);
 
-        // check event buffering
-        if (eventBuffering) {
-            assertUtil.info("Event buffering is enabled");
-        } else {
-            assertUtil.notInInfo("Event buffering is enabled");
-        }
+        SystemClock.sleep(1000);
 
-        // check Google play is not set
-        assertUtil.info("Unable to get Google Play Services Advertising ID at start time");
+        // session end does not pause the handlers
+        checkEndSession(false,   //pausing
+                true,   // updateActivityState
+                false,  // eventBufferingEnabled
+                true,   // checkOnPause,
+                false,  // forgroundAlreadySuspended
+                true);  // backgroundTimerStarts
 
-        checkReadFiles(readActivityState, readAttribution);
-    }
+        // end subsession again
+        // to test if background timer starts again
+        stopActivity(activityHandler);
 
-    private void checkReadFiles(String readActivityState, String readAttribution) {
-        if (readAttribution == null) {
-            //  test that the attribution file did not exist in the first run of the application
-            assertUtil.verbose("Attribution file not found");
-        } else {
-            assertUtil.debug("Read Attribution: " + readAttribution);
-        }
+        SystemClock.sleep(1000);
 
-        if (readActivityState == null) {
-            //  test that the activity state file did not exist in the first run of the application
-            assertUtil.verbose("Activity state file not found");
-        } else {
-            assertUtil.debug("Read Activity state: " + readActivityState);
-        }
-    }
+        // session end does not pause the handlers
+        checkEndSession(false,   //pausing
+                true,   // updateActivityState
+                false,  // eventBufferingEnabled
+                true,   // checkOnPause,
+                true,   // forgroundAlreadySuspended
+                false); // backgroundTimerStarts
 
-    private void checkFirstSession() {
-        checkFirstSession(false);
-    }
+        // wait for background timer launch
+        SystemClock.sleep(3000);
 
-    private void checkFirstSession(boolean paused) {
-        if (paused) {
-            assertUtil.test("PackageHandler init, startPaused: true");
-        } else {
-            assertUtil.test("PackageHandler init, startPaused: false");
-        }
+        // background timer fired
+        assertUtil.test("PackageHandler sendFirstPackage");
 
-        checkNewSession(paused, 1, 0, false);
-    }
+        // wait enough time
+        SystemClock.sleep(3000);
 
-    private void checkNewSession(boolean paused,
-                                 int sessionCount,
-                                 int eventCount) {
-        checkNewSession(paused, sessionCount, eventCount, false);
-    }
+        // check that background timer does not fire again
+        assertUtil.notInTest("PackageHandler sendFirstPackage");
 
-    private void checkNewSession(boolean paused,
-                                 int sessionCount,
-                                 int eventCount,
-                                 boolean timerAlreadyStarted)
-    {
-        // when a session package is being sent the attribution handler should resume sending
-        if (paused) {
-            assertUtil.test("AttributionHandler pauseSending");
-        } else {
-            assertUtil.test("AttributionHandler resumeSending");
-        }
+        activityHandler.trackEvent(new AdjustEvent("abc123"));
 
-        // when a session package is being sent the package handler should resume sending
-        if (paused) {
-            assertUtil.test("PackageHandler pauseSending");
-        } else {
-            assertUtil.test("PackageHandler resumeSending");
-        }
+        SystemClock.sleep(1000);
 
-        // if the package was build, it was sent to the Package Handler
+        // check that event package was added
         assertUtil.test("PackageHandler addPackage");
 
-        // after adding, the activity handler ping the Package handler to send the package
+        // check that event was sent to package handler
         assertUtil.test("PackageHandler sendFirstPackage");
 
-        // after sending a package saves the activity state
-        assertUtil.debug("Wrote Activity state: " +
-                "ec:" + eventCount + " sc:" + sessionCount + " ssc:1" );
+        // and not buffered
+        assertUtil.notInInfo("Buffered event");
 
-        checkTimerIsFired(!(paused || timerAlreadyStarted));
-    }
+        // does fire background timer
+        assertUtil.verbose("Background timer starting. Launching in 4.0 seconds");
 
-    private void checkInitAndFirstSession() {
-        checkInitTests();
-        checkFirstSession();
-    }
+        // after tracking the event it should write the activity state
+        assertUtil.debug("Wrote Activity state");
 
-    private void checkTimerIsFired(boolean timerFired) {
-        // timer fired
-        if (timerFired) {
-            assertUtil.debug("Session timer fired");
-        } else {
-            assertUtil.notInDebug("Session timer fired");
-        }
+        // disable and enable the sdk while in the background
+        activityHandler.setEnabled(false);
+
+        // check that it is disabled
+        assertUtil.isFalse(activityHandler.isEnabled());
+
+        // check if message the disable of the SDK
+        assertUtil.info("Pausing package handler and attribution handler due to SDK being disabled");
+
+        SystemClock.sleep(1000);
+
+        // handlers being paused because of the disable
+        checkHandlerStatus(true);
+
+        activityHandler.setEnabled(true);
+
+        // check that it is enabled
+        assertUtil.isTrue(activityHandler.isEnabled());
+
+        // check if message the enable of the SDK
+        assertUtil.info("Resuming package handler and attribution handler due to SDK being enabled");
+
+        SystemClock.sleep(1000);
+
+        // handlers being resumed because of the enable
+        // even in the background because of the sendInBackground option
+        checkHandlerStatus(false);
+
+        // set offline and online the sdk while in the background
+        activityHandler.setOfflineMode(true);
+
+        InternalState internalState = activityHandler.getInternalState();
+
+        // check that it is offline
+        assertUtil.isTrue(internalState.isOffline());
+
+        // check if message the offline of the SDK
+        assertUtil.info("Pausing package and attribution handler to put SDK offline mode");
+
+        SystemClock.sleep(1000);
+
+        // handlers being paused because of the offline
+        checkHandlerStatus(true);
+
+        activityHandler.setOfflineMode(false);
+
+        // check that it is online
+        assertUtil.isTrue(internalState.isOnline());
+
+        // check if message the online of the SDK
+        assertUtil.info("Resuming package handler and attribution handler to put SDK in online mode");
+
+        SystemClock.sleep(1000);
+
+        // handlers being resumed because of the online
+        // even in the background because of the sendInBackground option
+        checkHandlerStatus(false);
+    }
+
+    public void checkFinishTasks(AdjustConfig config,
+                                 DelegatesPresent delegatesPresent)
+    {
+        ActivityHandler activityHandler = startAndCheckFirstSession(config);
+
+        // test first session package
+        ActivityPackage firstSessionPackage = mockPackageHandler.queue.get(0);
+
+        // create activity package test
+        TestActivityPackage testActivityPackage = new TestActivityPackage(firstSessionPackage);
+
+        testActivityPackage.needsResponseDetails =
+                delegatesPresent.attributionDelegatePresent ||
+                        delegatesPresent.eventSuccessDelegatePresent ||
+                        delegatesPresent.eventFailureDelegatePresent ||
+                        delegatesPresent.sessionSuccessDelegatePresent ||
+                        delegatesPresent.sessionFailureDelegatePresent;
+
+        // set first session
+        testActivityPackage.testSessionPackage(1);
+
+        // simulate a successful session
+        SessionResponseData successSessionResponseData = (SessionResponseData) ResponseData.buildResponseData(firstSessionPackage);
+        successSessionResponseData.success = true;
+
+        activityHandler.finishedTrackingActivity(successSessionResponseData);
+        SystemClock.sleep(1000);
+
+        // attribution handler should always receive the session response
+        assertUtil.test("AttributionHandler checkSessionResponse");
+        // the first session does not trigger the event response delegate
+
+        assertUtil.notInDebug("Launching success event tracking listener");
+        assertUtil.notInDebug("Launching failed event tracking listener");
+
+        activityHandler.launchSessionResponseTasks(successSessionResponseData);
+        SystemClock.sleep(1000);
+
+        // if present, the first session triggers the success session delegate
+        if (delegatesPresent.sessionSuccessDelegatePresent) {
+            assertUtil.debug("Launching success session tracking listener");
+        } else {
+            assertUtil.notInDebug("Launching success session tracking delegate");
+        }
+        // it doesn't trigger the failure session delegate
+        assertUtil.notInDebug("Launching failed session tracking listener");
+
+        // simulate a failure session
+        SessionResponseData failureSessionResponseData = (SessionResponseData)ResponseData.buildResponseData(firstSessionPackage);
+        failureSessionResponseData.success = false;
+
+        activityHandler.launchSessionResponseTasks(failureSessionResponseData);
+        SystemClock.sleep(1000);
+
+        // it doesn't trigger the success session delegate
+        assertUtil.notInDebug("Launching success session tracking listener");
+
+        // if present, the first session triggers the failure session delegate
+        if (delegatesPresent.sessionFailureDelegatePresent) {
+            assertUtil.debug("Launching failed session tracking listener");
+        } else {
+            assertUtil.notInDebug("Launching failed session tracking listener");
+        }
+
+        // test success event response data
+        activityHandler.trackEvent(new AdjustEvent("abc123"));
+        SystemClock.sleep(1000);
+
+        ActivityPackage eventPackage = mockPackageHandler.queue.get(1);
+        EventResponseData eventSuccessResponseData = (EventResponseData)ResponseData.buildResponseData(eventPackage);
+        eventSuccessResponseData.success = true;
+
+        activityHandler.finishedTrackingActivity(eventSuccessResponseData);
+        SystemClock.sleep(1000);
+
+        // attribution handler should never receive the event response
+        assertUtil.notInTest("AttributionHandler checkSessionResponse");
+
+        // if present, the success event triggers the success event delegate
+        if (delegatesPresent.eventSuccessDelegatePresent) {
+            assertUtil.debug("Launching success event tracking listener");
+        } else {
+            assertUtil.notInDebug("Launching success event tracking listener");
+        }
+        // it doesn't trigger the failure event delegate
+        assertUtil.notInDebug("Launching failed event tracking listener");
+
+        // test failure event response data
+        EventResponseData eventFailureResponseData = (EventResponseData)ResponseData.buildResponseData(eventPackage);
+        eventFailureResponseData.success = false;
+
+        activityHandler.finishedTrackingActivity(eventFailureResponseData);
+        SystemClock.sleep(1000);
+
+        // attribution handler should never receive the event response
+        assertUtil.notInTest("AttributionHandler checkSessionResponse");
+
+        // if present, the failure event triggers the failure event delegate
+        if (delegatesPresent.eventFailureDelegatePresent) {
+            assertUtil.debug("Launching failed event tracking listener");
+        } else {
+            assertUtil.notInDebug("Launching failed event tracking listener");
+        }
+        // it doesn't trigger the success event delegate
+        assertUtil.notInDebug("Launching success event tracking listener");
+
+        // test click
+        Uri attributions = Uri.parse("AdjustTests://example.com/path/inApp?adjust_tracker=trackerValue&other=stuff&adjust_campaign=campaignValue&adjust_adgroup=adgroupValue&adjust_creative=creativeValue");
+        long now = System.currentTimeMillis();
+
+        activityHandler.readOpenUrl(attributions, now);
+        SystemClock.sleep(1000);
+
+        assertUtil.test("PackageHandler addPackage");
+        assertUtil.test("PackageHandler sendFirstPackage");
+
+        // test sdk_click response data
+        ActivityPackage sdkClickPackage = mockSdkClickHandler.queue.get(0);
+        ClickResponseData clickResponseData = (ClickResponseData)ResponseData.buildResponseData(sdkClickPackage);
+
+        activityHandler.finishedTrackingActivity(clickResponseData);
+        SystemClock.sleep(1000);
+
+        // attribution handler should never receive the click response
+        assertUtil.notInTest("AttributionHandler checkSessionResponse");
+        // it doesn't trigger the any event delegate
+        assertUtil.notInDebug("Launching success event tracking listener");
+        assertUtil.notInDebug("Launching failed event tracking listener");
+    }
+
+    private class DelegatesPresent {
+        boolean attributionDelegatePresent;
+        boolean eventSuccessDelegatePresent;
+        boolean eventFailureDelegatePresent;
+        boolean sessionSuccessDelegatePresent;
+        boolean sessionFailureDelegatePresent;
+    }
+
+    private class SessionState {
+        boolean toSend = true;
+        boolean paused = false;
+        int sessionCount = 1;
+        int subsessionCount = 1;
+        SessionType sessionType = null;
+        int eventCount = 0;
+        Boolean getAttributionIsCalled = null;
+        Boolean timerAlreadyStarted = false;
+        boolean eventBufferingIsEnabled = false;
+        boolean foregroundTimerStarts = true;
+        boolean foregroundTimerAlreadyStarted = false;
+
+        SessionState(SessionType sessionType) {
+            switch (sessionType) {
+                case NEW_SUBSESSION:
+                case NONSESSION:
+                    timerAlreadyStarted = true;
+                    break;
+            }
+            this.sessionType = sessionType;
+        }
+    }
+
+    private enum SessionType {
+        NEW_SESSION,
+        NEW_SUBSESSION,
+        TIME_TRAVEL,
+        NONSESSION;
+    }
+
+    private void checkFirstSession() {
+        SessionState newSessionState = new SessionState(SessionType.NEW_SESSION);
+        checkStartInternal(newSessionState);
+    }
+
+    private void checkSubSession(int sessionCount, int subsessionCount, boolean getAttributionIsCalled) {
+        SessionState subSessionState = new SessionState(SessionType.NEW_SUBSESSION);
+        subSessionState.sessionCount = sessionCount;
+        subSessionState.subsessionCount = subsessionCount;
+        subSessionState.getAttributionIsCalled = getAttributionIsCalled;
+        subSessionState.foregroundTimerAlreadyStarted = true;
+        checkStartInternal(subSessionState);
+    }
+
+    private void checkFurtherSessions(int sessionCount, boolean getAttributionIsCalled) {
+        SessionState subSessionState = new SessionState(SessionType.NEW_SESSION);
+        subSessionState.sessionCount = sessionCount;
+        subSessionState.timerAlreadyStarted = true;
+        subSessionState.getAttributionIsCalled = getAttributionIsCalled;
+        subSessionState.foregroundTimerAlreadyStarted = true;
+        checkStartInternal(subSessionState);
+    }
+
+    private void checkStartDisable() {
+        assertUtil.notInTest("AttributionHandler resumeSending");
+        assertUtil.notInTest("PackageHandler resumeSending");
+        assertUtil.notInTest("SdkClickHandler resumeSending");
+        assertUtil.notInTest("AttributionHandler pauseSending");
+        assertUtil.notInTest("PackageHandler pauseSending");
+        assertUtil.notInTest("SdkClickHandler pauseSending");
+        assertUtil.notInTest("PackageHandler addPackage");
+        assertUtil.notInTest("PackageHandler sendFirstPackage");
+        assertUtil.notInVerbose("Started subsession");
+        assertUtil.notInVerbose("Time span since last activity too short for a new subsession");
+        assertUtil.notInError("Time travel!");
+        assertUtil.notInDebug("Wrote Activity state: ");
+        assertUtil.notInTest("AttributionHandler getAttribution");
+        checkForegroundTimerFired(false);
+    }
+
+    private void checkStartInternal(SessionState sessionState)
+    {
+        // check onResume
+        checkOnResume(sessionState);
+
+        // update Handlers Status
+        checkHandlerStatus(!sessionState.toSend, sessionState.eventBufferingIsEnabled);
+
+        // process Session
+        switch (sessionState.sessionType) {
+            case NEW_SESSION:
+                // if the package was build, it was sent to the Package Handler
+                assertUtil.test("PackageHandler addPackage");
+
+                // after adding, the activity handler ping the Package handler to send the package
+                assertUtil.test("PackageHandler sendFirstPackage");
+                break;
+            case NEW_SUBSESSION:
+                // test the subsession message
+                assertUtil.verbose("Started subsession " + sessionState.subsessionCount + " of session " + sessionState.sessionCount);
+                break;
+            case NONSESSION:
+                // stopped for a short time, not enough for a new sub subsession
+                assertUtil.verbose("Time span since last activity too short for a new subsession");
+                break;
+            case TIME_TRAVEL:
+                assertUtil.error("Time travel!");
+                break;
+        }
+
+        // after processing the session, writes the activity state
+        if (sessionState.sessionType != SessionType.NONSESSION) {
+            assertUtil.debug("Wrote Activity state: " +
+                    "ec:" + sessionState.eventCount + " sc:" + sessionState.sessionCount + " ssc:" + sessionState.subsessionCount);
+        }
+        // check Attribution State
+        if (sessionState.getAttributionIsCalled != null) {
+            if (sessionState.getAttributionIsCalled) {
+                assertUtil.test("AttributionHandler getAttribution");
+            } else {
+                assertUtil.notInTest("AttributionHandler getAttribution");
+            }
+        }
+
+        /*
+        // start Foreground Timer
+        if (sessionState.paused) {
+            // foreground timer doesn't start when it's paused
+            assertUtil.notInDebug("Foreground timer started");
+            checkForegroundTimerFired(false);
+        } else if (sessionState.timerAlreadyStarted != null) {
+            checkForegroundTimerFired(!sessionState.timerAlreadyStarted);
+        }
+        */
+    }
+/*
+    private void checkInitAndFirstSession() {
+        SessionState newSessionState = new SessionState(SessionType.NEW_SESSION);
+        checkInitAndFirstSession(newSessionState);
+    }
+
+    private void checkInitAndFirstSession(SessionState sessionState) {
+        checkInitTests(sessionState.toSend);
+        checkStartInternal(sessionState);
+    }
+*/
+    private void checkForegroundTimerFired(boolean timerFired) {
+        // timer fired
+        if (timerFired) {
+            assertUtil.verbose("Foreground timer fired");
+        } else {
+            assertUtil.notInVerbose("Foreground timer fired");
+        }
+    }
+
+    private void checkInitTests() {
+        checkInitTests(false);
+    }
+
+    private void checkInitTests(boolean startsSending) {
+        checkInitTests(false, null, startsSending);
+    }
+
+
+    private void checkInitTests(boolean eventBuffering,
+                                String defaultTracker,
+                                boolean startsSending)
+    {
+        // check event buffering
+        if (eventBuffering) {
+            assertUtil.info("Event buffering is enabled");
+        } else {
+            assertUtil.notInInfo("Event buffering is enabled");
+        }
+
+        // check Google play is not set
+        assertUtil.info("Google Play Services Advertising ID read correctly at start time");
+
+        // check default tracker
+        if (defaultTracker != null) {
+            assertUtil.info("Default tracker: '%s'", defaultTracker);
+        }
+
+        if (startsSending) {
+            assertUtil.test("PackageHandler init, startsSending: true");
+            assertUtil.test("AttributionHandler init, startsSending: true");
+            assertUtil.test("SdkClickHandler init, startsSending: true");
+        } else {
+            assertUtil.test("PackageHandler init, startsSending: false");
+            assertUtil.test("AttributionHandler init, startsSending: false");
+            assertUtil.test("SdkClickHandler init, startsSending: false");
+        }
     }
 
     private void checkEndSession() {
@@ -1840,22 +2260,235 @@ private void checkEndSession() {
     }
 
     private void checkEndSession(boolean updateActivityState) {
-        assertUtil.test("PackageHandler pauseSending");
+        checkEndSession(true, updateActivityState, false, false, false, false);
+    }
 
-        assertUtil.test("AttributionHandler pauseSending");
+    private void checkEndSession(boolean pausing,
+                                 boolean updateActivityState,
+                                 boolean eventBufferingEnabled) {
+        checkEndSession(pausing, updateActivityState, eventBufferingEnabled, false, false, false);
+    }
+
+    private void checkEndSession(boolean pausing,
+                                 boolean updateActivityState,
+                                 boolean eventBufferingEnabled,
+                                 boolean checkOnPause,
+                                 boolean forgroundAlreadySuspended,
+                                 boolean backgroundTimerStarts)
+    {
+        if (checkOnPause) {
+            checkOnPause(forgroundAlreadySuspended, backgroundTimerStarts);
+        }
+
+        if (pausing) {
+            checkHandlerStatus(true, eventBufferingEnabled);
+        }
 
         if (updateActivityState) {
             assertUtil.debug("Wrote Activity state: ");
+        } else {
+            assertUtil.notInDebug("Wrote Activity state: ");
         }
     }
 
-    private ActivityHandler getActivityHandler(AdjustConfig config) {
+
+    private AdjustConfig getConfig() {
+        return getConfig(null);
+    }
+
+    private AdjustConfig getConfig(LogLevel logLevel) {
+        return getConfig(logLevel, "sandbox", "123456789012", context);
+    }
+
+    private AdjustConfig getConfig(LogLevel logLevel,
+                                   String environment,
+                                   String appToken,
+                                   Context context)
+    {
+        AdjustConfig adjustConfig = new AdjustConfig(context, appToken, environment);
+
+        if (adjustConfig != null) {
+            if (environment == "sandbox") {
+                assertUtil.Assert("SANDBOX: Adjust is running in Sandbox mode. Use this setting for testing. Don't forget to set the environment to `production` before publishing!");
+            } else if (environment == "production") {
+                assertUtil.Assert("PRODUCTION: Adjust is running in Production mode. Use this setting only for the build that you want to publish. Set the environment to `sandbox` if you want to test your app!");
+            } else {
+                fail();
+            }
+
+            if (logLevel != null) {
+                adjustConfig.setLogLevel(logLevel);
+            }
+        }
+
+        return adjustConfig;
+    }
+
+    private ActivityHandler getFirstActivityHandler(AdjustConfig config) {
+        return getActivityHandler(config, true, null, null, false, LogLevel.INFO);
+    }
+
+    private ActivityHandler getFirstActivityHandler(AdjustConfig config,
+                                                    LogLevel logLevel) {
+        return getActivityHandler(config, true, null, null, false, logLevel);
+    }
+
+    private ActivityHandler getActivityHandler(AdjustConfig config,
+                                               boolean startEnabled,
+                                               String readActivityState,
+                                               String readAttribution,
+                                               boolean isProductionEnvironment,
+                                               LogLevel logLevel) {
         ActivityHandler activityHandler = ActivityHandler.getInstance(config);
 
         if (activityHandler != null) {
-            activityHandler.trackSubsessionStart();
+            // check log level
+            if (isProductionEnvironment) {
+                assertUtil.test("MockLogger setLogLevel: " + LogLevel.ASSERT);
+            } else {
+                assertUtil.test("MockLogger setLogLevel: " + logLevel);
+            }
+
+            // check if files are read in constructor
+            checkReadFiles(readActivityState, readAttribution);
+
+            InternalState internalState = activityHandler.getInternalState();
+            // test default values
+            assertUtil.isEqual(startEnabled, internalState.isEnabled());
+            assertUtil.isTrue(internalState.isOnline());
+            assertUtil.isTrue(internalState.isBackground());
         }
 
         return activityHandler;
     }
+
+    private ActivityHandler startAndCheckFirstSession(AdjustConfig config) {
+        return startAndCheckFirstSession(config, LogLevel.INFO);
+    }
+
+    private ActivityHandler startAndCheckFirstSession(AdjustConfig config, LogLevel logLevel) {
+        // start activity handler with config
+        ActivityHandler activityHandler = getFirstActivityHandler(config, logLevel);
+
+        SystemClock.sleep(2000);
+
+        // test init values
+        checkInitTests();
+
+        startActivity(activityHandler);
+
+        SystemClock.sleep(2000);
+
+        // test session
+        checkFirstSession();
+
+        return activityHandler;
+    }
+
+    private void startActivity(ActivityHandler activityHandler) {
+        // start activity
+        activityHandler.onResume();
+
+        InternalState internalState = activityHandler.getInternalState();
+
+        // comes to the foreground
+        assertUtil.isTrue(internalState.isForeground());
+    }
+
+    private void checkOnResume(SessionState sessionState) {
+        // stops background timer
+        assertUtil.verbose("Background timer canceled");
+
+        // start foreground timer
+        if (sessionState.foregroundTimerStarts) {
+            if (sessionState.foregroundTimerAlreadyStarted) {
+                assertUtil.verbose("Foreground timer is already started");
+            } else {
+                assertUtil.verbose("Foreground timer starting");
+            }
+        } else {
+            assertUtil.notInVerbose("Foreground timer is already started");
+            assertUtil.notInVerbose("Foreground timer starting");
+        }
+
+        // starts the subsession
+        assertUtil.verbose("Subsession start");
+    }
+
+    private void stopActivity(ActivityHandler activityHandler) {
+        // stop activity
+        activityHandler.onPause();
+
+        InternalState internalState = activityHandler.getInternalState();
+
+        // goes to the background
+        assertUtil.isTrue(internalState.isBackground());
+
+    }
+
+    private void checkOnPause(boolean forgroundAlreadySuspended,
+                              boolean backgroundTimerStarts) {
+        // stop foreground timer
+        if (forgroundAlreadySuspended) {
+            assertUtil.verbose("Foreground timer is already suspended");
+        } else {
+            assertUtil.verbose("Foreground timer suspended");
+        }
+
+        // start background timer
+        if (backgroundTimerStarts) {
+            assertUtil.verbose("Background timer starting.");
+        } else {
+            assertUtil.notInVerbose("Background timer starting.");
+        }
+
+        // starts the subsession
+        assertUtil.verbose("Subsession end");
+
+    }
+
+    private void checkReadFiles(String readActivityState, String readAttribution) {
+        if (readAttribution == null) {
+            //  test that the attribution file did not exist in the first run of the application
+            assertUtil.debug("Attribution file not found");
+        } else {
+            assertUtil.debug("Read Attribution: " + readAttribution);
+        }
+
+        if (readActivityState == null) {
+            //  test that the activity state file did not exist in the first run of the application
+            assertUtil.debug("Activity state file not found");
+        } else {
+            assertUtil.debug("Read Activity state: " + readActivityState);
+        }
+    }
+
+    private void checkHandlerStatus(Boolean pausing) {
+        checkHandlerStatus(pausing, false);
+    }
+
+
+    private void checkHandlerStatus(Boolean pausing, boolean eventBufferingEnabled) {
+        if (pausing == null) {
+            assertUtil.notInTest("AttributionHandler pauseSending");
+            assertUtil.notInTest("PackageHandler pauseSending");
+            assertUtil.notInTest("SdkClickHandler pauseSending");
+            assertUtil.notInTest("AttributionHandler resumeSending");
+            assertUtil.notInTest("PackageHandler resumeSending");
+            assertUtil.notInTest("SdkClickHandler resumeSending");
+            return;
+        }
+        if (pausing) {
+            assertUtil.test("AttributionHandler pauseSending");
+            assertUtil.test("PackageHandler pauseSending");
+            assertUtil.test("SdkClickHandler pauseSending");
+        } else {
+            assertUtil.test("AttributionHandler resumeSending");
+            assertUtil.test("PackageHandler resumeSending");
+            assertUtil.test("SdkClickHandler resumeSending");
+            if (!eventBufferingEnabled) {
+                assertUtil.test("PackageHandler sendFirstPackage");
+            }
+        }
+    }
 }
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java
index 464e08434..fd0f12518 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java
@@ -24,6 +24,7 @@ public class TestActivityPackage {
     public Boolean deviceKnow;
     public boolean needsResponseDetails;
     public boolean playServices;
+    public boolean eventBufferingEnabled;
     // session
     public Integer sessionCount;
     public String defaultTracker;
@@ -38,9 +39,10 @@ public class TestActivityPackage {
     public String partnerParams;
     // click
     public String reftag;
-    public String deepLinkParameters;
+    public String otherParameters;
     public AdjustAttribution attribution;
     public String referrer;
+    public String deeplink;
 
     public TestActivityPackage(ActivityPackage activityPackage) {
         this.activityPackage = activityPackage;
@@ -52,6 +54,7 @@ public TestActivityPackage(ActivityPackage activityPackage) {
         clientSdk = "android4.6.0";
         suffix = "";
         attribution = new AdjustAttribution();
+        playServices = true;
     }
 
     public void testSessionPackage(int sessionCount) {
@@ -129,12 +132,16 @@ public void testClickPackage(String source) {
 
         if (source == Constants.REFTAG) {
             assertParameterEquals("referrer", referrer);
-        } else {
+            assertParameterNull("deeplink");
+        } else if (source == Constants.DEEPLINK) {
+            assertParameterEquals("deeplink", deeplink);
             assertParameterNull("referrer");
+        } else {
+            assertFail();
         }
 
         // params
-        assertJsonParameterEquals("params", deepLinkParameters);
+        assertJsonParameterEquals("params", otherParameters);
 
         // click_time
         // TODO add string click time to compare
@@ -160,6 +167,41 @@ public void testAttributionPackage() {
         testDeviceIdsParameters();
     }
 
+    public static void testQueryStringRequest(String queryStringRequest, Integer queueSize) {
+        String[] queryPairs = queryStringRequest.split("&");
+        boolean wasSentAtFound = false;
+        boolean wasQueueSizeFound = false;
+        int queueSizeFound = -1;
+
+        for (String pair : queryPairs) {
+            String[] pairComponents = pair.split("=");
+            String key = pairComponents[0];
+            String value = pairComponents[1];
+            if (key.equals("sent_at")) {
+                wasSentAtFound = true;
+            }
+            if (key.equals("queue_size")) {
+                wasQueueSizeFound = true;
+                queueSizeFound = Integer.parseInt(value);
+            }
+        }
+        if (!wasSentAtFound) {
+            Assert.fail(queryStringRequest);
+        }
+
+        if (queueSize == null) {
+            Assert.assertFalse(queryStringRequest, wasQueueSizeFound);
+            return;
+        }
+
+        if (!wasQueueSizeFound) {
+            Assert.fail(queryStringRequest);
+        } else {
+            Assert.assertEquals(queryStringRequest,
+                    queueSize.intValue(), queueSizeFound);
+        }
+    }
+
     private void testDefaultAttributes(String path, ActivityKind activityKind, String activityKindString) {
         // check the Sdk version is being tested
         assertEquals(activityPackage.getClientSdk(), clientSdk);
@@ -225,6 +267,10 @@ private void testDeviceInfo() {
         assertParameterNotNull("display_width");
         // display_height
         assertParameterNotNull("display_height");
+        // hardware_name
+        assertParameterNotNull("hardware_name");
+        // cpu_type
+        assertParameterNotNull("cpu_type");
     }
 
     private void testDeviceInfoIds() {
@@ -267,6 +313,7 @@ private void testConfig() {
             // tracking_enabled
             assertParameterNull("tracking_enabled");
         }
+        testParameterBoolean("event_buffering_enabled", eventBufferingEnabled);
     }
 
     private void testActivityState() {
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestAttributionHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestAttributionHandler.java
index b906ea7be..3373c9b90 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestAttributionHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestAttributionHandler.java
@@ -47,7 +47,7 @@ protected void setUp() throws Exception {
 
         AdjustFactory.setLogger(mockLogger);
         AdjustFactory.setActivityHandler(mockActivityHandler);
-        AdjustFactory.setMockHttpsURLConnection(mockHttpsURLConnection);
+        AdjustFactory.setHttpsURLConnection(mockHttpsURLConnection);
 
         activity = getActivity();
         context = activity.getApplicationContext();
@@ -75,7 +75,7 @@ private void savePackages() {
         ActivityHandler activityHandler = ActivityHandler.getInstance(config);
 
         if (activityHandler != null) {
-            activityHandler.trackSubsessionStart();
+            activityHandler.onResume();
         }
 
         SystemClock.sleep(3000);
@@ -95,7 +95,7 @@ private void savePackages() {
     protected void tearDown() throws Exception {
         super.tearDown();
 
-        AdjustFactory.setMockHttpsURLConnection(null);
+        AdjustFactory.setHttpsURLConnection(null);
         AdjustFactory.setActivityHandler(null);
         AdjustFactory.setLogger(null);
 
@@ -108,7 +108,7 @@ public void testGetAttribution() {
         mockLogger.Assert("TestAttributionHandler testGetAttribution");
 
         AttributionHandler attributionHandler = new AttributionHandler(mockActivityHandler,
-                attributionPackage, false, true);
+                attributionPackage, true, true);
 
         // test null client
         nullClientTest(attributionHandler);
@@ -127,7 +127,6 @@ public void testGetAttribution() {
 
         // test ok response with message
         okMessageTest(attributionHandler);
-
     }
 
     public void testCheckSessionResponse() {
@@ -135,7 +134,7 @@ public void testCheckSessionResponse() {
         mockLogger.Assert("TestAttributionHandler testCheckSessionResponse");
 
         AttributionHandler attributionHandler = new AttributionHandler(mockActivityHandler,
-                attributionPackage, false, true);
+                attributionPackage, true, true);
 
         // new attribution
         JSONObject attributionJson = null;
@@ -177,7 +176,7 @@ public void testAskIn() {
         mockLogger.Assert("TestAttributionHandler testAskIn");
 
         AttributionHandler attributionHandler = new AttributionHandler(mockActivityHandler,
-                attributionPackage, false, true);
+                attributionPackage, true, true);
 
         String response = "Response: { \"ask_in\" : 4000 }";
 
@@ -208,7 +207,7 @@ public void testAskIn() {
         assertUtil.test("ActivityHandler setAskingAttribution, true");
 
         // and waited to for query
-        assertUtil.debug("Waiting to query attribution in 4000 milliseconds");
+        assertUtil.debug("Waiting to query attribution in 4.0 seconds");
 
         SystemClock.sleep(2000);
 
@@ -229,7 +228,7 @@ public void testAskIn() {
         assertUtil.test("ActivityHandler setAskingAttribution, true");
 
         // and waited to for query
-        assertUtil.debug("Waiting to query attribution in 5000 milliseconds");
+        assertUtil.debug("Waiting to query attribution in 5.0 seconds");
 
         // it was been waiting for 1000 + 2000 + 3000 = 6 seconds
         // check that the mock http client was not called because the original clock was reseted
@@ -238,7 +237,7 @@ public void testAskIn() {
         // check that it was finally called after 6 seconds after the second ask_in
         SystemClock.sleep(4000);
 
-        okMessageTestLogs();
+        okMessageTestLogs(attributionHandler);
 
         //requestTest(mockHttpClient.lastRequest);
     }
@@ -248,7 +247,7 @@ public void testPause() {
         mockLogger.Assert("TestAttributionHandler testPause");
 
         AttributionHandler attributionHandler = new AttributionHandler(mockActivityHandler,
-                attributionPackage, true, true);
+                attributionPackage, false, true);
 
         mockHttpsURLConnection.responseType = ResponseType.MESSAGE;
 
@@ -270,7 +269,7 @@ public void testWithoutListener() {
         mockLogger.Assert("TestAttributionHandler testPause");
 
         AttributionHandler attributionHandler = new AttributionHandler(mockActivityHandler,
-                attributionPackage, false, false);
+                attributionPackage, true, false);
 
         mockHttpsURLConnection.responseType = ResponseType.MESSAGE;
 
@@ -349,10 +348,12 @@ private void serverErrorTest(AttributionHandler attributionHandler) {
     private void okMessageTest(AttributionHandler attributionHandler) {
         startGetAttributionTest(attributionHandler, ResponseType.MESSAGE);
 
-        okMessageTestLogs();
+        okMessageTestLogs(attributionHandler);
     }
 
-    private void okMessageTestLogs() {
+    private void okMessageTestLogs(AttributionHandler attributionHandler) {
+        TestActivityPackage.testQueryStringRequest(attributionHandler.lastUrlUsed.getQuery(), null);
+
         // check that the mock http client was called
         assertUtil.test("MockHttpsURLConnection getInputStream");
 
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestPackageHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestPackageHandler.java
index c7f805eed..f8963aae0 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestPackageHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestPackageHandler.java
@@ -7,10 +7,15 @@
 import com.adjust.sdk.ActivityKind;
 import com.adjust.sdk.ActivityPackage;
 import com.adjust.sdk.AdjustFactory;
+import com.adjust.sdk.BackoffStrategy;
+import com.adjust.sdk.Constants;
 import com.adjust.sdk.PackageHandler;
 import com.adjust.sdk.ResponseData;
 import com.adjust.sdk.UnknownResponseData;
 
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
 /**
  * Created by pfms on 30/01/15.
  */
@@ -83,19 +88,22 @@ public void testAddPackage() {
         secondPackageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        assertUtil.test("RequestHandler sendPackage, clickFirstPackage");
+        assertUtil.test("RequestHandler sendPackage, activityPackage clickFirstPackage");
+        assertUtil.test("RequestHandler sendPackage, queueSize 2");
 
         // send the second click package/ third package
         secondPackageHandler.sendNextPackage(null);
         SystemClock.sleep(1000);
 
-        assertUtil.test("RequestHandler sendPackage, clickThirdPackage");
+        assertUtil.test("RequestHandler sendPackage, activityPackage unknownSecondPackage");
+        assertUtil.test("RequestHandler sendPackage, queueSize 1");
 
         // send the unknow package/ second package
         secondPackageHandler.sendNextPackage(null);
         SystemClock.sleep(1000);
 
-        assertUtil.test("RequestHandler sendPackage, unknownSecondPackage");
+        assertUtil.test("RequestHandler sendPackage, activityPackage clickThirdPackage");
+        assertUtil.test("RequestHandler sendPackage, queueSize 0");
     }
 
     public void testSendFirst() {
@@ -107,7 +115,7 @@ public void testSendFirst() {
         packageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        sendFirstTests(SendFirstState.EMPTY_QUEUE, null);
+        sendFirstTests(SendFirstState.EMPTY_QUEUE, null, null);
 
         addAndSendFirstPackageTest(packageHandler);
 
@@ -115,30 +123,30 @@ public void testSendFirst() {
         packageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        sendFirstTests(SendFirstState.IS_SENDING, null);
+        sendFirstTests(SendFirstState.IS_SENDING, null, null);
 
         // try to send paused
         packageHandler.pauseSending();
         packageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        sendFirstTests(SendFirstState.PAUSED, null);
+        sendFirstTests(SendFirstState.PAUSED, null, null);
 
         // unpause, it's still sending
         packageHandler.resumeSending();
         packageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        sendFirstTests(SendFirstState.IS_SENDING, null);
+        sendFirstTests(SendFirstState.IS_SENDING, null, null);
 
         // verify that both paused and isSending are reset with a new session
-        PackageHandler secondSessionPackageHandler = new PackageHandler(mockActivityHandler, context, false);
+        PackageHandler secondSessionPackageHandler = new PackageHandler(mockActivityHandler, context, true);
 
         secondSessionPackageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
         // send the package to request handler
-        sendFirstTests(SendFirstState.SEND, "unknownFirstPackage");
+        sendFirstTests(SendFirstState.SEND, "unknownFirstPackage", 0);
     }
 
     public void testSendNext() {
@@ -155,7 +163,7 @@ public void testSendNext() {
         packageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        sendFirstTests(SendFirstState.IS_SENDING, null);
+        sendFirstTests(SendFirstState.IS_SENDING, null, null);
 
         // add a second package
         addSecondPackageTest(packageHandler);
@@ -167,12 +175,13 @@ public void testSendNext() {
         assertUtil.debug("Package handler wrote 1 packages");
 
         // try to send the second package
-        sendFirstTests(SendFirstState.SEND, "unknownSecondPackage");
+        sendFirstTests(SendFirstState.SEND, "unknownSecondPackage", 0);
     }
 
     public void testCloseFirstPackage() {
         // assert test name to read better in logcat
         mockLogger.Assert("TestPackageHandler testCloseFirstPackage");
+        AdjustFactory.setPackageHandlerBackoffStrategy(BackoffStrategy.NO_WAIT);
 
         PackageHandler packageHandler = startPackageHandler();
 
@@ -182,39 +191,138 @@ public void testCloseFirstPackage() {
         packageHandler.sendFirstPackage();
         SystemClock.sleep(1000);
 
-        sendFirstTests(SendFirstState.IS_SENDING, null);
+        sendFirstTests(SendFirstState.IS_SENDING, null, null);
 
         //send next package
         ActivityPackage activityPackage = new ActivityPackage(ActivityKind.UNKNOWN);
         UnknownResponseData unknownResponseData = (UnknownResponseData) ResponseData.buildResponseData(activityPackage);
-        packageHandler.closeFirstPackage(unknownResponseData);
+        packageHandler.closeFirstPackage(unknownResponseData, null);
         SystemClock.sleep(2000);
+        assertUtil.verbose("Package handler can send");
+        assertUtil.test("ActivityHandler finishedTrackingActivity, message:null timestamp:null json:null");
 
         assertUtil.notInDebug("Package handler wrote");
 
-        packageHandler.sendFirstPackage();
-        SystemClock.sleep(2000);
+        // tries to send the next package after sleeping
+        sendFirstTests(SendFirstState.SEND, "unknownFirstPackage", 0);
+    }
+
+    public void testBackoffJitter() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestPackageHandler testBackoffJitter");
+
+        AdjustFactory.setPackageHandlerBackoffStrategy(BackoffStrategy.TEST_WAIT);
+
+        PackageHandler packageHandler = startPackageHandler();
+
+        ActivityPackage activityPackage = new ActivityPackage(ActivityKind.UNKNOWN);
+        UnknownResponseData unknownResponseData = (UnknownResponseData) ResponseData.buildResponseData(activityPackage);
+        Pattern pattern = Pattern.compile("Sleeping for (\\d+\\.\\d) seconds before retrying the (\\d+) time");
+
+        // 1st
+        packageHandler.closeFirstPackage(unknownResponseData, activityPackage);
+        SystemClock.sleep(1500);
+
+        String matchingString = assertUtil.verbose("Sleeping for ");
+        // Sleeping for 0.1 seconds before retrying the 1 time
+
+        checkSleeping(pattern, matchingString, 0.1, 0.2, 1, 0.5, 1);
+
+        // 2nd
+        packageHandler.closeFirstPackage(unknownResponseData, activityPackage);
+        SystemClock.sleep(1500);
+
+        matchingString = assertUtil.verbose("Sleeping for ");
+
+        checkSleeping(pattern, matchingString, 0.2, 0.4, 1, 0.5, 2);
+
+        // 3rd
+        packageHandler.closeFirstPackage(unknownResponseData, activityPackage);
+        SystemClock.sleep(1500);
+
+        matchingString = assertUtil.verbose("Sleeping for ");
+
+        checkSleeping(pattern, matchingString, 0.4, 0.8, 1, 0.5, 3);
+
+        // 4th
+        packageHandler.closeFirstPackage(unknownResponseData, activityPackage);
+        SystemClock.sleep(1500);
+
+        matchingString = assertUtil.verbose("Sleeping for ");
+
+        checkSleeping(pattern, matchingString, 0.8, 1.6, 1, 0.5, 4);
+
+        // 5th
+        packageHandler.closeFirstPackage(unknownResponseData, activityPackage);
+        SystemClock.sleep(1500);
+
+        matchingString = assertUtil.verbose("Sleeping for ");
+
+        checkSleeping(pattern, matchingString, 1.6, 3.2, 1, 0.5, 5);
+
+        // 6th
+        packageHandler.closeFirstPackage(unknownResponseData, activityPackage);
+        SystemClock.sleep(1500);
+
+        matchingString = assertUtil.verbose("Sleeping for ");
+
+        checkSleeping(pattern, matchingString, 6.4, 12.8, 1, 0.5, 6);
+   }
+
+    private void checkSleeping(Pattern pattern,
+                               String sleepingLog,
+                               double minRange,
+                               double maxRange,
+                               long maxCeiling,
+                               double minCeiling,
+                               int numberRetries)
+    {
+        Matcher matcher = pattern.matcher(sleepingLog);
+
+        if (!matcher.matches()) {
+            assertUtil.fail();
+        }
+        Double sleepingTime = Double.valueOf(matcher.group(1));
+
+        boolean failsCeiling = sleepingTime > maxCeiling;
+        assertUtil.isFalse(failsCeiling);
+
+        if (maxRange < maxCeiling) {
+            boolean failsMinRange = sleepingTime < minRange;
+            assertUtil.isFalse(failsMinRange);
+        } else {
+            boolean failsMinRange = sleepingTime < minCeiling ;
+            assertUtil.isFalse(failsMinRange);
+        }
+
+        if (maxRange < maxCeiling) {
+            boolean failsMaxRange = sleepingTime > maxRange;
+            assertUtil.isFalse(failsMaxRange);
+        } else {
+            boolean failsMaxRange = sleepingTime > maxCeiling;
+            assertUtil.isFalse(failsMaxRange);
+        }
 
-        // try to send the first package again
-        sendFirstTests(SendFirstState.SEND, "unknownFirstPackage");
+        Integer retryTime = Integer.valueOf(matcher.group(2));
+        assertUtil.isEqual(numberRetries, retryTime);
     }
 
     private PackageHandler startPackageHandler() {
         // delete package queue for fresh start
         deletePackageQueue();
 
-        PackageHandler packageHandler = new PackageHandler(mockActivityHandler, context, false);
+        PackageHandler packageHandler = new PackageHandler(mockActivityHandler, context, true);
 
         SystemClock.sleep(1000);
 
-        assertUtil.verbose("Package queue file not found");
+        assertUtil.debug("Package queue file not found");
 
         return packageHandler;
     }
 
     private PackageHandler addSecondPackageTest(PackageHandler packageHandler) {
         if (packageHandler == null) {
-            packageHandler = new PackageHandler(mockActivityHandler, context, false);
+            packageHandler = new PackageHandler(mockActivityHandler, context, true);
 
             SystemClock.sleep(1000);
 
@@ -251,14 +359,14 @@ private void addAndSendFirstPackageTest(PackageHandler packageHandler) {
 
         addPackageTests(1, "unknownFirstPackage");
 
-        sendFirstTests(SendFirstState.SEND, "unknownFirstPackage");
+        sendFirstTests(SendFirstState.SEND, "unknownFirstPackage", 0);
     }
 
     private enum SendFirstState {
         EMPTY_QUEUE, PAUSED, IS_SENDING, SEND
     }
 
-    private void sendFirstTests(SendFirstState sendFirstState, String packageString) {
+    private void sendFirstTests(SendFirstState sendFirstState, String packageString, Integer queueSize) {
         if (sendFirstState == SendFirstState.PAUSED) {
             assertUtil.debug("Package handler is paused");
         } else {
@@ -272,7 +380,8 @@ private void sendFirstTests(SendFirstState sendFirstState, String packageString)
         }
 
         if (sendFirstState == SendFirstState.SEND) {
-            assertUtil.test("RequestHandler sendPackage, " + packageString);
+            assertUtil.test("RequestHandler sendPackage, activityPackage " + packageString);
+            assertUtil.test("RequestHandler sendPackage, queueSize " + queueSize);
         } else {
             assertUtil.notInTest("RequestHandler sendPackage");
         }
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestRequestHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestRequestHandler.java
index 3ce918590..49fcbf3be 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestRequestHandler.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestRequestHandler.java
@@ -43,7 +43,7 @@ protected void setUp() throws Exception {
 
         AdjustFactory.setLogger(mockLogger);
         AdjustFactory.setPackageHandler(mockPackageHandler);
-        AdjustFactory.setMockHttpsURLConnection(mockHttpsURLConnection);
+        AdjustFactory.setHttpsURLConnection(mockHttpsURLConnection);
 
         activity = getActivity();
         context = activity.getApplicationContext();
@@ -55,7 +55,7 @@ protected void setUp() throws Exception {
     protected void tearDown() throws Exception {
         super.tearDown();
 
-        AdjustFactory.setMockHttpsURLConnection(null);
+        AdjustFactory.setHttpsURLConnection(null);
         AdjustFactory.setPackageHandler(null);
         AdjustFactory.setLogger(null);
     }
@@ -101,14 +101,14 @@ public void testTimeout() {
     private void nullResponseTest() {
         mockHttpsURLConnection.responseType = null;
 
-        requestHandler.sendPackage(sessionPackage);
+        requestHandler.sendPackage(sessionPackage, -1);
         SystemClock.sleep(1000);
 
         assertUtil.test("MockHttpsURLConnection getInputStream, responseType: null");
 
-        assertUtil.error("Failed to read response. (lock == null)");
+        assertUtil.error("Failed to read response. (null)");
 
-        assertUtil.error("Failed to track session. (Runtime exception: java.lang.NullPointerException: lock == null)");
+        assertUtil.error("Failed to track session. (Runtime exception: java.lang.NullPointerException)");
 
         assertUtil.test("PackageHandler sendNextPackage");
     }
@@ -116,7 +116,7 @@ private void nullResponseTest() {
     private void clientExceptionTest() {
         mockHttpsURLConnection.responseType = ResponseType.CLIENT_PROTOCOL_EXCEPTION;
 
-        requestHandler.sendPackage(sessionPackage);
+        requestHandler.sendPackage(sessionPackage, -1);
         SystemClock.sleep(1000);
 
         assertUtil.test("MockHttpsURLConnection getInputStream, responseType: CLIENT_PROTOCOL_EXCEPTION");
@@ -129,7 +129,7 @@ private void clientExceptionTest() {
     private void serverErrorTest() {
         mockHttpsURLConnection.responseType = ResponseType.INTERNAL_SERVER_ERROR;
 
-        requestHandler.sendPackage(sessionPackage);
+        requestHandler.sendPackage(sessionPackage, -1);
         SystemClock.sleep(1000);
 
         assertUtil.test("MockHttpsURLConnection getErrorStream, responseType: INTERNAL_SERVER_ERROR");
@@ -144,7 +144,7 @@ private void serverErrorTest() {
     private void wrongJsonTest() {
         mockHttpsURLConnection.responseType = ResponseType.WRONG_JSON;
 
-        requestHandler.sendPackage(sessionPackage);
+        requestHandler.sendPackage(sessionPackage, -1);
         SystemClock.sleep(1000);
 
         assertUtil.test("MockHttpsURLConnection getInputStream, responseType: WRONG_JSON");
@@ -159,7 +159,7 @@ private void wrongJsonTest() {
     private void emptyJsonTest() {
         mockHttpsURLConnection.responseType = ResponseType.EMPTY_JSON;
 
-        requestHandler.sendPackage(sessionPackage);
+        requestHandler.sendPackage(sessionPackage, -1);
         SystemClock.sleep(1000);
 
         assertUtil.test("MockHttpsURLConnection getInputStream, responseType: EMPTY_JSON");
@@ -174,10 +174,10 @@ private void emptyJsonTest() {
     private void messageTest() {
         mockHttpsURLConnection.responseType = ResponseType.MESSAGE;
 
-        requestHandler.sendPackage(sessionPackage);
+        requestHandler.sendPackage(sessionPackage, 1);
         SystemClock.sleep(1000);
 
-        mockLogger.test(mockHttpsURLConnection.readRequest());
+        TestActivityPackage.testQueryStringRequest(mockHttpsURLConnection.readRequest(), 1);
 
         assertUtil.test("MockHttpsURLConnection getInputStream, responseType: MESSAGE");
 
@@ -190,8 +190,10 @@ private void messageTest() {
 
     private ActivityPackage getSessionPackage() {
         MockAttributionHandler mockAttributionHandler = new MockAttributionHandler(mockLogger);
+        MockSdkClickHandler mockSdkClickHandler = new MockSdkClickHandler(mockLogger);
 
         AdjustFactory.setAttributionHandler(mockAttributionHandler);
+        AdjustFactory.setSdkClickHandler(mockSdkClickHandler);
 
         // deleting the activity state file to simulate a first session
         boolean activityStateDeleted = ActivityHandler.deleteActivityState(context);
@@ -207,7 +209,7 @@ private ActivityPackage getSessionPackage() {
 
         // start activity handler with config
         ActivityHandler activityHandler = ActivityHandler.getInstance(config);
-        activityHandler.trackSubsessionStart();
+        activityHandler.onResume();
         SystemClock.sleep(3000);
 
         ActivityPackage sessionPackage = mockPackageHandler.queue.get(0);
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestSdkClickHandler.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestSdkClickHandler.java
new file mode 100644
index 000000000..a95f938c2
--- /dev/null
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestSdkClickHandler.java
@@ -0,0 +1,318 @@
+package com.adjust.sdk.test;
+
+import android.content.Context;
+import android.net.Uri;
+import android.os.SystemClock;
+import android.test.ActivityInstrumentationTestCase2;
+
+import com.adjust.sdk.ActivityHandler;
+import com.adjust.sdk.ActivityPackage;
+import com.adjust.sdk.AdjustConfig;
+import com.adjust.sdk.AdjustFactory;
+import com.adjust.sdk.BackoffStrategy;
+import com.adjust.sdk.SdkClickHandler;
+
+/**
+ * Created by pfms on 14/04/16.
+ */
+public class TestSdkClickHandler extends ActivityInstrumentationTestCase2<UnitTestActivity> {
+    private MockLogger mockLogger;
+    private AssertUtil assertUtil;
+    private MockHttpsURLConnection mockHttpsURLConnection;
+    private UnitTestActivity activity;
+    private Context context;
+    private ActivityPackage sdkClickPackage;
+
+    public TestSdkClickHandler() {
+        super(UnitTestActivity.class);
+    }
+
+    public TestSdkClickHandler(Class<UnitTestActivity> activityClass) {
+        super(activityClass);
+    }
+
+    @Override
+    protected void setUp() throws Exception {
+        super.setUp();
+        mockLogger = new MockLogger();
+        mockHttpsURLConnection = new MockHttpsURLConnection(null, mockLogger);
+
+        assertUtil = new AssertUtil(mockLogger);
+
+        AdjustFactory.setLogger(mockLogger);
+        AdjustFactory.setHttpsURLConnection(mockHttpsURLConnection);
+
+        activity = getActivity();
+        context = activity.getApplicationContext();
+        sdkClickPackage = getClickPackage();
+    }
+
+    @Override
+    protected void tearDown() throws Exception {
+        super.tearDown();
+
+        AdjustFactory.setHttpsURLConnection(null);
+        AdjustFactory.setLogger(null);
+    }
+
+    private ActivityPackage getClickPackage() {
+        MockSdkClickHandler mockSdkClickHandler = new MockSdkClickHandler(mockLogger);
+        MockAttributionHandler mockAttributionHandler = new MockAttributionHandler(mockLogger);
+        MockPackageHandler mockPackageHandler = new MockPackageHandler(mockLogger);
+
+        AdjustFactory.setPackageHandler(mockPackageHandler);
+        AdjustFactory.setSdkClickHandler(mockSdkClickHandler);
+        AdjustFactory.setAttributionHandler(mockAttributionHandler);
+
+        // create the config to start the session
+        AdjustConfig config = new AdjustConfig(context, "123456789012", AdjustConfig.ENVIRONMENT_SANDBOX);
+
+        // start activity handler with config
+        ActivityHandler activityHandler = ActivityHandler.getInstance(config);
+        activityHandler.onResume();
+        activityHandler.readOpenUrl(Uri.parse("AdjustTests://"), System.currentTimeMillis());
+        SystemClock.sleep(2000);
+
+        ActivityPackage sdkClickPackage = mockSdkClickHandler.queue.get(0);
+        mockLogger.reset();
+
+        return sdkClickPackage;
+    }
+
+    public void testPaused() {
+        sdkClickPackage.setClientSdk("Test-First-Click");
+        ActivityPackage secondSdkClickPackage = getClickPackage();
+        secondSdkClickPackage.setClientSdk("Test-Second-Click");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testPaused");
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(false);
+
+        mockHttpsURLConnection.responseType = ResponseType.CLIENT_PROTOCOL_EXCEPTION;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+        SystemClock.sleep(1000);
+
+        // added first click package to the queue
+        assertUtil.debug("Added sdk_click 1");
+
+        assertUtil.verbose("Path:      /sdk_click\n" +
+                "ClientSdk: Test-First-Click");
+
+        // but not send because it's paused
+        assertUtil.notInTest("MockHttpsURLConnection getInputStream");
+
+        // send second sdk click
+        sdkClickHandler.sendSdkClick(secondSdkClickPackage);
+        SystemClock.sleep(1000);
+
+        // added second click package to the queue
+        assertUtil.debug("Added sdk_click 2");
+
+        assertUtil.verbose("Path:      /sdk_click\n" +
+                "ClientSdk: Test-Second-Click");
+
+        // wait two seconds before sending
+        mockHttpsURLConnection.waitingTime = 2000L;
+
+        // try to send first package
+        checkSendFirstPackage(sdkClickHandler, 1);
+        // and then the second
+        checkSendSecondPackage(sdkClickHandler, 1);
+
+        // try to send first package again
+        checkSendFirstPackage(sdkClickHandler, 2);
+        // and then the second again
+        checkSendSecondPackage(sdkClickHandler, 2);
+    }
+
+    private void checkSendFirstPackage(SdkClickHandler sdkClickHandler, int retries) {
+        // try to send the first package
+        sdkClickHandler.resumeSending();
+
+        SystemClock.sleep(1000);
+
+        // prevent sending next again
+        sdkClickHandler.pauseSending();
+
+        SystemClock.sleep(2000);
+
+        // check that it tried to send the first package
+        assertUtil.test("MockHttpsURLConnection setRequestProperty, field Client-SDK, newValue Test-First-Click");
+
+        // and that it will try to send it again
+        assertUtil.error("Retrying sdk_click package for the " + retries + " time");
+
+        // first package added again on the end of the queue
+        assertUtil.debug("Added sdk_click 2");
+
+        assertUtil.verbose("Path:      /sdk_click\n" +
+                "ClientSdk: Test-First-Click");
+
+        // does not continue to send because it was paused
+        assertUtil.notInTest("MockHttpsURLConnection setRequestProperty");
+    }
+
+    private void checkSendSecondPackage(SdkClickHandler sdkClickHandler, int retries) {
+        // try to send the second package that is at the start of the queue
+        sdkClickHandler.resumeSending();
+
+        SystemClock.sleep(1000);
+
+        // prevent sending next again
+        sdkClickHandler.pauseSending();
+
+        SystemClock.sleep(2000);
+
+        // check that it tried to send the second package
+        assertUtil.test("MockHttpsURLConnection setRequestProperty, field Client-SDK, newValue Test-Second-Click");
+
+        // and that it will try to send it again
+        assertUtil.error("Retrying sdk_click package for the " + retries + " time");
+
+        // second package added again on the end of the queue
+        assertUtil.debug("Added sdk_click 2");
+
+        assertUtil.verbose("Path:      /sdk_click\n" +
+                "ClientSdk: Test-Second-Click");
+
+        // does not continue to send because it was paused
+        assertUtil.notInTest("MockHttpsURLConnection setRequestProperty");
+    }
+
+    public void testNullResponse() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testNullResponse");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(true);
+
+        mockHttpsURLConnection.responseType = null;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+
+        SystemClock.sleep(1000);
+
+        assertUtil.debug("Added sdk_click 1");
+
+        assertUtil.test("MockHttpsURLConnection getInputStream, responseType: null");
+
+        assertUtil.error("Failed to read response. (null)");
+
+        assertUtil.error("Failed to track click. (Sdk_click runtime exception: java.lang.NullPointerException)");
+
+        // does not to try to retry
+        assertUtil.notInError("Retrying sdk_click package for the");
+        assertUtil.notInDebug("Added sdk_click");
+    }
+
+    public void testClientException() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testClientException");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(true);
+
+        mockHttpsURLConnection.responseType = ResponseType.CLIENT_PROTOCOL_EXCEPTION;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+        SystemClock.sleep(1000);
+
+        assertUtil.test("MockHttpsURLConnection getInputStream, responseType: CLIENT_PROTOCOL_EXCEPTION");
+
+        assertUtil.error("Failed to track click. (Sdk_click request failed. Will retry later: java.io.IOException: testResponseError)");
+
+        // tries to retry
+        assertUtil.error("Retrying sdk_click package for the 1 time");
+
+        // adds to end of the queue
+        assertUtil.debug("Added sdk_click");
+    }
+
+    public void testServerError() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testServerError");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(true);
+
+        mockHttpsURLConnection.responseType = ResponseType.INTERNAL_SERVER_ERROR;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+        SystemClock.sleep(1000);
+
+        assertUtil.test("MockHttpsURLConnection getErrorStream, responseType: INTERNAL_SERVER_ERROR");
+
+        assertUtil.verbose("Response: { \"message\": \"testResponseError\"}");
+
+        assertUtil.error("testResponseError");
+    }
+
+    public void testWrongJson() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testWrongJson");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(true);
+
+        mockHttpsURLConnection.responseType = ResponseType.WRONG_JSON;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+        SystemClock.sleep(1000);
+
+        assertUtil.test("MockHttpsURLConnection getInputStream, responseType: WRONG_JSON");
+
+        assertUtil.verbose("Response: not a json response");
+
+        assertUtil.error("Failed to parse json response. (Value not of type java.lang.String cannot be converted to JSONObject)");
+    }
+
+    public void testEmptyJson() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testWrongJson");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(true);
+
+        mockHttpsURLConnection.responseType = ResponseType.EMPTY_JSON;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+        SystemClock.sleep(1000);
+
+        assertUtil.test("MockHttpsURLConnection getInputStream, responseType: EMPTY_JSON");
+
+        assertUtil.verbose("Response: { }");
+
+        assertUtil.info("No message found");
+    }
+
+    public void testMessage() {
+        // assert test name to read better in logcat
+        mockLogger.Assert("TestRequestHandler testWrongJson");
+
+        AdjustFactory.setSdkClickBackoffStrategy(BackoffStrategy.NO_WAIT);
+
+        SdkClickHandler sdkClickHandler = new SdkClickHandler(true);
+
+        mockHttpsURLConnection.responseType = ResponseType.MESSAGE;
+
+        sdkClickHandler.sendSdkClick(sdkClickPackage);
+        SystemClock.sleep(1000);
+
+        TestActivityPackage.testQueryStringRequest(mockHttpsURLConnection.readRequest(), 0);
+
+        assertUtil.test("MockHttpsURLConnection getInputStream, responseType: MESSAGE");
+
+        assertUtil.verbose("Response: { \"message\" : \"response OK\"}");
+
+        assertUtil.info("response OK");
+    }
+}

From 4ac574c27f636705e7866088e4b4e12040fa2f1c Mon Sep 17 00:00:00 2001
From: Pedro <pedro@adeven.com>
Date: Tue, 3 May 2016 15:37:44 -0700
Subject: [PATCH 37/37] New version v4.7.0

---
 Adjust/adjust/build.gradle                                      | 2 +-
 Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java       | 2 +-
 Adjust/example/build.gradle                                     | 2 +-
 Adjust/pom.xml                                                  | 2 +-
 Adjust/pom_criteo.xml                                           | 2 +-
 Adjust/pom_sociomantic.xml                                      | 2 +-
 Adjust/pom_trademob.xml                                         | 2 +-
 .../java/com/adjust/sdk/test/TestActivityPackage.java           | 2 +-
 README.md                                                       | 2 +-
 VERSION                                                         | 2 +-
 doc/criteo_plugin.md                                            | 2 +-
 doc/migrate.md                                                  | 2 +-
 doc/sociomantic_plugin.md                                       | 2 +-
 doc/trademob_plugin.md                                          | 2 +-
 14 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/Adjust/adjust/build.gradle b/Adjust/adjust/build.gradle
index b9b97bc80..259caf9fa 100644
--- a/Adjust/adjust/build.gradle
+++ b/Adjust/adjust/build.gradle
@@ -8,7 +8,7 @@ android {
         minSdkVersion 9
         targetSdkVersion 23
         versionCode 1
-        versionName "4.6.0"
+        versionName "4.7.0"
     }
 }
 
diff --git a/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java b/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
index c2b67b3fc..70ee70a93 100644
--- a/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
+++ b/Adjust/adjust/src/main/java/com/adjust/sdk/Constants.java
@@ -29,7 +29,7 @@ public interface Constants {
     String BASE_URL = "https://app.adjust.com";
     String SCHEME = "https";
     String AUTHORITY = "app.adjust.com";
-    String CLIENT_SDK = "android4.6.0";
+    String CLIENT_SDK = "android4.7.0";
     String LOGTAG = "Adjust";
     String REFTAG = "reftag";
     String DEEPLINK = "deeplink";
diff --git a/Adjust/example/build.gradle b/Adjust/example/build.gradle
index d756773f9..a6cb74063 100644
--- a/Adjust/example/build.gradle
+++ b/Adjust/example/build.gradle
@@ -28,5 +28,5 @@ dependencies {
     // running mvn package
     //compile fileTree(dir: '../target', include: ['*.jar'])
     // using maven repository
-    //compile 'com.adjust.sdk:adjust-android:4.6.0'
+    //compile 'com.adjust.sdk:adjust-android:4.7.0'
 }
diff --git a/Adjust/pom.xml b/Adjust/pom.xml
index 1bb5f4b85..566f9e473 100644
--- a/Adjust/pom.xml
+++ b/Adjust/pom.xml
@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>adjust-android</artifactId>
     <groupId>com.adjust.sdk</groupId>
-    <version>4.6.0</version>
+    <version>4.7.0</version>
     <packaging>jar</packaging>
     <name>Adjust Android SDK</name>
     <url>https://github.com/adjust/android_sdk</url>
diff --git a/Adjust/pom_criteo.xml b/Adjust/pom_criteo.xml
index e48044130..b66f98c42 100644
--- a/Adjust/pom_criteo.xml
+++ b/Adjust/pom_criteo.xml
@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>adjust-android-criteo</artifactId>
     <groupId>com.adjust.sdk</groupId>
-    <version>4.6.0</version>
+    <version>4.7.0</version>
     <packaging>jar</packaging>
     <name>Adjust Android SDK</name>
     <url>https://github.com/adjust/android_sdk</url>
diff --git a/Adjust/pom_sociomantic.xml b/Adjust/pom_sociomantic.xml
index eb2fec5b3..39ff95238 100644
--- a/Adjust/pom_sociomantic.xml
+++ b/Adjust/pom_sociomantic.xml
@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>adjust-android-sociomantic</artifactId>
     <groupId>com.adjust.sdk</groupId>
-    <version>4.6.0</version>
+    <version>4.7.0</version>
     <packaging>jar</packaging>
     <name>Adjust Android SDK</name>
     <url>https://github.com/adjust/android_sdk</url>
diff --git a/Adjust/pom_trademob.xml b/Adjust/pom_trademob.xml
index ef56178e2..7546ca782 100644
--- a/Adjust/pom_trademob.xml
+++ b/Adjust/pom_trademob.xml
@@ -5,7 +5,7 @@
     <modelVersion>4.0.0</modelVersion>
     <artifactId>adjust-android-trademob</artifactId>
     <groupId>com.adjust.sdk</groupId>
-    <version>4.6.0</version>
+    <version>4.7.0</version>
     <packaging>jar</packaging>
     <name>Adjust Android SDK</name>
     <url>https://github.com/adjust/android_sdk</url>
diff --git a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java
index fd0f12518..25beb5e57 100644
--- a/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java
+++ b/Adjust/test/src/androidTest/java/com/adjust/sdk/test/TestActivityPackage.java
@@ -51,7 +51,7 @@ public TestActivityPackage(ActivityPackage activityPackage) {
         // default values
         appToken = "123456789012";
         environment = "sandbox";
-        clientSdk = "android4.6.0";
+        clientSdk = "android4.7.0";
         suffix = "";
         attribution = new AdjustAttribution();
         playServices = true;
diff --git a/README.md b/README.md
index 38c5c1191..872b1140b 100644
--- a/README.md
+++ b/README.md
@@ -52,7 +52,7 @@ compile project(":adjust")
 If you are using Maven, add this line instead:
 
 ```
-compile 'com.adjust.sdk:adjust-android:4.6.0'
+compile 'com.adjust.sdk:adjust-android:4.7.0'
 ```
 
 ### 4. Add Google Play Services
diff --git a/VERSION b/VERSION
index 6016e8add..f6cdf4098 100644
--- a/VERSION
+++ b/VERSION
@@ -1 +1 @@
-4.6.0
+4.7.0
diff --git a/doc/criteo_plugin.md b/doc/criteo_plugin.md
index 421977a8d..f8a6695c3 100644
--- a/doc/criteo_plugin.md
+++ b/doc/criteo_plugin.md
@@ -3,7 +3,7 @@
 Add the dependency of the adjust sdk with the Criteo plugin:
 
 ```
-compile 'com.adjust.sdk:adjust-android-criteo:4.6.0'
+compile 'com.adjust.sdk:adjust-android-criteo:4.7.0'
 ```
 
 Or integrate adjust with Criteo events by following these steps:
diff --git a/doc/migrate.md b/doc/migrate.md
index a0fe3a5a1..ea3ac952b 100644
--- a/doc/migrate.md
+++ b/doc/migrate.md
@@ -1,4 +1,4 @@
-## Migrate your adjust SDK for Android to 4.6.0 from 3.6.2
+## Migrate your adjust SDK for Android to 4.7.0 from 3.6.2
 
 ### The Application class
 
diff --git a/doc/sociomantic_plugin.md b/doc/sociomantic_plugin.md
index 249b5c2cc..f07506944 100644
--- a/doc/sociomantic_plugin.md
+++ b/doc/sociomantic_plugin.md
@@ -3,7 +3,7 @@
 Add the dependency of the adjust sdk with the Sociomantic plugin:
 
 ```
-compile 'com.adjust.sdk:adjust-android-sociomantic:4.6.0'
+compile 'com.adjust.sdk:adjust-android-sociomantic:4.7.0'
 ```
 
 Or integrate adjust with Sociomantic events by following these steps:
diff --git a/doc/trademob_plugin.md b/doc/trademob_plugin.md
index aad32dc03..6aa39d3e9 100644
--- a/doc/trademob_plugin.md
+++ b/doc/trademob_plugin.md
@@ -3,7 +3,7 @@
 Add the dependency of the adjust sdk with the Trademob plugin:
 
 ```
-compile 'com.adjust.sdk:adjust-android-trademob:4.6.0'
+compile 'com.adjust.sdk:adjust-android-trademob:4.7.0'
 ```
 
 Or integrate adjust with Trademob events by following these steps: